Use WmapParser namespace

8 files changed, 147 insertions, 144 deletions

diff --git a/Tests/WmapParserTests/ComponentParserTests.swift b/Tests/WmapParserTests/ComponentParserTests.swift
index 52e347a..1f3a451 100644
--- a/Tests/WmapParserTests/ComponentParserTests.swift
+++ b/Tests/WmapParserTests/ComponentParserTests.swift
@@ -4,128 +4,128 @@ import Testing
 
 @Test func shouldParseABasicComponent() {
   let source = "Dominoes (0.9, 0.5)"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 1)
   #expect(
     result.components.first
-      == Component(
-        label: "Dominoes", coordinates: MapPoint(xCoordinate: 0.9, yCoordinate: 0.5), shape: .circle
+      == WmapParser.Component(
+        label: "Dominoes", coordinates: WmapParser.MapPoint(xCoordinate: 0.9, yCoordinate: 0.5), shape: .circle
       )
   )
 }
 
 @Test func shouldParseAComponentWithAShape() {
   let source = "Database (0.33, 0.81) [Square]"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 1)
   #expect(
     result.components.first
-      == Component(
-        label: "Database", coordinates: MapPoint(xCoordinate: 0.33, yCoordinate: 0.81),
+      == WmapParser.Component(
+        label: "Database", coordinates: WmapParser.MapPoint(xCoordinate: 0.33, yCoordinate: 0.81),
         shape: .square)
   )
 }
 
 @Test func shouldParseAComponentWithXShape() {
   let source = "API (0.5, 0.6) [x]"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 1)
   #expect(
     result.components.first
-      == Component(
-        label: "API", coordinates: MapPoint(xCoordinate: 0.5, yCoordinate: 0.6), shape: .xMark)
+      == WmapParser.Component(
+        label: "API", coordinates: WmapParser.MapPoint(xCoordinate: 0.5, yCoordinate: 0.6), shape: .xMark)
   )
 }
 
 @Test func shouldParseAComponentWithTriangleShape() {
   let source = "Service (0.4, 0.7) [Triangle]"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 1)
   #expect(
     result.components.first
-      == Component(
-        label: "Service", coordinates: MapPoint(xCoordinate: 0.4, yCoordinate: 0.7),
+      == WmapParser.Component(
+        label: "Service", coordinates: WmapParser.MapPoint(xCoordinate: 0.4, yCoordinate: 0.7),
         shape: .triangle)
   )
 }
 
 @Test func shouldParseAComponentWithCircleShape() {
   let source = "Process (0.2, 0.9) [CIRCLE]"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 1)
   #expect(
     result.components.first
-      == Component(
-        label: "Process", coordinates: MapPoint(xCoordinate: 0.2, yCoordinate: 0.9), shape: .circle)
+      == WmapParser.Component(
+        label: "Process", coordinates: WmapParser.MapPoint(xCoordinate: 0.2, yCoordinate: 0.9), shape: .circle)
   )
 }
 
 @Test func shouldDefaultShapeToCircleIfInvalid() {
   let source = "Figures (0.12, 0.711) ["
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 1)
   #expect(
     result.components.first
-      == Component(
-        label: "Figures", coordinates: MapPoint(xCoordinate: 0.12, yCoordinate: 0.711),
+      == WmapParser.Component(
+        label: "Figures", coordinates: WmapParser.MapPoint(xCoordinate: 0.12, yCoordinate: 0.711),
         shape: .circle)
   )
 }
 
 @Test func shouldHandleDecimalNumbers() {
   let source = "Item (.5, .123)"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 1)
   #expect(
     result.components.first
-      == Component(
-        label: "Item", coordinates: MapPoint(xCoordinate: 0.5, yCoordinate: 0.123), shape: .circle)
+      == WmapParser.Component(
+        label: "Item", coordinates: WmapParser.MapPoint(xCoordinate: 0.5, yCoordinate: 0.123), shape: .circle)
   )
 }
 
 @Test func shouldHandleIntegersAsCoordinates() {
   let source = "Item (1, 0)"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 1)
   #expect(
     result.components.first
