1 files changed, 67 insertions, 67 deletions
diff --git a/Tests/WmapParserTests/WmapParserTests.swift b/Tests/WmapParserTests/WmapParserTests.swift
index b141dc9..f5dfe38 100644
--- a/Tests/WmapParserTests/WmapParserTests.swift
+++ b/Tests/WmapParserTests/WmapParserTests.swift
@@ -8,73 +8,73 @@ import Testing
     Bucket (0.8, 0.4) [x]
     Water -> Bucket
     """
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 2)
   #expect(
     result.components.first
-      == Component(
-        label: "Water", coordinates: MapPoint(xCoordinate: 0.9, yCoordinate: 0.5), shape: .circle)
+      == WmapParser.Component(
+        label: "Water", coordinates: WmapParser.MapPoint(xCoordinate: 0.9, yCoordinate: 0.5), shape: .circle)
   )
   #expect(
     result.components[1]
-      == Component(
-        label: "Bucket", coordinates: MapPoint(xCoordinate: 0.8, yCoordinate: 0.4), shape: .xMark)
+      == WmapParser.Component(
+        label: "Bucket", coordinates: WmapParser.MapPoint(xCoordinate: 0.8, yCoordinate: 0.4), shape: .xMark)
   )
   #expect(result.dependencies.count == 1)
   #expect(
     result.dependencies.first
-      == Dependency(fromComponent: "Water", toComponent: "Bucket", isDirected: true)
+      == WmapParser.Dependency(fromComponent: "Water", toComponent: "Bucket", isDirected: true)
   )
 }
 
 @Test func shouldHandleUnixLineEndings() {
   let source = "Penguins (0.9, 0.5)\nI Use Arch BTW (0.8, 0.4) [x]"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 2)
   #expect(
     result.components.first
-      == Component(
-        label: "Penguins", coordinates: MapPoint(xCoordinate: 0.9, yCoordinate: 0.5), shape: .circle
+      == WmapParser.Component(
+        label: "Penguins", coordinates: WmapParser.MapPoint(xCoordinate: 0.9, yCoordinate: 0.5), shape: .circle
       )
   )
   #expect(
     result.components[1]
-      == Component(
-        label: "I Use Arch BTW", coordinates: MapPoint(xCoordinate: 0.8, yCoordinate: 0.4),
+      == WmapParser.Component(
+        label: "I Use Arch BTW", coordinates: WmapParser.MapPoint(xCoordinate: 0.8, yCoordinate: 0.4),
         shape: .xMark)
   )
 }
 
 @Test func shouldHandleWindowsLineEndings() {
   let source = "Clippy (0.9, 0.5)\r\nSpace Cadet (0.8, 0.4) [x]"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 2)
   #expect(
     result.components.first
-      == Component(
-        label: "Clippy", coordinates: MapPoint(xCoordinate: 0.9, yCoordinate: 0.5), shape: .circle)
+      == WmapParser.Component(
+        label: "Clippy", coordinates: WmapParser.MapPoint(xCoordinate: 0.9, yCoordinate: 0.5), shape: .circle)
   )
   #expect(
     result.components[1]
-      == Component(
-        label: "Space Cadet", coordinates: MapPoint(xCoordinate: 0.8, yCoordinate: 0.4),
+      == WmapParser.Component(
+        label: "Space Cadet", coordinates: WmapParser.MapPoint(xCoordinate: 0.8, yCoordinate: 0.4),
         shape: .xMark)
   )
 }
 
 @Test func shouldHandleMacLineEndings() {
   let source = "SE/30 (0.9, 0.5)\rPerforma (0.8, 0.4) [x]"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 2)
   #expect(
     result.components.first
-      == Component(
-        label: "SE/30", coordinates: MapPoint(xCoordinate: 0.9, yCoordinate: 0.5), shape: .circle)
+      == WmapParser.Component(
+        label: "SE/30", coordinates: WmapParser.MapPoint(xCoordinate: 0.9, yCoordinate: 0.5), shape: .circle)
   )
   #expect(
     result.components[1]
-      == Component(
-        label: "Performa", coordinates: MapPoint(xCoordinate: 0.8, yCoordinate: 0.4), shape: .xMark)
+      == WmapParser.Component(
+        label: "Performa", coordinates: WmapParser.MapPoint(xCoordinate: 0.8, yCoordinate: 0.4), shape: .xMark)
   )
 }
 
@@ -84,73 +84,73 @@ import Testing
 
     The Abyss (0.8, 0.4)
     """
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 2)
   #expect(
     result.components.first
