@tscircuit/pcb-viewer 1.10.10 → 1.10.11

package/dist/index.js

@@ -408,6 +408,20 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
+function _ts_values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function() {
+            if (o && i >= o.length) o = void 0;
+            return {
+                value: o && o[i++],
+                done: !o
+            };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
 var _loop = function(letter) {
     lineAlphabet[letter] = [];
     var segs = svgAlphabet[letter].split("M").slice(1).map(function(seg) {
@@ -2945,19 +2959,1042 @@ var require_lib = __commonJS({
                     possibilities = possibilities.concat(keys(units));
                 });
             }
-            return possibilities;
+            return possibilities;
+        };
+        Converter.prototype.measures = function() {
+            return keys(measures);
+        };
+        convert = function convert(value) {
+            return new Converter(value);
+        };
+        module2.exports = convert;
+    }
+});
+// node_modules/parsel-js/dist/parsel.min.cjs
+var require_parsel_min = __commonJS({
+    "node_modules/parsel-js/dist/parsel.min.cjs": function(exports2) {
+        "use strict";
+        Object.defineProperty(exports2, "__esModule", {
+            value: true
+        });
+        var e = {
+            attribute: RegExp("\\[\\s*(?:(?<namespace>\\*|[-\\w\\P{ASCII}]*)\\|)?(?<name>[-\\w\\P{ASCII}]+)\\s*(?:(?<operator>\\W?=)\\s*(?<value>.+?)\\s*(\\s(?<caseSensitive>[iIsS]))?\\s*)?\\]", "gu"),
+            id: RegExp("#(?<name>[-\\w\\P{ASCII}]+)", "gu"),
+            class: RegExp("\\.(?<name>[-\\w\\P{ASCII}]+)", "gu"),
+            comma: /\s*,\s*/g,
+            combinator: /\s*[\s>+~]\s*/g,
+            "pseudo-element": RegExp("::(?<name>[-\\w\\P{ASCII}]+)(?:\\((?<argument>\xb6*)\\))?", "gu"),
+            "pseudo-class": RegExp(":(?<name>[-\\w\\P{ASCII}]+)(?:\\((?<argument>\xb6*)\\))?", "gu"),
+            universal: RegExp("(?:(?<namespace>\\*|[-\\w\\P{ASCII}]*)\\|)?\\*", "gu"),
+            type: RegExp("(?:(?<namespace>\\*|[-\\w\\P{ASCII}]*)\\|)?(?<name>[-\\w\\P{ASCII}]+)", "gu")
+        };
+        var t = /* @__PURE__ */ new Set([
+            "combinator",
+            "comma"
+        ]);
+        var n = /* @__PURE__ */ new Set([
+            "not",
+            "is",
+            "where",
+            "has",
+            "matches",
+            "-moz-any",
+            "-webkit-any",
+            "nth-child",
+            "nth-last-child"
+        ]);
+        var s = RegExp("(?<index>[\\dn+-]+)\\s+of\\s+(?<subtree>.+)");
+        var o = {
+            "nth-child": s,
+            "nth-last-child": s
+        };
+        var r = function(t2) {
+            switch(t2){
+                case "pseudo-element":
+                case "pseudo-class":
+                    return new RegExp(e[t2].source.replace("(?<argument>\xb6*)", "(?<argument>.*)"), "gu");
+                default:
+                    return e[t2];
+            }
+        };
+        function c(e2, t2) {
+            var n2 = 0, s2 = "";
+            for(; t2 < e2.length; t2++){
+                var o2 = e2[t2];
+                switch(o2){
+                    case "(":
+                        ++n2;
+                        break;
+                    case ")":
+                        --n2;
+                }
+                if (s2 += o2, 0 === n2) return s2;
+            }
+            return s2;
+        }
+        function i(n2) {
+            var s2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : e;
+            if (!n2) return [];
+            var o2 = [
+                n2
+            ];
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = Object.entries(s2)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var _step_value = _sliced_to_array(_step.value, 2), e2 = _step_value[0], t2 = _step_value[1];
+                    for(var n3 = 0; n3 < o2.length; n3++){
+                        var _o2;
+                        var s3 = o2[n3];
+                        if ("string" != typeof s3) continue;
+                        t2.lastIndex = 0;
+                        var r3 = t2.exec(s3);
+                        if (!r3) continue;
+                        var c2 = r3.index - 1, i2 = [], a2 = r3[0], l2 = s3.slice(0, c2 + 1);
+                        l2 && i2.push(l2), i2.push(_object_spread_props(_object_spread({}, r3.groups), {
+                            type: e2,
+                            content: a2
+                        }));
+                        var u2 = s3.slice(c2 + a2.length + 1);
+                        u2 && i2.push(u2), (_o2 = o2).splice.apply(_o2, [
+                            n3,
+                            1
+                        ].concat(_to_consumable_array(i2)));
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            var r2 = 0;
+            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+            try {
+                for(var _iterator1 = o2[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                    var e21 = _step1.value;
+                    switch(typeof e21 === "undefined" ? "undefined" : _type_of(e21)){
+                        case "string":
+                            throw new Error("Unexpected sequence ".concat(e21, " found at index ").concat(r2));
+                        case "object":
+                            r2 += e21.content.length, e21.pos = [
+                                r2 - e21.content.length,
+                                r2
+                            ], t.has(e21.type) && (e21.content = e21.content.trim() || " ");
+                    }
+                }
+            } catch (err) {
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+            }
+            return o2;
+        }
+        var a = /(['"])([^\\\n]+?)\1/g;
+        var l = /\\./g;
+        function u(t2) {
+            var n2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : e;
+            if ("" === (t2 = t2.trim())) return [];
+            var s2 = [];
+            t2 = (t2 = t2.replace(l, function(e2, t3) {
+                return s2.push({
+                    value: e2,
+                    offset: t3
+                }), "".repeat(e2.length);
+            })).replace(a, function(e2, t3, n3, o3) {
+                return s2.push({
+                    value: e2,
+                    offset: o3
+                }), "".concat(t3).concat("".repeat(n3.length)).concat(t3);
+            });
+            {
+                var e2, n3 = 0;
+                for(; (e2 = t2.indexOf("(", n3)) > -1;){
+                    var o3 = c(t2, e2);
+                    s2.push({
+                        value: o3,
+                        offset: e2
+                    }), t2 = "".concat(t2.substring(0, e2), "(").concat("\xb6".repeat(o3.length - 2), ")").concat(t2.substring(e2 + o3.length)), n3 = e2 + o3.length;
+                }
+            }
+            var o2 = i(t2, n2), u2 = /* @__PURE__ */ new Set();
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined, _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+            try {
+                for(var _iterator = s2.reverse()[Symbol.iterator](), _step; !(_iteratorNormalCompletion1 = (_step = _iterator.next()).done); _iteratorNormalCompletion1 = true){
+                    var e21 = _step.value;
+                    try {
+                        for(var _iterator1 = o2[Symbol.iterator](), _step1; !(_iteratorNormalCompletion = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion = true){
+                            var t3 = _step1.value;
+                            var n31 = e21.offset, s3 = e21.value;
+                            if (!(t3.pos[0] <= n31 && n31 + s3.length <= t3.pos[1])) continue;
+                            var o31 = t3.content, r2 = n31 - t3.pos[0];
+                            t3.content = o31.slice(0, r2) + s3 + o31.slice(r2 + s3.length), t3.content !== o31 && u2.add(t3);
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator1.return != null) {
+                                _iterator1.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                }
+            } catch (err) {
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+            }
+            var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+            try {
+                for(var _iterator2 = u2[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                    var e22 = _step2.value;
+                    var t31 = r(e22.type);
+                    if (!t31) throw new Error("Unknown token type: ".concat(e22.type));
+                    t31.lastIndex = 0;
+                    var n32 = t31.exec(e22.content);
+                    if (!n32) throw new Error("Unable to parse content for ".concat(e22.type, ": ").concat(e22.content));
+                    Object.assign(e22, n32.groups);
+                }
+            } catch (err) {
+                _didIteratorError2 = true;
+                _iteratorError2 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                        _iterator2.return();
+                    }
+                } finally{
+                    if (_didIteratorError2) {
+                        throw _iteratorError2;
+                    }
+                }
+            }
+            return o2;
+        }
+        function p(e2) {
+            var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, tmp = _ref.list, t2 = tmp === void 0 ? true : tmp;
+            if (t2 && e2.find(function(e3) {
+                return "comma" === e3.type;
+            })) {
+                var t3 = [], n2 = [];
+                for(var s2 = 0; s2 < e2.length; s2++)if ("comma" === e2[s2].type) {
+                    if (0 === n2.length) throw new Error("Incorrect comma at " + s2);
+                    t3.push(p(n2, {
+                        list: false
+                    })), n2.length = 0;
+                } else n2.push(e2[s2]);
+                if (0 === n2.length) throw new Error("Trailing comma");
+                return t3.push(p(n2, {
+                    list: false
+                })), {
+                    type: "list",
+                    list: t3
+                };
+            }
+            for(var t31 = e2.length - 1; t31 >= 0; t31--){
+                var n21 = e2[t31];
+                if ("combinator" === n21.type) {
+                    var s21 = e2.slice(0, t31), o2 = e2.slice(t31 + 1);
+                    return {
+                        type: "complex",
+                        combinator: n21.content,
+                        left: p(s21),
+                        right: p(o2)
+                    };
+                }
+            }
+            switch(e2.length){
+                case 0:
+                    throw new Error("Could not build AST.");
+                case 1:
+                    return e2[0];
+                default:
+                    return {
+                        type: "compound",
+                        list: _to_consumable_array(e2)
+                    };
+            }
+        }
+        function f(e2, t2) {
+            var _, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, t3, err;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _ = e2.type;
+                        switch(_){
+                            case "list":
+                                return [
+                                    3,
+                                    1
+                                ];
+                            case "complex":
+                                return [
+                                    3,
+                                    10
+                                ];
+                            case "compound":
+                                return [
+                                    3,
+                                    13
+                                ];
+                        }
+                        return [
+                            3,
+                            15
+                        ];
+                    case 1:
+                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        _state.label = 2;
+                    case 2:
+                        _state.trys.push([
+                            2,
+                            7,
+                            8,
+                            9
+                        ]);
+                        _iterator = e2.list[Symbol.iterator]();
+                        _state.label = 3;
+                    case 3:
+                        if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                            3,
+                            6
+                        ];
+                        t3 = _step.value;
+                        return [
+                            5,
+                            _ts_values(f(t3, e2))
+                        ];
+                    case 4:
+                        _state.sent();
+                        _state.label = 5;
+                    case 5:
+                        _iteratorNormalCompletion = true;
+                        return [
+                            3,
+                            3
+                        ];
+                    case 6:
+                        return [
+                            3,
+                            9
+                        ];
+                    case 7:
+                        err = _state.sent();
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                        return [
+                            3,
+                            9
+                        ];
+                    case 8:
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                        return [
+                            7
+                        ];
+                    case 9:
+                        return [
+                            3,
+                            17
+                        ];
+                    case 10:
+                        return [
+                            5,
+                            _ts_values(f(e2.left, e2))
+                        ];
+                    case 11:
+                        _state.sent();
+                        return [
+                            5,
+                            _ts_values(f(e2.right, e2))
+                        ];
+                    case 12:
+                        _state.sent();
+                        return [
+                            3,
+                            17
+                        ];
+                    case 13:
+                        return [
+                            5,
+                            _ts_values(e2.list.map(function(t3) {
+                                return [
+                                    t3,
+                                    e2
+                                ];
+                            }))
+                        ];
+                    case 14:
+                        _state.sent();
+                        return [
+                            3,
+                            17
+                        ];
+                    case 15:
+                        return [
+                            4,
+                            [
+                                e2,
+                                t2
+                            ]
+                        ];
+                    case 16:
+                        _state.sent();
+                        _state.label = 17;
+                    case 17:
+                        return [
+                            2
+                        ];
+                }
+            });
+        }
+        function h(e2) {
+            var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, tmp = _ref.recursive, t2 = tmp === void 0 ? true : tmp, tmp1 = _ref.list, s2 = tmp1 === void 0 ? true : tmp1;
+            var r2 = u(e2);
+            if (!r2) return;
+            var c2 = p(r2, {
+                list: s2
+            });
+            if (!t2) return c2;
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = f(c2)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var _step_value = _sliced_to_array(_step.value, 1), e3 = _step_value[0];
+                    if ("pseudo-class" !== e3.type || !e3.argument) continue;
+                    if (!n.has(e3.name)) continue;
+                    var t3 = e3.argument;
+                    var s3 = o[e3.name];
+                    if (s3) {
+                        var n2 = s3.exec(t3);
+                        if (!n2) continue;
+                        Object.assign(e3, n2.groups), t3 = n2.groups.subtree;
+                    }
+                    t3 && Object.assign(e3, {
+                        subtree: h(t3, {
+                            recursive: true,
+                            list: true
+                        })
+                    });
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            return c2;
+        }
+        function m(e2, t2) {
+            var _Math;
+            return t2 = t2 || (_Math = Math).max.apply(_Math, _to_consumable_array(e2)) + 1, e2[0] * (t2 << 1) + e2[1] * t2 + e2[2];
+        }
+        exports2.RECURSIVE_PSEUDO_CLASSES = n, exports2.RECURSIVE_PSEUDO_CLASSES_ARGS = o, exports2.TOKENS = e, exports2.TRIM_TOKENS = t, exports2.flatten = f, exports2.gobbleParens = c, exports2.parse = h, exports2.specificity = function e2(t2) {
+            var s2 = t2;
+            if ("string" == typeof s2 && (s2 = h(s2, {
+                recursive: true
+            })), !s2) return [];
+            if ("list" === s2.type && "list" in s2) {
+                var _Math;
+                var t3 = 10;
+                var n2 = s2.list.map(function(n3) {
+                    var _Math;
+                    var s3 = e2(n3);
+                    return t3 = (_Math = Math).max.apply(_Math, [
+                        t3
+                    ].concat(_to_consumable_array(e2(n3)))), s3;
+                }), o3 = n2.map(function(e3) {
+                    return m(e3, t3);
+                });
+                return n2[o3.indexOf((_Math = Math).max.apply(_Math, _to_consumable_array(o3)))];
+            }
+            var o2 = [
+                0,
+                0,
+                0
+            ];
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = f(s2)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var _step_value = _sliced_to_array(_step.value, 1), t31 = _step_value[0];
+                    switch(t31.type){
+                        case "id":
+                            o2[0]++;
+                            break;
+                        case "class":
+                        case "attribute":
+                            o2[1]++;
+                            break;
+                        case "pseudo-element":
+                        case "type":
+                            o2[2]++;
+                            break;
+                        case "pseudo-class":
+                            if ("where" === t31.name) break;
+                            if (!n.has(t31.name) || !t31.subtree) {
+                                o2[1]++;
+                                break;
+                            }
+                            e2(t31.subtree).forEach(function(e3, t4) {
+                                return o2[t4] += e3;
+                            }), "nth-child" !== t31.name && "nth-last-child" !== t31.name || o2[1]++;
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            return o2;
+        }, exports2.specificityToNumber = m, exports2.stringify = function(e2) {
+            var t2;
+            return t2 = Array.isArray(e2) ? e2 : _to_consumable_array(f(e2)).map(function(param) {
+                var _param = _sliced_to_array(param, 1), e3 = _param[0];
+                return e3;
+            }), t2.map(function(e3) {
+                return e3.content;
+            }).join("");
+        }, exports2.tokenize = u, exports2.tokenizeBy = i, exports2.walk = function(e2, t2, n2) {
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            if (e2) try {
+                for(var _iterator = f(e2, n2)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var _step_value = _sliced_to_array(_step.value, 2), s2 = _step_value[0], o2 = _step_value[1];
+                    t2(s2, o2);
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        };
+    }
+});
+// node_modules/@tscircuit/soup-util/dist/index.cjs
+var require_dist = __commonJS({
+    "node_modules/@tscircuit/soup-util/dist/index.cjs": function(exports2, module2) {
+        "use strict";
+        var __create2 = Object.create;
+        var __defProp2 = Object.defineProperty;
+        var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames2 = Object.getOwnPropertyNames;
+        var __getProtoOf2 = Object.getPrototypeOf;
+        var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+        var __export2 = function(target, all) {
+            for(var name in all)__defProp2(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps2 = function(to, from, except, desc) {
+            if (from && typeof from === "object" || typeof from === "function") {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    var _loop = function() {
+                        var key = _step.value;
+                        if (!__hasOwnProp2.call(to, key) && key !== except) __defProp2(to, key, {
+                            get: function() {
+                                return from[key];
+                            },
+                            enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable
+                        });
+                    };
+                    for(var _iterator = __getOwnPropNames2(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+            return to;
+        };
+        var __toESM2 = function(mod, isNodeMode, target) {
+            return target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(// If the importer is in node compatibility mode or this is not an ESM
+            // file that has been converted to a CommonJS file using a Babel-
+            // compatible transform (i.e. "__esModule" has not been set), then set
+            // "default" to the CommonJS "module.exports" for node compatibility.
+            isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", {
+                value: mod,
+                enumerable: true
+            }) : target, mod);
+        };
+        var __toCommonJS2 = function(mod) {
+            return __copyProps2(__defProp2({}, "__esModule", {
+                value: true
+            }), mod);
+        };
+        var soup_util_exports = {};
+        __export2(soup_util_exports, {
+            applySelector: function() {
+                return applySelector;
+            },
+            applySelectorAST: function() {
+                return applySelectorAST;
+            },
+            directionToVec: function() {
+                return directionToVec;
+            },
+            oppositeDirection: function() {
+                return oppositeDirection;
+            },
+            oppositeSide: function() {
+                return oppositeSide;
+            },
+            rotateClockwise: function() {
+                return rotateClockwise;
+            },
+            rotateCounterClockwise: function() {
+                return rotateCounterClockwise;
+            },
+            rotateDirection: function() {
+                return rotateDirection;
+            },
+            su: function() {
+                return su_default;
+            },
+            transformPCBElement: function() {
+                return transformPCBElement2;
+            },
+            transformPCBElements: function() {
+                return transformPCBElements2;
+            },
+            transformSchematicElement: function() {
+                return transformSchematicElement;
+            },
+            transformSchematicElements: function() {
+                return transformSchematicElements;
+            },
+            vecToDirection: function() {
+                return vecToDirection;
+            }
+        });
+        module2.exports = __toCommonJS2(soup_util_exports);
+        var su5 = function(soup) {
+            var su22 = new Proxy({}, {
+                get: function(proxy_target, component_type) {
+                    return {
+                        get: function(id) {
+                            return soup.find(function(e) {
+                                return e.type === component_type && e["".concat(component_type, "_id")] === id;
+                            });
+                        },
+                        getUsing: function(using) {
+                            var keys = Object.keys(using);
+                            if (keys.length !== 1) {
+                                throw new Error("getUsing requires exactly one key, e.g. { pcb_component_id }");
+                            }
+                            var join_key = keys[0];
+                            var join_type = join_key.replace("_id", "");
+                            var joiner = soup.find(function(e) {
+                                return e.type === join_type && e[join_key] === using[join_key];
+                            });
+                            if (!joiner) return null;
+                            return soup.find(function(e) {
+                                return e.type === component_type && e["".concat(component_type, "_id")] === joiner["".concat(component_type, "_id")];
+                            });
+                        },
+                        getWhere: function(where) {
+                            var keys = Object.keys(where);
+                            return soup.find(function(e) {
+                                return e.type === component_type && keys.every(function(key) {
+                                    return e[key] === where[key];
+                                });
+                            });
+                        },
+                        list: function(where) {
+                            var keys = !where ? [] : Object.keys(where);
+                            return soup.filter(function(e) {
+                                return e.type === component_type && keys.every(function(key) {
+                                    return e[key] === where[key];
+                                });
+                            });
+                        },
+                        select: function(selector) {
+                            if (component_type === "source_component") {
+                                return soup.find(function(e) {
+                                    return e.type === "source_component" && e.name === selector.replace(/\./g, "");
+                                });
+                            } else if (component_type === "pcb_port" || component_type === "source_port" || component_type === "schematic_port") {
+                                var _selector_replace_split = _sliced_to_array(selector.replace(/\./g, "").split(/[\s\>]+/), 2), component_name = _selector_replace_split[0], port_selector = _selector_replace_split[1];
+                                var source_component = soup.find(function(e) {
+                                    return e.type === "source_component" && e.name === component_name;
+                                });
+                                if (!source_component) return null;
+                                var source_port2 = soup.find(function(e) {
+                                    var _e_port_hints;
+                                    return e.type === "source_port" && e.source_component_id === source_component.source_component_id && (e.name === port_selector || ((_e_port_hints = e.port_hints) !== null && _e_port_hints !== void 0 ? _e_port_hints : []).includes(port_selector));
+                                });
+                                if (!source_port2) return null;
+                                if (component_type === "source_port") return source_port2;
+                                if (component_type === "pcb_port") {
+                                    return soup.find(function(e) {
+                                        return e.type === "pcb_port" && e.source_port_id === source_port2.source_port_id;
+                                    });
+                                } else if (component_type === "schematic_port") {
+                                    return soup.find(function(e) {
+                                        return e.type === "schematic_port" && e.source_port_id === source_port2.source_port_id;
+                                    });
+                                }
+                            }
+                        }
+                    };
+                }
+            });
+            return su22;
+        };
+        su5.unparsed = su5;
+        var su_default = su5;
+        var directionToVec = function(direction) {
+            if (direction === "up") return {
+                x: 0,
+                y: 1
+            };
+            else if (direction === "down") return {
+                x: 0,
+                y: -1
+            };
+            else if (direction === "left") return {
+                x: -1,
+                y: 0
+            };
+            else if (direction === "right") return {
+                x: 1,
+                y: 0
+            };
+            else throw new Error("Invalid direction");
+        };
+        var vecToDirection = function(param) {
+            var x = param.x, y = param.y;
+            if (x > y) y = 0;
+            if (y > x) x = 0;
+            if (x > 0 && y === 0) return "right";
+            else if (x < 0 && y === 0) return "left";
+            else if (x === 0 && y > 0) return "up";
+            else if (x === 0 && y < 0) return "down";
+            else throw new Error("Invalid vector for direction conversion (".concat(x, ", ").concat(y, ")"));
+        };
+        var rotateClockwise = function(direction) {
+            if (direction === "up") return "right";
+            else if (direction === "right") return "down";
+            else if (direction === "down") return "left";
+            else if (direction === "left") return "up";
+            throw new Error("Invalid direction: ".concat(direction));
+        };
+        var rotateCounterClockwise = function(direction) {
+            if (direction === "up") return "left";
+            else if (direction === "left") return "down";
+            else if (direction === "down") return "right";
+            else if (direction === "right") return "up";
+            throw new Error("Invalid direction: ".concat(direction));
+        };
+        var rotateDirection = function(direction, num90DegreeClockwiseTurns) {
+            while(num90DegreeClockwiseTurns > 0){
+                direction = rotateClockwise(direction);
+                num90DegreeClockwiseTurns--;
+            }
+            while(num90DegreeClockwiseTurns < 0){
+                direction = rotateCounterClockwise(direction);
+                num90DegreeClockwiseTurns++;
+            }
+            return direction;
+        };
+        var oppositeDirection = function(direction) {
+            if (direction === "up") return "down";
+            else if (direction === "down") return "up";
+            else if (direction === "left") return "right";
+            else if (direction === "right") return "left";
+            throw new Error("Invalid direction: ".concat(direction));
+        };
+        var oppositeSide = function(sideOrDir) {
+            if (sideOrDir === "top" || sideOrDir === "up") return "bottom";
+            else if (sideOrDir === "bottom" || sideOrDir === "down") return "top";
+            else if (sideOrDir === "left") return "right";
+            else if (sideOrDir === "right") return "left";
+            throw new Error("Invalid sideOrDir: ".concat(sideOrDir));
+        };
+        var import_transformation_matrix10 = require("transformation-matrix");
+        var transformSchematicElement = function(elm, matrix) {
+            if (elm.type === "schematic_component") {
+                elm.center = (0, import_transformation_matrix10.applyToPoint)(matrix, elm.center);
+            } else if (elm.type === "schematic_port") {
+                elm.center = (0, import_transformation_matrix10.applyToPoint)(matrix, elm.center);
+                if (elm.facing_direction) {
+                    elm.facing_direction = rotateDirection(elm.facing_direction, -(Math.atan2(matrix.b, matrix.a) / Math.PI) * 2);
+                }
+            } else if (elm.type === "schematic_text") {
+                elm.position = (0, import_transformation_matrix10.applyToPoint)(matrix, elm.position);
+            } else if (elm.type === "schematic_trace") {} else if (elm.type === "schematic_box") {
+                var _ref = (0, import_transformation_matrix10.applyToPoint)(matrix, {
+                    x: elm.x,
+                    y: elm.y
+                }), x = _ref.x, y = _ref.y;
+                elm.x = x;
+                elm.y = y;
+            } else if (elm.type === "schematic_line") {
+                var _ref1 = (0, import_transformation_matrix10.applyToPoint)(matrix, {
+                    x: elm.x1,
+                    y: elm.y1
+                }), x1 = _ref1.x, y1 = _ref1.y;
+                var _ref2 = (0, import_transformation_matrix10.applyToPoint)(matrix, {
+                    x: elm.x2,
+                    y: elm.y2
+                }), x2 = _ref2.x, y2 = _ref2.y;
+                elm.x1 = x1;
+                elm.y1 = y1;
+                elm.x2 = x2;
+                elm.y2 = y2;
+            }
+            return elm;
+        };
+        var transformSchematicElements = function(elms, matrix) {
+            return elms.map(function(elm) {
+                return transformSchematicElement(elm, matrix);
+            });
+        };
+        var transformPCBElement2 = function(elm, matrix) {
+            if (elm.type === "pcb_plated_hole" || elm.type === "pcb_hole" || elm.type === "pcb_via" || elm.type === "pcb_smtpad" || elm.type === "pcb_port") {
+                var _ref = (0, import_transformation_matrix10.applyToPoint)(matrix, {
+                    x: elm.x,
+                    y: elm.y
+                }), x = _ref.x, y = _ref.y;
+                elm.x = x;
+                elm.y = y;
+            } else if (elm.type === "pcb_silkscreen_text" || elm.type === "pcb_fabrication_note_text") {
+                elm.anchor_position = (0, import_transformation_matrix10.applyToPoint)(matrix, elm.anchor_position);
+            } else if (elm.type === "pcb_silkscreen_circle" || elm.type === "pcb_silkscreen_rect" || elm.type === "pcb_component") {
+                elm.center = (0, import_transformation_matrix10.applyToPoint)(matrix, elm.center);
+            } else if (elm.type === "pcb_silkscreen_path" || elm.type === "pcb_trace" || elm.type === "pcb_fabrication_note_path") {
+                elm.route = elm.route.map(function(rp) {
+                    var tp = (0, import_transformation_matrix10.applyToPoint)(matrix, rp);
+                    rp.x = tp.x;
+                    rp.y = tp.y;
+                    return rp;
+                });
+            } else if (elm.type === "pcb_silkscreen_line") {
+                var p1 = {
+                    x: elm.x1,
+                    y: elm.y1
+                };
+                var p2 = {
+                    x: elm.x2,
+                    y: elm.y2
+                };
+                var p1t = (0, import_transformation_matrix10.applyToPoint)(matrix, p1);
+                var p2t = (0, import_transformation_matrix10.applyToPoint)(matrix, p2);
+                elm.x1 = p1t.x;
+                elm.y1 = p1t.y;
+                elm.x2 = p2t.x;
+                elm.y2 = p2t.y;
+            } else if (elm.type === "cad_component") {
+                var newPos = (0, import_transformation_matrix10.applyToPoint)(matrix, {
+                    x: elm.position.x,
+                    y: elm.position.y
+                });
+                elm.position.x = newPos.x;
+                elm.position.y = newPos.y;
+            }
+            return elm;
+        };
+        var transformPCBElements2 = function(elms, matrix) {
+            var tsr = (0, import_transformation_matrix10.decomposeTSR)(matrix);
+            var flipPadWidthHeight = Math.round(tsr.rotation.angle / (Math.PI / 2)) % 2 === 1;
+            var transformedElms = elms.map(function(elm) {
+                return transformPCBElement2(elm, matrix);
+            });
+            if (flipPadWidthHeight) {
+                transformedElms = transformedElms.map(function(elm) {
+                    if (elm.type === "pcb_smtpad" && elm.shape === "rect") {
+                        ;
+                        var ref;
+                        ref = [
+                            elm.height,
+                            elm.width
+                        ], elm.width = ref[0], elm.height = ref[1], ref;
+                    }
+                    return elm;
+                });
+            }
+            return transformedElms;
         };
-        Converter.prototype.measures = function() {
-            return keys(measures);
+        var parsel = __toESM2(require_parsel_min(), 1);
+        var convertAbbrToType = function(abbr) {
+            switch(abbr){
+                case "port":
+                    return "source_port";
+                case "net":
+                    return "source_net";
+                case "power":
+                    return "simple_power_source";
+            }
+            return abbr;
         };
-        convert = function convert(value) {
-            return new Converter(value);
+        var filterByType = function(elements, type) {
+            type = convertAbbrToType(type);
+            return elements.filter(function(elm) {
+                return "ftype" in elm && elm.ftype === type || elm.type === type;
+            });
+        };
+        var applySelector = function(elements, selectorRaw) {
+            var selectorAST = parsel.parse(selectorRaw);
+            return applySelectorAST(elements, selectorAST);
+        };
+        var doesElmMatchClassName = function(elm, className) {
+            var _elm_port_hints;
+            return "name" in elm && elm.name === className || "port_hints" in elm && ((_elm_port_hints = elm.port_hints) === null || _elm_port_hints === void 0 ? void 0 : _elm_port_hints.includes(className));
+        };
+        var applySelectorAST = function(elements, selectorAST) {
+            switch(selectorAST.type){
+                case "complex":
+                    {
+                        switch(selectorAST.combinator){
+                            case " ":
+                            case ">":
+                                {
+                                    var left = selectorAST.left, right = selectorAST.right;
+                                    if (left.type === "class" || left.type === "type") {
+                                        var matchElms;
+                                        if (left.type === "class") {
+                                            matchElms = elements.filter(function(elm) {
+                                                return doesElmMatchClassName(elm, left.name);
+                                            });
+                                        } else if (left.type === "type") {
+                                            matchElms = filterByType(elements, left.name);
+                                        } else {
+                                            matchElms = [];
+                                        }
+                                        var childrenOfMatchingElms = matchElms.flatMap(function(matchElm) {
+                                            return elements.filter(function(elm) {
+                                                return elm["".concat(matchElm.type, "_id")] === matchElm["".concat(matchElm.type, "_id")] && elm !== matchElm;
+                                            });
+                                        });
+                                        return applySelectorAST(childrenOfMatchingElms, right);
+                                    } else {
+                                        throw new Error('unsupported selector type "'.concat(left.type, '" '));
+                                    }
+                                }
+                            default:
+                                {
+                                    throw new Error("Couldn't apply selector AST for complex combinator \"".concat(selectorAST.combinator, '"'));
+                                }
+                        }
+                        return [];
+                    }
+                case "compound":
+                    {
+                        var conditionsToMatch = selectorAST.list.map(function(part) {
+                            switch(part.type){
+                                case "class":
+                                    {
+                                        return function(elm) {
+                                            return doesElmMatchClassName(elm, part.name);
+                                        };
+                                    }
+                                case "type":
+                                    {
+                                        var name = convertAbbrToType(part.name);
+                                        return function(elm) {
+                                            return elm.type === name;
+                                        };
+                                    }
+                            }
+                        });
+                        return elements.filter(function(elm) {
+                            return conditionsToMatch.every(function(condFn) {
+                                return condFn === null || condFn === void 0 ? void 0 : condFn(elm);
+                            });
+                        });
+                    }
+                case "type":
+                    {
+                        return filterByType(elements, selectorAST.name);
+                    }
+                case "class":
+                    {
+                        return elements.filter(function(elm) {
+                            return doesElmMatchClassName(elm, selectorAST.name);
+                        });
+                    }
+                default:
+                    {
+                        throw new Error("Couldn't apply selector AST for type: \"".concat(selectorAST.type, '" ').concat(JSON.stringify(selectorAST, null, " ")));
+                    }
+            }
         };
-        module2.exports = convert;
     }
 });
 // node_modules/use-mouse-matrix-transform/dist/index.js
-var require_dist = __commonJS({
+var require_dist2 = __commonJS({
     "node_modules/use-mouse-matrix-transform/dist/index.js": function(exports2, module2) {
         "use strict";
         var __defProp2 = Object.defineProperty;
@@ -3016,7 +4053,7 @@ var require_dist = __commonJS({
             }
         });
         module2.exports = __toCommonJS2(src_exports2);
-        var import_transformation_matrix11 = require("transformation-matrix");
+        var import_transformation_matrix10 = require("transformation-matrix");
         var import_react21 = require("react");
         var useMouseMatrixTransform2 = function() {
             var props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
@@ -3025,7 +4062,7 @@ var require_dist = __commonJS({
             var _props_canvasElm;
             var outerCanvasElm = (_props_canvasElm = props.canvasElm) !== null && _props_canvasElm !== void 0 ? _props_canvasElm : extRef.current;
             var _props_initialTransform;
-            var _ref1 = _sliced_to_array((0, import_react21.useState)((_props_initialTransform = props.initialTransform) !== null && _props_initialTransform !== void 0 ? _props_initialTransform : (0, import_transformation_matrix11.identity)()), 2), internalTransform = _ref1[0], setInternalTransform = _ref1[1];
+            var _ref1 = _sliced_to_array((0, import_react21.useState)((_props_initialTransform = props.initialTransform) !== null && _props_initialTransform !== void 0 ? _props_initialTransform : (0, import_transformation_matrix10.identity)()), 2), internalTransform = _ref1[0], setInternalTransform = _ref1[1];
             var _ref2 = _sliced_to_array((0, import_react21.useState)(0), 2), waitCounter = _ref2[0], setWaitCounter = _ref2[1];
             var _ref3 = _sliced_to_array((0, import_react21.useReducer)(function(s) {
                 return s + 1;
@@ -3062,7 +4099,7 @@ var require_dist = __commonJS({
                 var handleMouseUp = function handleMouseUp(e) {
                     if (!md) return;
                     m1 = getMousePos(e);
-                    var new_tf = (0, import_transformation_matrix11.compose)((0, import_transformation_matrix11.translate)(m1.x - m0.x, m1.y - m0.y), init_tf);
+                    var new_tf = (0, import_transformation_matrix10.compose)((0, import_transformation_matrix10.translate)(m1.x - m0.x, m1.y - m0.y), init_tf);
                     setTransform(new_tf);
                     init_tf = new_tf;
                     md = false;
@@ -3071,11 +4108,11 @@ var require_dist = __commonJS({
                     mlastrel = getMousePos(e);
                     if (!md) return;
                     m1 = getMousePos(e);
-                    setTransform((0, import_transformation_matrix11.compose)((0, import_transformation_matrix11.translate)(m1.x - m0.x, m1.y - m0.y), init_tf));
+                    setTransform((0, import_transformation_matrix10.compose)((0, import_transformation_matrix10.translate)(m1.x - m0.x, m1.y - m0.y), init_tf));
                 };
                 var handleMouseWheel = function handleMouseWheel(e) {
                     var center = getMousePos(e);
-                    var new_tf = (0, import_transformation_matrix11.compose)((0, import_transformation_matrix11.translate)(center.x, center.y), (0, import_transformation_matrix11.scale)(1 - e.deltaY / 1e3, 1 - e.deltaY / 1e3), (0, import_transformation_matrix11.translate)(-center.x, -center.y), init_tf);
+                    var new_tf = (0, import_transformation_matrix10.compose)((0, import_transformation_matrix10.translate)(center.x, center.y), (0, import_transformation_matrix10.scale)(1 - e.deltaY / 1e3, 1 - e.deltaY / 1e3), (0, import_transformation_matrix10.translate)(-center.x, -center.y), init_tf);
                     setTransform(new_tf);
                     init_tf = new_tf;
                     e.preventDefault();
@@ -3090,7 +4127,7 @@ var require_dist = __commonJS({
                     }
                     md = false;
                     m1 = getMousePos(e);
-                    var new_tf = (0, import_transformation_matrix11.compose)((0, import_transformation_matrix11.translate)(m1.x - m0.x, m1.y - m0.y), init_tf);
+                    var new_tf = (0, import_transformation_matrix10.compose)((0, import_transformation_matrix10.translate)(m1.x - m0.x, m1.y - m0.y), init_tf);
                     setTransform(new_tf);
                     init_tf = new_tf;
                 };
@@ -3145,7 +4182,7 @@ var require_dist = __commonJS({
                 lastDragCancelTime
             ]);
             var applyTransformToPoint = (0, import_react21.useCallback)(function(obj) {
-                return (0, import_transformation_matrix11.applyToPoint)(transform, obj);
+                return (0, import_transformation_matrix10.applyToPoint)(transform, obj);
             }, [
                 transform
             ]);
@@ -3176,6 +4213,8 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 // src/PCBViewer.tsx
 var import_react20 = require("react");
+var import_react_fiber = require("@tscircuit/react-fiber");
+var import_builder = require("@tscircuit/builder");
 // src/components/CanvasElementsRenderer.tsx
 var import_react16 = require("react");
 // src/components/CanvasPrimitiveRenderer.tsx
@@ -4103,240 +5142,6 @@ var useGlobalStore = function(s) {
     return (0, import_zustand.useStore)(store, s);
 };
 // node_modules/circuit-json/dist/index.mjs
-var dist_exports = {};
-__export(dist_exports, {
-    all_layers: function() {
-        return all_layers;
-    },
-    any_circuit_element: function() {
-        return any_circuit_element;
-    },
-    any_soup_element: function() {
-        return any_soup_element;
-    },
-    any_source_component: function() {
-        return any_source_component;
-    },
-    cad_component: function() {
-        return cad_component;
-    },
-    capacitance: function() {
-        return capacitance;
-    },
-    current: function() {
-        return current;
-    },
-    distance: function() {
-        return distance;
-    },
-    getZodPrefixedIdWithDefault: function() {
-        return getZodPrefixedIdWithDefault;
-    },
-    inductance: function() {
-        return inductance;
-    },
-    layer_ref: function() {
-        return layer_ref;
-    },
-    layer_string: function() {
-        return layer_string;
-    },
-    length: function() {
-        return length;
-    },
-    pcb_board: function() {
-        return pcb_board;
-    },
-    pcb_component: function() {
-        return pcb_component;
-    },
-    pcb_fabrication_note_path: function() {
-        return pcb_fabrication_note_path;
-    },
-    pcb_fabrication_note_text: function() {
-        return pcb_fabrication_note_text;
-    },
-    pcb_hole: function() {
-        return pcb_hole;
-    },
-    pcb_hole_circle_or_square_shape: function() {
-        return pcb_hole_circle_or_square_shape;
-    },
-    pcb_hole_oval_shape: function() {
-        return pcb_hole_oval_shape;
-    },
-    pcb_keepout: function() {
-        return pcb_keepout;
-    },
-    pcb_placement_error: function() {
-        return pcb_placement_error;
-    },
-    pcb_plated_hole: function() {
-        return pcb_plated_hole;
-    },
-    pcb_port: function() {
-        return pcb_port;
-    },
-    pcb_port_not_matched_error: function() {
-        return pcb_port_not_matched_error;
-    },
-    pcb_route_hint: function() {
-        return pcb_route_hint;
-    },
-    pcb_route_hints: function() {
-        return pcb_route_hints;
-    },
-    pcb_silkscreen_circle: function() {
-        return pcb_silkscreen_circle;
-    },
-    pcb_silkscreen_line: function() {
-        return pcb_silkscreen_line;
-    },
-    pcb_silkscreen_oval: function() {
-        return pcb_silkscreen_oval;
-    },
-    pcb_silkscreen_path: function() {
-        return pcb_silkscreen_path;
-    },
-    pcb_silkscreen_rect: function() {
-        return pcb_silkscreen_rect;
-    },
-    pcb_silkscreen_text: function() {
-        return pcb_silkscreen_text;
-    },
-    pcb_smtpad: function() {
-        return pcb_smtpad;
-    },
-    pcb_text: function() {
-        return pcb_text;
-    },
-    pcb_trace: function() {
-        return pcb_trace;
-    },
-    pcb_trace_error: function() {
-        return pcb_trace_error;
-    },
-    pcb_trace_hint: function() {
-        return pcb_trace_hint;
-    },
-    pcb_trace_route_point: function() {
-        return pcb_trace_route_point;
-    },
-    pcb_trace_route_point_via: function() {
-        return pcb_trace_route_point_via;
-    },
-    pcb_trace_route_point_wire: function() {
-        return pcb_trace_route_point_wire;
-    },
-    pcb_via: function() {
-        return pcb_via;
-    },
-    point: function() {
-        return point;
-    },
-    point3: function() {
-        return point3;
-    },
-    position: function() {
-        return position;
-    },
-    position3: function() {
-        return position3;
-    },
-    resistance: function() {
-        return resistance;
-    },
-    rotation: function() {
-        return rotation;
-    },
-    route_hint_point: function() {
-        return route_hint_point;
-    },
-    schematic_box: function() {
-        return schematic_box;
-    },
-    schematic_component: function() {
-        return schematic_component;
-    },
-    schematic_error: function() {
-        return schematic_error;
-    },
-    schematic_line: function() {
-        return schematic_line;
-    },
-    schematic_net_label: function() {
-        return schematic_net_label;
-    },
-    schematic_path: function() {
-        return schematic_path;
-    },
-    schematic_pin_styles: function() {
-        return schematic_pin_styles;
-    },
-    schematic_port: function() {
-        return schematic_port;
-    },
-    schematic_text: function() {
-        return schematic_text;
-    },
-    schematic_trace: function() {
-        return schematic_trace;
-    },
-    size: function() {
-        return size;
-    },
-    source_component_base: function() {
-        return source_component_base;
-    },
-    source_group: function() {
-        return source_group;
-    },
-    source_led: function() {
-        return source_led;
-    },
-    source_net: function() {
-        return source_net;
-    },
-    source_port: function() {
-        return source_port;
-    },
-    source_simple_bug: function() {
-        return source_simple_bug;
-    },
-    source_simple_capacitor: function() {
-        return source_simple_capacitor;
-    },
-    source_simple_chip: function() {
-        return source_simple_chip;
-    },
-    source_simple_diode: function() {
-        return source_simple_diode;
-    },
-    source_simple_ground: function() {
-        return source_simple_ground;
-    },
-    source_simple_power_source: function() {
-        return source_simple_power_source;
-    },
-    source_simple_resistor: function() {
-        return source_simple_resistor;
-    },
-    source_trace: function() {
-        return source_trace;
-    },
-    supplier_name: function() {
-        return supplier_name;
-    },
-    time: function() {
-        return time;
-    },
-    visible_layer: function() {
-        return visible_layer;
-    },
-    voltage: function() {
-        return voltage;
-    }
-});
 var import_convert_units = __toESM(require_lib(), 1);
 // node_modules/zod/lib/index.mjs
 var util;
@@ -4835,8 +5640,8 @@ var makeIssue = function(params) {
         });
     }
     var errorMessage = "";
-    var maps = errorMaps.filter(function(m2) {
-        return !!m2;
+    var maps = errorMaps.filter(function(m) {
+        return !!m;
     }).slice().reverse();
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
@@ -10685,13 +11490,11 @@ var point = z.object({
     x: distance,
     y: distance
 });
-var position = point;
 var point3 = z.object({
     x: distance,
     y: distance,
     z: distance
 });
-var position3 = point3;
 var size = z.object({
     width: z.number(),
     height: z.number()
@@ -11394,7 +12197,6 @@ var any_circuit_element = z.union([
     schematic_net_label,
     cad_component
 ]);
-var any_soup_element = any_circuit_element;
 // src/components/CanvasPrimitiveRenderer.tsx
 var import_jsx_runtime2 = require("react/jsx-runtime");
 var CanvasPrimitiveRenderer = function(param) {
@@ -11464,275 +12266,8 @@ var CanvasPrimitiveRenderer = function(param) {
 };
 // src/components/CanvasElementsRenderer.tsx
 var import_react17 = require("react");
-// node_modules/@tscircuit/soup-util/dist/index.js
-var import_transformation_matrix2 = require("transformation-matrix");
-var su = function(soup) {
-    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-    var internalStore = soup._internal_store;
-    if (!internalStore) {
-        internalStore = {
-            counts: {}
-        };
-        soup._internal_store = internalStore;
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = soup[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var elm = _step.value;
-                var type = elm.type;
-                var idVal = elm["".concat(type, "_id")];
-                if (!idVal) continue;
-                var idNum = Number.parseInt(idVal.split("_").pop());
-                if (!Number.isNaN(idNum)) {
-                    var _internalStore_counts_type;
-                    internalStore.counts[type] = Math.max((_internalStore_counts_type = internalStore.counts[type]) !== null && _internalStore_counts_type !== void 0 ? _internalStore_counts_type : 0, idNum);
-                }
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-    }
-    var su2 = new Proxy({}, {
-        get: function(proxy_target, component_type) {
-            if (component_type === "toArray") {
-                return function() {
-                    return soup;
-                };
-            }
-            return {
-                get: function(id) {
-                    return soup.find(function(e) {
-                        return e.type === component_type && e["".concat(component_type, "_id")] === id;
-                    });
-                },
-                getUsing: function(using) {
-                    var keys = Object.keys(using);
-                    if (keys.length !== 1) {
-                        throw new Error("getUsing requires exactly one key, e.g. { pcb_component_id }");
-                    }
-                    var join_key = keys[0];
-                    var join_type = join_key.replace("_id", "");
-                    var joiner = soup.find(function(e) {
-                        return e.type === join_type && e[join_key] === using[join_key];
-                    });
-                    if (!joiner) return null;
-                    return soup.find(function(e) {
-                        return e.type === component_type && e["".concat(component_type, "_id")] === joiner["".concat(component_type, "_id")];
-                    });
-                },
-                getWhere: function(where) {
-                    var keys = Object.keys(where);
-                    return soup.find(function(e) {
-                        return e.type === component_type && keys.every(function(key) {
-                            return e[key] === where[key];
-                        });
-                    });
-                },
-                list: function(where) {
-                    var keys = !where ? [] : Object.keys(where);
-                    return soup.filter(function(e) {
-                        return e.type === component_type && keys.every(function(key) {
-                            return e[key] === where[key];
-                        });
-                    });
-                },
-                insert: function(elm) {
-                    var _a;
-                    var _component_type;
-                    (_component_type = (_a = internalStore.counts)[component_type]) !== null && _component_type !== void 0 ? _component_type : _a[component_type] = -1;
-                    internalStore.counts[component_type]++;
-                    var index = internalStore.counts[component_type];
-                    var newElm = _object_spread(_define_property({
-                        type: component_type
-                    }, "".concat(component_type, "_id"), "".concat(component_type, "_").concat(index)), elm);
-                    if (options.validateInserts) {
-                        var _dist_exports_component_type;
-                        var parser = (_dist_exports_component_type = dist_exports[component_type]) !== null && _dist_exports_component_type !== void 0 ? _dist_exports_component_type : any_soup_element;
-                        parser.parse(newElm);
-                    }
-                    soup.push(newElm);
-                    return newElm;
-                },
-                delete: function(id) {
-                    var elm = soup.find(function(e) {
-                        return e["".concat(component_type, "_id")] === id;
-                    });
-                    if (!elm) return;
-                    soup.splice(soup.indexOf(elm), 1);
-                },
-                update: function(id, newProps) {
-                    var elm = soup.find(function(e) {
-                        return e["".concat(component_type, "_id")] === id;
-                    });
-                    if (!elm) return;
-                    Object.assign(elm, newProps);
-                    return elm;
-                },
-                select: function(selector) {
-                    if (component_type === "source_component") {
-                        return soup.find(function(e) {
-                            return e.type === "source_component" && e.name === selector.replace(/\./g, "");
-                        });
-                    } else if (component_type === "pcb_port" || component_type === "source_port" || component_type === "schematic_port") {
-                        var _selector_replace_split = _sliced_to_array(selector.replace(/\./g, "").split(/[\s\>]+/), 2), component_name = _selector_replace_split[0], port_selector = _selector_replace_split[1];
-                        var source_component = soup.find(function(e) {
-                            return e.type === "source_component" && e.name === component_name;
-                        });
-                        if (!source_component) return null;
-                        var source_port2 = soup.find(function(e) {
-                            var _e_port_hints;
-                            return e.type === "source_port" && e.source_component_id === source_component.source_component_id && (e.name === port_selector || ((_e_port_hints = e.port_hints) !== null && _e_port_hints !== void 0 ? _e_port_hints : []).includes(port_selector));
-                        });
-                        if (!source_port2) return null;
-                        if (component_type === "source_port") return source_port2;
-                        if (component_type === "pcb_port") {
-                            return soup.find(function(e) {
-                                return e.type === "pcb_port" && e.source_port_id === source_port2.source_port_id;
-                            });
-                        } else if (component_type === "schematic_port") {
-                            return soup.find(function(e) {
-                                return e.type === "schematic_port" && e.source_port_id === source_port2.source_port_id;
-                            });
-                        }
-                    }
-                }
-            };
-        }
-    });
-    return su2;
-};
-su.unparsed = su;
-var su_default = su;
-var transformPCBElement = function(elm, matrix) {
-    if (elm.type === "pcb_plated_hole" || elm.type === "pcb_hole" || elm.type === "pcb_via" || elm.type === "pcb_smtpad" || elm.type === "pcb_port") {
-        var _ref = (0, import_transformation_matrix2.applyToPoint)(matrix, {
-            x: elm.x,
-            y: elm.y
-        }), x = _ref.x, y = _ref.y;
-        elm.x = x;
-        elm.y = y;
-    } else if (elm.type === "pcb_keepout" || elm.type === "pcb_board") {
-        elm.center = (0, import_transformation_matrix2.applyToPoint)(matrix, elm.center);
-    } else if (elm.type === "pcb_silkscreen_text" || elm.type === "pcb_fabrication_note_text") {
-        elm.anchor_position = (0, import_transformation_matrix2.applyToPoint)(matrix, elm.anchor_position);
-    } else if (elm.type === "pcb_silkscreen_circle" || elm.type === "pcb_silkscreen_rect" || elm.type === "pcb_component") {
-        elm.center = (0, import_transformation_matrix2.applyToPoint)(matrix, elm.center);
-    } else if (elm.type === "pcb_silkscreen_path" || elm.type === "pcb_trace" || elm.type === "pcb_fabrication_note_path") {
-        elm.route = elm.route.map(function(rp) {
-            var tp = (0, import_transformation_matrix2.applyToPoint)(matrix, rp);
-            rp.x = tp.x;
-            rp.y = tp.y;
-            return rp;
-        });
-    } else if (elm.type === "pcb_silkscreen_line") {
-        var p1 = {
-            x: elm.x1,
-            y: elm.y1
-        };
-        var p2 = {
-            x: elm.x2,
-            y: elm.y2
-        };
-        var p1t = (0, import_transformation_matrix2.applyToPoint)(matrix, p1);
-        var p2t = (0, import_transformation_matrix2.applyToPoint)(matrix, p2);
-        elm.x1 = p1t.x;
-        elm.y1 = p1t.y;
-        elm.x2 = p2t.x;
-        elm.y2 = p2t.y;
-    } else if (elm.type === "cad_component") {
-        var newPos = (0, import_transformation_matrix2.applyToPoint)(matrix, {
-            x: elm.position.x,
-            y: elm.position.y
-        });
-        elm.position.x = newPos.x;
-        elm.position.y = newPos.y;
-    }
-    return elm;
-};
-var getBoundsOfPcbElements = function(elements) {
-    var minX = Number.POSITIVE_INFINITY;
-    var minY = Number.POSITIVE_INFINITY;
-    var maxX = Number.NEGATIVE_INFINITY;
-    var maxY = Number.NEGATIVE_INFINITY;
-    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-    try {
-        for(var _iterator = elements[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-            var elm = _step.value;
-            if (!elm.type.startsWith("pcb_")) continue;
-            if ("x" in elm && "y" in elm) {
-                minX = Math.min(minX, elm.x);
-                minY = Math.min(minY, elm.y);
-                maxX = Math.max(maxX, elm.x);
-                maxY = Math.max(maxY, elm.y);
-                if ("width" in elm) {
-                    maxX = Math.max(maxX, elm.x + elm.width);
-                }
-                if ("height" in elm) {
-                    maxY = Math.max(maxY, elm.y + elm.height);
-                }
-                if ("radius" in elm) {
-                    minX = Math.min(minX, elm.x - elm.radius);
-                    minY = Math.min(minY, elm.y - elm.radius);
-                    maxX = Math.max(maxX, elm.x + elm.radius);
-                    maxY = Math.max(maxY, elm.y + elm.radius);
-                }
-            } else if (elm.type === "pcb_trace") {
-                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
-                try {
-                    for(var _iterator1 = elm.route[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
-                        var point2 = _step1.value;
-                        minX = Math.min(minX, point2.x);
-                        minY = Math.min(minY, point2.y);
-                        maxX = Math.max(maxX, point2.x);
-                        maxY = Math.max(maxY, point2.y);
-                    }
-                } catch (err) {
-                    _didIteratorError1 = true;
-                    _iteratorError1 = err;
-                } finally{
-                    try {
-                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                            _iterator1.return();
-                        }
-                    } finally{
-                        if (_didIteratorError1) {
-                            throw _iteratorError1;
-                        }
-                    }
-                }
-            }
-        }
-    } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
-            }
-        } finally{
-            if (_didIteratorError) {
-                throw _iteratorError;
-            }
-        }
-    }
-    return {
-        minX: minX,
-        minY: minY,
-        maxX: maxX,
-        maxY: maxY
-    };
-};
+// src/lib/convert-element-to-primitive.ts
+var import_soup_util = __toESM(require_dist());
 // src/lib/util/expand-stroke.ts
 function getExpandedStroke(strokeInput, defaultWidth) {
     if (strokeInput.length < 2) {
@@ -11814,14 +12349,14 @@ function getExpandedStroke(strokeInput, defaultWidth) {
 // src/lib/convert-element-to-primitive.ts
 var globalPcbDrawingObjectCount = 0;
 var convertElementToPrimitives = function(element, allElements) {
-    var _su_default_pcb_port_get;
+    var _pcb_port_get;
     var _parent_pcb_component = "pcb_component_id" in element ? allElements.find(function(elm) {
         return elm.type === "pcb_component" && elm.pcb_component_id === element.pcb_component_id;
     }) : void 0;
     var _parent_source_component = _parent_pcb_component && "source_component_id" in _parent_pcb_component ? allElements.find(function(elm) {
         return elm.type === "source_component" && elm.source_component_id === _parent_pcb_component.source_component_id;
     }) : void 0;
-    var _source_port_id = "source_port_id" in element ? element.source_port_id : "pcb_port_id" in element ? (_su_default_pcb_port_get = su_default(allElements).pcb_port.get(element.pcb_port_id)) === null || _su_default_pcb_port_get === void 0 ? void 0 : _su_default_pcb_port_get.source_port_id : void 0;
+    var _source_port_id = "source_port_id" in element ? element.source_port_id : "pcb_port_id" in element ? (_pcb_port_get = (0, import_soup_util.su)(allElements).pcb_port.get(element.pcb_port_id)) === null || _pcb_port_get === void 0 ? void 0 : _pcb_port_get.source_port_id : void 0;
     var _source_port = _source_port_id ? allElements.find(function(e) {
         return e.type === "source_port" && e.source_port_id === _source_port_id;
     }) : void 0;
@@ -12341,7 +12876,7 @@ var convertElementToPrimitives = function(element, allElements) {
 // src/components/MouseElementTracker.tsx
 var import_react6 = require("react");
 var import_react7 = require("react");
-var import_transformation_matrix3 = require("transformation-matrix");
+var import_transformation_matrix2 = require("transformation-matrix");
 // src/components/ElementOverlayBox.tsx
 var import_react5 = require("react");
 var import_jsx_runtime3 = require("react/jsx-runtime");
@@ -12479,7 +13014,7 @@ var MouseElementTracker = function(param) {
                 if (((_primitive__element = primitive._element) === null || _primitive__element === void 0 ? void 0 : _primitive__element.type) === "pcb_via") return "continue";
                 if (((_primitive__element1 = primitive._element) === null || _primitive__element1 === void 0 ? void 0 : _primitive__element1.type) === "pcb_component") return "continue";
                 if ((primitive === null || primitive === void 0 ? void 0 : primitive.layer) === "drill") return "continue";
-                var screenPos = (0, import_transformation_matrix3.applyToPoint)(transform, primitive);
+                var screenPos = (0, import_transformation_matrix2.applyToPoint)(transform, primitive);
                 var w = "w" in primitive ? primitive.w : "r" in primitive ? primitive.r * 2 : 0;
                 var h = "h" in primitive ? primitive.h : "r" in primitive ? primitive.r * 2 : 0;
                 var screenSize = {
@@ -12526,7 +13061,7 @@ var MouseElementTracker = function(param) {
                 var rect = e.currentTarget.getBoundingClientRect();
                 var x = e.clientX - rect.left;
                 var y = e.clientY - rect.top;
-                var rwPoint = (0, import_transformation_matrix3.applyToPoint)((0, import_transformation_matrix3.inverse)(transform), {
+                var rwPoint = (0, import_transformation_matrix2.applyToPoint)((0, import_transformation_matrix2.inverse)(transform), {
                     x: x,
                     y: y
                 });
@@ -12578,11 +13113,11 @@ var MouseElementTracker = function(param) {
 };
 // src/components/DimensionOverlay.tsx
 var import_react8 = require("react");
-var import_transformation_matrix4 = require("transformation-matrix");
+var import_transformation_matrix3 = require("transformation-matrix");
 var import_jsx_runtime5 = require("react/jsx-runtime");
 var DimensionOverlay = function(param) {
     var children = param.children, transform = param.transform;
-    if (!transform) transform = (0, import_transformation_matrix4.identity)();
+    if (!transform) transform = (0, import_transformation_matrix3.identity)();
     var _ref = _sliced_to_array((0, import_react8.useState)(false), 2), dimensionToolVisible = _ref[0], setDimensionToolVisible = _ref[1];
     var _ref1 = _sliced_to_array((0, import_react8.useState)(false), 2), dimensionToolStretching = _ref1[0], setDimensionToolStretching = _ref1[1];
     var _ref2 = _sliced_to_array((0, import_react8.useState)({
@@ -12650,8 +13185,8 @@ var DimensionOverlay = function(param) {
     }, [
         containerRef
     ]);
-    var screenDStart = (0, import_transformation_matrix4.applyToPoint)(transform, dStart);
-    var screenDEnd = (0, import_transformation_matrix4.applyToPoint)(transform, dEnd);
+    var screenDStart = (0, import_transformation_matrix3.applyToPoint)(transform, dStart);
+    var screenDEnd = (0, import_transformation_matrix3.applyToPoint)(transform, dEnd);
     var arrowScreenBounds = {
         left: Math.min(screenDStart.x, screenDEnd.x),
         right: Math.max(screenDStart.x, screenDEnd.x),
@@ -12684,7 +13219,7 @@ var DimensionOverlay = function(param) {
             var rect = e.currentTarget.getBoundingClientRect();
             var x = e.clientX - rect.left;
             var y = e.clientY - rect.top;
-            var rwPoint = (0, import_transformation_matrix4.applyToPoint)((0, import_transformation_matrix4.inverse)(transform), {
+            var rwPoint = (0, import_transformation_matrix3.applyToPoint)((0, import_transformation_matrix3.inverse)(transform), {
                 x: x,
                 y: y
             });
@@ -12846,7 +13381,7 @@ var import_css = require("@emotion/css");
 // package.json
 var package_default = {
     name: "@tscircuit/pcb-viewer",
-    version: "1.10.9",
+    version: "1.10.10",
     main: "dist/index.js",
     repository: "tscircuit/pcb-viewer",
     license: "MIT",
@@ -12869,10 +13404,12 @@ var package_default = {
         "@storybook/nextjs": "^8.0.6",
         "@storybook/react": "^8.0.6",
         "@swc/core": "^1.4.12",
-        "@tscircuit/core": "^0.0.106",
+        "@tscircuit/builder": "^1.11.4",
+        "@tscircuit/core": "^0.0.88",
         "@tscircuit/eagle-xml-converter": "^0.0.6",
         "@tscircuit/props": "^0.0.46",
-        "@tscircuit/soup-util": "^0.0.32",
+        "@tscircuit/react-fiber": "^1.1.25",
+        "@tscircuit/soup-util": "^0.0.13",
         "@types/color": "^3.0.6",
         "@types/node": "18.7.23",
         "@types/react": "^18.3.3",
@@ -12889,8 +13426,9 @@ var package_default = {
         zod: "^3.23.5"
     },
     peerDependencies: {
-        react: "*",
-        "@tscircuit/core": "*"
+        "@tscircuit/builder": "*",
+        "@tscircuit/react-fiber": "*",
+        react: "*"
     },
     dependencies: {
         "@emotion/css": "^11.11.2",
@@ -13207,7 +13745,7 @@ var ToolbarOverlay = function(param) {
 // src/components/ErrorOverlay.tsx
 var import_css2 = require("@emotion/css");
 var import_react11 = require("react");
-var import_transformation_matrix5 = require("transformation-matrix");
+var import_transformation_matrix4 = require("transformation-matrix");
 var import_jsx_runtime7 = require("react/jsx-runtime");
 var ErrorSVG = function(param) {
     var screenPort1 = param.screenPort1, screenPort2 = param.screenPort2, errorCenter = param.errorCenter, canLineBeDrawn = param.canLineBeDrawn;
@@ -13256,7 +13794,7 @@ var ErrorSVG = function(param) {
 };
 var ErrorOverlay = function(param) {
     var children = param.children, transform = param.transform, elements = param.elements;
-    if (!transform) transform = (0, import_transformation_matrix5.identity)();
+    if (!transform) transform = (0, import_transformation_matrix4.identity)();
     var containerRef = (0, import_react11.useRef)(null);
     return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", {
         style: {
@@ -13276,11 +13814,11 @@ var ErrorOverlay = function(param) {
                     return el2.type === "pcb_port" && el2.pcb_port_id === (pcb_port_ids === null || pcb_port_ids === void 0 ? void 0 : pcb_port_ids[1]);
                 });
                 if (!port1 || !port2) return null;
-                var screenPort1 = (0, import_transformation_matrix5.applyToPoint)(transform, {
+                var screenPort1 = (0, import_transformation_matrix4.applyToPoint)(transform, {
                     x: port1.x,
                     y: port1.y
                 });
-                var screenPort2 = (0, import_transformation_matrix5.applyToPoint)(transform, {
+                var screenPort2 = (0, import_transformation_matrix4.applyToPoint)(transform, {
                     x: port2.x,
                     y: port2.y
                 });
@@ -13320,7 +13858,7 @@ var ErrorOverlay = function(param) {
 };
 // src/components/EditPlacementOverlay.tsx
 var import_react12 = require("react");
-var import_transformation_matrix6 = require("transformation-matrix");
+var import_transformation_matrix5 = require("transformation-matrix");
 var import_jsx_runtime8 = require("react/jsx-runtime");
 var isInsideOf = function(pcb_component2, point2) {
     var padding = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
@@ -13334,7 +13872,7 @@ var isInsideOf = function(pcb_component2, point2) {
 };
 var EditPlacementOverlay = function(param) {
     var children = param.children, disabledProp = param.disabled, transform = param.transform, soup = param.soup, cancelPanDrag = param.cancelPanDrag, onCreateEditEvent = param.onCreateEditEvent, onModifyEditEvent = param.onModifyEditEvent;
-    if (!transform) transform = (0, import_transformation_matrix6.identity)();
+    if (!transform) transform = (0, import_transformation_matrix5.identity)();
     var containerRef = (0, import_react12.useRef)(null);
     var _ref = _sliced_to_array((0, import_react12.useState)(null), 2), activePcbComponentId = _ref[0], setActivePcbComponent = _ref[1];
     var _ref1 = _sliced_to_array((0, import_react12.useState)(null), 2), dragState = _ref1[0], setDragState = _ref1[1];
@@ -13361,7 +13899,7 @@ var EditPlacementOverlay = function(param) {
             var x = e.clientX - rect.left;
             var y = e.clientY - rect.top;
             if (isNaN(x) || isNaN(y)) return;
-            var rwMousePoint = (0, import_transformation_matrix6.applyToPoint)((0, import_transformation_matrix6.inverse)(transform), {
+            var rwMousePoint = (0, import_transformation_matrix5.applyToPoint)((0, import_transformation_matrix5.inverse)(transform), {
                 x: x,
                 y: y
             });
@@ -13422,7 +13960,7 @@ var EditPlacementOverlay = function(param) {
             var x = e.clientX - rect.left;
             var y = e.clientY - rect.top;
             if (isNaN(x) || isNaN(y)) return;
-            var rwMousePoint = (0, import_transformation_matrix6.applyToPoint)((0, import_transformation_matrix6.inverse)(transform), {
+            var rwMousePoint = (0, import_transformation_matrix5.applyToPoint)((0, import_transformation_matrix5.inverse)(transform), {
                 x: x,
                 y: y
             });
@@ -13455,7 +13993,7 @@ var EditPlacementOverlay = function(param) {
                 return e.type === "pcb_component";
             }).map(function(e) {
                 if (!(e === null || e === void 0 ? void 0 : e.center)) return null;
-                var projectedCenter = (0, import_transformation_matrix6.applyToPoint)(transform, e.center);
+                var projectedCenter = (0, import_transformation_matrix5.applyToPoint)(transform, e.center);
                 return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", {
                     style: {
                         position: "absolute",
@@ -13474,8 +14012,9 @@ var EditPlacementOverlay = function(param) {
     });
 };
 // src/components/EditTraceHintOverlay.tsx
+var import_soup_util2 = __toESM(require_dist());
 var import_react15 = require("react");
-var import_transformation_matrix7 = require("transformation-matrix");
+var import_transformation_matrix6 = require("transformation-matrix");
 // src/components/HotkeyActionMenu.tsx
 var import_css3 = require("@emotion/css");
 var import_react13 = require("react");
@@ -13584,7 +14123,7 @@ var isInsideOfPlatedHole = function(hole, point2) {
 var EditTraceHintOverlay = function(param) {
     var children = param.children, disabledProp = param.disabled, transform = param.transform, soup = param.soup, cancelPanDrag = param.cancelPanDrag, onCreateEditEvent = param.onCreateEditEvent, onModifyEditEvent = param.onModifyEditEvent;
     var _containerRef_current;
-    if (!transform) transform = (0, import_transformation_matrix7.identity)();
+    if (!transform) transform = (0, import_transformation_matrix6.identity)();
     var containerRef = (0, import_react15.useRef)(null);
     var containerBounds = (_containerRef_current = containerRef.current) === null || _containerRef_current === void 0 ? void 0 : _containerRef_current.getBoundingClientRect();
     var _ref = _sliced_to_array((0, import_react15.useState)(null), 2), selectedElement = _ref[0], setSelectedElement = _ref[1];
@@ -13598,8 +14137,8 @@ var EditTraceHintOverlay = function(param) {
     var disabled = disabledProp || !in_edit_trace_mode;
     var ogCenterScreen, dragEndScreen;
     if ((dragState === null || dragState === void 0 ? void 0 : dragState.originalCenter) && (dragState === null || dragState === void 0 ? void 0 : dragState.dragEnd)) {
-        ogCenterScreen = (0, import_transformation_matrix7.applyToPoint)(transform, dragState === null || dragState === void 0 ? void 0 : dragState.originalCenter);
-        dragEndScreen = (0, import_transformation_matrix7.applyToPoint)(transform, dragState === null || dragState === void 0 ? void 0 : dragState.dragEnd);
+        ogCenterScreen = (0, import_transformation_matrix6.applyToPoint)(transform, dragState === null || dragState === void 0 ? void 0 : dragState.originalCenter);
+        dragEndScreen = (0, import_transformation_matrix6.applyToPoint)(transform, dragState === null || dragState === void 0 ? void 0 : dragState.dragEnd);
     }
     (0, import_react15.useEffect)(function() {
         var keyDown = function keyDown(e) {
@@ -13628,7 +14167,7 @@ var EditTraceHintOverlay = function(param) {
             var x = e.clientX - rect.left;
             var y = e.clientY - rect.top;
             if (isNaN(x) || isNaN(y)) return;
-            var rwMousePoint = (0, import_transformation_matrix7.applyToPoint)((0, import_transformation_matrix7.inverse)(transform), {
+            var rwMousePoint = (0, import_transformation_matrix6.applyToPoint)((0, import_transformation_matrix6.inverse)(transform), {
                 x: x,
                 y: y
             });
@@ -13693,7 +14232,7 @@ var EditTraceHintOverlay = function(param) {
             var x = e.clientX - rect.left;
             var y = e.clientY - rect.top;
             if (isNaN(x) || isNaN(y)) return;
-            var rwMousePoint = (0, import_transformation_matrix7.applyToPoint)((0, import_transformation_matrix7.inverse)(transform), {
+            var rwMousePoint = (0, import_transformation_matrix6.applyToPoint)((0, import_transformation_matrix6.inverse)(transform), {
                 x: x,
                 y: y
             });
@@ -13712,14 +14251,14 @@ var EditTraceHintOverlay = function(param) {
             var x = e.clientX - rect.left;
             var y = e.clientY - rect.top;
             if (isNaN(x) || isNaN(y)) return;
-            var rwMousePoint = (0, import_transformation_matrix7.applyToPoint)((0, import_transformation_matrix7.inverse)(transform), {
+            var rwMousePoint = (0, import_transformation_matrix6.applyToPoint)((0, import_transformation_matrix6.inverse)(transform), {
                 x: x,
                 y: y
             });
             if (dragState) {
                 cancelPanDrag();
                 var _dragState_editEvent_route_slice_;
-                var lastPointScreen = (0, import_transformation_matrix7.applyToPoint)(transform, (_dragState_editEvent_route_slice_ = dragState.editEvent.route.slice(-1)[0]) !== null && _dragState_editEvent_route_slice_ !== void 0 ? _dragState_editEvent_route_slice_ : dragState.originalCenter);
+                var lastPointScreen = (0, import_transformation_matrix6.applyToPoint)(transform, (_dragState_editEvent_route_slice_ = dragState.editEvent.route.slice(-1)[0]) !== null && _dragState_editEvent_route_slice_ !== void 0 ? _dragState_editEvent_route_slice_ : dragState.originalCenter);
                 var distanceFromLastPoint = Math.sqrt(Math.pow(x - lastPointScreen.x, 2) + Math.pow(y - lastPointScreen.y, 2));
                 if (distanceFromLastPoint < 20) {
                     onCreateEditEvent(_object_spread_props(_object_spread({}, dragState.editEvent), {
@@ -13757,13 +14296,13 @@ var EditTraceHintOverlay = function(param) {
                     /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("path", {
                         stroke: "red",
                         d: "M ".concat(ogCenterScreen.x, " ").concat(ogCenterScreen.y, " ").concat(dragState === null || dragState === void 0 ? void 0 : dragState.editEvent.route.map(function(p) {
-                            return (0, import_transformation_matrix7.applyToPoint)(transform, p);
+                            return (0, import_transformation_matrix6.applyToPoint)(transform, p);
                         }).map(function(p) {
                             return "L ".concat(p.x, " ").concat(p.y);
                         }).join(" "), " L ").concat(dragEndScreen.x, " ").concat(dragEndScreen.y)
                     }),
                     dragState === null || dragState === void 0 ? void 0 : dragState.editEvent.route.map(function(r, i) {
-                        var rScreen = (0, import_transformation_matrix7.applyToPoint)(transform, r);
+                        var rScreen = (0, import_transformation_matrix6.applyToPoint)(transform, r);
                         return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_react15.Fragment, {
                             children: [
                                 r.via && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("circle", {
@@ -13810,8 +14349,8 @@ var EditTraceHintOverlay = function(param) {
                     return e.type === "pcb_trace_hint";
                 }).map(function(e) {
                     var route = e.route;
-                    var pcb_port2 = su_default(soup).pcb_port.get(e.pcb_port_id);
-                    var pcb_port_screen = (0, import_transformation_matrix7.applyToPoint)(transform, pcb_port2);
+                    var pcb_port2 = (0, import_soup_util2.su)(soup).pcb_port.get(e.pcb_port_id);
+                    var pcb_port_screen = (0, import_transformation_matrix6.applyToPoint)(transform, pcb_port2);
                     return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_react15.Fragment, {
                         children: [
                             /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("rect", {
@@ -13824,13 +14363,13 @@ var EditTraceHintOverlay = function(param) {
                             /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("path", {
                                 stroke: "red",
                                 d: "M ".concat(pcb_port_screen.x, " ").concat(pcb_port_screen.y, " ").concat(route.map(function(r) {
-                                    return (0, import_transformation_matrix7.applyToPoint)(transform, r);
+                                    return (0, import_transformation_matrix6.applyToPoint)(transform, r);
                                 }).map(function(r) {
                                     return "L ".concat(r.x, " ").concat(r.y);
                                 }).join(" "))
                             }, "path-".concat(e.pcb_port_id)),
                             route.map(function(r) {
-                                return _object_spread({}, r, (0, import_transformation_matrix7.applyToPoint)(transform, r));
+                                return _object_spread({}, r, (0, import_transformation_matrix6.applyToPoint)(transform, r));
                             }).map(function(r, i) {
                                 return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_react15.Fragment, {
                                     children: [
@@ -13876,7 +14415,8 @@ var EditTraceHintOverlay = function(param) {
     });
 };
 // src/components/RatsNestOverlay.tsx
-var import_transformation_matrix8 = require("transformation-matrix");
+var import_transformation_matrix7 = require("transformation-matrix");
+var import_soup_util3 = __toESM(require_dist());
 var import_jsx_runtime12 = require("react/jsx-runtime");
 var RatsNestOverlay = function(param) {
     var transform = param.transform, soup = param.soup, children = param.children;
@@ -13884,14 +14424,14 @@ var RatsNestOverlay = function(param) {
         return s.is_showing_rats_nest;
     });
     if (!soup || !isShowingRatsNest) return children;
-    if (!transform) transform = (0, import_transformation_matrix8.identity)();
-    var sourceTraces = su_default(soup).source_trace.list();
+    if (!transform) transform = (0, import_transformation_matrix7.identity)();
+    var sourceTraces = (0, import_soup_util3.su)(soup).source_trace.list();
     var groups = [];
     sourceTraces.forEach(function(sourceTrace) {
         if (sourceTrace.connected_source_port_ids) {
             var group = [];
             sourceTrace.connected_source_port_ids.forEach(function(source_port_id) {
-                var pcbPort = su_default(soup).pcb_port.getWhere({
+                var pcbPort = (0, import_soup_util3.su)(soup).pcb_port.getWhere({
                     source_port_id: source_port_id
                 });
                 if (pcbPort) group.push(pcbPort);
@@ -13918,7 +14458,7 @@ var RatsNestOverlay = function(param) {
                 },
                 children: groups.map(function(group, index) {
                     var points = group.map(function(port) {
-                        return (0, import_transformation_matrix8.applyToPoint)(transform, {
+                        return (0, import_transformation_matrix7.applyToPoint)(transform, {
                             x: port.x,
                             y: port.y
                         });
@@ -14085,7 +14625,7 @@ var CanvasElementsRenderer = function(props) {
     });
 };
 // src/PCBViewer.tsx
-var import_use_mouse_matrix_transform = __toESM(require_dist());
+var import_use_mouse_matrix_transform = __toESM(require_dist2());
 // node_modules/react-use/esm/misc/util.js
 var noop = function noop() {};
 var isBrowser = typeof window !== "undefined";
@@ -14146,10 +14686,13 @@ var useMeasure_default = isBrowser && typeof window.ResizeObserver !== "undefine
     ];
 };
 // src/PCBViewer.tsx
-var import_transformation_matrix10 = require("transformation-matrix");
-// src/lib/apply-edit-events.ts
 var import_transformation_matrix9 = require("transformation-matrix");
+var import_builder2 = require("@tscircuit/builder");
+// src/lib/apply-edit-events.ts
+var import_soup_util5 = __toESM(require_dist());
+var import_transformation_matrix8 = require("transformation-matrix");
 // src/lib/apply-edit-events/apply-edit-trace-hint-event.ts
+var import_soup_util4 = __toESM(require_dist());
 var applyTraceHintEditEvent = function(soup, edit_event) {
     var existing_trace_hint = soup.find(function(th) {
         return th.type === "pcb_trace_hint" && th.pcb_trace_hint_id === edit_event.pcb_trace_hint_id;
@@ -14161,7 +14704,7 @@ var applyTraceHintEditEvent = function(soup, edit_event) {
             }) : e;
         });
     } else {
-        var pcb_port2 = su_default(soup).pcb_port.get(edit_event.pcb_port_id);
+        var pcb_port2 = (0, import_soup_util4.su)(soup).pcb_port.get(edit_event.pcb_port_id);
         soup = soup.filter(function(e) {
             return !(e.type === "pcb_trace_hint" && e.pcb_port_id === edit_event.pcb_port_id);
         }).concat([
@@ -14184,9 +14727,9 @@ var applyEditEvents = function(soup, edit_events) {
         var _loop = function() {
             var edit_event = _step.value;
             if (edit_event.pcb_edit_event_type === "edit_component_location") {
-                var mat = (0, import_transformation_matrix9.translate)(edit_event.new_center.x - edit_event.original_center.x, edit_event.new_center.y - edit_event.original_center.y);
+                var mat = (0, import_transformation_matrix8.translate)(edit_event.new_center.x - edit_event.original_center.x, edit_event.new_center.y - edit_event.original_center.y);
                 soup = soup.map(function(e) {
-                    return e.pcb_component_id !== edit_event.pcb_component_id ? e : transformPCBElement(e, mat);
+                    return e.pcb_component_id !== edit_event.pcb_component_id ? e : (0, import_soup_util5.transformPCBElement)(e, mat);
                 });
             } else if (edit_event.pcb_edit_event_type === "edit_trace_hint") {
                 soup = applyTraceHintEditEvent(soup, edit_event);
@@ -14210,28 +14753,20 @@ var applyEditEvents = function(soup, edit_events) {
     return soup;
 };
 // src/PCBViewer.tsx
-var import_core = require("@tscircuit/core");
 var import_jsx_runtime14 = require("react/jsx-runtime");
-var defaultTransform = (0, import_transformation_matrix10.compose)((0, import_transformation_matrix10.translate)(400, 300), (0, import_transformation_matrix10.scale)(40, -40));
+var defaultTransform = (0, import_transformation_matrix9.compose)((0, import_transformation_matrix9.translate)(400, 300), (0, import_transformation_matrix9.scale)(40, -40));
 var PCBViewer = function(param) {
     var children = param.children, soup = param.soup, _param_height = param.height, height = _param_height === void 0 ? 600 : _param_height, initialState = param.initialState, _param_allowEditing = param.allowEditing, allowEditing = _param_allowEditing === void 0 ? true : _param_allowEditing, editEventsProp = param.editEvents, onEditEventsChanged = param.onEditEventsChanged;
-    var _ref = (0, import_core.useRenderedCircuit)(children), circuitJsonFromChildren = _ref.circuitJson, errorFromChildren = _ref.error;
-    var _ref1;
-    var stateElements = (_ref1 = circuitJsonFromChildren !== null && circuitJsonFromChildren !== void 0 ? circuitJsonFromChildren : soup) !== null && _ref1 !== void 0 ? _ref1 : [];
+    var _ref = _sliced_to_array((0, import_react20.useState)([]), 2), stateElements = _ref[0], setStateElements = _ref[1];
     var _useMeasure_default = _sliced_to_array(useMeasure_default(), 2), ref = _useMeasure_default[0], refDimensions = _useMeasure_default[1];
-    var _ref2 = _sliced_to_array((0, import_react20.useState)(defaultTransform), 2), transform = _ref2[0], setTransformInternal = _ref2[1];
-    var _ref3 = (0, import_use_mouse_matrix_transform.default)({
+    var _ref1 = _sliced_to_array((0, import_react20.useState)(defaultTransform), 2), transform = _ref1[0], setTransformInternal = _ref1[1];
+    var _ref2 = (0, import_use_mouse_matrix_transform.default)({
         transform: transform,
         onSetTransform: setTransformInternal
-    }), transformRef = _ref3.ref, setTransform = _ref3.setTransform, cancelPanDrag = _ref3.cancelDrag;
-    var _ref4 = _sliced_to_array((0, import_react20.useState)([]), 2), editEvents = _ref4[0], setEditEvents = _ref4[1];
+    }), transformRef = _ref2.ref, setTransform = _ref2.setTransform, cancelPanDrag = _ref2.cancelDrag;
+    var _ref3 = _sliced_to_array((0, import_react20.useState)([]), 2), editEvents = _ref3[0], setEditEvents = _ref3[1];
     editEvents = editEventsProp !== null && editEventsProp !== void 0 ? editEventsProp : editEvents;
-    var _ref5 = _sliced_to_array((0, import_react20.useState)(null), 2), error = _ref5[0], setError = _ref5[1];
-    (0, import_react20.useEffect)(function() {
-        setError(errorFromChildren ? errorFromChildren.toString() : null);
-    }, [
-        errorFromChildren
-    ]);
+    var _ref4 = _sliced_to_array((0, import_react20.useState)(null), 2), error = _ref4[0], setError = _ref4[1];
     var resetTransform = function() {
         var elmBounds = (refDimensions === null || refDimensions === void 0 ? void 0 : refDimensions.width) > 0 ? refDimensions : {
             width: 500,
@@ -14239,26 +14774,58 @@ var PCBViewer = function(param) {
         };
         var _ref = elements.some(function(e) {
             return e.type.startsWith("pcb_");
-        }) ? getBoundsOfPcbElements(elements.filter(function(e) {
+        }) ? (0, import_builder2.findBoundsAndCenter)(elements.filter(function(e) {
             return e.type.startsWith("pcb_");
         })) : {
-            minX: -1e-3,
-            minY: -1e-3,
-            maxX: 1e-3,
-            maxY: 1e-3
-        }, minX = _ref.minX, minY = _ref.minY, maxX = _ref.maxX, maxY = _ref.maxY;
-        var width = maxX - minX;
-        var height2 = maxY - minY;
-        var center = {
-            x: (minX + maxX) / 2,
-            y: (minY + maxY) / 2
-        };
+            center: {
+                x: 0,
+                y: 0
+            },
+            width: 1e-3,
+            height: 1e-3
+        }, center = _ref.center, width = _ref.width, height2 = _ref.height;
         var _elmBounds_width, _elmBounds_height;
         var scaleFactor = Math.min(((_elmBounds_width = elmBounds.width) !== null && _elmBounds_width !== void 0 ? _elmBounds_width : 0) / width, ((_elmBounds_height = elmBounds.height) !== null && _elmBounds_height !== void 0 ? _elmBounds_height : 0) / height2, 100) * 0.75;
         var _elmBounds_width1, _elmBounds_height1;
-        setTransform((0, import_transformation_matrix10.compose)((0, import_transformation_matrix10.translate)(((_elmBounds_width1 = elmBounds.width) !== null && _elmBounds_width1 !== void 0 ? _elmBounds_width1 : 0) / 2, ((_elmBounds_height1 = elmBounds.height) !== null && _elmBounds_height1 !== void 0 ? _elmBounds_height1 : 0) / 2), // translate(100, 0),
-        (0, import_transformation_matrix10.scale)(scaleFactor, -scaleFactor, 0, 0), (0, import_transformation_matrix10.translate)(-center.x, -center.y)));
+        setTransform((0, import_transformation_matrix9.compose)((0, import_transformation_matrix9.translate)(((_elmBounds_width1 = elmBounds.width) !== null && _elmBounds_width1 !== void 0 ? _elmBounds_width1 : 0) / 2, ((_elmBounds_height1 = elmBounds.height) !== null && _elmBounds_height1 !== void 0 ? _elmBounds_height1 : 0) / 2), // translate(100, 0),
+        (0, import_transformation_matrix9.scale)(scaleFactor, -scaleFactor, 0, 0), (0, import_transformation_matrix9.translate)(-center.x, -center.y)));
     };
+    (0, import_react20.useEffect)(function() {
+        var doRender = function doRender() {
+            return _doRender.apply(this, arguments);
+        };
+        if (!children || (children === null || children === void 0 ? void 0 : children.length) === 0) return;
+        function _doRender() {
+            _doRender = _async_to_generator(function() {
+                var projectBuilder;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            projectBuilder = (0, import_builder.createProjectBuilder)();
+                            return [
+                                4,
+                                (0, import_react_fiber.createRoot)().render(children, projectBuilder).then(function(elements2) {
+                                    setStateElements(elements2);
+                                    setError(null);
+                                })
+                            ];
+                        case 1:
+                            _state.sent();
+                            return [
+                                2
+                            ];
+                    }
+                });
+            });
+            return _doRender.apply(this, arguments);
+        }
+        doRender().catch(function(e) {
+            setError(e.toString());
+            console.log(e.toString());
+        });
+    }, [
+        children
+    ]);
     (0, import_react20.useEffect)(function() {
         if (refDimensions && refDimensions.width !== 0 && (children || soup)) {
             resetTransform();