-      == Component(
-        label: "Item", coordinates: MapPoint(xCoordinate: 1.0, yCoordinate: 0.0), shape: .circle)
+      == WmapParser.Component(
+        label: "Item", coordinates: WmapParser.MapPoint(xCoordinate: 1.0, yCoordinate: 0.0), shape: .circle)
   )
 }
 
 @Test func shouldPreserveCaseInComponentLabels() {
   let source = "RubberGaskets (0.5, 0.5)"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 1)
   #expect(
     result.components.first
-      == Component(
-        label: "RubberGaskets", coordinates: MapPoint(xCoordinate: 0.5, yCoordinate: 0.5),
+      == WmapParser.Component(
+        label: "RubberGaskets", coordinates: WmapParser.MapPoint(xCoordinate: 0.5, yCoordinate: 0.5),
         shape: .circle)
   )
 }
 
 @Test func shouldHandleComponentLabelsWithSpaces() {
   let source = "Big Lawnmowers (0.5, 0.5)"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 1)
   #expect(
     result.components.first
-      == Component(
-        label: "Big Lawnmowers", coordinates: MapPoint(xCoordinate: 0.5, yCoordinate: 0.5),
+      == WmapParser.Component(
+        label: "Big Lawnmowers", coordinates: WmapParser.MapPoint(xCoordinate: 0.5, yCoordinate: 0.5),
         shape: .circle)
   )
 }
 
 @Test func shouldHandleWhitespaceAroundTokens() {
   let source = "  Outer Space  (  0.9  ,  0.5  )  [  Square  ]  "
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.components.count == 1)
   #expect(
     result.components.first
-      == Component(
-        label: "Outer Space", coordinates: MapPoint(xCoordinate: 0.9, yCoordinate: 0.5),
+      == WmapParser.Component(
+        label: "Outer Space", coordinates: WmapParser.MapPoint(xCoordinate: 0.9, yCoordinate: 0.5),
         shape: .square)
   )
 }
diff --git a/Tests/WmapParserTests/DependenciesParserTests.swift b/Tests/WmapParserTests/DependenciesParserTests.swift
index 88e6e99..356d5d3 100644
--- a/Tests/WmapParserTests/DependenciesParserTests.swift
+++ b/Tests/WmapParserTests/DependenciesParserTests.swift
@@ -4,41 +4,41 @@ import Testing
 
 @Test func shouldParseUndirectedDependency() {
   let source = "Smoke -- Fire"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.dependencies.count == 1)
   #expect(
     result.dependencies.first
-      == Dependency(fromComponent: "Smoke", toComponent: "Fire", isDirected: false)
+      == WmapParser.Dependency(fromComponent: "Smoke", toComponent: "Fire", isDirected: false)
   )
 }
 
 @Test func shouldParseDirectedDependency() {
   let source = "Cool Thing -> Different Cool Thing"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.dependencies.count == 1)
   #expect(
     result.dependencies.first
-      == Dependency(
+      == WmapParser.Dependency(
         fromComponent: "Cool Thing", toComponent: "Different Cool Thing", isDirected: true)
   )
 }
 
 @Test func shouldPreserveCaseInDependencyLabels() {
   let source = "SaRcAsM -> Seriousness."
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.dependencies.count == 1)
   #expect(
     result.dependencies.first
-      == Dependency(fromComponent: "SaRcAsM", toComponent: "Seriousness.", isDirected: true)
+      == WmapParser.Dependency(fromComponent: "SaRcAsM", toComponent: "Seriousness.", isDirected: true)
   )
 }
 
 @Test func shouldIgnoreWhitespaceInDependencies() {
   let source = "     loose      --TIGHT"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.dependencies.count == 1)
   #expect(
     result.dependencies.first
-      == Dependency(fromComponent: "loose", toComponent: "TIGHT", isDirected: false)
+      == WmapParser.Dependency(fromComponent: "loose", toComponent: "TIGHT", isDirected: false)
   )
 }
diff --git a/Tests/WmapParserTests/EvolutionParserTests.swift b/Tests/WmapParserTests/EvolutionParserTests.swift
index e87bf9e..66c946a 100644
--- a/Tests/WmapParserTests/EvolutionParserTests.swift
+++ b/Tests/WmapParserTests/EvolutionParserTests.swift
@@ -4,45 +4,45 @@ import Testing
 
 @Test func shouldParsePositiveEvolution() {
   let source = "[Evolution] Nanomachines + 0.5"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.evolutions.count == 1)
   #expect(