-      == Component(
-        label: "The Void", coordinates: MapPoint(xCoordinate: 0.9, yCoordinate: 0.5), shape: .circle
+      == WmapParser.Component(
+        label: "The Void", coordinates: WmapParser.MapPoint(xCoordinate: 0.9, yCoordinate: 0.5), shape: .circle
       )
   )
   #expect(
     result.components[1]
-      == Component(
-        label: "The Abyss", coordinates: MapPoint(xCoordinate: 0.8, yCoordinate: 0.4),
+      == WmapParser.Component(
+        label: "The Abyss", coordinates: WmapParser.MapPoint(xCoordinate: 0.8, yCoordinate: 0.4),
         shape: .circle)
   )
 }
 
 @Test func shouldHandleIncompleteNotes() {
   let source = "[Note]"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 0)
 }
 
 @Test func shouldHandleIncompleteGroups() {
   let source = "[Group]"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 0)
 }
 
 @Test func shouldHandleIncompleteNodesWithNoCoordinates() {
   let source = "I am a node? ("
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 0)
 }
 
 @Test func shouldHandleIncompleteNodesWithIncompleteCoordinates() {
   let source = "I am a node? (12"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 0)
 }
 
 @Test func shouldHandleIncompleteNodesWithMissingYCoordinates() {
   let source = "I am a node? (12,"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 0)
 }
 
 @Test func shouldHandleIncompleteNodesWithUnclosedCoordinates() {
   let source = "I am a node? (12,21"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 0)
 }
 
 @Test func shouldHandleIncompleteEvolutionWithoutValue() {
   let source = "[Evolution] I accidentally a +"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 0)
 }
 
 @Test func shouldHandleIncompleteEvolutionWithoutComponent() {
   let source = "[Evolution]+"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 0)
 }
 
 @Test func shouldHandleJustAParenthesis() {
   let source = "     ("
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 0)
 }
 
@@ -166,22 +166,22 @@ import Testing
     Hello -> It's OK
     [
     """
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 2)
   #expect(
     result.components.first
-      == Component(
-        label: "Hello", coordinates: MapPoint(xCoordinate: 0.9, yCoordinate: 0.5), shape: .circle)
+      == WmapParser.Component(
+        label: "Hello", coordinates: WmapParser.MapPoint(xCoordinate: 0.9, yCoordinate: 0.5), shape: .circle)
   )
   #expect(
     result.components[1]
-      == Component(
-        label: "It's OK", coordinates: MapPoint(xCoordinate: 0.8, yCoordinate: 0.4), shape: .circle)
+      == WmapParser.Component(
+        label: "It's OK", coordinates: WmapParser.MapPoint(xCoordinate: 0.8, yCoordinate: 0.4), shape: .circle)
   )
   #expect(result.dependencies.count == 1)
   #expect(
     result.dependencies.first
-      == Dependency(fromComponent: "Hello", toComponent: "It's OK", isDirected: true)
+      == WmapParser.Dependency(fromComponent: "Hello", toComponent: "It's OK", isDirected: true)
   )
 }
 
@@ -189,37 +189,37 @@ import Testing
 
 @Test func shouldHandleEmptyInput() {
   let source = ""
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 0)
 }
 
 @Test func shouldHandleOnlyWhitespace() {
   let source = "   \n  \n  "
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 0)
 }
 
 @Test func onlyLineBreaks() {
   let source = "\n"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 0)
 }
 
 @Test func shouldHandleOnlyInvalidLines() {
   let source = "invalid\nstill invalid"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 0)
 }
 
 @Test func shouldHandleComplexComponentLabels() {
   let source = "My Sü'per Complex Label 123 (0.5, 0.5)"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 1)
   #expect(
     result.components.first
-      == Component(
+      == WmapParser.Component(
         label: "My Sü'per Complex Label 123",
-        coordinates: MapPoint(xCoordinate: 0.5, yCoordinate: 0.5), shape: .circle)
+        coordinates: WmapParser.MapPoint(xCoordinate: 0.5, yCoordinate: 0.5), shape: .circle)
   )
 }
 
@@ -248,7 +248,7 @@ import Testing
     [Evolution] Tea + 0.1
     """
 
-  let result = parse(source)
+  let result = WmapParser.parse(source)
 
   // 4 stages + 4 components + 3 dependencies + 1 note + 1 group + 1 inertia + 1 evolution
   #expect(result.stages.count == 4)
@@ -259,54 +259,54 @@ import Testing
   #expect(result.inertias.count == 1)
   #expect(result.evolutions.count == 1)
 
-  #expect(result.stages.first == Stage(stage: .stageI, value: 0.25))
-  #expect(result.stages[1] == Stage(stage: .stageII, value: 0.5))
-  #expect(result.stages[2] == Stage(stage: .stageIII, value: 0.75))
-  #expect(result.stages[3] == Stage(stage: .stageIV, value: 1.0))
+  #expect(result.stages.first == WmapParser.Stage(stage: .stageI, value: 0.25))
+  #expect(result.stages[1] == WmapParser.Stage(stage: .stageII, value: 0.5))
+  #expect(result.stages[2] == WmapParser.Stage(stage: .stageIII, value: 0.75))
+  #expect(result.stages[3] == WmapParser.Stage(stage: .stageIV, value: 1.0))
 
   #expect(
     result.components.first
-      == Component(
-        label: "Tea", coordinates: MapPoint(xCoordinate: 0.9, yCoordinate: 0.5), shape: .circle)
+      == WmapParser.Component(
+        label: "Tea", coordinates: WmapParser.MapPoint(xCoordinate: 0.9, yCoordinate: 0.5), shape: .circle)
   )
   #expect(
     result.components[1]
