@vessel-dsp/core 0.6.0 → 0.6.1

package/{src/formats/interchange/parser.ts → dist/formats/interchange/parser.js}

@@ -1,95 +1,4 @@
-import { isParsedQuantity } from '../../model/properties';
-import type {
-    CircuitDocument,
-    CircuitDocumentDevice,
-    CircuitDocumentDeviceKind,
-    BoardApplicability,
-    BoardEdgeTerminal,
-    BoardFamily,
-    BoardFootprint,
-    BoardFootprintCatalog,
-    BoardFootprintPlacement,
-    BoardKind,
-    BoardNet,
-    BoardNetMember,
-    BoardNetlist,
-    BoardPlacedPad,
-    BoardRealization,
-    BoardRoute,
-    BoardSourceCircuitHash,
-    BoardSubtype,
-    BuildBom,
-    BuildBomItem,
-    BuildBomRef,
-    BuildCompleteness,
-    BuildIntent,
-    BuildPartProfile,
-    BuildPartProfileCatalog,
-    BuildScope,
-    Component,
-    ComponentKind,
-    ComponentTerminalRef,
-    ControlApplicabilityPredicate,
-    ControlContext,
-    ControlGroup,
-    DeviceInterface,
-    DeviceInterfaceBinding,
-    DeviceInterfaceControlKind,
-    ControlInterface,
-    ControlInterfaceAssignmentHint,
-    ControlInterfaceConnector,
-    ControlInterfacePolarity,
-    ControlInterfaceRole,
-    ControlOutput,
-    ControlOutputSwitchMode,
-    DocumentSource,
-    PanelColumnOrder,
-    PanelControlKind,
-    PanelElementBinding,
-    PanelElementPhysicalPlacement,
-    PanelFaceGeometry,
-    PanelGridLayout,
-    PanelGridIndexing,
-    PanelGridPosition,
-    PanelPlacementMetadata,
-    PanelRowOrder,
-    MechanicalBuildMetadata,
-    OffBoardWiringConnection,
-    OffBoardWiringCoverage,
-    OffBoardWiringEndpoint,
-    OffBoardWiringHarness,
-    OffBoardWiringHarnessStatus,
-    OffBoardWiringPlan,
-    ParsedQuantity,
-    Point,
-    PropertyValue,
-    Rotation,
-    Terminal,
-    VdspBuildDataObject,
-    VdspBuildDataValue,
-    Warning,
-    Wire,
-} from '../../model/types';
-
-type YamlScalar = string | number | boolean | null;
-type YamlValue = YamlScalar | readonly YamlValue[] | YamlObject;
-type YamlObject = { [key: string]: YamlValue };
-
-type YamlLine = Readonly<{
-    indent: number;
-    text: string;
-    lineNumber: number;
-}>;
-
-type Cursor = {
-    index: number;
-};
-
-type ParsedPair = Readonly<{
-    key: string;
-    rest: string;
-}>;
-
+import { isParsedQuantity } from '../../model/properties.js';
 const INTERCHANGE_SCHEMA_V2 = 'circuit-interchange/v2';
 const INTERCHANGE_SCHEMA_V3 = 'circuit-interchange/v3';
 const V3_ONLY_TOP_LEVEL_FIELDS = [
@@ -100,9 +9,8 @@ const V3_ONLY_TOP_LEVEL_FIELDS = [
     'footprints',
     'offBoardWiring',
     'boards',
-] as const;
-
-export function parseInterchangeYaml(source: string): CircuitDocument {
+];
+export function parseInterchangeYaml(source) {
     const value = parseYamlSubset(source);
     const root = expectObject(value, 'root');
     const schema = expectString(root.schema, 'schema');
@@ -113,7 +21,6 @@ export function parseInterchangeYaml(source: string): CircuitDocument {
     if (!isV3) {
         rejectV3OnlyTopLevelFields(root);
     }
-
     const panel = parsePanel(root.panel, isV3);
     const controlInterfaces = parseControlInterfaces(root.controlInterfaces);
     const device = parseDevice(root.device);
@@ -128,7 +35,6 @@ export function parseInterchangeYaml(source: string): CircuitDocument {
     const footprints = isV3 ? parseFootprints(root.footprints) : undefined;
     const offBoardWiring = isV3 ? parseOffBoardWiring(root.offBoardWiring) : undefined;
     const boards = isV3 ? parseBoards(root.boards) : undefined;
-
     return {
         metadata: parseMetadata(root.metadata),
         source: parseSource(root.source),
@@ -153,16 +59,14 @@ export function parseInterchangeYaml(source: string): CircuitDocument {
         rawAttributes: parseStringRecord(root.rawAttributes, 'rawAttributes'),
     };
 }
-
-function rejectV3OnlyTopLevelFields(root: YamlObject): void {
+function rejectV3OnlyTopLevelFields(root) {
     for (const field of V3_ONLY_TOP_LEVEL_FIELDS) {
         if (root[field] !== undefined) {
             throw new Error(`${field}: requires schema ${INTERCHANGE_SCHEMA_V3}`);
         }
     }
 }
-
-function parseMechanical(value: YamlValue | undefined): MechanicalBuildMetadata | undefined {
+function parseMechanical(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -173,8 +77,7 @@ function parseMechanical(value: YamlValue | undefined): MechanicalBuildMetadata
         ...(mechanical.units === undefined ? {} : { units: expectString(mechanical.units, 'mechanical.units') }),
     };
 }
-
-function parseBuild(value: YamlValue | undefined): BuildScope | undefined {
+function parseBuild(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -192,10 +95,7 @@ function parseBuild(value: YamlValue | undefined): BuildScope | undefined {
         ...(build.selectedOffBoardWiringHarnessIds === undefined
             ? {}
             : {
-                selectedOffBoardWiringHarnessIds: parseOptionalStringArray(
-                    build.selectedOffBoardWiringHarnessIds,
-                    'build.selectedOffBoardWiringHarnessIds',
-                ) ?? [],
+                selectedOffBoardWiringHarnessIds: parseOptionalStringArray(build.selectedOffBoardWiringHarnessIds, 'build.selectedOffBoardWiringHarnessIds') ?? [],
             }),
         ...(build.alternateBoardIds === undefined
             ? {}
@@ -203,24 +103,21 @@ function parseBuild(value: YamlValue | undefined): BuildScope | undefined {
         ...(build.bomScope === undefined ? {} : { bomScope: expectString(build.bomScope, 'build.bomScope') }),
     };
 }
-
-function parseBuildIntent(value: YamlValue | undefined, path: string): BuildIntent {
+function parseBuildIntent(value, path) {
     const intent = expectString(value, path);
     if (intent === 'diy-build-artifact' || intent === 'schema-review-sample') {
         return intent;
     }
     throw new Error(`${path}: expected diy-build-artifact or schema-review-sample`);
 }
-
-function parseBuildCompleteness(value: YamlValue | undefined, path: string): BuildCompleteness {
+function parseBuildCompleteness(value, path) {
     const completeness = expectString(value, path);
     if (completeness === 'complete-selected-build' || completeness === 'partial-offboard-wiring') {
         return completeness;
     }
     throw new Error(`${path}: expected complete-selected-build or partial-offboard-wiring`);
 }
-
-function parseBom(value: YamlValue | undefined): BuildBom | undefined {
+function parseBom(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -231,16 +128,13 @@ function parseBom(value: YamlValue | undefined): BuildBom | undefined {
         items: optionalArray(bom.items, 'bom.items').map(parseBomItem),
     };
 }
-
-function parseBomItem(value: YamlValue, index: number): BuildBomItem {
+function parseBomItem(value, index) {
     const path = `bom.items[${index}]`;
     const item = expectObject(value, path);
     return {
         ...parseBuildDataObject(item, path),
         id: expectString(item.id, `${path}.id`),
-        refs: optionalArray(item.refs, `${path}.refs`).map((ref, refIndex) =>
-            parseBomRef(ref, `${path}.refs[${refIndex}]`)
-        ),
+        refs: optionalArray(item.refs, `${path}.refs`).map((ref, refIndex) => parseBomRef(ref, `${path}.refs[${refIndex}]`)),
         quantity: expectNumber(item.quantity, `${path}.quantity`),
         ...(item.value === undefined ? {} : { value: expectString(item.value, `${path}.value`) }),
         ...(item.partProfileId === undefined
@@ -250,8 +144,7 @@ function parseBomItem(value: YamlValue, index: number): BuildBomItem {
         ...(item.sku === undefined ? {} : { sku: expectString(item.sku, `${path}.sku`) }),
     };
 }
-
-function parseBomRef(value: YamlValue, path: string): BuildBomRef {
+function parseBomRef(value, path) {
     const ref = expectObject(value, path);
     const kind = expectString(ref.kind, `${path}.kind`);
     switch (kind) {
@@ -275,8 +168,7 @@ function parseBomRef(value: YamlValue, path: string): BuildBomRef {
             throw new Error(`${path}.kind: expected component, device-interface-control, panel-element, board, or freeform-build-item`);
     }
 }
-
-function parsePartProfiles(value: YamlValue | undefined): BuildPartProfileCatalog | undefined {
+function parsePartProfiles(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -288,13 +180,10 @@ function parsePartProfiles(value: YamlValue | undefined): BuildPartProfileCatalo
             ? {}
             : { resolution: expectString(catalog.resolution, 'partProfiles.resolution') }),
         ...(catalog.units === undefined ? {} : { units: expectString(catalog.units, 'partProfiles.units') }),
-        profiles: optionalArray(catalog.profiles, 'partProfiles.profiles').map((profile, index) =>
-            parsePartProfile(profile, index)
-        ),
+        profiles: optionalArray(catalog.profiles, 'partProfiles.profiles').map((profile, index) => parsePartProfile(profile, index)),
     };
 }
-
-function parsePartProfile(value: YamlValue, index: number): BuildPartProfile {
+function parsePartProfile(value, index) {
     const path = `partProfiles.profiles[${index}]`;
     const profile = expectObject(value, path);
     return {
@@ -303,8 +192,7 @@ function parsePartProfile(value: YamlValue, index: number): BuildPartProfile {
         ...(profile.kind === undefined ? {} : { kind: expectString(profile.kind, `${path}.kind`) }),
     };
 }
-
-function parseFootprints(value: YamlValue | undefined): BoardFootprintCatalog | undefined {
+function parseFootprints(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -314,13 +202,10 @@ function parseFootprints(value: YamlValue | undefined): BoardFootprintCatalog |
         schema: parseLiteralString(catalog.schema, 'footprints.schema', 'board-footprint-catalog/v1'),
         ...(catalog.resolution === undefined ? {} : { resolution: expectString(catalog.resolution, 'footprints.resolution') }),
         ...(catalog.units === undefined ? {} : { units: expectString(catalog.units, 'footprints.units') }),
-        footprints: optionalArray(catalog.footprints, 'footprints.footprints').map((footprint, index) =>
-            parseFootprint(footprint, index)
-        ),
+        footprints: optionalArray(catalog.footprints, 'footprints.footprints').map((footprint, index) => parseFootprint(footprint, index)),
     };
 }
-
-function parseFootprint(value: YamlValue, index: number): BoardFootprint {
+function parseFootprint(value, index) {
     const path = `footprints.footprints[${index}]`;
     const footprint = expectObject(value, path);
     return {
@@ -331,8 +216,7 @@ function parseFootprint(value: YamlValue, index: number): BoardFootprint {
             : { boardApplicability: parseBoardApplicability(footprint.boardApplicability, `${path}.boardApplicability`) }),
     };
 }
-
-function parseBoardApplicability(value: YamlValue, path: string): BoardApplicability {
+function parseBoardApplicability(value, path) {
     const applicability = expectObject(value, path);
     return {
         ...parseBuildDataObject(applicability, path),
@@ -343,8 +227,7 @@ function parseBoardApplicability(value: YamlValue, path: string): BoardApplicabi
             : { subtype: parseBoardSubtype(applicability.subtype, `${path}.subtype`) }),
     };
 }
-
-function parseOffBoardWiring(value: YamlValue | undefined): OffBoardWiringPlan | undefined {
+function parseOffBoardWiring(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -359,16 +242,14 @@ function parseOffBoardWiring(value: YamlValue | undefined): OffBoardWiringPlan |
         harnesses: optionalArray(plan.harnesses, 'offBoardWiring.harnesses').map(parseOffBoardWiringHarness),
     };
 }
-
-function parseOffBoardWiringCoverage(value: YamlValue | undefined, path: string): OffBoardWiringCoverage {
+function parseOffBoardWiringCoverage(value, path) {
     const coverage = expectString(value, path);
     if (coverage === 'selected-build-complete' || coverage === 'representative-selected-build-endpoints') {
         return coverage;
     }
     throw new Error(`${path}: expected selected-build-complete or representative-selected-build-endpoints`);
 }
-
-function parseOffBoardWiringHarness(value: YamlValue, index: number): OffBoardWiringHarness {
+function parseOffBoardWiringHarness(value, index) {
     const path = `offBoardWiring.harnesses[${index}]`;
     const harness = expectObject(value, path);
     return {
@@ -378,24 +259,18 @@ function parseOffBoardWiringHarness(value: YamlValue, index: number): OffBoardWi
             ? {}
             : { status: parseOffBoardWiringHarnessStatus(harness.status, `${path}.status`) }),
         ...(harness.notes === undefined ? {} : { notes: expectString(harness.notes, `${path}.notes`) }),
-        endpoints: optionalArray(harness.endpoints, `${path}.endpoints`).map((endpoint, endpointIndex) =>
-            parseOffBoardWiringEndpoint(endpoint, `${path}.endpoints[${endpointIndex}]`)
-        ),
-        connections: optionalArray(harness.connections, `${path}.connections`).map((connection, connectionIndex) =>
-            parseOffBoardWiringConnection(connection, `${path}.connections[${connectionIndex}]`)
-        ),
+        endpoints: optionalArray(harness.endpoints, `${path}.endpoints`).map((endpoint, endpointIndex) => parseOffBoardWiringEndpoint(endpoint, `${path}.endpoints[${endpointIndex}]`)),
+        connections: optionalArray(harness.connections, `${path}.connections`).map((connection, connectionIndex) => parseOffBoardWiringConnection(connection, `${path}.connections[${connectionIndex}]`)),
     };
 }
-
-function parseOffBoardWiringHarnessStatus(value: YamlValue | undefined, path: string): OffBoardWiringHarnessStatus {
+function parseOffBoardWiringHarnessStatus(value, path) {
     const status = expectString(value, path);
     if (status === 'complete' || status === 'partial' || status === 'candidate') {
         return status;
     }
     throw new Error(`${path}: expected complete, partial, or candidate`);
 }
-
-function parseOffBoardWiringEndpoint(value: YamlValue, path: string): OffBoardWiringEndpoint {
+function parseOffBoardWiringEndpoint(value, path) {
     const endpoint = expectObject(value, path);
     const kind = expectString(endpoint.kind, `${path}.kind`);
     switch (kind) {
@@ -427,8 +302,7 @@ function parseOffBoardWiringEndpoint(value: YamlValue, path: string): OffBoardWi
             throw new Error(`${path}.kind: expected a supported off-board wiring endpoint kind`);
     }
 }
-
-function parseOffBoardWiringConnection(value: YamlValue, path: string): OffBoardWiringConnection {
+function parseOffBoardWiringConnection(value, path) {
     const connection = expectObject(value, path);
     return {
         ...parseBuildDataObject(connection, path),
@@ -441,15 +315,13 @@ function parseOffBoardWiringConnection(value: YamlValue, path: string): OffBoard
         ...(connection.wire === undefined ? {} : { wire: parseBuildDataObject(connection.wire, `${path}.wire`) }),
     };
 }
-
-function parseBoards(value: YamlValue | undefined): readonly BoardRealization[] | undefined {
+function parseBoards(value) {
     if (value === undefined) {
         return undefined;
     }
     return optionalArray(value, 'boards').map(parseBoard);
 }
-
-function parseBoard(value: YamlValue, index: number): BoardRealization {
+function parseBoard(value, index) {
     const path = `boards[${index}]`;
     const board = expectObject(value, path);
     const sourceCircuit = board.sourceCircuit === undefined
@@ -466,23 +338,16 @@ function parseBoard(value: YamlValue, index: number): BoardRealization {
         ...(board.units === undefined ? {} : { units: expectString(board.units, `${path}.units`) }),
         ...(board.locked === undefined ? {} : { locked: expectBoolean(board.locked, `${path}.locked`) }),
         ...(sourceCircuit === undefined ? {} : { sourceCircuit }),
-        edgeTerminals: optionalArray(board.edgeTerminals, `${path}.edgeTerminals`).map((terminal, terminalIndex) =>
-            parseBoardEdgeTerminal(terminal, `${path}.edgeTerminals[${terminalIndex}]`)
-        ),
-        footprintPlacements: optionalArray(board.footprintPlacements, `${path}.footprintPlacements`).map((placement, placementIndex) =>
-            parseBoardFootprintPlacement(placement, `${path}.footprintPlacements[${placementIndex}]`)
-        ),
+        edgeTerminals: optionalArray(board.edgeTerminals, `${path}.edgeTerminals`).map((terminal, terminalIndex) => parseBoardEdgeTerminal(terminal, `${path}.edgeTerminals[${terminalIndex}]`)),
+        footprintPlacements: optionalArray(board.footprintPlacements, `${path}.footprintPlacements`).map((placement, placementIndex) => parseBoardFootprintPlacement(placement, `${path}.footprintPlacements[${placementIndex}]`)),
         ...(board.netlist === undefined ? {} : { netlist: parseBoardNetlist(board.netlist, `${path}.netlist`) }),
-        routes: optionalArray(board.routes, `${path}.routes`).map((route, routeIndex) =>
-            parseBoardRoute(route, `${path}.routes[${routeIndex}]`)
-        ),
+        routes: optionalArray(board.routes, `${path}.routes`).map((route, routeIndex) => parseBoardRoute(route, `${path}.routes[${routeIndex}]`)),
         ...(board.zones === undefined ? {} : { zones: parseBuildDataObjectArray(board.zones, `${path}.zones`) }),
         ...(board.drills === undefined ? {} : { drills: parseBuildDataObjectArray(board.drills, `${path}.drills`) }),
         ...(board.review === undefined ? {} : { review: parseBuildDataObject(board.review, `${path}.review`) }),
     };
 }
-
-function parseBoardSourceCircuit(value: YamlValue, path: string): BoardSourceCircuitHash {
+function parseBoardSourceCircuit(value, path) {
     const sourceCircuit = expectObject(value, path);
     const hash = expectString(sourceCircuit.hash, `${path}.hash`);
     if (!/^sha256:[0-9a-f]{64}$/.test(hash)) {
@@ -495,8 +360,7 @@ function parseBoardSourceCircuit(value: YamlValue, path: string): BoardSourceCir
         hash,
     };
 }
-
-function parseBoardEdgeTerminal(value: YamlValue, path: string): BoardEdgeTerminal {
+function parseBoardEdgeTerminal(value, path) {
     const terminal = expectObject(value, path);
     return {
         ...parseBuildDataObject(terminal, path),
@@ -508,8 +372,7 @@ function parseBoardEdgeTerminal(value: YamlValue, path: string): BoardEdgeTermin
         ...(terminal.hole === undefined ? {} : { hole: parseBoardHole(terminal.hole, `${path}.hole`) }),
     };
 }
-
-function parseBoardFootprintPlacement(value: YamlValue, path: string): BoardFootprintPlacement {
+function parseBoardFootprintPlacement(value, path) {
     const placement = expectObject(value, path);
     return {
         ...parseBuildDataObject(placement, path),
@@ -518,13 +381,10 @@ function parseBoardFootprintPlacement(value: YamlValue, path: string): BoardFoot
         ...(placement.atGrid === undefined ? {} : { atGrid: parseBoardHole(placement.atGrid, `${path}.atGrid`) }),
         ...(placement.atMm === undefined ? {} : { atMm: parsePoint(placement.atMm, `${path}.atMm`) }),
         ...(placement.rotationDeg === undefined ? {} : { rotationDeg: expectNumber(placement.rotationDeg, `${path}.rotationDeg`) }),
-        pads: optionalArray(placement.pads, `${path}.pads`).map((pad, padIndex) =>
-            parseBoardPlacedPad(pad, `${path}.pads[${padIndex}]`)
-        ),
+        pads: optionalArray(placement.pads, `${path}.pads`).map((pad, padIndex) => parseBoardPlacedPad(pad, `${path}.pads[${padIndex}]`)),
     };
 }
-
-function parseBoardPlacedPad(value: YamlValue, path: string): BoardPlacedPad {
+function parseBoardPlacedPad(value, path) {
     const pad = expectObject(value, path);
     return {
         ...parseBuildDataObject(pad, path),
@@ -534,31 +394,24 @@ function parseBoardPlacedPad(value: YamlValue, path: string): BoardPlacedPad {
         ...(pad.positionMm === undefined ? {} : { positionMm: parsePoint(pad.positionMm, `${path}.positionMm`) }),
     };
 }
-
-function parseBoardNetlist(value: YamlValue, path: string): BoardNetlist {
+function parseBoardNetlist(value, path) {
     const netlist = expectObject(value, path);
     return {
         ...parseBuildDataObject(netlist, path),
         ...(netlist.source === undefined ? {} : { source: expectString(netlist.source, `${path}.source`) }),
-        nets: optionalArray(netlist.nets, `${path}.nets`).map((net, netIndex) =>
-            parseBoardNet(net, `${path}.nets[${netIndex}]`)
-        ),
+        nets: optionalArray(netlist.nets, `${path}.nets`).map((net, netIndex) => parseBoardNet(net, `${path}.nets[${netIndex}]`)),
     };
 }
-
-function parseBoardNet(value: YamlValue, path: string): BoardNet {
+function parseBoardNet(value, path) {
     const net = expectObject(value, path);
     return {
         ...parseBuildDataObject(net, path),
         id: expectString(net.id, `${path}.id`),
         ...(net.name === undefined ? {} : { name: expectString(net.name, `${path}.name`) }),
-        members: optionalArray(net.members, `${path}.members`).map((member, memberIndex) =>
-            parseBoardNetMember(member, `${path}.members[${memberIndex}]`)
-        ),
+        members: optionalArray(net.members, `${path}.members`).map((member, memberIndex) => parseBoardNetMember(member, `${path}.members[${memberIndex}]`)),
     };
 }
-
-function parseBoardNetMember(value: YamlValue, path: string): BoardNetMember {
+function parseBoardNetMember(value, path) {
     const member = expectObject(value, path);
     return {
         ...parseBuildDataObject(member, path),
@@ -568,8 +421,7 @@ function parseBoardNetMember(value: YamlValue, path: string): BoardNetMember {
         ...(member.terminalId === undefined ? {} : { terminalId: expectString(member.terminalId, `${path}.terminalId`) }),
     };
 }
-
-function parseBoardRoute(value: YamlValue, path: string): BoardRoute {
+function parseBoardRoute(value, path) {
     const route = expectObject(value, path);
     return {
         ...parseBuildDataObject(route, path),
@@ -585,8 +437,7 @@ function parseBoardRoute(value: YamlValue, path: string): BoardRoute {
         ...(route.drills === undefined ? {} : { drills: parseBuildDataObjectArray(route.drills, `${path}.drills`) }),
     };
 }
-
-function parseComponentTerminalRef(value: YamlValue, path: string): ComponentTerminalRef {
+function parseComponentTerminalRef(value, path) {
     const ref = expectObject(value, path);
     return {
         ...parseBuildDataObject(ref, path),
@@ -594,8 +445,7 @@ function parseComponentTerminalRef(value: YamlValue, path: string): ComponentTer
         terminalName: expectString(ref.terminalName, `${path}.terminalName`),
     };
 }
-
-function parseBoardHole(value: YamlValue, path: string) {
+function parseBoardHole(value, path) {
     const hole = expectObject(value, path);
     return {
         ...parseBuildDataObject(hole, path),
@@ -603,16 +453,14 @@ function parseBoardHole(value: YamlValue, path: string) {
         column: expectPositiveInteger(hole.column, `${path}.column`),
     };
 }
-
-function parseBoardFamily(value: YamlValue | undefined, path: string): BoardFamily {
+function parseBoardFamily(value, path) {
     const family = expectString(value, path);
     if (family === 'prototype-board' || family === 'fabricated-board') {
         return family;
     }
     throw new Error(`${path}: expected prototype-board or fabricated-board`);
 }
-
-function parseBoardKind(value: YamlValue | undefined, path: string): BoardKind {
+function parseBoardKind(value, path) {
     const kind = expectString(value, path);
     switch (kind) {
         case 'stripboard':
@@ -624,8 +472,7 @@ function parseBoardKind(value: YamlValue | undefined, path: string): BoardKind {
             throw new Error(`${path}: expected stripboard, perfboard, breadboard-pattern, or pcb`);
     }
 }
-
-function parseBoardSubtype(value: YamlValue | undefined, path: string): BoardSubtype {
+function parseBoardSubtype(value, path) {
     const subtype = expectString(value, path);
     switch (subtype) {
         case 'veroboard':
@@ -638,29 +485,25 @@ function parseBoardSubtype(value: YamlValue | undefined, path: string): BoardSub
             throw new Error(`${path}: expected a supported board subtype`);
     }
 }
-
-function parseLiteralString<T extends string>(value: YamlValue | undefined, path: string, expected: T): T {
+function parseLiteralString(value, path, expected) {
     const actual = expectString(value, path);
     if (actual === expected) {
         return expected;
     }
     throw new Error(`${path}: expected ${expected}`);
 }
-
-function parseBuildDataObjectArray(value: YamlValue | undefined, path: string): readonly VdspBuildDataObject[] {
+function parseBuildDataObjectArray(value, path) {
     return optionalArray(value, path).map((item, index) => parseBuildDataObject(item, `${path}[${index}]`));
 }
-
-function parseBuildDataObject(value: YamlValue | undefined, path: string): VdspBuildDataObject {
+function parseBuildDataObject(value, path) {
     const object = expectObject(value, path);
-    const out: Record<string, VdspBuildDataValue | undefined> = {};
+    const out = {};
     for (const [key, child] of Object.entries(object)) {
         out[key] = parseBuildDataValue(child, `${path}.${key}`);
     }
     return out;
 }
-
-function parseBuildDataValue(value: YamlValue, path: string): VdspBuildDataValue {
+function parseBuildDataValue(value, path) {
     if (isScalar(value)) {
         return value;
     }
@@ -672,8 +515,7 @@ function parseBuildDataValue(value: YamlValue, path: string): VdspBuildDataValue
     }
     throw new Error(`${path}: expected v3 build data value`);
 }
-
-function parseControlGroups(value: YamlValue | undefined): readonly ControlGroup[] | undefined {
+function parseControlGroups(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -691,8 +533,7 @@ function parseControlGroups(value: YamlValue | undefined): readonly ControlGroup
         };
     });
 }
-
-function parseControlContexts(value: YamlValue | undefined): readonly ControlContext[] | undefined {
+function parseControlContexts(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -708,8 +549,7 @@ function parseControlContexts(value: YamlValue | undefined): readonly ControlCon
         };
     });
 }
-
-function parseDeviceInterface(value: YamlValue | undefined): DeviceInterface | undefined {
+function parseDeviceInterface(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -737,11 +577,7 @@ function parseDeviceInterface(value: YamlValue | undefined): DeviceInterface | u
         }),
     };
 }
-
-function parseDeviceInterfaceControlKind(
-    value: YamlValue | undefined,
-    path: string,
-): DeviceInterfaceControlKind {
+function parseDeviceInterfaceControlKind(value, path) {
     const kind = expectString(value, path);
     switch (kind) {
         case 'knob':
@@ -756,11 +592,7 @@ function parseDeviceInterfaceControlKind(
             throw new Error(`${path}: expected knob, slider, switch, selector, footswitch, led, or jack`);
     }
 }
-
-function parseOptionalDeviceInterfaceBinding(
-    value: YamlValue | undefined,
-    path: string,
-): DeviceInterfaceBinding | undefined {
+function parseOptionalDeviceInterfaceBinding(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -777,11 +609,7 @@ function parseOptionalDeviceInterfaceBinding(
         ...(externalInterfaceId === undefined ? {} : { externalInterfaceId }),
     };
 }
-
-function parseOptionalApplicabilityPredicate(
-    value: YamlValue | undefined,
-    path: string,
-): ControlApplicabilityPredicate | undefined {
+function parseOptionalApplicabilityPredicate(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -793,8 +621,7 @@ function parseOptionalApplicabilityPredicate(
         ...(anyOf === undefined ? {} : { anyOf }),
     };
 }
-
-function parseDevice(value: YamlValue | undefined): CircuitDocumentDevice | undefined {
+function parseDevice(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -813,8 +640,7 @@ function parseDevice(value: YamlValue | undefined): CircuitDocumentDevice | unde
         ...(audioProcessing === undefined ? {} : { audioProcessing }),
     };
 }
-
-function parseCircuitDocumentDeviceKind(value: YamlValue | undefined, path: string): CircuitDocumentDeviceKind {
+function parseCircuitDocumentDeviceKind(value, path) {
     const kind = expectString(value, path);
     switch (kind) {
         case 'audio-pedal':
@@ -826,8 +652,7 @@ function parseCircuitDocumentDeviceKind(value: YamlValue | undefined, path: stri
             throw new Error(`${path}: expected audio-pedal, control-accessory, utility, or unknown`);
     }
 }
-
-function parseControlOutputs(value: YamlValue | undefined): readonly ControlOutput[] | undefined {
+function parseControlOutputs(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -855,11 +680,7 @@ function parseControlOutputs(value: YamlValue | undefined): readonly ControlOutp
         };
     });
 }
-
-function parseOptionalControlOutputSwitchMode(
-    value: YamlValue | undefined,
-    path: string,
-): ControlOutputSwitchMode | undefined {
+function parseOptionalControlOutputSwitchMode(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -872,8 +693,7 @@ function parseOptionalControlOutputSwitchMode(
             throw new Error(`${path}: expected momentary or latching`);
     }
 }
-
-function parseControlInterfaces(value: YamlValue | undefined): readonly ControlInterface[] | undefined {
+function parseControlInterfaces(value) {
     if (value === undefined) {
         return undefined;
     }
@@ -884,10 +704,7 @@ function parseControlInterfaces(value: YamlValue | undefined): readonly ControlI
         const controlRole = parseOptionalString(controlInterface.controlRole, `${path}.controlRole`);
         const interfaceName = parseOptionalString(controlInterface.interface, `${path}.interface`);
         const connector = parseOptionalControlInterfaceConnector(controlInterface.connector, `${path}.connector`);
-        const assignmentHint = parseOptionalControlInterfaceAssignmentHint(
-            controlInterface.assignmentHint,
-            `${path}.assignmentHint`,
-        );
+        const assignmentHint = parseOptionalControlInterfaceAssignmentHint(controlInterface.assignmentHint, `${path}.assignmentHint`);
         const polarity = parseOptionalControlInterfacePolarity(controlInterface.polarity, `${path}.polarity`);
         const binding = parseOptionalControlInterfaceBinding(controlInterface.binding, `${path}.binding`);
         const description = parseOptionalString(controlInterface.description, `${path}.description`);
@@ -906,11 +723,7 @@ function parseControlInterfaces(value: YamlValue | undefined): readonly ControlI
         };
     });
 }
-
-function parseOptionalControlInterfaceBinding(
-    value: YamlValue | undefined,
-    path: string,
-): ControlInterface['binding'] | undefined {
+function parseOptionalControlInterfaceBinding(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -926,8 +739,7 @@ function parseOptionalControlInterfaceBinding(
         ...(property === undefined ? {} : { property }),
     };
 }
-
-function parseControlInterfaceRole(value: YamlValue | undefined, path: string): ControlInterfaceRole {
+function parseControlInterfaceRole(value, path) {
     const role = expectString(value, path);
     switch (role) {
         case 'external-control':
@@ -942,11 +754,7 @@ function parseControlInterfaceRole(value: YamlValue | undefined, path: string):
             throw new Error(`${path}: expected external-control, tempo-tap, trigger, reset, sampler-trigger, expression, or unknown`);
     }
 }
-
-function parseOptionalControlInterfaceConnector(
-    value: YamlValue | undefined,
-    path: string,
-): ControlInterfaceConnector | undefined {
+function parseOptionalControlInterfaceConnector(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -963,11 +771,7 @@ function parseOptionalControlInterfaceConnector(
             throw new Error(`${path}: expected a supported connector kind`);
     }
 }
-
-function parseOptionalControlInterfaceAssignmentHint(
-    value: YamlValue | undefined,
-    path: string,
-): ControlInterfaceAssignmentHint | undefined {
+function parseOptionalControlInterfaceAssignmentHint(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -982,11 +786,7 @@ function parseOptionalControlInterfaceAssignmentHint(
             throw new Error(`${path}: expected momentary, latching, momentary-or-latching, or continuous`);
     }
 }
-
-function parseOptionalControlInterfacePolarity(
-    value: YamlValue | undefined,
-    path: string,
-): ControlInterfacePolarity | undefined {
+function parseOptionalControlInterfacePolarity(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -1001,13 +801,12 @@ function parseOptionalControlInterfacePolarity(
             throw new Error(`${path}: expected normally-open, normally-closed, expression, or unknown`);
     }
 }
-
-function parseYamlSubset(source: string): YamlValue {
+function parseYamlSubset(source) {
     const lines = tokenize(source);
     if (lines.length === 0) {
         throw new Error('interchange YAML is empty');
     }
-    const cursor: Cursor = { index: 0 };
+    const cursor = { index: 0 };
     const first = lines[0];
     if (first === undefined) {
         throw new Error('interchange YAML is empty');
@@ -1019,9 +818,8 @@ function parseYamlSubset(source: string): YamlValue {
     }
     return value;
 }
-
-function tokenize(source: string): readonly YamlLine[] {
-    const lines: YamlLine[] = [];
+function tokenize(source) {
+    const lines = [];
     const rawLines = source.replace(/^/, '').split(/\r?\n/);
     rawLines.forEach((rawLine, index) => {
         if (rawLine.trim().length === 0) {
@@ -1039,8 +837,7 @@ function tokenize(source: string): readonly YamlLine[] {
     });
     return lines;
 }
-
-function parseBlock(lines: readonly YamlLine[], cursor: Cursor, indent: number): YamlValue {
+function parseBlock(lines, cursor, indent) {
     const line = lines[cursor.index];
     if (line === undefined) {
         return {};
@@ -1053,9 +850,8 @@ function parseBlock(lines: readonly YamlLine[], cursor: Cursor, indent: number):
     }
     return parseObject(lines, cursor, indent);
 }
-
-function parseObject(lines: readonly YamlLine[], cursor: Cursor, indent: number): YamlObject {
-    const out: YamlObject = {};
+function parseObject(lines, cursor, indent) {
+    const out = {};
     while (cursor.index < lines.length) {
         const line = lines[cursor.index];
         if (line === undefined || line.indent < indent) {
@@ -1067,7 +863,6 @@ function parseObject(lines: readonly YamlLine[], cursor: Cursor, indent: number)
         if (line.text === '-' || line.text.startsWith('- ')) {
             break;
         }
-
         const pair = parsePair(line.text, line.lineNumber);
         cursor.index += 1;
         out[pair.key] = pair.rest.length > 0
@@ -1076,9 +871,8 @@ function parseObject(lines: readonly YamlLine[], cursor: Cursor, indent: number)
     }
     return out;
 }
-
-function parseArray(lines: readonly YamlLine[], cursor: Cursor, indent: number): readonly YamlValue[] {
-    const out: YamlValue[] = [];
+function parseArray(lines, cursor, indent) {
+    const out = [];
     while (cursor.index < lines.length) {
         const line = lines[cursor.index];
         if (line === undefined || line.indent < indent) {
@@ -1090,33 +884,26 @@ function parseArray(lines: readonly YamlLine[], cursor: Cursor, indent: number):
         if (line.text !== '-' && !line.text.startsWith('- ')) {
             break;
         }
-
         const rest = line.text === '-' ? '' : line.text.slice(2);
         cursor.index += 1;
         if (rest.length === 0) {
             out.push(parseNestedValue(lines, cursor, indent, line.lineNumber));
-        } else if (looksLikePair(rest)) {
+        }
+        else if (looksLikePair(rest)) {
             out.push(parseObjectItem(rest, lines, cursor, indent + 2, line.lineNumber));
-        } else {
+        }
+        else {
             out.push(parseInlineValue(rest, line.lineNumber));
         }
     }
     return out;
 }
-
-function parseObjectItem(
-    firstPairText: string,
-    lines: readonly YamlLine[],
-    cursor: Cursor,
-    indent: number,
-    lineNumber: number,
-): YamlObject {
-    const out: YamlObject = {};
+function parseObjectItem(firstPairText, lines, cursor, indent, lineNumber) {
+    const out = {};
     const firstPair = parsePair(firstPairText, lineNumber);
     out[firstPair.key] = firstPair.rest.length > 0
         ? parseInlineValue(firstPair.rest, lineNumber)
         : parseNestedValue(lines, cursor, indent, lineNumber);
-
     while (cursor.index < lines.length) {
         const line = lines[cursor.index];
         if (line === undefined || line.indent < indent) {
@@ -1128,23 +915,15 @@ function parseObjectItem(
         if (line.text === '-' || line.text.startsWith('- ')) {
             break;
         }
-
         const pair = parsePair(line.text, line.lineNumber);
         cursor.index += 1;
         out[pair.key] = pair.rest.length > 0
             ? parseInlineValue(pair.rest, line.lineNumber)
             : parseNestedValue(lines, cursor, indent, line.lineNumber);
     }
-
     return out;
 }
-
-function parseNestedValue(
-    lines: readonly YamlLine[],
-    cursor: Cursor,
-    parentIndent: number,
-    lineNumber: number,
-): YamlValue {
+function parseNestedValue(lines, cursor, parentIndent, lineNumber) {
     const next = lines[cursor.index];
     if (next === undefined || next.indent <= parentIndent) {
         return {};
@@ -1154,8 +933,7 @@ function parseNestedValue(
     }
     return parseBlock(lines, cursor, next.indent);
 }
-
-function parsePair(text: string, lineNumber: number): ParsedPair {
+function parsePair(text, lineNumber) {
     const colonIndex = findPairColon(text);
     if (colonIndex <= 0) {
         throw new Error(`line ${lineNumber}: expected key/value pair`);
@@ -1167,20 +945,17 @@ function parsePair(text: string, lineNumber: number): ParsedPair {
         rest: restText.startsWith(' ') ? restText.slice(1) : restText,
     };
 }
-
-function looksLikePair(text: string): boolean {
+function looksLikePair(text) {
     return findPairColon(text) > 0;
 }
-
-function findPairColon(text: string): number {
+function findPairColon(text) {
     if (text.startsWith('"')) {
         const end = findJsonStringEnd(text);
         return end >= 0 && text[end + 1] === ':' ? end + 1 : -1;
     }
     return text.indexOf(':');
 }
-
-function findJsonStringEnd(text: string): number {
+function findJsonStringEnd(text) {
     let escaped = false;
     for (let index = 1; index < text.length; index += 1) {
         const char = text[index];
@@ -1198,8 +973,7 @@ function findJsonStringEnd(text: string): number {
     }
     return -1;
 }
-
-function parseKey(text: string, lineNumber: number): string {
+function parseKey(text, lineNumber) {
     if (!text.startsWith('"')) {
         return text;
     }
@@ -1208,13 +982,13 @@ function parseKey(text: string, lineNumber: number): string {
         if (typeof parsed === 'string') {
             return parsed;
         }
-    } catch {
+    }
+    catch {
         // Fall through to the consistent parser error below.
     }
     throw new Error(`line ${lineNumber}: invalid quoted key`);
 }
-
-function parseInlineValue(text: string, lineNumber: number): YamlValue {
+function parseInlineValue(text, lineNumber) {
     if (text === '[]') {
         return [];
     }
@@ -1236,7 +1010,8 @@ function parseInlineValue(text: string, lineNumber: number): YamlValue {
             if (typeof parsed === 'string') {
                 return parsed;
             }
-        } catch {
+        }
+        catch {
             // Fall through to the consistent parser error below.
         }
         throw new Error(`line ${lineNumber}: invalid quoted scalar`);
@@ -1246,8 +1021,7 @@ function parseInlineValue(text: string, lineNumber: number): YamlValue {
     }
     return text;
 }
-
-function parseMetadata(value: YamlValue | undefined): CircuitDocument['metadata'] {
+function parseMetadata(value) {
     const metadata = optionalObject(value, 'metadata');
     return {
         name: scalarText(metadata.name),
@@ -1255,46 +1029,34 @@ function parseMetadata(value: YamlValue | undefined): CircuitDocument['metadata'
         partNumber: scalarText(metadata.partNumber),
     };
 }
-
-function parseSource(value: YamlValue | undefined): DocumentSource {
+function parseSource(value) {
     return parseStringRecord(value, 'source');
 }
-
-function parsePanel(value: YamlValue | undefined, allowV3PhysicalFields: boolean): PanelPlacementMetadata | undefined {
+function parsePanel(value, allowV3PhysicalFields) {
     if (value === undefined) {
         return undefined;
     }
     const panel = expectObject(value, 'panel');
-
     if (panel.faces !== undefined) {
         return {
-            faces: optionalArray(panel.faces, 'panel.faces').map((item, index) =>
-                parsePanelFace(item, index, allowV3PhysicalFields)
-            ),
+            faces: optionalArray(panel.faces, 'panel.faces').map((item, index) => parsePanelFace(item, index, allowV3PhysicalFields)),
         };
     }
-
     if (panel.layout === undefined) {
         return undefined;
     }
-
     const layout = parsePanelLayout(panel.layout, 'panel.layout');
     const elementsValue = panel.controls ?? panel.elements;
     const elementsPath = panel.controls === undefined ? 'panel.elements' : 'panel.controls';
     return {
         faces: [{
-            id: 'top',
-            layout,
-            elements: parsePanelElements(elementsValue, layout, elementsPath, allowV3PhysicalFields),
-        }],
+                id: 'top',
+                layout,
+                elements: parsePanelElements(elementsValue, layout, elementsPath, allowV3PhysicalFields),
+            }],
     };
 }
-
-function parsePanelFace(
-    value: YamlValue,
-    index: number,
-    allowV3PhysicalFields: boolean,
-): PanelPlacementMetadata['faces'][number] {
+function parsePanelFace(value, index, allowV3PhysicalFields) {
     const path = `panel.faces[${index}]`;
     const face = expectObject(value, path);
     const label = parseOptionalString(face.label, `${path}.label`);
@@ -1311,8 +1073,7 @@ function parsePanelFace(
         elements: parsePanelElements(face.elements, layout, `${path}.elements`, allowV3PhysicalFields),
     };
 }
-
-function parsePanelLayout(value: YamlValue | undefined, path: string): PanelGridLayout {
+function parsePanelLayout(value, path) {
     const layout = expectObject(value, path);
     const rowOrder = parseOptionalPanelRowOrder(layout.rowOrder, `${path}.rowOrder`);
     const columnOrder = parseOptionalPanelColumnOrder(layout.columnOrder, `${path}.columnOrder`);
@@ -1325,13 +1086,7 @@ function parsePanelLayout(value: YamlValue | undefined, path: string): PanelGrid
         ...(columnOrder === undefined ? {} : { columnOrder }),
     };
 }
-
-function parsePanelElements(
-    value: YamlValue | undefined,
-    layout: PanelGridLayout,
-    path: string,
-    allowV3PhysicalFields: boolean,
-): PanelPlacementMetadata['faces'][number]['elements'] {
+function parsePanelElements(value, layout, path, allowV3PhysicalFields) {
     return optionalArray(value, path).map((item, index) => {
         const elementPath = `${path}[${index}]`;
         const element = expectObject(item, elementPath);
@@ -1350,12 +1105,9 @@ function parsePanelElements(
         return {
             ...(id === undefined ? {} : { id }),
             bind: parsePanelElementBinding(element, elementPath),
-            kind: parsePanelControlKind(
-                element.kind ?? element.controlKind,
-                element.kind === undefined && element.controlKind !== undefined
-                    ? `${elementPath}.controlKind`
-                    : `${elementPath}.kind`,
-            ),
+            kind: parsePanelControlKind(element.kind ?? element.controlKind, element.kind === undefined && element.controlKind !== undefined
+                ? `${elementPath}.controlKind`
+                : `${elementPath}.kind`),
             grid: parsePanelGridPosition(element.grid, `${elementPath}.grid`, layout),
             ...(label === undefined ? {} : { label }),
             ...(interfaceControlId === undefined ? {} : { interfaceControlId }),
@@ -1363,11 +1115,7 @@ function parsePanelElements(
         };
     });
 }
-
-function parseOptionalPanelFaceGeometry(
-    value: YamlValue | undefined,
-    path: string,
-): PanelFaceGeometry | undefined {
+function parseOptionalPanelFaceGeometry(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -1381,11 +1129,7 @@ function parseOptionalPanelFaceGeometry(
             : { usableRectMm: parseMillimeterRect(geometry.usableRectMm, `${path}.usableRectMm`) }),
     };
 }
-
-function parseOptionalPanelElementPhysical(
-    value: YamlValue | undefined,
-    path: string,
-): PanelElementPhysicalPlacement | undefined {
+function parseOptionalPanelElementPhysical(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -1403,8 +1147,7 @@ function parseOptionalPanelElementPhysical(
         ...(physical.locked === undefined ? {} : { locked: expectBoolean(physical.locked, `${path}.locked`) }),
     };
 }
-
-function parseMillimeterRect(value: YamlValue | undefined, path: string) {
+function parseMillimeterRect(value, path) {
     const rect = expectObject(value, path);
     return {
         x: expectNumber(rect.x, `${path}.x`),
@@ -1413,8 +1156,7 @@ function parseMillimeterRect(value: YamlValue | undefined, path: string) {
         height: expectNumber(rect.height, `${path}.height`),
     };
 }
-
-function parsePanelElementBinding(element: YamlObject, path: string): PanelElementBinding {
+function parsePanelElementBinding(element, path) {
     if (element.bind !== undefined) {
         const bind = expectObject(element.bind, `${path}.bind`);
         const controlId = parseOptionalString(bind.controlId, `${path}.bind.controlId`);
@@ -1427,17 +1169,11 @@ function parsePanelElementBinding(element: YamlObject, path: string): PanelEleme
             ...(property === undefined ? {} : { property }),
         };
     }
-
     return {
         componentId: expectString(element.componentId, `${path}.componentId`),
     };
 }
-
-function parsePanelGridPosition(
-    value: YamlValue | undefined,
-    path: string,
-    layout: PanelGridLayout,
-): PanelGridPosition {
+function parsePanelGridPosition(value, path, layout) {
     const grid = expectObject(value, path);
     const rowSpan = parseOptionalPositiveInteger(grid.rowSpan, `${path}.rowSpan`);
     const columnSpan = parseOptionalPositiveInteger(grid.columnSpan, `${path}.columnSpan`);
@@ -1452,15 +1188,7 @@ function parsePanelGridPosition(
         ...(columnSpan === undefined ? {} : { columnSpan }),
     };
 }
-
-function validateGridAxis(
-    value: number,
-    span: number,
-    size: number,
-    indexing: PanelGridIndexing,
-    path: string,
-    axisName: 'row' | 'column',
-): void {
+function validateGridAxis(value, span, size, indexing, path, axisName) {
     const min = indexing === 'one-based' ? 1 : 0;
     const occupiedEnd = indexing === 'one-based' ? value + span - 1 : value + span;
     if (value < min || occupiedEnd > size) {
@@ -1468,24 +1196,21 @@ function validateGridAxis(
         throw new Error(`${path}: expected ${indexing} ${axisName} coordinate within ${min}..${maxLabel}`);
     }
 }
-
-function parsePanelLayoutKind(value: YamlValue | undefined, path: string): 'stompbox-grid' {
+function parsePanelLayoutKind(value, path) {
     const kind = expectString(value, path);
     if (kind === 'stompbox-grid') {
         return kind;
     }
     throw new Error(`${path}: expected stompbox-grid`);
 }
-
-function parsePanelGridIndexing(value: YamlValue | undefined, path: string): PanelGridIndexing {
+function parsePanelGridIndexing(value, path) {
     const indexing = expectString(value, path);
     if (indexing === 'one-based' || indexing === 'zero-based') {
         return indexing;
     }
     throw new Error(`${path}: expected one-based or zero-based`);
 }
-
-function parseOptionalPanelRowOrder(value: YamlValue | undefined, path: string): PanelRowOrder | undefined {
+function parseOptionalPanelRowOrder(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -1495,8 +1220,7 @@ function parseOptionalPanelRowOrder(value: YamlValue | undefined, path: string):
     }
     throw new Error(`${path}: expected top-to-bottom or bottom-to-top`);
 }
-
-function parseOptionalPanelColumnOrder(value: YamlValue | undefined, path: string): PanelColumnOrder | undefined {
+function parseOptionalPanelColumnOrder(value, path) {
     if (value === undefined) {
         return undefined;
     }
@@ -1506,8 +1230,7 @@ function parseOptionalPanelColumnOrder(value: YamlValue | undefined, path: strin
     }
     throw new Error(`${path}: expected left-to-right or right-to-left`);
 }
-
-function parsePanelControlKind(value: YamlValue | undefined, path: string): PanelControlKind {
+function parsePanelControlKind(value, path) {
     const kind = expectString(value, path);
     switch (kind) {
         case 'knob':
@@ -1522,8 +1245,7 @@ function parsePanelControlKind(value: YamlValue | undefined, path: string): Pane
             throw new Error(`${path}: expected knob, slider, switch, selector, footswitch, led, or jack`);
     }
 }
-
-function parseComponents(value: YamlValue | undefined): readonly Component[] {
+function parseComponents(value) {
     return optionalArray(value, 'components').map((item, index) => {
         const path = `components[${index}]`;
         const component = expectObject(item, path);
@@ -1540,8 +1262,7 @@ function parseComponents(value: YamlValue | undefined): readonly Component[] {
         };
     });
 }
-
-function parseTerminals(value: YamlValue | undefined, path: string): readonly Terminal[] {
+function parseTerminals(value, path) {
     return optionalArray(value, path).map((item, index) => {
         const terminalPath = `${path}[${index}]`;
         const terminal = expectObject(item, terminalPath);
@@ -1551,17 +1272,15 @@ function parseTerminals(value: YamlValue | undefined, path: string): readonly Te
         };
     });
 }
-
-function parseProperties(value: YamlValue | undefined, path: string): Readonly<Record<string, PropertyValue>> {
+function parseProperties(value, path) {
     const properties = optionalObject(value, path);
-    const out: Record<string, PropertyValue> = {};
+    const out = {};
     for (const [key, child] of Object.entries(properties)) {
         out[key] = parsePropertyValue(child, `${path}.${key}`);
     }
     return out;
 }
-
-function parsePropertyValue(value: YamlValue, path: string): PropertyValue {
+function parsePropertyValue(value, path) {
     if (isParsedQuantityValue(value)) {
         return {
             raw: expectString(value.raw, `${path}.raw`),
@@ -1573,7 +1292,7 @@ function parsePropertyValue(value: YamlValue, path: string): PropertyValue {
         return value.map((item, index) => parsePropertyValue(item, `${path}[${index}]`));
     }
     if (isYamlObject(value)) {
-        const out: Record<string, PropertyValue> = {};
+        const out = {};
         for (const [key, child] of Object.entries(value)) {
             out[key] = parsePropertyValue(child, `${path}.${key}`);
         }
@@ -1584,12 +1303,10 @@ function parsePropertyValue(value: YamlValue, path: string): PropertyValue {
     }
     throw new Error(`${path}: expected scalar property value or parsed quantity`);
 }
-
-function isParsedQuantityValue(value: YamlValue): value is ParsedQuantity {
+function isParsedQuantityValue(value) {
     return isParsedQuantity(value);
 }
-
-function parseWires(value: YamlValue | undefined): readonly Wire[] {
+function parseWires(value) {
     return optionalArray(value, 'wires').map((item, index) => {
         const path = `wires[${index}]`;
         const wire = expectObject(item, path);
@@ -1605,12 +1322,11 @@ function parseWires(value: YamlValue | undefined): readonly Wire[] {
         };
     });
 }
-
-function parseWarnings(value: YamlValue | undefined): readonly Warning[] {
+function parseWarnings(value) {
     return optionalArray(value, 'diagnostics').map((item, index) => {
         const path = `diagnostics[${index}]`;
         const warning = expectObject(item, path);
-        const out: Warning = {
+        const out = {
             code: expectString(warning.code, `${path}.code`),
             message: expectString(warning.message, `${path}.message`),
             ...(warning.componentId === undefined
@@ -1623,44 +1339,38 @@ function parseWarnings(value: YamlValue | undefined): readonly Warning[] {
         return out;
     });
 }
-
-function parseStringArray(value: YamlValue | undefined, path: string): readonly string[] {
+function parseStringArray(value, path) {
     return optionalArray(value, path).map((item, index) => scalarText(item, `${path}[${index}]`));
 }
-
-function parseStringRecord(value: YamlValue | undefined, path: string): Readonly<Record<string, string>> {
+function parseStringRecord(value, path) {
     const record = optionalObject(value, path);
-    const out: Record<string, string> = {};
+    const out = {};
     for (const [key, child] of Object.entries(record)) {
         out[key] = scalarText(child, `${path}.${key}`);
     }
     return out;
 }
-
-function parsePoint(value: YamlValue | undefined, path: string): Point {
+function parsePoint(value, path) {
     const point = expectObject(value, path);
     return {
         x: expectNumber(point.x, `${path}.x`),
         y: expectNumber(point.y, `${path}.y`),
     };
 }
-
-function parseRotation(value: YamlValue | undefined, path: string): Rotation {
+function parseRotation(value, path) {
     const rotation = expectNumber(value, path);
     if (rotation === 0 || rotation === 1 || rotation === 2 || rotation === 3) {
         return rotation;
     }
     throw new Error(`${path}: expected rotation 0, 1, 2, or 3`);
 }
-
-function parseNullableString(value: YamlValue | undefined, path: string): string | null {
+function parseNullableString(value, path) {
     if (value === null || value === undefined) {
         return null;
     }
     return expectString(value, path);
 }
-
-function parseComponentKind(value: YamlValue | undefined, path: string): ComponentKind {
+function parseComponentKind(value, path) {
     const kind = expectString(value, path);
     switch (kind) {
         case 'resistor':
@@ -1703,108 +1413,93 @@ function parseComponentKind(value: YamlValue | undefined, path: string): Compone
             throw new Error(`${path}: unsupported component kind "${kind}"`);
     }
 }
-
-function optionalObject(value: YamlValue | undefined, path: string): YamlObject {
+function optionalObject(value, path) {
     if (value === undefined) {
         return {};
     }
     return expectObject(value, path);
 }
-
-function optionalArray(value: YamlValue | undefined, path: string): readonly YamlValue[] {
+function optionalArray(value, path) {
     if (value === undefined) {
         return [];
     }
     return expectArray(value, path);
 }
-
-function expectObject(value: YamlValue | undefined, path: string): YamlObject {
+function expectObject(value, path) {
     if (isYamlObject(value)) {
         return value;
     }
     throw new Error(`${path}: expected object`);
 }
-
-function expectArray(value: YamlValue | undefined, path: string): readonly YamlValue[] {
+function expectArray(value, path) {
     if (Array.isArray(value)) {
         return value;
     }
     throw new Error(`${path}: expected array`);
 }
-
-function expectString(value: YamlValue | undefined, path: string): string {
+function expectString(value, path) {
     if (typeof value === 'string') {
         return value;
     }
     throw new Error(`${path}: expected string`);
 }
-
-function expectNumber(value: YamlValue | undefined, path: string): number {
+function expectNumber(value, path) {
     if (typeof value === 'number' && Number.isFinite(value)) {
         return value;
     }
     throw new Error(`${path}: expected number`);
 }
-
-function expectPositiveInteger(value: YamlValue | undefined, path: string): number {
+function expectPositiveInteger(value, path) {
     const number = expectNumber(value, path);
     if (Number.isInteger(number) && number > 0) {
         return number;
     }
     throw new Error(`${path}: expected positive integer`);
 }
-
-function expectNonNegativeInteger(value: YamlValue | undefined, path: string): number {
+function expectNonNegativeInteger(value, path) {
     const number = expectNumber(value, path);
     if (Number.isInteger(number) && number >= 0) {
         return number;
     }
     throw new Error(`${path}: expected non-negative integer`);
 }
-
-function parseOptionalPositiveInteger(value: YamlValue | undefined, path: string): number | undefined {
+function parseOptionalPositiveInteger(value, path) {
     if (value === undefined) {
         return undefined;
     }
     return expectPositiveInteger(value, path);
 }
-
-function parseOptionalNumber(value: YamlValue | undefined, path: string): number | undefined {
+function parseOptionalNumber(value, path) {
     if (value === undefined) {
         return undefined;
     }
     return expectNumber(value, path);
 }
-
-function parseOptionalString(value: YamlValue | undefined, path: string): string | undefined {
+function parseOptionalString(value, path) {
     if (value === undefined) {
         return undefined;
     }
     return expectString(value, path);
 }
-
-function parseOptionalStringArray(value: YamlValue | undefined, path: string): readonly string[] | undefined {
+function parseOptionalStringArray(value, path) {
     if (value === undefined) {
         return undefined;
     }
     return expectArray(value, path).map((item, index) => expectString(item, `${path}[${index}]`));
 }
-
-function parseOptionalBoolean(value: YamlValue | undefined, path: string): boolean | undefined {
+function parseOptionalBoolean(value, path) {
     if (value === undefined) {
         return undefined;
     }
     return expectBoolean(value, path);
 }
-
-function expectBoolean(value: YamlValue | undefined, path: string): boolean {
+function expectBoolean(value, path) {
     if (typeof value === 'boolean') {
         return value;
     }
     throw new Error(`${path}: expected boolean`);
 }
-
-function scalarText(value: YamlValue | undefined, path = 'value'): string {
+function scalarText(value, path = 'value') {
     if (value === undefined || value === null) {
         return '';
     }
@@ -1813,11 +1508,10 @@ function scalarText(value: YamlValue | undefined, path = 'value'): string {
     }
     throw new Error(`${path}: expected scalar`);
 }
-
-function isScalar(value: YamlValue): value is YamlScalar {
+function isScalar(value) {
     return value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
 }
-
-function isYamlObject(value: YamlValue | undefined): value is YamlObject {
+function isYamlObject(value) {
     return value !== undefined && value !== null && typeof value === 'object' && !Array.isArray(value);
 }
+//# sourceMappingURL=parser.js.map