-    result.evolutions.first == Evolution(component: "Nanomachines", value: 0.5)
+    result.evolutions.first == WmapParser.Evolution(component: "Nanomachines", value: 0.5)
   )
 }
 
 @Test func shouldParseNegativeEvolution() {
   let source = "[Evolution] FOXDIE - 0.3"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.evolutions.count == 1)
   #expect(
-    result.evolutions.first == Evolution(component: "FOXDIE", value: -0.3)
+    result.evolutions.first == WmapParser.Evolution(component: "FOXDIE", value: -0.3)
   )
 }
 
 @Test func shouldHandleCaseInsensitiveEvolutionKeyword() {
   let source = "[Evolution] tamales + 0.73"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.evolutions.count == 1)
   #expect(
-    result.evolutions.first == Evolution(component: "tamales", value: 0.73)
+    result.evolutions.first == WmapParser.Evolution(component: "tamales", value: 0.73)
   )
 }
 
 @Test func shouldPreserveCaseInEvolutionComponentLabel() {
   let source = "[EVOLUTION] iMac - 0.2"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.evolutions.count == 1)
   #expect(
-    result.evolutions.first == Evolution(component: "iMac", value: -0.2)
+    result.evolutions.first == WmapParser.Evolution(component: "iMac", value: -0.2)
   )
 }
 
 @Test func shouldHandleDecimalEvolutionValues() {
   let source = "[Evolution] Numerals + .75"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.evolutions.count == 1)
   #expect(
-    result.evolutions.first == Evolution(component: "Numerals", value: 0.75)
+    result.evolutions.first == WmapParser.Evolution(component: "Numerals", value: 0.75)
   )
 }
diff --git a/Tests/WmapParserTests/GroupsParserTests.swift b/Tests/WmapParserTests/GroupsParserTests.swift
index dced486..a441a67 100644
--- a/Tests/WmapParserTests/GroupsParserTests.swift
+++ b/Tests/WmapParserTests/GroupsParserTests.swift
@@ -4,35 +4,35 @@ import Testing
 
 @Test func shouldParseAGroupWithASingleComponent() {
   let source = "[Group] Lonely"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.groups.count == 1)
   #expect(result.groups.first?.components == ["Lonely"])
 }
 
 @Test func shouldParseAGroupWithMultipleComponents() {
   let source = "[GrouP] Huey, Dewey, Louie"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.groups.count == 1)
   #expect(result.groups.first?.components == ["Huey", "Dewey", "Louie"])
 }
 
 @Test func shouldHandleCaseInsensitiveGroupKeyword() {
   let source = "[group] Salt, Pepper"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.groups.count == 1)
   #expect(result.groups.first?.components == ["Salt", "Pepper"])
 }
 
 @Test func shouldPreserveCaseInGroupComponentLabel() {
   let source = "[GROUP] XML, LaTeX"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.groups.count == 1)
   #expect(result.groups.first?.components == ["XML", "LaTeX"])
 }
 
 @Test func shouldHandleWhitespaceAroundCommas() {
   let source = "[Group]    sky,    is  large,                      emperor"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.groups.count == 1)
   #expect(result.groups.first?.components == ["sky", "is  large", "emperor"])
 }
diff --git a/Tests/WmapParserTests/InertiaParserTests.swift b/Tests/WmapParserTests/InertiaParserTests.swift
index 92d9868..bcee55f 100644
--- a/Tests/WmapParserTests/InertiaParserTests.swift
+++ b/Tests/WmapParserTests/InertiaParserTests.swift
@@ -4,21 +4,21 @@ import Testing
 
 @Test func shouldParseInertia() {
   let source = "[Inertia] Print Media"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.inertias.count == 1)
   #expect(result.inertias.first?.component == "Print Media")
 }
 
 @Test func shouldHandleCaseInsensitiveInertiaKeyword() {
   let source = "[inertia] Yes"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.inertias.count == 1)
   #expect(result.inertias.first?.component == "Yes")
 }
 
 @Test func shouldPreserveCaseInInertiaComponentLabel() {
   let source = "[INERTIA] SpOnGeBoB"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.inertias.count == 1)
   #expect(result.inertias.first?.component == "SpOnGeBoB")
 }