-      == Component(
-        label: "Cup", coordinates: MapPoint(xCoordinate: 0.8, yCoordinate: 0.4), shape: .circle)
+      == WmapParser.Component(
+        label: "Cup", coordinates: WmapParser.MapPoint(xCoordinate: 0.8, yCoordinate: 0.4), shape: .circle)
   )
   #expect(
     result.components[2]
-      == Component(
-        label: "Kettle", coordinates: MapPoint(xCoordinate: 0.7, yCoordinate: 0.3), shape: .square)
+      == WmapParser.Component(
+        label: "Kettle", coordinates: WmapParser.MapPoint(xCoordinate: 0.7, yCoordinate: 0.3), shape: .square)
   )
   #expect(
     result.components[3]
-      == Component(
-        label: "Hot Water", coordinates: MapPoint(xCoordinate: 0.6, yCoordinate: 0.2),
+      == WmapParser.Component(
+        label: "Hot Water", coordinates: WmapParser.MapPoint(xCoordinate: 0.6, yCoordinate: 0.2),
         shape: .circle)
   )
 
   #expect(
     result.dependencies.first
-      == Dependency(fromComponent: "Tea", toComponent: "Cup", isDirected: true)
+      == WmapParser.Dependency(fromComponent: "Tea", toComponent: "Cup", isDirected: true)
   )
   #expect(
     result.dependencies[1]
-      == Dependency(fromComponent: "Cup", toComponent: "Kettle", isDirected: true)
+      == WmapParser.Dependency(fromComponent: "Cup", toComponent: "Kettle", isDirected: true)
   )
   #expect(
     result.dependencies[2]
-      == Dependency(fromComponent: "Kettle", toComponent: "Hot Water", isDirected: true)
+      == WmapParser.Dependency(fromComponent: "Kettle", toComponent: "Hot Water", isDirected: true)
   )
 
   #expect(
     result.notes.first
-      == Note(
+      == WmapParser.Note(
         text: "This is our tea supply chain",
-        coordinates: MapPoint(xCoordinate: 0.5, yCoordinate: 0.5))
+        coordinates: WmapParser.MapPoint(xCoordinate: 0.5, yCoordinate: 0.5))
   )
 
   #expect(result.groups.first?.components == ["Tea", "Cup", "Kettle"])
   #expect(result.inertias.first?.component == "Kettle")
-  #expect(result.evolutions.first == Evolution(component: "Tea", value: 0.1))
+  #expect(result.evolutions.first == WmapParser.Evolution(component: "Tea", value: 0.1))
 }