@tscircuit/cli 0.1.151 → 0.1.152

package/dist/main.js

@@ -227419,26 +227419,2229 @@ var require_svgson_cjs = __commonJS((exports2) => {
   exports2.stringify = stringify;
 });
 
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/applyToPoint.js
+var require_applyToPoint = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.applyToPoint = applyToPoint;
+  exports2.applyToPoints = applyToPoints;
+  function applyToPoint(matrix, point2) {
+    return Array.isArray(point2) ? [matrix.a * point2[0] + matrix.c * point2[1] + matrix.e, matrix.b * point2[0] + matrix.d * point2[1] + matrix.f] : {
+      x: matrix.a * point2.x + matrix.c * point2.y + matrix.e,
+      y: matrix.b * point2.x + matrix.d * point2.y + matrix.f
+    };
+  }
+  function applyToPoints(matrix, points) {
+    return points.map((point2) => applyToPoint(matrix, point2));
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/fromObject.js
+var require_fromObject = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.fromObject = fromObject;
+  function fromObject(object) {
+    return {
+      a: parseFloat(object.a),
+      b: parseFloat(object.b),
+      c: parseFloat(object.c),
+      d: parseFloat(object.d),
+      e: parseFloat(object.e),
+      f: parseFloat(object.f)
+    };
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/fromString.js
+var require_fromString = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.fromString = fromString;
+  var matrixRegex = /^matrix\(\s*([0-9_+-.e]+)\s*,\s*([0-9_+-.e]+)\s*,\s*([0-9_+-.e]+)\s*,\s*([0-9_+-.e]+)\s*,\s*([0-9_+-.e]+)\s*,\s*([0-9_+-.e]+)\s*\)$/i;
+  function fromString(string) {
+    const parsed = string.match(matrixRegex);
+    if (parsed === null || parsed.length < 7)
+      throw new Error(`'${string}' is not a matrix`);
+    return {
+      a: parseFloat(parsed[1]),
+      b: parseFloat(parsed[2]),
+      c: parseFloat(parsed[3]),
+      d: parseFloat(parsed[4]),
+      e: parseFloat(parsed[5]),
+      f: parseFloat(parsed[6])
+    };
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/identity.js
+var require_identity = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.identity = identity;
+  function identity() {
+    return {
+      a: 1,
+      c: 0,
+      e: 0,
+      b: 0,
+      d: 1,
+      f: 0
+    };
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/inverse.js
+var require_inverse = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.inverse = inverse;
+  function inverse(matrix) {
+    const {
+      a,
+      b,
+      c,
+      d,
+      e,
+      f
+    } = matrix;
+    const denom = a * d - b * c;
+    return {
+      a: d / denom,
+      b: b / -denom,
+      c: c / -denom,
+      d: a / denom,
+      e: (d * e - c * f) / -denom,
+      f: (b * e - a * f) / denom
+    };
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/utils.js
+var require_utils6 = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.isNumeric = isNumeric;
+  exports2.isObject = isObject3;
+  exports2.isUndefined = isUndefined2;
+  exports2.matchesShape = matchesShape;
+  function isUndefined2(val) {
+    return typeof val === "undefined";
+  }
+  function isNumeric(n) {
+    return typeof n === "number" && !Number.isNaN(n) && Number.isFinite(n);
+  }
+  function isObject3(obj) {
+    return typeof obj === "object" && obj !== null && !Array.isArray(obj);
+  }
+  function matchesShape(obj, keys) {
+    return keys.every((key) => (key in obj));
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/isAffineMatrix.js
+var require_isAffineMatrix = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.isAffineMatrix = isAffineMatrix;
+  var _utils = require_utils6();
+  function isAffineMatrix(object) {
+    return (0, _utils.isObject)(object) && "a" in object && (0, _utils.isNumeric)(object.a) && "b" in object && (0, _utils.isNumeric)(object.b) && "c" in object && (0, _utils.isNumeric)(object.c) && "d" in object && (0, _utils.isNumeric)(object.d) && "e" in object && (0, _utils.isNumeric)(object.e) && "f" in object && (0, _utils.isNumeric)(object.f);
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/translate.js
+var require_translate = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.translate = translate;
+  function translate(tx, ty = 0) {
+    return {
+      a: 1,
+      c: 0,
+      e: tx,
+      b: 0,
+      d: 1,
+      f: ty
+    };
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/transform.js
+var require_transform = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.compose = compose;
+  exports2.transform = transform;
+  function transform(...matrices) {
+    matrices = Array.isArray(matrices[0]) ? matrices[0] : matrices;
+    const multiply = (m1, m2) => {
+      return {
+        a: m1.a * m2.a + m1.c * m2.b,
+        c: m1.a * m2.c + m1.c * m2.d,
+        e: m1.a * m2.e + m1.c * m2.f + m1.e,
+        b: m1.b * m2.a + m1.d * m2.b,
+        d: m1.b * m2.c + m1.d * m2.d,
+        f: m1.b * m2.e + m1.d * m2.f + m1.f
+      };
+    };
+    switch (matrices.length) {
+      case 0:
+        throw new Error("no matrices provided");
+      case 1:
+        return matrices[0];
+      case 2:
+        return multiply(matrices[0], matrices[1]);
+      default: {
+        const [m1, m2, ...rest] = matrices;
+        const m = multiply(m1, m2);
+        return transform(m, ...rest);
+      }
+    }
+  }
+  function compose(...matrices) {
+    return transform(...matrices);
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/rotate.js
+var require_rotate = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.rotate = rotate;
+  exports2.rotateDEG = rotateDEG;
+  var _utils = require_utils6();
+  var _translate = require_translate();
+  var _transform = require_transform();
+  var {
+    cos,
+    sin,
+    PI
+  } = Math;
+  function rotate(angle, cx, cy) {
+    const cosAngle = cos(angle);
+    const sinAngle = sin(angle);
+    const rotationMatrix = {
+      a: cosAngle,
+      c: -sinAngle,
+      e: 0,
+      b: sinAngle,
+      d: cosAngle,
+      f: 0
+    };
+    if ((0, _utils.isUndefined)(cx) || (0, _utils.isUndefined)(cy)) {
+      return rotationMatrix;
+    }
+    return (0, _transform.transform)([(0, _translate.translate)(cx, cy), rotationMatrix, (0, _translate.translate)(-cx, -cy)]);
+  }
+  function rotateDEG(angle, cx = undefined, cy = undefined) {
+    return rotate(angle * PI / 180, cx, cy);
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/scale.js
+var require_scale = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.scale = scale;
+  var _utils = require_utils6();
+  var _translate = require_translate();
+  var _transform = require_transform();
+  function scale(sx, sy = undefined, cx = undefined, cy = undefined) {
+    if ((0, _utils.isUndefined)(sy))
+      sy = sx;
+    const scaleMatrix = {
+      a: sx,
+      c: 0,
+      e: 0,
+      b: 0,
+      d: sy,
+      f: 0
+    };
+    if ((0, _utils.isUndefined)(cx) || (0, _utils.isUndefined)(cy)) {
+      return scaleMatrix;
+    }
+    return (0, _transform.transform)([(0, _translate.translate)(cx, cy), scaleMatrix, (0, _translate.translate)(-cx, -cy)]);
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/shear.js
+var require_shear = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.shear = shear;
+  function shear(shx, shy) {
+    return {
+      a: 1,
+      c: shx,
+      e: 0,
+      b: shy,
+      d: 1,
+      f: 0
+    };
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/skew.js
+var require_skew = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.skew = skew;
+  exports2.skewDEG = skewDEG;
+  var {
+    tan
+  } = Math;
+  function skew(ax, ay) {
+    return {
+      a: 1,
+      c: tan(ax),
+      e: 0,
+      b: tan(ay),
+      d: 1,
+      f: 0
+    };
+  }
+  function skewDEG(ax, ay) {
+    return skew(ax * Math.PI / 180, ay * Math.PI / 180);
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/toString.js
+var require_toString = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.toCSS = toCSS;
+  exports2.toSVG = toSVG;
+  exports2.toString = toString;
+  function toCSS(matrix) {
+    return toString(matrix);
+  }
+  function toSVG(matrix) {
+    return toString(matrix);
+  }
+  function toString(matrix) {
+    return `matrix(${matrix.a},${matrix.b},${matrix.c},${matrix.d},${matrix.e},${matrix.f})`;
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/smoothMatrix.js
+var require_smoothMatrix = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.smoothMatrix = smoothMatrix;
+  function smoothMatrix(matrix, precision = 10000000000) {
+    return {
+      a: Math.round(matrix.a * precision) / precision,
+      b: Math.round(matrix.b * precision) / precision,
+      c: Math.round(matrix.c * precision) / precision,
+      d: Math.round(matrix.d * precision) / precision,
+      e: Math.round(matrix.e * precision) / precision,
+      f: Math.round(matrix.f * precision) / precision
+    };
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/fromTriangles.js
+var require_fromTriangles = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.fromTriangles = fromTriangles;
+  var _inverse = require_inverse();
+  var _transform = require_transform();
+  var _smoothMatrix = require_smoothMatrix();
+  function fromTriangles(t1, t2) {
+    const px1 = t1[0].x != null ? t1[0].x : t1[0][0];
+    const py1 = t1[0].y != null ? t1[0].y : t1[0][1];
+    const px2 = t2[0].x != null ? t2[0].x : t2[0][0];
+    const py2 = t2[0].y != null ? t2[0].y : t2[0][1];
+    const qx1 = t1[1].x != null ? t1[1].x : t1[1][0];
+    const qy1 = t1[1].y != null ? t1[1].y : t1[1][1];
+    const qx2 = t2[1].x != null ? t2[1].x : t2[1][0];
+    const qy2 = t2[1].y != null ? t2[1].y : t2[1][1];
+    const rx1 = t1[2].x != null ? t1[2].x : t1[2][0];
+    const ry1 = t1[2].y != null ? t1[2].y : t1[2][1];
+    const rx2 = t2[2].x != null ? t2[2].x : t2[2][0];
+    const ry2 = t2[2].y != null ? t2[2].y : t2[2][1];
+    const r1 = {
+      a: px1 - rx1,
+      b: py1 - ry1,
+      c: qx1 - rx1,
+      d: qy1 - ry1,
+      e: rx1,
+      f: ry1
+    };
+    const r2 = {
+      a: px2 - rx2,
+      b: py2 - ry2,
+      c: qx2 - rx2,
+      d: qy2 - ry2,
+      e: rx2,
+      f: ry2
+    };
+    const inverseR1 = (0, _inverse.inverse)(r1);
+    const affineMatrix = (0, _transform.transform)([r2, inverseR1]);
+    return (0, _smoothMatrix.smoothMatrix)(affineMatrix);
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/fromDefinition.js
+var require_fromDefinition = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.fromDefinition = fromDefinition;
+  var _fromObject = require_fromObject();
+  var _translate = require_translate();
+  var _scale = require_scale();
+  var _rotate = require_rotate();
+  var _skew = require_skew();
+  var _shear = require_shear();
+  function fromDefinition(definitionOrArrayOfDefinition) {
+    return Array.isArray(definitionOrArrayOfDefinition) ? definitionOrArrayOfDefinition.map(mapper) : mapper(definitionOrArrayOfDefinition);
+    function mapper(descriptor) {
+      switch (descriptor.type) {
+        case "matrix":
+          if ("a" in descriptor && "b" in descriptor && "c" in descriptor && "d" in descriptor && "e" in descriptor && "f" in descriptor) {
+            return (0, _fromObject.fromObject)(descriptor);
+          } else {
+            throw new Error("MISSING_MANDATORY_PARAM");
+          }
+        case "translate":
+          if (!("tx" in descriptor))
+            throw new Error("MISSING_MANDATORY_PARAM");
+          if ("ty" in descriptor)
+            return (0, _translate.translate)(descriptor.tx, descriptor.ty);
+          return (0, _translate.translate)(descriptor.tx);
+        case "scale":
+          if (!("sx" in descriptor))
+            throw new Error("MISSING_MANDATORY_PARAM");
+          if ("sy" in descriptor)
+            return (0, _scale.scale)(descriptor.sx, descriptor.sy);
+          return (0, _scale.scale)(descriptor.sx);
+        case "rotate":
+          if (!("angle" in descriptor))
+            throw new Error("MISSING_MANDATORY_PARAM");
+          if ("cx" in descriptor && "cy" in descriptor) {
+            return (0, _rotate.rotateDEG)(descriptor.angle, descriptor.cx, descriptor.cy);
+          }
+          return (0, _rotate.rotateDEG)(descriptor.angle);
+        case "skewX":
+          if (!("angle" in descriptor))
+            throw new Error("MISSING_MANDATORY_PARAM");
+          return (0, _skew.skewDEG)(descriptor.angle, 0);
+        case "skewY":
+          if (!("angle" in descriptor))
+            throw new Error("MISSING_MANDATORY_PARAM");
+          return (0, _skew.skewDEG)(0, descriptor.angle);
+        case "shear":
+          if (!(("shx" in descriptor) && ("shy" in descriptor)))
+            throw new Error("MISSING_MANDATORY_PARAM");
+          return (0, _shear.shear)(descriptor.shx, descriptor.shy);
+        default:
+          throw new Error("UNSUPPORTED_DESCRIPTOR");
+      }
+    }
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/fromTransformAttribute.autogenerated.js
+var require_fromTransformAttribute_autogenerated = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.SyntaxError = peg$SyntaxError2;
+  exports2.parse = peg$parse;
+  function peg$subclass2(child, parent) {
+    function C() {
+      this.constructor = child;
+    }
+    C.prototype = parent.prototype;
+    child.prototype = new C;
+  }
+  function peg$SyntaxError2(message, expected, found, location) {
+    var self = Error.call(this, message);
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(self, peg$SyntaxError2.prototype);
+    }
+    self.expected = expected;
+    self.found = found;
+    self.location = location;
+    self.name = "SyntaxError";
+    return self;
+  }
+  peg$subclass2(peg$SyntaxError2, Error);
+  function peg$padEnd2(str, targetLength, padString) {
+    padString = padString || " ";
+    if (str.length > targetLength) {
+      return str;
+    }
+    targetLength -= str.length;
+    padString += padString.repeat(targetLength);
+    return str + padString.slice(0, targetLength);
+  }
+  peg$SyntaxError2.prototype.format = function(sources) {
+    var str = "Error: " + this.message;
+    if (this.location) {
+      var src = null;
+      var k;
+      for (k = 0;k < sources.length; k++) {
+        if (sources[k].source === this.location.source) {
+          src = sources[k].text.split(/\r\n|\n|\r/g);
+          break;
+        }
+      }
+      var s = this.location.start;
+      var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s;
+      var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column;
+      if (src) {
+        var e = this.location.end;
+        var filler = peg$padEnd2("", offset_s.line.toString().length, " ");
+        var line = src[s.line - 1];
+        var last = s.line === e.line ? e.column : line.length + 1;
+        var hatLen = last - s.column || 1;
+        str += `
+ --> ` + loc + `
+` + filler + ` |
+` + offset_s.line + " | " + line + `
+` + filler + " | " + peg$padEnd2("", s.column - 1, " ") + peg$padEnd2("", hatLen, "^");
+      } else {
+        str += `
+ at ` + loc;
+      }
+    }
+    return str;
+  };
+  peg$SyntaxError2.buildMessage = function(expected, found) {
+    var DESCRIBE_EXPECTATION_FNS = {
+      literal: function(expectation) {
+        return '"' + literalEscape(expectation.text) + '"';
+      },
+      class: function(expectation) {
+        var escapedParts = expectation.parts.map(function(part) {
+          return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part);
+        });
+        return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]";
+      },
+      any: function() {
+        return "any character";
+      },
+      end: function() {
+        return "end of input";
+      },
+      other: function(expectation) {
+        return expectation.description;
+      }
+    };
+    function hex(ch) {
+      return ch.charCodeAt(0).toString(16).toUpperCase();
+    }
+    function literalEscape(s) {
+      return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) {
+        return "\\x0" + hex(ch);
+      }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) {
+        return "\\x" + hex(ch);
+      });
+    }
+    function classEscape(s) {
+      return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) {
+        return "\\x0" + hex(ch);
+      }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) {
+        return "\\x" + hex(ch);
+      });
+    }
+    function describeExpectation(expectation) {
+      return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
+    }
+    function describeExpected(expected2) {
+      var descriptions = expected2.map(describeExpectation);
+      var i, j;
+      descriptions.sort();
+      if (descriptions.length > 0) {
+        for (i = 1, j = 1;i < descriptions.length; i++) {
+          if (descriptions[i - 1] !== descriptions[i]) {
+            descriptions[j] = descriptions[i];
+            j++;
+          }
+        }
+        descriptions.length = j;
+      }
+      switch (descriptions.length) {
+        case 1:
+          return descriptions[0];
+        case 2:
+          return descriptions[0] + " or " + descriptions[1];
+        default:
+          return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1];
+      }
+    }
+    function describeFound(found2) {
+      return found2 ? '"' + literalEscape(found2) + '"' : "end of input";
+    }
+    return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
+  };
+  function peg$parse(input, options) {
+    options = options !== undefined ? options : {};
+    var peg$FAILED = {};
+    var peg$source = options.grammarSource;
+    var peg$startRuleFunctions = {
+      transformList: peg$parsetransformList
+    };
+    var peg$startRuleFunction = peg$parsetransformList;
+    var peg$c0 = "matrix";
+    var peg$c1 = "(";
+    var peg$c2 = ")";
+    var peg$c3 = "translate";
+    var peg$c4 = "scale";
+    var peg$c5 = "rotate";
+    var peg$c6 = "skewX";
+    var peg$c7 = "skewY";
+    var peg$c8 = ",";
+    var peg$c9 = ".";
+    var peg$r0 = /^[eE]/;
+    var peg$r1 = /^[+\-]/;
+    var peg$r2 = /^[0-9]/;
+    var peg$r3 = /^[ \t\r\n]/;
+    var peg$e0 = peg$literalExpectation("matrix", false);
+    var peg$e1 = peg$literalExpectation("(", false);
+    var peg$e2 = peg$literalExpectation(")", false);
+    var peg$e3 = peg$literalExpectation("translate", false);
+    var peg$e4 = peg$literalExpectation("scale", false);
+    var peg$e5 = peg$literalExpectation("rotate", false);
+    var peg$e6 = peg$literalExpectation("skewX", false);
+    var peg$e7 = peg$literalExpectation("skewY", false);
+    var peg$e8 = peg$literalExpectation(",", false);
+    var peg$e9 = peg$otherExpectation("fractionalConstant");
+    var peg$e10 = peg$literalExpectation(".", false);
+    var peg$e11 = peg$classExpectation(["e", "E"], false, false);
+    var peg$e12 = peg$classExpectation(["+", "-"], false, false);
+    var peg$e13 = peg$classExpectation([["0", "9"]], false, false);
+    var peg$e14 = peg$classExpectation([" ", "\t", "\r", `
+`], false, false);
+    var peg$f0 = function(ts3) {
+      return ts3;
+    };
+    var peg$f1 = function(t, ts3) {
+      return t.concat(ts3);
+    };
+    var peg$f2 = function(a, b, c, d, e, f) {
+      return [{
+        type: "matrix",
+        a,
+        b,
+        c,
+        d,
+        e,
+        f
+      }];
+    };
+    var peg$f3 = function(tx, ty) {
+      var t = {
+        type: "translate",
+        tx
+      };
+      if (ty)
+        t.ty = ty;
+      return [t];
+    };
+    var peg$f4 = function(sx, sy) {
+      var s = {
+        type: "scale",
+        sx
+      };
+      if (sy)
+        s.sy = sy;
+      return [s];
+    };
+    var peg$f5 = function(angle, c) {
+      var r = {
+        type: "rotate",
+        angle
+      };
+      if (c) {
+        r.cx = c[0];
+        r.cy = c[1];
+      }
+      return [r];
+    };
+    var peg$f6 = function(angle) {
+      return [{
+        type: "skewX",
+        angle
+      }];
+    };
+    var peg$f7 = function(angle) {
+      return [{
+        type: "skewY",
+        angle
+      }];
+    };
+    var peg$f8 = function(f) {
+      return parseFloat(f.join(""));
+    };
+    var peg$f9 = function(i) {
+      return parseInt(i.join(""));
+    };
+    var peg$f10 = function(n) {
+      return n;
+    };
+    var peg$f11 = function(n1, n2) {
+      return [n1, n2];
+    };
+    var peg$f12 = function(ds) {
+      return ds.join("");
+    };
+    var peg$f13 = function(f, e) {
+      return [f, e || null].join("");
+    };
+    var peg$f14 = function(d, e) {
+      return [d, e].join("");
+    };
+    var peg$f15 = function(d1, d2) {
+      return [d1 ? d1.join("") : null, ".", d2.join("")].join("");
+    };
+    var peg$f16 = function(d) {
+      return d.join("");
+    };
+    var peg$f17 = function(s, d) {
+      return ["e", s, d.join("")].join("");
+    };
+    var peg$currPos = 0;
+    var peg$savedPos = 0;
+    var peg$posDetailsCache = [{
+      line: 1,
+      column: 1
+    }];
+    var peg$maxFailPos = 0;
+    var peg$maxFailExpected = [];
+    var peg$silentFails = 0;
+    var peg$result;
+    if ("startRule" in options) {
+      if (!(options.startRule in peg$startRuleFunctions)) {
+        throw new Error(`Can't start parsing from rule "` + options.startRule + '".');
+      }
+      peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
+    }
+    function text() {
+      return input.substring(peg$savedPos, peg$currPos);
+    }
+    function offset() {
+      return peg$savedPos;
+    }
+    function range() {
+      return {
+        source: peg$source,
+        start: peg$savedPos,
+        end: peg$currPos
+      };
+    }
+    function location() {
+      return peg$computeLocation(peg$savedPos, peg$currPos);
+    }
+    function expected(description, location2) {
+      location2 = location2 !== undefined ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);
+      throw peg$buildStructuredError([peg$otherExpectation(description)], input.substring(peg$savedPos, peg$currPos), location2);
+    }
+    function error(message, location2) {
+      location2 = location2 !== undefined ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);
+      throw peg$buildSimpleError(message, location2);
+    }
+    function peg$literalExpectation(text2, ignoreCase) {
+      return {
+        type: "literal",
+        text: text2,
+        ignoreCase
+      };
+    }
+    function peg$classExpectation(parts, inverted, ignoreCase) {
+      return {
+        type: "class",
+        parts,
+        inverted,
+        ignoreCase
+      };
+    }
+    function peg$anyExpectation() {
+      return {
+        type: "any"
+      };
+    }
+    function peg$endExpectation() {
+      return {
+        type: "end"
+      };
+    }
+    function peg$otherExpectation(description) {
+      return {
+        type: "other",
+        description
+      };
+    }
+    function peg$computePosDetails(pos) {
+      var details = peg$posDetailsCache[pos];
+      var p;
+      if (details) {
+        return details;
+      } else {
+        p = pos - 1;
+        while (!peg$posDetailsCache[p]) {
+          p--;
+        }
+        details = peg$posDetailsCache[p];
+        details = {
+          line: details.line,
+          column: details.column
+        };
+        while (p < pos) {
+          if (input.charCodeAt(p) === 10) {
+            details.line++;
+            details.column = 1;
+          } else {
+            details.column++;
+          }
+          p++;
+        }
+        peg$posDetailsCache[pos] = details;
+        return details;
+      }
+    }
+    function peg$computeLocation(startPos, endPos, offset2) {
+      var startPosDetails = peg$computePosDetails(startPos);
+      var endPosDetails = peg$computePosDetails(endPos);
+      var res = {
+        source: peg$source,
+        start: {
+          offset: startPos,
+          line: startPosDetails.line,
+          column: startPosDetails.column
+        },
+        end: {
+          offset: endPos,
+          line: endPosDetails.line,
+          column: endPosDetails.column
+        }
+      };
+      if (offset2 && peg$source && typeof peg$source.offset === "function") {
+        res.start = peg$source.offset(res.start);
+        res.end = peg$source.offset(res.end);
+      }
+      return res;
+    }
+    function peg$fail(expected2) {
+      if (peg$currPos < peg$maxFailPos) {
+        return;
+      }
+      if (peg$currPos > peg$maxFailPos) {
+        peg$maxFailPos = peg$currPos;
+        peg$maxFailExpected = [];
+      }
+      peg$maxFailExpected.push(expected2);
+    }
+    function peg$buildSimpleError(message, location2) {
+      return new peg$SyntaxError2(message, null, null, location2);
+    }
+    function peg$buildStructuredError(expected2, found, location2) {
+      return new peg$SyntaxError2(peg$SyntaxError2.buildMessage(expected2, found), expected2, found, location2);
+    }
+    function peg$parsetransformList() {
+      var s0, s1, s2, s3, s4;
+      s0 = peg$currPos;
+      s1 = [];
+      s2 = peg$parsewsp();
+      while (s2 !== peg$FAILED) {
+        s1.push(s2);
+        s2 = peg$parsewsp();
+      }
+      s2 = peg$parsetransforms();
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      s3 = [];
+      s4 = peg$parsewsp();
+      while (s4 !== peg$FAILED) {
+        s3.push(s4);
+        s4 = peg$parsewsp();
+      }
+      peg$savedPos = s0;
+      s0 = peg$f0(s2);
+      return s0;
+    }
+    function peg$parsetransforms() {
+      var s0, s1, s2, s3;
+      s0 = peg$currPos;
+      s1 = peg$parsetransform();
+      if (s1 !== peg$FAILED) {
+        s2 = [];
+        s3 = peg$parsecommaWsp();
+        if (s3 !== peg$FAILED) {
+          while (s3 !== peg$FAILED) {
+            s2.push(s3);
+            s3 = peg$parsecommaWsp();
+          }
+        } else {
+          s2 = peg$FAILED;
+        }
+        if (s2 !== peg$FAILED) {
+          s3 = peg$parsetransforms();
+          if (s3 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s0 = peg$f1(s1, s3);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$parsetransform();
+      }
+      return s0;
+    }
+    function peg$parsetransform() {
+      var s0;
+      s0 = peg$parsematrix();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parsetranslate();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parsescale();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parserotate();
+            if (s0 === peg$FAILED) {
+              s0 = peg$parseskewX();
+              if (s0 === peg$FAILED) {
+                s0 = peg$parseskewY();
+              }
+            }
+          }
+        }
+      }
+      return s0;
+    }
+    function peg$parsematrix() {
+      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17;
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 6) === peg$c0) {
+        s1 = peg$c0;
+        peg$currPos += 6;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e0);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = [];
+        s3 = peg$parsewsp();
+        while (s3 !== peg$FAILED) {
+          s2.push(s3);
+          s3 = peg$parsewsp();
+        }
+        if (input.charCodeAt(peg$currPos) === 40) {
+          s3 = peg$c1;
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e1);
+          }
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = [];
+          s5 = peg$parsewsp();
+          while (s5 !== peg$FAILED) {
+            s4.push(s5);
+            s5 = peg$parsewsp();
+          }
+          s5 = peg$parsenumber();
+          if (s5 !== peg$FAILED) {
+            s6 = peg$parsecommaWsp();
+            if (s6 !== peg$FAILED) {
+              s7 = peg$parsenumber();
+              if (s7 !== peg$FAILED) {
+                s8 = peg$parsecommaWsp();
+                if (s8 !== peg$FAILED) {
+                  s9 = peg$parsenumber();
+                  if (s9 !== peg$FAILED) {
+                    s10 = peg$parsecommaWsp();
+                    if (s10 !== peg$FAILED) {
+                      s11 = peg$parsenumber();
+                      if (s11 !== peg$FAILED) {
+                        s12 = peg$parsecommaWsp();
+                        if (s12 !== peg$FAILED) {
+                          s13 = peg$parsenumber();
+                          if (s13 !== peg$FAILED) {
+                            s14 = peg$parsecommaWsp();
+                            if (s14 !== peg$FAILED) {
+                              s15 = peg$parsenumber();
+                              if (s15 !== peg$FAILED) {
+                                s16 = [];
+                                s17 = peg$parsewsp();
+                                while (s17 !== peg$FAILED) {
+                                  s16.push(s17);
+                                  s17 = peg$parsewsp();
+                                }
+                                if (input.charCodeAt(peg$currPos) === 41) {
+                                  s17 = peg$c2;
+                                  peg$currPos++;
+                                } else {
+                                  s17 = peg$FAILED;
+                                  if (peg$silentFails === 0) {
+                                    peg$fail(peg$e2);
+                                  }
+                                }
+                                if (s17 !== peg$FAILED) {
+                                  peg$savedPos = s0;
+                                  s0 = peg$f2(s5, s7, s9, s11, s13, s15);
+                                } else {
+                                  peg$currPos = s0;
+                                  s0 = peg$FAILED;
+                                }
+                              } else {
+                                peg$currPos = s0;
+                                s0 = peg$FAILED;
+                              }
+                            } else {
+                              peg$currPos = s0;
+                              s0 = peg$FAILED;
+                            }
+                          } else {
+                            peg$currPos = s0;
+                            s0 = peg$FAILED;
+                          }
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parsetranslate() {
+      var s0, s1, s2, s3, s4, s5, s6, s7, s8;
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 9) === peg$c3) {
+        s1 = peg$c3;
+        peg$currPos += 9;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e3);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = [];
+        s3 = peg$parsewsp();
+        while (s3 !== peg$FAILED) {
+          s2.push(s3);
+          s3 = peg$parsewsp();
+        }
+        if (input.charCodeAt(peg$currPos) === 40) {
+          s3 = peg$c1;
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e1);
+          }
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = [];
+          s5 = peg$parsewsp();
+          while (s5 !== peg$FAILED) {
+            s4.push(s5);
+            s5 = peg$parsewsp();
+          }
+          s5 = peg$parsenumber();
+          if (s5 !== peg$FAILED) {
+            s6 = peg$parsecommaWspNumber();
+            if (s6 === peg$FAILED) {
+              s6 = null;
+            }
+            s7 = [];
+            s8 = peg$parsewsp();
+            while (s8 !== peg$FAILED) {
+              s7.push(s8);
+              s8 = peg$parsewsp();
+            }
+            if (input.charCodeAt(peg$currPos) === 41) {
+              s8 = peg$c2;
+              peg$currPos++;
+            } else {
+              s8 = peg$FAILED;
+              if (peg$silentFails === 0) {
+                peg$fail(peg$e2);
+              }
+            }
+            if (s8 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s0 = peg$f3(s5, s6);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parsescale() {
+      var s0, s1, s2, s3, s4, s5, s6, s7, s8;
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 5) === peg$c4) {
+        s1 = peg$c4;
+        peg$currPos += 5;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e4);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = [];
+        s3 = peg$parsewsp();
+        while (s3 !== peg$FAILED) {
+          s2.push(s3);
+          s3 = peg$parsewsp();
+        }
+        if (input.charCodeAt(peg$currPos) === 40) {
+          s3 = peg$c1;
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e1);
+          }
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = [];
+          s5 = peg$parsewsp();
+          while (s5 !== peg$FAILED) {
+            s4.push(s5);
+            s5 = peg$parsewsp();
+          }
+          s5 = peg$parsenumber();
+          if (s5 !== peg$FAILED) {
+            s6 = peg$parsecommaWspNumber();
+            if (s6 === peg$FAILED) {
+              s6 = null;
+            }
+            s7 = [];
+            s8 = peg$parsewsp();
+            while (s8 !== peg$FAILED) {
+              s7.push(s8);
+              s8 = peg$parsewsp();
+            }
+            if (input.charCodeAt(peg$currPos) === 41) {
+              s8 = peg$c2;
+              peg$currPos++;
+            } else {
+              s8 = peg$FAILED;
+              if (peg$silentFails === 0) {
+                peg$fail(peg$e2);
+              }
+            }
+            if (s8 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s0 = peg$f4(s5, s6);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parserotate() {
+      var s0, s1, s2, s3, s4, s5, s6, s7, s8;
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 6) === peg$c5) {
+        s1 = peg$c5;
+        peg$currPos += 6;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e5);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = [];
+        s3 = peg$parsewsp();
+        while (s3 !== peg$FAILED) {
+          s2.push(s3);
+          s3 = peg$parsewsp();
+        }
+        if (input.charCodeAt(peg$currPos) === 40) {
+          s3 = peg$c1;
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e1);
+          }
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = [];
+          s5 = peg$parsewsp();
+          while (s5 !== peg$FAILED) {
+            s4.push(s5);
+            s5 = peg$parsewsp();
+          }
+          s5 = peg$parsenumber();
+          if (s5 !== peg$FAILED) {
+            s6 = peg$parsecommaWspTwoNumbers();
+            if (s6 === peg$FAILED) {
+              s6 = null;
+            }
+            s7 = [];
+            s8 = peg$parsewsp();
+            while (s8 !== peg$FAILED) {
+              s7.push(s8);
+              s8 = peg$parsewsp();
+            }
+            if (input.charCodeAt(peg$currPos) === 41) {
+              s8 = peg$c2;
+              peg$currPos++;
+            } else {
+              s8 = peg$FAILED;
+              if (peg$silentFails === 0) {
+                peg$fail(peg$e2);
+              }
+            }
+            if (s8 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s0 = peg$f5(s5, s6);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parseskewX() {
+      var s0, s1, s2, s3, s4, s5, s6, s7;
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 5) === peg$c6) {
+        s1 = peg$c6;
+        peg$currPos += 5;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e6);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = [];
+        s3 = peg$parsewsp();
+        while (s3 !== peg$FAILED) {
+          s2.push(s3);
+          s3 = peg$parsewsp();
+        }
+        if (input.charCodeAt(peg$currPos) === 40) {
+          s3 = peg$c1;
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e1);
+          }
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = [];
+          s5 = peg$parsewsp();
+          while (s5 !== peg$FAILED) {
+            s4.push(s5);
+            s5 = peg$parsewsp();
+          }
+          s5 = peg$parsenumber();
+          if (s5 !== peg$FAILED) {
+            s6 = [];
+            s7 = peg$parsewsp();
+            while (s7 !== peg$FAILED) {
+              s6.push(s7);
+              s7 = peg$parsewsp();
+            }
+            if (input.charCodeAt(peg$currPos) === 41) {
+              s7 = peg$c2;
+              peg$currPos++;
+            } else {
+              s7 = peg$FAILED;
+              if (peg$silentFails === 0) {
+                peg$fail(peg$e2);
+              }
+            }
+            if (s7 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s0 = peg$f6(s5);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parseskewY() {
+      var s0, s1, s2, s3, s4, s5, s6, s7;
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 5) === peg$c7) {
+        s1 = peg$c7;
+        peg$currPos += 5;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e7);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = [];
+        s3 = peg$parsewsp();
+        while (s3 !== peg$FAILED) {
+          s2.push(s3);
+          s3 = peg$parsewsp();
+        }
+        if (input.charCodeAt(peg$currPos) === 40) {
+          s3 = peg$c1;
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e1);
+          }
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = [];
+          s5 = peg$parsewsp();
+          while (s5 !== peg$FAILED) {
+            s4.push(s5);
+            s5 = peg$parsewsp();
+          }
+          s5 = peg$parsenumber();
+          if (s5 !== peg$FAILED) {
+            s6 = [];
+            s7 = peg$parsewsp();
+            while (s7 !== peg$FAILED) {
+              s6.push(s7);
+              s7 = peg$parsewsp();
+            }
+            if (input.charCodeAt(peg$currPos) === 41) {
+              s7 = peg$c2;
+              peg$currPos++;
+            } else {
+              s7 = peg$FAILED;
+              if (peg$silentFails === 0) {
+                peg$fail(peg$e2);
+              }
+            }
+            if (s7 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s0 = peg$f7(s5);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parsenumber() {
+      var s0, s1, s2, s3;
+      s0 = peg$currPos;
+      s1 = peg$currPos;
+      s2 = peg$parsesign();
+      if (s2 === peg$FAILED) {
+        s2 = null;
+      }
+      s3 = peg$parsefloatingPointConstant();
+      if (s3 !== peg$FAILED) {
+        s2 = [s2, s3];
+        s1 = s2;
+      } else {
+        peg$currPos = s1;
+        s1 = peg$FAILED;
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$f8(s1);
+      }
+      s0 = s1;
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = peg$currPos;
+        s2 = peg$parsesign();
+        if (s2 === peg$FAILED) {
+          s2 = null;
+        }
+        s3 = peg$parseintegerConstant();
+        if (s3 !== peg$FAILED) {
+          s2 = [s2, s3];
+          s1 = s2;
+        } else {
+          peg$currPos = s1;
+          s1 = peg$FAILED;
+        }
+        if (s1 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s1 = peg$f9(s1);
+        }
+        s0 = s1;
+      }
+      return s0;
+    }
+    function peg$parsecommaWspNumber() {
+      var s0, s1, s2;
+      s0 = peg$currPos;
+      s1 = peg$parsecommaWsp();
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parsenumber();
+        if (s2 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f10(s2);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parsecommaWspTwoNumbers() {
+      var s0, s1, s2, s3, s4;
+      s0 = peg$currPos;
+      s1 = peg$parsecommaWsp();
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parsenumber();
+        if (s2 !== peg$FAILED) {
+          s3 = peg$parsecommaWsp();
+          if (s3 !== peg$FAILED) {
+            s4 = peg$parsenumber();
+            if (s4 !== peg$FAILED) {
+              peg$savedPos = s0;
+              s0 = peg$f11(s2, s4);
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parsecommaWsp() {
+      var s0, s1, s2, s3, s4;
+      s0 = peg$currPos;
+      s1 = [];
+      s2 = peg$parsewsp();
+      if (s2 !== peg$FAILED) {
+        while (s2 !== peg$FAILED) {
+          s1.push(s2);
+          s2 = peg$parsewsp();
+        }
+      } else {
+        s1 = peg$FAILED;
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parsecomma();
+        if (s2 === peg$FAILED) {
+          s2 = null;
+        }
+        s3 = [];
+        s4 = peg$parsewsp();
+        while (s4 !== peg$FAILED) {
+          s3.push(s4);
+          s4 = peg$parsewsp();
+        }
+        s1 = [s1, s2, s3];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = peg$parsecomma();
+        if (s1 !== peg$FAILED) {
+          s2 = [];
+          s3 = peg$parsewsp();
+          while (s3 !== peg$FAILED) {
+            s2.push(s3);
+            s3 = peg$parsewsp();
+          }
+          s1 = [s1, s2];
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      }
+      return s0;
+    }
+    function peg$parsecomma() {
+      var s0;
+      if (input.charCodeAt(peg$currPos) === 44) {
+        s0 = peg$c8;
+        peg$currPos++;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e8);
+        }
+      }
+      return s0;
+    }
+    function peg$parseintegerConstant() {
+      var s0, s1;
+      s0 = peg$currPos;
+      s1 = peg$parsedigitSequence();
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$f12(s1);
+      }
+      s0 = s1;
+      return s0;
+    }
+    function peg$parsefloatingPointConstant() {
+      var s0, s1, s2;
+      s0 = peg$currPos;
+      s1 = peg$parsefractionalConstant();
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parseexponent();
+        if (s2 === peg$FAILED) {
+          s2 = null;
+        }
+        peg$savedPos = s0;
+        s0 = peg$f13(s1, s2);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = peg$parsedigitSequence();
+        if (s1 !== peg$FAILED) {
+          s2 = peg$parseexponent();
+          if (s2 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s0 = peg$f14(s1, s2);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      }
+      return s0;
+    }
+    function peg$parsefractionalConstant() {
+      var s0, s1, s2, s3;
+      peg$silentFails++;
+      s0 = peg$currPos;
+      s1 = peg$parsedigitSequence();
+      if (s1 === peg$FAILED) {
+        s1 = null;
+      }
+      if (input.charCodeAt(peg$currPos) === 46) {
+        s2 = peg$c9;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e10);
+        }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parsedigitSequence();
+        if (s3 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f15(s1, s3);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = peg$parsedigitSequence();
+        if (s1 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 46) {
+            s2 = peg$c9;
+            peg$currPos++;
+          } else {
+            s2 = peg$FAILED;
+            if (peg$silentFails === 0) {
+              peg$fail(peg$e10);
+            }
+          }
+          if (s2 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s0 = peg$f16(s1);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      }
+      peg$silentFails--;
+      if (s0 === peg$FAILED) {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e9);
+        }
+      }
+      return s0;
+    }
+    function peg$parseexponent() {
+      var s0, s1, s2, s3;
+      s0 = peg$currPos;
+      if (peg$r0.test(input.charAt(peg$currPos))) {
+        s1 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e11);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parsesign();
+        if (s2 === peg$FAILED) {
+          s2 = null;
+        }
+        s3 = peg$parsedigitSequence();
+        if (s3 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f17(s2, s3);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parsesign() {
+      var s0;
+      if (peg$r1.test(input.charAt(peg$currPos))) {
+        s0 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e12);
+        }
+      }
+      return s0;
+    }
+    function peg$parsedigitSequence() {
+      var s0, s1;
+      s0 = [];
+      s1 = peg$parsedigit();
+      if (s1 !== peg$FAILED) {
+        while (s1 !== peg$FAILED) {
+          s0.push(s1);
+          s1 = peg$parsedigit();
+        }
+      } else {
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parsedigit() {
+      var s0;
+      if (peg$r2.test(input.charAt(peg$currPos))) {
+        s0 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e13);
+        }
+      }
+      return s0;
+    }
+    function peg$parsewsp() {
+      var s0;
+      if (peg$r3.test(input.charAt(peg$currPos))) {
+        s0 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e14);
+        }
+      }
+      return s0;
+    }
+    peg$result = peg$startRuleFunction();
+    if (peg$result !== peg$FAILED && peg$currPos === input.length) {
+      return peg$result;
+    } else {
+      if (peg$result !== peg$FAILED && peg$currPos < input.length) {
+        peg$fail(peg$endExpectation());
+      }
+      throw peg$buildStructuredError(peg$maxFailExpected, peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos));
+    }
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/fromTransformAttribute.js
+var require_fromTransformAttribute = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.fromTransformAttribute = fromTransformAttribute;
+  var _fromTransformAttribute = require_fromTransformAttribute_autogenerated();
+  function fromTransformAttribute(transformString) {
+    return (0, _fromTransformAttribute.parse)(transformString);
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/decompose.js
+var require_decompose = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.decomposeTSR = decomposeTSR;
+  var _scale = require_scale();
+  var _transform = require_transform();
+  function decomposeTSR(matrix, flipX = false, flipY = false) {
+    if (flipX) {
+      if (flipY) {
+        matrix = (0, _transform.compose)(matrix, (0, _scale.scale)(-1, -1));
+      } else {
+        matrix = (0, _transform.compose)(matrix, (0, _scale.scale)(1, -1));
+      }
+    } else if (flipY) {
+      matrix = (0, _transform.compose)(matrix, (0, _scale.scale)(-1, 1));
+    }
+    const a = matrix.a;
+    const b = matrix.b;
+    const c = matrix.c;
+    const d = matrix.d;
+    let scaleX, scaleY, rotation2;
+    if (a !== 0 || c !== 0) {
+      const hypotAc = Math.hypot(a, c);
+      scaleX = hypotAc;
+      scaleY = (a * d - b * c) / hypotAc;
+      const acos = Math.acos(a / hypotAc);
+      rotation2 = c > 0 ? -acos : acos;
+    } else if (b !== 0 || d !== 0) {
+      const hypotBd = Math.hypot(b, d);
+      scaleX = (a * d - b * c) / hypotBd;
+      scaleY = hypotBd;
+      const acos = Math.acos(b / hypotBd);
+      rotation2 = Math.PI / 2 + (d > 0 ? -acos : acos);
+    } else {
+      scaleX = 0;
+      scaleY = 0;
+      rotation2 = 0;
+    }
+    if (flipY) {
+      scaleX = -scaleX;
+    }
+    if (flipX) {
+      scaleY = -scaleY;
+    }
+    return {
+      translate: {
+        tx: matrix.e,
+        ty: matrix.f
+      },
+      scale: {
+        sx: scaleX,
+        sy: scaleY
+      },
+      rotation: {
+        angle: rotation2
+      }
+    };
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/flip.js
+var require_flip = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.flipOrigin = flipOrigin;
+  exports2.flipX = flipX;
+  exports2.flipY = flipY;
+  function flipX() {
+    return {
+      a: 1,
+      c: 0,
+      e: 0,
+      b: 0,
+      d: -1,
+      f: 0
+    };
+  }
+  function flipY() {
+    return {
+      a: -1,
+      c: 0,
+      e: 0,
+      b: 0,
+      d: 1,
+      f: 0
+    };
+  }
+  function flipOrigin() {
+    return {
+      a: -1,
+      c: 0,
+      e: 0,
+      b: 0,
+      d: -1,
+      f: 0
+    };
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/fromMovingPoints.js
+var require_fromMovingPoints = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  exports2.fromOneMovingPoint = fromOneMovingPoint;
+  exports2.fromTwoMovingPoints = fromTwoMovingPoints;
+  var _translate = require_translate();
+  var _applyToPoint = require_applyToPoint();
+  var _rotate = require_rotate();
+  var _scale = require_scale();
+  var _transform = require_transform();
+  function fromOneMovingPoint(startingPoint, endingPoint) {
+    const tx = endingPoint.x - startingPoint.x;
+    const ty = endingPoint.y - startingPoint.y;
+    return (0, _translate.translate)(tx, ty);
+  }
+  function fromTwoMovingPoints(startingPoint1, startingPoint2, endingPoint1, endingPoint2) {
+    const translationMatrix = fromOneMovingPoint(startingPoint1, endingPoint1);
+    const pointA = (0, _applyToPoint.applyToPoint)(translationMatrix, startingPoint2);
+    const center = endingPoint1;
+    const pointB = endingPoint2;
+    const angle = Math.atan2(pointB.y - center.y, pointB.x - center.x) - Math.atan2(pointA.y - center.y, pointA.x - center.x);
+    const rotationMatrix = (0, _rotate.rotate)(angle, center.x, center.y);
+    const d1 = Math.sqrt(Math.pow(pointA.x - center.x, 2) + Math.pow(pointA.y - center.y, 2));
+    const d2 = Math.sqrt(Math.pow(pointB.x - center.x, 2) + Math.pow(pointB.y - center.y, 2));
+    const scalingLevel = d2 / d1;
+    const scalingMatrix = (0, _scale.scale)(scalingLevel, scalingLevel, center.x, center.y);
+    return (0, _transform.compose)([translationMatrix, scalingMatrix, rotationMatrix]);
+  }
+});
+
+// node_modules/circuit-to-svg/node_modules/transformation-matrix/build-commonjs/index.js
+var require_build_commonjs = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", {
+    value: true
+  });
+  var _applyToPoint = require_applyToPoint();
+  Object.keys(_applyToPoint).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _applyToPoint[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _applyToPoint[key];
+      }
+    });
+  });
+  var _fromObject = require_fromObject();
+  Object.keys(_fromObject).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _fromObject[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _fromObject[key];
+      }
+    });
+  });
+  var _fromString = require_fromString();
+  Object.keys(_fromString).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _fromString[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _fromString[key];
+      }
+    });
+  });
+  var _identity = require_identity();
+  Object.keys(_identity).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _identity[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _identity[key];
+      }
+    });
+  });
+  var _inverse = require_inverse();
+  Object.keys(_inverse).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _inverse[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _inverse[key];
+      }
+    });
+  });
+  var _isAffineMatrix = require_isAffineMatrix();
+  Object.keys(_isAffineMatrix).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _isAffineMatrix[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _isAffineMatrix[key];
+      }
+    });
+  });
+  var _rotate = require_rotate();
+  Object.keys(_rotate).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _rotate[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _rotate[key];
+      }
+    });
+  });
+  var _scale = require_scale();
+  Object.keys(_scale).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _scale[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _scale[key];
+      }
+    });
+  });
+  var _shear = require_shear();
+  Object.keys(_shear).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _shear[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _shear[key];
+      }
+    });
+  });
+  var _skew = require_skew();
+  Object.keys(_skew).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _skew[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _skew[key];
+      }
+    });
+  });
+  var _toString = require_toString();
+  Object.keys(_toString).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _toString[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _toString[key];
+      }
+    });
+  });
+  var _transform = require_transform();
+  Object.keys(_transform).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _transform[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _transform[key];
+      }
+    });
+  });
+  var _translate = require_translate();
+  Object.keys(_translate).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _translate[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _translate[key];
+      }
+    });
+  });
+  var _fromTriangles = require_fromTriangles();
+  Object.keys(_fromTriangles).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _fromTriangles[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _fromTriangles[key];
+      }
+    });
+  });
+  var _smoothMatrix = require_smoothMatrix();
+  Object.keys(_smoothMatrix).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _smoothMatrix[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _smoothMatrix[key];
+      }
+    });
+  });
+  var _fromDefinition = require_fromDefinition();
+  Object.keys(_fromDefinition).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _fromDefinition[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _fromDefinition[key];
+      }
+    });
+  });
+  var _fromTransformAttribute = require_fromTransformAttribute();
+  Object.keys(_fromTransformAttribute).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _fromTransformAttribute[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _fromTransformAttribute[key];
+      }
+    });
+  });
+  var _decompose = require_decompose();
+  Object.keys(_decompose).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _decompose[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _decompose[key];
+      }
+    });
+  });
+  var _flip = require_flip();
+  Object.keys(_flip).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _flip[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _flip[key];
+      }
+    });
+  });
+  var _fromMovingPoints = require_fromMovingPoints();
+  Object.keys(_fromMovingPoints).forEach(function(key) {
+    if (key === "default" || key === "__esModule")
+      return;
+    if (key in exports2 && exports2[key] === _fromMovingPoints[key])
+      return;
+    Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: function() {
+        return _fromMovingPoints[key];
+      }
+    });
+  });
+});
+
 // node_modules/transformation-matrix/build-commonjs/applyToPoint.js