diff --git a/Tests/WmapParserTests/NotesParserTests.swift b/Tests/WmapParserTests/NotesParserTests.swift
index 655bef6..ae99c75 100644
--- a/Tests/WmapParserTests/NotesParserTests.swift
+++ b/Tests/WmapParserTests/NotesParserTests.swift
@@ -4,39 +4,42 @@ import Testing
 
 @Test func shouldParseANote() {
   let source = "[Note] (0.5, 0.5) This is a note"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.notes.count == 1)
   #expect(
     result.notes.first
-      == Note(text: "This is a note", coordinates: MapPoint(xCoordinate: 0.5, yCoordinate: 0.5))
+      == WmapParser.Note(text: "This is a note", coordinates: WmapParser.MapPoint(xCoordinate: 0.5, yCoordinate: 0.5))
   )
 }
 
 @Test func shouldHandleCaseInsensitiveNoteKeyword() {
   let source = "[note] (0.1, 0.2) Text"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.notes.count == 1)
   #expect(
     result.notes.first
-      == Note(text: "Text", coordinates: MapPoint(xCoordinate: 0.1, yCoordinate: 0.2))
+      == WmapParser.Note(text: "Text", coordinates: WmapParser.MapPoint(xCoordinate: 0.1, yCoordinate: 0.2))
   )
 }
 
 @Test func shouldPreserveCaseInNoteText() {
   let source = "[NOTE] (0.77, 0.19) Important NOTE"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.notes.count == 1)
   #expect(
     result.notes.first
-      == Note(text: "Important NOTE", coordinates: MapPoint(xCoordinate: 0.77, yCoordinate: 0.19))
+      == WmapParser.Note(text: "Important NOTE", coordinates: WmapParser.MapPoint(xCoordinate: 0.77, yCoordinate: 0.19))
   )
 }
 
 @Test func shouldHandleEmptyNoteText() {
   let source = "[Note] (0.5, 0.5) "
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.notes.count == 1)
   #expect(
-    result.notes.first == Note(text: "", coordinates: MapPoint(xCoordinate: 0.5, yCoordinate: 0.5))
+    result.notes.first == WmapParser.Note(
+        text: "",
+        coordinates: WmapParser.MapPoint(xCoordinate: 0.5, yCoordinate: 0.5)
+    )
   )
 }
diff --git a/Tests/WmapParserTests/StagesParserTests.swift b/Tests/WmapParserTests/StagesParserTests.swift
index 50bab4b..2dd30fa 100644
--- a/Tests/WmapParserTests/StagesParserTests.swift
+++ b/Tests/WmapParserTests/StagesParserTests.swift
@@ -4,45 +4,45 @@ import Testing
 
 @Test func shouldParseStageI() {
   let source = "[I] 0.25"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.stages.count == 1)
   #expect(
-    result.stages.first == Stage(stage: .stageI, value: 0.25)
+    result.stages.first == WmapParser.Stage(stage: .stageI, value: 0.25)
   )
 }
 
 @Test func shouldParseStageII() {
   let source = "[ii] 0.5"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.stages.count == 1)
   #expect(
-    result.stages.first == Stage(stage: .stageII, value: 0.5)
+    result.stages.first == WmapParser.Stage(stage: .stageII, value: 0.5)
   )
 }
 
 @Test func shouldParseStageIII() {
   let source = "[III] 0.75"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.stages.count == 1)
   #expect(
-    result.stages.first == Stage(stage: .stageIII, value: 0.75)
+    result.stages.first == WmapParser.Stage(stage: .stageIII, value: 0.75)
   )
 }
 
 @Test func shouldParseStageIV() {
   let source = "[Iv] 1.0"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.stages.count == 1)
   #expect(
-    result.stages.first == Stage(stage: .stageIV, value: 1.0)
+    result.stages.first == WmapParser.Stage(stage: .stageIV, value: 1.0)
   )
 }
 
 @Test func shouldHandleDecimalValues() {
   let source = "[i] .333"
-  let result = parse(source)
+  let result = WmapParser.parse(source)
   #expect(result.stages.count == 1)
   #expect(
-    result.stages.first == Stage(stage: .stageI, value: 0.333)
+    result.stages.first == WmapParser.Stage(stage: .stageI, value: 0.333)
   )
 }
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))
 }