@tscircuit/cli 0.1.1480 → 0.1.1482

package/dist/cli/main.js

@@ -34587,7 +34587,7 @@ function compose7(...matrices) {
 function isUndefined2(val) {
   return typeof val === "undefined";
 }
-function rotate9(angle, cx2, cy2) {
+function rotate10(angle, cx2, cy2) {
   const cosAngle = cos(angle);
   const sinAngle = sin(angle);
   const rotationMatrix = {
@@ -34608,7 +34608,7 @@ function rotate9(angle, cx2, cy2) {
   ]);
 }
 function rotateDEG(angle, cx2 = undefined, cy2 = undefined) {
-  return rotate9(angle * PI / 180, cx2, cy2);
+  return rotate10(angle * PI / 180, cx2, cy2);
 }
 function scale5(sx2, sy2 = undefined, cx2 = undefined, cy2 = undefined) {
   if (isUndefined2(sy2))
@@ -34799,13 +34799,13 @@ function doSegmentsIntersect(p12, q12, p22, q22) {
   if (o12 !== o22 && o3 !== o4) {
     return true;
   }
-  if (o12 === 0 && onSegment(p12, p22, q12))
+  if (o12 === 0 && onSegment2(p12, p22, q12))
     return true;
-  if (o22 === 0 && onSegment(p12, q22, q12))
+  if (o22 === 0 && onSegment2(p12, q22, q12))
     return true;
-  if (o3 === 0 && onSegment(p22, p12, q22))
+  if (o3 === 0 && onSegment2(p22, p12, q22))
     return true;
-  if (o4 === 0 && onSegment(p22, q12, q22))
+  if (o4 === 0 && onSegment2(p22, q12, q22))
     return true;
   return false;
 }
@@ -34815,7 +34815,7 @@ function orientation(p, q3, r3) {
     return 0;
   return val > 0 ? 1 : 2;
 }
-function onSegment(p, q3, r3) {
+function onSegment2(p, q3, r3) {
   return q3.x <= Math.max(p.x, r3.x) && q3.x >= Math.min(p.x, r3.x) && q3.y <= Math.max(p.y, r3.y) && q3.y >= Math.min(p.y, r3.y);
 }
 function segmentsDistance(a12, a2, b12, b22) {
@@ -39149,7 +39149,7 @@ var init_chunk_SK323GHE = __esm(() => {
         element: "element",
         text: "text"
       };
-      var createNode2 = function createNode22(params2) {
+      var createNode3 = function createNode22(params2) {
         return Object.assign({
           name: "",
           type: NodeType.element,
@@ -39177,7 +39177,7 @@ var init_chunk_SK323GHE = __esm(() => {
                 current2 = rootNode;
                 current2.name = data.value;
               } else {
-                var node = createNode2({
+                var node = createNode3({
                   name: data.value,
                   parent: current2
                 });
@@ -39210,7 +39210,7 @@ var init_chunk_SK323GHE = __esm(() => {
               break;
             case Type.text:
               if (current2) {
-                current2.children.push(createNode2({
+                current2.children.push(createNode3({
                   type: NodeType.text,
                   value: data.value,
                   parent: options.parentNodes ? current2 : null
@@ -39229,7 +39229,7 @@ var init_chunk_SK323GHE = __esm(() => {
         reader.reset = function() {
           lexer = Lexer.create({ debug: options.debug });
           lexer.on("data", handleLexerData);
-          rootNode = createNode2();
+          rootNode = createNode3();
           current2 = null;
           attrName = "";
           reader.parse = lexer.write;
@@ -47699,7 +47699,7 @@ function createSvgObjectsFromPcbFabricationNoteText(pcbFabNoteText, ctx) {
       dominantBaseline = "text-after-edge";
       break;
   }
-  const textTransform = compose7(translate7(transformedX, transformedY), rotate9(Math.PI / 180));
+  const textTransform = compose7(translate7(transformedX, transformedY), rotate10(Math.PI / 180));
   const svgObject = {
     name: "text",
     type: "element",
@@ -49528,7 +49528,7 @@ function createSvgObjectsFromPcbSilkscreenText(pcbSilkscreenText, ctx) {
     const rectW = width + padLeft + padRight;
     const rectH = height + padTop + padBottom;
     const strokeWidth = scaledFontSize * 0.15;
-    const knockoutTransform = toString(compose7(translate7(transformedX, transformedY), rotate9(-ccw_rotation * Math.PI / 180), ...applyMirror ? [scale5(-1, 1)] : [], scale5(scaleFactor, scaleFactor)));
+    const knockoutTransform = toString(compose7(translate7(transformedX, transformedY), rotate10(-ccw_rotation * Math.PI / 180), ...applyMirror ? [scale5(-1, 1)] : [], scale5(scaleFactor, scaleFactor)));
     const maskId = `silkscreen-knockout-mask-${pcbSilkscreenText.pcb_silkscreen_text_id}-${silkscreenMaskIdCounter++}`;
     return [
       {
@@ -49641,7 +49641,7 @@ function createSvgObjectsFromPcbSilkscreenText(pcbSilkscreenText, ctx) {
       dominantBaseline = "central";
       break;
   }
-  const textTransform = compose7(translate7(transformedX, transformedY), rotate9(-ccw_rotation * Math.PI / 180), ...layer === "bottom" ? [scale5(-1, 1)] : []);
+  const textTransform = compose7(translate7(transformedX, transformedY), rotate10(-ccw_rotation * Math.PI / 180), ...layer === "bottom" ? [scale5(-1, 1)] : []);
   const lines = text.split(`
 `);
   const children = lines.length === 1 ? [
@@ -49883,7 +49883,7 @@ function createSvgObjectsFromPcbCopperText(pcbCopperText, ctx) {
     const rectW = width2 + padX * 2;
     const rectH = height2 + padY * 2;
     const strokeWidth2 = scaledFontSize2 * 0.15;
-    const knockoutTransform = toString(compose7(translate7(ax2, ay2), rotate9(-ccw_rotation * Math.PI / 180), ...applyMirror ? [scale5(-1, 1)] : [], scale5(scaleFactor, scaleFactor)));
+    const knockoutTransform = toString(compose7(translate7(ax2, ay2), rotate10(-ccw_rotation * Math.PI / 180), ...applyMirror ? [scale5(-1, 1)] : [], scale5(scaleFactor, scaleFactor)));
     const maskId = `knockout-mask-${pcbCopperText.pcb_copper_text_id}-${maskIdCounter++}`;
     return [
       {
@@ -49985,7 +49985,7 @@ function createSvgObjectsFromPcbCopperText(pcbCopperText, ctx) {
       offsetY = -height / 2;
       break;
   }
-  const textTransform = toString(compose7(translate7(ax2, ay2), rotate9(-ccw_rotation * Math.PI / 180), ...applyMirror ? [scale5(-1, 1)] : [], translate7(offsetX, offsetY), scale5(scaleFactor, scaleFactor)));
+  const textTransform = toString(compose7(translate7(ax2, ay2), rotate10(-ccw_rotation * Math.PI / 180), ...applyMirror ? [scale5(-1, 1)] : [], translate7(offsetX, offsetY), scale5(scaleFactor, scaleFactor)));
   const strokeWidth = scaledFontSize * 0.15;
   return [
     {
@@ -52056,7 +52056,7 @@ function createSvgObjectsFromPcbCutout(cutout, ctx) {
       width: scaledWidth.toString(),
       height: scaledHeight.toString(),
       fill: colorMap2.drill,
-      transform: toString(compose7(translate7(cx2, cy2), rotate9(svgRotation * Math.PI / 180))),
+      transform: toString(compose7(translate7(cx2, cy2), rotate10(svgRotation * Math.PI / 180))),
       "data-type": "pcb_cutout",
       "data-pcb-layer": "drill"
     };
@@ -52407,7 +52407,7 @@ function createSvgObjectsFromPcbCopperPour(pour, ctx) {
       y: (-scaledHeight / 2).toString(),
       width: scaledWidth.toString(),
       height: scaledHeight.toString(),
-      transform: toString(compose7(translate7(cx2, cy2), rotate9(svgRotation * Math.PI / 180)))
+      transform: toString(compose7(translate7(cx2, cy2), rotate10(svgRotation * Math.PI / 180)))
     };
     const copperRect = {
       name: "rect",
@@ -55394,15 +55394,15 @@ function calculateVerticalEdgeLabels(edge, pinout_labels, {
       stagger_rank = geometric_middle_index - dist_from_middle;
     }
     const stagger_offset = stagger_offset_base + stagger_rank * (STAGGER_OFFSET_STEP * styleScale * pxPerMm);
-    const sign = edge === "left" ? -1 : 1;
+    const sign2 = edge === "left" ? -1 : 1;
     const is_main_group_pin = main_group_indices.includes(i);
     const y_pos = is_all_main_group ? edge_ports[i].y : main_group_indices.length > 0 && is_main_group_pin ? edge_ports[i].y : current_y;
     const elbow_end = {
-      x: board_edge_x + sign * stagger_offset,
+      x: board_edge_x + sign2 * stagger_offset,
       y: y_pos
     };
     const label_pos = {
-      x: board_edge_x + sign * aligned_label_offset,
+      x: board_edge_x + sign2 * aligned_label_offset,
       y: y_pos
     };
     label_positions.set(pcb_port2.pcb_port_id, {
@@ -58785,7 +58785,7 @@ var import_debug2, svgAlphabet, lineAlphabet, debug2, debugPcb, debugSch, DEFAUL
     y: schNetLabel.center.y - realTextGrowthVec.y * fullWidthFsr * fontSizeMm / 2
   };
   const pathRotation = 0;
-  const rotationMatrix = rotate9(pathRotation / 180 * Math.PI);
+  const rotationMatrix = rotate10(pathRotation / 180 * Math.PI);
   const symbolBounds = {
     minX: Math.min(...symbol.primitives.flatMap((p) => p.type === "path" ? p.points.map((pt2) => pt2.x) : [])),
     maxX: Math.max(...symbol.primitives.flatMap((p) => p.type === "path" ? p.points.map((pt2) => pt2.x) : [])),
@@ -58971,7 +58971,7 @@ var import_debug2, svgAlphabet, lineAlphabet, debug2, debugPcb, debugSch, DEFAUL
       x: ARROW_POINT_WIDTH_FSR,
       y: -0.6
     }
-  ].map((fontRelativePoint) => applyToPoint23(compose7(realToScreenTransform, translate7(realAnchorPosition.x, realAnchorPosition.y), scale5(fontSizeMm), rotate9(pathRotation / 180 * Math.PI)), fontRelativePoint));
+  ].map((fontRelativePoint) => applyToPoint23(compose7(realToScreenTransform, translate7(realAnchorPosition.x, realAnchorPosition.y), scale5(fontSizeMm), rotate10(pathRotation / 180 * Math.PI)), fontRelativePoint));
   const pathD = `
     M ${screenOutlinePoints[0].x},${screenOutlinePoints[0].y}
     L ${screenOutlinePoints[1].x},${screenOutlinePoints[1].y}
@@ -100763,7 +100763,7 @@ var import_perfect_cli = __toESM2(require_dist2(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.1479";
+var version = "0.1.1481";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -100801,7 +100801,7 @@ var package_default = {
     "circuit-json": "^0.0.425",
     "circuit-json-to-bom-csv": "^0.0.7",
     "circuit-json-to-gerber": "^0.0.51",
-    "circuit-json-to-kicad": "0.0.137",
+    "circuit-json-to-kicad": "0.0.150",
     "circuit-json-to-pnp-csv": "^0.0.7",
     "circuit-json-to-readable-netlist": "^0.0.15",
     "circuit-json-to-spice": "^0.0.10",
@@ -104838,12 +104838,466 @@ import {
 import { KicadPcb as KicadPcb2 } from "kicadts";
 import { cju as cju2 } from "@tscircuit/circuit-json-util";
 import { compose as compose6, translate as translate6, scale as scale4 } from "transformation-matrix";
+
+// node_modules/earcut/src/earcut.js
+function earcut(data, holeIndices, dim = 2) {
+  const hasHoles = holeIndices && holeIndices.length;
+  const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+  let outerNode = linkedList(data, 0, outerLen, dim, true);
+  const triangles = [];
+  if (!outerNode || outerNode.next === outerNode.prev)
+    return triangles;
+  let minX, minY, invSize;
+  if (hasHoles)
+    outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+  if (data.length > 80 * dim) {
+    minX = data[0];
+    minY = data[1];
+    let maxX = minX;
+    let maxY = minY;
+    for (let i = dim;i < outerLen; i += dim) {
+      const x = data[i];
+      const y = data[i + 1];
+      if (x < minX)
+        minX = x;
+      if (y < minY)
+        minY = y;
+      if (x > maxX)
+        maxX = x;
+      if (y > maxY)
+        maxY = y;
+    }
+    invSize = Math.max(maxX - minX, maxY - minY);
+    invSize = invSize !== 0 ? 32767 / invSize : 0;
+  }
+  earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
+  return triangles;
+}
+function linkedList(data, start, end, dim, clockwise) {
+  let last;
+  if (clockwise === signedArea(data, start, end, dim) > 0) {
+    for (let i = start;i < end; i += dim)
+      last = insertNode(i / dim | 0, data[i], data[i + 1], last);
+  } else {
+    for (let i = end - dim;i >= start; i -= dim)
+      last = insertNode(i / dim | 0, data[i], data[i + 1], last);
+  }
+  if (last && equals(last, last.next)) {
+    removeNode(last);
+    last = last.next;
+  }
+  return last;
+}
+function filterPoints(start, end) {
+  if (!start)
+    return start;
+  if (!end)
+    end = start;
+  let p = start, again;
+  do {
+    again = false;
+    if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+      removeNode(p);
+      p = end = p.prev;
+      if (p === p.next)
+        break;
+      again = true;
+    } else {
+      p = p.next;
+    }
+  } while (again || p !== end);
+  return end;
+}
+function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+  if (!ear)
+    return;
+  if (!pass && invSize)
+    indexCurve(ear, minX, minY, invSize);
+  let stop2 = ear;
+  while (ear.prev !== ear.next) {
+    const prev = ear.prev;
+    const next = ear.next;
+    if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+      triangles.push(prev.i, ear.i, next.i);
+      removeNode(ear);
+      ear = next.next;
+      stop2 = next.next;
+      continue;
+    }
+    ear = next;
+    if (ear === stop2) {
+      if (!pass) {
+        earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+      } else if (pass === 1) {
+        ear = cureLocalIntersections(filterPoints(ear), triangles);
+        earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+      } else if (pass === 2) {
+        splitEarcut(ear, triangles, dim, minX, minY, invSize);
+      }
+      break;
+    }
+  }
+}
+function isEar(ear) {
+  const a = ear.prev, b = ear, c = ear.next;
+  if (area(a, b, c) >= 0)
+    return false;
+  const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+  const x0 = Math.min(ax, bx, cx), y0 = Math.min(ay, by, cy), x1 = Math.max(ax, bx, cx), y1 = Math.max(ay, by, cy);
+  let p = c.next;
+  while (p !== a) {
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+      return false;
+    p = p.next;
+  }
+  return true;
+}
+function isEarHashed(ear, minX, minY, invSize) {
+  const a = ear.prev, b = ear, c = ear.next;
+  if (area(a, b, c) >= 0)
+    return false;
+  const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+  const x0 = Math.min(ax, bx, cx), y0 = Math.min(ay, by, cy), x1 = Math.max(ax, bx, cx), y1 = Math.max(ay, by, cy);
+  const minZ = zOrder(x0, y0, minX, minY, invSize), maxZ = zOrder(x1, y1, minX, minY, invSize);
+  let { prevZ: p, nextZ: n } = ear;
+  while (p && p.z >= minZ && n && n.z <= maxZ) {
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+      return false;
+    p = p.prevZ;
+    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+      return false;
+    n = n.nextZ;
+  }
+  while (p && p.z >= minZ) {
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+      return false;
+    p = p.prevZ;
+  }
+  while (n && n.z <= maxZ) {
+    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+      return false;
+    n = n.nextZ;
+  }
+  return true;
+}
+function cureLocalIntersections(start, triangles) {
+  let p = start;
+  do {
+    const a = p.prev, b = p.next.next;
+    if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+      triangles.push(a.i, p.i, b.i);
+      removeNode(p);
+      removeNode(p.next);
+      p = start = b;
+    }
+    p = p.next;
+  } while (p !== start);
+  return filterPoints(p);
+}
+function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+  let a = start;
+  do {
+    let b = a.next.next;
+    while (b !== a.prev) {
+      if (a.i !== b.i && isValidDiagonal(a, b)) {
+        let c = splitPolygon(a, b);
+        a = filterPoints(a, a.next);
+        c = filterPoints(c, c.next);
+        earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
+        earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
+        return;
+      }
+      b = b.next;
+    }
+    a = a.next;
+  } while (a !== start);
+}
+function eliminateHoles(data, holeIndices, outerNode, dim) {
+  const queue = [];
+  for (let i = 0, len = holeIndices.length;i < len; i++) {
+    const start = holeIndices[i] * dim;
+    const end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+    const list = linkedList(data, start, end, dim, false);
+    if (list === list.next)
+      list.steiner = true;
+    queue.push(getLeftmost(list));
+  }
+  queue.sort(compareXYSlope);
+  for (let i = 0;i < queue.length; i++) {
+    outerNode = eliminateHole(queue[i], outerNode);
+  }
+  return outerNode;
+}
+function compareXYSlope(a, b) {
+  let result = a.x - b.x;
+  if (result === 0) {
+    result = a.y - b.y;
+    if (result === 0) {
+      const aSlope = (a.next.y - a.y) / (a.next.x - a.x);
+      const bSlope = (b.next.y - b.y) / (b.next.x - b.x);
+      result = aSlope - bSlope;
+    }
+  }
+  return result;
+}
+function eliminateHole(hole, outerNode) {
+  const bridge = findHoleBridge(hole, outerNode);
+  if (!bridge) {
+    return outerNode;
+  }
+  const bridgeReverse = splitPolygon(bridge, hole);
+  filterPoints(bridgeReverse, bridgeReverse.next);
+  return filterPoints(bridge, bridge.next);
+}
+function findHoleBridge(hole, outerNode) {
+  let p = outerNode;
+  const hx = hole.x;
+  const hy = hole.y;
+  let qx = -Infinity;
+  let m;
+  if (equals(hole, p))
+    return p;
+  do {
+    if (equals(hole, p.next))
+      return p.next;
+    else if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+      const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+      if (x <= hx && x > qx) {
+        qx = x;
+        m = p.x < p.next.x ? p : p.next;
+        if (x === hx)
+          return m;
+      }
+    }
+    p = p.next;
+  } while (p !== outerNode);
+  if (!m)
+    return null;
+  const stop2 = m;
+  const mx = m.x;
+  const my = m.y;
+  let tanMin = Infinity;
+  p = m;
+  do {
+    if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+      const tan = Math.abs(hy - p.y) / (hx - p.x);
+      if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
+        m = p;
+        tanMin = tan;
+      }
+    }
+    p = p.next;
+  } while (p !== stop2);
+  return m;
+}
+function sectorContainsSector(m, p) {
+  return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+}
+function indexCurve(start, minX, minY, invSize) {
+  let p = start;
+  do {
+    if (p.z === 0)
+      p.z = zOrder(p.x, p.y, minX, minY, invSize);
+    p.prevZ = p.prev;
+    p.nextZ = p.next;
+    p = p.next;
+  } while (p !== start);
+  p.prevZ.nextZ = null;
+  p.prevZ = null;
+  sortLinked(p);
+}
+function sortLinked(list) {
+  let numMerges;
+  let inSize = 1;
+  do {
+    let p = list;
+    let e;
+    list = null;
+    let tail = null;
+    numMerges = 0;
+    while (p) {
+      numMerges++;
+      let q = p;
+      let pSize = 0;
+      for (let i = 0;i < inSize; i++) {
+        pSize++;
+        q = q.nextZ;
+        if (!q)
+          break;
+      }
+      let qSize = inSize;
+      while (pSize > 0 || qSize > 0 && q) {
+        if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
+          e = p;
+          p = p.nextZ;
+          pSize--;
+        } else {
+          e = q;
+          q = q.nextZ;
+          qSize--;
+        }
+        if (tail)
+          tail.nextZ = e;
+        else
+          list = e;
+        e.prevZ = tail;
+        tail = e;
+      }
+      p = q;
+    }
+    tail.nextZ = null;
+    inSize *= 2;
+  } while (numMerges > 1);
+  return list;
+}
+function zOrder(x, y, minX, minY, invSize) {
+  x = (x - minX) * invSize | 0;
+  y = (y - minY) * invSize | 0;
+  x = (x | x << 8) & 16711935;
+  x = (x | x << 4) & 252645135;
+  x = (x | x << 2) & 858993459;
+  x = (x | x << 1) & 1431655765;
+  y = (y | y << 8) & 16711935;
+  y = (y | y << 4) & 252645135;
+  y = (y | y << 2) & 858993459;
+  y = (y | y << 1) & 1431655765;
+  return x | y << 1;
+}
+function getLeftmost(start) {
+  let p = start, leftmost = start;
+  do {
+    if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y)
+      leftmost = p;
+    p = p.next;
+  } while (p !== start);
+  return leftmost;
+}
+function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+  return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
+}
+function pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, px, py) {
+  return !(ax === px && ay === py) && pointInTriangle(ax, ay, bx, by, cx, cy, px, py);
+}
+function isValidDiagonal(a, b) {
+  return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && (area(a.prev, a, b.prev) || area(a, b.prev, b)) || equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);
+}
+function area(p, q, r) {
+  return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+}
+function equals(p1, p2) {
+  return p1.x === p2.x && p1.y === p2.y;
+}
+function intersects(p1, q1, p2, q2) {
+  const o1 = sign(area(p1, q1, p2));
+  const o2 = sign(area(p1, q1, q2));
+  const o3 = sign(area(p2, q2, p1));
+  const o4 = sign(area(p2, q2, q1));
+  if (o1 !== o2 && o3 !== o4)
+    return true;
+  if (o1 === 0 && onSegment(p1, p2, q1))
+    return true;
+  if (o2 === 0 && onSegment(p1, q2, q1))
+    return true;
+  if (o3 === 0 && onSegment(p2, p1, q2))
+    return true;
+  if (o4 === 0 && onSegment(p2, q1, q2))
+    return true;
+  return false;
+}
+function onSegment(p, q, r) {
+  return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+}
+function sign(num) {
+  return num > 0 ? 1 : num < 0 ? -1 : 0;
+}
+function intersectsPolygon(a, b) {
+  let p = a;
+  do {
+    if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b))
+      return true;
+    p = p.next;
+  } while (p !== a);
+  return false;
+}
+function locallyInside(a, b) {
+  return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+}
+function middleInside(a, b) {
+  let p = a;
+  let inside = false;
+  const px = (a.x + b.x) / 2;
+  const py = (a.y + b.y) / 2;
+  do {
+    if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x)
+      inside = !inside;
+    p = p.next;
+  } while (p !== a);
+  return inside;
+}
+function splitPolygon(a, b) {
+  const a2 = createNode(a.i, a.x, a.y), b2 = createNode(b.i, b.x, b.y), an = a.next, bp = b.prev;
+  a.next = b;
+  b.prev = a;
+  a2.next = an;
+  an.prev = a2;
+  b2.next = a2;
+  a2.prev = b2;
+  bp.next = b2;
+  b2.prev = bp;
+  return b2;
+}
+function insertNode(i, x, y, last) {
+  const p = createNode(i, x, y);
+  if (!last) {
+    p.prev = p;
+    p.next = p;
+  } else {
+    p.next = last.next;
+    p.prev = last;
+    last.next.prev = p;
+    last.next = p;
+  }
+  return p;
+}
+function removeNode(p) {
+  p.next.prev = p.prev;
+  p.prev.next = p.next;
+  if (p.prevZ)
+    p.prevZ.nextZ = p.nextZ;
+  if (p.nextZ)
+    p.nextZ.prevZ = p.prevZ;
+}
+function createNode(i, x, y) {
+  return {
+    i,
+    x,
+    y,
+    prev: null,
+    next: null,
+    z: 0,
+    prevZ: null,
+    nextZ: null,
+    steiner: false
+  };
+}
+function signedArea(data, start, end, dim) {
+  let sum = 0;
+  for (let i = start, j = end - dim;i < end; i += dim) {
+    sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+    j = i;
+  }
+  return sum;
+}
+
+// node_modules/circuit-json-to-kicad/dist/index.js
 import {
+  Layer,
   Pts as Pts3,
   Xy as Xy3,
   Zone,
   ZoneConnectPads,
   ZoneFill,
+  ZoneFilledPolygon,
   ZoneHatch,
   ZonePolygon
 } from "kicadts";
@@ -104929,7 +105383,7 @@ import { Via, ViaNet } from "kicadts";
 import { applyToPoint as applyToPoint18 } from "transformation-matrix";
 import { Footprint as Footprint4 } from "kicadts";
 import { applyToPoint as applyToPoint19 } from "transformation-matrix";
-import { GrLine } from "kicadts";
+import { GrCircle, GrLine, GrPoly } from "kicadts";
 import {
   At as At2,
   GrText,
@@ -104938,7 +105392,7 @@ import {
   TextEffectsJustify as TextEffectsJustify3
 } from "kicadts";
 import { applyToPoint as applyToPoint20 } from "transformation-matrix";
-import { applyToPoint as applyToPoint22 } from "transformation-matrix";
+import { applyToPoint as applyToPoint22, rotate as rotate9 } from "transformation-matrix";
 import {
   GrText as GrText2,
   TextEffects as TextEffects11,
@@ -105083,8 +105537,9 @@ function getReferencePrefixForComponent(sourceComponent) {
 }
 function getReferenceDesignator(sourceComponent) {
   const name = sourceComponent?.name;
-  if (isReferenceDesignator(name)) {
-    return name.trim();
+  const trimmedName = name?.trim();
+  if (trimmedName) {
+    return trimmedName;
   }
   const prefix = getReferencePrefixForComponent(sourceComponent);
   return `${prefix}?`;
@@ -106682,6 +107137,8 @@ function generateDeterministicUuid(data) {
   const hash = simpleHash(data);
   return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(12, 16)}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`;
 }
+var isPcbCopperPour = (element) => element.type === "pcb_copper_pour";
+var getCopperPours = (circuitJson) => circuitJson.filter(isPcbCopperPour);
 var getCopperPourNetInfo = (pour, ctx) => {
   let connectivityKey = pour.source_net_id;
   if (connectivityKey) {
@@ -106692,19 +107149,13 @@ var getCopperPourNetInfo = (pour, ctx) => {
     return;
   return ctx.pcbNetMap?.get(connectivityKey);
 };
-var getRingPoints = (ring, c2kMatPcb) => {
-  return (ring.vertices ?? []).map((point) => {
-    const transformedPoint = applyToPoint8(c2kMatPcb, point);
-    return new Xy3(transformedPoint.x, transformedPoint.y);
-  });
-};
-var getPolygonPoints = (points, c2kMatPcb) => {
+var convertPointsToKicadXy = (points, c2kMatPcb) => {
   return (points ?? []).map((point) => {
     const transformedPoint = applyToPoint8(c2kMatPcb, point);
     return new Xy3(transformedPoint.x, transformedPoint.y);
   });
 };
-var rotatePointsToTopRight = (points) => {
+var rotateRingToStartAtTopRight = (points) => {
   if (points.length < 2)
     return points;
   let startIndex = 0;
@@ -106719,6 +107170,26 @@ var rotatePointsToTopRight = (points) => {
   }
   return [...points.slice(startIndex), ...points.slice(0, startIndex)];
 };
+var removeConsecutiveDuplicatePoints = (points) => {
+  const dedupedPoints = [];
+  for (const point of points) {
+    const lastPoint = dedupedPoints[dedupedPoints.length - 1];
+    if (lastPoint?.x === point.x && lastPoint.y === point.y) {
+      continue;
+    }
+    dedupedPoints.push(point);
+  }
+  return dedupedPoints;
+};
+var removeRepeatedClosingPoint = (points) => {
+  const dedupedPoints = [...points];
+  const firstPoint = dedupedPoints[0];
+  const lastPoint = dedupedPoints[dedupedPoints.length - 1];
+  if (firstPoint && lastPoint && dedupedPoints.length > 1 && firstPoint.x === lastPoint.x && firstPoint.y === lastPoint.y) {
+    dedupedPoints.pop();
+  }
+  return dedupedPoints;
+};
 var getRectRingPoints = (pour, c2kMatPcb) => {
   const ccwRotationDegrees = pour.rotation ?? 0;
   const cornerTransform = compose3(translate3(pour.center.x, pour.center.y), rotate(ccwRotationDegrees * Math.PI / 180));
@@ -106730,17 +107201,87 @@ var getRectRingPoints = (pour, c2kMatPcb) => {
     { x: halfWidth, y: halfHeight },
     { x: -halfWidth, y: halfHeight }
   ].map((corner) => applyToPoint8(cornerTransform, corner));
-  return rotatePointsToTopRight(getPolygonPoints(corners, c2kMatPcb));
+  return convertPointsToKicadXy(corners, c2kMatPcb);
 };
-var getCopperPourPolygonPoints = (pour, c2kMatPcb) => {
-  if (pour.shape === "rect") {
-    return getRectRingPoints(pour, c2kMatPcb);
+var getPolygonRingPoints = (pour, c2kMatPcb) => removeRepeatedClosingPoint(removeConsecutiveDuplicatePoints(rotateRingToStartAtTopRight(convertPointsToKicadXy(pour.points, c2kMatPcb))));
+var getBrepZoneRings = (pour, c2kMatPcb) => [
+  removeRepeatedClosingPoint(removeConsecutiveDuplicatePoints(rotateRingToStartAtTopRight(convertPointsToKicadXy(pour.brep_shape.outer_ring.vertices, c2kMatPcb)))),
+  pour.brep_shape.inner_rings.map((ring) => removeRepeatedClosingPoint(removeConsecutiveDuplicatePoints(rotateRingToStartAtTopRight(convertPointsToKicadXy(ring.vertices, c2kMatPcb))))).filter((ringPoints) => ringPoints.length >= 3)
+];
+var getCopperPourZoneRings = (pour, c2kMatPcb) => {
+  switch (pour.shape) {
+    case "rect":
+      return [
+        removeRepeatedClosingPoint(removeConsecutiveDuplicatePoints(rotateRingToStartAtTopRight(getRectRingPoints(pour, c2kMatPcb)))),
+        []
+      ];
+    case "polygon":
+      return [getPolygonRingPoints(pour, c2kMatPcb), []];
+    case "brep":
+      return getBrepZoneRings(pour, c2kMatPcb);
   }
-  if (pour.shape === "polygon") {
-    return rotatePointsToTopRight(getPolygonPoints(pour.points, c2kMatPcb));
+};
+var createZonePolygons = (outerRing, innerRings) => {
+  const polygons = [];
+  if (outerRing.length >= 3) {
+    polygons.push(new ZonePolygon(new Pts3(outerRing)));
+  }
+  for (const innerRing of innerRings) {
+    if (innerRing.length < 3)
+      continue;
+    polygons.push(new ZonePolygon(new Pts3(innerRing)));
+  }
+  return polygons;
+};
+var getTriangleArea = (a, b, c) => Math.abs((a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y)) / 2);
+var createZoneFilledPolygons = (outerRing, innerRings, kicadLayer) => {
+  if (outerRing.length < 3) {
+    return [];
+  }
+  const layer = new Layer([kicadLayer]);
+  if (innerRings.length === 0) {
+    return [
+      new ZoneFilledPolygon({
+        layer,
+        pts: new Pts3(outerRing)
+      })
+    ];
+  }
+  const flattenedPoints = [];
+  const holeIndices = [];
+  let pointIndex = 0;
+  const addRing = (ring) => {
+    for (const point of ring) {
+      flattenedPoints.push(point.x, point.y);
+    }
+    pointIndex += ring.length;
+  };
+  addRing(outerRing);
+  for (const innerRing of innerRings) {
+    holeIndices.push(pointIndex);
+    addRing(innerRing);
+  }
+  const triangleIndices = earcut(flattenedPoints, holeIndices, 2);
+  const filledPolygons = [];
+  for (let i = 0;i < triangleIndices.length; i += 3) {
+    const trianglePoints = [];
+    for (let offset = 0;offset < 3; offset++) {
+      const pointOffset = triangleIndices[i + offset] * 2;
+      const x = flattenedPoints[pointOffset];
+      const y = flattenedPoints[pointOffset + 1];
+      if (x === undefined || y === undefined)
+        continue;
+      trianglePoints.push(new Xy3(x, y));
+    }
+    if (trianglePoints.length !== 3 || getTriangleArea(trianglePoints[0], trianglePoints[1], trianglePoints[2]) === 0) {
+      continue;
+    }
+    filledPolygons.push(new ZoneFilledPolygon({
+      layer,
+      pts: new Pts3(trianglePoints)
+    }));
   }
-  const outerRing = pour.brep_shape?.outer_ring;
-  return outerRing ? rotatePointsToTopRight(getRingPoints(outerRing, c2kMatPcb)) : [];
+  return filledPolygons;
 };
 var AddCopperPoursStage = class extends ConverterStage {
   _step() {
@@ -106751,19 +107292,18 @@ var AddCopperPoursStage = class extends ConverterStage {
     if (!c2kMatPcb) {
       throw new Error("PCB transformation matrix not initialized in context");
     }
-    const copperPours = this.ctx.db.pcb_copper_pour?.list();
-    for (const pour of copperPours ?? []) {
-      const polygonPoints = getCopperPourPolygonPoints(pour, c2kMatPcb);
-      if (polygonPoints.length < 3)
+    const copperPours = getCopperPours(this.input);
+    for (const pour of copperPours) {
+      const [outerRing, innerRings] = getCopperPourZoneRings(pour, c2kMatPcb);
+      if (outerRing.length < 3)
         continue;
       const netInfo = getCopperPourNetInfo(pour, this.ctx);
       const kicadLayer = getKicadLayer(pour.layer);
-      const polygonPts = new Pts3(polygonPoints);
       const zone = new Zone({
         net: netInfo?.id ?? 0,
         netName: netInfo?.name ?? "",
         layer: kicadLayer,
-        uuid: generateDeterministicUuid(`zone:${pour.pcb_copper_pour_id ?? ""}`),
+        uuid: generateDeterministicUuid(`zone:${pour.pcb_copper_pour_id}`),
         hatch: new ZoneHatch("edge", 0.5),
         connectPads: new ZoneConnectPads({ enabled: true, clearance: 0.15 }),
         minThickness: 0.25,
@@ -106771,9 +107311,11 @@ var AddCopperPoursStage = class extends ConverterStage {
         fill: new ZoneFill({
           filled: true,
           thermalGap: 0.5,
-          thermalBridgeWidth: 0.5
+          thermalBridgeWidth: 0.5,
+          islandRemovalMode: 0
         }),
-        polygons: [new ZonePolygon(polygonPts)]
+        polygons: createZonePolygons(outerRing, innerRings),
+        filledPolygons: createZoneFilledPolygons(outerRing, innerRings, kicadLayer)
       });
       const zones = kicadPcb.zones;
       zones.push(zone);
@@ -107443,7 +107985,8 @@ function convertCourtyardRects(courtyardRects, componentCenter) {
   }
   return fpRects;
 }
-function convertCourtyardOutlines(courtyardOutlines, componentCenter, componentRotation = 0) {
+function convertCourtyardOutlines(params2) {
+  const { courtyardOutlines, componentCenter, componentRotation = 0 } = params2;
   const fpPolys = [];
   const cj2kicadMatrix = compose4(componentRotation !== 0 ? rotate2(componentRotation * Math.PI / 180) : { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 }, scale2(1, -1), translate4(-componentCenter.x, -componentCenter.y));
   for (const outline of courtyardOutlines) {
@@ -107514,7 +108057,13 @@ function createFpTextFromCircuitJson({
     effects: textEffects
   });
 }
-function convertSilkscreenTexts(silkscreenTexts, componentCenter, componentRotation, sourceComponentName) {
+function convertSilkscreenTexts(params2) {
+  const {
+    silkscreenTexts,
+    componentCenter,
+    componentRotation,
+    sourceComponentName
+  } = params2;
   const fpTexts = [];
   for (const textElement of silkscreenTexts) {
     const fpText = createFpTextFromCircuitJson({
@@ -107570,7 +108119,8 @@ function convertSilkscreenPaths(silkscreenPaths, { componentCenter, componentRot
   }
   return fpLines;
 }
-function convertNoteTexts(noteTexts, componentCenter, componentRotation) {
+function convertNoteTexts(params2) {
+  const { noteTexts, componentCenter, componentRotation } = params2;
   const fpTexts = [];
   for (const textElement of noteTexts) {
     const relX = textElement.anchor_position.x - componentCenter.x;
@@ -107600,17 +108150,19 @@ function create3DModelsFromCadComponent(cadComponent, componentCenter, options)
   const model = new FootprintModel3(modelUrl);
   if (cadComponent.position) {
     const boardLayerZOffset = options?.boardLayerZOffset ?? 0;
+    const modelOriginPosition = cadComponent.model_origin_position;
     model.offset = {
-      x: (cadComponent.position.x || 0) - componentCenter.x,
-      y: (cadComponent.position.y || 0) - componentCenter.y,
-      z: (cadComponent.position.z || 0) - boardLayerZOffset
+      x: (cadComponent.position.x || 0) - componentCenter.x - (modelOriginPosition?.x || 0),
+      y: (cadComponent.position.y || 0) - componentCenter.y - (modelOriginPosition?.y || 0),
+      z: (cadComponent.position.z || 0) - boardLayerZOffset - (modelOriginPosition?.z || 0)
     };
   }
   if (cadComponent.rotation) {
+    const footprintRotation = options?.footprintRotation ?? 0;
     model.rotate = {
       x: cadComponent.rotation.x || 0,
       y: cadComponent.rotation.y || 0,
-      z: cadComponent.rotation.z || 0
+      z: (cadComponent.rotation.z || 0) - footprintRotation
     };
   }
   if (cadComponent.model_unit_to_mm_scale_factor) {
@@ -107689,6 +108241,15 @@ function createSmdPadFromCircuitJson({
     }
     padSize = [pcbPad.width, pcbPad.height];
     rotation = pcbPad.ccw_rotation;
+  } else if (pcbPad.shape === "pill") {
+    padShape = "roundrect";
+    padSize = [pcbPad.width, pcbPad.height];
+    roundrect_rratio = pcbPad.radius / Math.min(pcbPad.width, pcbPad.height);
+  } else if (pcbPad.shape === "rotated_pill") {
+    padShape = "roundrect";
+    padSize = [pcbPad.width, pcbPad.height];
+    roundrect_rratio = pcbPad.radius / Math.min(pcbPad.width, pcbPad.height);
+    rotation = pcbPad.ccw_rotation;
   } else if (pcbPad.shape === "rect") {
     const cornerRadius = pcbPad.corner_radius ?? pcbPad.rect_border_radius;
     if (cornerRadius) {
@@ -107712,6 +108273,7 @@ function createSmdPadFromCircuitJson({
       `${padLayer === "F.Cu" ? "F" : "B"}.Mask`
     ],
     solderMaskMargin: pcbPad.soldermask_margin,
+    roundrectRatio: roundrect_rratio,
     uuid: generateDeterministicUuid(padData)
   });
   if (padOptions) {
@@ -107955,7 +108517,8 @@ function createNpthPadFromCircuitJson({
     uuid: crypto.randomUUID()
   });
 }
-function convertNpthHoles(pcbHoles, componentCenter, componentRotation) {
+function convertNpthHoles(params2) {
+  const { pcbHoles, componentCenter, componentRotation } = params2;
   const pads = [];
   for (const pcbHole of pcbHoles) {
     const pad = createNpthPadFromCircuitJson({
@@ -108028,9 +108591,18 @@ var AddFootprintsStage = class extends ConverterStage {
     });
     const fpTexts = footprint.fpTexts;
     const pcbSilkscreenTexts = this.ctx.db.pcb_silkscreen_text?.list().filter((text) => text.pcb_component_id === component.pcb_component_id) || [];
-    fpTexts.push(...convertSilkscreenTexts(pcbSilkscreenTexts, component.center, component.rotation || 0, sourceComponent?.name));
+    fpTexts.push(...convertSilkscreenTexts({
+      silkscreenTexts: pcbSilkscreenTexts,
+      componentCenter: component.center,
+      componentRotation: component.rotation || 0,
+      sourceComponentName: sourceComponent?.name
+    }));
     const pcbNoteTexts = this.ctx.db.pcb_note_text?.list().filter((text) => text.pcb_component_id === component.pcb_component_id) || [];
-    fpTexts.push(...convertNoteTexts(pcbNoteTexts, component.center, component.rotation || 0));
+    fpTexts.push(...convertNoteTexts({
+      noteTexts: pcbNoteTexts,
+      componentCenter: component.center,
+      componentRotation: component.rotation || 0
+    }));
     footprint.fpTexts = fpTexts;
     const pcbSilkscreenPaths = this.ctx.db.pcb_silkscreen_path?.list().filter((path16) => path16.pcb_component_id === component.pcb_component_id) || [];
     const fpLines = footprint.fpLines ?? [];
@@ -108062,7 +108634,11 @@ var AddFootprintsStage = class extends ConverterStage {
     }, this.ctx);
     fpPads.push(...thruHolePads);
     const pcbHoles = this.ctx.db.pcb_hole?.list().filter((hole) => hole.pcb_component_id === component.pcb_component_id) || [];
-    const npthPads = convertNpthHoles(pcbHoles, component.center, component.rotation || 0);
+    const npthPads = convertNpthHoles({
+      pcbHoles,
+      componentCenter: component.center,
+      componentRotation: component.rotation || 0
+    });
     fpPads.push(...npthPads);
     footprint.fpPads = fpPads;
     const pcbSilkscreenCircles = this.ctx.db.pcb_silkscreen_circle?.list().filter((circle) => circle.pcb_component_id === component.pcb_component_id) || [];
@@ -108080,7 +108656,11 @@ var AddFootprintsStage = class extends ConverterStage {
     fpRects.push(...convertCourtyardRects(pcbCourtyardRects, component.center));
     footprint.fpRects = fpRects;
     const pcbCourtyardOutlines = this.ctx.db.pcb_courtyard_outline?.list().filter((outline) => outline.pcb_component_id === component.pcb_component_id) || [];
-    const fpPolys = convertCourtyardOutlines(pcbCourtyardOutlines, component.center, component.rotation || 0);
+    const fpPolys = convertCourtyardOutlines({
+      courtyardOutlines: pcbCourtyardOutlines,
+      componentCenter: component.center,
+      componentRotation: component.rotation || 0
+    });
     if (fpPolys.length > 0) {
       footprint.fpPolys = fpPolys;
     }
@@ -108088,7 +108668,10 @@ var AddFootprintsStage = class extends ConverterStage {
       const pcbBoard = this.ctx.db.pcb_board?.list()[0];
       const boardThickness = pcbBoard?.thickness ?? 0;
       const boardLayerZOffset = component.layer === "bottom" ? -(boardThickness / 2) : boardThickness / 2;
-      const models = create3DModelsFromCadComponent(cadComponent, component.center, { boardLayerZOffset });
+      const models = create3DModelsFromCadComponent(cadComponent, component.center, {
+        boardLayerZOffset,
+        footprintRotation: component.rotation || 0
+      });
       const KICAD_3D_BASE = "${KIPRJMOD}/3dmodels";
       if (models.length > 0) {
         if (this.includeBuiltin3dModels) {
@@ -108142,6 +108725,24 @@ var AddFootprintsStage = class extends ConverterStage {
     return this.ctx.kicadPcb;
   }
 };
+function getRoutePointLayer(point, pointRoleInSegment) {
+  if ("layer" in point) {
+    return point.layer;
+  }
+  if (point.route_type === "through_pad") {
+    if (pointRoleInSegment === "start") {
+      return point.end_layer;
+    }
+    return point.start_layer;
+  }
+  return;
+}
+function getRoutePointWidth(point) {
+  if ("width" in point) {
+    return point.width;
+  }
+  return;
+}
 var AddTracesStage = class extends ConverterStage {
   tracesProcessed = 0;
   pcbTraces = [];
@@ -108149,6 +108750,18 @@ var AddTracesStage = class extends ConverterStage {
     super(input, ctx);
     this.pcbTraces = this.ctx.db.pcb_trace.list();
   }
+  getRoutePointPosition(point, pointRoleInSegment) {
+    if ("x" in point && "y" in point) {
+      return { x: point.x, y: point.y };
+    }
+    if (point.route_type !== "through_pad") {
+      return null;
+    }
+    if (pointRoleInSegment === "start") {
+      return { x: point.end.x, y: point.end.y };
+    }
+    return { x: point.start.x, y: point.start.y };
+  }
   _step() {
     const { kicadPcb, c2kMatPcb, pcbNetMap } = this.ctx;
     if (!kicadPcb) {
@@ -108162,22 +108775,25 @@ var AddTracesStage = class extends ConverterStage {
       return;
     }
     const trace = this.pcbTraces[this.tracesProcessed];
-    if (!trace.route || trace.route.length < 2) {
+    const route = trace.route;
+    if (!route || route.length < 2) {
       this.tracesProcessed++;
       return;
     }
-    let lastKnownLayer = trace.route[0]?.layer;
-    for (let i = 0;i < trace.route.length - 1; i++) {
-      const startPoint = trace.route[i];
-      const endPoint = trace.route[i + 1];
-      const transformedStart = applyToPoint17(c2kMatPcb, {
-        x: startPoint.x,
-        y: startPoint.y
-      });
-      const transformedEnd = applyToPoint17(c2kMatPcb, {
-        x: endPoint.x,
-        y: endPoint.y
-      });
+    let lastKnownLayer = getRoutePointLayer(route[0], "start");
+    for (let i = 0;i < route.length - 1; i++) {
+      const startPoint = route[i];
+      const endPoint = route[i + 1];
+      const startPosition = this.getRoutePointPosition(startPoint, "start");
+      const endPosition = this.getRoutePointPosition(endPoint, "end");
+      if (!startPosition || !endPosition) {
+        throw new Error(`Unable to convert pcb_trace route segment ${trace.pcb_trace_id ?? this.tracesProcessed}:${i} to KiCad segment`);
+      }
+      const transformedStart = applyToPoint17(c2kMatPcb, startPosition);
+      const transformedEnd = applyToPoint17(c2kMatPcb, endPosition);
+      if (transformedStart.x === transformedEnd.x && transformedStart.y === transformedEnd.y) {
+        continue;
+      }
       let netInfo;
       if (pcbNetMap) {
         let connectivityKey = trace.subcircuit_connectivity_map_key;
@@ -108206,25 +108822,27 @@ var AddTracesStage = class extends ConverterStage {
           netInfo = pcbNetMap.get(connectivityKey);
         }
       }
-      const segmentLayerSource = startPoint.layer ?? endPoint.layer ?? lastKnownLayer;
+      const segmentLayerSource = getRoutePointLayer(startPoint, "start") ?? getRoutePointLayer(endPoint, "end") ?? lastKnownLayer;
       const kicadLayer = getKicadLayer(segmentLayerSource);
       const segmentData = `segment:${transformedStart.x},${transformedStart.y}:${transformedEnd.x},${transformedEnd.y}:${kicadLayer}:${netInfo?.id ?? 0}`;
       const segment = new Segment({
         start: { x: transformedStart.x, y: transformedStart.y },
         end: { x: transformedEnd.x, y: transformedEnd.y },
         layer: kicadLayer,
-        width: startPoint.width ?? endPoint.width ?? trace.width ?? 0.25,
+        width: getRoutePointWidth(startPoint) ?? getRoutePointWidth(endPoint) ?? trace.width ?? 0.25,
         net: new SegmentNet(netInfo?.id ?? 0),
         uuid: generateDeterministicUuid(segmentData)
       });
       const segments = kicadPcb.segments;
       segments.push(segment);
       kicadPcb.segments = segments;
-      if (startPoint.layer) {
-        lastKnownLayer = startPoint.layer;
+      const startLayer = getRoutePointLayer(startPoint, "start");
+      const endLayer = getRoutePointLayer(endPoint, "end");
+      if (startLayer) {
+        lastKnownLayer = startLayer;
       }
-      if (endPoint.layer) {
-        lastKnownLayer = endPoint.layer;
+      if (endLayer) {
+        lastKnownLayer = endLayer;
       }
     }
     this.tracesProcessed++;
@@ -108424,7 +109042,11 @@ var AddStandalonePcbElements = class extends ConverterStage {
         uuid: generateDeterministicUuid(footprintSeed)
       });
       const ccwRotationDegrees = 0;
-      const npthPads = convertNpthHoles([hole], { x: hole.x, y: hole.y }, ccwRotationDegrees);
+      const npthPads = convertNpthHoles({
+        pcbHoles: [hole],
+        componentCenter: { x: hole.x, y: hole.y },
+        componentRotation: ccwRotationDegrees
+      });
       if (npthPads.length > 0) {
         footprint.fpPads = npthPads;
         const footprints = kicadPcb.footprints;
@@ -108575,7 +109197,8 @@ function createFabricationNoteTextFromCircuitJson({
   const grText = new GrText({
     text: textElement.text,
     layer: kicadLayer,
-    effects: textEffects
+    effects: textEffects,
+    uuid: generateDeterministicUuid(textElement.pcb_fabrication_note_text_id ?? textElement.text)
   });
   grText.position = position;
   return grText;
@@ -108632,7 +109255,8 @@ function createGrTextFromCircuitJson({
   const grText = new GrText2({
     text: textElement.text,
     layer: kicadLayer,
-    effects: textEffects
+    effects: textEffects,
+    uuid: generateDeterministicUuid(textElement.pcb_silkscreen_text_id ?? textElement.text)
   });
   grText.position = position;
   return grText;
@@ -108651,6 +109275,44 @@ var normalizeOutlineCorners = (corners) => {
   }
   return dedupedCorners;
 };
+var EDGE_CUTS_WIDTH = 0.1;
+var appendGraphicLine = (kicadPcb, grLine) => {
+  const graphicLines = kicadPcb.graphicLines;
+  graphicLines.push(grLine);
+  kicadPcb.graphicLines = graphicLines;
+};
+var appendGraphicCircle = (kicadPcb, grCircle) => {
+  const graphicCircles = kicadPcb.graphicCircles;
+  graphicCircles.push(grCircle);
+  kicadPcb.graphicCircles = graphicCircles;
+};
+var appendGraphicPoly = (kicadPcb, grPoly) => {
+  const graphicPolys = kicadPcb.graphicPolys;
+  graphicPolys.push(grPoly);
+  kicadPcb.graphicPolys = graphicPolys;
+};
+var rotatePointAroundOrigin = (point, rotationDegrees = 0) => {
+  if (!rotationDegrees)
+    return point;
+  return applyToPoint22(rotate9(rotationDegrees * Math.PI / 180), point);
+};
+var getRectCutoutCorners = (cutout) => {
+  const halfWidth = cutout.width / 2;
+  const halfHeight = cutout.height / 2;
+  const localCorners = [
+    { x: -halfWidth, y: -halfHeight },
+    { x: halfWidth, y: -halfHeight },
+    { x: halfWidth, y: halfHeight },
+    { x: -halfWidth, y: halfHeight }
+  ];
+  return localCorners.map((point) => {
+    const rotatedPoint = rotatePointAroundOrigin(point, cutout.rotation);
+    return {
+      x: rotatedPoint.x + cutout.center.x,
+      y: rotatedPoint.y + cutout.center.y
+    };
+  });
+};
 var AddGraphicsStage = class extends ConverterStage {
   _step() {
     const { kicadPcb, c2kMatPcb } = this.ctx;
@@ -108688,9 +109350,7 @@ var AddGraphicsStage = class extends ConverterStage {
           layer: kicadLayer,
           width: path16.stroke_width || 0.15
         });
-        const graphicLines = kicadPcb.graphicLines;
-        graphicLines.push(grLine);
-        kicadPcb.graphicLines = graphicLines;
+        appendGraphicLine(kicadPcb, grLine);
       }
     }
     const standaloneSilkscreenTexts = this.ctx.db.pcb_silkscreen_text?.list().filter((text) => !text.pcb_component_id) || [];
@@ -108753,11 +109413,62 @@ var AddGraphicsStage = class extends ConverterStage {
           start: { x: start.x, y: start.y },
           end: { x: end.x, y: end.y },
           layer: "Edge.Cuts",
-          width: 0.1
+          width: EDGE_CUTS_WIDTH
         });
-        const graphicLines = kicadPcb.graphicLines;
-        graphicLines.push(edgeLine);
-        kicadPcb.graphicLines = graphicLines;
+        appendGraphicLine(kicadPcb, edgeLine);
+      }
+    }
+    const pcbCutouts = this.ctx.db.pcb_cutout?.list() || [];
+    for (const cutout of pcbCutouts) {
+      if (cutout.shape === "circle") {
+        const transformedCenter = applyToPoint22(c2kMatPcb, cutout.center);
+        const transformedEnd = applyToPoint22(c2kMatPcb, {
+          x: cutout.center.x + cutout.radius,
+          y: cutout.center.y
+        });
+        appendGraphicCircle(kicadPcb, new GrCircle({
+          center: transformedCenter,
+          end: transformedEnd,
+          layer: "Edge.Cuts",
+          width: EDGE_CUTS_WIDTH
+        }));
+      } else if (cutout.shape === "polygon") {
+        const corners = normalizeOutlineCorners(cutout.points);
+        if (corners.length < 3)
+          continue;
+        appendGraphicPoly(kicadPcb, new GrPoly({
+          points: corners.map((point) => applyToPoint22(c2kMatPcb, point)),
+          layer: "Edge.Cuts",
+          width: EDGE_CUTS_WIDTH,
+          fill: false
+        }));
+      } else if (cutout.shape === "rect") {
+        const corners = normalizeOutlineCorners(getRectCutoutCorners(cutout));
+        if (corners.length < 3)
+          continue;
+        appendGraphicPoly(kicadPcb, new GrPoly({
+          points: corners.map((point) => applyToPoint22(c2kMatPcb, point)),
+          layer: "Edge.Cuts",
+          width: EDGE_CUTS_WIDTH,
+          fill: false
+        }));
+      } else if (cutout.shape === "path") {
+        if (!cutout.route || cutout.route.length < 2)
+          continue;
+        for (let i = 0;i < cutout.route.length - 1; i++) {
+          const startPoint = cutout.route[i];
+          const endPoint = cutout.route[i + 1];
+          if (!startPoint || !endPoint)
+            continue;
+          const transformedStart = applyToPoint22(c2kMatPcb, startPoint);
+          const transformedEnd = applyToPoint22(c2kMatPcb, endPoint);
+          appendGraphicLine(kicadPcb, new GrLine({
+            start: transformedStart,
+            end: transformedEnd,
+            layer: "Edge.Cuts",
+            width: EDGE_CUTS_WIDTH
+          }));
+        }
       }
     }
     this.finished = true;
@@ -116114,7 +116825,7 @@ class RBush {
   search(bbox) {
     let node = this.data;
     const result = [];
-    if (!intersects(bbox, node))
+    if (!intersects2(bbox, node))
       return result;
     const toBBox = this.toBBox;
     const nodesToSearch = [];
@@ -116122,7 +116833,7 @@ class RBush {
       for (let i = 0;i < node.children.length; i++) {
         const child = node.children[i];
         const childBBox = node.leaf ? toBBox(child) : child;
-        if (intersects(bbox, childBBox)) {
+        if (intersects2(bbox, childBBox)) {
           if (node.leaf)
             result.push(child);
           else if (contains(bbox, childBBox))
@@ -116137,14 +116848,14 @@ class RBush {
   }
   collides(bbox) {
     let node = this.data;
-    if (!intersects(bbox, node))
+    if (!intersects2(bbox, node))
       return false;
     const nodesToSearch = [];
     while (node) {
       for (let i = 0;i < node.children.length; i++) {
         const child = node.children[i];
         const childBBox = node.leaf ? this.toBBox(child) : child;
-        if (intersects(bbox, childBBox)) {
+        if (intersects2(bbox, childBBox)) {
           if (node.leaf || contains(bbox, childBBox))
             return true;
           nodesToSearch.push(child);
@@ -116184,7 +116895,7 @@ class RBush {
     return this;
   }
   clear() {
-    this.data = createNode([]);
+    this.data = createNode2([]);
     return this;
   }
   remove(item, equalsFn) {
@@ -116258,7 +116969,7 @@ class RBush {
     let M = this._maxEntries;
     let node;
     if (N <= M) {
-      node = createNode(items.slice(left, right + 1));
+      node = createNode2(items.slice(left, right + 1));
       calcBBox(node, this.toBBox);
       return node;
     }
@@ -116266,7 +116977,7 @@ class RBush {
       height = Math.ceil(Math.log(N) / Math.log(M));
       M = Math.ceil(N / Math.pow(M, height - 1));
     }
-    node = createNode([]);
+    node = createNode2([]);
     node.leaf = false;
     node.height = height;
     const N2 = Math.ceil(N / M);
@@ -116293,15 +117004,15 @@ class RBush {
       let targetNode;
       for (let i = 0;i < node.children.length; i++) {
         const child = node.children[i];
-        const area = bboxArea(child);
-        const enlargement = enlargedArea(bbox, child) - area;
+        const area2 = bboxArea(child);
+        const enlargement = enlargedArea(bbox, child) - area2;
         if (enlargement < minEnlargement) {
           minEnlargement = enlargement;
-          minArea = area < minArea ? area : minArea;
+          minArea = area2 < minArea ? area2 : minArea;
           targetNode = child;
         } else if (enlargement === minEnlargement) {
-          if (area < minArea) {
-            minArea = area;
+          if (area2 < minArea) {
+            minArea = area2;
             targetNode = child;
           }
         }
@@ -116331,7 +117042,7 @@ class RBush {
     const m = this._minEntries;
     this._chooseSplitAxis(node, m, M);
     const splitIndex = this._chooseSplitIndex(node, m, M);
-    const newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));
+    const newNode = createNode2(node.children.splice(splitIndex, node.children.length - splitIndex));
     newNode.height = node.height;
     newNode.leaf = node.leaf;
     calcBBox(node, this.toBBox);
@@ -116342,7 +117053,7 @@ class RBush {
       this._splitRoot(node, newNode);
   }
   _splitRoot(node, newNode) {
-    this.data = createNode([node, newNode]);
+    this.data = createNode2([node, newNode]);
     this.data.height = node.height + 1;
     this.data.leaf = false;
     calcBBox(this.data, this.toBBox);
@@ -116355,14 +117066,14 @@ class RBush {
       const bbox1 = distBBox(node, 0, i, this.toBBox);
       const bbox2 = distBBox(node, i, M, this.toBBox);
       const overlap = intersectionArea(bbox1, bbox2);
-      const area = bboxArea(bbox1) + bboxArea(bbox2);
+      const area2 = bboxArea(bbox1) + bboxArea(bbox2);
       if (overlap < minOverlap) {
         minOverlap = overlap;
         index = i;
-        minArea = area < minArea ? area : minArea;
+        minArea = area2 < minArea ? area2 : minArea;
       } else if (overlap === minOverlap) {
-        if (area < minArea) {
-          minArea = area;
+        if (area2 < minArea) {
+          minArea = area2;
           index = i;
         }
       }
@@ -116427,7 +117138,7 @@ function calcBBox(node, toBBox) {
 }
 function distBBox(node, k, p, toBBox, destNode) {
   if (!destNode)
-    destNode = createNode(null);
+    destNode = createNode2(null);
   destNode.minX = Infinity;
   destNode.minY = Infinity;
   destNode.maxX = -Infinity;
@@ -116470,10 +117181,10 @@ function intersectionArea(a, b) {
 function contains(a, b) {
   return a.minX <= b.minX && a.minY <= b.minY && b.maxX <= a.maxX && b.maxY <= a.maxY;
 }
-function intersects(a, b) {
+function intersects2(a, b) {
   return b.minX <= a.maxX && b.minY <= a.maxY && b.maxX >= a.minX && b.maxY >= a.minY;
 }
-function createNode(children) {
+function createNode2(children) {
   return {
     children,
     height: 1,
@@ -117557,15 +118268,15 @@ var getLargestEmptySpaceFromPoint = (x, y, boardBounds, occupiedBounds, occupied
   return horizontalArea >= verticalArea ? horizontalFirst : verticalFirst;
 };
 var createEmptySpaceIndexItem = (bounds, boardArea, sequenceNumber) => {
-  const area = bounds.width * bounds.height;
+  const area2 = bounds.width * bounds.height;
   return {
     id: `empty-space-${sequenceNumber}`,
     minX: bounds.min_x,
     minY: bounds.min_y,
     maxX: bounds.max_x,
     maxY: bounds.max_y,
-    area,
-    areaPercent: boardArea === 0 ? 0 : area / boardArea * 100,
+    area: area2,
+    areaPercent: boardArea === 0 ? 0 : area2 / boardArea * 100,
     bounds: toPlacementBounds(bounds)
   };
 };
@@ -117579,8 +118290,8 @@ var buildLargeEmptySpaces = (boardBounds, occupiedBounds, occupiedIndex, boardAr
       const bounds = getLargestEmptySpaceFromPoint(x, y, boardBounds, occupiedBounds, occupiedIndex);
       if (!bounds)
         continue;
-      const area = bounds.width * bounds.height;
-      if (area <= thresholdArea)
+      const area2 = bounds.width * bounds.height;
+      if (area2 <= thresholdArea)
         continue;
       const candidate = createEmptySpaceIndexItem(bounds, boardArea, sequenceNumber++);
       const overlappingSpaces = emptySpaceIndex.search(candidate).filter((space) => boundsOverlapWithArea(bounds, createBounds(space.minX, space.maxX, space.minY, space.maxY)));
@@ -117593,8 +118304,8 @@ var buildLargeEmptySpaces = (boardBounds, occupiedBounds, occupiedIndex, boardAr
       emptySpaceIndex.insert(candidate);
     }
   }
-  return emptySpaceIndex.all().map(({ area, areaPercent, bounds }) => ({
-    area,
+  return emptySpaceIndex.all().map(({ area: area2, areaPercent, bounds }) => ({
+    area: area2,
     areaPercent,
     bounds
   })).sort((a, b) => {
@@ -141734,7 +142445,7 @@ var require_reader4 = __commonJS22({
       element: "element",
       text: "text"
     };
-    var createNode2 = function createNode22(params2) {
+    var createNode3 = function createNode22(params2) {
       return Object.assign({
         name: "",
         type: NodeType.element,
@@ -141762,7 +142473,7 @@ var require_reader4 = __commonJS22({
               current2 = rootNode;
               current2.name = data.value;
             } else {
-              var node = createNode2({
+              var node = createNode3({
                 name: data.value,
                 parent: current2
               });
@@ -141795,7 +142506,7 @@ var require_reader4 = __commonJS22({
             break;
           case Type.text:
             if (current2) {
-              current2.children.push(createNode2({
+              current2.children.push(createNode3({
                 type: NodeType.text,
                 value: data.value,
                 parent: options.parentNodes ? current2 : null
@@ -141814,7 +142525,7 @@ var require_reader4 = __commonJS22({
       reader.reset = function() {
         lexer = Lexer.create({ debug: options.debug });
         lexer.on("data", handleLexerData);
-        rootNode = createNode2();
+        rootNode = createNode3();
         current2 = null;
         attrName = "";
         reader.parse = lexer.write;
@@ -175787,13 +176498,13 @@ function doSegmentsIntersect2(p12, q12, p22, q22) {
   if (o12 !== o22 && o3 !== o4) {
     return true;
   }
-  if (o12 === 0 && onSegment2(p12, p22, q12))
+  if (o12 === 0 && onSegment3(p12, p22, q12))
     return true;
-  if (o22 === 0 && onSegment2(p12, q22, q12))
+  if (o22 === 0 && onSegment3(p12, q22, q12))
     return true;
-  if (o3 === 0 && onSegment2(p22, p12, q22))
+  if (o3 === 0 && onSegment3(p22, p12, q22))
     return true;
-  if (o4 === 0 && onSegment2(p22, q12, q22))
+  if (o4 === 0 && onSegment3(p22, q12, q22))
     return true;
   return false;
 }
@@ -175803,7 +176514,7 @@ function orientation2(p3, q22, r22) {
     return 0;
   return val > 0 ? 1 : 2;
 }
-function onSegment2(p3, q22, r22) {
+function onSegment3(p3, q22, r22) {
   return q22.x <= Math.max(p3.x, r22.x) && q22.x >= Math.min(p3.x, r22.x) && q22.y <= Math.max(p3.y, r22.y) && q22.y >= Math.min(p3.y, r22.y);
 }
 function segmentsDistance2(a12, a2, b12, b22) {
@@ -175910,8 +176621,8 @@ var isPointInsidePolygon = (point5, polygon2) => {
     const yi22 = polygon2[i2].y;
     const xj = polygon2[j22].x;
     const yj = polygon2[j22].y;
-    const intersects2 = yi22 > point5.y !== yj > point5.y && point5.x < (xj - xi22) * (point5.y - yi22) / (yj - yi22) + xi22;
-    if (intersects2) {
+    const intersects3 = yi22 > point5.y !== yj > point5.y && point5.x < (xj - xi22) * (point5.y - yi22) / (yj - yi22) + xi22;
+    if (intersects3) {
       inside2 = !inside2;
     }
   }
@@ -197493,24 +198204,24 @@ function parse2(formula) {
   }
   let idx = 0;
   let a2 = 0;
-  let sign = readSign();
+  let sign2 = readSign();
   let number = readNumber();
   if (idx < formula.length && formula.charAt(idx) === "n") {
     idx++;
-    a2 = sign * (number !== null && number !== undefined ? number : 1);
+    a2 = sign2 * (number !== null && number !== undefined ? number : 1);
     skipWhitespace();
     if (idx < formula.length) {
-      sign = readSign();
+      sign2 = readSign();
       skipWhitespace();
       number = readNumber();
     } else {
-      sign = number = 0;
+      sign2 = number = 0;
     }
   }
   if (number === null || idx < formula.length) {
     throw new Error(`n-th rule couldn't be parsed ('${formula}')`);
   }
-  return [a2, sign * number];
+  return [a2, sign2 * number];
   function readSign() {
     if (formula.charAt(idx) === "-") {
       idx++;
@@ -197574,7 +198285,7 @@ var filters = {
       return next(elem) && adapter.getText(elem).toLowerCase().includes(itext);
     };
   },
-  "nth-child"(next, rule, { adapter, equals }) {
+  "nth-child"(next, rule, { adapter, equals: equals2 }) {
     const func = nthCheck(rule);
     if (func === import_boolbase3.default.falseFunc)
       return import_boolbase3.default.falseFunc;
@@ -197584,7 +198295,7 @@ var filters = {
       const siblings = adapter.getSiblings(elem);
       let pos = 0;
       for (let i2 = 0;i2 < siblings.length; i2++) {
-        if (equals(elem, siblings[i2]))
+        if (equals2(elem, siblings[i2]))
           break;
         if (adapter.isTag(siblings[i2])) {
           pos++;
@@ -197593,7 +198304,7 @@ var filters = {
       return func(pos) && next(elem);
     };
   },
-  "nth-last-child"(next, rule, { adapter, equals }) {
+  "nth-last-child"(next, rule, { adapter, equals: equals2 }) {
     const func = nthCheck(rule);
     if (func === import_boolbase3.default.falseFunc)
       return import_boolbase3.default.falseFunc;
@@ -197603,7 +198314,7 @@ var filters = {
       const siblings = adapter.getSiblings(elem);
       let pos = 0;
       for (let i2 = siblings.length - 1;i2 >= 0; i2--) {
-        if (equals(elem, siblings[i2]))
+        if (equals2(elem, siblings[i2]))
           break;
         if (adapter.isTag(siblings[i2])) {
           pos++;
@@ -197612,7 +198323,7 @@ var filters = {
       return func(pos) && next(elem);
     };
   },
-  "nth-of-type"(next, rule, { adapter, equals }) {
+  "nth-of-type"(next, rule, { adapter, equals: equals2 }) {
     const func = nthCheck(rule);
     if (func === import_boolbase3.default.falseFunc)
       return import_boolbase3.default.falseFunc;
@@ -197623,7 +198334,7 @@ var filters = {
       let pos = 0;
       for (let i2 = 0;i2 < siblings.length; i2++) {
         const currentSibling = siblings[i2];
-        if (equals(elem, currentSibling))
+        if (equals2(elem, currentSibling))
           break;
         if (adapter.isTag(currentSibling) && adapter.getName(currentSibling) === adapter.getName(elem)) {
           pos++;
@@ -197632,7 +198343,7 @@ var filters = {
       return func(pos) && next(elem);
     };
   },
-  "nth-last-of-type"(next, rule, { adapter, equals }) {
+  "nth-last-of-type"(next, rule, { adapter, equals: equals2 }) {
     const func = nthCheck(rule);
     if (func === import_boolbase3.default.falseFunc)
       return import_boolbase3.default.falseFunc;
@@ -197643,7 +198354,7 @@ var filters = {
       let pos = 0;
       for (let i2 = siblings.length - 1;i2 >= 0; i2--) {
         const currentSibling = siblings[i2];
-        if (equals(elem, currentSibling))
+        if (equals2(elem, currentSibling))
           break;
         if (adapter.isTag(currentSibling) && adapter.getName(currentSibling) === adapter.getName(elem)) {
           pos++;
@@ -197659,12 +198370,12 @@ var filters = {
     };
   },
   scope(next, rule, options, context) {
-    const { equals } = options;
+    const { equals: equals2 } = options;
     if (!context || context.length === 0) {
       return filters["root"](next, rule, options);
     }
     if (context.length === 1) {
-      return (elem) => equals(context[0], elem) && next(elem);
+      return (elem) => equals2(context[0], elem) && next(elem);
     }
     return (elem) => context.includes(elem) && next(elem);
   },
@@ -197687,29 +198398,29 @@ var pseudos = {
   empty(elem, { adapter }) {
     return !adapter.getChildren(elem).some((elem2) => adapter.isTag(elem2) || adapter.getText(elem2) !== "");
   },
-  "first-child"(elem, { adapter, equals }) {
+  "first-child"(elem, { adapter, equals: equals2 }) {
     if (adapter.prevElementSibling) {
       return adapter.prevElementSibling(elem) == null;
     }
     const firstChild = adapter.getSiblings(elem).find((elem2) => adapter.isTag(elem2));
-    return firstChild != null && equals(elem, firstChild);
+    return firstChild != null && equals2(elem, firstChild);
   },
-  "last-child"(elem, { adapter, equals }) {
+  "last-child"(elem, { adapter, equals: equals2 }) {
     const siblings = adapter.getSiblings(elem);
     for (let i2 = siblings.length - 1;i2 >= 0; i2--) {
-      if (equals(elem, siblings[i2]))
+      if (equals2(elem, siblings[i2]))
         return true;
       if (adapter.isTag(siblings[i2]))
         break;
     }
     return false;
   },
-  "first-of-type"(elem, { adapter, equals }) {
+  "first-of-type"(elem, { adapter, equals: equals2 }) {
     const siblings = adapter.getSiblings(elem);
     const elemName = adapter.getName(elem);
     for (let i2 = 0;i2 < siblings.length; i2++) {
       const currentSibling = siblings[i2];
-      if (equals(elem, currentSibling))
+      if (equals2(elem, currentSibling))
         return true;
       if (adapter.isTag(currentSibling) && adapter.getName(currentSibling) === elemName) {
         break;
@@ -197717,12 +198428,12 @@ var pseudos = {
     }
     return false;
   },
-  "last-of-type"(elem, { adapter, equals }) {
+  "last-of-type"(elem, { adapter, equals: equals2 }) {
     const siblings = adapter.getSiblings(elem);
     const elemName = adapter.getName(elem);
     for (let i2 = siblings.length - 1;i2 >= 0; i2--) {
       const currentSibling = siblings[i2];
-      if (equals(elem, currentSibling))
+      if (equals2(elem, currentSibling))
         return true;
       if (adapter.isTag(currentSibling) && adapter.getName(currentSibling) === elemName) {
         break;
@@ -197730,12 +198441,12 @@ var pseudos = {
     }
     return false;
   },
-  "only-of-type"(elem, { adapter, equals }) {
+  "only-of-type"(elem, { adapter, equals: equals2 }) {
     const elemName = adapter.getName(elem);
-    return adapter.getSiblings(elem).every((sibling) => equals(elem, sibling) || !adapter.isTag(sibling) || adapter.getName(sibling) !== elemName);
+    return adapter.getSiblings(elem).every((sibling) => equals2(elem, sibling) || !adapter.isTag(sibling) || adapter.getName(sibling) !== elemName);
   },
-  "only-child"(elem, { adapter, equals }) {
-    return adapter.getSiblings(elem).every((sibling) => equals(elem, sibling) || !adapter.isTag(sibling));
+  "only-child"(elem, { adapter, equals: equals2 }) {
+    return adapter.getSiblings(elem).every((sibling) => equals2(elem, sibling) || !adapter.isTag(sibling));
   }
 };
 function verifyPseudoArgs(func, name, subselect, argIndex) {
@@ -197876,7 +198587,7 @@ function getElementParent(node, adapter) {
   return null;
 }
 function compileGeneralSelector(next, selector, options, context, compileToken2) {
-  const { adapter, equals } = options;
+  const { adapter, equals: equals2 } = options;
   switch (selector.type) {
     case SelectorType.PseudoElement: {
       throw new Error("Pseudo-elements are not supported by css-select");
@@ -197960,7 +198671,7 @@ function compileGeneralSelector(next, selector, options, context, compileToken2)
         const siblings = adapter.getSiblings(elem);
         for (let i2 = 0;i2 < siblings.length; i2++) {
           const currentSibling = siblings[i2];
-          if (equals(elem, currentSibling))
+          if (equals2(elem, currentSibling))
             break;
           if (adapter.isTag(currentSibling) && next(currentSibling)) {
             return true;
@@ -197981,7 +198692,7 @@ function compileGeneralSelector(next, selector, options, context, compileToken2)
         let lastElement;
         for (let i2 = 0;i2 < siblings.length; i2++) {
           const currentSibling = siblings[i2];
-          if (equals(elem, currentSibling))
+          if (equals2(elem, currentSibling))
             break;
           if (adapter.isTag(currentSibling)) {
             lastElement = currentSibling;
@@ -201878,8 +202589,8 @@ var Arc = class extends Shape {
   }
   definiteIntegral(ymin = 0) {
     let f_arcs = this.breakToFunctional();
-    let area = f_arcs.reduce((acc, arc2) => acc + arc2.circularSegmentDefiniteIntegral(ymin), 0);
-    return area;
+    let area2 = f_arcs.reduce((acc, arc2) => acc + arc2.circularSegmentDefiniteIntegral(ymin), 0);
+    return area2;
   }
   circularSegmentDefiniteIntegral(ymin) {
     let segment2 = new Flatten.Segment(this.start, this.end);
@@ -202173,9 +202884,9 @@ var Edge = class {
       let largeArcFlag;
       let sweepFlag = arc2.counterClockwise ? "1" : "0";
       if (Flatten.Utils.EQ(arc2.sweep, 2 * Math.PI)) {
-        let sign = arc2.counterClockwise ? 1 : -1;
-        let halfArc1 = new Flatten.Arc(arc2.pc, arc2.r, arc2.startAngle, arc2.startAngle + sign * Math.PI, arc2.counterClockwise);
-        let halfArc2 = new Flatten.Arc(arc2.pc, arc2.r, arc2.startAngle + sign * Math.PI, arc2.endAngle, arc2.counterClockwise);
+        let sign2 = arc2.counterClockwise ? 1 : -1;
+        let halfArc1 = new Flatten.Arc(arc2.pc, arc2.r, arc2.startAngle, arc2.startAngle + sign2 * Math.PI, arc2.counterClockwise);
+        let halfArc2 = new Flatten.Arc(arc2.pc, arc2.r, arc2.startAngle + sign2 * Math.PI, arc2.endAngle, arc2.counterClockwise);
         largeArcFlag = "0";
         return ` A${halfArc1.r},${halfArc1.r} 0 ${largeArcFlag},${sweepFlag} ${halfArc1.end.x},${halfArc1.end.y}
                     A${halfArc2.r},${halfArc2.r} 0 ${largeArcFlag},${sweepFlag} ${halfArc2.end.x},${halfArc2.end.y}`;
@@ -202426,10 +203137,10 @@ var Face = class _Face extends CircularLinkedList {
   }
   orientation() {
     if (this._orientation === undefined) {
-      let area = this.signedArea();
-      if (Flatten.Utils.EQ_0(area)) {
+      let area2 = this.signedArea();
+      if (Flatten.Utils.EQ_0(area2)) {
         this._orientation = ORIENTATION.NOT_ORIENTABLE;
-      } else if (Flatten.Utils.LT(area, 0)) {
+      } else if (Flatten.Utils.LT(area2, 0)) {
         this._orientation = ORIENTATION.CCW;
       } else {
         this._orientation = ORIENTATION.CW;
@@ -206453,16 +207164,16 @@ function simplifyCollinearSegments(outline, tolerance = 0.0000000001) {
   }
   return simplified;
 }
-function signedArea(points) {
-  let area = 0;
+function signedArea2(points) {
+  let area2 = 0;
   for (let i2 = 0;i2 < points.length; i2++) {
     const j22 = (i2 + 1) % points.length;
     const pi22 = points[i2];
     const pj = points[j22];
-    area += pi22.x * pj.y;
-    area -= pj.x * pi22.y;
+    area2 += pi22.x * pj.y;
+    area2 -= pj.x * pi22.y;
   }
-  return area / 2;
+  return area2 / 2;
 }
 function extractFacePoints(face) {
   const points = [];
@@ -206485,10 +207196,10 @@ function parseFlattenPolygonLoops(polygon2) {
     const points = extractFacePoints(face);
     if (points.length < 3)
       continue;
-    const area = signedArea(points);
-    if (area > 0) {
+    const area2 = signedArea2(points);
+    if (area2 > 0) {
       obstacleFreeLoops.push(points);
-    } else if (area < 0) {
+    } else if (area2 < 0) {
       obstacleContainingLoops.push(points);
     }
   }
@@ -207245,7 +207956,7 @@ function getOutwardNormal(outlineSegment, ccwFullOutline) {
       verts.push(seg[1]);
     }
   }
-  const signedArea2 = (() => {
+  const signedArea22 = (() => {
     let a2 = 0;
     for (let i2 = 0;i2 < verts.length; i2++) {
       const v12 = verts[i2];
@@ -207254,8 +207965,8 @@ function getOutwardNormal(outlineSegment, ccwFullOutline) {
     }
     return a2 / 2;
   })();
-  const geometricOutward = signedArea2 > 0 ? right : left;
-  const isCW = signedArea2 < 0;
+  const geometricOutward = signedArea22 > 0 ? right : left;
+  const isCW = signedArea22 < 0;
   if (isCW) {
     return { x: -geometricOutward.x, y: -geometricOutward.y };
   }
@@ -207460,9 +208171,9 @@ var LargestRectOutsideOutlineFromPointSolver = class extends BaseSolver2 {
         if (xi22 === undefined || xj1 === undefined)
           continue;
         const width = xj1 - xi22;
-        const area = width * height;
-        if (area > bestArea) {
-          bestArea = area;
+        const area2 = width * height;
+        if (area2 > bestArea) {
+          bestArea = area2;
           best = { x: xi22, y: maxBot, w: width, h: height };
         }
       }
@@ -207706,14 +208417,14 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver2 {
       y: this.largestRectMidPoint.y + outwardNormal.y * 0.0001
     };
     const outlinePoints = this.ccwFullOutline.flatMap(([p3]) => p3);
-    let signedArea2 = 0;
+    let signedArea22 = 0;
     for (let i2 = 0;i2 < outlinePoints.length; i2++) {
       const p122 = outlinePoints[i2];
       const p222 = outlinePoints[(i2 + 1) % outlinePoints.length];
-      signedArea2 += p122.x * p222.y - p222.x * p122.y;
+      signedArea22 += p122.x * p222.y - p222.x * p122.y;
     }
-    signedArea2 /= 2;
-    const isCW = signedArea2 < 0;
+    signedArea22 /= 2;
+    const isCW = signedArea22 < 0;
     const rectSearchMode = isCW ? "inside" : "outside";
     const largestRectSolverParams = {
       ccwFullOutline: outlinePoints,
@@ -208762,26 +209473,26 @@ function getPolygonCentroid(points) {
     const sumY = points.reduce((sum, p3) => sum + p3.y, 0);
     return { x: sumX / points.length, y: sumY / points.length };
   }
-  let signedArea2 = 0;
+  let signedArea22 = 0;
   let cx2 = 0;
   let cy2 = 0;
   for (let i2 = 0;i2 < points.length; i2++) {
     const p12 = points[i2];
     const p22 = points[(i2 + 1) % points.length];
     const crossProduct = p12.x * p22.y - p22.x * p12.y;
-    signedArea2 += crossProduct;
+    signedArea22 += crossProduct;
     cx2 += (p12.x + p22.x) * crossProduct;
     cy2 += (p12.y + p22.y) * crossProduct;
   }
-  signedArea2 *= 0.5;
-  const area = Math.abs(signedArea2);
-  if (area < 0.0000000001) {
+  signedArea22 *= 0.5;
+  const area2 = Math.abs(signedArea22);
+  if (area2 < 0.0000000001) {
     const sumX = points.reduce((sum, p3) => sum + p3.x, 0);
     const sumY = points.reduce((sum, p3) => sum + p3.y, 0);
     return { x: sumX / points.length, y: sumY / points.length };
   }
-  cx2 /= 6 * signedArea2;
-  cy2 /= 6 * signedArea2;
+  cx2 /= 6 * signedArea22;
+  cy2 /= 6 * signedArea22;
   return { x: cx2, y: cy2 };
 }
 var PackSolver2 = class extends BaseSolver2 {
@@ -218496,14 +219207,14 @@ var BJTCommand = class {
     this.props = props;
   }
   toSpiceString() {
-    const { name, collector, base, emitter, substrate, model, area } = this.props;
+    const { name, collector, base, emitter, substrate, model, area: area2 } = this.props;
     let spiceString = `Q${name} ${collector} ${base} ${emitter}`;
     if (substrate) {
       spiceString += ` ${substrate}`;
     }
     spiceString += ` ${model}`;
-    if (area) {
-      spiceString += ` ${area}`;
+    if (area2) {
+      spiceString += ` ${area2}`;
     }
     return spiceString;
   }
@@ -218562,10 +219273,10 @@ var DiodeCommand = class {
     this.props = props;
   }
   toSpiceString() {
-    const { name, positiveNode, negativeNode, model, area } = this.props;
+    const { name, positiveNode, negativeNode, model, area: area2 } = this.props;
     let spiceString = `D${name} ${positiveNode} ${negativeNode} ${model}`;
-    if (area) {
-      spiceString += ` ${area}`;
+    if (area2) {
+      spiceString += ` ${area2}`;
     }
     return spiceString;
   }
@@ -223381,14 +224092,14 @@ var PrimitiveComponent2 = class extends Renderable {
   computePcbPropsTransform() {
     const rotation4 = this._getPcbRotationBeforeLayout() ?? 0;
     const { pcbX, pcbY } = this.getResolvedPcbPositionProp();
-    const matrix2 = compose7(translate7(pcbX, pcbY), rotate9(rotation4 * Math.PI / 180));
+    const matrix2 = compose7(translate7(pcbX, pcbY), rotate10(rotation4 * Math.PI / 180));
     return matrix2;
   }
   _computePcbGlobalTransformBeforeLayout() {
     const manualPlacement = this.getSubcircuit()._getPcbManualPlacementForComponent(this);
     if (manualPlacement && this.props.pcbX === undefined && this.props.pcbY === undefined) {
       const rotation4 = this._getPcbRotationBeforeLayout() ?? 0;
-      return compose7(this.parent?._computePcbGlobalTransformBeforeLayout() ?? identity6(), compose7(translate7(manualPlacement.x, manualPlacement.y), rotate9(rotation4 * Math.PI / 180)));
+      return compose7(this.parent?._computePcbGlobalTransformBeforeLayout() ?? identity6(), compose7(translate7(manualPlacement.x, manualPlacement.y), rotate10(rotation4 * Math.PI / 180)));
     }
     if (this.isPcbPrimitive) {
       const primitiveContainer = this.getPrimitiveContainer();
@@ -232748,7 +233459,7 @@ var extractPcbPrimitivesFromCircuitJson = ({
 }) => {
   const componentCenter = pcbComponent.center || { x: 0, y: 0 };
   const componentRotation = pcbComponent.rotation || 0;
-  const absoluteToComponentRelativeTransform = inverse(compose7(translate7(componentCenter.x, componentCenter.y), rotate9(componentRotation * Math.PI / 180)));
+  const absoluteToComponentRelativeTransform = inverse(compose7(translate7(componentCenter.x, componentCenter.y), rotate10(componentRotation * Math.PI / 180)));
   const relativeElements = db.toArray().filter((elm) => ("pcb_component_id" in elm) && elm.pcb_component_id === pcbComponent.pcb_component_id);
   const clonedRelativeElements = structuredClone(relativeElements);
   transformPCBElements(clonedRelativeElements, absoluteToComponentRelativeTransform);
@@ -234776,7 +235487,7 @@ var applyPackOutput = (group, packOutput, clusterMap) => {
         if (!member)
           continue;
         const originalCenter2 = member.center;
-        const transformMatrix2 = compose7(group._computePcbGlobalTransformBeforeLayout(), translate7(center2.x + rotatedRel.x, center2.y + rotatedRel.y), rotate9(angleRad), translate7(-originalCenter2.x, -originalCenter2.y));
+        const transformMatrix2 = compose7(group._computePcbGlobalTransformBeforeLayout(), translate7(center2.x + rotatedRel.x, center2.y + rotatedRel.y), rotate10(angleRad), translate7(-originalCenter2.x, -originalCenter2.y));
         const related = db.toArray().filter((elm) => ("pcb_component_id" in elm) && elm.pcb_component_id === memberId);
         transformPCBElements(related, transformMatrix2);
         updateCadRotation({
@@ -234801,7 +235512,7 @@ var applyPackOutput = (group, packOutput, clusterMap) => {
       }
       const originalCenter2 = pcbComponent.center;
       const rotationDegrees2 = ccwRotationDegrees ?? ccwRotationOffset ?? 0;
-      const transformMatrix2 = compose7(group._computePcbGlobalTransformBeforeLayout(), translate7(center2.x, center2.y), rotate9(rotationDegrees2 * Math.PI / 180), translate7(-originalCenter2.x, -originalCenter2.y));
+      const transformMatrix2 = compose7(group._computePcbGlobalTransformBeforeLayout(), translate7(center2.x, center2.y), rotate10(rotationDegrees2 * Math.PI / 180), translate7(-originalCenter2.x, -originalCenter2.y));
       const related = db.toArray().filter((elm) => ("pcb_component_id" in elm) && elm.pcb_component_id === componentId);
       transformPCBElements(related, transformMatrix2);
       updateCadRotation({
@@ -234817,7 +235528,7 @@ var applyPackOutput = (group, packOutput, clusterMap) => {
       continue;
     const originalCenter = pcbGroup.center;
     const rotationDegrees = ccwRotationDegrees ?? ccwRotationOffset ?? 0;
-    const transformMatrix = compose7(group._computePcbGlobalTransformBeforeLayout(), translate7(center2.x, center2.y), rotate9(rotationDegrees * Math.PI / 180), translate7(-originalCenter.x, -originalCenter.y));
+    const transformMatrix = compose7(group._computePcbGlobalTransformBeforeLayout(), translate7(center2.x, center2.y), rotate10(rotationDegrees * Math.PI / 180), translate7(-originalCenter.x, -originalCenter.y));
     const relatedElements = db.toArray().filter((elm) => {
       if ("source_group_id" in elm && elm.source_group_id) {
         if (elm.source_group_id === componentId) {
@@ -236372,15 +237083,15 @@ function nearlyEqual(a2, b22, tol = TOL2) {
 function pointEq(a2, b22, tol = TOL2) {
   return nearlyEqual(a2.x, b22.x, tol) && nearlyEqual(a2.y, b22.y, tol);
 }
-function onSegment3(p3, a2, b22, tol = TOL2) {
+function onSegment32(p3, a2, b22, tol = TOL2) {
   const minX = Math.min(a2.x, b22.x) - tol;
   const maxX = Math.max(a2.x, b22.x) + tol;
   const minY = Math.min(a2.y, b22.y) - tol;
   const maxY = Math.max(a2.y, b22.y) + tol;
   if (p3.x < minX || p3.x > maxX || p3.y < minY || p3.y > maxY)
     return false;
-  const area = Math.abs((b22.x - a2.x) * (p3.y - a2.y) - (b22.y - a2.y) * (p3.x - a2.x));
-  return area <= tol;
+  const area2 = Math.abs((b22.x - a2.x) * (p3.y - a2.y) - (b22.y - a2.y) * (p3.x - a2.x));
+  return area2 <= tol;
 }
 function dedupePoints(points, tol = TOL2) {
   const map = /* @__PURE__ */ new Map;
@@ -236480,7 +237191,7 @@ function computeJunctions(traces, opts = {}) {
       }
       for (const pa22 of AEnds) {
         for (const eB of B32.edges) {
-          if (onSegment3(pa22, eB.from, eB.to, tol)) {
+          if (onSegment32(pa22, eB.from, eB.to, tol)) {
             const aEdgesAtP = incidentEdgesAtPoint(A22, pa22, tol);
             const hasCorner = aEdgesAtP.some((eA) => !isParallel(eA, eB, tol));
             const aCorner = getCornerOrientationAtPoint(A22, pa22, tol);
@@ -236497,7 +237208,7 @@ function computeJunctions(traces, opts = {}) {
       }
       for (const pb of BEnds) {
         for (const eA of A22.edges) {
-          if (onSegment3(pb, eA.from, eA.to, tol)) {
+          if (onSegment32(pb, eA.from, eA.to, tol)) {
             const bEdgesAtP = incidentEdgesAtPoint(B32, pb, tol);
             const hasCorner = bEdgesAtP.some((eB) => !isParallel(eA, eB, tol));
             const bCorner = getCornerOrientationAtPoint(B32, pb, tol);
@@ -239947,9 +240658,9 @@ function generatePanelTabsAndMouseBites(boards, options) {
       boardDimensions.push(Math.min(board.width, board.height));
     } else if (board.outline && board.outline.length > 0) {
       const outlinePolygon = new Polygon$1(board.outline.map((p3) => point4(p3.x, p3.y)));
-      const area = Math.abs(outlinePolygon.area());
-      if (area > 0) {
-        boardDimensions.push(Math.sqrt(area));
+      const area2 = Math.abs(outlinePolygon.area());
+      if (area2 > 0) {
+        boardDimensions.push(Math.sqrt(area2));
       }
     }
   }
@@ -241994,8 +242705,8 @@ var isPointInRing = (point6, ring2) => {
   for (const current2 of ring2) {
     if (isPointOnSegment2(point6, previous, current2))
       return true;
-    const intersects2 = current2.y > point6.y !== previous.y > point6.y && point6.x < (previous.x - current2.x) * (point6.y - current2.y) / (previous.y - current2.y) + current2.x;
-    if (intersects2)
+    const intersects3 = current2.y > point6.y !== previous.y > point6.y && point6.x < (previous.x - current2.x) * (point6.y - current2.y) / (previous.y - current2.y) + current2.x;
+    if (intersects3)
       inside2 = !inside2;
     previous = current2;
   }
@@ -244191,8 +244902,8 @@ var clamp012 = (value) => Math.max(0, Math.min(1, value));
 var roundProbability = (value) => Number.parseFloat(value.toFixed(3));
 var getNodeDensity = (node) => {
   const layerCount = Math.max(node.availableZ?.length ?? 1, 1);
-  const area = Math.max(node.width * node.height, 0.001);
-  return node.portPoints.length / (area * layerCount);
+  const area2 = Math.max(node.width * node.height, 0.001);
+  return node.portPoints.length / (area2 * layerCount);
 };
 var getProbabilityOfFailure = (node, maxDensity, maxPortPointCount) => {
   const crampedPortPointCount = node.portPoints.filter((portPoint) => isCrampedPortPoint(portPoint.portPointId)).length;
@@ -252724,7 +253435,7 @@ import {
   applyToPoint as applyToPoint26,
   compose as compose9,
   identity as identity8,
-  rotate as rotate11,
+  rotate as rotate12,
   translate as translate9
 } from "transformation-matrix";
 var defineExcellonDrillCommand = ({
@@ -254111,7 +254822,7 @@ var convertSoupToGerberCommands = (soup, opts = {}) => {
     }
     if (rotation4) {
       const rad = rotation4 * Math.PI / 180;
-      transforms.push(translate9(cx2, cy2), rotate11(rad), translate9(-cx2, -cy2));
+      transforms.push(translate9(cx2, cy2), rotate12(rad), translate9(-cx2, -cy2));
     }
     const transformMatrix = transforms.length > 0 ? compose9(...transforms) : undefined;
     const applyTransform = (point5) => transformMatrix ? applyToPoint26(transformMatrix, point5) : point5;
@@ -254292,7 +255003,7 @@ var convertSoupToGerberCommands = (soup, opts = {}) => {
           let transformMatrix = identity8();
           if (rotation4) {
             const angle_rad = rotation4 * Math.PI / 180;
-            transformMatrix = rotate11(angle_rad);
+            transformMatrix = rotate12(angle_rad);
           }
           transformMatrix = compose9(translate9(center2.x, center2.y), transformMatrix);
           const transformedPoints = points.map((p3) => applyToPoint26(transformMatrix, p3));
@@ -254653,7 +255364,7 @@ var convertSoupToGerberCommands = (soup, opts = {}) => {
               let transformMatrix2 = identity8();
               if (rotation4) {
                 const angle_rad = rotation4 * Math.PI / 180;
-                transformMatrix2 = rotate11(angle_rad);
+                transformMatrix2 = rotate12(angle_rad);
               }
               return compose9(translate9(center2.x, center2.y), transformMatrix2);
             };
@@ -272443,7 +273154,7 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env2))) {
       return 3;
     }
-    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env2)) || env2.CI_NAME === "codeship") {
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign2) => (sign2 in env2)) || env2.CI_NAME === "codeship") {
       return 1;
     }
     return min;