schematex 0.9.17 → 0.9.19

package/dist/{chunk-24YHD4YI.cjs → chunk-JXPBZEFM.cjs}

@@ -1460,6 +1460,7 @@ var SYMBOLS = {
   voltmeter,
   wattmeter,
   motor,
+  lamp,
   speaker,
   microphone,
   buzzer,
@@ -1521,14 +1522,9 @@ var SYMBOLS = {
   switch_dpdt,
   oscilloscope,
   port
-  // Lamp reuses buzzer slot? No, needs its own entry but our CircuitComponentType
-  // doesn't have "lamp". We map it via parser alias to "buzzer" or add specifically.
-};
-var EXTRA_SYMBOLS = {
-  lamp
 };
 function getSymbol(t) {
-  return SYMBOLS[t] ?? EXTRA_SYMBOLS[t];
+  return SYMBOLS[t];
 }
 function getNetlistPinOrder(t) {
   const sym = getSymbol(t);
@@ -1592,7 +1588,10 @@ var TYPE_ALIASES = {
   wireduct: "wire_duct",
   wire_duct: "wire_duct",
   trunking: "wire_duct",
-  plc: "plc"
+  plc: "plc",
+  lamp: "lamp",
+  light: "lamp",
+  bulb: "lamp"
 };
 var GROUND_REF = /^(0|gnd|ground|earth|pe|agnd|dgnd|gnda|gndd|vss|com)(_\w+|\d+)?$/i;
 function isGroundRef(s) {
@@ -1656,7 +1655,7 @@ function parseNetlist(body, title2) {
   for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
     const raw = lines[lineIdx];
     if (/^\s*\*/.test(raw)) continue;
-    const stripped = raw.replace(/#.*$/, "").trim();
+    const stripped = raw.replace(/[#;].*$/, "").trim();
     if (!stripped) continue;
     const tokens = tokenize(stripped);
     if (tokens.length < 2) {
@@ -1887,6 +1886,7 @@ var COMPONENT_TYPES = /* @__PURE__ */ new Set([
   "thermal_overload",
   "disconnect_switch",
   "motor",
+  "lamp",
   "speaker",
   "microphone",
   "buzzer",
@@ -1951,18 +1951,16 @@ var ALIASES = {
   overload: "thermal_overload",
   thermal: "thermal_overload",
   disconnect: "disconnect_switch",
-  isolator: "disconnect_switch"
+  isolator: "disconnect_switch",
+  light: "lamp",
+  bulb: "lamp"
 };
-var EXTRA_TYPES = /* @__PURE__ */ new Set(["lamp"]);
 function normalizeType(raw) {
   const lower = raw.toLowerCase();
   if (ALIASES[lower]) return ALIASES[lower];
   if (COMPONENT_TYPES.has(lower)) {
     return lower;
   }
-  if (EXTRA_TYPES.has(lower)) {
-    return lower;
-  }
   return null;
 }
 var DIRECTIONS = /* @__PURE__ */ new Set(["right", "left", "up", "down"]);
@@ -2021,12 +2019,12 @@ function parseAttrs(rest) {
 }
 function parseCircuit(text2) {
   const rawLines = text2.split("\n");
-  const firstMeaningful = rawLines.map((l) => l.replace(/#.*$/, "").trim()).find((l) => l.length > 0) ?? "";
+  const firstMeaningful = rawLines.map((l) => l.replace(/[#;].*$/, "").trim()).find((l) => l.length > 0) ?? "";
   if (/^circuit\b.*\bnetlist\s*$/i.test(firstMeaningful)) {
     const netlistTitle = chunkVHDSPI6A_cjs.matchQuotedTitle(firstMeaningful);
     let headerIdx = -1;
     for (let i = 0; i < rawLines.length; i++) {
-      const s = rawLines[i].replace(/#.*$/, "").trim();
+      const s = rawLines[i].replace(/[#;].*$/, "").trim();
       if (s.length > 0) {
         headerIdx = i;
         break;
@@ -2044,7 +2042,7 @@ function parseCircuit(text2) {
   let pendingAt;
   const mkId = (prefix) => `${prefix}_${autoId++}`;
   for (const rawLine of lines) {
-    const stripped = rawLine.replace(/#.*$/, "").trim();
+    const stripped = rawLine.replace(/[#;].*$/, "").trim();
     if (!stripped) continue;
     if (/^circuit\b/i.test(stripped)) {
       const t = chunkVHDSPI6A_cjs.matchQuotedTitle(stripped);
@@ -2143,7 +2141,9 @@ function parseCircuit(text2) {
       const typeStr = bareMatch[1];
       const norm = normalizeType(typeStr);
       if (!norm) {
-        continue;
+        throw new CircuitParseError(
+          `Unknown component type: "${typeStr}". For SPICE-style connectivity (Id net1 net2 [value]), start the diagram with the \`netlist\` header: circuit "..." netlist.`
+        );
       }
       const rest = bareMatch[2] ?? "";
       const parsed = parseAttrs(rest);
@@ -2472,6 +2472,11 @@ var ROW_H = 80;
 var LEFT_MARGIN = 70;
 var TOP_MARGIN = 56;
 var SHUNT_OFFSET = 28;
+var AC_LEFT_MARGIN = 96;
+var AC_LIVE_Y = 56;
+var AC_RETURN_Y = 150;
+var AC_SERIES_GAP = 58;
+var AC_TRAVELER_SPAN = 128;
 function isPowerSource(c) {
   return c.componentType === "voltage_source" || c.componentType === "current_source" || c.componentType === "ac_source" || c.componentType === "battery" || c.componentType === "vcc";
 }
@@ -2498,8 +2503,334 @@ function extendBBox(bbox, pt) {
   if (pt.x > bbox.maxX) bbox.maxX = pt.x;
   if (pt.y > bbox.maxY) bbox.maxY = pt.y;
 }
+function placeComponent(comp, x, y, fallbackDir) {
+  const direction = comp.attrs?.dirExplicit === "true" ? comp.direction : fallbackDir ?? defaultDirection(comp);
+  comp.direction = direction;
+  const rot = rotationOf(direction);
+  const sym = getSymbol(comp.componentType);
+  const worldAnchors = {};
+  if (sym) {
+    for (const [name, pt] of Object.entries(sym.anchors)) {
+      const rp = rotatePt(pt, rot);
+      worldAnchors[name] = { x: x + rp.x, y: y + rp.y };
+    }
+  } else {
+    worldAnchors.start = { x, y };
+    worldAnchors.end = { x: x + 30, y };
+  }
+  return {
+    component: comp,
+    x,
+    y,
+    rotation: rot,
+    length: sym?.length ?? 30,
+    anchors: worldAnchors
+  };
+}
+function placeMirroredComponent(comp, x, y) {
+  const sym = getSymbol(comp.componentType);
+  const length = sym?.length ?? 30;
+  const worldAnchors = {};
+  comp.direction = "left";
+  if (sym) {
+    for (const [name, pt] of Object.entries(sym.anchors)) {
+      worldAnchors[name] = { x: x + length - pt.x, y: y + pt.y };
+    }
+  } else {
+    worldAnchors.start = { x: x + length, y };
+    worldAnchors.end = { x, y };
+  }
+  return {
+    component: comp,
+    x,
+    y,
+    rotation: 0,
+    mirrorX: true,
+    length,
+    anchors: worldAnchors
+  };
+}
+function pinEntries(pinMap, comp) {
+  return Object.entries(pinMap[comp.id] ?? {});
+}
+function anchorForNet(pinMap, laid, netId) {
+  const pin = Object.entries(pinMap[laid.component.id] ?? {}).find(
+    ([, net]) => net === netId
+  )?.[0];
+  return pin ? laid.anchors[pin] : void 0;
+}
+function compactPoints(points) {
+  const out = [];
+  for (const p of points) {
+    const prev = out[out.length - 1];
+    if (!prev || Math.abs(prev.x - p.x) > 0.5 || Math.abs(prev.y - p.y) > 0.5) {
+      out.push(p);
+    }
+  }
+  return out;
+}
+function routeViaY(netId, a, b, y) {
+  if (Math.abs(a.y - b.y) < 0.5) return { netId, points: [a, b] };
+  return {
+    netId,
+    points: compactPoints([a, { x: a.x, y }, { x: b.x, y }, b])
+  };
+}
+function routeViaX(netId, a, b, x) {
+  if (Math.abs(a.x - b.x) < 0.5) return { netId, points: [a, b] };
+  return {
+    netId,
+    points: compactPoints([a, { x, y: a.y }, { x, y: b.y }, b])
+  };
+}
+function isAutoGround(c) {
+  return isGround(c) && c.attrs?.auto === "true";
+}
+function isTwoTerminal(pinMap, comp) {
+  return pinEntries(pinMap, comp).length === 2;
+}
+function isLightingLoad(c) {
+  return c.componentType === "lamp" || c.componentType === "pilot_light" || c.componentType === "motor" || c.componentType === "buzzer" || c.componentType === "speaker";
+}
+function traceTwoTerminalChain(pinMap, candidates, startNet, endNet) {
+  const remaining = new Set(candidates.map((c) => c.id));
+  const steps = [];
+  const seenNets = /* @__PURE__ */ new Set([startNet]);
+  let current = startNet;
+  for (let guard = 0; guard <= candidates.length; guard++) {
+    if (current === endNet) return { steps, used: new Set(steps.map((s) => s.comp.id)) };
+    const hits = candidates.filter((c) => {
+      if (!remaining.has(c.id) || !isTwoTerminal(pinMap, c)) return false;
+      return pinEntries(pinMap, c).some(([, net]) => net === current);
+    });
+    if (hits.length !== 1) return null;
+    const comp = hits[0];
+    const nets = pinEntries(pinMap, comp).map(([, net]) => net);
+    const next = nets[0] === current ? nets[1] : nets[0];
+    if (!next || seenNets.has(next) && next !== endNet) return null;
+    steps.push({ comp, inNet: current, outNet: next });
+    remaining.delete(comp.id);
+    seenNets.add(next);
+    current = next;
+  }
+  return null;
+}
+function finalizeAutoLayout(items, routes) {
+  const bbox = {
+    minX: Infinity,
+    minY: Infinity,
+    maxX: -Infinity,
+    maxY: -Infinity
+  };
+  for (const it of items) {
+    for (const a of Object.values(it.anchors)) extendBBox(bbox, a);
+  }
+  for (const r of routes) {
+    for (const p of r.points) extendBBox(bbox, p);
+  }
+  if (!isFinite(bbox.minX)) {
+    bbox.minX = 0;
+    bbox.minY = 0;
+    bbox.maxX = 200;
+    bbox.maxY = 200;
+  }
+  const pad = 52;
+  const minX = bbox.minX - pad;
+  const minY = bbox.minY - pad;
+  const maxX = bbox.maxX + pad;
+  const maxY = bbox.maxY + pad;
+  return {
+    width: maxX - minX,
+    height: maxY - minY,
+    offsetX: -minX,
+    offsetY: -minY,
+    items,
+    routes
+  };
+}
+function appendReturnRail(routes, pinMap, sourceLaid, loadLaid, returnNet) {
+  const sourceReturn = anchorForNet(pinMap, sourceLaid, returnNet);
+  const loadReturn = anchorForNet(pinMap, loadLaid, returnNet);
+  if (!sourceReturn || !loadReturn) return false;
+  routes.push({
+    netId: returnNet,
+    points: [
+      { x: sourceReturn.x, y: AC_RETURN_Y },
+      { x: loadReturn.x, y: AC_RETURN_Y }
+    ]
+  });
+  routes.push({
+    netId: `${returnNet}.${sourceLaid.component.id}`,
+    points: compactPoints([sourceReturn, { x: sourceReturn.x, y: AC_RETURN_Y }])
+  });
+  routes.push({
+    netId: `${returnNet}.${loadLaid.component.id}`,
+    points: compactPoints([loadReturn, { x: loadReturn.x, y: AC_RETURN_Y }])
+  });
+  return true;
+}
+function sourceLiveReturnNets(pinMap, source) {
+  const pins = pinMap[source.id];
+  if (!pins) return null;
+  const liveNet = pins.plus ?? pins.end ?? Object.values(pins)[0];
+  const returnNet = pins.minus ?? pins.start ?? Object.values(pins)[1];
+  if (!liveNet || !returnNet || liveNet === returnNet) return null;
+  return { liveNet, returnNet };
+}
+function layoutTwoWireSeriesLoop(ast, source, chain, load, liveNet, returnNet, loadLiveNet) {
+  const pinMap = ast.pinMap ?? {};
+  const items = [];
+  const routes = [];
+  const put = (comp, x, y, fallbackDir) => {
+    const laid = placeComponent(comp, x, y, fallbackDir);
+    items.push(laid);
+    return laid;
+  };
+  const sourceLaid = put(source, AC_LEFT_MARGIN, AC_LIVE_Y + 62, "up");
+  let cursorX = AC_LEFT_MARGIN + 86;
+  let prevPt = anchorForNet(pinMap, sourceLaid, liveNet);
+  if (!prevPt) return null;
+  for (const step of chain) {
+    const laid = put(step.comp, cursorX, AC_LIVE_Y, "right");
+    const inPt = anchorForNet(pinMap, laid, step.inNet);
+    const outPt = anchorForNet(pinMap, laid, step.outNet);
+    if (!inPt || !outPt) return null;
+    routes.push(routeViaY(step.inNet, prevPt, inPt, AC_LIVE_Y));
+    prevPt = outPt;
+    cursorX += laid.length + AC_SERIES_GAP;
+  }
+  const loadLaid = put(load, cursorX, AC_LIVE_Y, "right");
+  const loadLive = anchorForNet(pinMap, loadLaid, loadLiveNet);
+  if (!loadLive) return null;
+  routes.push(routeViaY(loadLiveNet, prevPt, loadLive, AC_LIVE_Y));
+  if (!appendReturnRail(routes, pinMap, sourceLaid, loadLaid, returnNet)) return null;
+  return finalizeAutoLayout(items, routes);
+}
+function layoutTwoWayLightingLoop(ast, source, preChain, leftSwitch, rightSwitch, postChain, load, liveNet, returnNet, loadLiveNet) {
+  const pinMap = ast.pinMap ?? {};
+  const leftPins = pinMap[leftSwitch.id] ?? {};
+  const rightPins = pinMap[rightSwitch.id] ?? {};
+  const travelerNets = [leftPins.nc, leftPins.no].filter(Boolean);
+  if (travelerNets.length !== 2 || !travelerNets.every((n) => n === rightPins.nc || n === rightPins.no)) {
+    return null;
+  }
+  const items = [];
+  const routes = [];
+  const put = (comp, x, y, fallbackDir) => {
+    const laid = placeComponent(comp, x, y, fallbackDir);
+    items.push(laid);
+    return laid;
+  };
+  const sourceLaid = put(source, AC_LEFT_MARGIN, AC_LIVE_Y + 62, "up");
+  let cursorX = AC_LEFT_MARGIN + 86;
+  let prevPt = anchorForNet(pinMap, sourceLaid, liveNet);
+  if (!prevPt) return null;
+  for (const step of preChain) {
+    const laid = put(step.comp, cursorX, AC_LIVE_Y, "right");
+    const inPt = anchorForNet(pinMap, laid, step.inNet);
+    const outPt = anchorForNet(pinMap, laid, step.outNet);
+    if (!inPt || !outPt) return null;
+    routes.push(routeViaY(step.inNet, prevPt, inPt, AC_LIVE_Y));
+    prevPt = outPt;
+    cursorX += laid.length + AC_SERIES_GAP;
+  }
+  const leftLaid = put(leftSwitch, cursorX, AC_LIVE_Y, "right");
+  const leftCommon = leftLaid.anchors.common;
+  if (!leftCommon) return null;
+  routes.push(routeViaY(leftPins.common ?? liveNet, prevPt, leftCommon, AC_LIVE_Y));
+  const rightCommonX = leftLaid.x + leftLaid.length + AC_TRAVELER_SPAN + leftLaid.length;
+  const sameTravelerOrder = leftPins.nc === rightPins.nc && leftPins.no === rightPins.no;
+  const rightLength = getSymbol(rightSwitch.componentType)?.length ?? 30;
+  const rightLaid = sameTravelerOrder ? placeMirroredComponent(rightSwitch, rightCommonX - rightLength, AC_LIVE_Y) : placeComponent(rightSwitch, rightCommonX, AC_LIVE_Y, "left");
+  items.push(rightLaid);
+  for (const net of travelerNets) {
+    const a = anchorForNet(pinMap, leftLaid, net);
+    const b = anchorForNet(pinMap, rightLaid, net);
+    if (!a || !b) return null;
+    routes.push(routeViaX(net, a, b, (a.x + b.x) / 2));
+  }
+  prevPt = rightLaid.anchors.common;
+  if (!prevPt) return null;
+  cursorX = rightCommonX + AC_SERIES_GAP;
+  for (const step of postChain) {
+    const laid = put(step.comp, cursorX, AC_LIVE_Y, "right");
+    const inPt = anchorForNet(pinMap, laid, step.inNet);
+    const outPt = anchorForNet(pinMap, laid, step.outNet);
+    if (!inPt || !outPt) return null;
+    routes.push(routeViaY(step.inNet, prevPt, inPt, AC_LIVE_Y));
+    prevPt = outPt;
+    cursorX += laid.length + AC_SERIES_GAP;
+  }
+  const loadLaid = put(load, cursorX, AC_LIVE_Y, "right");
+  const loadLive = anchorForNet(pinMap, loadLaid, loadLiveNet);
+  if (!loadLive) return null;
+  routes.push(routeViaY(loadLiveNet, prevPt, loadLive, AC_LIVE_Y));
+  if (!appendReturnRail(routes, pinMap, sourceLaid, loadLaid, returnNet)) return null;
+  return finalizeAutoLayout(items, routes);
+}
+function tryLayoutTwoWireLighting(ast) {
+  const pinMap = ast.pinMap ?? {};
+  const sources = ast.components.filter(isPowerSource);
+  if (sources.length !== 1) return null;
+  const source = sources[0];
+  const nets = sourceLiveReturnNets(pinMap, source);
+  if (!nets || nets.liveNet === "GND" || nets.returnNet === "GND") return null;
+  const { liveNet, returnNet } = nets;
+  const loads = ast.components.filter((c) => {
+    if (!isLightingLoad(c)) return false;
+    const pins = pinEntries(pinMap, c);
+    return pins.length === 2 && pins.some(([, net]) => net === returnNet);
+  });
+  if (loads.length !== 1) return null;
+  const load = loads[0];
+  const loadLiveNet = pinEntries(pinMap, load).find(([, net]) => net !== returnNet)?.[1];
+  if (!loadLiveNet) return null;
+  const excluded = /* @__PURE__ */ new Set([source.id, load.id]);
+  const middle = ast.components.filter((c) => !excluded.has(c.id) && !isAutoGround(c));
+  const spdts = middle.filter((c) => c.componentType === "switch_spdt");
+  if (spdts.length === 0) {
+    if (!middle.every((c) => isTwoTerminal(pinMap, c))) return null;
+    const traced = traceTwoTerminalChain(pinMap, middle, liveNet, loadLiveNet);
+    if (!traced || traced.used.size !== middle.length) return null;
+    return layoutTwoWireSeriesLoop(ast, source, traced.steps, load, liveNet, returnNet, loadLiveNet);
+  }
+  if (spdts.length === 2) {
+    const twoTerminal = middle.filter((c) => c.componentType !== "switch_spdt");
+    if (!twoTerminal.every((c) => isTwoTerminal(pinMap, c))) return null;
+    for (const [leftSwitch, rightSwitch] of [
+      [spdts[0], spdts[1]],
+      [spdts[1], spdts[0]]
+    ]) {
+      const leftCommon = pinMap[leftSwitch.id]?.common;
+      const rightCommon = pinMap[rightSwitch.id]?.common;
+      if (!leftCommon || !rightCommon) continue;
+      const pre = traceTwoTerminalChain(pinMap, twoTerminal, liveNet, leftCommon);
+      if (!pre) continue;
+      const postCandidates = twoTerminal.filter((c) => !pre.used.has(c.id));
+      const post = traceTwoTerminalChain(pinMap, postCandidates, rightCommon, loadLiveNet);
+      if (!post) continue;
+      if (pre.used.size + post.used.size !== twoTerminal.length) continue;
+      const rendered = layoutTwoWayLightingLoop(
+        ast,
+        source,
+        pre.steps,
+        leftSwitch,
+        rightSwitch,
+        post.steps,
+        load,
+        liveNet,
+        returnNet,
+        loadLiveNet
+      );
+      if (rendered) return rendered;
+    }
+  }
+  return null;
+}
 function layoutCircuitNetlist(ast) {
   const pinMap = ast.pinMap ?? {};
+  const twoWireLighting = tryLayoutTwoWireLighting(ast);
+  if (twoWireLighting) return twoWireLighting;
   const isShunt = (c) => {
     if (isPowerSource(c) || isGround(c)) return false;
     const pins = pinMap[c.id];
@@ -2521,28 +2852,7 @@ function layoutCircuitNetlist(ast) {
   const placed = /* @__PURE__ */ new Map();
   const items = [];
   const place = (comp, x, y, fallbackDir) => {
-    const direction = comp.attrs?.dirExplicit === "true" ? comp.direction : fallbackDir ?? defaultDirection(comp);
-    comp.direction = direction;
-    const rot = rotationOf(direction);
-    const sym = getSymbol(comp.componentType);
-    const worldAnchors = {};
-    if (sym) {
-      for (const [name, pt] of Object.entries(sym.anchors)) {
-        const rp = rotatePt(pt, rot);
-        worldAnchors[name] = { x: x + rp.x, y: y + rp.y };
-      }
-    } else {
-      worldAnchors.start = { x, y };
-      worldAnchors.end = { x: x + 30, y };
-    }
-    const laid = {
-      component: comp,
-      x,
-      y,
-      rotation: rot,
-      length: sym?.length ?? 30,
-      anchors: worldAnchors
-    };
+    const laid = placeComponent(comp, x, y, fallbackDir);
     items.push(laid);
     placed.set(comp.id, laid);
     return laid;
@@ -2759,20 +3069,21 @@ function renderItem(it, offX, offY) {
     return `<rect x="${tx - 10}" y="${ty - 10}" width="20" height="20" fill="none" class="schematex-circuit-err" stroke-dasharray="3,2"/><text x="${tx}" y="${ty + 3}" text-anchor="middle" font-size="9" class="schematex-circuit-err">?${chunk3WNW5Y7P_cjs.escapeXml(comp.componentType)}</text>`;
   }
   const body = sym.svg(comp.label, comp.value, comp.attrs);
-  const transform = `translate(${tx}, ${ty}) rotate(${it.rotation})`;
+  const transform = it.mirrorX ? `translate(${tx + it.length}, ${ty}) scale(-1, 1)` : `translate(${tx}, ${ty}) rotate(${it.rotation})`;
   const labels = [];
   if (comp.label || comp.value) {
-    const labelX = it.x + offX + it.length * Math.cos(it.rotation * Math.PI / 180) / 2;
-    const labelY = it.y + offY + it.length * Math.sin(it.rotation * Math.PI / 180) / 2;
-    const perpDX = Math.sin(it.rotation * Math.PI / 180);
-    const perpDY = -Math.cos(it.rotation * Math.PI / 180);
-    const off = 16;
+    const angle = it.rotation * Math.PI / 180;
+    const midpointX = it.x + offX + it.length * Math.cos(angle) / 2;
+    const midpointY = it.y + offY + it.length * Math.sin(angle) / 2;
+    const vertical = Math.abs(Math.sin(angle)) > 0.5;
+    const labelX = midpointX + (vertical ? 34 : 0);
+    const labelY = midpointY - (vertical ? 2 : 18);
     if (comp.label) {
       labels.push(
         chunk3WNW5Y7P_cjs.text(
           {
-            x: labelX + perpDX * off,
-            y: labelY + perpDY * off - 2,
+            x: labelX,
+            y: labelY,
             class: "schematex-circuit-label",
             "text-anchor": "middle"
           },
@@ -2784,8 +3095,8 @@ function renderItem(it, offX, offY) {
       labels.push(
         chunk3WNW5Y7P_cjs.text(
           {
-            x: labelX + perpDX * off,
-            y: labelY + perpDY * off + 10,
+            x: labelX,
+            y: labelY + 12,
             class: "schematex-circuit-value",
             "text-anchor": "middle"
           },
@@ -2882,7 +3193,6 @@ var circuit = {
   }
 };
 
-exports.EXTRA_SYMBOLS = EXTRA_SYMBOLS;
 exports.SYMBOLS = SYMBOLS;
 exports.circuit = circuit;
 exports.layoutCircuit = layoutCircuit;
@@ -2891,5 +3201,5 @@ exports.lintCircuit = lintCircuit;
 exports.parseCircuit = parseCircuit;
 exports.parseNetlist = parseNetlist;
 exports.renderCircuit = renderCircuit;
-//# sourceMappingURL=chunk-24YHD4YI.cjs.map
-//# sourceMappingURL=chunk-24YHD4YI.cjs.map
+//# sourceMappingURL=chunk-JXPBZEFM.cjs.map
+//# sourceMappingURL=chunk-JXPBZEFM.cjs.map