-var require_applyToPoint = __commonJS((exports2) => {
+var require_applyToPoint2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
   exports2.applyToPoint = applyToPoint;
   exports2.applyToPoints = applyToPoints;
-  function applyToPoint(matrix, point2) {
-    return Array.isArray(point2) ? [matrix.a * point2[0] + matrix.c * point2[1] + matrix.e, matrix.b * point2[0] + matrix.d * point2[1] + matrix.f] : {
-      x: matrix.a * point2.x + matrix.c * point2.y + matrix.e,
-      y: matrix.b * point2.x + matrix.d * point2.y + matrix.f
+  function applyToPoint(matrix, point4) {
+    return Array.isArray(point4) ? [matrix.a * point4[0] + matrix.c * point4[1] + matrix.e, matrix.b * point4[0] + matrix.d * point4[1] + matrix.f] : {
+      x: matrix.a * point4.x + matrix.c * point4.y + matrix.e,
+      y: matrix.b * point4.x + matrix.d * point4.y + matrix.f
     };
   }
   function applyToPoints(matrix, points) {
-    return points.map((point2) => applyToPoint(matrix, point2));
+    return points.map((point4) => applyToPoint(matrix, point4));
   }
 });
 
 // node_modules/transformation-matrix/build-commonjs/fromObject.js
-var require_fromObject = __commonJS((exports2) => {
+var require_fromObject2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
@@ -227456,13 +229659,37 @@ var require_fromObject = __commonJS((exports2) => {
 });
 
 // node_modules/transformation-matrix/build-commonjs/fromString.js
-var require_fromString = __commonJS((exports2) => {
+var require_fromString2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
   exports2.fromString = fromString;
+  exports2.fromStringLegacy = fromStringLegacy;
   var matrixRegex = /^matrix\(\s*([0-9_+-.e]+)\s*,\s*([0-9_+-.e]+)\s*,\s*([0-9_+-.e]+)\s*,\s*([0-9_+-.e]+)\s*,\s*([0-9_+-.e]+)\s*,\s*([0-9_+-.e]+)\s*\)$/i;
   function fromString(string) {
+    const parseFloatOrThrow = (number) => {
+      const n = parseFloat(number);
+      if (Number.isFinite(n))
+        return n;
+      throw new Error(`'${string}' is not a matrix`);
+    };
+    const prefix = string.substring(0, 7).toLowerCase();
+    const suffix = string.substring(string.length - 1);
+    const body = string.substring(7, string.length - 1);
+    const elements = body.split(",");
+    if (prefix === "matrix(" && suffix === ")" && elements.length === 6) {
+      return {
+        a: parseFloatOrThrow(elements[0]),
+        b: parseFloatOrThrow(elements[1]),
+        c: parseFloatOrThrow(elements[2]),
+        d: parseFloatOrThrow(elements[3]),
+        e: parseFloatOrThrow(elements[4]),
+        f: parseFloatOrThrow(elements[5])
+      };
+    }
+    throw new Error(`'${string}' is not a matrix`);
+  }
+  function fromStringLegacy(string) {
     const parsed = string.match(matrixRegex);
     if (parsed === null || parsed.length < 7)
       throw new Error(`'${string}' is not a matrix`);
@@ -227478,7 +229705,7 @@ var require_fromString = __commonJS((exports2) => {
 });
 
 // node_modules/transformation-matrix/build-commonjs/identity.js
-var require_identity = __commonJS((exports2) => {
+var require_identity2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
@@ -227496,7 +229723,7 @@ var require_identity = __commonJS((exports2) => {
 });
 
 // node_modules/transformation-matrix/build-commonjs/inverse.js
-var require_inverse = __commonJS((exports2) => {
+var require_inverse2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
@@ -227523,7 +229750,7 @@ var require_inverse = __commonJS((exports2) => {
 });
 
 // node_modules/transformation-matrix/build-commonjs/utils.js
-var require_utils6 = __commonJS((exports2) => {
+var require_utils7 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
@@ -227546,19 +229773,19 @@ var require_utils6 = __commonJS((exports2) => {
 });
 
 // node_modules/transformation-matrix/build-commonjs/isAffineMatrix.js
-var require_isAffineMatrix = __commonJS((exports2) => {
+var require_isAffineMatrix2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
   exports2.isAffineMatrix = isAffineMatrix;
-  var _utils = require_utils6();
+  var _utils = require_utils7();
   function isAffineMatrix(object) {
     return (0, _utils.isObject)(object) && "a" in object && (0, _utils.isNumeric)(object.a) && "b" in object && (0, _utils.isNumeric)(object.b) && "c" in object && (0, _utils.isNumeric)(object.c) && "d" in object && (0, _utils.isNumeric)(object.d) && "e" in object && (0, _utils.isNumeric)(object.e) && "f" in object && (0, _utils.isNumeric)(object.f);
   }
 });
 
 // node_modules/transformation-matrix/build-commonjs/translate.js
-var require_translate = __commonJS((exports2) => {
+var require_translate2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
@@ -227576,7 +229803,7 @@ var require_translate = __commonJS((exports2) => {
 });
 
 // node_modules/transformation-matrix/build-commonjs/transform.js
-var require_transform = __commonJS((exports2) => {
+var require_transform2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
@@ -227614,15 +229841,15 @@ var require_transform = __commonJS((exports2) => {
 });
 
 // node_modules/transformation-matrix/build-commonjs/rotate.js
-var require_rotate = __commonJS((exports2) => {
+var require_rotate2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
   exports2.rotate = rotate;
   exports2.rotateDEG = rotateDEG;
-  var _utils = require_utils6();
-  var _translate = require_translate();
-  var _transform = require_transform();
+  var _utils = require_utils7();
+  var _translate = require_translate2();
+  var _transform = require_transform2();
   var {
     cos,
     sin,
@@ -227650,14 +229877,14 @@ var require_rotate = __commonJS((exports2) => {
 });
 
 // node_modules/transformation-matrix/build-commonjs/scale.js
-var require_scale = __commonJS((exports2) => {
+var require_scale2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
   exports2.scale = scale;
-  var _utils = require_utils6();
-  var _translate = require_translate();
-  var _transform = require_transform();
+  var _utils = require_utils7();
+  var _translate = require_translate2();
+  var _transform = require_transform2();
   function scale(sx, sy = undefined, cx = undefined, cy = undefined) {
     if ((0, _utils.isUndefined)(sy))
       sy = sx;
@@ -227677,7 +229904,7 @@ var require_scale = __commonJS((exports2) => {
 });
 
 // node_modules/transformation-matrix/build-commonjs/shear.js
-var require_shear = __commonJS((exports2) => {
+var require_shear2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
@@ -227695,7 +229922,7 @@ var require_shear = __commonJS((exports2) => {
 });
 
 // node_modules/transformation-matrix/build-commonjs/skew.js
-var require_skew = __commonJS((exports2) => {
+var require_skew2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
@@ -227720,7 +229947,7 @@ var require_skew = __commonJS((exports2) => {
 });
 
 // node_modules/transformation-matrix/build-commonjs/toString.js
-var require_toString = __commonJS((exports2) => {
+var require_toString2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
@@ -227739,7 +229966,7 @@ var require_toString = __commonJS((exports2) => {
 });
 
 // node_modules/transformation-matrix/build-commonjs/smoothMatrix.js
-var require_smoothMatrix = __commonJS((exports2) => {
+var require_smoothMatrix2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
@@ -227757,14 +229984,14 @@ var require_smoothMatrix = __commonJS((exports2) => {
 });
 
 // node_modules/transformation-matrix/build-commonjs/fromTriangles.js
-var require_fromTriangles = __commonJS((exports2) => {
+var require_fromTriangles2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
   exports2.fromTriangles = fromTriangles;
-  var _inverse = require_inverse();
-  var _transform = require_transform();
-  var _smoothMatrix = require_smoothMatrix();
+  var _inverse = require_inverse2();
+  var _transform = require_transform2();
+  var _smoothMatrix = require_smoothMatrix2();
   function fromTriangles(t1, t2) {
     const px1 = t1[0].x != null ? t1[0].x : t1[0][0];
     const py1 = t1[0].y != null ? t1[0].y : t1[0][1];
@@ -227801,17 +230028,17 @@ var require_fromTriangles = __commonJS((exports2) => {
 });
 
 // node_modules/transformation-matrix/build-commonjs/fromDefinition.js
-var require_fromDefinition = __commonJS((exports2) => {
+var require_fromDefinition2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
   exports2.fromDefinition = fromDefinition;
-  var _fromObject = require_fromObject();
-  var _translate = require_translate();
-  var _scale = require_scale();
-  var _rotate = require_rotate();
-  var _skew = require_skew();
-  var _shear = require_shear();
+  var _fromObject = require_fromObject2();
+  var _translate = require_translate2();
+  var _scale = require_scale2();
+  var _rotate = require_rotate2();
+  var _skew = require_skew2();
+  var _shear = require_shear2();
   function fromDefinition(definitionOrArrayOfDefinition) {
     return Array.isArray(definitionOrArrayOfDefinition) ? definitionOrArrayOfDefinition.map(mapper) : mapper(definitionOrArrayOfDefinition);
     function mapper(descriptor) {
@@ -227861,10 +230088,11 @@ var require_fromDefinition = __commonJS((exports2) => {
 });
 
 // node_modules/transformation-matrix/build-commonjs/fromTransformAttribute.autogenerated.js
-var require_fromTransformAttribute_autogenerated = __commonJS((exports2) => {
+var require_fromTransformAttribute_autogenerated2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
+  exports2.StartRules = undefined;
   exports2.SyntaxError = peg$SyntaxError2;
   exports2.parse = peg$parse;
   function peg$subclass2(child, parent) {
@@ -228121,17 +230349,17 @@ var require_fromTransformAttribute_autogenerated = __commonJS((exports2) => {
     var peg$f17 = function(s, d) {
       return ["e", s, d.join("")].join("");
     };
-    var peg$currPos = 0;
-    var peg$savedPos = 0;
+    var peg$currPos = options.peg$currPos | 0;
+    var peg$savedPos = peg$currPos;
     var peg$posDetailsCache = [{
       line: 1,
       column: 1
     }];
-    var peg$maxFailPos = 0;
-    var peg$maxFailExpected = [];
-    var peg$silentFails = 0;
+    var peg$maxFailPos = peg$currPos;
+    var peg$maxFailExpected = options.peg$maxFailExpected || [];
+    var peg$silentFails = options.peg$silentFails | 0;
     var peg$result;
-    if ("startRule" in options) {
+    if (options.startRule) {
       if (!(options.startRule in peg$startRuleFunctions)) {
         throw new Error(`Can't start parsing from rule "` + options.startRule + '".');
       }
@@ -228198,9 +230426,11 @@ var require_fromTransformAttribute_autogenerated = __commonJS((exports2) => {
       if (details) {
         return details;
       } else {
-        p = pos - 1;
-        while (!peg$posDetailsCache[p]) {
-          p--;
+        if (pos >= peg$posDetailsCache.length) {
+          p = peg$posDetailsCache.length - 1;
+        } else {
+          p = pos;
+          while (!peg$posDetailsCache[--p]) {}
         }
         details = peg$posDetailsCache[p];
         details = {
@@ -229116,8 +231346,8 @@ var require_fromTransformAttribute_autogenerated = __commonJS((exports2) => {
     function peg$parseexponent() {
       var s0, s1, s2, s3;
       s0 = peg$currPos;
-      if (peg$r0.test(input.charAt(peg$currPos))) {
-        s1 = input.charAt(peg$currPos);
+      s1 = input.charAt(peg$currPos);
+      if (peg$r0.test(s1)) {
         peg$currPos++;
       } else {
         s1 = peg$FAILED;
@@ -229146,8 +231376,8 @@ var require_fromTransformAttribute_autogenerated = __commonJS((exports2) => {
     }
     function peg$parsesign() {
       var s0;
-      if (peg$r1.test(input.charAt(peg$currPos))) {
-        s0 = input.charAt(peg$currPos);
+      s0 = input.charAt(peg$currPos);
+      if (peg$r1.test(s0)) {
         peg$currPos++;
       } else {
         s0 = peg$FAILED;
@@ -229173,8 +231403,8 @@ var require_fromTransformAttribute_autogenerated = __commonJS((exports2) => {
     }
     function peg$parsedigit() {
       var s0;
-      if (peg$r2.test(input.charAt(peg$currPos))) {
-        s0 = input.charAt(peg$currPos);
+      s0 = input.charAt(peg$currPos);
+      if (peg$r2.test(s0)) {
         peg$currPos++;
       } else {
         s0 = peg$FAILED;
@@ -229186,8 +231416,8 @@ var require_fromTransformAttribute_autogenerated = __commonJS((exports2) => {
     }
     function peg$parsewsp() {
       var s0;
-      if (peg$r3.test(input.charAt(peg$currPos))) {
-        s0 = input.charAt(peg$currPos);
+      s0 = input.charAt(peg$currPos);
+      if (peg$r3.test(s0)) {
         peg$currPos++;
       } else {
         s0 = peg$FAILED;
@@ -229198,6 +231428,15 @@ var require_fromTransformAttribute_autogenerated = __commonJS((exports2) => {
       return s0;
     }
     peg$result = peg$startRuleFunction();
+    if (options.peg$library) {
+      return {
+        peg$result,
+        peg$currPos,
+        peg$FAILED,
+        peg$maxFailExpected,
+        peg$maxFailPos
+      };
+    }
     if (peg$result !== peg$FAILED && peg$currPos === input.length) {
       return peg$result;
     } else {
@@ -229207,28 +231446,29 @@ var require_fromTransformAttribute_autogenerated = __commonJS((exports2) => {
       throw peg$buildStructuredError(peg$maxFailExpected, peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos));
     }
   }
+  var peg$allowedStartRules = exports2.StartRules = ["transformList"];
 });
 
 // node_modules/transformation-matrix/build-commonjs/fromTransformAttribute.js
-var require_fromTransformAttribute = __commonJS((exports2) => {
+var require_fromTransformAttribute2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
   exports2.fromTransformAttribute = fromTransformAttribute;
-  var _fromTransformAttribute = require_fromTransformAttribute_autogenerated();
+  var _fromTransformAttribute = require_fromTransformAttribute_autogenerated2();
   function fromTransformAttribute(transformString) {
     return (0, _fromTransformAttribute.parse)(transformString);
   }
 });
 
 // node_modules/transformation-matrix/build-commonjs/decompose.js
-var require_decompose = __commonJS((exports2) => {
+var require_decompose2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
   exports2.decomposeTSR = decomposeTSR;
-  var _scale = require_scale();
-  var _transform = require_transform();
+  var _scale = require_scale2();
+  var _transform = require_transform2();
   function decomposeTSR(matrix, flipX = false, flipY = false) {
     if (flipX) {
       if (flipY) {
@@ -229243,23 +231483,23 @@ var require_decompose = __commonJS((exports2) => {
     const b = matrix.b;
     const c = matrix.c;
     const d = matrix.d;
-    let scaleX, scaleY, rotation2;
+    let scaleX, scaleY, rotation3;
     if (a !== 0 || c !== 0) {
       const hypotAc = Math.hypot(a, c);
       scaleX = hypotAc;
       scaleY = (a * d - b * c) / hypotAc;
       const acos = Math.acos(a / hypotAc);
-      rotation2 = c > 0 ? -acos : acos;
+      rotation3 = c > 0 ? -acos : acos;
     } else if (b !== 0 || d !== 0) {
       const hypotBd = Math.hypot(b, d);
       scaleX = (a * d - b * c) / hypotBd;
       scaleY = hypotBd;
       const acos = Math.acos(b / hypotBd);
-      rotation2 = Math.PI / 2 + (d > 0 ? -acos : acos);
+      rotation3 = Math.PI / 2 + (d > 0 ? -acos : acos);
     } else {
       scaleX = 0;
       scaleY = 0;
-      rotation2 = 0;
+      rotation3 = 0;
     }
     if (flipY) {
       scaleX = -scaleX;
@@ -229277,14 +231517,14 @@ var require_decompose = __commonJS((exports2) => {
         sy: scaleY
       },
       rotation: {
-        angle: rotation2
+        angle: rotation3
       }
     };
   }
 });
 
 // node_modules/transformation-matrix/build-commonjs/flip.js
-var require_flip = __commonJS((exports2) => {
+var require_flip2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
@@ -229324,17 +231564,17 @@ var require_flip = __commonJS((exports2) => {
 });
 
 // node_modules/transformation-matrix/build-commonjs/fromMovingPoints.js
-var require_fromMovingPoints = __commonJS((exports2) => {
+var require_fromMovingPoints2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
   exports2.fromOneMovingPoint = fromOneMovingPoint;
   exports2.fromTwoMovingPoints = fromTwoMovingPoints;
-  var _translate = require_translate();
-  var _applyToPoint = require_applyToPoint();
-  var _rotate = require_rotate();
-  var _scale = require_scale();
-  var _transform = require_transform();
+  var _translate = require_translate2();
+  var _applyToPoint = require_applyToPoint2();
+  var _rotate = require_rotate2();
+  var _scale = require_scale2();
+  var _transform = require_transform2();
   function fromOneMovingPoint(startingPoint, endingPoint) {
     const tx = endingPoint.x - startingPoint.x;
     const ty = endingPoint.y - startingPoint.y;
@@ -229356,11 +231596,11 @@ var require_fromMovingPoints = __commonJS((exports2) => {
 });
 
 // node_modules/transformation-matrix/build-commonjs/index.js
-var require_build_commonjs = __commonJS((exports2) => {
+var require_build_commonjs2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", {
     value: true
   });
-  var _applyToPoint = require_applyToPoint();
+  var _applyToPoint = require_applyToPoint2();
   Object.keys(_applyToPoint).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229373,7 +231613,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _fromObject = require_fromObject();
+  var _fromObject = require_fromObject2();
   Object.keys(_fromObject).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229386,7 +231626,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _fromString = require_fromString();
+  var _fromString = require_fromString2();
   Object.keys(_fromString).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229399,7 +231639,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _identity = require_identity();
+  var _identity = require_identity2();
   Object.keys(_identity).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229412,7 +231652,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _inverse = require_inverse();
+  var _inverse = require_inverse2();
   Object.keys(_inverse).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229425,7 +231665,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _isAffineMatrix = require_isAffineMatrix();
+  var _isAffineMatrix = require_isAffineMatrix2();
   Object.keys(_isAffineMatrix).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229438,7 +231678,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _rotate = require_rotate();
+  var _rotate = require_rotate2();
   Object.keys(_rotate).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229451,7 +231691,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _scale = require_scale();
+  var _scale = require_scale2();
   Object.keys(_scale).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229464,7 +231704,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _shear = require_shear();
+  var _shear = require_shear2();
   Object.keys(_shear).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229477,7 +231717,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _skew = require_skew();
+  var _skew = require_skew2();
   Object.keys(_skew).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229490,7 +231730,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _toString = require_toString();
+  var _toString = require_toString2();
   Object.keys(_toString).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229503,7 +231743,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _transform = require_transform();
+  var _transform = require_transform2();
   Object.keys(_transform).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229516,7 +231756,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _translate = require_translate();
+  var _translate = require_translate2();
   Object.keys(_translate).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229529,7 +231769,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _fromTriangles = require_fromTriangles();
+  var _fromTriangles = require_fromTriangles2();
   Object.keys(_fromTriangles).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229542,7 +231782,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _smoothMatrix = require_smoothMatrix();
+  var _smoothMatrix = require_smoothMatrix2();
   Object.keys(_smoothMatrix).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229555,7 +231795,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _fromDefinition = require_fromDefinition();
+  var _fromDefinition = require_fromDefinition2();
   Object.keys(_fromDefinition).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229568,7 +231808,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _fromTransformAttribute = require_fromTransformAttribute();
+  var _fromTransformAttribute = require_fromTransformAttribute2();
   Object.keys(_fromTransformAttribute).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229581,7 +231821,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _decompose = require_decompose();
+  var _decompose = require_decompose2();
   Object.keys(_decompose).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229594,7 +231834,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _flip = require_flip();
+  var _flip = require_flip2();
   Object.keys(_flip).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -229607,7 +231847,7 @@ var require_build_commonjs = __commonJS((exports2) => {
       }
     });
   });
-  var _fromMovingPoints = require_fromMovingPoints();
+  var _fromMovingPoints = require_fromMovingPoints2();
   Object.keys(_fromMovingPoints).forEach(function(key) {
     if (key === "default" || key === "__esModule")
       return;
@@ -238299,7 +240539,7 @@ var getGlobalDepsInstallCommand = (packageManager, deps) => {
 import { execSync as execSync2 } from "node:child_process";
 var import_semver2 = __toESM2(require_semver2(), 1);
 // package.json
-var version = "0.1.150";
+var version = "0.1.151";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -238307,14 +240547,14 @@ var package_default = {
   devDependencies: {
     "@babel/standalone": "^7.26.9",
     "@biomejs/biome": "^1.9.4",
-    "@tscircuit/circuit-json-util": "^0.0.47",
+    "@tscircuit/circuit-json-util": "^0.0.50",
     "@tscircuit/fake-snippets": "^0.0.87",
     "@tscircuit/file-server": "^0.0.24",
     "@tscircuit/math-utils": "^0.0.18",
-    "@tscircuit/props": "^0.0.242",
+    "@tscircuit/props": "^0.0.244",
     "@tscircuit/runframe": "^0.0.614",
     "@tscircuit/schematic-match-adapt": "^0.0.22",
-    "@tscircuit/simple-3d-svg": "^0.0.10",
+    "@tscircuit/simple-3d-svg": "^0.0.22",
     "@types/bun": "^1.2.2",
     "@types/configstore": "^6.0.2",
     "@types/debug": "^4.1.12",
@@ -250865,22 +253105,88 @@ expectTypesMatch2(true);
 expectStringUnionsMatch2(true);
 
 // node_modules/@tscircuit/circuit-json-util/dist/index.js
-var import_transformation_matrix = __toESM2(require_build_commonjs(), 1);
+var import_transformation_matrix = __toESM2(require_build_commonjs2(), 1);
 
 // node_modules/parsel-js/dist/parsel.min.js
 var t = new Set(["combinator", "comma"]);
 var n = new Set(["not", "is", "where", "has", "matches", "-moz-any", "-webkit-any", "nth-child", "nth-last-child"]);
 
 // node_modules/@tscircuit/circuit-json-util/dist/index.js
-var cju = (soup, options = {}) => {
-  let internalStore = soup._internal_store;
+function connect(map, a, b) {
+  if (!a || !b)
+    return;
+  let setA = map.get(a);
+  if (!setA) {
+    setA = /* @__PURE__ */ new Set;
+    map.set(a, setA);
+  }
+  setA.add(b);
+  let setB = map.get(b);
+  if (!setB) {
+    setB = /* @__PURE__ */ new Set;
+    map.set(b, setB);
+  }
+  setB.add(a);
+}
+function buildSubtree(soup, opts) {
+  if (!opts.subcircuit_id && !opts.source_group_id)
+    return [...soup];
+  const idMap = /* @__PURE__ */ new Map;
+  for (const elm of soup) {
+    const idVal = elm[`${elm.type}_id`];
+    if (typeof idVal === "string") {
+      idMap.set(idVal, elm);
+    }
+  }
+  const adj = /* @__PURE__ */ new Map;
+  for (const elm of soup) {
+    const entries = Object.entries(elm);
+    for (const [key, val] of entries) {
+      if (key.endsWith("_id") && typeof val === "string") {
+        const other = idMap.get(val);
+        connect(adj, elm, other);
+      } else if (key.endsWith("_ids") && Array.isArray(val)) {
+        for (const v of val) {
+          if (typeof v === "string") {
+            const other = idMap.get(v);
+            connect(adj, elm, other);
+          }
+        }
+      }
+    }
+  }
+  const queue = [];
+  const included = /* @__PURE__ */ new Set;
+  for (const elm of soup) {
+    if (opts.subcircuit_id && elm.subcircuit_id === opts.subcircuit_id || opts.source_group_id && (elm.source_group_id === opts.source_group_id || Array.isArray(elm.member_source_group_ids) && elm.member_source_group_ids.includes(opts.source_group_id))) {
+      queue.push(elm);
+      included.add(elm);
+    }
+  }
+  while (queue.length > 0) {
+    const elm = queue.shift();
+    const neighbors = adj.get(elm);
+    if (!neighbors)
+      continue;
+    for (const n2 of neighbors) {
+      if (!included.has(n2)) {
+        included.add(n2);
+        queue.push(n2);
+      }
+    }
+  }
+  return soup.filter((e) => included.has(e));
+}
+var cju = (circuitJsonInput, options = {}) => {
+  const circuitJson = circuitJsonInput;
+  let internalStore = circuitJson._internal_store;
   if (!internalStore) {
     internalStore = {
       counts: {},
       editCount: 0
     };
-    soup._internal_store = internalStore;
-    for (const elm of soup) {
+    circuitJson._internal_store = internalStore;
+    for (const elm of circuitJson) {
       const type = elm.type;
       const idVal = elm[`${type}_id`];
       if (!idVal)
@@ -250895,16 +253201,19 @@ var cju = (soup, options = {}) => {
     get: (proxy_target, prop) => {
       if (prop === "toArray") {
         return () => {
-          soup.editCount = internalStore.editCount;
-          return soup;
+          circuitJson.editCount = internalStore.editCount;
+          return circuitJson;
         };
       }
       if (prop === "editCount") {
         return internalStore.editCount;
       }
+      if (prop === "subtree") {
+        return (opts) => cju(buildSubtree(circuitJson, opts), options);
+      }
       const component_type = prop;
       return {
-        get: (id) => soup.find((e) => e.type === component_type && e[`${component_type}_id`] === id),
+        get: (id) => circuitJson.find((e) => e.type === component_type && e[`${component_type}_id`] === id),
         getUsing: (using) => {
           const keys = Object.keys(using);
           if (keys.length !== 1) {
@@ -250912,18 +253221,18 @@ var cju = (soup, options = {}) => {
           }
           const join_key = keys[0];
           const join_type = join_key.replace("_id", "");
-          const joiner = soup.find((e) => e.type === join_type && e[join_key] === using[join_key]);
+          const joiner = circuitJson.find((e) => e.type === join_type && e[join_key] === using[join_key]);
           if (!joiner)
             return null;
-          return soup.find((e) => e.type === component_type && e[`${component_type}_id`] === joiner[`${component_type}_id`]);
+          return circuitJson.find((e) => e.type === component_type && e[`${component_type}_id`] === joiner[`${component_type}_id`]);
         },
         getWhere: (where) => {
           const keys = Object.keys(where);
-          return soup.find((e) => e.type === component_type && keys.every((key) => e[key] === where[key]));
+          return circuitJson.find((e) => e.type === component_type && keys.every((key) => e[key] === where[key]));
         },
         list: (where) => {
           const keys = !where ? [] : Object.keys(where);
-          return soup.filter((e) => e.type === component_type && keys.every((key) => e[key] === where[key]));
+          return circuitJson.filter((e) => e.type === component_type && keys.every((key) => e[key] === where[key]));
         },
         insert: (elm) => {
           internalStore.counts[component_type] ??= -1;
@@ -250938,19 +253247,19 @@ var cju = (soup, options = {}) => {
             const parser = exports_dist[component_type] ?? any_soup_element2;
             parser.parse(newElm);
           }
-          soup.push(newElm);
+          circuitJson.push(newElm);
           internalStore.editCount++;
           return newElm;
         },
         delete: (id) => {
-          const elm = soup.find((e) => e[`${component_type}_id`] === id);
+          const elm = circuitJson.find((e) => e[`${component_type}_id`] === id);
           if (!elm)
             return;
-          soup.splice(soup.indexOf(elm), 1);
+          circuitJson.splice(circuitJson.indexOf(elm), 1);
           internalStore.editCount++;
         },
         update: (id, newProps) => {
-          const elm = soup.find((e) => e.type === component_type && e[`${component_type}_id`] === id);
+          const elm = circuitJson.find((e) => e.type === component_type && e[`${component_type}_id`] === id);
           if (!elm)
             return null;
           Object.assign(elm, newProps);
@@ -250959,21 +253268,21 @@ var cju = (soup, options = {}) => {
         },
         select: (selector) => {
           if (component_type === "source_component") {
-            return soup.find((e) => e.type === "source_component" && e.name === selector.replace(/\./g, ""));
+            return circuitJson.find((e) => e.type === "source_component" && e.name === selector.replace(/\./g, ""));
           } else if (component_type === "pcb_port" || component_type === "source_port" || component_type === "schematic_port") {
             const [component_name, port_selector] = selector.replace(/\./g, "").split(/[\s\>]+/);
-            const source_component = soup.find((e) => e.type === "source_component" && e.name === component_name);
+            const source_component = circuitJson.find((e) => e.type === "source_component" && e.name === component_name);
             if (!source_component)
               return null;
-            const source_port3 = soup.find((e) => e.type === "source_port" && e.source_component_id === source_component.source_component_id && (e.name === port_selector || (e.port_hints ?? []).includes(port_selector)));
+            const source_port3 = circuitJson.find((e) => e.type === "source_port" && e.source_component_id === source_component.source_component_id && (e.name === port_selector || (e.port_hints ?? []).includes(port_selector)));
             if (!source_port3)
               return null;
             if (component_type === "source_port")
               return source_port3;
             if (component_type === "pcb_port") {
-              return soup.find((e) => e.type === "pcb_port" && e.source_port_id === source_port3.source_port_id);
+              return circuitJson.find((e) => e.type === "pcb_port" && e.source_port_id === source_port3.source_port_id);
             } else if (component_type === "schematic_port") {
-              return soup.find((e) => e.type === "schematic_port" && e.source_port_id === source_port3.source_port_id);
+              return circuitJson.find((e) => e.type === "schematic_port" && e.source_port_id === source_port3.source_port_id);
             }
           }
         }
@@ -251453,7 +253762,7 @@ var import_transformation_matrix28 = __toESM2(require_build_commonjs(), 1);
 var import_transformation_matrix29 = __toESM2(require_build_commonjs(), 1);
 
 // node_modules/schematic-symbols/dist/index.js
-var import_transformation_matrix2 = __toESM2(require_build_commonjs(), 1);
+var import_transformation_matrix2 = __toESM2(require_build_commonjs2(), 1);
 function getBoundsOfPrimitives(primitives2) {
   if (primitives2.length === 0) {
     return { minX: 0, maxX: 0, minY: 0, maxY: 0 };
@@ -277089,10 +279398,10 @@ function convertCircuitJsonToSchematicSvg(circuitJson, options) {
 }
 
 // node_modules/dsn-converter/dist/index.js
-var import_transformation_matrix48 = __toESM2(require_build_commonjs(), 1);
+var import_transformation_matrix48 = __toESM2(require_build_commonjs2(), 1);
 
 // node_modules/@tscircuit/soup-util/dist/index.js
-var import_transformation_matrix47 = __toESM2(require_build_commonjs(), 1);
+var import_transformation_matrix47 = __toESM2(require_build_commonjs2(), 1);
 var su3 = (soup, options = {}) => {
   let internalStore = soup._internal_store;
   if (!internalStore) {
@@ -277197,24 +279506,24 @@ var su_default2 = su3;
 
 // node_modules/dsn-converter/dist/index.js
 var import_debug3 = __toESM2(require_src2(), 1);
-var import_transformation_matrix49 = __toESM2(require_build_commonjs(), 1);
+var import_transformation_matrix49 = __toESM2(require_build_commonjs2(), 1);
 var import_debug4 = __toESM2(require_src2(), 1);
-var import_transformation_matrix50 = __toESM2(require_build_commonjs(), 1);
-var import_transformation_matrix51 = __toESM2(require_build_commonjs(), 1);
-var import_transformation_matrix52 = __toESM2(require_build_commonjs(), 1);
+var import_transformation_matrix50 = __toESM2(require_build_commonjs2(), 1);
+var import_transformation_matrix51 = __toESM2(require_build_commonjs2(), 1);
+var import_transformation_matrix52 = __toESM2(require_build_commonjs2(), 1);
 var import_debug5 = __toESM2(require_src2(), 1);
-var import_transformation_matrix53 = __toESM2(require_build_commonjs(), 1);
-var import_transformation_matrix54 = __toESM2(require_build_commonjs(), 1);
-var import_transformation_matrix55 = __toESM2(require_build_commonjs(), 1);
+var import_transformation_matrix53 = __toESM2(require_build_commonjs2(), 1);
+var import_transformation_matrix54 = __toESM2(require_build_commonjs2(), 1);
+var import_transformation_matrix55 = __toESM2(require_build_commonjs2(), 1);
 var import_debug6 = __toESM2(require_src2(), 1);
 var import_debug7 = __toESM2(require_src2(), 1);
-var import_transformation_matrix56 = __toESM2(require_build_commonjs(), 1);
+var import_transformation_matrix56 = __toESM2(require_build_commonjs2(), 1);
 var import_debug8 = __toESM2(require_src2(), 1);
-var import_transformation_matrix57 = __toESM2(require_build_commonjs(), 1);
-var import_transformation_matrix58 = __toESM2(require_build_commonjs(), 1);
+var import_transformation_matrix57 = __toESM2(require_build_commonjs2(), 1);
+var import_transformation_matrix58 = __toESM2(require_build_commonjs2(), 1);
 var import_debug9 = __toESM2(require_src2(), 1);
-var import_transformation_matrix59 = __toESM2(require_build_commonjs(), 1);
-var import_transformation_matrix60 = __toESM2(require_build_commonjs(), 1);
+var import_transformation_matrix59 = __toESM2(require_build_commonjs2(), 1);
+var import_transformation_matrix60 = __toESM2(require_build_commonjs2(), 1);
 var import_debug10 = __toESM2(require_src2(), 1);
 var import_debug11 = __toESM2(require_src2(), 1);
 var import_debug12 = __toESM2(require_src2(), 1);
@@ -278823,8 +281132,235 @@ function calculateBoundingBox(triangles) {
     max: { x: maxX, y: maxY, z: maxZ }
   };
 }
+var objCache = /* @__PURE__ */ new Map;
+async function loadOBJ(url) {
+  if (objCache.has(url)) {
+    return objCache.get(url);
+  }
+  const response = await fetch(url);
+  const text = await response.text();
+  const mesh = parseOBJ(text);
+  objCache.set(url, mesh);
+  return mesh;
+}
+function parseOBJ(text) {
+  const lines = text.split(/\r?\n/);
+  const vertices = [];
+  const vertexColors = [];
+  const normals = [];
+  const triangles = [];
+  const materialColors = {};
+  let activeMaterial;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("v ")) {
+      const parts = trimmed.split(/\s+/);
+      const x = parts[1];
+      const y = parts[2];
+      const z3 = parts[3];
+      vertices.push({ x: parseFloat(x), y: parseFloat(y), z: parseFloat(z3) });
+      if (parts.length >= 7) {
+        const [rStr, gStr, bStr] = parts.slice(4, 7);
+        let r = Number(rStr);
+        let g = Number(gStr);
+        let b = Number(bStr);
+        if (r <= 1 && g <= 1 && b <= 1) {
+          r *= 255;
+          g *= 255;
+          b *= 255;
+        }
+        vertexColors.push([r, g, b, 1]);
+      } else {
+        vertexColors.push(undefined);
+      }
+    } else if (trimmed.startsWith("vn ")) {
+      const parts = trimmed.split(/\s+/);
+      const x = parts[1];
+      const y = parts[2];
+      const z3 = parts[3];
+      normals.push({ x: parseFloat(x), y: parseFloat(y), z: parseFloat(z3) });
+    } else if (trimmed.startsWith("newmtl ")) {
+      activeMaterial = trimmed.split(/\s+/)[1];
+    } else if (trimmed.startsWith("Kd ") && activeMaterial) {
+      const parts = trimmed.split(/\s+/);
+      const rStr = parts[1];
+      const gStr = parts[2];
+      const bStr = parts[3];
+      let r = parseFloat(rStr);
+      let g = parseFloat(gStr);
+      let b = parseFloat(bStr);
+      if (r <= 1 && g <= 1 && b <= 1) {
+        r *= 255;
+        g *= 255;
+        b *= 255;
+      }
+      materialColors[activeMaterial] = [r, g, b, 1];
+    } else if (trimmed.startsWith("usemtl ")) {
+      activeMaterial = trimmed.split(/\s+/)[1];
+    } else if (trimmed.startsWith("f ")) {
+      const parts = trimmed.slice(2).trim().split(/\s+/);
+      const idxs = parts.map((p) => {
+        const [vi, , ni] = p.split("/");
+        return {
+          v: parseInt(vi) - 1,
+          n: ni ? parseInt(ni) - 1 : undefined
+        };
+      });
+      for (let i = 1;i < idxs.length - 1; i++) {
+        const a = idxs[0];
+        const b = idxs[i];
+        const c = idxs[i + 1];
+        const v0 = vertices[a.v];
+        const v1 = vertices[b.v];
+        const v2 = vertices[c.v];
+        let normal;
+        if (a.n !== undefined && normals[a.n]) {
+          normal = normals[a.n];
+        } else if (b.n !== undefined && normals[b.n]) {
+          normal = normals[b.n];
+        } else if (c.n !== undefined && normals[c.n]) {
+          normal = normals[c.n];
+        } else {
+          const edge1 = {
+            x: v1.x - v0.x,
+            y: v1.y - v0.y,
+            z: v1.z - v0.z
+          };
+          const edge2 = {
+            x: v2.x - v0.x,
+            y: v2.y - v0.y,
+            z: v2.z - v0.z
+          };
+          normal = {
+            x: edge1.y * edge2.z - edge1.z * edge2.y,
+            y: edge1.z * edge2.x - edge1.x * edge2.z,
+            z: edge1.x * edge2.y - edge1.y * edge2.x
+          };
+        }
+        let color;
+        if (activeMaterial && materialColors[activeMaterial]) {
+          color = materialColors[activeMaterial];
+        } else {
+          color = vertexColors[a.v] ?? vertexColors[b.v] ?? vertexColors[c.v];
+        }
+        triangles.push({ vertices: [v0, v1, v2], normal, color });
+      }
+    }
+  }
+  return {
+    triangles,
+    boundingBox: calculateBoundingBox2(triangles)
+  };
+}
+function calculateBoundingBox2(triangles) {
+  if (triangles.length === 0) {
+    return { min: { x: 0, y: 0, z: 0 }, max: { x: 0, y: 0, z: 0 } };
+  }
+  let minX = Infinity;
+  let minY = Infinity;
+  let minZ = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let maxZ = -Infinity;
+  for (const tri of triangles) {
+    for (const v of tri.vertices) {
+      if (v.x < minX)
+        minX = v.x;
+      if (v.y < minY)
+        minY = v.y;
+      if (v.z < minZ)
+        minZ = v.z;
+      if (v.x > maxX)
+        maxX = v.x;
+      if (v.y > maxY)
+        maxY = v.y;
+      if (v.z > maxZ)
+        maxZ = v.z;
+    }
+  }
+  return {
+    min: { x: minX, y: minY, z: minZ },
+    max: { x: maxX, y: maxY, z: maxZ }
+  };
+}
 function colorToCss(c) {
-  return typeof c === "string" ? c : `rgba(${c[0]},${c[1]},${c[2]},${c[3]})`;
+  if (typeof c === "string")
+    return c;
+  const [r, g, b, a] = c;
+  return `rgba(${Math.round(r)},${Math.round(g)},${Math.round(b)},${a})`;
+}
+var NAMED_COLORS = {
+  black: [0, 0, 0],
+  silver: [192, 192, 192],
+  gray: [128, 128, 128],
+  grey: [128, 128, 128],
+  white: [255, 255, 255],
+  maroon: [128, 0, 0],
+  red: [255, 0, 0],
+  purple: [128, 0, 128],
+  fuchsia: [255, 0, 255],
+  green: [0, 128, 0],
+  lime: [0, 255, 0],
+  olive: [128, 128, 0],
+  yellow: [255, 255, 0],
+  navy: [0, 0, 128],
+  blue: [0, 0, 255],
+  teal: [0, 128, 128],
+  aqua: [0, 255, 255],
+  orange: [255, 165, 0]
+};
+function colorToRGBA(c) {
+  if (Array.isArray(c))
+    return c;
+  const s = c.trim().toLowerCase();
+  if (s.startsWith("#")) {
+    const hex = s.slice(1);
+    if (hex.length === 3) {
+      const r = parseInt(hex.charAt(0) + hex.charAt(0), 16);
+      const g = parseInt(hex.charAt(1) + hex.charAt(1), 16);
+      const b = parseInt(hex.charAt(2) + hex.charAt(2), 16);
+      return [r, g, b, 1];
+    }
+    if (hex.length === 6) {
+      const r = parseInt(hex.slice(0, 2), 16);
+      const g = parseInt(hex.slice(2, 4), 16);
+      const b = parseInt(hex.slice(4, 6), 16);
+      return [r, g, b, 1];
+    }
+  }
+  const rgbm = s.match(/^rgba?\(([^)]+)\)$/);
+  if (rgbm) {
+    const content = rgbm[1];
+    const parts = content.split(/\s*,\s*/).map(Number);
+    const [r = 0, g = 0, b = 0, a = 1] = parts;
+    return [r, g, b, a];
+  }
+  const named = NAMED_COLORS[s];
+  if (named)
+    return [named[0], named[1], named[2], 1];
+  return [0, 0, 0, 1];
+}
+function lightenColor(c, f) {
+  const [r, g, b, a] = colorToRGBA(c);
+  return [r + (255 - r) * f, g + (255 - g) * f, b + (255 - b) * f, a];
+}
+function darkenColor(c, f) {
+  const [r, g, b, a] = colorToRGBA(c);
+  return [r * (1 - f), g * (1 - f), b * (1 - f), a];
+}
+function shadeByNormal(base, normal) {
+  const n2 = norm(normal);
+  if (n2.z >= 0) {
+    return colorToCss(lightenColor(base, n2.z * 0.4));
+  } else {
+    return colorToCss(darkenColor(base, -n2.z * 0.4));
+  }
+}
+function fmt(n2) {
+  return Math.round(n2).toString();
+}
+function fmtPrecise(n2) {
+  return (Math.round(n2 * 100) / 100).toString();
 }
 function add(a, b) {
   return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
@@ -278902,12 +281438,26 @@ function proj(p, w, h, focal) {
 }
 var FACES = [
   [0, 1, 2, 3],
-  [4, 5, 6, 7],
+  [4, 7, 6, 5],
   [0, 1, 5, 4],
   [3, 2, 6, 7],
   [1, 2, 6, 5],
   [0, 3, 7, 4]
 ];
+var EDGES = [
+  [0, 1],
+  [1, 2],
+  [2, 3],
+  [3, 0],
+  [4, 5],
+  [5, 6],
+  [6, 7],
+  [7, 4],
+  [0, 4],
+  [1, 5],
+  [2, 6],
+  [3, 7]
+];
 var TOP = [3, 2, 6, 7];
 function verts(b) {
   const {
@@ -278975,32 +281525,67 @@ function affineMatrix(src, dst) {
   const M = mul3(D, inv3(S));
   return `matrix(${M[0][0]} ${M[1][0]} ${M[0][1]} ${M[1][1]} ${M[0][2]} ${M[1][2]})`;
 }
-function scaleAndPositionMesh(mesh, box) {
+function scaleAndPositionMesh(mesh, box, scaleToBox) {
   const { boundingBox } = mesh;
-  const meshSize = sub(boundingBox.max, boundingBox.min);
-  const boxSize = box.size;
-  const scaleX = boxSize.x / meshSize.x;
-  const scaleY = boxSize.y / meshSize.y;
-  const scaleZ = boxSize.z / meshSize.z;
-  const uniformScale = Math.min(scaleX, scaleY, scaleZ);
   const meshCenter = scale9(add(boundingBox.min, boundingBox.max), 0.5);
+  const centerModel = box.centerModel !== false;
+  const rotatedVerts = [];
+  for (const tri of mesh.triangles) {
+    for (const v of tri.vertices) {
+      let p = sub(v, meshCenter);
+      if (box.stlRotation)
+        p = rotLocal(p, box.stlRotation);
+      if (box.objRotation)
+        p = rotLocal(p, box.objRotation);
+      if (!centerModel)
+        p = add(p, meshCenter);
+      rotatedVerts.push(p);
+    }
+  }
+  let uniformScale = 1;
+  let rotatedCenter = { x: 0, y: 0, z: 0 };
+  if (scaleToBox) {
+    let min = { x: Infinity, y: Infinity, z: Infinity };
+    let max = { x: -Infinity, y: -Infinity, z: -Infinity };
+    for (const v of rotatedVerts) {
+      if (v.x < min.x)
+        min.x = v.x;
+      if (v.y < min.y)
+        min.y = v.y;
+      if (v.z < min.z)
+        min.z = v.z;
+      if (v.x > max.x)
+        max.x = v.x;
+      if (v.y > max.y)
+        max.y = v.y;
+      if (v.z > max.z)
+        max.z = v.z;
+    }
+    const rotatedSize = sub(max, min);
+    const boxSize = box.size;
+    const scaleX = boxSize.x / rotatedSize.x;
+    const scaleY = boxSize.y / rotatedSize.y;
+    const scaleZ = boxSize.z / rotatedSize.z;
+    uniformScale = Math.min(scaleX, scaleY, scaleZ);
+    rotatedCenter = scale9(add(min, max), 0.5);
+  }
   const transformedVertices = [];
-  for (const triangle of mesh.triangles) {
-    for (const vertex of triangle.vertices) {
-      let transformed = sub(vertex, meshCenter);
-      transformed = scale9(transformed, uniformScale);
-      if (box.stlRotation) {
-        transformed = rotLocal(transformed, box.stlRotation);
-      }
-      if (box.stlPosition) {
-        transformed = add(transformed, box.stlPosition);
-      }
-      if (box.rotation) {
-        transformed = rotLocal(transformed, box.rotation);
-      }
-      transformed = add(transformed, box.center);
-      transformedVertices.push(transformed);
-    }
+  for (const p of rotatedVerts) {
+    let t2 = p;
+    if (scaleToBox) {
+      t2 = sub(t2, rotatedCenter);
+      t2 = scale9(t2, uniformScale);
+      if (!centerModel)
+        t2 = add(t2, rotatedCenter);
+    }
+    if (box.stlPosition)
+      t2 = add(t2, box.stlPosition);
+    if (box.objPosition)
+      t2 = add(t2, box.objPosition);
+    if (box.rotation)
+      t2 = rotLocal(t2, box.rotation);
+    t2 = add(t2, box.center);
+    transformedVertices.push(t2);
   }
   return transformedVertices;
 }
@@ -279011,9 +281596,11 @@ async function renderScene(scene, opt = {}) {
   const faces = [];
   const images = [];
   const labels = [];
+  const edges = [];
   let clipSeq = 0;
   const texId = /* @__PURE__ */ new Map;
   const stlMeshes = /* @__PURE__ */ new Map;
+  const objMeshes = /* @__PURE__ */ new Map;
   for (const box of scene.boxes) {
     if (box.stlUrl && !stlMeshes.has(box.stlUrl)) {
       try {
@@ -279023,11 +281610,32 @@ async function renderScene(scene, opt = {}) {
         console.warn(`Failed to load STL from ${box.stlUrl}:`, error);
       }
     }
+    if (box.objUrl && !objMeshes.has(box.objUrl)) {
+      try {
+        const mesh = await loadOBJ(box.objUrl);
+        objMeshes.set(box.objUrl, mesh);
+      } catch (error) {
+        console.warn(`Failed to load OBJ from ${box.objUrl}:`, error);
+      }
+    }
   }
   for (const box of scene.boxes) {
+    const bw = verts(box);
+    const bc = bw.map((v) => toCam(v, scene.camera));
+    const bp = bc.map((v) => proj(v, W, H, focal));
+    if (box.drawBoundingBox) {
+      for (const [a, b] of EDGES) {
+        const pa = bp[a];
+        const pb = bp[b];
+        if (pa && pb) {
+          const depth = Math.max(bc[a].z, bc[b].z);
+          edges.push({ pts: [pa, pb], depth, color: "rgba(0,0,0,0.5)" });
+        }
+      }
+    }
     if (box.stlUrl && stlMeshes.has(box.stlUrl)) {
       const mesh = stlMeshes.get(box.stlUrl);
-      const transformedVertices = scaleAndPositionMesh(mesh, box);
+      const transformedVertices = scaleAndPositionMesh(mesh, box, box.scaleStlToBox ?? false);
       for (let i = 0;i < mesh.triangles.length; i++) {
         const triangle = mesh.triangles[i];
         const vertexStart = i * 3;
@@ -279040,6 +281648,35 @@ async function renderScene(scene, opt = {}) {
         const v0p = proj(v0c, W, H, focal);
         const v1p = proj(v1c, W, H, focal);
         const v2p = proj(v2c, W, H, focal);
+        if (v0p && v1p && v2p) {
+          const edge1 = sub(v1c, v0c);
+          const edge2 = sub(v2c, v0c);
+          const normal = cross(edge1, edge2);
+          const depth = Math.max(v0c.z, v1c.z, v2c.z);
+          const baseColor = box.color ?? "gray";
+          faces.push({
+            pts: [v0p, v1p, v2p],
+            depth,
+            fill: shadeByNormal(baseColor, normal),
+            stroke: false
+          });
+        }
+      }
+    } else if (box.objUrl && objMeshes.has(box.objUrl)) {
+      const mesh = objMeshes.get(box.objUrl);
+      const transformedVertices = scaleAndPositionMesh(mesh, box, box.scaleObjToBox ?? false);
+      for (let i = 0;i < mesh.triangles.length; i++) {
+        const vertexStart = i * 3;
+        const triangle = mesh.triangles[i];
+        const v0w = transformedVertices[vertexStart];
+        const v1w = transformedVertices[vertexStart + 1];
+        const v2w = transformedVertices[vertexStart + 2];
+        const v0c = toCam(v0w, scene.camera);
+        const v1c = toCam(v1w, scene.camera);
+        const v2c = toCam(v2w, scene.camera);
+        const v0p = proj(v0c, W, H, focal);
+        const v1p = proj(v1c, W, H, focal);
+        const v2p = proj(v2c, W, H, focal);
         if (v0p && v1p && v2p) {
           const edge1 = sub(v1c, v0c);
           const edge2 = sub(v2c, v0c);
@@ -279049,7 +281686,8 @@ async function renderScene(scene, opt = {}) {
             faces.push({
               pts: [v0p, v1p, v2p],
               depth,
-              fill: colorToCss(box.color)
+              fill: shadeByNormal(box.color ?? triangle.color ?? "gray", faceNormal),
+              stroke: false
             });
           }
         }
@@ -279073,18 +281711,15 @@ async function renderScene(scene, opt = {}) {
         }
         if (behind)
           continue;
-        const [a, b, c] = idx;
-        const n2 = cross(sub(vc[b], vc[a]), sub(vc[c], vc[a]));
-        if (n2.z >= 0)
-          continue;
         faces.push({
           pts: p4,
           depth: zMax,
-          fill: colorToCss(box.color)
+          fill: colorToCss(box.color ?? "gray"),
+          stroke: true
         });
       }
       if (box.faceImages?.top) {
-        const pts = TOP.map((i) => vp[i]);
+        const pts = TOP.map((i) => vw[i]);
         if (pts.every(Boolean)) {
           const dst = pts;
           const cz = Math.max(...TOP.map((i) => vc[i].z));
@@ -279106,10 +281741,10 @@ async function renderScene(scene, opt = {}) {
                 y: a.y * (1 - t2) + b.y * t2,
                 z: a.z * (1 - t2) + b.z * t2
               });
-              const p00 = lerp(lerp(dst[0], dst[1], u0), lerp(dst[3], dst[2], u0), v0);
-              const p10 = lerp(lerp(dst[0], dst[1], u1), lerp(dst[3], dst[2], u1), v0);
-              const p01 = lerp(lerp(dst[0], dst[1], u0), lerp(dst[3], dst[2], u0), v1);
-              const p11 = lerp(lerp(dst[0], dst[1], u1), lerp(dst[3], dst[2], u1), v1);
+              const p00 = proj(toCam(lerp(lerp(dst[0], dst[1], u0), lerp(dst[3], dst[2], u0), v0), scene.camera), W, H, focal);
+              const p10 = proj(toCam(lerp(lerp(dst[0], dst[1], u1), lerp(dst[3], dst[2], u1), v0), scene.camera), W, H, focal);
+              const p01 = proj(toCam(lerp(lerp(dst[0], dst[1], u0), lerp(dst[3], dst[2], u0), v1), scene.camera), W, H, focal);
+              const p11 = proj(toCam(lerp(lerp(dst[0], dst[1], u1), lerp(dst[3], dst[2], u1), v1), scene.camera), W, H, focal);
               const tri0Mat = affineMatrix([
                 { x: u0, y: v0 },
                 { x: u1, y: v0 },
@@ -279121,7 +281756,7 @@ async function renderScene(scene, opt = {}) {
                 depth: cz,
                 href,
                 clip: id0,
-                points: `${u0},${v0} ${u1},${v0} ${u1},${v1}`,
+                points: `${fmtPrecise(u0)},${fmtPrecise(v0)} ${fmtPrecise(u1)},${fmtPrecise(v0)} ${fmtPrecise(u1)},${fmtPrecise(v1)}`,
                 sym
               });
               const tri1Mat = affineMatrix([
@@ -279135,7 +281770,7 @@ async function renderScene(scene, opt = {}) {
                 depth: cz,
                 href,
                 clip: id1,
-                points: `${u0},${v0} ${u1},${v1} ${u0},${v1}`,
+                points: `${fmtPrecise(u0)},${fmtPrecise(v0)} ${fmtPrecise(u1)},${fmtPrecise(v1)} ${fmtPrecise(u0)},${fmtPrecise(v1)}`,
                 sym
               });
             }
@@ -279174,7 +281809,8 @@ async function renderScene(scene, opt = {}) {
   const allElements = [
     ...faces.map((f) => ({ type: "face", data: f })),
     ...images.map((i) => ({ type: "image", data: i })),
-    ...labels.map((l) => ({ type: "label", data: l }))
+    ...labels.map((l) => ({ type: "label", data: l })),
+    ...edges.map((e) => ({ type: "edge", data: e }))
   ];
   allElements.sort((a, b) => b.data.depth - a.data.depth);
   const out = [];
@@ -279207,7 +281843,8 @@ async function renderScene(scene, opt = {}) {
       }
       if (element.type === "face") {
         const f = element.data;
-        out.push(`    <polygon fill="${f.fill}" points="${f.pts.map((p) => `${p.x},${p.y}`).join(" ")}" />
+        const strokeAttr = f.stroke ? "" : ' stroke="none"';
+        out.push(`    <polygon fill="${f.fill}"${strokeAttr} points="${f.pts.map((p) => `${fmt(p.x)},${fmt(p.y)}`).join(" ")}" />
 `);
       } else {
         const img = element.data;
@@ -279222,6 +281859,15 @@ async function renderScene(scene, opt = {}) {
       }
       const l = element.data;
       out.push(`  <g font-family="sans-serif" font-size="14" text-anchor="middle" dominant-baseline="central" transform="${l.matrix}"><text x="0" y="0" fill="${l.fill}">${l.text}</text></g>
+`);
+    } else if (element.type === "edge") {
+      if (inStrokeGroup) {
+        out.push(`  </g>
+`);
+        inStrokeGroup = false;
+      }
+      const e = element.data;
+      out.push(`  <polyline fill="none" stroke="${e.color}" points="${e.pts.map((p) => `${p.x},${p.y}`).join(" ")}" />
 `);
     }
   }