@tscircuit/cli 0.1.1643 → 0.1.1644

package/dist/cli/main.js

@@ -53619,6 +53619,1817 @@ var init_dist_3YR26ALR = __esm(() => {
   ];
 });
 
+// node_modules/splaytree/dist/splaytree.umd.cjs
+var require_splaytree_umd = __commonJS((exports2, module2) => {
+  (function(h4, c3) {
+    typeof exports2 == "object" && typeof module2 < "u" ? module2.exports = c3() : typeof define == "function" && define.amd ? define(c3) : (h4 = typeof globalThis < "u" ? globalThis : h4 || self, h4.SplayTree = c3());
+  })(exports2, function() {
+
+    class h4 {
+      constructor(t50, e4) {
+        this.next = null, this.key = t50, this.data = e4, this.left = null, this.right = null;
+      }
+    }
+    function c3(n3, t50) {
+      return n3 > t50 ? 1 : n3 < t50 ? -1 : 0;
+    }
+    function u4(n3, t50, e4) {
+      const r4 = new h4(null, null);
+      let i3 = r4, l3 = r4;
+      for (;; ) {
+        const o3 = e4(n3, t50.key);
+        if (o3 < 0) {
+          if (t50.left === null)
+            break;
+          if (e4(n3, t50.left.key) < 0) {
+            const s3 = t50.left;
+            if (t50.left = s3.right, s3.right = t50, t50 = s3, t50.left === null)
+              break;
+          }
+          l3.left = t50, l3 = t50, t50 = t50.left;
+        } else if (o3 > 0) {
+          if (t50.right === null)
+            break;
+          if (e4(n3, t50.right.key) > 0) {
+            const s3 = t50.right;
+            if (t50.right = s3.left, s3.left = t50, t50 = s3, t50.right === null)
+              break;
+          }
+          i3.right = t50, i3 = t50, t50 = t50.right;
+        } else
+          break;
+      }
+      return i3.right = t50.left, l3.left = t50.right, t50.left = r4.right, t50.right = r4.left, t50;
+    }
+    function _4(n3, t50, e4, r4) {
+      const i3 = new h4(n3, t50);
+      if (e4 === null)
+        return i3.left = i3.right = null, i3;
+      e4 = u4(n3, e4, r4);
+      const l3 = r4(n3, e4.key);
+      return l3 < 0 ? (i3.left = e4.left, i3.right = e4, e4.left = null) : l3 >= 0 && (i3.right = e4.right, i3.left = e4, e4.right = null), i3;
+    }
+    function d3(n3, t50, e4) {
+      let r4 = null, i3 = null;
+      if (t50) {
+        t50 = u4(n3, t50, e4);
+        const l3 = e4(t50.key, n3);
+        l3 === 0 ? (r4 = t50.left, i3 = t50.right) : l3 < 0 ? (i3 = t50.right, t50.right = null, r4 = t50) : (r4 = t50.left, t50.left = null, i3 = t50);
+      }
+      return { left: r4, right: i3 };
+    }
+    function w4(n3, t50, e4) {
+      return t50 === null ? n3 : (n3 === null || (t50 = u4(n3.key, t50, e4), t50.left = n3), t50);
+    }
+    function a3(n3, t50, e4, r4, i3) {
+      if (n3) {
+        r4(`${t50}${e4 ? "└── " : "├── "}${i3(n3)}
+`);
+        const l3 = t50 + (e4 ? "    " : "│   ");
+        n3.left && a3(n3.left, l3, false, r4, i3), n3.right && a3(n3.right, l3, true, r4, i3);
+      }
+    }
+
+    class x4 {
+      constructor(t50 = c3) {
+        this._root = null, this._size = 0, this._comparator = t50;
+      }
+      insert(t50, e4) {
+        return this._size++, this._root = _4(t50, e4, this._root, this._comparator);
+      }
+      add(t50, e4) {
+        const r4 = new h4(t50, e4);
+        this._root === null && (r4.left = r4.right = null, this._size++, this._root = r4);
+        const i3 = this._comparator, l3 = u4(t50, this._root, i3), o3 = i3(t50, l3.key);
+        return o3 === 0 ? this._root = l3 : (o3 < 0 ? (r4.left = l3.left, r4.right = l3, l3.left = null) : o3 > 0 && (r4.right = l3.right, r4.left = l3, l3.right = null), this._size++, this._root = r4), this._root;
+      }
+      remove(t50) {
+        this._root = this._remove(t50, this._root, this._comparator);
+      }
+      _remove(t50, e4, r4) {
+        let i3;
+        return e4 === null ? null : (e4 = u4(t50, e4, r4), r4(t50, e4.key) === 0 ? (e4.left === null ? i3 = e4.right : (i3 = u4(t50, e4.left, r4), i3.right = e4.right), this._size--, i3) : e4);
+      }
+      pop() {
+        let t50 = this._root;
+        if (t50) {
+          for (;t50.left; )
+            t50 = t50.left;
+          return this._root = u4(t50.key, this._root, this._comparator), this._root = this._remove(t50.key, this._root, this._comparator), { key: t50.key, data: t50.data };
+        }
+        return null;
+      }
+      findStatic(t50) {
+        let e4 = this._root;
+        const r4 = this._comparator;
+        for (;e4; ) {
+          const i3 = r4(t50, e4.key);
+          if (i3 === 0)
+            return e4;
+          i3 < 0 ? e4 = e4.left : e4 = e4.right;
+        }
+        return null;
+      }
+      find(t50) {
+        return this._root && (this._root = u4(t50, this._root, this._comparator), this._comparator(t50, this._root.key) !== 0) ? null : this._root;
+      }
+      contains(t50) {
+        let e4 = this._root;
+        const r4 = this._comparator;
+        for (;e4; ) {
+          const i3 = r4(t50, e4.key);
+          if (i3 === 0)
+            return true;
+          i3 < 0 ? e4 = e4.left : e4 = e4.right;
+        }
+        return false;
+      }
+      forEach(t50, e4) {
+        let r4 = this._root;
+        const i3 = [];
+        let l3 = false;
+        for (;!l3; )
+          r4 !== null ? (i3.push(r4), r4 = r4.left) : i3.length !== 0 ? (r4 = i3.pop(), t50.call(e4, r4), r4 = r4.right) : l3 = true;
+        return this;
+      }
+      range(t50, e4, r4, i3) {
+        const l3 = [], o3 = this._comparator;
+        let s3 = this._root, f3;
+        for (;l3.length !== 0 || s3; )
+          if (s3)
+            l3.push(s3), s3 = s3.left;
+          else {
+            if (s3 = l3.pop(), f3 = o3(s3.key, e4), f3 > 0)
+              break;
+            if (o3(s3.key, t50) >= 0 && r4.call(i3, s3))
+              return this;
+            s3 = s3.right;
+          }
+        return this;
+      }
+      keys() {
+        const t50 = [];
+        return this.forEach(({ key: e4 }) => {
+          t50.push(e4);
+        }), t50;
+      }
+      values() {
+        const t50 = [];
+        return this.forEach(({ data: e4 }) => {
+          t50.push(e4);
+        }), t50;
+      }
+      min() {
+        return this._root ? this.minNode(this._root).key : null;
+      }
+      max() {
+        return this._root ? this.maxNode(this._root).key : null;
+      }
+      minNode(t50 = this._root) {
+        if (t50)
+          for (;t50.left; )
+            t50 = t50.left;
+        return t50;
+      }
+      maxNode(t50 = this._root) {
+        if (t50)
+          for (;t50.right; )
+            t50 = t50.right;
+        return t50;
+      }
+      at(t50) {
+        let e4 = this._root, r4 = false, i3 = 0;
+        const l3 = [];
+        for (;!r4; )
+          if (e4)
+            l3.push(e4), e4 = e4.left;
+          else if (l3.length > 0) {
+            if (e4 = l3.pop(), i3 === t50)
+              return e4;
+            i3++, e4 = e4.right;
+          } else
+            r4 = true;
+        return null;
+      }
+      next(t50) {
+        let e4 = this._root, r4 = null;
+        if (t50.right) {
+          for (r4 = t50.right;r4.left; )
+            r4 = r4.left;
+          return r4;
+        }
+        const i3 = this._comparator;
+        for (;e4; ) {
+          const l3 = i3(t50.key, e4.key);
+          if (l3 === 0)
+            break;
+          l3 < 0 ? (r4 = e4, e4 = e4.left) : e4 = e4.right;
+        }
+        return r4;
+      }
+      prev(t50) {
+        let e4 = this._root, r4 = null;
+        if (t50.left !== null) {
+          for (r4 = t50.left;r4.right; )
+            r4 = r4.right;
+          return r4;
+        }
+        const i3 = this._comparator;
+        for (;e4; ) {
+          const l3 = i3(t50.key, e4.key);
+          if (l3 === 0)
+            break;
+          l3 < 0 ? e4 = e4.left : (r4 = e4, e4 = e4.right);
+        }
+        return r4;
+      }
+      clear() {
+        return this._root = null, this._size = 0, this;
+      }
+      toList() {
+        return y4(this._root);
+      }
+      load(t50, e4 = [], r4 = false) {
+        let i3 = t50.length;
+        const l3 = this._comparator;
+        if (r4 && m4(t50, e4, 0, i3 - 1, l3), this._root === null)
+          this._root = p3(t50, e4, 0, i3), this._size = i3;
+        else {
+          const o3 = z4(this.toList(), k4(t50, e4), l3);
+          i3 = this._size + i3, this._root = g6({ head: o3 }, 0, i3);
+        }
+        return this;
+      }
+      isEmpty() {
+        return this._root === null;
+      }
+      get size() {
+        return this._size;
+      }
+      get root() {
+        return this._root;
+      }
+      toString(t50 = (e4) => String(e4.key)) {
+        const e4 = [];
+        return a3(this._root, "", true, (r4) => e4.push(r4), t50), e4.join("");
+      }
+      update(t50, e4, r4) {
+        const i3 = this._comparator;
+        let { left: l3, right: o3 } = d3(t50, this._root, i3);
+        i3(t50, e4) < 0 ? o3 = _4(e4, r4, o3, i3) : l3 = _4(e4, r4, l3, i3), this._root = w4(l3, o3, i3);
+      }
+      split(t50) {
+        return d3(t50, this._root, this._comparator);
+      }
+      *[Symbol.iterator]() {
+        let t50 = this._root;
+        const e4 = [];
+        let r4 = false;
+        for (;!r4; )
+          t50 !== null ? (e4.push(t50), t50 = t50.left) : e4.length !== 0 ? (t50 = e4.pop(), yield t50, t50 = t50.right) : r4 = true;
+      }
+    }
+    function p3(n3, t50, e4, r4) {
+      const i3 = r4 - e4;
+      if (i3 > 0) {
+        const l3 = e4 + Math.floor(i3 / 2), o3 = n3[l3], s3 = t50[l3], f3 = new h4(o3, s3);
+        return f3.left = p3(n3, t50, e4, l3), f3.right = p3(n3, t50, l3 + 1, r4), f3;
+      }
+      return null;
+    }
+    function k4(n3, t50) {
+      const e4 = new h4(null, null);
+      let r4 = e4;
+      for (let i3 = 0;i3 < n3.length; i3++)
+        r4 = r4.next = new h4(n3[i3], t50[i3]);
+      return r4.next = null, e4.next;
+    }
+    function y4(n3) {
+      let t50 = n3;
+      const e4 = [];
+      let r4 = false;
+      const i3 = new h4(null, null);
+      let l3 = i3;
+      for (;!r4; )
+        t50 ? (e4.push(t50), t50 = t50.left) : e4.length > 0 ? (t50 = l3 = l3.next = e4.pop(), t50 = t50.right) : r4 = true;
+      return l3.next = null, i3.next;
+    }
+    function g6(n3, t50, e4) {
+      const r4 = e4 - t50;
+      if (r4 > 0) {
+        const i3 = t50 + Math.floor(r4 / 2), l3 = g6(n3, t50, i3), o3 = n3.head;
+        return o3.left = l3, n3.head = n3.head.next, o3.right = g6(n3, i3 + 1, e4), o3;
+      }
+      return null;
+    }
+    function z4(n3, t50, e4) {
+      const r4 = new h4(null, null);
+      let i3 = r4, l3 = n3, o3 = t50;
+      for (;l3 !== null && o3 !== null; )
+        e4(l3.key, o3.key) < 0 ? (i3.next = l3, l3 = l3.next) : (i3.next = o3, o3 = o3.next), i3 = i3.next;
+      return l3 !== null ? i3.next = l3 : o3 !== null && (i3.next = o3), r4.next;
+    }
+    function m4(n3, t50, e4, r4, i3) {
+      if (e4 >= r4)
+        return;
+      const l3 = n3[e4 + r4 >> 1];
+      let o3 = e4 - 1, s3 = r4 + 1;
+      for (;; ) {
+        do
+          o3++;
+        while (i3(n3[o3], l3) < 0);
+        do
+          s3--;
+        while (i3(n3[s3], l3) > 0);
+        if (o3 >= s3)
+          break;
+        let f3 = n3[o3];
+        n3[o3] = n3[s3], n3[s3] = f3, f3 = t50[o3], t50[o3] = t50[s3], t50[s3] = f3;
+      }
+      m4(n3, t50, e4, s3, i3), m4(n3, t50, s3 + 1, r4, i3);
+    }
+    return x4;
+  });
+});
+
+// node_modules/polygon-clipping/dist/polygon-clipping.cjs.js
+var require_polygon_clipping_cjs = __commonJS((exports2, module2) => {
+  var SplayTree = require_splaytree_umd();
+  function _interopDefaultLegacy(e4) {
+    return e4 && typeof e4 === "object" && "default" in e4 ? e4 : { default: e4 };
+  }
+  var SplayTree__default = /* @__PURE__ */ _interopDefaultLegacy(SplayTree);
+  var isInBbox = (bbox, point9) => {
+    return bbox.ll.x <= point9.x && point9.x <= bbox.ur.x && bbox.ll.y <= point9.y && point9.y <= bbox.ur.y;
+  };
+  var getBboxOverlap = (b12, b22) => {
+    if (b22.ur.x < b12.ll.x || b12.ur.x < b22.ll.x || b22.ur.y < b12.ll.y || b12.ur.y < b22.ll.y)
+      return null;
+    const lowerX = b12.ll.x < b22.ll.x ? b22.ll.x : b12.ll.x;
+    const upperX = b12.ur.x < b22.ur.x ? b12.ur.x : b22.ur.x;
+    const lowerY = b12.ll.y < b22.ll.y ? b22.ll.y : b12.ll.y;
+    const upperY = b12.ur.y < b22.ur.y ? b12.ur.y : b22.ur.y;
+    return {
+      ll: {
+        x: lowerX,
+        y: lowerY
+      },
+      ur: {
+        x: upperX,
+        y: upperY
+      }
+    };
+  };
+  var epsilon$1 = Number.EPSILON;
+  if (epsilon$1 === undefined)
+    epsilon$1 = Math.pow(2, -52);
+  var EPSILON_SQ = epsilon$1 * epsilon$1;
+  var cmp = (a3, b3) => {
+    if (-epsilon$1 < a3 && a3 < epsilon$1) {
+      if (-epsilon$1 < b3 && b3 < epsilon$1) {
+        return 0;
+      }
+    }
+    const ab2 = a3 - b3;
+    if (ab2 * ab2 < EPSILON_SQ * a3 * b3) {
+      return 0;
+    }
+    return a3 < b3 ? -1 : 1;
+  };
+
+  class PtRounder {
+    constructor() {
+      this.reset();
+    }
+    reset() {
+      this.xRounder = new CoordRounder;
+      this.yRounder = new CoordRounder;
+    }
+    round(x4, y4) {
+      return {
+        x: this.xRounder.round(x4),
+        y: this.yRounder.round(y4)
+      };
+    }
+  }
+
+  class CoordRounder {
+    constructor() {
+      this.tree = new SplayTree__default["default"];
+      this.round(0);
+    }
+    round(coord) {
+      const node = this.tree.add(coord);
+      const prevNode = this.tree.prev(node);
+      if (prevNode !== null && cmp(node.key, prevNode.key) === 0) {
+        this.tree.remove(coord);
+        return prevNode.key;
+      }
+      const nextNode = this.tree.next(node);
+      if (nextNode !== null && cmp(node.key, nextNode.key) === 0) {
+        this.tree.remove(coord);
+        return nextNode.key;
+      }
+      return coord;
+    }
+  }
+  var rounder = new PtRounder;
+  var epsilon = 0.00000000000000011102230246251565;
+  var splitter = 134217729;
+  var resulterrbound = (3 + 8 * epsilon) * epsilon;
+  function sum(elen, e4, flen, f3, h4) {
+    let Q4, Qnew, hh3, bvirt;
+    let enow = e4[0];
+    let fnow = f3[0];
+    let eindex = 0;
+    let findex = 0;
+    if (fnow > enow === fnow > -enow) {
+      Q4 = enow;
+      enow = e4[++eindex];
+    } else {
+      Q4 = fnow;
+      fnow = f3[++findex];
+    }
+    let hindex = 0;
+    if (eindex < elen && findex < flen) {
+      if (fnow > enow === fnow > -enow) {
+        Qnew = enow + Q4;
+        hh3 = Q4 - (Qnew - enow);
+        enow = e4[++eindex];
+      } else {
+        Qnew = fnow + Q4;
+        hh3 = Q4 - (Qnew - fnow);
+        fnow = f3[++findex];
+      }
+      Q4 = Qnew;
+      if (hh3 !== 0) {
+        h4[hindex++] = hh3;
+      }
+      while (eindex < elen && findex < flen) {
+        if (fnow > enow === fnow > -enow) {
+          Qnew = Q4 + enow;
+          bvirt = Qnew - Q4;
+          hh3 = Q4 - (Qnew - bvirt) + (enow - bvirt);
+          enow = e4[++eindex];
+        } else {
+          Qnew = Q4 + fnow;
+          bvirt = Qnew - Q4;
+          hh3 = Q4 - (Qnew - bvirt) + (fnow - bvirt);
+          fnow = f3[++findex];
+        }
+        Q4 = Qnew;
+        if (hh3 !== 0) {
+          h4[hindex++] = hh3;
+        }
+      }
+    }
+    while (eindex < elen) {
+      Qnew = Q4 + enow;
+      bvirt = Qnew - Q4;
+      hh3 = Q4 - (Qnew - bvirt) + (enow - bvirt);
+      enow = e4[++eindex];
+      Q4 = Qnew;
+      if (hh3 !== 0) {
+        h4[hindex++] = hh3;
+      }
+    }
+    while (findex < flen) {
+      Qnew = Q4 + fnow;
+      bvirt = Qnew - Q4;
+      hh3 = Q4 - (Qnew - bvirt) + (fnow - bvirt);
+      fnow = f3[++findex];
+      Q4 = Qnew;
+      if (hh3 !== 0) {
+        h4[hindex++] = hh3;
+      }
+    }
+    if (Q4 !== 0 || hindex === 0) {
+      h4[hindex++] = Q4;
+    }
+    return hindex;
+  }
+  function estimate(elen, e4) {
+    let Q4 = e4[0];
+    for (let i3 = 1;i3 < elen; i3++)
+      Q4 += e4[i3];
+    return Q4;
+  }
+  function vec(n3) {
+    return new Float64Array(n3);
+  }
+  var ccwerrboundA = (3 + 16 * epsilon) * epsilon;
+  var ccwerrboundB = (2 + 12 * epsilon) * epsilon;
+  var ccwerrboundC = (9 + 64 * epsilon) * epsilon * epsilon;
+  var B4 = vec(4);
+  var C12 = vec(8);
+  var C22 = vec(12);
+  var D4 = vec(16);
+  var u4 = vec(4);
+  function orient2dadapt(ax3, ay3, bx3, by3, cx3, cy3, detsum) {
+    let acxtail, acytail, bcxtail, bcytail;
+    let bvirt, c3, ahi, alo, bhi, blo, _i3, _j, _02, s12, s02, t110, t02, u32;
+    const acx = ax3 - cx3;
+    const bcx = bx3 - cx3;
+    const acy = ay3 - cy3;
+    const bcy = by3 - cy3;
+    s12 = acx * bcy;
+    c3 = splitter * acx;
+    ahi = c3 - (c3 - acx);
+    alo = acx - ahi;
+    c3 = splitter * bcy;
+    bhi = c3 - (c3 - bcy);
+    blo = bcy - bhi;
+    s02 = alo * blo - (s12 - ahi * bhi - alo * bhi - ahi * blo);
+    t110 = acy * bcx;
+    c3 = splitter * acy;
+    ahi = c3 - (c3 - acy);
+    alo = acy - ahi;
+    c3 = splitter * bcx;
+    bhi = c3 - (c3 - bcx);
+    blo = bcx - bhi;
+    t02 = alo * blo - (t110 - ahi * bhi - alo * bhi - ahi * blo);
+    _i3 = s02 - t02;
+    bvirt = s02 - _i3;
+    B4[0] = s02 - (_i3 + bvirt) + (bvirt - t02);
+    _j = s12 + _i3;
+    bvirt = _j - s12;
+    _02 = s12 - (_j - bvirt) + (_i3 - bvirt);
+    _i3 = _02 - t110;
+    bvirt = _02 - _i3;
+    B4[1] = _02 - (_i3 + bvirt) + (bvirt - t110);
+    u32 = _j + _i3;
+    bvirt = u32 - _j;
+    B4[2] = _j - (u32 - bvirt) + (_i3 - bvirt);
+    B4[3] = u32;
+    let det = estimate(4, B4);
+    let errbound = ccwerrboundB * detsum;
+    if (det >= errbound || -det >= errbound) {
+      return det;
+    }
+    bvirt = ax3 - acx;
+    acxtail = ax3 - (acx + bvirt) + (bvirt - cx3);
+    bvirt = bx3 - bcx;
+    bcxtail = bx3 - (bcx + bvirt) + (bvirt - cx3);
+    bvirt = ay3 - acy;
+    acytail = ay3 - (acy + bvirt) + (bvirt - cy3);
+    bvirt = by3 - bcy;
+    bcytail = by3 - (bcy + bvirt) + (bvirt - cy3);
+    if (acxtail === 0 && acytail === 0 && bcxtail === 0 && bcytail === 0) {
+      return det;
+    }
+    errbound = ccwerrboundC * detsum + resulterrbound * Math.abs(det);
+    det += acx * bcytail + bcy * acxtail - (acy * bcxtail + bcx * acytail);
+    if (det >= errbound || -det >= errbound)
+      return det;
+    s12 = acxtail * bcy;
+    c3 = splitter * acxtail;
+    ahi = c3 - (c3 - acxtail);
+    alo = acxtail - ahi;
+    c3 = splitter * bcy;
+    bhi = c3 - (c3 - bcy);
+    blo = bcy - bhi;
+    s02 = alo * blo - (s12 - ahi * bhi - alo * bhi - ahi * blo);
+    t110 = acytail * bcx;
+    c3 = splitter * acytail;
+    ahi = c3 - (c3 - acytail);
+    alo = acytail - ahi;
+    c3 = splitter * bcx;
+    bhi = c3 - (c3 - bcx);
+    blo = bcx - bhi;
+    t02 = alo * blo - (t110 - ahi * bhi - alo * bhi - ahi * blo);
+    _i3 = s02 - t02;
+    bvirt = s02 - _i3;
+    u4[0] = s02 - (_i3 + bvirt) + (bvirt - t02);
+    _j = s12 + _i3;
+    bvirt = _j - s12;
+    _02 = s12 - (_j - bvirt) + (_i3 - bvirt);
+    _i3 = _02 - t110;
+    bvirt = _02 - _i3;
+    u4[1] = _02 - (_i3 + bvirt) + (bvirt - t110);
+    u32 = _j + _i3;
+    bvirt = u32 - _j;
+    u4[2] = _j - (u32 - bvirt) + (_i3 - bvirt);
+    u4[3] = u32;
+    const C1len = sum(4, B4, 4, u4, C12);
+    s12 = acx * bcytail;
+    c3 = splitter * acx;
+    ahi = c3 - (c3 - acx);
+    alo = acx - ahi;
+    c3 = splitter * bcytail;
+    bhi = c3 - (c3 - bcytail);
+    blo = bcytail - bhi;
+    s02 = alo * blo - (s12 - ahi * bhi - alo * bhi - ahi * blo);
+    t110 = acy * bcxtail;
+    c3 = splitter * acy;
+    ahi = c3 - (c3 - acy);
+    alo = acy - ahi;
+    c3 = splitter * bcxtail;
+    bhi = c3 - (c3 - bcxtail);
+    blo = bcxtail - bhi;
+    t02 = alo * blo - (t110 - ahi * bhi - alo * bhi - ahi * blo);
+    _i3 = s02 - t02;
+    bvirt = s02 - _i3;
+    u4[0] = s02 - (_i3 + bvirt) + (bvirt - t02);
+    _j = s12 + _i3;
+    bvirt = _j - s12;
+    _02 = s12 - (_j - bvirt) + (_i3 - bvirt);
+    _i3 = _02 - t110;
+    bvirt = _02 - _i3;
+    u4[1] = _02 - (_i3 + bvirt) + (bvirt - t110);
+    u32 = _j + _i3;
+    bvirt = u32 - _j;
+    u4[2] = _j - (u32 - bvirt) + (_i3 - bvirt);
+    u4[3] = u32;
+    const C2len = sum(C1len, C12, 4, u4, C22);
+    s12 = acxtail * bcytail;
+    c3 = splitter * acxtail;
+    ahi = c3 - (c3 - acxtail);
+    alo = acxtail - ahi;
+    c3 = splitter * bcytail;
+    bhi = c3 - (c3 - bcytail);
+    blo = bcytail - bhi;
+    s02 = alo * blo - (s12 - ahi * bhi - alo * bhi - ahi * blo);
+    t110 = acytail * bcxtail;
+    c3 = splitter * acytail;
+    ahi = c3 - (c3 - acytail);
+    alo = acytail - ahi;
+    c3 = splitter * bcxtail;
+    bhi = c3 - (c3 - bcxtail);
+    blo = bcxtail - bhi;
+    t02 = alo * blo - (t110 - ahi * bhi - alo * bhi - ahi * blo);
+    _i3 = s02 - t02;
+    bvirt = s02 - _i3;
+    u4[0] = s02 - (_i3 + bvirt) + (bvirt - t02);
+    _j = s12 + _i3;
+    bvirt = _j - s12;
+    _02 = s12 - (_j - bvirt) + (_i3 - bvirt);
+    _i3 = _02 - t110;
+    bvirt = _02 - _i3;
+    u4[1] = _02 - (_i3 + bvirt) + (bvirt - t110);
+    u32 = _j + _i3;
+    bvirt = u32 - _j;
+    u4[2] = _j - (u32 - bvirt) + (_i3 - bvirt);
+    u4[3] = u32;
+    const Dlen = sum(C2len, C22, 4, u4, D4);
+    return D4[Dlen - 1];
+  }
+  function orient2d(ax3, ay3, bx3, by3, cx3, cy3) {
+    const detleft = (ay3 - cy3) * (bx3 - cx3);
+    const detright = (ax3 - cx3) * (by3 - cy3);
+    const det = detleft - detright;
+    const detsum = Math.abs(detleft + detright);
+    if (Math.abs(det) >= ccwerrboundA * detsum)
+      return det;
+    return -orient2dadapt(ax3, ay3, bx3, by3, cx3, cy3, detsum);
+  }
+  var crossProduct = (a3, b3) => a3.x * b3.y - a3.y * b3.x;
+  var dotProduct = (a3, b3) => a3.x * b3.x + a3.y * b3.y;
+  var compareVectorAngles = (basePt, endPt1, endPt2) => {
+    const res2 = orient2d(basePt.x, basePt.y, endPt1.x, endPt1.y, endPt2.x, endPt2.y);
+    if (res2 > 0)
+      return -1;
+    if (res2 < 0)
+      return 1;
+    return 0;
+  };
+  var length67 = (v4) => Math.sqrt(dotProduct(v4, v4));
+  var sineOfAngle = (pShared, pBase, pAngle) => {
+    const vBase = {
+      x: pBase.x - pShared.x,
+      y: pBase.y - pShared.y
+    };
+    const vAngle = {
+      x: pAngle.x - pShared.x,
+      y: pAngle.y - pShared.y
+    };
+    return crossProduct(vAngle, vBase) / length67(vAngle) / length67(vBase);
+  };
+  var cosineOfAngle = (pShared, pBase, pAngle) => {
+    const vBase = {
+      x: pBase.x - pShared.x,
+      y: pBase.y - pShared.y
+    };
+    const vAngle = {
+      x: pAngle.x - pShared.x,
+      y: pAngle.y - pShared.y
+    };
+    return dotProduct(vAngle, vBase) / length67(vAngle) / length67(vBase);
+  };
+  var horizontalIntersection = (pt3, v4, y4) => {
+    if (v4.y === 0)
+      return null;
+    return {
+      x: pt3.x + v4.x / v4.y * (y4 - pt3.y),
+      y: y4
+    };
+  };
+  var verticalIntersection = (pt3, v4, x4) => {
+    if (v4.x === 0)
+      return null;
+    return {
+      x: x4,
+      y: pt3.y + v4.y / v4.x * (x4 - pt3.x)
+    };
+  };
+  var intersection$1 = (pt1, v12, pt22, v22) => {
+    if (v12.x === 0)
+      return verticalIntersection(pt22, v22, pt1.x);
+    if (v22.x === 0)
+      return verticalIntersection(pt1, v12, pt22.x);
+    if (v12.y === 0)
+      return horizontalIntersection(pt22, v22, pt1.y);
+    if (v22.y === 0)
+      return horizontalIntersection(pt1, v12, pt22.y);
+    const kross = crossProduct(v12, v22);
+    if (kross == 0)
+      return null;
+    const ve3 = {
+      x: pt22.x - pt1.x,
+      y: pt22.y - pt1.y
+    };
+    const d12 = crossProduct(ve3, v12) / kross;
+    const d23 = crossProduct(ve3, v22) / kross;
+    const x12 = pt1.x + d23 * v12.x, x22 = pt22.x + d12 * v22.x;
+    const y12 = pt1.y + d23 * v12.y, y22 = pt22.y + d12 * v22.y;
+    const x4 = (x12 + x22) / 2;
+    const y4 = (y12 + y22) / 2;
+    return {
+      x: x4,
+      y: y4
+    };
+  };
+
+  class SweepEvent {
+    static compare(a3, b3) {
+      const ptCmp = SweepEvent.comparePoints(a3.point, b3.point);
+      if (ptCmp !== 0)
+        return ptCmp;
+      if (a3.point !== b3.point)
+        a3.link(b3);
+      if (a3.isLeft !== b3.isLeft)
+        return a3.isLeft ? 1 : -1;
+      return Segment3.compare(a3.segment, b3.segment);
+    }
+    static comparePoints(aPt, bPt) {
+      if (aPt.x < bPt.x)
+        return -1;
+      if (aPt.x > bPt.x)
+        return 1;
+      if (aPt.y < bPt.y)
+        return -1;
+      if (aPt.y > bPt.y)
+        return 1;
+      return 0;
+    }
+    constructor(point9, isLeft) {
+      if (point9.events === undefined)
+        point9.events = [this];
+      else
+        point9.events.push(this);
+      this.point = point9;
+      this.isLeft = isLeft;
+    }
+    link(other) {
+      if (other.point === this.point) {
+        throw new Error("Tried to link already linked events");
+      }
+      const otherEvents = other.point.events;
+      for (let i3 = 0, iMax = otherEvents.length;i3 < iMax; i3++) {
+        const evt = otherEvents[i3];
+        this.point.events.push(evt);
+        evt.point = this.point;
+      }
+      this.checkForConsuming();
+    }
+    checkForConsuming() {
+      const numEvents = this.point.events.length;
+      for (let i3 = 0;i3 < numEvents; i3++) {
+        const evt1 = this.point.events[i3];
+        if (evt1.segment.consumedBy !== undefined)
+          continue;
+        for (let j4 = i3 + 1;j4 < numEvents; j4++) {
+          const evt2 = this.point.events[j4];
+          if (evt2.consumedBy !== undefined)
+            continue;
+          if (evt1.otherSE.point.events !== evt2.otherSE.point.events)
+            continue;
+          evt1.segment.consume(evt2.segment);
+        }
+      }
+    }
+    getAvailableLinkedEvents() {
+      const events = [];
+      for (let i3 = 0, iMax = this.point.events.length;i3 < iMax; i3++) {
+        const evt = this.point.events[i3];
+        if (evt !== this && !evt.segment.ringOut && evt.segment.isInResult()) {
+          events.push(evt);
+        }
+      }
+      return events;
+    }
+    getLeftmostComparator(baseEvent) {
+      const cache = new Map;
+      const fillCache = (linkedEvent) => {
+        const nextEvent = linkedEvent.otherSE;
+        cache.set(linkedEvent, {
+          sine: sineOfAngle(this.point, baseEvent.point, nextEvent.point),
+          cosine: cosineOfAngle(this.point, baseEvent.point, nextEvent.point)
+        });
+      };
+      return (a3, b3) => {
+        if (!cache.has(a3))
+          fillCache(a3);
+        if (!cache.has(b3))
+          fillCache(b3);
+        const {
+          sine: asine,
+          cosine: acosine
+        } = cache.get(a3);
+        const {
+          sine: bsine,
+          cosine: bcosine
+        } = cache.get(b3);
+        if (asine >= 0 && bsine >= 0) {
+          if (acosine < bcosine)
+            return 1;
+          if (acosine > bcosine)
+            return -1;
+          return 0;
+        }
+        if (asine < 0 && bsine < 0) {
+          if (acosine < bcosine)
+            return -1;
+          if (acosine > bcosine)
+            return 1;
+          return 0;
+        }
+        if (bsine < asine)
+          return -1;
+        if (bsine > asine)
+          return 1;
+        return 0;
+      };
+    }
+  }
+  var segmentId = 0;
+
+  class Segment3 {
+    static compare(a3, b3) {
+      const alx = a3.leftSE.point.x;
+      const blx = b3.leftSE.point.x;
+      const arx = a3.rightSE.point.x;
+      const brx = b3.rightSE.point.x;
+      if (brx < alx)
+        return 1;
+      if (arx < blx)
+        return -1;
+      const aly = a3.leftSE.point.y;
+      const bly = b3.leftSE.point.y;
+      const ary = a3.rightSE.point.y;
+      const bry = b3.rightSE.point.y;
+      if (alx < blx) {
+        if (bly < aly && bly < ary)
+          return 1;
+        if (bly > aly && bly > ary)
+          return -1;
+        const aCmpBLeft = a3.comparePoint(b3.leftSE.point);
+        if (aCmpBLeft < 0)
+          return 1;
+        if (aCmpBLeft > 0)
+          return -1;
+        const bCmpARight = b3.comparePoint(a3.rightSE.point);
+        if (bCmpARight !== 0)
+          return bCmpARight;
+        return -1;
+      }
+      if (alx > blx) {
+        if (aly < bly && aly < bry)
+          return -1;
+        if (aly > bly && aly > bry)
+          return 1;
+        const bCmpALeft = b3.comparePoint(a3.leftSE.point);
+        if (bCmpALeft !== 0)
+          return bCmpALeft;
+        const aCmpBRight = a3.comparePoint(b3.rightSE.point);
+        if (aCmpBRight < 0)
+          return 1;
+        if (aCmpBRight > 0)
+          return -1;
+        return 1;
+      }
+      if (aly < bly)
+        return -1;
+      if (aly > bly)
+        return 1;
+      if (arx < brx) {
+        const bCmpARight = b3.comparePoint(a3.rightSE.point);
+        if (bCmpARight !== 0)
+          return bCmpARight;
+      }
+      if (arx > brx) {
+        const aCmpBRight = a3.comparePoint(b3.rightSE.point);
+        if (aCmpBRight < 0)
+          return 1;
+        if (aCmpBRight > 0)
+          return -1;
+      }
+      if (arx !== brx) {
+        const ay3 = ary - aly;
+        const ax3 = arx - alx;
+        const by3 = bry - bly;
+        const bx3 = brx - blx;
+        if (ay3 > ax3 && by3 < bx3)
+          return 1;
+        if (ay3 < ax3 && by3 > bx3)
+          return -1;
+      }
+      if (arx > brx)
+        return 1;
+      if (arx < brx)
+        return -1;
+      if (ary < bry)
+        return -1;
+      if (ary > bry)
+        return 1;
+      if (a3.id < b3.id)
+        return -1;
+      if (a3.id > b3.id)
+        return 1;
+      return 0;
+    }
+    constructor(leftSE, rightSE, rings, windings) {
+      this.id = ++segmentId;
+      this.leftSE = leftSE;
+      leftSE.segment = this;
+      leftSE.otherSE = rightSE;
+      this.rightSE = rightSE;
+      rightSE.segment = this;
+      rightSE.otherSE = leftSE;
+      this.rings = rings;
+      this.windings = windings;
+    }
+    static fromRing(pt1, pt22, ring) {
+      let leftPt, rightPt, winding;
+      const cmpPts = SweepEvent.comparePoints(pt1, pt22);
+      if (cmpPts < 0) {
+        leftPt = pt1;
+        rightPt = pt22;
+        winding = 1;
+      } else if (cmpPts > 0) {
+        leftPt = pt22;
+        rightPt = pt1;
+        winding = -1;
+      } else
+        throw new Error(`Tried to create degenerate segment at [${pt1.x}, ${pt1.y}]`);
+      const leftSE = new SweepEvent(leftPt, true);
+      const rightSE = new SweepEvent(rightPt, false);
+      return new Segment3(leftSE, rightSE, [ring], [winding]);
+    }
+    replaceRightSE(newRightSE) {
+      this.rightSE = newRightSE;
+      this.rightSE.segment = this;
+      this.rightSE.otherSE = this.leftSE;
+      this.leftSE.otherSE = this.rightSE;
+    }
+    bbox() {
+      const y12 = this.leftSE.point.y;
+      const y22 = this.rightSE.point.y;
+      return {
+        ll: {
+          x: this.leftSE.point.x,
+          y: y12 < y22 ? y12 : y22
+        },
+        ur: {
+          x: this.rightSE.point.x,
+          y: y12 > y22 ? y12 : y22
+        }
+      };
+    }
+    vector() {
+      return {
+        x: this.rightSE.point.x - this.leftSE.point.x,
+        y: this.rightSE.point.y - this.leftSE.point.y
+      };
+    }
+    isAnEndpoint(pt3) {
+      return pt3.x === this.leftSE.point.x && pt3.y === this.leftSE.point.y || pt3.x === this.rightSE.point.x && pt3.y === this.rightSE.point.y;
+    }
+    comparePoint(point9) {
+      if (this.isAnEndpoint(point9))
+        return 0;
+      const lPt = this.leftSE.point;
+      const rPt = this.rightSE.point;
+      const v4 = this.vector();
+      if (lPt.x === rPt.x) {
+        if (point9.x === lPt.x)
+          return 0;
+        return point9.x < lPt.x ? 1 : -1;
+      }
+      const yDist = (point9.y - lPt.y) / v4.y;
+      const xFromYDist = lPt.x + yDist * v4.x;
+      if (point9.x === xFromYDist)
+        return 0;
+      const xDist = (point9.x - lPt.x) / v4.x;
+      const yFromXDist = lPt.y + xDist * v4.y;
+      if (point9.y === yFromXDist)
+        return 0;
+      return point9.y < yFromXDist ? -1 : 1;
+    }
+    getIntersection(other) {
+      const tBbox = this.bbox();
+      const oBbox = other.bbox();
+      const bboxOverlap = getBboxOverlap(tBbox, oBbox);
+      if (bboxOverlap === null)
+        return null;
+      const tlp = this.leftSE.point;
+      const trp = this.rightSE.point;
+      const olp = other.leftSE.point;
+      const orp = other.rightSE.point;
+      const touchesOtherLSE = isInBbox(tBbox, olp) && this.comparePoint(olp) === 0;
+      const touchesThisLSE = isInBbox(oBbox, tlp) && other.comparePoint(tlp) === 0;
+      const touchesOtherRSE = isInBbox(tBbox, orp) && this.comparePoint(orp) === 0;
+      const touchesThisRSE = isInBbox(oBbox, trp) && other.comparePoint(trp) === 0;
+      if (touchesThisLSE && touchesOtherLSE) {
+        if (touchesThisRSE && !touchesOtherRSE)
+          return trp;
+        if (!touchesThisRSE && touchesOtherRSE)
+          return orp;
+        return null;
+      }
+      if (touchesThisLSE) {
+        if (touchesOtherRSE) {
+          if (tlp.x === orp.x && tlp.y === orp.y)
+            return null;
+        }
+        return tlp;
+      }
+      if (touchesOtherLSE) {
+        if (touchesThisRSE) {
+          if (trp.x === olp.x && trp.y === olp.y)
+            return null;
+        }
+        return olp;
+      }
+      if (touchesThisRSE && touchesOtherRSE)
+        return null;
+      if (touchesThisRSE)
+        return trp;
+      if (touchesOtherRSE)
+        return orp;
+      const pt3 = intersection$1(tlp, this.vector(), olp, other.vector());
+      if (pt3 === null)
+        return null;
+      if (!isInBbox(bboxOverlap, pt3))
+        return null;
+      return rounder.round(pt3.x, pt3.y);
+    }
+    split(point9) {
+      const newEvents = [];
+      const alreadyLinked = point9.events !== undefined;
+      const newLeftSE = new SweepEvent(point9, true);
+      const newRightSE = new SweepEvent(point9, false);
+      const oldRightSE = this.rightSE;
+      this.replaceRightSE(newRightSE);
+      newEvents.push(newRightSE);
+      newEvents.push(newLeftSE);
+      const newSeg = new Segment3(newLeftSE, oldRightSE, this.rings.slice(), this.windings.slice());
+      if (SweepEvent.comparePoints(newSeg.leftSE.point, newSeg.rightSE.point) > 0) {
+        newSeg.swapEvents();
+      }
+      if (SweepEvent.comparePoints(this.leftSE.point, this.rightSE.point) > 0) {
+        this.swapEvents();
+      }
+      if (alreadyLinked) {
+        newLeftSE.checkForConsuming();
+        newRightSE.checkForConsuming();
+      }
+      return newEvents;
+    }
+    swapEvents() {
+      const tmpEvt = this.rightSE;
+      this.rightSE = this.leftSE;
+      this.leftSE = tmpEvt;
+      this.leftSE.isLeft = true;
+      this.rightSE.isLeft = false;
+      for (let i3 = 0, iMax = this.windings.length;i3 < iMax; i3++) {
+        this.windings[i3] *= -1;
+      }
+    }
+    consume(other) {
+      let consumer = this;
+      let consumee = other;
+      while (consumer.consumedBy)
+        consumer = consumer.consumedBy;
+      while (consumee.consumedBy)
+        consumee = consumee.consumedBy;
+      const cmp2 = Segment3.compare(consumer, consumee);
+      if (cmp2 === 0)
+        return;
+      if (cmp2 > 0) {
+        const tmp = consumer;
+        consumer = consumee;
+        consumee = tmp;
+      }
+      if (consumer.prev === consumee) {
+        const tmp = consumer;
+        consumer = consumee;
+        consumee = tmp;
+      }
+      for (let i3 = 0, iMax = consumee.rings.length;i3 < iMax; i3++) {
+        const ring = consumee.rings[i3];
+        const winding = consumee.windings[i3];
+        const index2 = consumer.rings.indexOf(ring);
+        if (index2 === -1) {
+          consumer.rings.push(ring);
+          consumer.windings.push(winding);
+        } else
+          consumer.windings[index2] += winding;
+      }
+      consumee.rings = null;
+      consumee.windings = null;
+      consumee.consumedBy = consumer;
+      consumee.leftSE.consumedBy = consumer.leftSE;
+      consumee.rightSE.consumedBy = consumer.rightSE;
+    }
+    prevInResult() {
+      if (this._prevInResult !== undefined)
+        return this._prevInResult;
+      if (!this.prev)
+        this._prevInResult = null;
+      else if (this.prev.isInResult())
+        this._prevInResult = this.prev;
+      else
+        this._prevInResult = this.prev.prevInResult();
+      return this._prevInResult;
+    }
+    beforeState() {
+      if (this._beforeState !== undefined)
+        return this._beforeState;
+      if (!this.prev)
+        this._beforeState = {
+          rings: [],
+          windings: [],
+          multiPolys: []
+        };
+      else {
+        const seg = this.prev.consumedBy || this.prev;
+        this._beforeState = seg.afterState();
+      }
+      return this._beforeState;
+    }
+    afterState() {
+      if (this._afterState !== undefined)
+        return this._afterState;
+      const beforeState = this.beforeState();
+      this._afterState = {
+        rings: beforeState.rings.slice(0),
+        windings: beforeState.windings.slice(0),
+        multiPolys: []
+      };
+      const ringsAfter = this._afterState.rings;
+      const windingsAfter = this._afterState.windings;
+      const mpsAfter = this._afterState.multiPolys;
+      for (let i3 = 0, iMax = this.rings.length;i3 < iMax; i3++) {
+        const ring = this.rings[i3];
+        const winding = this.windings[i3];
+        const index2 = ringsAfter.indexOf(ring);
+        if (index2 === -1) {
+          ringsAfter.push(ring);
+          windingsAfter.push(winding);
+        } else
+          windingsAfter[index2] += winding;
+      }
+      const polysAfter = [];
+      const polysExclude = [];
+      for (let i3 = 0, iMax = ringsAfter.length;i3 < iMax; i3++) {
+        if (windingsAfter[i3] === 0)
+          continue;
+        const ring = ringsAfter[i3];
+        const poly = ring.poly;
+        if (polysExclude.indexOf(poly) !== -1)
+          continue;
+        if (ring.isExterior)
+          polysAfter.push(poly);
+        else {
+          if (polysExclude.indexOf(poly) === -1)
+            polysExclude.push(poly);
+          const index2 = polysAfter.indexOf(ring.poly);
+          if (index2 !== -1)
+            polysAfter.splice(index2, 1);
+        }
+      }
+      for (let i3 = 0, iMax = polysAfter.length;i3 < iMax; i3++) {
+        const mp3 = polysAfter[i3].multiPoly;
+        if (mpsAfter.indexOf(mp3) === -1)
+          mpsAfter.push(mp3);
+      }
+      return this._afterState;
+    }
+    isInResult() {
+      if (this.consumedBy)
+        return false;
+      if (this._isInResult !== undefined)
+        return this._isInResult;
+      const mpsBefore = this.beforeState().multiPolys;
+      const mpsAfter = this.afterState().multiPolys;
+      switch (operation.type) {
+        case "union": {
+          const noBefores = mpsBefore.length === 0;
+          const noAfters = mpsAfter.length === 0;
+          this._isInResult = noBefores !== noAfters;
+          break;
+        }
+        case "intersection": {
+          let least;
+          let most;
+          if (mpsBefore.length < mpsAfter.length) {
+            least = mpsBefore.length;
+            most = mpsAfter.length;
+          } else {
+            least = mpsAfter.length;
+            most = mpsBefore.length;
+          }
+          this._isInResult = most === operation.numMultiPolys && least < most;
+          break;
+        }
+        case "xor": {
+          const diff = Math.abs(mpsBefore.length - mpsAfter.length);
+          this._isInResult = diff % 2 === 1;
+          break;
+        }
+        case "difference": {
+          const isJustSubject = (mps) => mps.length === 1 && mps[0].isSubject;
+          this._isInResult = isJustSubject(mpsBefore) !== isJustSubject(mpsAfter);
+          break;
+        }
+        default:
+          throw new Error(`Unrecognized operation type found ${operation.type}`);
+      }
+      return this._isInResult;
+    }
+  }
+
+  class RingIn {
+    constructor(geomRing, poly, isExterior) {
+      if (!Array.isArray(geomRing) || geomRing.length === 0) {
+        throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+      }
+      this.poly = poly;
+      this.isExterior = isExterior;
+      this.segments = [];
+      if (typeof geomRing[0][0] !== "number" || typeof geomRing[0][1] !== "number") {
+        throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+      }
+      const firstPoint = rounder.round(geomRing[0][0], geomRing[0][1]);
+      this.bbox = {
+        ll: {
+          x: firstPoint.x,
+          y: firstPoint.y
+        },
+        ur: {
+          x: firstPoint.x,
+          y: firstPoint.y
+        }
+      };
+      let prevPoint = firstPoint;
+      for (let i3 = 1, iMax = geomRing.length;i3 < iMax; i3++) {
+        if (typeof geomRing[i3][0] !== "number" || typeof geomRing[i3][1] !== "number") {
+          throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+        }
+        let point9 = rounder.round(geomRing[i3][0], geomRing[i3][1]);
+        if (point9.x === prevPoint.x && point9.y === prevPoint.y)
+          continue;
+        this.segments.push(Segment3.fromRing(prevPoint, point9, this));
+        if (point9.x < this.bbox.ll.x)
+          this.bbox.ll.x = point9.x;
+        if (point9.y < this.bbox.ll.y)
+          this.bbox.ll.y = point9.y;
+        if (point9.x > this.bbox.ur.x)
+          this.bbox.ur.x = point9.x;
+        if (point9.y > this.bbox.ur.y)
+          this.bbox.ur.y = point9.y;
+        prevPoint = point9;
+      }
+      if (firstPoint.x !== prevPoint.x || firstPoint.y !== prevPoint.y) {
+        this.segments.push(Segment3.fromRing(prevPoint, firstPoint, this));
+      }
+    }
+    getSweepEvents() {
+      const sweepEvents = [];
+      for (let i3 = 0, iMax = this.segments.length;i3 < iMax; i3++) {
+        const segment2 = this.segments[i3];
+        sweepEvents.push(segment2.leftSE);
+        sweepEvents.push(segment2.rightSE);
+      }
+      return sweepEvents;
+    }
+  }
+
+  class PolyIn {
+    constructor(geomPoly, multiPoly) {
+      if (!Array.isArray(geomPoly)) {
+        throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+      }
+      this.exteriorRing = new RingIn(geomPoly[0], this, true);
+      this.bbox = {
+        ll: {
+          x: this.exteriorRing.bbox.ll.x,
+          y: this.exteriorRing.bbox.ll.y
+        },
+        ur: {
+          x: this.exteriorRing.bbox.ur.x,
+          y: this.exteriorRing.bbox.ur.y
+        }
+      };
+      this.interiorRings = [];
+      for (let i3 = 1, iMax = geomPoly.length;i3 < iMax; i3++) {
+        const ring = new RingIn(geomPoly[i3], this, false);
+        if (ring.bbox.ll.x < this.bbox.ll.x)
+          this.bbox.ll.x = ring.bbox.ll.x;
+        if (ring.bbox.ll.y < this.bbox.ll.y)
+          this.bbox.ll.y = ring.bbox.ll.y;
+        if (ring.bbox.ur.x > this.bbox.ur.x)
+          this.bbox.ur.x = ring.bbox.ur.x;
+        if (ring.bbox.ur.y > this.bbox.ur.y)
+          this.bbox.ur.y = ring.bbox.ur.y;
+        this.interiorRings.push(ring);
+      }
+      this.multiPoly = multiPoly;
+    }
+    getSweepEvents() {
+      const sweepEvents = this.exteriorRing.getSweepEvents();
+      for (let i3 = 0, iMax = this.interiorRings.length;i3 < iMax; i3++) {
+        const ringSweepEvents = this.interiorRings[i3].getSweepEvents();
+        for (let j4 = 0, jMax = ringSweepEvents.length;j4 < jMax; j4++) {
+          sweepEvents.push(ringSweepEvents[j4]);
+        }
+      }
+      return sweepEvents;
+    }
+  }
+
+  class MultiPolyIn {
+    constructor(geom, isSubject) {
+      if (!Array.isArray(geom)) {
+        throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+      }
+      try {
+        if (typeof geom[0][0][0] === "number")
+          geom = [geom];
+      } catch (ex3) {}
+      this.polys = [];
+      this.bbox = {
+        ll: {
+          x: Number.POSITIVE_INFINITY,
+          y: Number.POSITIVE_INFINITY
+        },
+        ur: {
+          x: Number.NEGATIVE_INFINITY,
+          y: Number.NEGATIVE_INFINITY
+        }
+      };
+      for (let i3 = 0, iMax = geom.length;i3 < iMax; i3++) {
+        const poly = new PolyIn(geom[i3], this);
+        if (poly.bbox.ll.x < this.bbox.ll.x)
+          this.bbox.ll.x = poly.bbox.ll.x;
+        if (poly.bbox.ll.y < this.bbox.ll.y)
+          this.bbox.ll.y = poly.bbox.ll.y;
+        if (poly.bbox.ur.x > this.bbox.ur.x)
+          this.bbox.ur.x = poly.bbox.ur.x;
+        if (poly.bbox.ur.y > this.bbox.ur.y)
+          this.bbox.ur.y = poly.bbox.ur.y;
+        this.polys.push(poly);
+      }
+      this.isSubject = isSubject;
+    }
+    getSweepEvents() {
+      const sweepEvents = [];
+      for (let i3 = 0, iMax = this.polys.length;i3 < iMax; i3++) {
+        const polySweepEvents = this.polys[i3].getSweepEvents();
+        for (let j4 = 0, jMax = polySweepEvents.length;j4 < jMax; j4++) {
+          sweepEvents.push(polySweepEvents[j4]);
+        }
+      }
+      return sweepEvents;
+    }
+  }
+
+  class RingOut {
+    static factory(allSegments) {
+      const ringsOut = [];
+      for (let i3 = 0, iMax = allSegments.length;i3 < iMax; i3++) {
+        const segment2 = allSegments[i3];
+        if (!segment2.isInResult() || segment2.ringOut)
+          continue;
+        let prevEvent = null;
+        let event = segment2.leftSE;
+        let nextEvent = segment2.rightSE;
+        const events = [event];
+        const startingPoint = event.point;
+        const intersectionLEs = [];
+        while (true) {
+          prevEvent = event;
+          event = nextEvent;
+          events.push(event);
+          if (event.point === startingPoint)
+            break;
+          while (true) {
+            const availableLEs = event.getAvailableLinkedEvents();
+            if (availableLEs.length === 0) {
+              const firstPt = events[0].point;
+              const lastPt = events[events.length - 1].point;
+              throw new Error(`Unable to complete output ring starting at [${firstPt.x},` + ` ${firstPt.y}]. Last matching segment found ends at` + ` [${lastPt.x}, ${lastPt.y}].`);
+            }
+            if (availableLEs.length === 1) {
+              nextEvent = availableLEs[0].otherSE;
+              break;
+            }
+            let indexLE = null;
+            for (let j4 = 0, jMax = intersectionLEs.length;j4 < jMax; j4++) {
+              if (intersectionLEs[j4].point === event.point) {
+                indexLE = j4;
+                break;
+              }
+            }
+            if (indexLE !== null) {
+              const intersectionLE = intersectionLEs.splice(indexLE)[0];
+              const ringEvents = events.splice(intersectionLE.index);
+              ringEvents.unshift(ringEvents[0].otherSE);
+              ringsOut.push(new RingOut(ringEvents.reverse()));
+              continue;
+            }
+            intersectionLEs.push({
+              index: events.length,
+              point: event.point
+            });
+            const comparator = event.getLeftmostComparator(prevEvent);
+            nextEvent = availableLEs.sort(comparator)[0].otherSE;
+            break;
+          }
+        }
+        ringsOut.push(new RingOut(events));
+      }
+      return ringsOut;
+    }
+    constructor(events) {
+      this.events = events;
+      for (let i3 = 0, iMax = events.length;i3 < iMax; i3++) {
+        events[i3].segment.ringOut = this;
+      }
+      this.poly = null;
+    }
+    getGeom() {
+      let prevPt = this.events[0].point;
+      const points = [prevPt];
+      for (let i3 = 1, iMax = this.events.length - 1;i3 < iMax; i3++) {
+        const pt4 = this.events[i3].point;
+        const nextPt2 = this.events[i3 + 1].point;
+        if (compareVectorAngles(pt4, prevPt, nextPt2) === 0)
+          continue;
+        points.push(pt4);
+        prevPt = pt4;
+      }
+      if (points.length === 1)
+        return null;
+      const pt3 = points[0];
+      const nextPt = points[1];
+      if (compareVectorAngles(pt3, prevPt, nextPt) === 0)
+        points.shift();
+      points.push(points[0]);
+      const step = this.isExteriorRing() ? 1 : -1;
+      const iStart = this.isExteriorRing() ? 0 : points.length - 1;
+      const iEnd = this.isExteriorRing() ? points.length : -1;
+      const orderedPoints = [];
+      for (let i3 = iStart;i3 != iEnd; i3 += step)
+        orderedPoints.push([points[i3].x, points[i3].y]);
+      return orderedPoints;
+    }
+    isExteriorRing() {
+      if (this._isExteriorRing === undefined) {
+        const enclosing = this.enclosingRing();
+        this._isExteriorRing = enclosing ? !enclosing.isExteriorRing() : true;
+      }
+      return this._isExteriorRing;
+    }
+    enclosingRing() {
+      if (this._enclosingRing === undefined) {
+        this._enclosingRing = this._calcEnclosingRing();
+      }
+      return this._enclosingRing;
+    }
+    _calcEnclosingRing() {
+      let leftMostEvt = this.events[0];
+      for (let i3 = 1, iMax = this.events.length;i3 < iMax; i3++) {
+        const evt = this.events[i3];
+        if (SweepEvent.compare(leftMostEvt, evt) > 0)
+          leftMostEvt = evt;
+      }
+      let prevSeg = leftMostEvt.segment.prevInResult();
+      let prevPrevSeg = prevSeg ? prevSeg.prevInResult() : null;
+      while (true) {
+        if (!prevSeg)
+          return null;
+        if (!prevPrevSeg)
+          return prevSeg.ringOut;
+        if (prevPrevSeg.ringOut !== prevSeg.ringOut) {
+          if (prevPrevSeg.ringOut.enclosingRing() !== prevSeg.ringOut) {
+            return prevSeg.ringOut;
+          } else
+            return prevSeg.ringOut.enclosingRing();
+        }
+        prevSeg = prevPrevSeg.prevInResult();
+        prevPrevSeg = prevSeg ? prevSeg.prevInResult() : null;
+      }
+    }
+  }
+
+  class PolyOut {
+    constructor(exteriorRing) {
+      this.exteriorRing = exteriorRing;
+      exteriorRing.poly = this;
+      this.interiorRings = [];
+    }
+    addInterior(ring) {
+      this.interiorRings.push(ring);
+      ring.poly = this;
+    }
+    getGeom() {
+      const geom = [this.exteriorRing.getGeom()];
+      if (geom[0] === null)
+        return null;
+      for (let i3 = 0, iMax = this.interiorRings.length;i3 < iMax; i3++) {
+        const ringGeom = this.interiorRings[i3].getGeom();
+        if (ringGeom === null)
+          continue;
+        geom.push(ringGeom);
+      }
+      return geom;
+    }
+  }
+
+  class MultiPolyOut {
+    constructor(rings) {
+      this.rings = rings;
+      this.polys = this._composePolys(rings);
+    }
+    getGeom() {
+      const geom = [];
+      for (let i3 = 0, iMax = this.polys.length;i3 < iMax; i3++) {
+        const polyGeom = this.polys[i3].getGeom();
+        if (polyGeom === null)
+          continue;
+        geom.push(polyGeom);
+      }
+      return geom;
+    }
+    _composePolys(rings) {
+      const polys = [];
+      for (let i3 = 0, iMax = rings.length;i3 < iMax; i3++) {
+        const ring = rings[i3];
+        if (ring.poly)
+          continue;
+        if (ring.isExteriorRing())
+          polys.push(new PolyOut(ring));
+        else {
+          const enclosingRing = ring.enclosingRing();
+          if (!enclosingRing.poly)
+            polys.push(new PolyOut(enclosingRing));
+          enclosingRing.poly.addInterior(ring);
+        }
+      }
+      return polys;
+    }
+  }
+
+  class SweepLine {
+    constructor(queue) {
+      let comparator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Segment3.compare;
+      this.queue = queue;
+      this.tree = new SplayTree__default["default"](comparator);
+      this.segments = [];
+    }
+    process(event) {
+      const segment2 = event.segment;
+      const newEvents = [];
+      if (event.consumedBy) {
+        if (event.isLeft)
+          this.queue.remove(event.otherSE);
+        else
+          this.tree.remove(segment2);
+        return newEvents;
+      }
+      const node = event.isLeft ? this.tree.add(segment2) : this.tree.find(segment2);
+      if (!node)
+        throw new Error(`Unable to find segment #${segment2.id} ` + `[${segment2.leftSE.point.x}, ${segment2.leftSE.point.y}] -> ` + `[${segment2.rightSE.point.x}, ${segment2.rightSE.point.y}] ` + "in SweepLine tree.");
+      let prevNode = node;
+      let nextNode = node;
+      let prevSeg = undefined;
+      let nextSeg = undefined;
+      while (prevSeg === undefined) {
+        prevNode = this.tree.prev(prevNode);
+        if (prevNode === null)
+          prevSeg = null;
+        else if (prevNode.key.consumedBy === undefined)
+          prevSeg = prevNode.key;
+      }
+      while (nextSeg === undefined) {
+        nextNode = this.tree.next(nextNode);
+        if (nextNode === null)
+          nextSeg = null;
+        else if (nextNode.key.consumedBy === undefined)
+          nextSeg = nextNode.key;
+      }
+      if (event.isLeft) {
+        let prevMySplitter = null;
+        if (prevSeg) {
+          const prevInter = prevSeg.getIntersection(segment2);
+          if (prevInter !== null) {
+            if (!segment2.isAnEndpoint(prevInter))
+              prevMySplitter = prevInter;
+            if (!prevSeg.isAnEndpoint(prevInter)) {
+              const newEventsFromSplit = this._splitSafely(prevSeg, prevInter);
+              for (let i3 = 0, iMax = newEventsFromSplit.length;i3 < iMax; i3++) {
+                newEvents.push(newEventsFromSplit[i3]);
+              }
+            }
+          }
+        }
+        let nextMySplitter = null;
+        if (nextSeg) {
+          const nextInter = nextSeg.getIntersection(segment2);
+          if (nextInter !== null) {
+            if (!segment2.isAnEndpoint(nextInter))
+              nextMySplitter = nextInter;
+            if (!nextSeg.isAnEndpoint(nextInter)) {
+              const newEventsFromSplit = this._splitSafely(nextSeg, nextInter);
+              for (let i3 = 0, iMax = newEventsFromSplit.length;i3 < iMax; i3++) {
+                newEvents.push(newEventsFromSplit[i3]);
+              }
+            }
+          }
+        }
+        if (prevMySplitter !== null || nextMySplitter !== null) {
+          let mySplitter = null;
+          if (prevMySplitter === null)
+            mySplitter = nextMySplitter;
+          else if (nextMySplitter === null)
+            mySplitter = prevMySplitter;
+          else {
+            const cmpSplitters = SweepEvent.comparePoints(prevMySplitter, nextMySplitter);
+            mySplitter = cmpSplitters <= 0 ? prevMySplitter : nextMySplitter;
+          }
+          this.queue.remove(segment2.rightSE);
+          newEvents.push(segment2.rightSE);
+          const newEventsFromSplit = segment2.split(mySplitter);
+          for (let i3 = 0, iMax = newEventsFromSplit.length;i3 < iMax; i3++) {
+            newEvents.push(newEventsFromSplit[i3]);
+          }
+        }
+        if (newEvents.length > 0) {
+          this.tree.remove(segment2);
+          newEvents.push(event);
+        } else {
+          this.segments.push(segment2);
+          segment2.prev = prevSeg;
+        }
+      } else {
+        if (prevSeg && nextSeg) {
+          const inter = prevSeg.getIntersection(nextSeg);
+          if (inter !== null) {
+            if (!prevSeg.isAnEndpoint(inter)) {
+              const newEventsFromSplit = this._splitSafely(prevSeg, inter);
+              for (let i3 = 0, iMax = newEventsFromSplit.length;i3 < iMax; i3++) {
+                newEvents.push(newEventsFromSplit[i3]);
+              }
+            }
+            if (!nextSeg.isAnEndpoint(inter)) {
+              const newEventsFromSplit = this._splitSafely(nextSeg, inter);
+              for (let i3 = 0, iMax = newEventsFromSplit.length;i3 < iMax; i3++) {
+                newEvents.push(newEventsFromSplit[i3]);
+              }
+            }
+          }
+        }
+        this.tree.remove(segment2);
+      }
+      return newEvents;
+    }
+    _splitSafely(seg, pt3) {
+      this.tree.remove(seg);
+      const rightSE = seg.rightSE;
+      this.queue.remove(rightSE);
+      const newEvents = seg.split(pt3);
+      newEvents.push(rightSE);
+      if (seg.consumedBy === undefined)
+        this.tree.add(seg);
+      return newEvents;
+    }
+  }
+  var POLYGON_CLIPPING_MAX_QUEUE_SIZE = typeof process !== "undefined" && process.env.POLYGON_CLIPPING_MAX_QUEUE_SIZE || 1e6;
+  var POLYGON_CLIPPING_MAX_SWEEPLINE_SEGMENTS = typeof process !== "undefined" && process.env.POLYGON_CLIPPING_MAX_SWEEPLINE_SEGMENTS || 1e6;
+
+  class Operation {
+    run(type, geom, moreGeoms) {
+      operation.type = type;
+      rounder.reset();
+      const multipolys = [new MultiPolyIn(geom, true)];
+      for (let i3 = 0, iMax = moreGeoms.length;i3 < iMax; i3++) {
+        multipolys.push(new MultiPolyIn(moreGeoms[i3], false));
+      }
+      operation.numMultiPolys = multipolys.length;
+      if (operation.type === "difference") {
+        const subject = multipolys[0];
+        let i3 = 1;
+        while (i3 < multipolys.length) {
+          if (getBboxOverlap(multipolys[i3].bbox, subject.bbox) !== null)
+            i3++;
+          else
+            multipolys.splice(i3, 1);
+        }
+      }
+      if (operation.type === "intersection") {
+        for (let i3 = 0, iMax = multipolys.length;i3 < iMax; i3++) {
+          const mpA = multipolys[i3];
+          for (let j4 = i3 + 1, jMax = multipolys.length;j4 < jMax; j4++) {
+            if (getBboxOverlap(mpA.bbox, multipolys[j4].bbox) === null)
+              return [];
+          }
+        }
+      }
+      const queue = new SplayTree__default["default"](SweepEvent.compare);
+      for (let i3 = 0, iMax = multipolys.length;i3 < iMax; i3++) {
+        const sweepEvents = multipolys[i3].getSweepEvents();
+        for (let j4 = 0, jMax = sweepEvents.length;j4 < jMax; j4++) {
+          queue.insert(sweepEvents[j4]);
+          if (queue.size > POLYGON_CLIPPING_MAX_QUEUE_SIZE) {
+            throw new Error("Infinite loop when putting segment endpoints in a priority queue " + "(queue size too big).");
+          }
+        }
+      }
+      const sweepLine = new SweepLine(queue);
+      let prevQueueSize = queue.size;
+      let node = queue.pop();
+      while (node) {
+        const evt = node.key;
+        if (queue.size === prevQueueSize) {
+          const seg = evt.segment;
+          throw new Error(`Unable to pop() ${evt.isLeft ? "left" : "right"} SweepEvent ` + `[${evt.point.x}, ${evt.point.y}] from segment #${seg.id} ` + `[${seg.leftSE.point.x}, ${seg.leftSE.point.y}] -> ` + `[${seg.rightSE.point.x}, ${seg.rightSE.point.y}] from queue.`);
+        }
+        if (queue.size > POLYGON_CLIPPING_MAX_QUEUE_SIZE) {
+          throw new Error("Infinite loop when passing sweep line over endpoints " + "(queue size too big).");
+        }
+        if (sweepLine.segments.length > POLYGON_CLIPPING_MAX_SWEEPLINE_SEGMENTS) {
+          throw new Error("Infinite loop when passing sweep line over endpoints " + "(too many sweep line segments).");
+        }
+        const newEvents = sweepLine.process(evt);
+        for (let i3 = 0, iMax = newEvents.length;i3 < iMax; i3++) {
+          const evt2 = newEvents[i3];
+          if (evt2.consumedBy === undefined)
+            queue.insert(evt2);
+        }
+        prevQueueSize = queue.size;
+        node = queue.pop();
+      }
+      rounder.reset();
+      const ringsOut = RingOut.factory(sweepLine.segments);
+      const result = new MultiPolyOut(ringsOut);
+      return result.getGeom();
+    }
+  }
+  var operation = new Operation;
+  var union = function(geom) {
+    for (var _len = arguments.length, moreGeoms = new Array(_len > 1 ? _len - 1 : 0), _key = 1;_key < _len; _key++) {
+      moreGeoms[_key - 1] = arguments[_key];
+    }
+    return operation.run("union", geom, moreGeoms);
+  };
+  var intersection = function(geom) {
+    for (var _len2 = arguments.length, moreGeoms = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1;_key2 < _len2; _key2++) {
+      moreGeoms[_key2 - 1] = arguments[_key2];
+    }
+    return operation.run("intersection", geom, moreGeoms);
+  };
+  var xor = function(geom) {
+    for (var _len3 = arguments.length, moreGeoms = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1;_key3 < _len3; _key3++) {
+      moreGeoms[_key3 - 1] = arguments[_key3];
+    }
+    return operation.run("xor", geom, moreGeoms);
+  };
+  var difference = function(subjectGeom) {
+    for (var _len4 = arguments.length, clippingGeoms = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1;_key4 < _len4; _key4++) {
+      clippingGeoms[_key4 - 1] = arguments[_key4];
+    }
+    return operation.run("difference", subjectGeom, clippingGeoms);
+  };
+  var index = {
+    union,
+    intersection,
+    xor,
+    difference
+  };
+  module2.exports = index;
+});
+
 // node_modules/fast-json-stable-stringify/index.js
 var require_fast_json_stable_stringify = __commonJS((exports2, module2) => {
   module2.exports = function(data, opts) {
@@ -53682,7 +55493,7 @@ var require_fast_json_stable_stringify = __commonJS((exports2, module2) => {
   };
 });
 
-// node_modules/circuit-json-to-gerber/dist/chunk-FNNZTRYF.js
+// node_modules/circuit-json-to-gerber/dist/chunk-46NSLLUV.js
 import { z as z4 } from "zod";
 import { z as z23 } from "zod";
 import { z as z32 } from "zod";
@@ -53703,6 +55514,7 @@ import { z as z17 } from "zod";
 import { z as z18 } from "zod";
 import { z as z19 } from "zod";
 import { z as z20 } from "zod";
+import { getBoundFromCenteredRect } from "@tscircuit/math-utils";
 import { z as z21 } from "zod";
 import { z as z222 } from "zod";
 import { z as z232 } from "zod";
@@ -53733,7 +55545,6 @@ import { z as z47 } from "zod";
 import { z as z48 } from "zod";
 import { z as z49 } from "zod";
 import { z as z50 } from "zod";
-import { lineAlphabet as lineAlphabet2 } from "@tscircuit/alphabet";
 import {
   applyToPoint as applyToPoint26,
   compose as compose9,
@@ -53741,6 +55552,25 @@ import {
   rotate as rotate12,
   translate as translate9
 } from "transformation-matrix";
+import { getBoundFromCenteredRect as getBoundFromCenteredRect2 } from "@tscircuit/math-utils";
+import { lineAlphabet as lineAlphabet2 } from "@tscircuit/alphabet";
+import {
+  applyToPoint as applyToPoint42,
+  compose as compose42,
+  identity as identity32,
+  rotate as rotate42,
+  translate as translate42
+} from "transformation-matrix";
+import { getBoundFromCenteredRect as getBoundFromCenteredRect3 } from "@tscircuit/math-utils";
+import { applyToPoint as applyToPoint25, compose as compose22, rotate as rotate22, translate as translate22 } from "transformation-matrix";
+import { getBoundFromCenteredRect as getBoundFromCenteredRect4 } from "@tscircuit/math-utils";
+import {
+  applyToPoint as applyToPoint32,
+  compose as compose32,
+  identity as identity22,
+  rotate as rotate32,
+  translate as translate32
+} from "transformation-matrix";
 function pairs3(arr) {
   const result = [];
   for (let i3 = 0;i3 < arr.length - 1; i3++) {
@@ -53756,17 +55586,30 @@ function getAllTraceWidths(soup) {
       if (segment2.route_type === "wire") {
         widths[segment2.layer] = widths[segment2.layer] || /* @__PURE__ */ new Set;
         widths[segment2.layer].add(segment2.width);
+      } else if (segment2.route_type === "through_pad") {
+        for (const layer of [segment2.start_layer, segment2.end_layer]) {
+          if (typeof layer === "string" && typeof segment2.width === "number") {
+            widths[layer] = widths[layer] || /* @__PURE__ */ new Set;
+            widths[layer].add(segment2.width);
+          }
+        }
       }
     }
   }
   return {
     top: Array.from(widths.top || []),
+    inner1: Array.from(widths.inner1 || []),
+    inner2: Array.from(widths.inner2 || []),
+    inner3: Array.from(widths.inner3 || []),
+    inner4: Array.from(widths.inner4 || []),
+    inner5: Array.from(widths.inner5 || []),
+    inner6: Array.from(widths.inner6 || []),
     bottom: Array.from(widths.bottom || [])
   };
 }
 function defineAperturesForLayer({
   glayer,
-  soup,
+  circuitJson,
   glayer_name
 }) {
   const getNextApertureNumber = () => {
@@ -53782,15 +55625,20 @@ function defineAperturesForLayer({
     return highest_aperture_number + 1;
   };
   glayer.push(...gerberBuilder().add("comment", { comment: "aperture START LIST" }).build());
-  const traceWidths = getAllTraceWidths(soup);
-  for (const width of traceWidths[glayer_name.startsWith("F_") ? "top" : "bottom"]) {
+  const traceWidths = getAllTraceWidths(circuitJson);
+  const layerRef = getLayerRefFromGerberLayerName(glayer_name);
+  for (const width of traceWidths[layerRef]) {
     glayer.push(...gerberBuilder().add("define_aperture_template", {
       aperture_number: getNextApertureNumber(),
       standard_template_code: "C",
       diameter: width
     }).build());
   }
-  const apertureConfigs = getAllApertureTemplateConfigsForLayer(soup, glayer_name.startsWith("F_") ? "top" : "bottom");
+  const apertureConfigs = getAllApertureTemplateConfigsForLayer({
+    circuitJson,
+    layer: layerRef,
+    glayer_name
+  });
   for (const apertureConfig of apertureConfigs) {
     glayer.push(...gerberBuilder().add("define_aperture_template", {
       aperture_number: getNextApertureNumber(),
@@ -53799,9 +55647,16 @@ function defineAperturesForLayer({
   }
   glayer.push(...gerberBuilder().add("delete_attribute", {}).add("comment", { comment: "aperture END LIST" }).build());
 }
-function getAllApertureTemplateConfigsForLayer(soup, layer) {
+function getAllApertureTemplateConfigsForLayer({
+  circuitJson,
+  layer,
+  glayer_name
+}) {
   const configs = [];
   const configHashMap = /* @__PURE__ */ new Set;
+  const isSoldermaskLayer = glayer_name.endsWith("_Mask");
+  const isCopperLayer = glayer_name.endsWith("_Cu");
+  const isFabricationLayer = glayer_name.endsWith("_Fab");
   const addConfigIfNew = (config) => {
     const hash = import_fast_json_stable_stringify.default(config);
     if (!configHashMap.has(hash)) {
@@ -53809,38 +55664,145 @@ function getAllApertureTemplateConfigsForLayer(soup, layer) {
       configHashMap.add(hash);
     }
   };
-  for (const elm of soup) {
+  for (const elm of circuitJson) {
     if (elm.type === "pcb_smtpad") {
+      if (isFabricationLayer)
+        continue;
       if (elm.layer === layer && elm.shape !== "polygon") {
-        addConfigIfNew(getApertureConfigFromPcbSmtpad(elm));
+        if (isSoldermaskLayer) {
+          addConfigIfNew(getApertureConfigFromPcbSmtpadSoldermask(elm));
+        } else {
+          addConfigIfNew(getApertureConfigFromPcbSmtpad(elm));
+        }
       }
     } else if (elm.type === "pcb_solder_paste") {
+      if (isFabricationLayer)
+        continue;
       if (elm.layer === layer) {
         addConfigIfNew(getApertureConfigFromPcbSolderPaste(elm));
+        if (elm.shape === "pill") {
+          addConfigIfNew(getApertureConfigFromPcbSolderPaste({
+            ...elm,
+            width: elm.height,
+            height: elm.width
+          }));
+        }
       }
     } else if (elm.type === "pcb_plated_hole") {
+      if (isFabricationLayer)
+        continue;
       if (elm.layers.includes(layer)) {
-        addConfigIfNew(getApertureConfigFromPcbPlatedHole(elm));
+        if (elm.shape === "hole_with_polygon_pad") {
+          continue;
+        }
+        if (glayer_name.endsWith("_Mask") && elm.is_covered_with_solder_mask === true) {
+          continue;
+        }
+        if (isSoldermaskLayer) {
+          addConfigIfNew(getApertureConfigFromPcbPlatedHoleSoldermask(elm));
+        } else {
+          addConfigIfNew(getApertureConfigFromPcbPlatedHole(elm));
+        }
       }
     } else if (elm.type === "pcb_hole") {
-      if (elm.hole_shape === "circle")
-        addConfigIfNew(getApertureConfigFromCirclePcbHole(elm));
-      else
+      if (!isSoldermaskLayer)
+        continue;
+      if (glayer_name.endsWith("_Mask") && elm.is_covered_with_solder_mask === true) {
+        continue;
+      }
+      if (elm.hole_shape === "circle") {
+        if (isSoldermaskLayer) {
+          addConfigIfNew(getApertureConfigFromCirclePcbHoleSoldermask(elm));
+        } else {
+          addConfigIfNew(getApertureConfigFromCirclePcbHole(elm));
+        }
+      } else
         console.warn("NOT IMPLEMENTED: drawing gerber for non circle holes");
     } else if (elm.type === "pcb_via") {
-      addConfigIfNew(getApertureConfigFromPcbVia(elm));
-    } else if (elm.type === "pcb_silkscreen_path")
-      addConfigIfNew(getApertureConfigFromPcbSilkscreenPath(elm));
-    else if (elm.type === "pcb_silkscreen_text")
-      addConfigIfNew(getApertureConfigFromPcbSilkscreenText(elm));
-    else if (elm.type === "pcb_copper_text") {
+      if (isFabricationLayer)
+        continue;
+      addConfigIfNew(getApertureConfigFromOuterDiameter(elm));
+    } else if (elm.type === "pcb_trace") {
+      if (isFabricationLayer)
+        continue;
+      for (const point9 of elm.route) {
+        if (point9.route_type === "via" && typeof point9.outer_diameter === "number" && (point9.from_layer === layer || point9.to_layer === layer)) {
+          addConfigIfNew(getApertureConfigFromOuterDiameter(point9));
+        }
+      }
+    } else if (elm.type === "pcb_silkscreen_path") {
+      if (!isFabricationLayer)
+        addConfigIfNew(getApertureConfigFromPcbSilkscreenPath(elm));
+    } else if (isSilkscreenShape(elm)) {
+      if (!isFabricationLayer) {
+        addConfigIfNew({
+          standard_template_code: "C",
+          diameter: elm.stroke_width ?? 0.1
+        });
+        if (elm.is_filled === true) {
+          addConfigIfNew(REGION_APERTURE_CONFIG);
+        }
+      }
+    } else if (elm.type === "pcb_silkscreen_graphic") {
+      if (glayer_name.endsWith("_SilkScreen")) {
+        addConfigIfNew(REGION_APERTURE_CONFIG);
+      }
+    } else if (elm.type === "pcb_silkscreen_text") {
+      if (!isFabricationLayer)
+        addConfigIfNew(getApertureConfigFromPcbSilkscreenText(elm));
+    } else if (elm.type === "pcb_fabrication_note_text") {
+      if (isFabricationLayer && elm.layer === layer)
+        addConfigIfNew(getApertureConfigFromPcbFabricationNoteText(elm));
+    } else if (elm.type === "pcb_fabrication_note_path") {
+      if (isFabricationLayer && elm.layer === layer)
+        addConfigIfNew(getApertureConfigFromPcbFabricationNotePath(elm));
+    } else if (elm.type === "pcb_fabrication_note_rect") {
+      if (isFabricationLayer && elm.layer === layer) {
+        if (elm.has_stroke !== false)
+          addConfigIfNew(getApertureConfigFromPcbFabricationNotePath(elm));
+        if (elm.is_filled === true)
+          addConfigIfNew(REGION_APERTURE_CONFIG);
+      }
+    } else if (elm.type === "pcb_fabrication_note_dimension") {
+      if (isFabricationLayer && elm.layer === layer) {
+        addConfigIfNew(getApertureConfigFromPcbFabricationNoteDimension(elm));
+        addConfigIfNew(getApertureConfigFromPcbFabricationNoteText(elm));
+      }
+    } else if (elm.type === "pcb_copper_text") {
       if (elm.layer === layer)
         addConfigIfNew(getApertureConfigFromPcbCopperText(elm));
     }
   }
+  const needsRegionAperture = circuitJson.some((elm) => {
+    if (elm.type === "pcb_copper_pour") {
+      if (elm.layer !== layer)
+        return false;
+      if (isCopperLayer)
+        return true;
+      return isSoldermaskLayer && elm.covered_with_solder_mask === false;
+    }
+    if (elm.type === "pcb_smtpad" && elm.shape === "polygon") {
+      if (elm.layer !== layer)
+        return false;
+      if (isCopperLayer)
+        return true;
+      return isSoldermaskLayer && elm.is_covered_with_solder_mask !== true;
+    }
+    if (elm.type === "pcb_plated_hole" && elm.shape === "hole_with_polygon_pad") {
+      if (!elm.layers.includes(layer))
+        return false;
+      if (isCopperLayer)
+        return true;
+      return isSoldermaskLayer && elm.is_covered_with_solder_mask !== true;
+    }
+    return false;
+  });
+  if (needsRegionAperture) {
+    addConfigIfNew(REGION_APERTURE_CONFIG);
+  }
   return configs;
 }
-var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
+var import_polygon_clipping, import_fast_json_stable_stringify, import_polygon_clipping2, import_polygon_clipping3, defineExcellonDrillCommand = ({
   command_code,
   schema,
   stringify: stringify3
@@ -53873,12 +55835,270 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
   build() {
     return this.commands;
   }
-}, excellonDrill = () => new ExcellonDrillBuilder, convertSoupToExcellonDrillCommands = ({
+}, excellonDrill = () => new ExcellonDrillBuilder, getLayerCount = (circuitJson) => {
+  const board = circuitJson.find((element) => element.type === "pcb_board");
+  if (!board || typeof board.num_layers !== "number") {
+    return 2;
+  }
+  return Math.max(2, board.num_layers);
+}, getLayerNumber = (layer, layerCount) => {
+  if (layer === "top")
+    return 1;
+  if (layer === "bottom")
+    return layerCount;
+  const innerLayerMatch = layer.match(/^inner([1-6])$/);
+  if (innerLayerMatch) {
+    const innerLayerNumber = Number(innerLayerMatch[1]);
+    if (innerLayerNumber >= 1 && innerLayerNumber <= layerCount - 2) {
+      return innerLayerNumber + 1;
+    }
+  }
+  throw new Error(`Invalid layer "${layer}" for ${layerCount}-layer board`);
+}, normalizeLayerSpan = (span, layerCount) => {
+  const fromLayerNumber = getLayerNumber(span.from_layer, layerCount);
+  const toLayerNumber = getLayerNumber(span.to_layer, layerCount);
+  if (fromLayerNumber <= toLayerNumber) {
+    return span;
+  }
+  return {
+    from_layer: span.to_layer,
+    to_layer: span.from_layer
+  };
+}, getPlatedElementLayerSpan = (element, layerCount) => {
+  if (element.type !== "pcb_plated_hole" && element.type !== "pcb_via") {
+    return;
+  }
+  if ("from_layer" in element && typeof element.from_layer === "string" && "to_layer" in element && typeof element.to_layer === "string") {
+    return normalizeLayerSpan({
+      from_layer: element.from_layer,
+      to_layer: element.to_layer
+    }, layerCount);
+  }
+  let layers = [];
+  if ("layers" in element && Array.isArray(element.layers)) {
+    layers = element.layers;
+  }
+  if (layers.length > 0) {
+    const sortedLayers = [...layers].sort((a3, b3) => getLayerNumber(a3, layerCount) - getLayerNumber(b3, layerCount));
+    return {
+      from_layer: sortedLayers[0],
+      to_layer: sortedLayers[sortedLayers.length - 1]
+    };
+  }
+  return {
+    from_layer: "top",
+    to_layer: "bottom"
+  };
+}, getDefaultPlatedDrillLayerSpan = () => ({
+  from_layer: "top",
+  to_layer: "bottom"
+}), getRequestedLayerSpan = (layer_span) => {
+  if (layer_span) {
+    return layer_span;
+  }
+  return getDefaultPlatedDrillLayerSpan();
+}, isSameLayerSpan = (a3, b3, layerCount) => {
+  const normalizedA = normalizeLayerSpan(a3, layerCount);
+  const normalizedB = normalizeLayerSpan(b3, layerCount);
+  return normalizedA.from_layer === normalizedB.from_layer && normalizedA.to_layer === normalizedB.to_layer;
+}, shouldIncludeElement = ({
+  element,
+  is_plated,
+  layer_span,
+  layerCount
+}) => {
+  if (element.type !== "pcb_plated_hole" && element.type !== "pcb_hole" && element.type !== "pcb_via") {
+    return false;
+  }
+  if (!is_plated)
+    return element.type === "pcb_hole";
+  if (element.type === "pcb_hole")
+    return false;
+  const elementLayerSpan = getPlatedElementLayerSpan(element, layerCount);
+  if (!elementLayerSpan)
+    return false;
+  const requestedLayerSpan = getRequestedLayerSpan(layer_span);
+  return isSameLayerSpan(elementLayerSpan, requestedLayerSpan, layerCount);
+}, getFileFunctionLayerSpan = ({
+  circuitJson,
+  is_plated,
+  layer_span
+}) => {
+  const layerCount = getLayerCount(circuitJson);
+  if (!is_plated)
+    return `NonPlated,1,${layerCount},NPTH`;
+  const requestedLayerSpan = getRequestedLayerSpan(layer_span);
+  const span = normalizeLayerSpan(requestedLayerSpan, layerCount);
+  return `Plated,${getLayerNumber(span.from_layer, layerCount)},${getLayerNumber(span.to_layer, layerCount)},PTH`;
+}, getTraceRouteViaElements = (circuitJson) => {
+  const routeVias = [];
+  for (const element of circuitJson) {
+    if (element.type !== "pcb_trace") {
+      continue;
+    }
+    for (const [index, point9] of element.route.entries()) {
+      if (point9.route_type !== "via" || typeof point9.hole_diameter !== "number" || typeof point9.outer_diameter !== "number" || typeof point9.from_layer !== "string" || typeof point9.to_layer !== "string") {
+        continue;
+      }
+      const fromLayer = point9.from_layer;
+      const toLayer = point9.to_layer;
+      routeVias.push({
+        type: "pcb_via",
+        pcb_via_id: `${element.pcb_trace_id}_route_via_${index}`,
+        x: point9.x,
+        y: point9.y,
+        hole_diameter: point9.hole_diameter,
+        outer_diameter: point9.outer_diameter,
+        from_layer: fromLayer,
+        to_layer: toLayer,
+        layers: [fromLayer, toLayer]
+      });
+    }
+  }
+  return routeVias;
+}, getDrillableElements = (circuitJson) => [
+  ...circuitJson,
+  ...getTraceRouteViaElements(circuitJson)
+], circleCutoutPolygonSegmentCount = 64, getBoardOutlinePolygons = (circuitJson) => {
+  return circuitJson.flatMap((element) => {
+    if (element.type !== "pcb_board") {
+      return [];
+    }
+    if (element.outline && element.outline.length > 2) {
+      return [[element.outline.map((point9) => [point9.x, point9.y])]];
+    }
+    const bounds = getBoundFromCenteredRect({
+      center: element.center,
+      width: element.width,
+      height: element.height
+    });
+    return [
+      [
+        [
+          [bounds.minX, bounds.minY],
+          [bounds.maxX, bounds.minY],
+          [bounds.maxX, bounds.maxY],
+          [bounds.minX, bounds.maxY]
+        ]
+      ]
+    ];
+  });
+}, getCircleCutoutPolygon = (cutout) => {
+  const points = [];
+  for (let i3 = 0;i3 < circleCutoutPolygonSegmentCount; i3++) {
+    const angle = i3 / circleCutoutPolygonSegmentCount * Math.PI * 2;
+    points.push([
+      cutout.center.x + cutout.radius * Math.cos(angle),
+      cutout.center.y + cutout.radius * Math.sin(angle)
+    ]);
+  }
+  return [points];
+}, isInternalCircularCutout = ({
+  cutout,
+  boardOutlinePolygons
+}) => {
+  const cutoutPolygon = getCircleCutoutPolygon(cutout);
+  return boardOutlinePolygons.some((boardOutlinePolygon) => {
+    const overlapsBoard = import_polygon_clipping.default.intersection(boardOutlinePolygon, cutoutPolygon).length > 0;
+    const extendsOutsideBoard = import_polygon_clipping.default.difference(cutoutPolygon, boardOutlinePolygon).length > 0;
+    return overlapsBoard && !extendsOutsideBoard;
+  });
+}, getInternalCircularCutoutDrills = (circuitJson) => {
+  const boardOutlinePolygons = getBoardOutlinePolygons(circuitJson);
+  return circuitJson.filter((element) => {
+    if (element.type !== "pcb_cutout") {
+      return false;
+    }
+    if (element.shape !== "circle") {
+      return false;
+    }
+    return isInternalCircularCutout({
+      cutout: element,
+      boardOutlinePolygons
+    });
+  });
+}, getDrillElements = ({
+  circuitJson,
+  is_plated
+}) => {
+  const drillableElements = getDrillableElements(circuitJson).filter((element) => element.type !== "pcb_cutout");
+  if (is_plated) {
+    return drillableElements;
+  }
+  const internalCircularCutoutDrills = getInternalCircularCutoutDrills(circuitJson);
+  return [...drillableElements, ...internalCircularCutoutDrills];
+}, getHoleDiameter = (element) => {
+  if ("hole_diameter" in element && typeof element.hole_diameter === "number") {
+    return element.hole_diameter;
+  }
+  if (element.type === "pcb_cutout") {
+    return element.radius * 2;
+  }
+  if ("hole_width" in element && typeof element.hole_width === "number" && "hole_height" in element && typeof element.hole_height === "number") {
+    return Math.min(element.hole_width, element.hole_height);
+  }
+  return;
+}, getDrillCenter = (element) => {
+  if (element.type === "pcb_cutout") {
+    return element.center;
+  }
+  let x4 = 0;
+  let y4 = 0;
+  let holeOffsetX = 0;
+  let holeOffsetY = 0;
+  if ("x" in element && typeof element.x === "number") {
+    x4 = element.x;
+  }
+  if ("y" in element && typeof element.y === "number") {
+    y4 = element.y;
+  }
+  if ("hole_offset_x" in element && typeof element.hole_offset_x === "number") {
+    holeOffsetX = element.hole_offset_x;
+  }
+  if ("hole_offset_y" in element && typeof element.hole_offset_y === "number") {
+    holeOffsetY = element.hole_offset_y;
+  }
+  return {
+    x: x4 + holeOffsetX,
+    y: y4 + holeOffsetY
+  };
+}, getYMultiplier = (flip_y_axis) => {
+  if (flip_y_axis) {
+    return -1;
+  }
+  return 1;
+}, getSlotEndpoints = ({
+  holeWidth,
+  holeHeight,
+  slotHalfLength
+}) => {
+  let startRelative = { x: 0, y: -slotHalfLength };
+  let endRelative = { x: 0, y: slotHalfLength };
+  if (holeWidth >= holeHeight) {
+    startRelative = { x: -slotHalfLength, y: 0 };
+    endRelative = { x: slotHalfLength, y: 0 };
+  }
+  return { startRelative, endRelative };
+}, getHoleRotationDegrees = (element) => {
+  if ("hole_ccw_rotation" in element && typeof element.hole_ccw_rotation === "number") {
+    return element.hole_ccw_rotation;
+  }
+  if ("ccw_rotation" in element && typeof element.ccw_rotation === "number") {
+    return element.ccw_rotation;
+  }
+  return 0;
+}, convertSoupToExcellonDrillCommands = ({
   circuitJson,
   is_plated,
-  flip_y_axis = false
+  flip_y_axis = false,
+  layer_span
 }) => {
   const builder = excellonDrill();
+  const layerCount = getLayerCount(circuitJson);
+  const drillElements = getDrillElements({
+    circuitJson,
+    is_plated
+  });
   builder.add("M48", {});
   const date_str = (/* @__PURE__ */ new Date()).toISOString();
   builder.add("header_comment", {
@@ -53893,18 +56113,27 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
     attribute_value: "tscircuit"
   }).add("header_attribute", {
     attribute_name: "TF.FileFunction",
-    attribute_value: is_plated ? "Plated,1,2,PTH" : "NonPlated,1,2,NPTH"
+    attribute_value: getFileFunctionLayerSpan({
+      circuitJson,
+      is_plated,
+      layer_span
+    })
   }).add("FMAT", { format: 2 }).add("unit_format", { unit: "METRIC", lz: null });
   let tool_counter = 10;
   const diameterToToolNumber = {};
-  for (const element of circuitJson) {
-    if (element.type !== "pcb_plated_hole" && element.type !== "pcb_hole" && element.type !== "pcb_via") {
+  for (const element of drillElements) {
+    if (element.type !== "pcb_cutout" && !shouldIncludeElement({
+      element,
+      is_plated,
+      layer_span,
+      layerCount
+    })) {
       continue;
     }
-    if (!is_plated && (element.type === "pcb_plated_hole" || element.type === "pcb_via")) {
+    if (is_plated && element.type === "pcb_hole") {
       continue;
     }
-    const holeDiameter = "hole_diameter" in element && typeof element.hole_diameter === "number" ? element.hole_diameter : ("hole_width" in element) && typeof element.hole_width === "number" && ("hole_height" in element) && typeof element.hole_height === "number" ? Math.min(element.hole_width, element.hole_height) : undefined;
+    const holeDiameter = getHoleDiameter(element);
     if (!holeDiameter)
       continue;
     if (!diameterToToolNumber[holeDiameter]) {
@@ -53924,22 +56153,27 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
   builder.add("G05", {});
   for (let i3 = 10;i3 < tool_counter; i3++) {
     builder.add("use_tool", { tool_number: i3 });
-    for (const element of circuitJson) {
-      if (element.type === "pcb_plated_hole" || element.type === "pcb_hole" || element.type === "pcb_via") {
-        if (!is_plated && (element.type === "pcb_plated_hole" || element.type === "pcb_via")) {
+    for (const element of drillElements) {
+      if (element.type === "pcb_plated_hole" || element.type === "pcb_hole" || element.type === "pcb_via" || element.type === "pcb_cutout") {
+        if (element.type !== "pcb_cutout" && !shouldIncludeElement({
+          element,
+          is_plated,
+          layer_span,
+          layerCount
+        })) {
+          continue;
+        }
+        if (is_plated && element.type === "pcb_hole") {
           continue;
         }
-        const holeDiameter = "hole_diameter" in element && typeof element.hole_diameter === "number" ? element.hole_diameter : ("hole_width" in element) && typeof element.hole_width === "number" && ("hole_height" in element) && typeof element.hole_height === "number" ? Math.min(element.hole_width, element.hole_height) : undefined;
+        const holeDiameter = getHoleDiameter(element);
         if (!holeDiameter || diameterToToolNumber[holeDiameter] !== i3) {
           continue;
         }
-        const elementX = "x" in element && typeof element.x === "number" ? element.x : 0;
-        const elementY = "y" in element && typeof element.y === "number" ? element.y : 0;
-        const offsetX = "hole_offset_x" in element && typeof element.hole_offset_x === "number" ? element.hole_offset_x : 0;
-        const offsetY = "hole_offset_y" in element && typeof element.hole_offset_y === "number" ? element.hole_offset_y : 0;
-        const centerX = elementX + offsetX;
-        const centerY = elementY + offsetY;
-        const yMultiplier = flip_y_axis ? -1 : 1;
+        const drillCenter = getDrillCenter(element);
+        const centerX = drillCenter.x;
+        const centerY = drillCenter.y;
+        const yMultiplier = getYMultiplier(flip_y_axis);
         if ("hole_width" in element && typeof element.hole_width === "number" && "hole_height" in element && typeof element.hole_height === "number") {
           const holeWidth = element.hole_width;
           const holeHeight = element.hole_height;
@@ -53952,14 +56186,16 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
             });
             continue;
           }
-          const rotationDegrees = "hole_ccw_rotation" in element && typeof element.hole_ccw_rotation === "number" ? element.hole_ccw_rotation : ("ccw_rotation" in element) && typeof element.ccw_rotation === "number" ? element.ccw_rotation : 0;
+          const rotationDegrees = getHoleRotationDegrees(element);
           const rotationRadians = rotationDegrees * Math.PI / 180;
           const cosTheta = Math.cos(rotationRadians);
           const sinTheta = Math.sin(rotationRadians);
-          const isWidthMajor = holeWidth >= holeHeight;
           const slotHalfLength = (maxDim - minDim) / 2;
-          const startRelative = isWidthMajor ? { x: -slotHalfLength, y: 0 } : { x: 0, y: -slotHalfLength };
-          const endRelative = isWidthMajor ? { x: slotHalfLength, y: 0 } : { x: 0, y: slotHalfLength };
+          const { startRelative, endRelative } = getSlotEndpoints({
+            holeWidth,
+            holeHeight,
+            slotHalfLength
+          });
           const rotatePoint4 = ({ x: x4, y: y4 }) => ({
             x: x4 * cosTheta - y4 * sinTheta,
             y: x4 * sinTheta + y4 * cosTheta
@@ -54061,7 +56297,7 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
 0 $4 = Circle center offset
 0 21 = Center Line(Exposure, Width, Height, Center X, Center Y, Rotation)*
 0 1 = Circle(Exposure, Diameter, Center X, Center Y, Rotation)*
-21,1,$1,$2,0.0,0.0,0.0*
+21,1,$1-$3,$2,0.0,0.0,0.0*
 1,1,$3,0.0-$4,0.0*
 1,1,$3,$4,0.0*
 `.trim()
@@ -54075,12 +56311,12 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
 0 $3 = Circle diameter (equal to width)*
 0 $4 = Circle center offset
 0 21 = Center Line(Exposure, Width, Height, Center X, Center Y, Rotation)*
-21,1,$1,$2,0.0,0.0,0.0*
+21,1,$1,$2-$3,0.0,0.0,0.0*
 1,1,$3,0.0,0.0-$4*
 1,1,$3,0.0,$4*
 `.trim()
   }).add("define_macro_aperture_template", {
-    macro_name: "RoundRect",
+    macro_name: "ROUNDRECT",
     template_code: `
 0 Rectangle with rounded corners*
 0 $1 Corner radius*
@@ -54099,7 +56335,117 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
 20,1,$1+$1,$8,$9,$2,$3,0*
 `.trim()
   }).add("comment", { comment: "APERTURE MACROS END" }).build());
-}, getApertureConfigFromPcbSmtpad = (elm) => {
+}, SILKSCREEN_SHAPE_TYPES, isSilkscreenShape = (element) => SILKSCREEN_SHAPE_TYPES.includes(element.type), DEFAULT_STROKE_WIDTH2 = 0.1, ELLIPSE_SEGMENTS = 48, CORNER_SEGMENTS = 12, rotationAboutCenter = (center2, ccwDegrees) => ccwDegrees ? compose9(translate9(center2.x, center2.y), rotate12(ccwDegrees * Math.PI / 180), translate9(-center2.x, -center2.y)) : identity8(), ellipseRoute = (center2, radiusX, radiusY, ccwDegrees = 0) => {
+  const matrix2 = rotationAboutCenter(center2, ccwDegrees);
+  return Array.from({ length: ELLIPSE_SEGMENTS + 1 }, (_4, i3) => {
+    const angle = i3 / ELLIPSE_SEGMENTS * Math.PI * 2;
+    return applyToPoint26(matrix2, {
+      x: center2.x + radiusX * Math.cos(angle),
+      y: center2.y + radiusY * Math.sin(angle)
+    });
+  });
+}, rectangleRoute = (center2, width, height, cornerRadius, ccwDegrees = 0) => {
+  const halfW = width / 2;
+  const halfH = height / 2;
+  const route = [];
+  if (cornerRadius <= 0) {
+    const bounds = getBoundFromCenteredRect2({ center: center2, width, height });
+    route.push({ x: bounds.minX, y: bounds.minY }, { x: bounds.maxX, y: bounds.minY }, { x: bounds.maxX, y: bounds.maxY }, { x: bounds.minX, y: bounds.maxY });
+  } else {
+    const insetW = halfW - cornerRadius;
+    const insetH = halfH - cornerRadius;
+    const corners = [
+      { x: center2.x + insetW, y: center2.y + insetH, start: 0 },
+      { x: center2.x - insetW, y: center2.y + insetH, start: Math.PI / 2 },
+      { x: center2.x - insetW, y: center2.y - insetH, start: Math.PI },
+      { x: center2.x + insetW, y: center2.y - insetH, start: 3 * Math.PI / 2 }
+    ];
+    for (const corner of corners) {
+      for (let i3 = 0;i3 <= CORNER_SEGMENTS; i3++) {
+        const angle = corner.start + i3 / CORNER_SEGMENTS * (Math.PI / 2);
+        route.push({
+          x: corner.x + cornerRadius * Math.cos(angle),
+          y: corner.y + cornerRadius * Math.sin(angle)
+        });
+      }
+    }
+  }
+  route.push(route[0]);
+  const matrix2 = rotationAboutCenter(center2, ccwDegrees);
+  return route.map((point9) => applyToPoint26(matrix2, point9));
+}, clampCornerRadius = (width, height, cornerRadius) => {
+  if (typeof cornerRadius !== "number" || cornerRadius <= 0)
+    return 0;
+  return Math.min(cornerRadius, width / 2, height / 2);
+}, getSilkscreenShapeStroke = (element) => {
+  const strokeWidth = element.stroke_width ?? DEFAULT_STROKE_WIDTH2;
+  switch (element.type) {
+    case "pcb_silkscreen_line":
+      return {
+        route: [
+          { x: element.x1, y: element.y1 },
+          { x: element.x2, y: element.y2 }
+        ],
+        strokeWidth
+      };
+    case "pcb_silkscreen_rect":
+      return {
+        route: rectangleRoute(element.center, element.width, element.height, clampCornerRadius(element.width, element.height, element.corner_radius), element.ccw_rotation ?? 0),
+        strokeWidth
+      };
+    case "pcb_silkscreen_circle":
+      return {
+        route: ellipseRoute(element.center, element.radius, element.radius),
+        strokeWidth
+      };
+    case "pcb_silkscreen_oval":
+      return {
+        route: ellipseRoute(element.center, element.radius_x, element.radius_y, element.ccw_rotation ?? 0),
+        strokeWidth
+      };
+    case "pcb_silkscreen_pill":
+      return {
+        route: rectangleRoute(element.center, element.width, element.height, Math.min(element.width, element.height) / 2),
+        strokeWidth
+      };
+    default:
+      return null;
+  }
+}, getLayerRefFromGerberLayerName = (glayer_name) => {
+  if (glayer_name.startsWith("F_"))
+    return "top";
+  if (glayer_name.startsWith("B_"))
+    return "bottom";
+  const innerLayerMatch = glayer_name.match(/^In([1-6])_/);
+  if (innerLayerMatch)
+    return `inner${innerLayerMatch[1]}`;
+  throw new Error(`Could not infer layer ref from ${glayer_name}`);
+}, getClampedRoundedRectCornerRadius = (width, height, cornerRadius) => {
+  if (typeof cornerRadius !== "number")
+    return 0;
+  return Math.max(0, Math.min(cornerRadius, width / 2, height / 2));
+}, getRoundedRectApertureConfig = (width, height, cornerRadius) => {
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  return {
+    macro_name: "ROUNDRECT",
+    corner_radius: cornerRadius,
+    corner_1_x: -halfWidth + cornerRadius,
+    corner_1_y: halfHeight - cornerRadius,
+    corner_2_x: halfWidth - cornerRadius,
+    corner_2_y: halfHeight - cornerRadius,
+    corner_3_x: halfWidth - cornerRadius,
+    corner_3_y: -halfHeight + cornerRadius,
+    corner_4_x: -halfWidth + cornerRadius,
+    corner_4_y: -halfHeight + cornerRadius
+  };
+}, REGION_APERTURE_CONFIG, getApertureConfigFromPcbSmtpad = (elm) => {
+  if (elm.shape === "rect" || elm.shape === "rotated_rect") {
+    const cornerRadius = getClampedRoundedRectCornerRadius(elm.width, elm.height, "corner_radius" in elm ? elm.corner_radius : undefined);
+    if (cornerRadius > 0) {
+      return getRoundedRectApertureConfig(elm.width, elm.height, cornerRadius);
+    }
+  }
   if (elm.shape === "rect") {
     return {
       standard_template_code: "R",
@@ -54120,6 +56466,63 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
       y_size: elm.height
     };
   }
+  if (elm.shape === "pill" || elm.shape === "rotated_pill") {
+    if (!(("width" in elm) && ("height" in elm))) {
+      throw new Error("Invalid pill shape in getApertureConfigFromPcbSmtpad: missing dimensions");
+    }
+    return {
+      standard_template_code: "C",
+      diameter: Math.min(elm.width, elm.height)
+    };
+  }
+  if (elm.shape === "polygon") {
+    throw new Error("Polygon SMT pads are drawn as regions, not apertures");
+  }
+  throw new Error(`Unsupported shape ${elm.shape}`);
+}, getApertureConfigFromPcbSmtpadSoldermask = (elm) => {
+  let soldermaskMargin = 0;
+  if ("soldermask_margin" in elm && typeof elm.soldermask_margin === "number") {
+    soldermaskMargin = elm.soldermask_margin;
+  }
+  if (elm.shape === "rect" || elm.shape === "rotated_rect") {
+    const width = elm.width + soldermaskMargin * 2;
+    const height = elm.height + soldermaskMargin * 2;
+    const cornerRadius = getClampedRoundedRectCornerRadius(width, height, "corner_radius" in elm && typeof elm.corner_radius === "number" ? elm.corner_radius + soldermaskMargin : undefined);
+    if (cornerRadius > 0) {
+      return getRoundedRectApertureConfig(width, height, cornerRadius);
+    }
+  }
+  if (elm.shape === "rect") {
+    return {
+      standard_template_code: "R",
+      x_size: elm.width + soldermaskMargin * 2,
+      y_size: elm.height + soldermaskMargin * 2
+    };
+  }
+  if (elm.shape === "circle") {
+    return {
+      standard_template_code: "C",
+      diameter: elm.radius * 2 + soldermaskMargin * 2
+    };
+  }
+  if (elm.shape === "rotated_rect") {
+    return {
+      standard_template_code: "R",
+      x_size: elm.width + soldermaskMargin * 2,
+      y_size: elm.height + soldermaskMargin * 2
+    };
+  }
+  if (elm.shape === "pill" || elm.shape === "rotated_pill") {
+    if (!(("width" in elm) && ("height" in elm))) {
+      throw new Error("Invalid pill shape in getApertureConfigFromPcbSmtpadSoldermask: missing dimensions");
+    }
+    const width = elm.width + soldermaskMargin * 2;
+    const height = elm.height + soldermaskMargin * 2;
+    return {
+      standard_template_code: "C",
+      diameter: Math.min(width, height)
+    };
+  }
   if (elm.shape === "polygon") {
     throw new Error("Polygon SMT pads are drawn as regions, not apertures");
   }
@@ -54148,6 +56551,30 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
     };
   }
   throw new Error(`Provide font_size for: ${elm}`);
+}, getApertureConfigFromPcbFabricationNoteText = (elm) => {
+  if ("font_size" in elm) {
+    return {
+      standard_template_code: "C",
+      diameter: elm.font_size / 8
+    };
+  }
+  throw new Error(`Provide font_size for: ${elm}`);
+}, getApertureConfigFromPcbFabricationNotePath = (elm) => {
+  if (!("stroke_width" in elm) || typeof elm.stroke_width !== "number") {
+    return {
+      standard_template_code: "C",
+      diameter: 0.1
+    };
+  }
+  return {
+    standard_template_code: "C",
+    diameter: elm.stroke_width
+  };
+}, getApertureConfigFromPcbFabricationNoteDimension = (elm) => {
+  return {
+    standard_template_code: "C",
+    diameter: Math.max(0.05, elm.font_size / 10)
+  };
 }, getApertureConfigFromPcbSolderPaste = (elm) => {
   if (elm.shape === "rect") {
     return {
@@ -54179,7 +56606,7 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
         x_size: elm.width,
         y_size: elm.height,
         circle_diameter: Math.min(elm.width, elm.height),
-        circle_center_offset: elm.width / 2
+        circle_center_offset: (elm.width - elm.height) / 2
       };
     }
     return {
@@ -54187,7 +56614,7 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
       x_size: elm.width,
       y_size: elm.height,
       circle_diameter: Math.min(elm.width, elm.height),
-      circle_center_offset: elm.height / 2
+      circle_center_offset: (elm.height - elm.width) / 2
     };
   }
   throw new Error(`Unsupported shape ${elm.shape}`);
@@ -54211,7 +56638,7 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
         x_size: elm.outer_width,
         y_size: elm.outer_height,
         circle_diameter: Math.min(elm.outer_width, elm.outer_height),
-        circle_center_offset: elm.outer_width / 2
+        circle_center_offset: (elm.outer_width - elm.outer_height) / 2
       };
     }
     return {
@@ -54219,7 +56646,7 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
       x_size: elm.outer_width,
       y_size: elm.outer_height,
       circle_diameter: Math.min(elm.outer_width, elm.outer_height),
-      circle_center_offset: elm.outer_height / 2
+      circle_center_offset: (elm.outer_height - elm.outer_width) / 2
     };
   }
   const shape = elm.shape;
@@ -54234,6 +56661,55 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
     };
   }
   throw new Error(`Unsupported shape in getApertureConfigFromPcbPlatedHole: ${elm.shape}`);
+}, getApertureConfigFromPcbPlatedHoleSoldermask = (elm) => {
+  let soldermaskMargin = 0;
+  if ("soldermask_margin" in elm && typeof elm.soldermask_margin === "number") {
+    soldermaskMargin = elm.soldermask_margin;
+  }
+  if (elm.shape === "circle") {
+    if (!(("outer_diameter" in elm) && ("hole_diameter" in elm))) {
+      throw new Error("Invalid circle shape in getApertureConfigFromPcbPlatedHoleSoldermask: missing diameters");
+    }
+    return {
+      standard_template_code: "C",
+      diameter: elm.outer_diameter + soldermaskMargin * 2
+    };
+  }
+  if (elm.shape === "pill") {
+    if (!(("outer_width" in elm) && ("outer_height" in elm))) {
+      throw new Error("Invalid pill shape in getApertureConfigFromPcbPlatedHoleSoldermask: missing dimensions");
+    }
+    const outerWidth = elm.outer_width + soldermaskMargin * 2;
+    const outerHeight = elm.outer_height + soldermaskMargin * 2;
+    if (outerWidth > outerHeight) {
+      return {
+        macro_name: "HORZPILL",
+        x_size: outerWidth,
+        y_size: outerHeight,
+        circle_diameter: Math.min(outerWidth, outerHeight),
+        circle_center_offset: (outerWidth - outerHeight) / 2
+      };
+    }
+    return {
+      macro_name: "VERTPILL",
+      x_size: outerWidth,
+      y_size: outerHeight,
+      circle_diameter: Math.min(outerWidth, outerHeight),
+      circle_center_offset: (outerHeight - outerWidth) / 2
+    };
+  }
+  const shape = elm.shape;
+  if (shape === "circular_hole_with_rect_pad" || shape === "pill_hole_with_rect_pad" || shape === "rotated_pill_hole_with_rect_pad") {
+    if (!(("rect_pad_width" in elm) && ("rect_pad_height" in elm))) {
+      throw new Error(`Invalid ${shape} shape in getApertureConfigFromPcbPlatedHoleSoldermask: missing dimensions`);
+    }
+    return {
+      standard_template_code: "R",
+      x_size: elm.rect_pad_width + soldermaskMargin * 2,
+      y_size: elm.rect_pad_height + soldermaskMargin * 2
+    };
+  }
+  throw new Error(`Unsupported shape in getApertureConfigFromPcbPlatedHoleSoldermask: ${elm.shape}`);
 }, getApertureConfigFromCirclePcbHole = (elm) => {
   if (!("hole_diameter" in elm)) {
     throw new Error(`Invalid shape called in getApertureConfigFromCirclePcbHole: ${elm.hole_shape}`);
@@ -54242,9 +56718,21 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
     standard_template_code: "C",
     diameter: elm.hole_diameter
   };
-}, getApertureConfigFromPcbVia = (elm) => {
-  if (!("outer_diameter" in elm)) {
-    throw new Error("outer_diameter not specified in getApertureConfigFromPcbVia");
+}, getApertureConfigFromCirclePcbHoleSoldermask = (elm) => {
+  if (!("hole_diameter" in elm)) {
+    throw new Error(`Invalid shape called in getApertureConfigFromCirclePcbHoleSoldermask: ${elm.hole_shape}`);
+  }
+  let soldermaskMargin = 0;
+  if ("soldermask_margin" in elm && typeof elm.soldermask_margin === "number") {
+    soldermaskMargin = elm.soldermask_margin;
+  }
+  return {
+    standard_template_code: "C",
+    diameter: elm.hole_diameter + soldermaskMargin * 2
+  };
+}, getApertureConfigFromOuterDiameter = (elm) => {
+  if (typeof elm.outer_diameter !== "number") {
+    throw new Error("outer_diameter not specified in getApertureConfigFromOuterDiameter");
   }
   return {
     standard_template_code: "C",
@@ -54262,8 +56750,22 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
     throw new Error(`Aperture not found for search params ${JSON.stringify(search_params)}`);
   }
   return aperture.aperture_number;
-}, package_default5, layerAndTypeToFileFunction, getCommandHeaders = (opts) => {
-  const file_function = layerAndTypeToFileFunction[opts.layer_type ? `${opts.layer}-${opts.layer_type}` : opts.layer];
+}, package_default5, layerAndTypeToFileFunction, getCopperLayerNumber = (layer, total_layer_count) => {
+  if (layer === "top")
+    return 1;
+  if (layer === "bottom")
+    return total_layer_count;
+  return Number(layer.replace("inner", "")) + 1;
+}, getCommandHeaders = (opts) => {
+  const total_layer_count = opts.total_layer_count ?? 2;
+  let file_function;
+  if (opts.layer_type === "copper" && opts.layer !== "edgecut") {
+    const layerNumber = getCopperLayerNumber(opts.layer, total_layer_count);
+    const layerPosition = opts.layer === "top" ? "Top" : opts.layer === "bottom" ? "Bot" : "Inr";
+    file_function = `Copper,L${layerNumber},${layerPosition}`;
+  } else {
+    file_function = layerAndTypeToFileFunction[opts.layer_type ? `${opts.layer}-${opts.layer_type}` : opts.layer];
+  }
   return gerberBuilder().add("add_attribute_on_file", {
     attribute_name: "GenerationSoftware",
     attribute_value: `tscircuit,circuit-json-to-gerber,${package_default5.version}`
@@ -54291,14 +56793,564 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
 }, layerRefToGerberPrefix, layerTypeToGerberSuffix, getGerberLayerName = (layer_ref2, layer_type) => {
   if (layer_ref2 === "edgecut")
     return "Edge_Cuts";
+  if (layer_ref2.startsWith("inner") && layer_type !== "copper") {
+    throw new Error(`Inner layer ${layer_ref2} only supports copper gerbers`);
+  }
   return `${layerRefToGerberPrefix[layer_ref2]}${layerTypeToGerberSuffix[layer_type]}`;
-}, convertSoupToGerberCommands = (soup, opts = {}) => {
+}, getSignedPolygonArea = (points) => {
+  let area2 = 0;
+  for (let i3 = 0;i3 < points.length; i3++) {
+    const current2 = points[i3];
+    const next = points[(i3 + 1) % points.length];
+    area2 += current2.x * next.y - next.x * current2.y;
+  }
+  return area2 / 2;
+}, getLineIntersection = (lineA, lineB) => {
+  const ax3 = lineA.end.x - lineA.start.x;
+  const ay3 = lineA.end.y - lineA.start.y;
+  const bx3 = lineB.end.x - lineB.start.x;
+  const by3 = lineB.end.y - lineB.start.y;
+  const denominator = ax3 * by3 - ay3 * bx3;
+  if (Math.abs(denominator) < 0.000000001) {
+    return null;
+  }
+  const cx3 = lineB.start.x - lineA.start.x;
+  const cy3 = lineB.start.y - lineA.start.y;
+  const t50 = (cx3 * by3 - cy3 * bx3) / denominator;
+  return {
+    x: lineA.start.x + ax3 * t50,
+    y: lineA.start.y + ay3 * t50
+  };
+}, offsetPolygonOutline = (points, offset) => {
+  if (points.length < 3 || offset === 0) {
+    return points;
+  }
+  const isCounterClockwise = getSignedPolygonArea(points) > 0;
+  const shiftedEdges = [];
+  for (let i3 = 0;i3 < points.length; i3++) {
+    const start = points[i3];
+    const end = points[(i3 + 1) % points.length];
+    const dx3 = end.x - start.x;
+    const dy3 = end.y - start.y;
+    const length67 = Math.sqrt(dx3 * dx3 + dy3 * dy3);
+    if (length67 < 0.000000001) {
+      continue;
+    }
+    let normalX = -dy3 / length67;
+    let normalY = dx3 / length67;
+    if (isCounterClockwise) {
+      normalX = dy3 / length67;
+      normalY = -dx3 / length67;
+    }
+    shiftedEdges.push({
+      start: {
+        x: start.x + normalX * offset,
+        y: start.y + normalY * offset
+      },
+      end: {
+        x: end.x + normalX * offset,
+        y: end.y + normalY * offset
+      }
+    });
+  }
+  if (shiftedEdges.length < 3) {
+    return points;
+  }
+  const offsetPoints = [];
+  for (let i3 = 0;i3 < shiftedEdges.length; i3++) {
+    const previousEdge = shiftedEdges[(i3 - 1 + shiftedEdges.length) % shiftedEdges.length];
+    const currentEdge = shiftedEdges[i3];
+    const intersection = getLineIntersection(previousEdge, currentEdge);
+    if (intersection) {
+      offsetPoints.push(intersection);
+    } else {
+      offsetPoints.push(currentEdge.start);
+    }
+  }
+  return offsetPoints;
+}, outerLayerRefs, isOuterLayerRef = (layerRef) => layerRef === "top" || layerRef === "bottom", isFabricationElementOnLayer = (element, layerRef) => (element.type === "pcb_fabrication_note_text" || element.type === "pcb_fabrication_note_path" || element.type === "pcb_fabrication_note_rect" || element.type === "pcb_fabrication_note_dimension") && element.layer === layerRef, getFabricationLayerRefs = (circuitJson) => outerLayerRefs.filter((layerRef) => circuitJson.some((element) => isFabricationElementOnLayer(element, layerRef))), getFabRectPoints = (element) => {
+  const bounds = getBoundFromCenteredRect3({
+    center: element.center,
+    width: element.width,
+    height: element.height
+  });
+  return [
+    { x: bounds.minX, y: bounds.minY },
+    { x: bounds.maxX, y: bounds.minY },
+    { x: bounds.maxX, y: bounds.maxY },
+    { x: bounds.minX, y: bounds.maxY }
+  ];
+}, renderOpenPath = ({
+  element,
+  glayer,
+  apertureConfig,
+  route,
+  mapY
+}) => {
+  if (route.length === 0)
+    return;
+  const gerber = gerberBuilder().add("select_aperture", {
+    aperture_number: findApertureNumber(glayer, apertureConfig)
+  });
+  gerber.add("move_operation", {
+    x: route[0].x,
+    y: mapY(route[0].y)
+  });
+  const isDashed = element.is_stroke_dashed === true;
+  if (!isDashed) {
+    for (let i3 = 1;i3 < route.length; i3++) {
+      gerber.add("plot_operation", {
+        x: route[i3].x,
+        y: mapY(route[i3].y)
+      });
+    }
+    glayer.push(...gerber.build());
+    return;
+  }
+  const dashLength = Math.max(0.2, (element.stroke_width ?? 0.1) * 4);
+  const gapLength = dashLength;
+  for (const [start, end] of pairs3(route)) {
+    const dx3 = end.x - start.x;
+    const dy3 = end.y - start.y;
+    const length67 = Math.hypot(dx3, dy3);
+    if (length67 <= 0.000000001)
+      continue;
+    const ux3 = dx3 / length67;
+    const uy3 = dy3 / length67;
+    let distance49 = 0;
+    while (distance49 < length67) {
+      const dashEndDistance = Math.min(distance49 + dashLength, length67);
+      const dashStart = {
+        x: start.x + ux3 * distance49,
+        y: start.y + uy3 * distance49
+      };
+      const dashEnd = {
+        x: start.x + ux3 * dashEndDistance,
+        y: start.y + uy3 * dashEndDistance
+      };
+      gerber.add("move_operation", {
+        x: dashStart.x,
+        y: mapY(dashStart.y)
+      });
+      gerber.add("plot_operation", {
+        x: dashEnd.x,
+        y: mapY(dashEnd.y)
+      });
+      distance49 += dashLength + gapLength;
+    }
+  }
+  glayer.push(...gerber.build());
+}, renderFabricationDimension = ({
+  element,
+  glayer,
+  mapY,
+  renderText: renderText2
+}) => {
+  const from = element.from;
+  const to3 = element.to;
+  const dx3 = to3.x - from.x;
+  const dy3 = to3.y - from.y;
+  const length67 = Math.hypot(dx3, dy3);
+  if (length67 <= 0.000000001)
+    return;
+  const offsetDistance = element.offset_distance ?? element.offset ?? 0;
+  const defaultOffsetDirection = { x: -dy3 / length67, y: dx3 / length67 };
+  const offsetDirection = element.offset_direction ?? defaultOffsetDirection;
+  const offsetMagnitude = Math.hypot(offsetDirection.x, offsetDirection.y) || 1;
+  const offsetVector = {
+    x: offsetDirection.x / offsetMagnitude * offsetDistance,
+    y: offsetDirection.y / offsetMagnitude * offsetDistance
+  };
+  const dimStart = { x: from.x + offsetVector.x, y: from.y + offsetVector.y };
+  const dimEnd = { x: to3.x + offsetVector.x, y: to3.y + offsetVector.y };
+  const arrowSize = element.arrow_size ?? 1;
+  const ux3 = dx3 / length67;
+  const uy3 = dy3 / length67;
+  const px3 = -uy3;
+  const py3 = ux3;
+  const arrowHalfWidth = arrowSize * 0.35;
+  const lineConfig = getApertureConfigFromPcbFabricationNoteDimension(element);
+  renderOpenPath({
+    element,
+    glayer,
+    apertureConfig: lineConfig,
+    route: [from, dimStart, dimEnd, to3],
+    mapY
+  });
+  renderOpenPath({
+    element,
+    glayer,
+    apertureConfig: lineConfig,
+    route: [
+      {
+        x: dimStart.x + ux3 * arrowSize + px3 * arrowHalfWidth,
+        y: dimStart.y + uy3 * arrowSize + py3 * arrowHalfWidth
+      },
+      dimStart,
+      {
+        x: dimStart.x + ux3 * arrowSize - px3 * arrowHalfWidth,
+        y: dimStart.y + uy3 * arrowSize - py3 * arrowHalfWidth
+      }
+    ],
+    mapY
+  });
+  renderOpenPath({
+    element,
+    glayer,
+    apertureConfig: lineConfig,
+    route: [
+      {
+        x: dimEnd.x - ux3 * arrowSize + px3 * arrowHalfWidth,
+        y: dimEnd.y - uy3 * arrowSize + py3 * arrowHalfWidth
+      },
+      dimEnd,
+      {
+        x: dimEnd.x - ux3 * arrowSize - px3 * arrowHalfWidth,
+        y: dimEnd.y - uy3 * arrowSize - py3 * arrowHalfWidth
+      }
+    ],
+    mapY
+  });
+  if (element.text) {
+    renderText2({
+      ...element,
+      anchor_position: {
+        x: (dimStart.x + dimEnd.x) / 2,
+        y: (dimStart.y + dimEnd.y) / 2
+      },
+      anchor_alignment: "center",
+      ccw_rotation: element.text_ccw_rotation ?? Math.atan2(dy3, dx3) * 180 / Math.PI
+    });
+  }
+}, roundedRectCornerArcSegmentCount = 8, circleCutoutPolygonSegmentCount2 = 64, getBoardOutlinePolygon = (board) => {
+  if (board.outline && board.outline.length > 2) {
+    return [board.outline.map((point9) => [point9.x, point9.y])];
+  }
+  const bounds = getBoundFromCenteredRect4({
+    center: board.center,
+    width: board.width,
+    height: board.height
+  });
+  return [
+    [
+      [bounds.minX, bounds.minY],
+      [bounds.maxX, bounds.minY],
+      [bounds.maxX, bounds.maxY],
+      [bounds.minX, bounds.maxY]
+    ]
+  ];
+}, getBoardOutlinePolygons2 = (circuitJson) => circuitJson.filter((element) => element.type === "pcb_board").map(getBoardOutlinePolygon), getRectCutoutOutlinePoints = (cutout) => {
+  const { center: center2, width, height, rotation: rotation11, corner_radius } = cutout;
+  const w4 = width / 2;
+  const h4 = height / 2;
+  const r4 = Math.max(0, Math.min(corner_radius ?? 0, Math.abs(w4), Math.abs(h4)));
+  let transformMatrix = translate22(center2.x, center2.y);
+  if (rotation11) {
+    transformMatrix = compose22(transformMatrix, rotate22(rotation11 * Math.PI / 180));
+  }
+  if (r4 === 0) {
+    return [
+      { x: -w4, y: h4 },
+      { x: w4, y: h4 },
+      { x: w4, y: -h4 },
+      { x: -w4, y: -h4 }
+    ].map((point9) => applyToPoint25(transformMatrix, point9));
+  }
+  const points = [];
+  const corners = [
+    { center: { x: w4 - r4, y: h4 - r4 }, start: Math.PI / 2, end: 0 },
+    { center: { x: w4 - r4, y: -h4 + r4 }, start: 0, end: -Math.PI / 2 },
+    { center: { x: -w4 + r4, y: -h4 + r4 }, start: -Math.PI / 2, end: -Math.PI },
+    { center: { x: -w4 + r4, y: h4 - r4 }, start: Math.PI, end: Math.PI / 2 }
+  ];
+  for (const corner of corners) {
+    for (let i3 = 0;i3 <= roundedRectCornerArcSegmentCount; i3++) {
+      const t50 = i3 / roundedRectCornerArcSegmentCount;
+      const angle = corner.start + (corner.end - corner.start) * t50;
+      points.push({
+        x: corner.center.x + r4 * Math.cos(angle),
+        y: corner.center.y + r4 * Math.sin(angle)
+      });
+    }
+  }
+  return points.map((point9) => applyToPoint25(transformMatrix, point9));
+}, getCircleCutoutOutlinePolygon = (cutout) => {
+  const points = [];
+  for (let i3 = 0;i3 < circleCutoutPolygonSegmentCount2; i3++) {
+    const angle = i3 / circleCutoutPolygonSegmentCount2 * Math.PI * 2;
+    points.push([
+      cutout.center.x + cutout.radius * Math.cos(angle),
+      cutout.center.y + cutout.radius * Math.sin(angle)
+    ]);
+  }
+  return [points];
+}, getSolidCutoutOutlinePolygon = (cutout) => {
+  if (cutout.shape === "rect") {
+    return [
+      getRectCutoutOutlinePoints(cutout).map((point9) => [point9.x, point9.y])
+    ];
+  }
+  if (cutout.shape === "circle") {
+    return getCircleCutoutOutlinePolygon(cutout);
+  }
+  if (cutout.shape === "polygon") {
+    return [cutout.points.map((point9) => [point9.x, point9.y])];
+  }
+  return null;
+}, doesSolidCutoutOverlapBoardEdge = ({
+  cutout,
+  boardOutlinePolygons
+}) => {
+  const cutoutOutlinePolygon = getSolidCutoutOutlinePolygon(cutout);
+  if (!cutoutOutlinePolygon)
+    return false;
+  return boardOutlinePolygons.some((boardOutlinePolygon) => {
+    const overlapsBoard = import_polygon_clipping3.default.intersection(boardOutlinePolygon, cutoutOutlinePolygon).length > 0;
+    const extendsOutsideBoard = import_polygon_clipping3.default.difference(cutoutOutlinePolygon, boardOutlinePolygon).length > 0;
+    return overlapsBoard && extendsOutsideBoard;
+  });
+}, isCutoutFullyInternal = ({
+  cutout,
+  boardOutlinePolygons
+}) => {
+  const cutoutOutlinePolygon = getSolidCutoutOutlinePolygon(cutout);
+  if (!cutoutOutlinePolygon)
+    return false;
+  return boardOutlinePolygons.some((boardOutlinePolygon) => import_polygon_clipping3.default.intersection(boardOutlinePolygon, cutoutOutlinePolygon).length > 0 && import_polygon_clipping3.default.difference(cutoutOutlinePolygon, boardOutlinePolygon).length === 0);
+}, emitCutoutEdgeCuts = ({
+  cutout,
+  builder,
+  mfy,
+  drawCw
+}) => {
+  if (cutout.shape === "circle") {
+    emitCircle({ cutout, builder, mfy, drawCw });
+  } else if (cutout.shape === "rect") {
+    emitRect({ cutout, builder, mfy, drawCw });
+  } else if (cutout.shape === "polygon") {
+    emitPolygon({ cutout, builder, mfy, drawCw });
+  }
+}, emitCircle = ({
+  cutout,
+  builder,
+  mfy,
+  drawCw
+}) => {
+  const { center: center2, radius } = cutout;
+  const p12 = { x: center2.x + radius, y: center2.y };
+  const p23 = { x: center2.x - radius, y: center2.y };
+  const isYFlipped = mfy(1) < 0;
+  let isClockwise = drawCw;
+  if (isYFlipped) {
+    isClockwise = !isClockwise;
+  }
+  let arcMode = "set_movement_mode_to_counterclockwise_circular";
+  if (isClockwise) {
+    arcMode = "set_movement_mode_to_clockwise_circular";
+  }
+  builder.add("move_operation", { x: p12.x, y: mfy(p12.y) }).add(arcMode, {}).add("plot_operation", { x: p23.x, y: mfy(p23.y), i: -radius, j: 0 }).add("plot_operation", { x: p12.x, y: mfy(p12.y), i: radius, j: 0 }).add("set_movement_mode_to_linear", {});
+}, emitRect = ({
+  cutout,
+  builder,
+  mfy,
+  drawCw
+}) => {
+  const { center: center2, width, height, rotation: rotation11, corner_radius } = cutout;
+  const w4 = width / 2;
+  const h4 = height / 2;
+  let cr3 = 0;
+  if (corner_radius !== undefined) {
+    cr3 = corner_radius;
+  }
+  const r4 = Math.max(0, Math.min(cr3, Math.abs(w4), Math.abs(h4)));
+  let rotationTransform = identity22();
+  if (rotation11) {
+    rotationTransform = rotate32(rotation11 * Math.PI / 180);
+  }
+  const transformMatrix = compose32(translate32(center2.x, center2.y), rotationTransform);
+  if (r4 > 0) {
+    emitRoundedRect({ w: w4, h: h4, r: r4, transformMatrix, builder, mfy, drawCw });
+  } else {
+    emitSharpRect({ w: w4, h: h4, transformMatrix, builder, mfy, drawCw });
+  }
+}, emitSharpRect = ({
+  w: w4,
+  h: h4,
+  transformMatrix,
+  builder,
+  mfy,
+  drawCw
+}) => {
+  const cwPoints = [
+    { x: -w4, y: h4 },
+    { x: w4, y: h4 },
+    { x: w4, y: -h4 },
+    { x: -w4, y: -h4 }
+  ];
+  const isYFlipped = mfy(1) < 0;
+  let shouldReverse = !drawCw;
+  if (isYFlipped) {
+    shouldReverse = !shouldReverse;
+  }
+  let pts = cwPoints;
+  if (shouldReverse) {
+    pts = [...cwPoints].reverse();
+  }
+  const tpts = pts.map((p3) => applyToPoint32(transformMatrix, p3));
+  builder.add("move_operation", { x: tpts[0].x, y: mfy(tpts[0].y) });
+  for (let i3 = 1;i3 < tpts.length; i3++) {
+    builder.add("plot_operation", { x: tpts[i3].x, y: mfy(tpts[i3].y) });
+  }
+  builder.add("plot_operation", { x: tpts[0].x, y: mfy(tpts[0].y) });
+}, emitRoundedRect = ({
+  w: w4,
+  h: h4,
+  r: r4,
+  transformMatrix,
+  builder,
+  mfy,
+  drawCw
+}) => {
+  const isYFlipped = mfy(1) < 0;
+  let isClockwise = drawCw;
+  if (isYFlipped) {
+    isClockwise = !isClockwise;
+  }
+  let arcMode = "set_movement_mode_to_counterclockwise_circular";
+  if (isClockwise) {
+    arcMode = "set_movement_mode_to_clockwise_circular";
+  }
+  let currentPoint;
+  const addLine = (pt3) => {
+    const tpt = applyToPoint32(transformMatrix, pt3);
+    builder.add("plot_operation", { x: tpt.x, y: mfy(tpt.y) });
+    currentPoint = tpt;
+  };
+  const addArc = (endPt, centerPt) => {
+    const tEnd = applyToPoint32(transformMatrix, endPt);
+    const tCenter = applyToPoint32(transformMatrix, centerPt);
+    builder.add(arcMode, {}).add("plot_operation", {
+      x: tEnd.x,
+      y: mfy(tEnd.y),
+      i: tCenter.x - currentPoint.x,
+      j: mfy(tCenter.y) - mfy(currentPoint.y)
+    }).add("set_movement_mode_to_linear", {});
+    currentPoint = tEnd;
+  };
+  if (isClockwise) {
+    const cwSegments = [
+      {
+        lineTo: { x: w4 - r4, y: h4 },
+        arcEnd: { x: w4, y: h4 - r4 },
+        arcCenter: { x: w4 - r4, y: h4 - r4 }
+      },
+      {
+        lineTo: { x: w4, y: -h4 + r4 },
+        arcEnd: { x: w4 - r4, y: -h4 },
+        arcCenter: { x: w4 - r4, y: -h4 + r4 }
+      },
+      {
+        lineTo: { x: -w4 + r4, y: -h4 },
+        arcEnd: { x: -w4, y: -h4 + r4 },
+        arcCenter: { x: -w4 + r4, y: -h4 + r4 }
+      },
+      {
+        lineTo: { x: -w4, y: h4 - r4 },
+        arcEnd: { x: -w4 + r4, y: h4 },
+        arcCenter: { x: -w4 + r4, y: h4 - r4 }
+      }
+    ];
+    const startPt = { x: -w4 + r4, y: h4 };
+    const tStart = applyToPoint32(transformMatrix, startPt);
+    builder.add("move_operation", { x: tStart.x, y: mfy(tStart.y) });
+    currentPoint = tStart;
+    for (const seg of cwSegments) {
+      addLine(seg.lineTo);
+      addArc(seg.arcEnd, seg.arcCenter);
+    }
+  } else {
+    const startPt = { x: w4 - r4, y: h4 };
+    const tStart = applyToPoint32(transformMatrix, startPt);
+    builder.add("move_operation", { x: tStart.x, y: mfy(tStart.y) });
+    currentPoint = tStart;
+    addLine({ x: -w4 + r4, y: h4 });
+    addArc({ x: -w4, y: h4 - r4 }, { x: -w4 + r4, y: h4 - r4 });
+    addLine({ x: -w4, y: -h4 + r4 });
+    addArc({ x: -w4 + r4, y: -h4 }, { x: -w4 + r4, y: -h4 + r4 });
+    addLine({ x: w4 - r4, y: -h4 });
+    addArc({ x: w4, y: -h4 + r4 }, { x: w4 - r4, y: -h4 + r4 });
+    addLine({ x: w4, y: h4 - r4 });
+    addArc({ x: w4 - r4, y: h4 }, { x: w4 - r4, y: h4 - r4 });
+  }
+}, emitPolygon = ({
+  cutout,
+  builder,
+  mfy,
+  drawCw
+}) => {
+  const points = cutout.points;
+  if (points.length === 0)
+    return;
+  const isYFlipped = mfy(1) < 0;
+  let shouldReverse = !drawCw;
+  if (isYFlipped) {
+    shouldReverse = !shouldReverse;
+  }
+  let ordered = points;
+  if (shouldReverse) {
+    ordered = [...points].reverse();
+  }
+  builder.add("move_operation", { x: ordered[0].x, y: mfy(ordered[0].y) });
+  for (let i3 = 1;i3 < ordered.length; i3++) {
+    builder.add("plot_operation", { x: ordered[i3].x, y: mfy(ordered[i3].y) });
+  }
+  builder.add("plot_operation", { x: ordered[0].x, y: mfy(ordered[0].y) });
+}, closeRing = (ring) => {
+  const first = ring[0];
+  const last = ring[ring.length - 1];
+  if (!first || !last)
+    return ring;
+  if (first[0] === last[0] && first[1] === last[1])
+    return ring;
+  return [...ring, first];
+}, emitEdgeCutRing = (gerberBuild, ring, mfy) => {
+  const closedRing = closeRing(ring);
+  const firstPoint = closedRing[0];
+  if (!firstPoint || closedRing.length < 4)
+    return;
+  gerberBuild.add("move_operation", {
+    x: firstPoint[0],
+    y: mfy(firstPoint[1])
+  });
+  for (let i3 = 1;i3 < closedRing.length; i3++) {
+    const point9 = closedRing[i3];
+    gerberBuild.add("plot_operation", {
+      x: point9[0],
+      y: mfy(point9[1])
+    });
+  }
+}, getLayerCount2 = (circuitJson) => {
+  const board = circuitJson.find((element) => element.type === "pcb_board");
+  const numLayers = board?.num_layers ?? 2;
+  return Math.max(2, Math.min(8, numLayers));
+}, getInnerLayerRefs = (layerCount) => Array.from({ length: layerCount - 2 }, (_4, i3) => `inner${i3 + 1}`), getGerberInnerLayerName = (layerRef) => {
+  if (!layerRef.startsWith("inner")) {
+    throw new Error(`Expected inner layer, got ${layerRef}`);
+  }
+  return `In${layerRef.replace("inner", "")}_Cu`;
+}, convertSoupToGerberCommands = (circuitJson, opts = {}) => {
   opts.flip_y_axis ??= false;
-  const hasPanel = soup.some((e4) => e4.type === "pcb_panel");
+  const hasPanel = circuitJson.some((e4) => e4.type === "pcb_panel");
+  const hasBoard = circuitJson.some((e4) => e4.type === "pcb_board");
+  const layerCount = getLayerCount2(circuitJson);
+  const innerLayerRefs = getInnerLayerRefs(layerCount);
+  const copperLayerRefs = ["top", ...innerLayerRefs, "bottom"];
+  const fabricationLayerRefs = getFabricationLayerRefs(circuitJson);
   const glayers = {
     F_Cu: getCommandHeaders({
       layer: "top",
-      layer_type: "copper"
+      layer_type: "copper",
+      total_layer_count: layerCount
     }),
     F_SilkScreen: getCommandHeaders({
       layer: "top",
@@ -54314,7 +57366,8 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
     }),
     B_Cu: getCommandHeaders({
       layer: "bottom",
-      layer_type: "copper"
+      layer_type: "copper",
+      total_layer_count: layerCount
     }),
     B_SilkScreen: getCommandHeaders({
       layer: "bottom",
@@ -54332,20 +57385,36 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
       layer: "edgecut"
     })
   };
+  for (const innerLayerRef of innerLayerRefs) {
+    glayers[getGerberInnerLayerName(innerLayerRef)] = getCommandHeaders({
+      layer: innerLayerRef,
+      layer_type: "copper",
+      total_layer_count: layerCount
+    });
+  }
+  for (const layerRef of fabricationLayerRefs) {
+    glayers[getGerberLayerName(layerRef, "fabrication")] = getCommandHeaders({
+      layer: layerRef,
+      layer_type: "fabrication"
+    });
+  }
+  const copperGerberLayerNames = copperLayerRefs.map((layerRef) => getGerberLayerName(layerRef, "copper"));
+  const fabricationGerberLayerNames = fabricationLayerRefs.map((layerRef) => getGerberLayerName(layerRef, "fabrication"));
+  const outerGerberLayerNames = outerLayerRefs.flatMap((layerRef) => [
+    getGerberLayerName(layerRef, "soldermask"),
+    getGerberLayerName(layerRef, "paste"),
+    getGerberLayerName(layerRef, "silkscreen")
+  ]);
   for (const glayer_name of [
     "F_Cu",
-    "B_Cu",
-    "F_Mask",
-    "B_Mask",
-    "F_Paste",
-    "B_Paste",
-    "F_SilkScreen",
-    "B_SilkScreen"
+    ...copperGerberLayerNames.filter((name) => name !== "F_Cu"),
+    ...fabricationGerberLayerNames,
+    ...outerGerberLayerNames
   ]) {
     const glayer = glayers[glayer_name];
     defineCommonMacros(glayer);
     defineAperturesForLayer({
-      soup,
+      circuitJson,
       glayer,
       glayer_name
     });
@@ -54355,14 +57424,92 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
     standard_template_code: "C",
     diameter: 0.05
   }).build());
-  const mfy = (y4) => opts.flip_y_axis ? -y4 : y4;
-  const rotationLookup = /* @__PURE__ */ new Map;
-  for (const element of soup) {
-    if (element.type === "pcb_plated_hole" && "x" in element && typeof element.x === "number" && "y" in element && typeof element.y === "number") {
-      const rotation11 = "ccw_rotation" in element && typeof element.ccw_rotation === "number" ? element.ccw_rotation : 0;
-      rotationLookup.set(`${element.x}:${element.y}`, rotation11);
+  const mfy = (y4) => {
+    if (opts.flip_y_axis) {
+      return -y4;
     }
-  }
+    return y4;
+  };
+  const boardOutlinePolygons = getBoardOutlinePolygons2(circuitJson);
+  const solidCutoutPolygons = circuitJson.filter((element) => element.type === "pcb_cutout").filter((cutout) => doesSolidCutoutOverlapBoardEdge({ cutout, boardOutlinePolygons })).map(getSolidCutoutOutlinePolygon).filter((polygon2) => polygon2 !== null);
+  const renderPillFlash = ({
+    glayer,
+    x: x4,
+    y: y4,
+    width,
+    height,
+    rotationDegrees = 0
+  }) => {
+    const circleApertureConfig = {
+      standard_template_code: "C",
+      diameter: Math.min(width, height)
+    };
+    const apertureNumber = findApertureNumber(glayer, circleApertureConfig);
+    const gb3 = gerberBuilder().add("select_aperture", {
+      aperture_number: apertureNumber
+    });
+    const offset = Math.abs(width - height) / 2;
+    const rotationRadians = rotationDegrees * Math.PI / 180;
+    const cosTheta = Math.cos(rotationRadians);
+    const sinTheta = Math.sin(rotationRadians);
+    const rotateAndTranslate = (dx3, dy3) => ({
+      x: x4 + dx3 * cosTheta - dy3 * sinTheta,
+      y: y4 + dx3 * sinTheta + dy3 * cosTheta
+    });
+    if (offset <= 0.000000001) {
+      gb3.add("flash_operation", { x: x4, y: mfy(y4) });
+      glayer.push(...gb3.build());
+      return;
+    }
+    const isHorizontal2 = width >= height;
+    const startRelative = isHorizontal2 ? { x: -offset, y: 0 } : { x: 0, y: -offset };
+    const endRelative = isHorizontal2 ? { x: offset, y: 0 } : { x: 0, y: offset };
+    const startPoint = rotateAndTranslate(startRelative.x, startRelative.y);
+    const endPoint = rotateAndTranslate(endRelative.x, endRelative.y);
+    gb3.add("flash_operation", {
+      x: startPoint.x,
+      y: mfy(startPoint.y)
+    }).add("move_operation", {
+      x: startPoint.x,
+      y: mfy(startPoint.y)
+    }).add("plot_operation", {
+      x: endPoint.x,
+      y: mfy(endPoint.y)
+    }).add("flash_operation", {
+      x: endPoint.x,
+      y: mfy(endPoint.y)
+    });
+    glayer.push(...gb3.build());
+  };
+  const getRegionApertureNumber = (glayer) => findApertureNumber(glayer, REGION_APERTURE_CONFIG);
+  const addClosedRegionFromPoints = ({
+    target,
+    apertureSource,
+    points
+  }) => {
+    if (points.length === 0)
+      return;
+    const regionApertureNumber = getRegionApertureNumber(apertureSource);
+    const regionBuilder = gerberBuilder().add("select_aperture", {
+      aperture_number: regionApertureNumber
+    }).add("start_region_statement", {});
+    regionBuilder.add("move_operation", {
+      x: points[0].x,
+      y: mfy(points[0].y)
+    });
+    for (let i3 = 1;i3 < points.length; i3++) {
+      regionBuilder.add("plot_operation", {
+        x: points[i3].x,
+        y: mfy(points[i3].y)
+      });
+    }
+    regionBuilder.add("plot_operation", {
+      x: points[0].x,
+      y: mfy(points[0].y)
+    });
+    regionBuilder.add("end_region_statement", {});
+    target.push(...regionBuilder.build());
+  };
   const renderVectorText = (element, layer, layerType, getApertureConfig) => {
     if (element.layer !== layer)
       return;
@@ -54439,16 +57586,16 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
     const transforms = [];
     const shouldMirror = element.is_mirrored !== undefined ? element.is_mirrored : element.layer === "bottom";
     if (shouldMirror) {
-      transforms.push(translate9(cx3, cy3), { a: -1, b: 0, c: 0, d: 1, e: 0, f: 0 }, translate9(-cx3, -cy3));
+      transforms.push(translate42(cx3, cy3), { a: -1, b: 0, c: 0, d: 1, e: 0, f: 0 }, translate42(-cx3, -cy3));
       rotation11 = -rotation11;
     }
     if (rotation11) {
       const rad = rotation11 * Math.PI / 180;
-      transforms.push(translate9(cx3, cy3), rotate12(rad), translate9(-cx3, -cy3));
+      transforms.push(translate42(cx3, cy3), rotate42(rad), translate42(-cx3, -cy3));
     }
-    const transformMatrix = transforms.length > 0 ? compose9(...transforms) : undefined;
-    const applyTransform = (point9) => transformMatrix ? applyToPoint26(transformMatrix, point9) : point9;
-    if (layerType === "copper" && element.is_knockout) {
+    const transformMatrix = transforms.length > 0 ? compose42(...transforms) : undefined;
+    const applyTransform = (point9) => transformMatrix ? applyToPoint42(transformMatrix, point9) : point9;
+    if (element.is_knockout) {
       const padding = element.knockout_padding ?? {
         left: 0.2,
         right: 0.2,
@@ -54490,7 +57637,7 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
       }).add("end_region_statement", {}).build());
       glayer.push(...gerberBuilder().add("set_layer_polarity", { polarity: "C" }).build());
     }
-    for (const char of element.text.toUpperCase()) {
+    for (const char of element.text) {
       if (char === " ") {
         anchoredX += spaceWidth + letterSpacing;
         continue;
@@ -54509,7 +57656,7 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
       anchoredX += fontSize + letterSpacing;
     }
     glayer.push(...gerber.build());
-    if (layerType === "copper" && element.is_knockout) {
+    if (element.is_knockout) {
       glayer.push(...gerberBuilder().add("set_layer_polarity", { polarity: "D" }).build());
     }
   };
@@ -54588,8 +57735,8 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
     });
     return { vertices: new_vertices };
   };
-  for (const layer of ["top", "bottom"]) {
-    for (const element of soup) {
+  for (const layer of copperLayerRefs) {
+    for (const element of circuitJson) {
       if (element.type === "pcb_copper_pour" && layer === element.layer) {
         const copper_glayer = glayers[getGerberLayerName(layer, "copper")];
         const all_pour_commands = [];
@@ -54598,14 +57745,17 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
           if (!brep_shape)
             continue;
           const { outer_ring, inner_rings } = brep_shape;
-          const outer_builder = gerberBuilder().add("select_aperture", { aperture_number: 10 }).add("start_region_statement", {});
+          const regionApertureNumber = getRegionApertureNumber(copper_glayer);
+          const outer_builder = gerberBuilder().add("select_aperture", { aperture_number: regionApertureNumber }).add("start_region_statement", {});
           drawRingToBuilder(outer_builder, reverseRing(outer_ring));
           outer_builder.add("end_region_statement", {});
           all_pour_commands.push(...outer_builder.build());
           if (inner_rings && inner_rings.length > 0) {
             all_pour_commands.push(...gerberBuilder().add("set_layer_polarity", { polarity: "C" }).build());
             for (const inner_ring of inner_rings) {
-              const inner_builder = gerberBuilder().add("select_aperture", { aperture_number: 10 }).add("start_region_statement", {});
+              const inner_builder = gerberBuilder().add("select_aperture", {
+                aperture_number: regionApertureNumber
+              }).add("start_region_statement", {});
               drawRingToBuilder(inner_builder, inner_ring);
               inner_builder.add("end_region_statement", {});
               all_pour_commands.push(...inner_builder.build());
@@ -54622,14 +57772,15 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
             { x: w4, y: -h4 },
             { x: -w4, y: -h4 }
           ];
-          let transformMatrix = identity8();
+          let transformMatrix = identity32();
           if (rotation11) {
             const angle_rad = rotation11 * Math.PI / 180;
-            transformMatrix = rotate12(angle_rad);
+            transformMatrix = rotate42(angle_rad);
           }
-          transformMatrix = compose9(translate9(center2.x, center2.y), transformMatrix);
-          const transformedPoints = points.map((p3) => applyToPoint26(transformMatrix, p3));
-          const rect_builder = gerberBuilder().add("select_aperture", { aperture_number: 10 }).add("start_region_statement", {});
+          transformMatrix = compose42(translate42(center2.x, center2.y), transformMatrix);
+          const transformedPoints = points.map((p3) => applyToPoint42(transformMatrix, p3));
+          const regionApertureNumber = getRegionApertureNumber(copper_glayer);
+          const rect_builder = gerberBuilder().add("select_aperture", { aperture_number: regionApertureNumber }).add("start_region_statement", {});
           rect_builder.add("move_operation", {
             x: transformedPoints[0].x,
             y: mfy(transformedPoints[0].y)
@@ -54648,25 +57799,11 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
           all_pour_commands.push(...rect_builder.build());
         } else if (element.shape === "polygon") {
           const { points } = element;
-          if (points.length > 0) {
-            const poly_builder = gerberBuilder().add("select_aperture", { aperture_number: 10 }).add("start_region_statement", {});
-            poly_builder.add("move_operation", {
-              x: points[0].x,
-              y: mfy(points[0].y)
-            });
-            for (let i3 = 1;i3 < points.length; i3++) {
-              poly_builder.add("plot_operation", {
-                x: points[i3].x,
-                y: mfy(points[i3].y)
-              });
-            }
-            poly_builder.add("plot_operation", {
-              x: points[0].x,
-              y: mfy(points[0].y)
-            });
-            poly_builder.add("end_region_statement", {});
-            all_pour_commands.push(...poly_builder.build());
-          }
+          addClosedRegionFromPoints({
+            target: all_pour_commands,
+            apertureSource: copper_glayer,
+            points
+          });
         }
         copper_glayer.push(...all_pour_commands);
         if (element.covered_with_solder_mask === false) {
@@ -54676,23 +57813,66 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
       }
     }
   }
-  for (const layer of ["top", "bottom", "edgecut"]) {
-    for (const element of soup) {
+  for (const layer of [...copperLayerRefs, "edgecut"]) {
+    for (const element of circuitJson) {
       if (element.type === "pcb_trace") {
-        const { route } = element;
+        if (layer === "edgecut")
+          continue;
+        const route = element.route;
         for (const [a3, b3] of pairs3(route)) {
           if (a3.route_type === "wire") {
             if (a3.layer === layer) {
+              let bPoint = null;
+              if (b3.route_type === "wire" || b3.route_type === "via") {
+                bPoint = b3;
+              } else if (b3.route_type === "through_pad") {
+                if (b3.start_layer === layer) {
+                  bPoint = b3.start;
+                } else if (b3.end_layer === layer) {
+                  bPoint = b3.end;
+                }
+              }
+              if (!bPoint)
+                continue;
               const glayer = glayers[getGerberLayerName(layer, "copper")];
               glayer.push(...gerberBuilder().add("select_aperture", {
                 aperture_number: findApertureNumber(glayer, {
                   trace_width: a3.width
                 })
+              }).add("move_operation", { x: a3.x, y: mfy(a3.y) }).add("plot_operation", { x: bPoint.x, y: mfy(bPoint.y) }).build());
+            }
+          } else if (a3.route_type === "via" && b3.route_type === "wire") {
+            if (b3.layer === layer) {
+              const glayer = glayers[getGerberLayerName(layer, "copper")];
+              glayer.push(...gerberBuilder().add("select_aperture", {
+                aperture_number: findApertureNumber(glayer, {
+                  trace_width: b3.width
+                })
               }).add("move_operation", { x: a3.x, y: mfy(a3.y) }).add("plot_operation", { x: b3.x, y: mfy(b3.y) }).build());
             }
+          } else if (a3.route_type === "through_pad" && b3.route_type === "wire") {
+            if (b3.layer === layer) {
+              const aPoint = a3.end_layer === layer ? a3.end : a3.start_layer === layer ? a3.start : null;
+              if (!aPoint)
+                continue;
+              const glayer = glayers[getGerberLayerName(layer, "copper")];
+              glayer.push(...gerberBuilder().add("select_aperture", {
+                aperture_number: findApertureNumber(glayer, {
+                  trace_width: b3.width
+                })
+              }).add("move_operation", { x: aPoint.x, y: mfy(aPoint.y) }).add("plot_operation", { x: b3.x, y: mfy(b3.y) }).build());
+            }
+          }
+        }
+        for (const point9 of route) {
+          if (point9.route_type === "via" && typeof point9.outer_diameter === "number" && (point9.from_layer === layer || point9.to_layer === layer)) {
+            const glayer = glayers[getGerberLayerName(layer, "copper")];
+            glayer.push(...gerberBuilder().add("select_aperture", {
+              aperture_number: findApertureNumber(glayer, getApertureConfigFromOuterDiameter(point9))
+            }).add("flash_operation", { x: point9.x, y: mfy(point9.y) }).build());
           }
         }
-      } else if (element.type === "pcb_silkscreen_path") {
+      } else if (element.type === "pcb_silkscreen_path" && isOuterLayerRef(layer)) {
         if (element.layer === layer) {
           const glayer = glayers[getGerberLayerName(layer, "silkscreen")];
           const apertureConfig = getApertureConfigFromPcbSilkscreenPath(element);
@@ -54713,74 +57893,205 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
           }
           glayer.push(...gerber.build());
         }
-      } else if (element.type === "pcb_silkscreen_text" && layer !== "edgecut") {
+      } else if (isSilkscreenShape(element) && isOuterLayerRef(layer)) {
+        if (element.layer === layer) {
+          const stroke = getSilkscreenShapeStroke(element);
+          if (stroke) {
+            const glayer = glayers[getGerberLayerName(layer, "silkscreen")];
+            const isFilled = element.is_filled === true;
+            const isStroked = element.has_stroke !== false;
+            if (isFilled) {
+              addClosedRegionFromPoints({
+                target: glayer,
+                apertureSource: glayer,
+                points: stroke.route
+              });
+            }
+            if (isStroked) {
+              renderOpenPath({
+                element: {
+                  type: element.type,
+                  stroke_width: stroke.strokeWidth,
+                  is_stroke_dashed: element.is_stroke_dashed
+                },
+                glayer,
+                apertureConfig: {
+                  standard_template_code: "C",
+                  diameter: stroke.strokeWidth
+                },
+                route: stroke.route,
+                mapY: mfy
+              });
+            }
+          }
+        }
+      } else if (element.type === "pcb_silkscreen_graphic" && isOuterLayerRef(layer)) {
+        const graphic = element;
+        if (graphic.layer === layer && graphic.brep_shape) {
+          const glayer = glayers[getGerberLayerName(layer, "silkscreen")];
+          const { outer_ring, inner_rings } = graphic.brep_shape;
+          const regionApertureNumber = getRegionApertureNumber(glayer);
+          const outerBuilder = gerberBuilder().add("select_aperture", { aperture_number: regionApertureNumber }).add("start_region_statement", {});
+          drawRingToBuilder(outerBuilder, reverseRing(outer_ring));
+          outerBuilder.add("end_region_statement", {});
+          glayer.push(...outerBuilder.build());
+          if (inner_rings && inner_rings.length > 0) {
+            glayer.push(...gerberBuilder().add("set_layer_polarity", { polarity: "C" }).build());
+            for (const inner_ring of inner_rings) {
+              const innerBuilder = gerberBuilder().add("select_aperture", {
+                aperture_number: regionApertureNumber
+              }).add("start_region_statement", {});
+              drawRingToBuilder(innerBuilder, inner_ring);
+              innerBuilder.add("end_region_statement", {});
+              glayer.push(...innerBuilder.build());
+            }
+            glayer.push(...gerberBuilder().add("set_layer_polarity", { polarity: "D" }).build());
+          }
+        }
+      } else if (element.type === "pcb_silkscreen_text" && isOuterLayerRef(layer)) {
         renderVectorText(element, layer, "silkscreen", getApertureConfigFromPcbSilkscreenText);
+      } else if (element.type === "pcb_fabrication_note_path" && isOuterLayerRef(layer)) {
+        if (element.layer === layer) {
+          renderOpenPath({
+            element,
+            glayer: glayers[getGerberLayerName(layer, "fabrication")],
+            apertureConfig: getApertureConfigFromPcbFabricationNotePath(element),
+            route: element.route,
+            mapY: mfy
+          });
+        }
+      } else if (element.type === "pcb_fabrication_note_rect" && isOuterLayerRef(layer)) {
+        if (element.layer === layer) {
+          const glayer = glayers[getGerberLayerName(layer, "fabrication")];
+          const points = getFabRectPoints(element);
+          if (element.is_filled === true) {
+            addClosedRegionFromPoints({
+              target: glayer,
+              apertureSource: glayer,
+              points
+            });
+          }
+          if (element.has_stroke !== false) {
+            renderOpenPath({
+              element,
+              glayer,
+              apertureConfig: getApertureConfigFromPcbFabricationNotePath(element),
+              route: [...points, points[0]],
+              mapY: mfy
+            });
+          }
+        }
+      } else if (element.type === "pcb_fabrication_note_dimension" && isOuterLayerRef(layer)) {
+        if (element.layer === layer) {
+          renderFabricationDimension({
+            element,
+            glayer: glayers[getGerberLayerName(layer, "fabrication")],
+            mapY: mfy,
+            renderText: (textElement) => renderVectorText(textElement, layer, "fabrication", getApertureConfigFromPcbFabricationNoteText)
+          });
+        }
+      } else if (element.type === "pcb_fabrication_note_text" && isOuterLayerRef(layer)) {
+        renderVectorText(element, layer, "fabrication", getApertureConfigFromPcbFabricationNoteText);
       } else if (element.type === "pcb_copper_text" && layer !== "edgecut") {
         renderVectorText(element, layer, "copper", getApertureConfigFromPcbCopperText);
       } else if (element.type === "pcb_smtpad" && element.shape !== "polygon") {
-        if (element.layer === layer) {
-          for (const glayer of [
-            glayers[getGerberLayerName(layer, "copper")],
-            glayers[getGerberLayerName(layer, "soldermask")]
+        if (element.layer === layer && isOuterLayerRef(layer)) {
+          if (element.shape === "pill" || element.shape === "rotated_pill") {
+            const soldermaskMargin = typeof element.soldermask_margin === "number" ? element.soldermask_margin : 0;
+            const rotation23 = element.shape === "rotated_pill" && typeof element.ccw_rotation === "number" ? element.ccw_rotation : 0;
+            renderPillFlash({
+              glayer: glayers[getGerberLayerName(layer, "copper")],
+              x: element.x,
+              y: element.y,
+              width: element.width,
+              height: element.height,
+              rotationDegrees: rotation23
+            });
+            renderPillFlash({
+              glayer: glayers[getGerberLayerName(layer, "soldermask")],
+              x: element.x,
+              y: element.y,
+              width: element.width + soldermaskMargin * 2,
+              height: element.height + soldermaskMargin * 2,
+              rotationDegrees: rotation23
+            });
+            continue;
+          }
+          const rotation11 = element.shape === "rotated_rect" && typeof element.ccw_rotation === "number" ? element.ccw_rotation : 0;
+          for (const { glayer, apertureConfig } of [
+            {
+              glayer: glayers[getGerberLayerName(layer, "copper")],
+              apertureConfig: getApertureConfigFromPcbSmtpad(element)
+            },
+            {
+              glayer: glayers[getGerberLayerName(layer, "soldermask")],
+              apertureConfig: getApertureConfigFromPcbSmtpadSoldermask(element)
+            }
           ]) {
-            const apertureConfig = getApertureConfigFromPcbSmtpad(element);
             const apertureNumber = findApertureNumber(glayer, apertureConfig);
             const gb3 = gerberBuilder().add("select_aperture", {
               aperture_number: apertureNumber
             });
-            if (element.shape === "rotated_rect" && element.ccw_rotation) {
+            if (rotation11) {
               gb3.add("load_rotation", {
-                rotation_degrees: element.ccw_rotation
+                rotation_degrees: rotation11
               });
             }
             gb3.add("flash_operation", { x: element.x, y: mfy(element.y) });
-            if (element.shape === "rotated_rect" && element.ccw_rotation) {
+            if (rotation11) {
               gb3.add("load_rotation", { rotation_degrees: 0 });
             }
             glayer.push(...gb3.build());
           }
         }
       } else if (element.type === "pcb_smtpad" && element.shape === "polygon") {
-        if (element.layer === layer) {
+        if (element.layer === layer && isOuterLayerRef(layer)) {
           const layers_to_add_to = [
             glayers[getGerberLayerName(layer, "copper")]
           ];
-          if (!("is_covered_with_solder_mask" in element) || element.is_covered_with_solder_mask !== false) {
+          if (element.is_covered_with_solder_mask !== true) {
             layers_to_add_to.push(glayers[getGerberLayerName(layer, "soldermask")]);
           }
           for (const glayer of layers_to_add_to) {
-            const pad_builder = gerberBuilder().add("select_aperture", { aperture_number: 10 }).add("start_region_statement", {});
             const { points } = element;
-            if (points && points.length > 0) {
-              pad_builder.add("move_operation", {
-                x: points[0].x,
-                y: mfy(points[0].y)
-              });
-              for (let i3 = 1;i3 < points.length; i3++) {
-                pad_builder.add("plot_operation", {
-                  x: points[i3].x,
-                  y: mfy(points[i3].y)
-                });
-              }
-              pad_builder.add("plot_operation", {
-                x: points[0].x,
-                y: mfy(points[0].y)
-              });
-            }
-            pad_builder.add("end_region_statement", {});
-            glayer.push(...pad_builder.build());
+            if (!points)
+              continue;
+            addClosedRegionFromPoints({
+              target: glayer,
+              apertureSource: glayer,
+              points
+            });
           }
         }
       } else if (element.type === "pcb_solder_paste") {
-        if (element.layer === layer) {
+        if (element.layer === layer && isOuterLayerRef(layer)) {
           const glayer = glayers[getGerberLayerName(layer, "paste")];
-          const aperture_number = findApertureNumber(glayer, getApertureConfigFromPcbSolderPaste(element));
-          const rotation11 = "ccw_rotation" in element && typeof element.ccw_rotation === "number" ? element.ccw_rotation : rotationLookup.get(`${element.x}:${element.y}`) ?? 0;
+          let rotation11 = 0;
+          if ("ccw_rotation" in element && typeof element.ccw_rotation === "number") {
+            rotation11 = element.ccw_rotation;
+          } else {
+            const platedHole = circuitJson.find((candidate) => candidate.type === "pcb_plated_hole" && candidate.x === element.x && candidate.y === element.y && ("ccw_rotation" in candidate) && typeof candidate.ccw_rotation === "number");
+            if (platedHole) {
+              rotation11 = platedHole.ccw_rotation;
+            }
+          }
+          let apertureConfig = getApertureConfigFromPcbSolderPaste(element);
+          if (element.shape === "pill" && (rotation11 === 90 || rotation11 === 270)) {
+            apertureConfig = getApertureConfigFromPcbSolderPaste({
+              ...element,
+              width: element.height,
+              height: element.width
+            });
+            rotation11 = 0;
+          }
+          const aperture_number = findApertureNumber(glayer, apertureConfig);
           const gb3 = gerberBuilder().add("select_aperture", {
             aperture_number
           });
           if (rotation11) {
-            gb3.add("load_rotation", { rotation_degrees: rotation11 });
+            gb3.add("load_rotation", {
+              rotation_degrees: rotation11
+            });
           }
           gb3.add("flash_operation", { x: element.x, y: mfy(element.y) });
           if (rotation11) {
@@ -54790,10 +58101,33 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
         }
       } else if (element.type === "pcb_plated_hole") {
         if (element.layers.includes(layer)) {
-          for (const glayer of [
-            glayers[getGerberLayerName(layer, "copper")],
-            glayers[getGerberLayerName(layer, "soldermask")]
-          ]) {
+          const layersToAddTo = [
+            glayers[getGerberLayerName(layer, "copper")]
+          ];
+          if (isOuterLayerRef(layer) && element.is_covered_with_solder_mask !== true) {
+            layersToAddTo.push(glayers[getGerberLayerName(layer, "soldermask")]);
+          }
+          for (const glayer of layersToAddTo) {
+            if (element.shape === "hole_with_polygon_pad") {
+              const { pad_outline } = element;
+              if (!pad_outline?.length)
+                continue;
+              const soldermaskGlayer2 = glayers[getGerberLayerName(layer, "soldermask")];
+              let points = pad_outline;
+              if (glayer === soldermaskGlayer2 && "soldermask_margin" in element && typeof element.soldermask_margin === "number") {
+                points = offsetPolygonOutline(pad_outline, element.soldermask_margin);
+              }
+              const translatedPoints = points.map((point9) => ({
+                x: point9.x + element.x,
+                y: point9.y + element.y
+              }));
+              addClosedRegionFromPoints({
+                target: glayer,
+                apertureSource: glayer,
+                points: translatedPoints
+              });
+              continue;
+            }
             const holeW = "hole_width" in element && typeof element.hole_width === "number" ? element.hole_width : 0;
             const holeH = "hole_height" in element && typeof element.hole_height === "number" ? element.hole_height : 0;
             const padWidthCandidates = [holeW];
@@ -54812,10 +58146,17 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
               padHeightCandidates.push(element.rect_pad_height);
             }
             const padH = Math.max(...padHeightCandidates);
+            const soldermaskGlayer = glayers[getGerberLayerName(layer, "soldermask")];
+            let soldermaskMargin = 0;
+            if (glayer === soldermaskGlayer && "soldermask_margin" in element && typeof element.soldermask_margin === "number") {
+              soldermaskMargin = element.soldermask_margin;
+            }
+            const aperturePadW = padW + soldermaskMargin * 2;
+            const aperturePadH = padH + soldermaskMargin * 2;
             if (element.shape === "pill") {
               const circleApertureConfig = {
                 standard_template_code: "C",
-                diameter: Math.min(padW, padH)
+                diameter: Math.min(aperturePadW, aperturePadH)
               };
               let aperture_number;
               try {
@@ -54841,8 +58182,8 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
                   y: element.y + rotatedY
                 };
               };
-              const isHorizontal2 = padW >= padH;
-              const offset = isHorizontal2 ? (padW - padH) / 2 : (padH - padW) / 2;
+              const isHorizontal2 = aperturePadW >= aperturePadH;
+              const offset = isHorizontal2 ? (aperturePadW - aperturePadH) / 2 : (aperturePadH - aperturePadW) / 2;
               if (offset <= 0) {
                 const center2 = rotateAndTranslate(0, 0);
                 gb3.add("flash_operation", { x: center2.x, y: mfy(center2.y) });
@@ -54867,10 +58208,16 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
               }
               glayer.push(...gb3.build());
             } else {
-              const apertureConfig = getApertureConfigFromPcbPlatedHole({
+              let apertureConfig = getApertureConfigFromPcbPlatedHole({
                 ...element,
                 ...element.shape !== "circle" ? { outer_width: padW, outer_height: padH } : {}
               });
+              if (glayer === soldermaskGlayer) {
+                apertureConfig = getApertureConfigFromPcbPlatedHoleSoldermask({
+                  ...element,
+                  ...element.shape !== "circle" ? { outer_width: padW, outer_height: padH } : {}
+                });
+              }
               const rotation11 = "rect_ccw_rotation" in element && typeof element.rect_ccw_rotation === "number" && Math.abs(padW - padH) > 0.000000001 ? element.rect_ccw_rotation : undefined;
               const gb3 = gerberBuilder().add("select_aperture", {
                 aperture_number: findApertureNumber(glayer, apertureConfig)
@@ -54885,7 +58232,7 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
           }
         }
       } else if (element.type === "pcb_hole") {
-        if (layer !== "edgecut") {
+        if (isOuterLayerRef(layer) && element.is_covered_with_solder_mask !== true) {
           for (const glayer of [
             glayers[getGerberLayerName(layer, "soldermask")]
           ]) {
@@ -54894,15 +58241,21 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
               continue;
             }
             glayer.push(...gerberBuilder().add("select_aperture", {
-              aperture_number: findApertureNumber(glayer, getApertureConfigFromCirclePcbHole(element))
+              aperture_number: findApertureNumber(glayer, getApertureConfigFromCirclePcbHoleSoldermask(element))
             }).add("flash_operation", { x: element.x, y: mfy(element.y) }).build());
           }
         }
       } else if (element.type === "pcb_via") {
         if (element.layers.includes(layer)) {
-          for (const glayer of [glayers[getGerberLayerName(layer, "copper")]]) {
+          const layersToAddTo = [
+            glayers[getGerberLayerName(layer, "copper")]
+          ];
+          if (element.is_tented === false && isOuterLayerRef(layer)) {
+            layersToAddTo.push(glayers[getGerberLayerName(layer, "soldermask")]);
+          }
+          for (const glayer of layersToAddTo) {
             glayer.push(...gerberBuilder().add("select_aperture", {
-              aperture_number: findApertureNumber(glayer, getApertureConfigFromPcbVia(element))
+              aperture_number: findApertureNumber(glayer, getApertureConfigFromOuterDiameter(element))
             }).add("flash_operation", { x: element.x, y: mfy(element.y) }).build());
           }
         }
@@ -54915,36 +58268,36 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
           aperture_number: 10
         });
         if (outline && outline.length > 2) {
-          const outlinePoints = outline.map((point9) => ({
-            x: point9.x,
-            y: mfy(point9.y)
-          }));
-          const firstPoint = outlinePoints[0];
-          gerberBuild.add("move_operation", firstPoint);
-          for (let i3 = 1;i3 < outlinePoints.length; i3++) {
-            gerberBuild.add("plot_operation", outlinePoints[i3]);
+          const boardPolygon = [
+            outline.map((point9) => [point9.x, point9.y])
+          ];
+          let boardGeometry = [boardPolygon];
+          if (solidCutoutPolygons.length > 0) {
+            boardGeometry = import_polygon_clipping2.default.difference(boardPolygon, ...solidCutoutPolygons);
           }
-          const lastPoint = outlinePoints[outlinePoints.length - 1];
-          if (lastPoint.x !== firstPoint.x || lastPoint.y !== firstPoint.y) {
-            gerberBuild.add("plot_operation", firstPoint);
+          for (const polygon2 of boardGeometry) {
+            for (const ring of polygon2) {
+              emitEdgeCutRing(gerberBuild, ring, mfy);
+            }
           }
         } else {
-          gerberBuild.add("move_operation", {
-            x: center2.x - width / 2,
-            y: mfy(center2.y - height / 2)
-          }).add("plot_operation", {
-            x: center2.x + width / 2,
-            y: mfy(center2.y - height / 2)
-          }).add("plot_operation", {
-            x: center2.x + width / 2,
-            y: mfy(center2.y + height / 2)
-          }).add("plot_operation", {
-            x: center2.x - width / 2,
-            y: mfy(center2.y + height / 2)
-          }).add("plot_operation", {
-            x: center2.x - width / 2,
-            y: mfy(center2.y - height / 2)
-          });
+          const boardPolygon = [
+            [
+              [center2.x - width / 2, center2.y - height / 2],
+              [center2.x + width / 2, center2.y - height / 2],
+              [center2.x + width / 2, center2.y + height / 2],
+              [center2.x - width / 2, center2.y + height / 2]
+            ]
+          ];
+          let boardGeometry = [boardPolygon];
+          if (solidCutoutPolygons.length > 0) {
+            boardGeometry = import_polygon_clipping2.default.difference(boardPolygon, ...solidCutoutPolygons);
+          }
+          for (const polygon2 of boardGeometry) {
+            for (const ring of polygon2) {
+              emitEdgeCutRing(gerberBuild, ring, mfy);
+            }
+          }
         }
         glayer.push(...gerberBuild.build());
       } else if (element.type === "pcb_panel" && layer === "edgecut") {
@@ -54972,131 +58325,26 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
         glayer.push(...gerberBuild.build());
       } else if (element.type === "pcb_cutout") {
         if (layer === "edgecut") {
+          if (hasBoard && !hasPanel && doesSolidCutoutOverlapBoardEdge({
+            cutout: element,
+            boardOutlinePolygons
+          })) {
+            continue;
+          }
           const ec_layer = glayers.Edge_Cuts;
           const cutout_builder = gerberBuilder().add("select_aperture", {
             aperture_number: 10
           });
-          const el3 = element;
-          if (el3.shape === "rect") {
-            const { center: center2, width, height, rotation: rotation11, corner_radius } = el3;
-            const w4 = width / 2;
-            const h4 = height / 2;
-            const r4 = Math.max(0, Math.min(corner_radius ?? 0, Math.abs(w4), Math.abs(h4)));
-            const makeTransformMatrix = () => {
-              let transformMatrix2 = identity8();
-              if (rotation11) {
-                const angle_rad = rotation11 * Math.PI / 180;
-                transformMatrix2 = rotate12(angle_rad);
-              }
-              return compose9(translate9(center2.x, center2.y), transformMatrix2);
-            };
-            const transformMatrix = makeTransformMatrix();
-            if (r4 > 0) {
-              const startPoint = { x: -w4 + r4, y: h4 };
-              let currentPoint = applyToPoint26(transformMatrix, startPoint);
-              cutout_builder.add("move_operation", {
-                x: currentPoint.x,
-                y: mfy(currentPoint.y)
-              });
-              const addLine = (point9) => {
-                const transformedPoint = applyToPoint26(transformMatrix, point9);
-                cutout_builder.add("plot_operation", {
-                  x: transformedPoint.x,
-                  y: mfy(transformedPoint.y)
-                });
-                currentPoint = transformedPoint;
-              };
-              const addArc = (options) => {
-                const transformedPoint = applyToPoint26(transformMatrix, options.point);
-                const transformedCenter = applyToPoint26(transformMatrix, options.center);
-                cutout_builder.add("set_movement_mode_to_clockwise_circular", {}).add("plot_operation", {
-                  x: transformedPoint.x,
-                  y: mfy(transformedPoint.y),
-                  i: transformedCenter.x - currentPoint.x,
-                  j: mfy(transformedCenter.y) - mfy(currentPoint.y)
-                }).add("set_movement_mode_to_linear", {});
-                currentPoint = transformedPoint;
-              };
-              addLine({ x: w4 - r4, y: h4 });
-              addArc({
-                point: { x: w4, y: h4 - r4 },
-                center: { x: w4 - r4, y: h4 - r4 }
-              });
-              addLine({ x: w4, y: -h4 + r4 });
-              addArc({
-                point: { x: w4 - r4, y: -h4 },
-                center: { x: w4 - r4, y: -h4 + r4 }
-              });
-              addLine({ x: -w4 + r4, y: -h4 });
-              addArc({
-                point: { x: -w4, y: -h4 + r4 },
-                center: { x: -w4 + r4, y: -h4 + r4 }
-              });
-              addLine({ x: -w4, y: h4 - r4 });
-              addArc({
-                point: { x: -w4 + r4, y: h4 },
-                center: { x: -w4 + r4, y: h4 - r4 }
-              });
-            } else {
-              const points = [
-                { x: -w4, y: h4 },
-                { x: w4, y: h4 },
-                { x: w4, y: -h4 },
-                { x: -w4, y: -h4 }
-              ];
-              const transformedPoints = points.map((p3) => applyToPoint26(transformMatrix, p3));
-              cutout_builder.add("move_operation", {
-                x: transformedPoints[0].x,
-                y: mfy(transformedPoints[0].y)
-              });
-              for (let i3 = 1;i3 < transformedPoints.length; i3++) {
-                cutout_builder.add("plot_operation", {
-                  x: transformedPoints[i3].x,
-                  y: mfy(transformedPoints[i3].y)
-                });
-              }
-              cutout_builder.add("plot_operation", {
-                x: transformedPoints[0].x,
-                y: mfy(transformedPoints[0].y)
-              });
-            }
-          } else if (el3.shape === "circle") {
-            const { center: center2, radius } = el3;
-            const p12 = { x: center2.x + radius, y: center2.y };
-            const p23 = { x: center2.x - radius, y: center2.y };
-            cutout_builder.add("move_operation", {
-              x: p12.x,
-              y: mfy(p12.y)
-            }).add("set_movement_mode_to_counterclockwise_circular", {}).add("plot_operation", {
-              x: p23.x,
-              y: mfy(p23.y),
-              i: -radius,
-              j: 0
-            }).add("plot_operation", {
-              x: p12.x,
-              y: mfy(p12.y),
-              i: radius,
-              j: 0
-            }).add("set_movement_mode_to_linear", {});
-          } else if (el3.shape === "polygon") {
-            const { points } = el3;
-            if (points.length > 0) {
-              cutout_builder.add("move_operation", {
-                x: points[0].x,
-                y: mfy(points[0].y)
-              });
-              for (let i3 = 1;i3 < points.length; i3++) {
-                cutout_builder.add("plot_operation", {
-                  x: points[i3].x,
-                  y: mfy(points[i3].y)
-                });
-              }
-              cutout_builder.add("plot_operation", {
-                x: points[0].x,
-                y: mfy(points[0].y)
-              });
-            }
-          }
+          const drawCw = hasBoard && !hasPanel && isCutoutFullyInternal({
+            cutout: element,
+            boardOutlinePolygons
+          });
+          emitCutoutEdgeCuts({
+            cutout: element,
+            builder: cutout_builder,
+            mfy,
+            drawCw
+          });
           ec_layer.push(...cutout_builder.build());
         }
       }
@@ -55107,8 +58355,11 @@ var import_fast_json_stable_stringify, defineExcellonDrillCommand = ({
   }
   return glayers;
 };
-var init_chunk_FNNZTRYF = __esm(() => {
+var init_chunk_46NSLLUV = __esm(() => {
+  import_polygon_clipping = __toESM2(require_polygon_clipping_cjs(), 1);
   import_fast_json_stable_stringify = __toESM2(require_fast_json_stable_stringify(), 1);
+  import_polygon_clipping2 = __toESM2(require_polygon_clipping_cjs(), 1);
+  import_polygon_clipping3 = __toESM2(require_polygon_clipping_cjs(), 1);
   FMAT = defineExcellonDrillCommand({
     command_code: "FMAT",
     schema: z4.object({
@@ -55636,7 +58887,17 @@ ${template_code}%`;
         if (macro_name === "HORZPILL" || macro_name === "VERTPILL") {
           commandString += `${props.x_size.toFixed(6)}X${props.y_size.toFixed(6)}X${props.circle_diameter.toFixed(6)}X${props.circle_center_offset.toFixed(6)}`;
         } else if (macro_name === "ROUNDRECT") {
-          throw new Error("ROUNDRECT macro not implemented yet");
+          commandString += [
+            props.corner_radius,
+            props.corner_1_x,
+            props.corner_1_y,
+            props.corner_2_x,
+            props.corner_2_y,
+            props.corner_3_x,
+            props.corner_3_y,
+            props.corner_4_x,
+            props.corner_4_y
+          ].map((value) => value.toFixed(6)).join("X");
         }
         commandString += "*%";
         return commandString;
@@ -55696,9 +58957,20 @@ ${template_code}%`;
     set_layer_polarity,
     start_region_statement
   };
+  SILKSCREEN_SHAPE_TYPES = [
+    "pcb_silkscreen_line",
+    "pcb_silkscreen_rect",
+    "pcb_silkscreen_circle",
+    "pcb_silkscreen_oval",
+    "pcb_silkscreen_pill"
+  ];
+  REGION_APERTURE_CONFIG = {
+    standard_template_code: "C",
+    diameter: 0.001
+  };
   package_default5 = {
     name: "circuit-json-to-gerber",
-    version: "0.0.50",
+    version: "0.0.82",
     main: "dist/index.js",
     type: "module",
     scripts: {
@@ -55723,15 +58995,16 @@ ${template_code}%`;
       "@types/react-dom": "^19.1.5",
       archiver: "^7.0.1",
       "bun-match-svg": "^0.0.13",
-      "circuit-json": "^0.0.421",
+      "circuit-json": "^0.0.426",
       commander: "^12.1.0",
       "gerber-to-svg": "^4.2.8",
       gerberts: "^0.0.3",
       jszip: "^3.10.1",
       "pcb-stackup": "^4.2.8",
+      "polygon-clipping": "^0.15.7",
       react: "^19.2.1",
       "react-dom": "^19.2.1",
-      tscircuit: "^0.0.1705",
+      tscircuit: "^0.0.1776",
       tsup: "^8.2.4"
     },
     peerDependencies: {
@@ -55747,31 +59020,40 @@ ${template_code}%`;
   };
   layerAndTypeToFileFunction = {
     "top-copper": "Copper,L1,Top",
-    "bottom-copper": "Copper,L2,Bot",
     "top-soldermask": "Soldermask,Top",
     "bottom-soldermask": "Soldermask,Bot",
     "top-silkscreen": "Legend,Top",
     "bottom-silkscreen": "Legend,Bot",
+    "top-fabrication": "Other,Fab,Top",
+    "bottom-fabrication": "Other,Fab,Bot",
     "top-paste": "Paste,Top",
     "bottom-paste": "Paste,Bot",
     edgecut: "Profile,NP"
   };
   layerRefToGerberPrefix = {
     top: "F_",
-    bottom: "B_"
+    bottom: "B_",
+    inner1: "In1_",
+    inner2: "In2_",
+    inner3: "In3_",
+    inner4: "In4_",
+    inner5: "In5_",
+    inner6: "In6_"
   };
   layerTypeToGerberSuffix = {
     copper: "Cu",
     silkscreen: "SilkScreen",
+    fabrication: "Fab",
     soldermask: "Mask",
     mask: "Mask",
     paste: "Paste"
   };
+  outerLayerRefs = ["top", "bottom"];
 });
 
 // node_modules/circuit-json-to-gerber/dist/index.js
 var init_dist = __esm(() => {
-  init_chunk_FNNZTRYF();
+  init_chunk_46NSLLUV();
 });
 
 // node_modules/@tracespace/xml-id/index.js
@@ -68645,11 +71927,11 @@ var init_lib = __esm(() => {
 });
 
 // node_modules/circuit-to-canvas/dist/index.js
-import { compose as compose32, identity as identity9, scale as scale7, translate as translate32 } from "transformation-matrix";
+import { compose as compose33, identity as identity9, scale as scale7, translate as translate33 } from "transformation-matrix";
 import { applyToPoint as applyToPoint27 } from "transformation-matrix";
-import { applyToPoint as applyToPoint25 } from "transformation-matrix";
-import { applyToPoint as applyToPoint42 } from "transformation-matrix";
-import { applyToPoint as applyToPoint32 } from "transformation-matrix";
+import { applyToPoint as applyToPoint28 } from "transformation-matrix";
+import { applyToPoint as applyToPoint43 } from "transformation-matrix";
+import { applyToPoint as applyToPoint33 } from "transformation-matrix";
 import { glyphLineAlphabet } from "@tscircuit/alphabet";
 import { applyToPoint as applyToPoint52 } from "transformation-matrix";
 import {
@@ -68666,7 +71948,7 @@ import { applyToPoint as applyToPoint102 } from "transformation-matrix";
 import { applyToPoint as applyToPoint112 } from "transformation-matrix";
 import { applyToPoint as applyToPoint152 } from "transformation-matrix";
 import { applyToPoint as applyToPoint122, compose as compose10, rotate as rotate13, translate as translate10 } from "transformation-matrix";
-import { applyToPoint as applyToPoint132, compose as compose22, rotate as rotate22, translate as translate22 } from "transformation-matrix";
+import { applyToPoint as applyToPoint132, compose as compose23, rotate as rotate23, translate as translate23 } from "transformation-matrix";
 import { applyToPoint as applyToPoint142 } from "transformation-matrix";
 import { applyToPoint as applyToPoint162 } from "transformation-matrix";
 import { applyToPoint as applyToPoint172 } from "transformation-matrix";
@@ -68738,7 +72020,7 @@ function drawRect(params2) {
     isStrokeDashed = false,
     lineJoin
   } = params2;
-  const [cx3, cy3] = applyToPoint25(realToCanvasMat, [center2.x, center2.y]);
+  const [cx3, cy3] = applyToPoint28(realToCanvasMat, [center2.x, center2.y]);
   const scaledWidth = width * Math.abs(realToCanvasMat.a);
   const scaledHeight = height * Math.abs(realToCanvasMat.a);
   const scaledRadius = borderRadius * Math.abs(realToCanvasMat.a);
@@ -68850,7 +72132,7 @@ function drawPolygon(params2) {
   if (points.length < 3)
     return;
   ctx.beginPath();
-  const canvasPoints = points.map((p3) => applyToPoint32(realToCanvasMat, [p3.x, p3.y]));
+  const canvasPoints = points.map((p3) => applyToPoint33(realToCanvasMat, [p3.x, p3.y]));
   const firstPoint = canvasPoints[0];
   if (!firstPoint)
     return;
@@ -68895,25 +72177,25 @@ function computeArcFromBulge(startX, startY, endX, endY, bulge) {
 }
 function drawArcFromBulge(ctx, realStartX, realStartY, realEndX, realEndY, bulge, realToCanvasMat) {
   if (Math.abs(bulge) < 0.0000000001) {
-    const [endX, endY] = applyToPoint42(realToCanvasMat, [realEndX, realEndY]);
+    const [endX, endY] = applyToPoint43(realToCanvasMat, [realEndX, realEndY]);
     ctx.lineTo(endX, endY);
     return;
   }
   const arc2 = computeArcFromBulge(realStartX, realStartY, realEndX, realEndY, bulge);
   if (!arc2) {
-    const [endX, endY] = applyToPoint42(realToCanvasMat, [realEndX, realEndY]);
+    const [endX, endY] = applyToPoint43(realToCanvasMat, [realEndX, realEndY]);
     ctx.lineTo(endX, endY);
     return;
   }
-  const [canvasStartX, canvasStartY] = applyToPoint42(realToCanvasMat, [
+  const [canvasStartX, canvasStartY] = applyToPoint43(realToCanvasMat, [
     realStartX,
     realStartY
   ]);
-  const [canvasEndX, canvasEndY] = applyToPoint42(realToCanvasMat, [
+  const [canvasEndX, canvasEndY] = applyToPoint43(realToCanvasMat, [
     realEndX,
     realEndY
   ]);
-  const [canvasCenterX, canvasCenterY] = applyToPoint42(realToCanvasMat, [
+  const [canvasCenterX, canvasCenterY] = applyToPoint43(realToCanvasMat, [
     arc2.centerX,
     arc2.centerY
   ]);
@@ -68932,7 +72214,7 @@ function drawRing(ctx, ring, realToCanvasMat) {
     const v02 = ring.vertices[0];
     const v12 = ring.vertices[1];
     if (v02 && v12 && Math.abs((v02.bulge ?? 0) - 1) < 0.0000000001 && Math.abs((v12.bulge ?? 0) - 1) < 0.0000000001) {
-      const [x02, y02] = applyToPoint42(realToCanvasMat, [v02.x, v02.y]);
+      const [x02, y02] = applyToPoint43(realToCanvasMat, [v02.x, v02.y]);
       ctx.moveTo(x02, y02);
       drawArcFromBulge(ctx, v02.x, v02.y, v12.x, v12.y, 1, realToCanvasMat);
       drawArcFromBulge(ctx, v12.x, v12.y, v02.x, v02.y, 1, realToCanvasMat);
@@ -68942,7 +72224,7 @@ function drawRing(ctx, ring, realToCanvasMat) {
   const firstVertex = ring.vertices[0];
   if (!firstVertex)
     return;
-  const [firstX, firstY] = applyToPoint42(realToCanvasMat, [
+  const [firstX, firstY] = applyToPoint43(realToCanvasMat, [
     firstVertex.x,
     firstVertex.y
   ]);
@@ -68955,7 +72237,7 @@ function drawRing(ctx, ring, realToCanvasMat) {
       continue;
     const bulge = currentVertex.bulge ?? 0;
     if (Math.abs(bulge) < 0.0000000001) {
-      const [nextX, nextY] = applyToPoint42(realToCanvasMat, [
+      const [nextX, nextY] = applyToPoint43(realToCanvasMat, [
         nextVertex.x,
         nextVertex.y
       ]);
@@ -68972,7 +72254,7 @@ function drawPcbCopperPour(params2) {
   ctx.save();
   ctx.globalAlpha = opacity;
   if (pour.shape === "rect") {
-    const [cx3, cy3] = applyToPoint42(realToCanvasMat, [
+    const [cx3, cy3] = applyToPoint43(realToCanvasMat, [
       pour.center.x,
       pour.center.y
     ]);
@@ -68991,7 +72273,7 @@ function drawPcbCopperPour(params2) {
   }
   if (pour.shape === "polygon") {
     if (pour.points && pour.points.length >= 3) {
-      const canvasPoints = pour.points.map((p3) => applyToPoint42(realToCanvasMat, [p3.x, p3.y]));
+      const canvasPoints = pour.points.map((p3) => applyToPoint43(realToCanvasMat, [p3.x, p3.y]));
       const firstPoint = canvasPoints[0];
       if (!firstPoint) {
         ctx.restore();
@@ -70016,7 +73298,7 @@ function drawRoundedRectPath(params2) {
     ccwRotationDegrees = 0
   } = params2;
   const ccwRotationRadians = ccwRotationDegrees * Math.PI / 180;
-  const realToPxTransform = compose22(translate22(centerX, centerY), rotate22(-ccwRotationRadians));
+  const realToPxTransform = compose23(translate23(centerX, centerY), rotate23(-ccwRotationRadians));
   const rectHalfWidth = width / 2;
   const rectHalfHeight = height / 2;
   const rectCornerRadius = Math.min(radius, rectHalfWidth, rectHalfHeight);
@@ -73371,7 +76653,7 @@ var getAdvanceRatio = (char) => glyphAdvanceRatio[char] ?? (char === " " ? textM
     const uniformScale = Math.min(scaleX, scaleY);
     const offsetX = (canvasWidth - realWidth * uniformScale) / 2;
     const offsetY = (canvasHeight - realHeight * uniformScale) / 2;
-    this.realToCanvasMat = compose32(translate32(offsetX, offsetY), scale7(uniformScale, -uniformScale), translate32(-bounds.minX, -bounds.maxY));
+    this.realToCanvasMat = compose33(translate33(offsetX, offsetY), scale7(uniformScale, -uniformScale), translate33(-bounds.minX, -bounds.maxY));
   }
   drawElements(elements, options = {}) {
     const layer = getCopperLayer(options.layers);
@@ -73830,7 +77112,7 @@ import {
   isPointInsidePolygon as isPointInsidePolygon2,
   pointToSegmentDistance as pointToSegmentDistance3
 } from "@tscircuit/math-utils";
-import { applyToPoint as applyToPoint28, identity as identity10 } from "transformation-matrix";
+import { applyToPoint as applyToPoint29, identity as identity10 } from "transformation-matrix";
 import { convertCircuitJsonToPcbSvg as convertCircuitJsonToPcbSvg22 } from "circuit-to-svg";
 import { deflateSync } from "node:zlib";
 
@@ -74450,7 +77732,7 @@ var import_gerber_to_svg, renderTscircuitRepro = async (tsx, options = {}) => {
   const svg = await renderGerberToSvg(gerber);
   const boardSvg = forceSvgViewport({ svg, bounds, width, height });
   return getMaskFromPng(renderSvgToPng(boardSvg));
-}, transformPoint = (matrix2, point9) => applyToPoint28(matrix2, point9), getBounds2 = (parts) => {
+}, transformPoint = (matrix2, point9) => applyToPoint29(matrix2, point9), getBounds2 = (parts) => {
   let minX = Number.POSITIVE_INFINITY;
   let minY = Number.POSITIVE_INFINITY;
   let maxX = Number.NEGATIVE_INFINITY;
@@ -115063,7 +118345,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.1642";
+var version = "0.1.1643";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -115103,7 +118385,7 @@ var package_default = {
     "circuit-json-to-3d-png": "^0.0.6",
     "circuit-json-to-bom-csv": "^0.0.7",
     "circuit-json-to-connectivity-map": "^0.0.25",
-    "circuit-json-to-gerber": "^0.0.51",
+    "circuit-json-to-gerber": "^0.0.83",
     "circuit-json-to-kicad": "0.0.157",
     "circuit-json-to-pnp-csv": "^0.0.7",
     "circuit-json-to-readable-netlist": "^0.0.15",
@@ -115136,6 +118418,7 @@ var package_default = {
     md5: "^2.3.0",
     "perfect-cli": "^1.0.21",
     playwright: "^1.57.0",
+    "polygon-clipping": "^0.15.7",
     poppygl: "^0.0.24",
     prompts: "^2.4.2",
     redaxios: "^0.5.1",
@@ -287233,7 +290516,7 @@ import {
 // node_modules/dsn-converter/dist/index.js
 import { su as su14 } from "@tscircuit/soup-util";
 import { getBoundsFromPoints as getBoundsFromPoints4 } from "@tscircuit/math-utils";
-import { applyToPoint as applyToPoint29, scale as scale8 } from "transformation-matrix";
+import { applyToPoint as applyToPoint31, scale as scale8 } from "transformation-matrix";
 import { su as su24 } from "@tscircuit/soup-util";
 import { su as su34 } from "@tscircuit/soup-util";
 import Debug4 from "debug";
@@ -287242,9 +290525,9 @@ import { applyToPoint as applyToPoint210, scale as scale22 } from "transformatio
 import Debug22 from "debug";
 import { applyToPoint as applyToPoint93, scale as scale32 } from "transformation-matrix";
 import { su as su52 } from "@tscircuit/soup-util";
-import { applyToPoint as applyToPoint33 } from "transformation-matrix";
+import { applyToPoint as applyToPoint34 } from "transformation-matrix";
 import Debug32 from "debug";
-import { applyToPoint as applyToPoint43 } from "transformation-matrix";
+import { applyToPoint as applyToPoint44 } from "transformation-matrix";
 import Debug6 from "debug";
 import"transformation-matrix";
 import { applyToPoint as applyToPoint53 } from "transformation-matrix";
@@ -287644,7 +290927,7 @@ function processComponentsAndPads(componentGroups, circuitElements, pcb) {
     const sourceComponent = su14(circuitElements).source_component.list().find((e4) => e4.source_component_id === pcbComponent?.source_component_id);
     const footprintName = getFootprintName(sourceComponent, pcbComponent);
     const componentName = sourceComponent?.name || "Unknown";
-    const circuitSpaceCoordinates = applyToPoint29(transformMmToUm, pcbComponent.center);
+    const circuitSpaceCoordinates = applyToPoint31(transformMmToUm, pcbComponent.center);
     if (!componentsByFootprint.has(footprintName)) {
       componentsByFootprint.set(footprintName, []);
     }
@@ -296329,7 +299612,7 @@ var any_circuit_element = external_exports2.union([
 var any_soup_element4 = any_circuit_element;
 expectTypesMatch2(true);
 expectStringUnionsMatch(true);
-function applyToPoint30(matrix2, point22) {
+function applyToPoint35(matrix2, point22) {
   return Array.isArray(point22) ? [
     matrix2.a * point22[0] + matrix2.c * point22[1] + matrix2.e,
     matrix2.b * point22[0] + matrix2.d * point22[1] + matrix2.f
@@ -297293,7 +300576,7 @@ var transformPCBElement2 = (elm, matrix2) => {
   const tsr = decomposeTSR2(matrix2);
   const flipPadWidthHeight = Math.round(tsr.rotation.angle / (Math.PI / 2)) % 2 === 1;
   if (elm.type === "pcb_plated_hole" || elm.type === "pcb_hole" || elm.type === "pcb_via" || elm.type === "pcb_smtpad" || elm.type === "pcb_port") {
-    const { x: x4, y: y4 } = applyToPoint30(matrix2, {
+    const { x: x4, y: y4 } = applyToPoint35(matrix2, {
       x: Number(elm.x),
       y: Number(elm.y)
     });
@@ -297301,7 +300584,7 @@ var transformPCBElement2 = (elm, matrix2) => {
     elm.y = y4;
     if (elm.type === "pcb_smtpad" && elm.shape === "polygon" && Array.isArray(elm.points)) {
       elm.points = elm.points.map((point22) => {
-        const tp3 = applyToPoint30(matrix2, { x: point22.x, y: point22.y });
+        const tp3 = applyToPoint35(matrix2, { x: point22.x, y: point22.y });
         return {
           x: tp3.x,
           y: tp3.y
@@ -297309,13 +300592,13 @@ var transformPCBElement2 = (elm, matrix2) => {
       });
     }
   } else if (elm.type === "pcb_keepout" || elm.type === "pcb_board") {
-    elm.center = applyToPoint30(matrix2, elm.center);
+    elm.center = applyToPoint35(matrix2, elm.center);
   } else if (elm.type === "pcb_silkscreen_text" || elm.type === "pcb_fabrication_note_text" || elm.type === "pcb_note_text") {
-    elm.anchor_position = applyToPoint30(matrix2, elm.anchor_position);
+    elm.anchor_position = applyToPoint35(matrix2, elm.anchor_position);
   } else if (elm.type === "pcb_silkscreen_circle" || elm.type === "pcb_silkscreen_rect" || elm.type === "pcb_note_rect" || elm.type === "pcb_courtyard_rect" || elm.type === "pcb_courtyard_circle") {
-    elm.center = applyToPoint30(matrix2, elm.center);
+    elm.center = applyToPoint35(matrix2, elm.center);
   } else if (elm.type === "pcb_component") {
-    elm.center = applyToPoint30(matrix2, elm.center);
+    elm.center = applyToPoint35(matrix2, elm.center);
     elm.rotation = elm.rotation + tsr.rotation.angle / Math.PI * 180;
     elm.rotation = elm.rotation % 360;
     if (flipPadWidthHeight) {
@@ -297323,21 +300606,21 @@ var transformPCBElement2 = (elm, matrix2) => {
     }
   } else if (elm.type === "pcb_courtyard_outline") {
     elm.outline = elm.outline.map((p3) => {
-      const tp3 = applyToPoint30(matrix2, p3);
+      const tp3 = applyToPoint35(matrix2, p3);
       p3.x = tp3.x;
       p3.y = tp3.y;
       return p3;
     });
   } else if (elm.type === "pcb_courtyard_polygon") {
     elm.points = elm.points.map((p3) => {
-      const tp3 = applyToPoint30(matrix2, p3);
+      const tp3 = applyToPoint35(matrix2, p3);
       p3.x = tp3.x;
       p3.y = tp3.y;
       return p3;
     });
   } else if (elm.type === "pcb_silkscreen_path" || elm.type === "pcb_trace" || elm.type === "pcb_fabrication_note_path" || elm.type === "pcb_note_path") {
     elm.route = elm.route.map((rp3) => {
-      const tp3 = applyToPoint30(matrix2, rp3);
+      const tp3 = applyToPoint35(matrix2, rp3);
       rp3.x = tp3.x;
       rp3.y = tp3.y;
       return rp3;
@@ -297345,14 +300628,14 @@ var transformPCBElement2 = (elm, matrix2) => {
   } else if (elm.type === "pcb_silkscreen_line" || elm.type === "pcb_note_line") {
     const p12 = { x: elm.x1, y: elm.y1 };
     const p23 = { x: elm.x2, y: elm.y2 };
-    const p1t = applyToPoint30(matrix2, p12);
-    const p2t = applyToPoint30(matrix2, p23);
+    const p1t = applyToPoint35(matrix2, p12);
+    const p2t = applyToPoint35(matrix2, p23);
     elm.x1 = p1t.x;
     elm.y1 = p1t.y;
     elm.x2 = p2t.x;
     elm.y2 = p2t.y;
   } else if (elm.type === "cad_component") {
-    const newPos = applyToPoint30(matrix2, {
+    const newPos = applyToPoint35(matrix2, {
       x: elm.position.x,
       y: elm.position.y
     });
@@ -298315,15 +301598,15 @@ var convertEasyEdaJsonToCircuitJson = (easyEdaJson, {
       for (const e4 of circuitElements) {
         if (e4.type === "pcb_cutout") {
           if (e4.shape === "polygon") {
-            e4.points = e4.points.map((p3) => applyToPoint30(matrix2, p3));
+            e4.points = e4.points.map((p3) => applyToPoint35(matrix2, p3));
           } else if (e4.shape === "circle" || e4.shape === "rect") {
-            e4.center = applyToPoint30(matrix2, e4.center);
+            e4.center = applyToPoint35(matrix2, e4.center);
           } else if ("route" in e4) {
             const cutoutPath = e4;
-            cutoutPath.route = cutoutPath.route.map((p3) => applyToPoint30(matrix2, p3));
+            cutoutPath.route = cutoutPath.route.map((p3) => applyToPoint35(matrix2, p3));
           }
         } else if (e4.type === "pcb_smtpad" && e4.shape === "polygon") {
-          e4.points = e4.points.map((p3) => applyToPoint30(matrix2, p3));
+          e4.points = e4.points.map((p3) => applyToPoint35(matrix2, p3));
         }
       }
       const cad = circuitElements.find((e4) => e4.type === "cad_component");
@@ -303116,7 +306399,7 @@ var any_circuit_element2 = z160.union([
 var any_soup_element5 = any_circuit_element2;
 expectTypesMatch3(true);
 expectStringUnionsMatch2(true);
-function applyToPoint31(matrix2, point22) {
+function applyToPoint37(matrix2, point22) {
   return Array.isArray(point22) ? [
     matrix2.a * point22[0] + matrix2.c * point22[1] + matrix2.e,
     matrix2.b * point22[0] + matrix2.d * point22[1] + matrix2.f
@@ -304079,7 +307362,7 @@ var transformPCBElement3 = (elm, matrix2) => {
   const tsr = decomposeTSR3(matrix2);
   const flipPadWidthHeight = Math.round(tsr.rotation.angle / (Math.PI / 2)) % 2 === 1;
   if (elm.type === "pcb_plated_hole" || elm.type === "pcb_hole" || elm.type === "pcb_via" || elm.type === "pcb_smtpad" || elm.type === "pcb_port") {
-    const { x: x4, y: y4 } = applyToPoint31(matrix2, {
+    const { x: x4, y: y4 } = applyToPoint37(matrix2, {
       x: Number(elm.x),
       y: Number(elm.y)
     });
@@ -304087,7 +307370,7 @@ var transformPCBElement3 = (elm, matrix2) => {
     elm.y = y4;
     if (elm.type === "pcb_smtpad" && elm.shape === "polygon" && Array.isArray(elm.points)) {
       elm.points = elm.points.map((point22) => {
-        const tp3 = applyToPoint31(matrix2, { x: point22.x, y: point22.y });
+        const tp3 = applyToPoint37(matrix2, { x: point22.x, y: point22.y });
         return {
           x: tp3.x,
           y: tp3.y
@@ -304095,13 +307378,13 @@ var transformPCBElement3 = (elm, matrix2) => {
       });
     }
   } else if (elm.type === "pcb_keepout" || elm.type === "pcb_board") {
-    elm.center = applyToPoint31(matrix2, elm.center);
+    elm.center = applyToPoint37(matrix2, elm.center);
   } else if (elm.type === "pcb_silkscreen_text" || elm.type === "pcb_fabrication_note_text" || elm.type === "pcb_note_text") {
-    elm.anchor_position = applyToPoint31(matrix2, elm.anchor_position);
+    elm.anchor_position = applyToPoint37(matrix2, elm.anchor_position);
   } else if (elm.type === "pcb_silkscreen_circle" || elm.type === "pcb_silkscreen_rect" || elm.type === "pcb_note_rect" || elm.type === "pcb_courtyard_rect" || elm.type === "pcb_courtyard_circle") {
-    elm.center = applyToPoint31(matrix2, elm.center);
+    elm.center = applyToPoint37(matrix2, elm.center);
   } else if (elm.type === "pcb_component") {
-    elm.center = applyToPoint31(matrix2, elm.center);
+    elm.center = applyToPoint37(matrix2, elm.center);
     elm.rotation = elm.rotation + tsr.rotation.angle / Math.PI * 180;
     elm.rotation = elm.rotation % 360;
     if (flipPadWidthHeight) {
@@ -304109,21 +307392,21 @@ var transformPCBElement3 = (elm, matrix2) => {
     }
   } else if (elm.type === "pcb_courtyard_outline") {
     elm.outline = elm.outline.map((p3) => {
-      const tp3 = applyToPoint31(matrix2, p3);
+      const tp3 = applyToPoint37(matrix2, p3);
       p3.x = tp3.x;
       p3.y = tp3.y;
       return p3;
     });
   } else if (elm.type === "pcb_courtyard_polygon") {
     elm.points = elm.points.map((p3) => {
-      const tp3 = applyToPoint31(matrix2, p3);
+      const tp3 = applyToPoint37(matrix2, p3);
       p3.x = tp3.x;
       p3.y = tp3.y;
       return p3;
     });
   } else if (elm.type === "pcb_silkscreen_path" || elm.type === "pcb_trace" || elm.type === "pcb_fabrication_note_path" || elm.type === "pcb_note_path") {
     elm.route = elm.route.map((rp3) => {
-      const tp3 = applyToPoint31(matrix2, rp3);
+      const tp3 = applyToPoint37(matrix2, rp3);
       rp3.x = tp3.x;
       rp3.y = tp3.y;
       return rp3;
@@ -304131,14 +307414,14 @@ var transformPCBElement3 = (elm, matrix2) => {
   } else if (elm.type === "pcb_silkscreen_line" || elm.type === "pcb_note_line") {
     const p12 = { x: elm.x1, y: elm.y1 };
     const p23 = { x: elm.x2, y: elm.y2 };
-    const p1t = applyToPoint31(matrix2, p12);
-    const p2t = applyToPoint31(matrix2, p23);
+    const p1t = applyToPoint37(matrix2, p12);
+    const p2t = applyToPoint37(matrix2, p23);
     elm.x1 = p1t.x;
     elm.y1 = p1t.y;
     elm.x2 = p2t.x;
     elm.y2 = p2t.y;
   } else if (elm.type === "cad_component") {
-    const newPos = applyToPoint31(matrix2, {
+    const newPos = applyToPoint37(matrix2, {
       x: elm.position.x,
       y: elm.position.y
     });
@@ -305084,15 +308367,15 @@ var convertEasyEdaJsonToCircuitJson2 = (easyEdaJson, {
       for (const e4 of circuitElements) {
         if (e4.type === "pcb_cutout") {
           if (e4.shape === "polygon") {
-            e4.points = e4.points.map((p3) => applyToPoint31(matrix2, p3));
+            e4.points = e4.points.map((p3) => applyToPoint37(matrix2, p3));
           } else if (e4.shape === "circle" || e4.shape === "rect") {
-            e4.center = applyToPoint31(matrix2, e4.center);
+            e4.center = applyToPoint37(matrix2, e4.center);
           } else if ("route" in e4) {
             const cutoutPath = e4;
-            cutoutPath.route = cutoutPath.route.map((p3) => applyToPoint31(matrix2, p3));
+            cutoutPath.route = cutoutPath.route.map((p3) => applyToPoint37(matrix2, p3));
           }
         } else if (e4.type === "pcb_smtpad" && e4.shape === "polygon") {
-          e4.points = e4.points.map((p3) => applyToPoint31(matrix2, p3));
+          e4.points = e4.points.map((p3) => applyToPoint37(matrix2, p3));
         }
       }
       const cad = circuitElements.find((e4) => e4.type === "cad_component");