@tscircuit/pcb-viewer 1.10.17 → 1.10.18

package/dist/index.js

@@ -555,2407 +555,6 @@ var __toCommonJS = function(mod) {
         value: true
     }), mod);
 };
-// node_modules/lodash._objecttypes/index.js
-var require_lodash = __commonJS({
-    "node_modules/lodash._objecttypes/index.js": function(exports2, module2) {
-        var objectTypes = {
-            "boolean": false,
-            "function": true,
-            "object": true,
-            "number": false,
-            "string": false,
-            "undefined": false
-        };
-        module2.exports = objectTypes;
-    }
-});
-// node_modules/lodash.isobject/index.js
-var require_lodash2 = __commonJS({
-    "node_modules/lodash.isobject/index.js": function(exports2, module2) {
-        var objectTypes = require_lodash();
-        function isObject(value) {
-            return !!(value && objectTypes[typeof value === "undefined" ? "undefined" : _type_of(value)]);
-        }
-        module2.exports = isObject;
-    }
-});
-// node_modules/lodash._renative/index.js
-var require_lodash3 = __commonJS({
-    "node_modules/lodash._renative/index.js": function(exports2, module2) {
-        var objectProto = Object.prototype;
-        var toString = objectProto.toString;
-        var reNative = RegExp("^" + String(toString).replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/toString| for [^\]]+/g, ".*?") + "$");
-        module2.exports = reNative;
-    }
-});
-// node_modules/lodash._shimkeys/index.js
-var require_lodash4 = __commonJS({
-    "node_modules/lodash._shimkeys/index.js": function(exports2, module2) {
-        var objectTypes = require_lodash();
-        var objectProto = Object.prototype;
-        var hasOwnProperty = objectProto.hasOwnProperty;
-        var shimKeys = function shimKeys(object) {
-            var index, iterable = object, result = [];
-            if (!iterable) return result;
-            if (!objectTypes[typeof object === "undefined" ? "undefined" : _type_of(object)]) return result;
-            for(index in iterable){
-                if (hasOwnProperty.call(iterable, index)) {
-                    result.push(index);
-                }
-            }
-            return result;
-        };
-        module2.exports = shimKeys;
-    }
-});
-// node_modules/lodash.keys/index.js
-var require_lodash5 = __commonJS({
-    "node_modules/lodash.keys/index.js": function(exports2, module2) {
-        var isObject = require_lodash2();
-        var reNative = require_lodash3();
-        var shimKeys = require_lodash4();
-        var nativeKeys = reNative.test(nativeKeys = Object.keys) && nativeKeys;
-        var keys = !nativeKeys ? shimKeys : function keys(object) {
-            if (!isObject(object)) {
-                return [];
-            }
-            return nativeKeys(object);
-        };
-        module2.exports = keys;
-    }
-});
-// node_modules/lodash.noop/index.js
-var require_lodash6 = __commonJS({
-    "node_modules/lodash.noop/index.js": function(exports2, module2) {
-        function noop2() {}
-        module2.exports = noop2;
-    }
-});
-// node_modules/lodash._basecreate/index.js
-var require_lodash7 = __commonJS({
-    "node_modules/lodash._basecreate/index.js": function(exports2, module2) {
-        var isObject = require_lodash2();
-        var noop2 = require_lodash6();
-        var reNative = require_lodash3();
-        var nativeCreate = reNative.test(nativeCreate = Object.create) && nativeCreate;
-        function baseCreate(prototype, properties) {
-            return isObject(prototype) ? nativeCreate(prototype) : {};
-        }
-        if (!nativeCreate) {
-            baseCreate = /* @__PURE__ */ function() {
-                function Object2() {}
-                return function(prototype) {
-                    if (isObject(prototype)) {
-                        Object2.prototype = prototype;
-                        var result = new Object2();
-                        Object2.prototype = null;
-                    }
-                    return result || global.Object();
-                };
-            }();
-        }
-        module2.exports = baseCreate;
-    }
-});
-// node_modules/lodash._setbinddata/index.js
-var require_lodash8 = __commonJS({
-    "node_modules/lodash._setbinddata/index.js": function(exports2, module2) {
-        var noop2 = require_lodash6();
-        var reNative = require_lodash3();
-        var descriptor = {
-            "configurable": false,
-            "enumerable": false,
-            "value": null,
-            "writable": false
-        };
-        var defineProperty = function() {
-            try {
-                var o = {}, func = reNative.test(func = Object.defineProperty) && func, result = func(o, o, o) && func;
-            } catch (e) {}
-            return result;
-        }();
-        var setBindData = !defineProperty ? noop2 : function setBindData(func, value) {
-            descriptor.value = value;
-            defineProperty(func, "__bindData__", descriptor);
-        };
-        module2.exports = setBindData;
-    }
-});
-// node_modules/lodash._basebind/index.js
-var require_lodash9 = __commonJS({
-    "node_modules/lodash._basebind/index.js": function(exports2, module2) {
-        var baseCreate = require_lodash7();
-        var isObject = require_lodash2();
-        var setBindData = require_lodash8();
-        var arrayRef = [];
-        var push = arrayRef.push;
-        function baseBind(bindData) {
-            var func = bindData[0], partialArgs = bindData[2], thisArg = bindData[4];
-            function bound() {
-                if (partialArgs) {
-                    var args = partialArgs.slice();
-                    push.apply(args, arguments);
-                }
-                if (_instanceof(this, bound)) {
-                    var thisBinding = baseCreate(func.prototype), result = func.apply(thisBinding, args || arguments);
-                    return isObject(result) ? result : thisBinding;
-                }
-                return func.apply(thisArg, args || arguments);
-            }
-            setBindData(bound, bindData);
-            return bound;
-        }
-        module2.exports = baseBind;
-    }
-});
-// node_modules/lodash._slice/index.js
-var require_lodash10 = __commonJS({
-    "node_modules/lodash._slice/index.js": function(exports2, module2) {
-        function slice(array, start, end) {
-            start || (start = 0);
-            if (typeof end == "undefined") {
-                end = array ? array.length : 0;
-            }
-            var index = -1, length2 = end - start || 0, result = Array(length2 < 0 ? 0 : length2);
-            while(++index < length2){
-                result[index] = array[start + index];
-            }
-            return result;
-        }
-        module2.exports = slice;
-    }
-});
-// node_modules/lodash._basecreatewrapper/index.js
-var require_lodash11 = __commonJS({
-    "node_modules/lodash._basecreatewrapper/index.js": function(exports2, module2) {
-        var baseCreate = require_lodash7();
-        var isObject = require_lodash2();
-        var setBindData = require_lodash8();
-        var slice = require_lodash10();
-        var arrayRef = [];
-        var push = arrayRef.push;
-        function baseCreateWrapper(bindData) {
-            var func = bindData[0], bitmask = bindData[1], partialArgs = bindData[2], partialRightArgs = bindData[3], thisArg = bindData[4], arity = bindData[5];
-            var isBind = bitmask & 1, isBindKey = bitmask & 2, isCurry = bitmask & 4, isCurryBound = bitmask & 8, key = func;
-            function bound() {
-                var thisBinding = isBind ? thisArg : this;
-                if (partialArgs) {
-                    var args = partialArgs.slice();
-                    push.apply(args, arguments);
-                }
-                if (partialRightArgs || isCurry) {
-                    args || (args = slice(arguments));
-                    if (partialRightArgs) {
-                        push.apply(args, partialRightArgs);
-                    }
-                    if (isCurry && args.length < arity) {
-                        bitmask |= 16 & ~32;
-                        return baseCreateWrapper([
-                            func,
-                            isCurryBound ? bitmask : bitmask & ~3,
-                            args,
-                            null,
-                            thisArg,
-                            arity
-                        ]);
-                    }
-                }
-                args || (args = arguments);
-                if (isBindKey) {
-                    func = thisBinding[key];
-                }
-                if (_instanceof(this, bound)) {
-                    thisBinding = baseCreate(func.prototype);
-                    var result = func.apply(thisBinding, args);
-                    return isObject(result) ? result : thisBinding;
-                }
-                return func.apply(thisBinding, args);
-            }
-            setBindData(bound, bindData);
-            return bound;
-        }
-        module2.exports = baseCreateWrapper;
-    }
-});
-// node_modules/lodash.isfunction/index.js
-var require_lodash12 = __commonJS({
-    "node_modules/lodash.isfunction/index.js": function(exports2, module2) {
-        function isFunction(value) {
-            return typeof value == "function";
-        }
-        module2.exports = isFunction;
-    }
-});
-// node_modules/lodash._createwrapper/index.js
-var require_lodash13 = __commonJS({
-    "node_modules/lodash._createwrapper/index.js": function(exports2, module2) {
-        var baseBind = require_lodash9();
-        var baseCreateWrapper = require_lodash11();
-        var isFunction = require_lodash12();
-        var arrayRef = [];
-        var push = arrayRef.push;
-        function createWrapper(func, bitmask, partialArgs, partialRightArgs, thisArg, arity) {
-            var isBind = bitmask & 1, isBindKey = bitmask & 2, isCurry = bitmask & 4, isCurryBound = bitmask & 8, isPartial = bitmask & 16, isPartialRight = bitmask & 32;
-            if (!isBindKey && !isFunction(func)) {
-                throw new TypeError();
-            }
-            if (isPartial && !partialArgs.length) {
-                bitmask &= ~16;
-                isPartial = partialArgs = false;
-            }
-            if (isPartialRight && !partialRightArgs.length) {
-                bitmask &= ~32;
-                isPartialRight = partialRightArgs = false;
-            }
-            var bindData = func && func.__bindData__;
-            if (bindData && bindData !== true) {
-                bindData = bindData.slice();
-                if (isBind && !(bindData[1] & 1)) {
-                    bindData[4] = thisArg;
-                }
-                if (!isBind && bindData[1] & 1) {
-                    bitmask |= 8;
-                }
-                if (isCurry && !(bindData[1] & 4)) {
-                    bindData[5] = arity;
-                }
-                if (isPartial) {
-                    push.apply(bindData[2] || (bindData[2] = []), partialArgs);
-                }
-                if (isPartialRight) {
-                    push.apply(bindData[3] || (bindData[3] = []), partialRightArgs);
-                }
-                bindData[1] |= bitmask;
-                return createWrapper.apply(null, bindData);
-            }
-            var creater = bitmask == 1 || bitmask === 17 ? baseBind : baseCreateWrapper;
-            return creater([
-                func,
-                bitmask,
-                partialArgs,
-                partialRightArgs,
-                thisArg,
-                arity
-            ]);
-        }
-        module2.exports = createWrapper;
-    }
-});
-// node_modules/lodash.bind/index.js
-var require_lodash14 = __commonJS({
-    "node_modules/lodash.bind/index.js": function(exports2, module2) {
-        var createWrapper = require_lodash13();
-        var reNative = require_lodash3();
-        var slice = require_lodash10();
-        function bind(func, thisArg) {
-            return arguments.length > 2 ? createWrapper(func, 17, slice(arguments, 2), null, thisArg) : createWrapper(func, 1, null, null, thisArg);
-        }
-        module2.exports = bind;
-    }
-});
-// node_modules/lodash.identity/index.js
-var require_lodash15 = __commonJS({
-    "node_modules/lodash.identity/index.js": function(exports2, module2) {
-        function identity7(value) {
-            return value;
-        }
-        module2.exports = identity7;
-    }
-});
-// node_modules/lodash.support/index.js
-var require_lodash16 = __commonJS({
-    "node_modules/lodash.support/index.js": function(exports2, module2) {
-        var reNative = require_lodash3();
-        var reThis = /\bthis\b/;
-        var support = {};
-        support.funcDecomp = !reNative.test(global.WinRTError) && reThis.test(function() {
-            return this;
-        });
-        support.funcNames = typeof Function.name == "string";
-        module2.exports = support;
-    }
-});
-// node_modules/lodash._basecreatecallback/index.js
-var require_lodash17 = __commonJS({
-    "node_modules/lodash._basecreatecallback/index.js": function(exports2, module2) {
-        var bind = require_lodash14();
-        var identity7 = require_lodash15();
-        var setBindData = require_lodash8();
-        var support = require_lodash16();
-        var reFuncName = /^\s*function[ \n\r\t]+\w/;
-        var reThis = /\bthis\b/;
-        var fnToString = Function.prototype.toString;
-        function baseCreateCallback(func, thisArg, argCount) {
-            if (typeof func != "function") {
-                return identity7;
-            }
-            if (typeof thisArg == "undefined" || !("prototype" in func)) {
-                return func;
-            }
-            var bindData = func.__bindData__;
-            if (typeof bindData == "undefined") {
-                if (support.funcNames) {
-                    bindData = !func.name;
-                }
-                bindData = bindData || !support.funcDecomp;
-                if (!bindData) {
-                    var source = fnToString.call(func);
-                    if (!support.funcNames) {
-                        bindData = !reFuncName.test(source);
-                    }
-                    if (!bindData) {
-                        bindData = reThis.test(source);
-                        setBindData(func, bindData);
-                    }
-                }
-            }
-            if (bindData === false || bindData !== true && bindData[1] & 1) {
-                return func;
-            }
-            switch(argCount){
-                case 1:
-                    return function(value) {
-                        return func.call(thisArg, value);
-                    };
-                case 2:
-                    return function(a, b) {
-                        return func.call(thisArg, a, b);
-                    };
-                case 3:
-                    return function(value, index, collection) {
-                        return func.call(thisArg, value, index, collection);
-                    };
-                case 4:
-                    return function(accumulator, value, index, collection) {
-                        return func.call(thisArg, accumulator, value, index, collection);
-                    };
-            }
-            return bind(func, thisArg);
-        }
-        module2.exports = baseCreateCallback;
-    }
-});
-// node_modules/lodash.forown/index.js
-var require_lodash18 = __commonJS({
-    "node_modules/lodash.forown/index.js": function(exports2, module2) {
-        var baseCreateCallback = require_lodash17();
-        var keys = require_lodash5();
-        var objectTypes = require_lodash();
-        var forOwn = function forOwn(collection, callback, thisArg) {
-            var index, iterable = collection, result = iterable;
-            if (!iterable) return result;
-            if (!objectTypes[typeof iterable === "undefined" ? "undefined" : _type_of(iterable)]) return result;
-            callback = callback && typeof thisArg == "undefined" ? callback : baseCreateCallback(callback, thisArg, 3);
-            var ownIndex = -1, ownProps = objectTypes[typeof iterable === "undefined" ? "undefined" : _type_of(iterable)] && keys(iterable), length2 = ownProps ? ownProps.length : 0;
-            while(++ownIndex < length2){
-                index = ownProps[ownIndex];
-                if (callback(iterable[index], index, collection) === false) return result;
-            }
-            return result;
-        };
-        module2.exports = forOwn;
-    }
-});
-// node_modules/lodash.foreach/index.js
-var require_lodash19 = __commonJS({
-    "node_modules/lodash.foreach/index.js": function(exports2, module2) {
-        var baseCreateCallback = require_lodash17();
-        var forOwn = require_lodash18();
-        function forEach(collection, callback, thisArg) {
-            var index = -1, length2 = collection ? collection.length : 0;
-            callback = callback && typeof thisArg == "undefined" ? callback : baseCreateCallback(callback, thisArg, 3);
-            if (typeof length2 == "number") {
-                while(++index < length2){
-                    if (callback(collection[index], index, collection) === false) {
-                        break;
-                    }
-                }
-            } else {
-                forOwn(collection, callback);
-            }
-            return collection;
-        }
-        module2.exports = forEach;
-    }
-});
-// node_modules/convert-units/lib/definitions/length.js
-var require_length = __commonJS({
-    "node_modules/convert-units/lib/definitions/length.js": function(exports2, module2) {
-        var metric;
-        var imperial;
-        metric = {
-            mm: {
-                name: {
-                    singular: "Millimeter",
-                    plural: "Millimeters"
-                },
-                to_anchor: 1 / 1e3
-            },
-            cm: {
-                name: {
-                    singular: "Centimeter",
-                    plural: "Centimeters"
-                },
-                to_anchor: 1 / 100
-            },
-            m: {
-                name: {
-                    singular: "Meter",
-                    plural: "Meters"
-                },
-                to_anchor: 1
-            },
-            km: {
-                name: {
-                    singular: "Kilometer",
-                    plural: "Kilometers"
-                },
-                to_anchor: 1e3
-            }
-        };
-        imperial = {
-            "in": {
-                name: {
-                    singular: "Inch",
-                    plural: "Inches"
-                },
-                to_anchor: 1 / 12
-            },
-            yd: {
-                name: {
-                    singular: "Yard",
-                    plural: "Yards"
-                },
-                to_anchor: 3
-            },
-            "ft-us": {
-                name: {
-                    singular: "US Survey Foot",
-                    plural: "US Survey Feet"
-                },
-                to_anchor: 1.000002
-            },
-            ft: {
-                name: {
-                    singular: "Foot",
-                    plural: "Feet"
-                },
-                to_anchor: 1
-            },
-            mi: {
-                name: {
-                    singular: "Mile",
-                    plural: "Miles"
-                },
-                to_anchor: 5280
-            }
-        };
-        module2.exports = {
-            metric: metric,
-            imperial: imperial,
-            _anchors: {
-                metric: {
-                    unit: "m",
-                    ratio: 3.28084
-                },
-                imperial: {
-                    unit: "ft",
-                    ratio: 1 / 3.28084
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/area.js
-var require_area = __commonJS({
-    "node_modules/convert-units/lib/definitions/area.js": function(exports2, module2) {
-        var metric;
-        var imperial;
-        metric = {
-            mm2: {
-                name: {
-                    singular: "Square Millimeter",
-                    plural: "Square Millimeters"
-                },
-                to_anchor: 1 / 1e6
-            },
-            cm2: {
-                name: {
-                    singular: "Centimeter",
-                    plural: "Centimeters"
-                },
-                to_anchor: 1 / 1e4
-            },
-            m2: {
-                name: {
-                    singular: "Square Meter",
-                    plural: "Square Meters"
-                },
-                to_anchor: 1
-            },
-            ha: {
-                name: {
-                    singular: "Hectare",
-                    plural: "Hectares"
-                },
-                to_anchor: 1e4
-            },
-            km2: {
-                name: {
-                    singular: "Square Kilometer",
-                    plural: "Square Kilometers"
-                },
-                to_anchor: 1e6
-            }
-        };
-        imperial = {
-            "in2": {
-                name: {
-                    singular: "Square Inch",
-                    plural: "Square Inches"
-                },
-                to_anchor: 1 / 144
-            },
-            yd2: {
-                name: {
-                    singular: "Square Yard",
-                    plural: "Square Yards"
-                },
-                to_anchor: 9
-            },
-            ft2: {
-                name: {
-                    singular: "Square Foot",
-                    plural: "Square Feet"
-                },
-                to_anchor: 1
-            },
-            ac: {
-                name: {
-                    singular: "Acre",
-                    plural: "Acres"
-                },
-                to_anchor: 43560
-            },
-            mi2: {
-                name: {
-                    singular: "Square Mile",
-                    plural: "Square Miles"
-                },
-                to_anchor: 27878400
-            }
-        };
-        module2.exports = {
-            metric: metric,
-            imperial: imperial,
-            _anchors: {
-                metric: {
-                    unit: "m2",
-                    ratio: 10.7639
-                },
-                imperial: {
-                    unit: "ft2",
-                    ratio: 1 / 10.7639
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/mass.js
-var require_mass = __commonJS({
-    "node_modules/convert-units/lib/definitions/mass.js": function(exports2, module2) {
-        var metric;
-        var imperial;
-        metric = {
-            mcg: {
-                name: {
-                    singular: "Microgram",
-                    plural: "Micrograms"
-                },
-                to_anchor: 1 / 1e6
-            },
-            mg: {
-                name: {
-                    singular: "Milligram",
-                    plural: "Milligrams"
-                },
-                to_anchor: 1 / 1e3
-            },
-            g: {
-                name: {
-                    singular: "Gram",
-                    plural: "Grams"
-                },
-                to_anchor: 1
-            },
-            kg: {
-                name: {
-                    singular: "Kilogram",
-                    plural: "Kilograms"
-                },
-                to_anchor: 1e3
-            },
-            mt: {
-                name: {
-                    singular: "Metric Tonne",
-                    plural: "Metric Tonnes"
-                },
-                to_anchor: 1e6
-            }
-        };
-        imperial = {
-            oz: {
-                name: {
-                    singular: "Ounce",
-                    plural: "Ounces"
-                },
-                to_anchor: 1 / 16
-            },
-            lb: {
-                name: {
-                    singular: "Pound",
-                    plural: "Pounds"
-                },
-                to_anchor: 1
-            },
-            t: {
-                name: {
-                    singular: "Ton",
-                    plural: "Tons"
-                },
-                to_anchor: 2e3
-            }
-        };
-        module2.exports = {
-            metric: metric,
-            imperial: imperial,
-            _anchors: {
-                metric: {
-                    unit: "g",
-                    ratio: 1 / 453.592
-                },
-                imperial: {
-                    unit: "lb",
-                    ratio: 453.592
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/volume.js
-var require_volume = __commonJS({
-    "node_modules/convert-units/lib/definitions/volume.js": function(exports2, module2) {
-        var metric;
-        var imperial;
-        metric = {
-            mm3: {
-                name: {
-                    singular: "Cubic Millimeter",
-                    plural: "Cubic Millimeters"
-                },
-                to_anchor: 1 / 1e6
-            },
-            cm3: {
-                name: {
-                    singular: "Cubic Centimeter",
-                    plural: "Cubic Centimeters"
-                },
-                to_anchor: 1 / 1e3
-            },
-            ml: {
-                name: {
-                    singular: "Millilitre",
-                    plural: "Millilitres"
-                },
-                to_anchor: 1 / 1e3
-            },
-            cl: {
-                name: {
-                    singular: "Centilitre",
-                    plural: "Centilitres"
-                },
-                to_anchor: 1 / 100
-            },
-            dl: {
-                name: {
-                    singular: "Decilitre",
-                    plural: "Decilitres"
-                },
-                to_anchor: 1 / 10
-            },
-            l: {
-                name: {
-                    singular: "Litre",
-                    plural: "Litres"
-                },
-                to_anchor: 1
-            },
-            kl: {
-                name: {
-                    singular: "Kilolitre",
-                    plural: "Kilolitres"
-                },
-                to_anchor: 1e3
-            },
-            m3: {
-                name: {
-                    singular: "Cubic meter",
-                    plural: "Cubic meters"
-                },
-                to_anchor: 1e3
-            },
-            km3: {
-                name: {
-                    singular: "Cubic kilometer",
-                    plural: "Cubic kilometers"
-                },
-                to_anchor: 1e12
-            },
-            krm: {
-                name: {
-                    singular: "Matsked",
-                    plural: "Matskedar"
-                },
-                to_anchor: 1 / 1e3
-            },
-            tsk: {
-                name: {
-                    singular: "Tesked",
-                    plural: "Teskedar"
-                },
-                to_anchor: 5 / 1e3
-            },
-            msk: {
-                name: {
-                    singular: "Matsked",
-                    plural: "Matskedar"
-                },
-                to_anchor: 15 / 1e3
-            },
-            kkp: {
-                name: {
-                    singular: "Kaffekopp",
-                    plural: "Kaffekoppar"
-                },
-                to_anchor: 150 / 1e3
-            },
-            glas: {
-                name: {
-                    singular: "Glas",
-                    plural: "Glas"
-                },
-                to_anchor: 200 / 1e3
-            },
-            kanna: {
-                name: {
-                    singular: "Kanna",
-                    plural: "Kannor"
-                },
-                to_anchor: 2.617
-            }
-        };
-        imperial = {
-            tsp: {
-                name: {
-                    singular: "Teaspoon",
-                    plural: "Teaspoons"
-                },
-                to_anchor: 1 / 6
-            },
-            Tbs: {
-                name: {
-                    singular: "Tablespoon",
-                    plural: "Tablespoons"
-                },
-                to_anchor: 1 / 2
-            },
-            in3: {
-                name: {
-                    singular: "Cubic inch",
-                    plural: "Cubic inches"
-                },
-                to_anchor: 0.55411
-            },
-            "fl-oz": {
-                name: {
-                    singular: "Fluid Ounce",
-                    plural: "Fluid Ounces"
-                },
-                to_anchor: 1
-            },
-            cup: {
-                name: {
-                    singular: "Cup",
-                    plural: "Cups"
-                },
-                to_anchor: 8
-            },
-            pnt: {
-                name: {
-                    singular: "Pint",
-                    plural: "Pints"
-                },
-                to_anchor: 16
-            },
-            qt: {
-                name: {
-                    singular: "Quart",
-                    plural: "Quarts"
-                },
-                to_anchor: 32
-            },
-            gal: {
-                name: {
-                    singular: "Gallon",
-                    plural: "Gallons"
-                },
-                to_anchor: 128
-            },
-            ft3: {
-                name: {
-                    singular: "Cubic foot",
-                    plural: "Cubic feet"
-                },
-                to_anchor: 957.506
-            },
-            yd3: {
-                name: {
-                    singular: "Cubic yard",
-                    plural: "Cubic yards"
-                },
-                to_anchor: 25852.7
-            }
-        };
-        module2.exports = {
-            metric: metric,
-            imperial: imperial,
-            _anchors: {
-                metric: {
-                    unit: "l",
-                    ratio: 33.8140226
-                },
-                imperial: {
-                    unit: "fl-oz",
-                    ratio: 1 / 33.8140226
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/each.js
-var require_each = __commonJS({
-    "node_modules/convert-units/lib/definitions/each.js": function(exports2, module2) {
-        var metric;
-        metric = {
-            ea: {
-                name: {
-                    singular: "Each",
-                    plural: "Each"
-                },
-                to_anchor: 1
-            },
-            dz: {
-                name: {
-                    singular: "Dozen",
-                    plural: "Dozens"
-                },
-                to_anchor: 12
-            }
-        };
-        module2.exports = {
-            metric: metric,
-            imperial: {},
-            _anchors: {
-                metric: {
-                    unit: "ea",
-                    ratio: 1
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/temperature.js
-var require_temperature = __commonJS({
-    "node_modules/convert-units/lib/definitions/temperature.js": function(exports2, module2) {
-        var metric;
-        var imperial;
-        metric = {
-            C: {
-                name: {
-                    singular: "degree Celsius",
-                    plural: "degrees Celsius"
-                },
-                to_anchor: 1,
-                anchor_shift: 0
-            },
-            K: {
-                name: {
-                    singular: "degree Kelvin",
-                    plural: "degrees Kelvin"
-                },
-                to_anchor: 1,
-                anchor_shift: 273.15
-            }
-        };
-        imperial = {
-            F: {
-                name: {
-                    singular: "degree Fahrenheit",
-                    plural: "degrees Fahrenheit"
-                },
-                to_anchor: 1
-            },
-            R: {
-                name: {
-                    singular: "degree Rankine",
-                    plural: "degrees Rankine"
-                },
-                to_anchor: 1,
-                anchor_shift: 459.67
-            }
-        };
-        module2.exports = {
-            metric: metric,
-            imperial: imperial,
-            _anchors: {
-                metric: {
-                    unit: "C",
-                    transform: function transform(C) {
-                        return C / (5 / 9) + 32;
-                    }
-                },
-                imperial: {
-                    unit: "F",
-                    transform: function transform(F) {
-                        return (F - 32) * (5 / 9);
-                    }
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/time.js
-var require_time = __commonJS({
-    "node_modules/convert-units/lib/definitions/time.js": function(exports2, module2) {
-        var time2;
-        var daysInYear = 365.25;
-        time2 = {
-            ns: {
-                name: {
-                    singular: "Nanosecond",
-                    plural: "Nanoseconds"
-                },
-                to_anchor: 1 / 1e9
-            },
-            mu: {
-                name: {
-                    singular: "Microsecond",
-                    plural: "Microseconds"
-                },
-                to_anchor: 1 / 1e6
-            },
-            ms: {
-                name: {
-                    singular: "Millisecond",
-                    plural: "Milliseconds"
-                },
-                to_anchor: 1 / 1e3
-            },
-            s: {
-                name: {
-                    singular: "Second",
-                    plural: "Seconds"
-                },
-                to_anchor: 1
-            },
-            min: {
-                name: {
-                    singular: "Minute",
-                    plural: "Minutes"
-                },
-                to_anchor: 60
-            },
-            h: {
-                name: {
-                    singular: "Hour",
-                    plural: "Hours"
-                },
-                to_anchor: 60 * 60
-            },
-            d: {
-                name: {
-                    singular: "Day",
-                    plural: "Days"
-                },
-                to_anchor: 60 * 60 * 24
-            },
-            week: {
-                name: {
-                    singular: "Week",
-                    plural: "Weeks"
-                },
-                to_anchor: 60 * 60 * 24 * 7
-            },
-            month: {
-                name: {
-                    singular: "Month",
-                    plural: "Months"
-                },
-                to_anchor: 60 * 60 * 24 * daysInYear / 12
-            },
-            year: {
-                name: {
-                    singular: "Year",
-                    plural: "Years"
-                },
-                to_anchor: 60 * 60 * 24 * daysInYear
-            }
-        };
-        module2.exports = {
-            metric: time2,
-            _anchors: {
-                metric: {
-                    unit: "s",
-                    ratio: 1
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/digital.js
-var require_digital = __commonJS({
-    "node_modules/convert-units/lib/definitions/digital.js": function(exports2, module2) {
-        var bits;
-        var bytes;
-        bits = {
-            b: {
-                name: {
-                    singular: "Bit",
-                    plural: "Bits"
-                },
-                to_anchor: 1
-            },
-            Kb: {
-                name: {
-                    singular: "Kilobit",
-                    plural: "Kilobits"
-                },
-                to_anchor: 1024
-            },
-            Mb: {
-                name: {
-                    singular: "Megabit",
-                    plural: "Megabits"
-                },
-                to_anchor: 1048576
-            },
-            Gb: {
-                name: {
-                    singular: "Gigabit",
-                    plural: "Gigabits"
-                },
-                to_anchor: 1073741824
-            },
-            Tb: {
-                name: {
-                    singular: "Terabit",
-                    plural: "Terabits"
-                },
-                to_anchor: 1099511627776
-            }
-        };
-        bytes = {
-            B: {
-                name: {
-                    singular: "Byte",
-                    plural: "Bytes"
-                },
-                to_anchor: 1
-            },
-            KB: {
-                name: {
-                    singular: "Kilobyte",
-                    plural: "Kilobytes"
-                },
-                to_anchor: 1024
-            },
-            MB: {
-                name: {
-                    singular: "Megabyte",
-                    plural: "Megabytes"
-                },
-                to_anchor: 1048576
-            },
-            GB: {
-                name: {
-                    singular: "Gigabyte",
-                    plural: "Gigabytes"
-                },
-                to_anchor: 1073741824
-            },
-            TB: {
-                name: {
-                    singular: "Terabyte",
-                    plural: "Terabytes"
-                },
-                to_anchor: 1099511627776
-            }
-        };
-        module2.exports = {
-            bits: bits,
-            bytes: bytes,
-            _anchors: {
-                bits: {
-                    unit: "b",
-                    ratio: 1 / 8
-                },
-                bytes: {
-                    unit: "B",
-                    ratio: 8
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/partsPer.js
-var require_partsPer = __commonJS({
-    "node_modules/convert-units/lib/definitions/partsPer.js": function(exports2, module2) {
-        var metric;
-        metric = {
-            ppm: {
-                name: {
-                    singular: "Part-per Million",
-                    plural: "Parts-per Million"
-                },
-                to_anchor: 1
-            },
-            ppb: {
-                name: {
-                    singular: "Part-per Billion",
-                    plural: "Parts-per Billion"
-                },
-                to_anchor: 1e-3
-            },
-            ppt: {
-                name: {
-                    singular: "Part-per Trillion",
-                    plural: "Parts-per Trillion"
-                },
-                to_anchor: 1e-6
-            },
-            ppq: {
-                name: {
-                    singular: "Part-per Quadrillion",
-                    plural: "Parts-per Quadrillion"
-                },
-                to_anchor: 1e-9
-            }
-        };
-        module2.exports = {
-            metric: metric,
-            imperial: {},
-            _anchors: {
-                metric: {
-                    unit: "ppm",
-                    ratio: 1e-6
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/speed.js
-var require_speed = __commonJS({
-    "node_modules/convert-units/lib/definitions/speed.js": function(exports2, module2) {
-        var metric;
-        var imperial;
-        metric = {
-            "m/s": {
-                name: {
-                    singular: "Metre per second",
-                    plural: "Metres per second"
-                },
-                to_anchor: 3.6
-            },
-            "km/h": {
-                name: {
-                    singular: "Kilometre per hour",
-                    plural: "Kilometres per hour"
-                },
-                to_anchor: 1
-            }
-        };
-        imperial = {
-            "m/h": {
-                name: {
-                    singular: "Mile per hour",
-                    plural: "Miles per hour"
-                },
-                to_anchor: 1
-            },
-            knot: {
-                name: {
-                    singular: "Knot",
-                    plural: "Knots"
-                },
-                to_anchor: 1.150779
-            },
-            "ft/s": {
-                name: {
-                    singular: "Foot per second",
-                    plural: "Feet per second"
-                },
-                to_anchor: 0.681818
-            }
-        };
-        module2.exports = {
-            metric: metric,
-            imperial: imperial,
-            _anchors: {
-                metric: {
-                    unit: "km/h",
-                    ratio: 1 / 1.609344
-                },
-                imperial: {
-                    unit: "m/h",
-                    ratio: 1.609344
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/pace.js
-var require_pace = __commonJS({
-    "node_modules/convert-units/lib/definitions/pace.js": function(exports2, module2) {
-        var metric;
-        var imperial;
-        metric = {
-            "min/km": {
-                name: {
-                    singular: "Minute per kilometre",
-                    plural: "Minutes per kilometre"
-                },
-                to_anchor: 0.06
-            },
-            "s/m": {
-                name: {
-                    singular: "Second per metre",
-                    plural: "Seconds per metre"
-                },
-                to_anchor: 1
-            }
-        };
-        imperial = {
-            "min/mi": {
-                name: {
-                    singular: "Minute per mile",
-                    plural: "Minutes per mile"
-                },
-                to_anchor: 0.0113636
-            },
-            "s/ft": {
-                name: {
-                    singular: "Second per foot",
-                    plural: "Seconds per foot"
-                },
-                to_anchor: 1
-            }
-        };
-        module2.exports = {
-            metric: metric,
-            imperial: imperial,
-            _anchors: {
-                metric: {
-                    unit: "s/m",
-                    ratio: 0.3048
-                },
-                imperial: {
-                    unit: "s/ft",
-                    ratio: 1 / 0.3048
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/pressure.js
-var require_pressure = __commonJS({
-    "node_modules/convert-units/lib/definitions/pressure.js": function(exports2, module2) {
-        var metric;
-        var imperial;
-        metric = {
-            Pa: {
-                name: {
-                    singular: "pascal",
-                    plural: "pascals"
-                },
-                to_anchor: 1 / 1e3
-            },
-            kPa: {
-                name: {
-                    singular: "kilopascal",
-                    plural: "kilopascals"
-                },
-                to_anchor: 1
-            },
-            MPa: {
-                name: {
-                    singular: "megapascal",
-                    plural: "megapascals"
-                },
-                to_anchor: 1e3
-            },
-            hPa: {
-                name: {
-                    singular: "hectopascal",
-                    plural: "hectopascals"
-                },
-                to_anchor: 1 / 10
-            },
-            bar: {
-                name: {
-                    singular: "bar",
-                    plural: "bar"
-                },
-                to_anchor: 100
-            },
-            torr: {
-                name: {
-                    singular: "torr",
-                    plural: "torr"
-                },
-                to_anchor: 101325 / 76e4
-            }
-        };
-        imperial = {
-            psi: {
-                name: {
-                    singular: "pound per square inch",
-                    plural: "pounds per square inch"
-                },
-                to_anchor: 1 / 1e3
-            },
-            ksi: {
-                name: {
-                    singular: "kilopound per square inch",
-                    plural: "kilopound per square inch"
-                },
-                to_anchor: 1
-            }
-        };
-        module2.exports = {
-            metric: metric,
-            imperial: imperial,
-            _anchors: {
-                metric: {
-                    unit: "kPa",
-                    ratio: 14503768078e-14
-                },
-                imperial: {
-                    unit: "psi",
-                    ratio: 1 / 14503768078e-14
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/current.js
-var require_current = __commonJS({
-    "node_modules/convert-units/lib/definitions/current.js": function(exports2, module2) {
-        var current2;
-        current2 = {
-            A: {
-                name: {
-                    singular: "Ampere",
-                    plural: "Amperes"
-                },
-                to_anchor: 1
-            },
-            mA: {
-                name: {
-                    singular: "Milliampere",
-                    plural: "Milliamperes"
-                },
-                to_anchor: 1e-3
-            },
-            kA: {
-                name: {
-                    singular: "Kiloampere",
-                    plural: "Kiloamperes"
-                },
-                to_anchor: 1e3
-            }
-        };
-        module2.exports = {
-            metric: current2,
-            _anchors: {
-                metric: {
-                    unit: "A",
-                    ratio: 1
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/voltage.js
-var require_voltage = __commonJS({
-    "node_modules/convert-units/lib/definitions/voltage.js": function(exports2, module2) {
-        var voltage2;
-        voltage2 = {
-            V: {
-                name: {
-                    singular: "Volt",
-                    plural: "Volts"
-                },
-                to_anchor: 1
-            },
-            mV: {
-                name: {
-                    singular: "Millivolt",
-                    plural: "Millivolts"
-                },
-                to_anchor: 1e-3
-            },
-            kV: {
-                name: {
-                    singular: "Kilovolt",
-                    plural: "Kilovolts"
-                },
-                to_anchor: 1e3
-            }
-        };
-        module2.exports = {
-            metric: voltage2,
-            _anchors: {
-                metric: {
-                    unit: "V",
-                    ratio: 1
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/power.js
-var require_power = __commonJS({
-    "node_modules/convert-units/lib/definitions/power.js": function(exports2, module2) {
-        var power;
-        power = {
-            W: {
-                name: {
-                    singular: "Watt",
-                    plural: "Watts"
-                },
-                to_anchor: 1
-            },
-            mW: {
-                name: {
-                    singular: "Milliwatt",
-                    plural: "Milliwatts"
-                },
-                to_anchor: 1e-3
-            },
-            kW: {
-                name: {
-                    singular: "Kilowatt",
-                    plural: "Kilowatts"
-                },
-                to_anchor: 1e3
-            },
-            MW: {
-                name: {
-                    singular: "Megawatt",
-                    plural: "Megawatts"
-                },
-                to_anchor: 1e6
-            },
-            GW: {
-                name: {
-                    singular: "Gigawatt",
-                    plural: "Gigawatts"
-                },
-                to_anchor: 1e9
-            }
-        };
-        module2.exports = {
-            metric: power,
-            _anchors: {
-                metric: {
-                    unit: "W",
-                    ratio: 1
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/reactivePower.js
-var require_reactivePower = __commonJS({
-    "node_modules/convert-units/lib/definitions/reactivePower.js": function(exports2, module2) {
-        var reactivePower;
-        reactivePower = {
-            VAR: {
-                name: {
-                    singular: "Volt-Ampere Reactive",
-                    plural: "Volt-Amperes Reactive"
-                },
-                to_anchor: 1
-            },
-            mVAR: {
-                name: {
-                    singular: "Millivolt-Ampere Reactive",
-                    plural: "Millivolt-Amperes Reactive"
-                },
-                to_anchor: 1e-3
-            },
-            kVAR: {
-                name: {
-                    singular: "Kilovolt-Ampere Reactive",
-                    plural: "Kilovolt-Amperes Reactive"
-                },
-                to_anchor: 1e3
-            },
-            MVAR: {
-                name: {
-                    singular: "Megavolt-Ampere Reactive",
-                    plural: "Megavolt-Amperes Reactive"
-                },
-                to_anchor: 1e6
-            },
-            GVAR: {
-                name: {
-                    singular: "Gigavolt-Ampere Reactive",
-                    plural: "Gigavolt-Amperes Reactive"
-                },
-                to_anchor: 1e9
-            }
-        };
-        module2.exports = {
-            metric: reactivePower,
-            _anchors: {
-                metric: {
-                    unit: "VAR",
-                    ratio: 1
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/apparentPower.js
-var require_apparentPower = __commonJS({
-    "node_modules/convert-units/lib/definitions/apparentPower.js": function(exports2, module2) {
-        var apparentPower;
-        apparentPower = {
-            VA: {
-                name: {
-                    singular: "Volt-Ampere",
-                    plural: "Volt-Amperes"
-                },
-                to_anchor: 1
-            },
-            mVA: {
-                name: {
-                    singular: "Millivolt-Ampere",
-                    plural: "Millivolt-Amperes"
-                },
-                to_anchor: 1e-3
-            },
-            kVA: {
-                name: {
-                    singular: "Kilovolt-Ampere",
-                    plural: "Kilovolt-Amperes"
-                },
-                to_anchor: 1e3
-            },
-            MVA: {
-                name: {
-                    singular: "Megavolt-Ampere",
-                    plural: "Megavolt-Amperes"
-                },
-                to_anchor: 1e6
-            },
-            GVA: {
-                name: {
-                    singular: "Gigavolt-Ampere",
-                    plural: "Gigavolt-Amperes"
-                },
-                to_anchor: 1e9
-            }
-        };
-        module2.exports = {
-            metric: apparentPower,
-            _anchors: {
-                metric: {
-                    unit: "VA",
-                    ratio: 1
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/energy.js
-var require_energy = __commonJS({
-    "node_modules/convert-units/lib/definitions/energy.js": function(exports2, module2) {
-        var energy;
-        energy = {
-            Wh: {
-                name: {
-                    singular: "Watt-hour",
-                    plural: "Watt-hours"
-                },
-                to_anchor: 3600
-            },
-            mWh: {
-                name: {
-                    singular: "Milliwatt-hour",
-                    plural: "Milliwatt-hours"
-                },
-                to_anchor: 3.6
-            },
-            kWh: {
-                name: {
-                    singular: "Kilowatt-hour",
-                    plural: "Kilowatt-hours"
-                },
-                to_anchor: 36e5
-            },
-            MWh: {
-                name: {
-                    singular: "Megawatt-hour",
-                    plural: "Megawatt-hours"
-                },
-                to_anchor: 36e8
-            },
-            GWh: {
-                name: {
-                    singular: "Gigawatt-hour",
-                    plural: "Gigawatt-hours"
-                },
-                to_anchor: 36e11
-            },
-            J: {
-                name: {
-                    singular: "Joule",
-                    plural: "Joules"
-                },
-                to_anchor: 1
-            },
-            kJ: {
-                name: {
-                    singular: "Kilojoule",
-                    plural: "Kilojoules"
-                },
-                to_anchor: 1e3
-            }
-        };
-        module2.exports = {
-            metric: energy,
-            _anchors: {
-                metric: {
-                    unit: "J",
-                    ratio: 1
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/reactiveEnergy.js
-var require_reactiveEnergy = __commonJS({
-    "node_modules/convert-units/lib/definitions/reactiveEnergy.js": function(exports2, module2) {
-        var reactiveEnergy;
-        reactiveEnergy = {
-            VARh: {
-                name: {
-                    singular: "Volt-Ampere Reactive Hour",
-                    plural: "Volt-Amperes Reactive Hour"
-                },
-                to_anchor: 1
-            },
-            mVARh: {
-                name: {
-                    singular: "Millivolt-Ampere Reactive Hour",
-                    plural: "Millivolt-Amperes Reactive Hour"
-                },
-                to_anchor: 1e-3
-            },
-            kVARh: {
-                name: {
-                    singular: "Kilovolt-Ampere Reactive Hour",
-                    plural: "Kilovolt-Amperes Reactive Hour"
-                },
-                to_anchor: 1e3
-            },
-            MVARh: {
-                name: {
-                    singular: "Megavolt-Ampere Reactive Hour",
-                    plural: "Megavolt-Amperes Reactive Hour"
-                },
-                to_anchor: 1e6
-            },
-            GVARh: {
-                name: {
-                    singular: "Gigavolt-Ampere Reactive Hour",
-                    plural: "Gigavolt-Amperes Reactive Hour"
-                },
-                to_anchor: 1e9
-            }
-        };
-        module2.exports = {
-            metric: reactiveEnergy,
-            _anchors: {
-                metric: {
-                    unit: "VARh",
-                    ratio: 1
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/volumeFlowRate.js
-var require_volumeFlowRate = __commonJS({
-    "node_modules/convert-units/lib/definitions/volumeFlowRate.js": function(exports2, module2) {
-        var metric;
-        var imperial;
-        metric = {
-            "mm3/s": {
-                name: {
-                    singular: "Cubic Millimeter per second",
-                    plural: "Cubic Millimeters per second"
-                },
-                to_anchor: 1 / 1e6
-            },
-            "cm3/s": {
-                name: {
-                    singular: "Cubic Centimeter per second",
-                    plural: "Cubic Centimeters per second"
-                },
-                to_anchor: 1 / 1e3
-            },
-            "ml/s": {
-                name: {
-                    singular: "Millilitre per second",
-                    plural: "Millilitres per second"
-                },
-                to_anchor: 1 / 1e3
-            },
-            "cl/s": {
-                name: {
-                    singular: "Centilitre per second",
-                    plural: "Centilitres per second"
-                },
-                to_anchor: 1 / 100
-            },
-            "dl/s": {
-                name: {
-                    singular: "Decilitre per second",
-                    plural: "Decilitres per second"
-                },
-                to_anchor: 1 / 10
-            },
-            "l/s": {
-                name: {
-                    singular: "Litre per second",
-                    plural: "Litres per second"
-                },
-                to_anchor: 1
-            },
-            "l/min": {
-                name: {
-                    singular: "Litre per minute",
-                    plural: "Litres per minute"
-                },
-                to_anchor: 1 / 60
-            },
-            "l/h": {
-                name: {
-                    singular: "Litre per hour",
-                    plural: "Litres per hour"
-                },
-                to_anchor: 1 / 3600
-            },
-            "kl/s": {
-                name: {
-                    singular: "Kilolitre per second",
-                    plural: "Kilolitres per second"
-                },
-                to_anchor: 1e3
-            },
-            "kl/min": {
-                name: {
-                    singular: "Kilolitre per minute",
-                    plural: "Kilolitres per minute"
-                },
-                to_anchor: 50 / 3
-            },
-            "kl/h": {
-                name: {
-                    singular: "Kilolitre per hour",
-                    plural: "Kilolitres per hour"
-                },
-                to_anchor: 5 / 18
-            },
-            "m3/s": {
-                name: {
-                    singular: "Cubic meter per second",
-                    plural: "Cubic meters per second"
-                },
-                to_anchor: 1e3
-            },
-            "m3/min": {
-                name: {
-                    singular: "Cubic meter per minute",
-                    plural: "Cubic meters per minute"
-                },
-                to_anchor: 50 / 3
-            },
-            "m3/h": {
-                name: {
-                    singular: "Cubic meter per hour",
-                    plural: "Cubic meters per hour"
-                },
-                to_anchor: 5 / 18
-            },
-            "km3/s": {
-                name: {
-                    singular: "Cubic kilometer per second",
-                    plural: "Cubic kilometers per second"
-                },
-                to_anchor: 1e12
-            }
-        };
-        imperial = {
-            "tsp/s": {
-                name: {
-                    singular: "Teaspoon per second",
-                    plural: "Teaspoons per second"
-                },
-                to_anchor: 1 / 6
-            },
-            "Tbs/s": {
-                name: {
-                    singular: "Tablespoon per second",
-                    plural: "Tablespoons per second"
-                },
-                to_anchor: 1 / 2
-            },
-            "in3/s": {
-                name: {
-                    singular: "Cubic inch per second",
-                    plural: "Cubic inches per second"
-                },
-                to_anchor: 0.55411
-            },
-            "in3/min": {
-                name: {
-                    singular: "Cubic inch per minute",
-                    plural: "Cubic inches per minute"
-                },
-                to_anchor: 0.55411 / 60
-            },
-            "in3/h": {
-                name: {
-                    singular: "Cubic inch per hour",
-                    plural: "Cubic inches per hour"
-                },
-                to_anchor: 0.55411 / 3600
-            },
-            "fl-oz/s": {
-                name: {
-                    singular: "Fluid Ounce per second",
-                    plural: "Fluid Ounces per second"
-                },
-                to_anchor: 1
-            },
-            "fl-oz/min": {
-                name: {
-                    singular: "Fluid Ounce per minute",
-                    plural: "Fluid Ounces per minute"
-                },
-                to_anchor: 1 / 60
-            },
-            "fl-oz/h": {
-                name: {
-                    singular: "Fluid Ounce per hour",
-                    plural: "Fluid Ounces per hour"
-                },
-                to_anchor: 1 / 3600
-            },
-            "cup/s": {
-                name: {
-                    singular: "Cup per second",
-                    plural: "Cups per second"
-                },
-                to_anchor: 8
-            },
-            "pnt/s": {
-                name: {
-                    singular: "Pint per second",
-                    plural: "Pints per second"
-                },
-                to_anchor: 16
-            },
-            "pnt/min": {
-                name: {
-                    singular: "Pint per minute",
-                    plural: "Pints per minute"
-                },
-                to_anchor: 4 / 15
-            },
-            "pnt/h": {
-                name: {
-                    singular: "Pint per hour",
-                    plural: "Pints per hour"
-                },
-                to_anchor: 1 / 225
-            },
-            "qt/s": {
-                name: {
-                    singular: "Quart per second",
-                    plural: "Quarts per second"
-                },
-                to_anchor: 32
-            },
-            "gal/s": {
-                name: {
-                    singular: "Gallon per second",
-                    plural: "Gallons per second"
-                },
-                to_anchor: 128
-            },
-            "gal/min": {
-                name: {
-                    singular: "Gallon per minute",
-                    plural: "Gallons per minute"
-                },
-                to_anchor: 32 / 15
-            },
-            "gal/h": {
-                name: {
-                    singular: "Gallon per hour",
-                    plural: "Gallons per hour"
-                },
-                to_anchor: 8 / 225
-            },
-            "ft3/s": {
-                name: {
-                    singular: "Cubic foot per second",
-                    plural: "Cubic feet per second"
-                },
-                to_anchor: 957.506
-            },
-            "ft3/min": {
-                name: {
-                    singular: "Cubic foot per minute",
-                    plural: "Cubic feet per minute"
-                },
-                to_anchor: 957.506 / 60
-            },
-            "ft3/h": {
-                name: {
-                    singular: "Cubic foot per hour",
-                    plural: "Cubic feet per hour"
-                },
-                to_anchor: 957.506 / 3600
-            },
-            "yd3/s": {
-                name: {
-                    singular: "Cubic yard per second",
-                    plural: "Cubic yards per second"
-                },
-                to_anchor: 25852.7
-            },
-            "yd3/min": {
-                name: {
-                    singular: "Cubic yard per minute",
-                    plural: "Cubic yards per minute"
-                },
-                to_anchor: 25852.7 / 60
-            },
-            "yd3/h": {
-                name: {
-                    singular: "Cubic yard per hour",
-                    plural: "Cubic yards per hour"
-                },
-                to_anchor: 25852.7 / 3600
-            }
-        };
-        module2.exports = {
-            metric: metric,
-            imperial: imperial,
-            _anchors: {
-                metric: {
-                    unit: "l/s",
-                    ratio: 33.8140227
-                },
-                imperial: {
-                    unit: "fl-oz/s",
-                    ratio: 1 / 33.8140227
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/illuminance.js
-var require_illuminance = __commonJS({
-    "node_modules/convert-units/lib/definitions/illuminance.js": function(exports2, module2) {
-        var metric;
-        var imperial;
-        metric = {
-            "lx": {
-                name: {
-                    singular: "Lux",
-                    plural: "Lux"
-                },
-                to_anchor: 1
-            }
-        };
-        imperial = {
-            "ft-cd": {
-                name: {
-                    singular: "Foot-candle",
-                    plural: "Foot-candles"
-                },
-                to_anchor: 1
-            }
-        };
-        module2.exports = {
-            metric: metric,
-            imperial: imperial,
-            _anchors: {
-                metric: {
-                    unit: "lx",
-                    ratio: 1 / 10.76391
-                },
-                imperial: {
-                    unit: "ft-cd",
-                    ratio: 10.76391
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/frequency.js
-var require_frequency = __commonJS({
-    "node_modules/convert-units/lib/definitions/frequency.js": function(exports2, module2) {
-        var frequency;
-        frequency = {
-            mHz: {
-                name: {
-                    singular: "millihertz",
-                    plural: "millihertz"
-                },
-                to_anchor: 1 / 1e3
-            },
-            Hz: {
-                name: {
-                    singular: "hertz",
-                    plural: "hertz"
-                },
-                to_anchor: 1
-            },
-            kHz: {
-                name: {
-                    singular: "kilohertz",
-                    plural: "kilohertz"
-                },
-                to_anchor: 1e3
-            },
-            MHz: {
-                name: {
-                    singular: "megahertz",
-                    plural: "megahertz"
-                },
-                to_anchor: 1e3 * 1e3
-            },
-            GHz: {
-                name: {
-                    singular: "gigahertz",
-                    plural: "gigahertz"
-                },
-                to_anchor: 1e3 * 1e3 * 1e3
-            },
-            THz: {
-                name: {
-                    singular: "terahertz",
-                    plural: "terahertz"
-                },
-                to_anchor: 1e3 * 1e3 * 1e3 * 1e3
-            },
-            rpm: {
-                name: {
-                    singular: "rotation per minute",
-                    plural: "rotations per minute"
-                },
-                to_anchor: 1 / 60
-            },
-            "deg/s": {
-                name: {
-                    singular: "degree per second",
-                    plural: "degrees per second"
-                },
-                to_anchor: 1 / 360
-            },
-            "rad/s": {
-                name: {
-                    singular: "radian per second",
-                    plural: "radians per second"
-                },
-                to_anchor: 1 / (Math.PI * 2)
-            }
-        };
-        module2.exports = {
-            metric: frequency,
-            _anchors: {
-                frequency: {
-                    unit: "hz",
-                    ratio: 1
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/definitions/angle.js
-var require_angle = __commonJS({
-    "node_modules/convert-units/lib/definitions/angle.js": function(exports2, module2) {
-        var angle;
-        angle = {
-            rad: {
-                name: {
-                    singular: "radian",
-                    plural: "radians"
-                },
-                to_anchor: 180 / Math.PI
-            },
-            deg: {
-                name: {
-                    singular: "degree",
-                    plural: "degrees"
-                },
-                to_anchor: 1
-            },
-            grad: {
-                name: {
-                    singular: "gradian",
-                    plural: "gradians"
-                },
-                to_anchor: 9 / 10
-            },
-            arcmin: {
-                name: {
-                    singular: "arcminute",
-                    plural: "arcminutes"
-                },
-                to_anchor: 1 / 60
-            },
-            arcsec: {
-                name: {
-                    singular: "arcsecond",
-                    plural: "arcseconds"
-                },
-                to_anchor: 1 / 3600
-            }
-        };
-        module2.exports = {
-            metric: angle,
-            _anchors: {
-                metric: {
-                    unit: "deg",
-                    ratio: 1
-                }
-            }
-        };
-    }
-});
-// node_modules/convert-units/lib/index.js
-var require_lib = __commonJS({
-    "node_modules/convert-units/lib/index.js": function(exports2, module2) {
-        var convert;
-        var keys = require_lodash5();
-        var each = require_lodash19();
-        var measures = {
-            length: require_length(),
-            area: require_area(),
-            mass: require_mass(),
-            volume: require_volume(),
-            each: require_each(),
-            temperature: require_temperature(),
-            time: require_time(),
-            digital: require_digital(),
-            partsPer: require_partsPer(),
-            speed: require_speed(),
-            pace: require_pace(),
-            pressure: require_pressure(),
-            current: require_current(),
-            voltage: require_voltage(),
-            power: require_power(),
-            reactivePower: require_reactivePower(),
-            apparentPower: require_apparentPower(),
-            energy: require_energy(),
-            reactiveEnergy: require_reactiveEnergy(),
-            volumeFlowRate: require_volumeFlowRate(),
-            illuminance: require_illuminance(),
-            frequency: require_frequency(),
-            angle: require_angle()
-        };
-        var Converter;
-        Converter = function Converter(numerator, denominator) {
-            if (denominator) this.val = numerator / denominator;
-            else this.val = numerator;
-        };
-        Converter.prototype.from = function(from) {
-            if (this.destination) throw new Error(".from must be called before .to");
-            this.origin = this.getUnit(from);
-            if (!this.origin) {
-                this.throwUnsupportedUnitError(from);
-            }
-            return this;
-        };
-        Converter.prototype.to = function(to) {
-            if (!this.origin) throw new Error(".to must be called after .from");
-            this.destination = this.getUnit(to);
-            var result, transform;
-            if (!this.destination) {
-                this.throwUnsupportedUnitError(to);
-            }
-            if (this.origin.abbr === this.destination.abbr) {
-                return this.val;
-            }
-            if (this.destination.measure != this.origin.measure) {
-                throw new Error("Cannot convert incompatible measures of " + this.destination.measure + " and " + this.origin.measure);
-            }
-            result = this.val * this.origin.unit.to_anchor;
-            if (this.origin.unit.anchor_shift) {
-                result -= this.origin.unit.anchor_shift;
-            }
-            if (this.origin.system != this.destination.system) {
-                transform = measures[this.origin.measure]._anchors[this.origin.system].transform;
-                if (typeof transform === "function") {
-                    result = transform(result);
-                } else {
-                    result *= measures[this.origin.measure]._anchors[this.origin.system].ratio;
-                }
-            }
-            if (this.destination.unit.anchor_shift) {
-                result += this.destination.unit.anchor_shift;
-            }
-            return result / this.destination.unit.to_anchor;
-        };
-        Converter.prototype.toBest = function(options) {
-            if (!this.origin) throw new Error(".toBest must be called after .from");
-            var options = Object.assign({
-                exclude: [],
-                cutOffNumber: 1
-            }, options);
-            var best;
-            each(this.possibilities(), (function(possibility) {
-                var unit = this.describe(possibility);
-                var isIncluded = options.exclude.indexOf(possibility) === -1;
-                if (isIncluded && unit.system === this.origin.system) {
-                    var result = this.to(possibility);
-                    if (!best || result >= options.cutOffNumber && result < best.val) {
-                        best = {
-                            val: result,
-                            unit: possibility,
-                            singular: unit.singular,
-                            plural: unit.plural
-                        };
-                    }
-                }
-            }).bind(this));
-            return best;
-        };
-        Converter.prototype.getUnit = function(abbr) {
-            var found;
-            each(measures, function(systems, measure) {
-                each(systems, function(units, system) {
-                    if (system == "_anchors") return false;
-                    each(units, function(unit, testAbbr) {
-                        if (testAbbr == abbr) {
-                            found = {
-                                abbr: abbr,
-                                measure: measure,
-                                system: system,
-                                unit: unit
-                            };
-                            return false;
-                        }
-                    });
-                    if (found) return false;
-                });
-                if (found) return false;
-            });
-            return found;
-        };
-        var describe = function describe(resp) {
-            return {
-                abbr: resp.abbr,
-                measure: resp.measure,
-                system: resp.system,
-                singular: resp.unit.name.singular,
-                plural: resp.unit.name.plural
-            };
-        };
-        Converter.prototype.describe = function(abbr) {
-            var resp = Converter.prototype.getUnit(abbr);
-            var desc = null;
-            try {
-                desc = describe(resp);
-            } catch (err) {
-                this.throwUnsupportedUnitError(abbr);
-            }
-            return desc;
-        };
-        Converter.prototype.list = function(measure) {
-            var list = [];
-            each(measures, function(systems, testMeasure) {
-                if (measure && measure !== testMeasure) return;
-                each(systems, function(units, system) {
-                    if (system == "_anchors") return false;
-                    each(units, function(unit, abbr) {
-                        list = list.concat(describe({
-                            abbr: abbr,
-                            measure: testMeasure,
-                            system: system,
-                            unit: unit
-                        }));
-                    });
-                });
-            });
-            return list;
-        };
-        Converter.prototype.throwUnsupportedUnitError = function(what) {
-            var validUnits = [];
-            each(measures, function(systems, measure) {
-                each(systems, function(units, system) {
-                    if (system == "_anchors") return false;
-                    validUnits = validUnits.concat(keys(units));
-                });
-            });
-            throw new Error("Unsupported unit " + what + ", use one of: " + validUnits.join(", "));
-        };
-        Converter.prototype.possibilities = function(measure) {
-            var possibilities = [];
-            if (!this.origin && !measure) {
-                each(keys(measures), function(measure2) {
-                    each(measures[measure2], function(units, system) {
-                        if (system == "_anchors") return false;
-                        possibilities = possibilities.concat(keys(units));
-                    });
-                });
-            } else {
-                measure = measure || this.origin.measure;
-                each(measures[measure], function(units, system) {
-                    if (system == "_anchors") return false;
-                    possibilities = possibilities.concat(keys(units));
-                });
-            }
-            return possibilities;
-        };
-        Converter.prototype.measures = function() {
-            return keys(measures);
-        };
-        convert = function convert(value) {
-            return new Converter(value);
-        };
-        module2.exports = convert;
-    }
-});
 // node_modules/use-mouse-matrix-transform/dist/index.js
 var require_dist = __commonJS({
     "node_modules/use-mouse-matrix-transform/dist/index.js": function(exports2, module2) {
@@ -3191,6 +790,9 @@ __export(dist_exports, {
     any_source_component: function() {
         return any_source_component;
     },
+    battery_capacity: function() {
+        return battery_capacity;
+    },
     cad_component: function() {
         return cad_component;
     },
@@ -3203,6 +805,9 @@ __export(dist_exports, {
     distance: function() {
         return distance;
     },
+    frequency: function() {
+        return frequency;
+    },
     getZodPrefixedIdWithDefault: function() {
         return getZodPrefixedIdWithDefault;
     },
@@ -3242,6 +847,9 @@ __export(dist_exports, {
     pcb_keepout: function() {
         return pcb_keepout;
     },
+    pcb_missing_footprint_error: function() {
+        return pcb_missing_footprint_error;
+    },
     pcb_placement_error: function() {
         return pcb_placement_error;
     },
@@ -3281,6 +889,9 @@ __export(dist_exports, {
     pcb_smtpad: function() {
         return pcb_smtpad;
     },
+    pcb_solder_paste: function() {
+        return pcb_solder_paste;
+    },
     pcb_text: function() {
         return pcb_text;
     },
@@ -3311,6 +922,9 @@ __export(dist_exports, {
     point3: function() {
         return point3;
     },
+    port_arrangement: function() {
+        return port_arrangement;
+    },
     position: function() {
         return position;
     },
@@ -3332,6 +946,27 @@ __export(dist_exports, {
     schematic_component: function() {
         return schematic_component;
     },
+    schematic_component_port_arrangement_by_sides: function() {
+        return schematic_component_port_arrangement_by_sides;
+    },
+    schematic_component_port_arrangement_by_size: function() {
+        return schematic_component_port_arrangement_by_size;
+    },
+    schematic_debug_line: function() {
+        return schematic_debug_line;
+    },
+    schematic_debug_object: function() {
+        return schematic_debug_object;
+    },
+    schematic_debug_object_base: function() {
+        return schematic_debug_object_base;
+    },
+    schematic_debug_point: function() {
+        return schematic_debug_point;
+    },
+    schematic_debug_rect: function() {
+        return schematic_debug_rect;
+    },
     schematic_error: function() {
         return schematic_error;
     },
@@ -3374,6 +1009,9 @@ __export(dist_exports, {
     source_port: function() {
         return source_port;
     },
+    source_simple_battery: function() {
+        return source_simple_battery;
+    },
     source_simple_bug: function() {
         return source_simple_bug;
     },
@@ -3383,15 +1021,27 @@ __export(dist_exports, {
     source_simple_chip: function() {
         return source_simple_chip;
     },
+    source_simple_crystal: function() {
+        return source_simple_crystal;
+    },
     source_simple_diode: function() {
         return source_simple_diode;
     },
     source_simple_ground: function() {
         return source_simple_ground;
     },
+    source_simple_inductor: function() {
+        return source_simple_inductor;
+    },
+    source_simple_potentiometer: function() {
+        return source_simple_potentiometer;
+    },
     source_simple_power_source: function() {
         return source_simple_power_source;
     },
+    source_simple_push_button: function() {
+        return source_simple_push_button;
+    },
     source_simple_resistor: function() {
         return source_simple_resistor;
     },
@@ -3411,7 +1061,6 @@ __export(dist_exports, {
         return voltage;
     }
 });
-var import_convert_units = __toESM(require_lib(), 1);
 // node_modules/zod/lib/index.mjs
 var util;
 (function(util2) {
@@ -9617,44 +7266,159 @@ function nanoid() {
     return id;
 }
 // node_modules/circuit-json/dist/index.mjs
-var si_prefix_multiplier = {
-    tera: 1e13,
-    T: 1e13,
-    giga: 1e10,
-    G: 1e10,
-    mega: 1e7,
-    M: 1e7,
-    kilo: 1e4,
-    k: 1e4,
-    deci: 1,
-    d: 1,
-    centi: 0.1,
-    c: 0.1,
-    milli: 0.01,
-    m: 0.01,
-    micro: 1e-5,
-    u: 1e-5,
-    µ: 1e-5,
-    nano: 1e-8,
-    n: 1e-8,
-    pico: 1e-11,
-    p: 1e-11
-};
-var si_prefixes = Object.keys(si_prefix_multiplier);
-var target_conversion = {
-    mass: "g",
-    length: "mm",
-    time: "ms",
-    volume: "ml",
-    angle: "deg"
+var unitMappings = {
+    Hz: {
+        baseUnit: "Hz",
+        variants: {
+            MHz: 1e6,
+            kHz: 1e3,
+            Hz: 1
+        }
+    },
+    g: {
+        baseUnit: "g",
+        variants: {
+            kg: 1e3,
+            g: 1
+        }
+    },
+    Ω: {
+        baseUnit: "Ω",
+        variants: {
+            mΩ: 1e-3,
+            Ω: 1,
+            kΩ: 1e3,
+            MΩ: 1e6,
+            GΩ: 1e9,
+            TΩ: 1e12
+        }
+    },
+    V: {
+        baseUnit: "V",
+        variants: {
+            mV: 1e-3,
+            V: 1,
+            kV: 1e3,
+            MV: 1e6,
+            GV: 1e9,
+            TV: 1e12
+        }
+    },
+    A: {
+        baseUnit: "A",
+        variants: {
+            µA: 1e-6,
+            mA: 1e-3,
+            ma: 1e-3,
+            A: 1,
+            kA: 1e3,
+            MA: 1e6
+        }
+    },
+    F: {
+        baseUnit: "F",
+        variants: {
+            pF: 1e-12,
+            nF: 1e-9,
+            µF: 1e-6,
+            uF: 1e-6,
+            mF: 1e-3,
+            F: 1
+        }
+    },
+    ml: {
+        baseUnit: "ml",
+        variants: {
+            ml: 1,
+            mL: 1,
+            l: 1e3,
+            L: 1e3
+        }
+    },
+    deg: {
+        baseUnit: "deg",
+        variants: {
+            rad: 180 / Math.PI
+        }
+    },
+    ms: {
+        baseUnit: "ms",
+        variants: {
+            s: 1e3
+        }
+    },
+    mm: {
+        baseUnit: "mm",
+        variants: {
+            nm: 1e-6,
+            µm: 1e-3,
+            um: 1e-3,
+            mm: 1,
+            cm: 10,
+            dm: 100,
+            m: 1e3,
+            km: 1e6,
+            in: 25.4,
+            ft: 304.8,
+            IN: 25.4,
+            FT: 304.8,
+            yd: 914.4,
+            mi: 1609344,
+            mil: 0.0254
+        }
+    }
 };
-function getSiPrefixMultiplierFromUnit(v) {
+var unitMappingAndVariantSuffixes = /* @__PURE__ */ new Set();
+var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+try {
+    for(var _iterator = Object.entries(unitMappings)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+        var _step_value = _sliced_to_array(_step.value, 2), baseUnit = _step_value[0], info = _step_value[1];
+        unitMappingAndVariantSuffixes.add(baseUnit);
+        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+        try {
+            for(var _iterator1 = Object.keys(info.variants)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                var variant = _step1.value;
+                unitMappingAndVariantSuffixes.add(variant);
+            }
+        } 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;
+        }
+    }
+}
+function getBaseTscircuitUnit(unit) {
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
-        for(var _iterator = si_prefixes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-            var prefix = _step.value;
-            if (v.startsWith(prefix)) {
-                return si_prefix_multiplier[prefix];
+        for(var _iterator = Object.entries(unitMappings)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array(_step.value, 2), baseUnit = _step_value[0], info = _step_value[1];
+            if (unit in info.variants) {
+                return {
+                    baseUnit: info.baseUnit,
+                    conversionFactor: info.variants[unit]
+                };
             }
         }
     } catch (err) {
@@ -9671,57 +7435,83 @@ function getSiPrefixMultiplierFromUnit(v) {
             }
         }
     }
-    return 1;
+    return {
+        baseUnit: unit,
+        conversionFactor: 1
+    };
 }
+var si_prefix_multiplier = {
+    tera: 1e12,
+    T: 1e12,
+    giga: 1e9,
+    G: 1e9,
+    mega: 1e6,
+    M: 1e6,
+    kilo: 1e3,
+    k: 1e3,
+    deci: 0.1,
+    d: 0.1,
+    centi: 0.01,
+    c: 0.01,
+    milli: 1e-3,
+    m: 1e-3,
+    micro: 1e-6,
+    u: 1e-6,
+    µ: 1e-6,
+    nano: 1e-9,
+    n: 1e-9,
+    pico: 1e-12,
+    p: 1e-12
+};
 var parseAndConvertSiUnit = function(v) {
-    var _v_split_reverse_join_match;
+    var _reversed_input_string_match;
     if (typeof v === "undefined") return {
-        unit: null,
+        parsedUnit: null,
+        unitOfValue: null,
         value: null
     };
     if (typeof v === "string" && v.match(/^[\d\.]+$/)) return {
-        value: parseFloat(v),
-        unit: null
+        value: Number.parseFloat(v),
+        parsedUnit: null,
+        unitOfValue: null
     };
     if (typeof v === "number") return {
         value: v,
-        unit: null
+        parsedUnit: null,
+        unitOfValue: null
     };
     if (typeof v === "object" && "x" in v && "y" in v) {
+        var _parseAndConvertSiUnit = parseAndConvertSiUnit(v.x), parsedUnit = _parseAndConvertSiUnit.parsedUnit, unitOfValue = _parseAndConvertSiUnit.unitOfValue;
         return {
-            unit: parseAndConvertSiUnit(v.x).unit,
+            parsedUnit: parsedUnit,
+            unitOfValue: unitOfValue,
             value: {
                 x: parseAndConvertSiUnit(v.x).value,
                 y: parseAndConvertSiUnit(v.y).value
             }
         };
     }
-    var unit_reversed = (_v_split_reverse_join_match = v.split("").reverse().join("").match(/[a-zA-Z]+/)) === null || _v_split_reverse_join_match === void 0 ? void 0 : _v_split_reverse_join_match[0];
+    var reversed_input_string = v.toString().split("").reverse().join("");
+    var unit_reversed = (_reversed_input_string_match = reversed_input_string.match(/[^\d\s]+/)) === null || _reversed_input_string_match === void 0 ? void 0 : _reversed_input_string_match[0];
     if (!unit_reversed) {
         throw new Error('Could not determine unit: "'.concat(v, '"'));
     }
     var unit = unit_reversed.split("").reverse().join("");
-    var value = v.slice(0, -unit.length);
-    var measure;
-    try {
-        var _describe;
-        measure = (_describe = (0, import_convert_units.default)().describe(unit)) === null || _describe === void 0 ? void 0 : _describe.measure;
-    } catch (e) {}
-    if (measure) {
-        var target_unit = target_conversion[measure];
-        if (!target_unit) {
-            throw new Error('Could not determine target unit for measure: "'.concat(measure, '"'));
-        }
-        return {
-            unit: unit,
-            value: (0, import_convert_units.default)(parseFloat(value)).from(unit).to(target_unit)
-        };
-    } else {
+    var numberPart = v.slice(0, -unit.length);
+    if (unit in si_prefix_multiplier && !unitMappingAndVariantSuffixes.has(unit)) {
+        var siMultiplier = si_prefix_multiplier[unit];
         return {
-            unit: unit,
-            value: getSiPrefixMultiplierFromUnit(unit) * parseFloat(value)
+            parsedUnit: null,
+            unitOfValue: null,
+            value: Number.parseFloat(numberPart) * siMultiplier
         };
     }
+    var _getBaseTscircuitUnit = getBaseTscircuitUnit(unit), baseUnit = _getBaseTscircuitUnit.baseUnit, conversionFactor = _getBaseTscircuitUnit.conversionFactor;
+    return {
+        parsedUnit: unit,
+        unitOfValue: baseUnit,
+        value: conversionFactor * Number.parseFloat(numberPart)
+    };
 };
 var resistance = z.string().or(z.number()).transform(function(v) {
     return parseAndConvertSiUnit(v).value;
@@ -9738,6 +7528,9 @@ var voltage = z.string().or(z.number()).transform(function(v) {
 var length = z.string().or(z.number()).transform(function(v) {
     return parseAndConvertSiUnit(v).value;
 });
+var frequency = z.string().or(z.number()).transform(function(v) {
+    return parseAndConvertSiUnit(v).value;
+});
 var distance = length;
 var current = z.string().or(z.number()).transform(function(v) {
     return parseAndConvertSiUnit(v).value;
@@ -9755,6 +7548,17 @@ var rotation = z.string().or(z.number()).transform(function(arg) {
     }
     return Number.parseFloat(arg);
 });
+var battery_capacity = z.number().or(z.string().endsWith("mAh")).transform(function(v) {
+    if (typeof v === "string") {
+        var valString = v.replace("mAh", "");
+        var num = Number.parseFloat(valString);
+        if (Number.isNaN(num)) {
+            throw new Error("Invalid capacity");
+        }
+        return num;
+    }
+    return v;
+}).describe("Battery capacity in mAh");
 var point = z.object({
     x: distance,
     y: distance
@@ -9783,14 +7587,20 @@ var supplier_name = z.enum([
     "mouser",
     "lcsc"
 ]);
+var expectTypesMatch = function(shouldBe) {};
+expectTypesMatch("extra props b");
+expectTypesMatch("missing props b");
+expectTypesMatch(true);
 var source_component_base = z.object({
     type: z.literal("source_component"),
     ftype: z.string().optional(),
     source_component_id: z.string(),
     name: z.string(),
     manufacturer_part_number: z.string().optional(),
-    supplier_part_numbers: z.record(supplier_name, z.array(z.string())).optional()
+    supplier_part_numbers: z.record(supplier_name, z.array(z.string())).optional(),
+    display_value: z.string().optional()
 });
+expectTypesMatch(true);
 var source_simple_capacitor = source_component_base.extend({
     ftype: z.literal("simple_capacitor"),
     capacitance: capacitance
@@ -9811,10 +7621,6 @@ var source_simple_bug = source_component_base.extend({
 var source_simple_chip = source_component_base.extend({
     ftype: z.literal("simple_chip")
 });
-var source_simple_inductor = source_component_base.extend({
-    ftype: z.literal("simple_inductor"),
-    inductance: inductance
-});
 var source_led = source_simple_diode.extend({
     ftype: z.literal("led")
 });
@@ -9822,6 +7628,26 @@ var source_simple_power_source = source_component_base.extend({
     ftype: z.literal("simple_power_source"),
     voltage: voltage
 });
+var source_simple_battery = source_component_base.extend({
+    ftype: z.literal("simple_battery"),
+    capacity: battery_capacity
+});
+var source_simple_inductor = source_component_base.extend({
+    ftype: z.literal("simple_inductor"),
+    inductance: inductance
+});
+var source_simple_push_button = source_component_base.extend({
+    ftype: z.literal("simple_push_button")
+});
+var source_simple_potentiometer = source_component_base.extend({
+    ftype: z.literal("simple_potentiometer"),
+    max_resistance: resistance
+});
+var source_simple_crystal = source_component_base.extend({
+    ftype: z.literal("simple_crystal"),
+    frequency: z.number().describe("Frequency in Hz"),
+    load_capacitance: z.number().optional().describe("Load capacitance in pF")
+});
 var any_source_component = z.union([
     source_simple_resistor,
     source_simple_capacitor,
@@ -9830,7 +7656,12 @@ var any_source_component = z.union([
     source_simple_chip,
     source_simple_bug,
     source_led,
-    source_simple_power_source
+    source_simple_power_source,
+    source_simple_battery,
+    source_simple_inductor,
+    source_simple_push_button,
+    source_simple_potentiometer,
+    source_simple_crystal
 ]);
 var source_port = z.object({
     type: z.literal("source_port"),
@@ -9844,8 +7675,10 @@ var source_trace = z.object({
     type: z.literal("source_trace"),
     source_trace_id: z.string(),
     connected_source_port_ids: z.array(z.string()),
-    connected_source_net_ids: z.array(z.string())
+    connected_source_net_ids: z.array(z.string()),
+    subcircuit_connectivity_map_key: z.string().optional()
 });
+expectTypesMatch(true);
 var source_group = z.object({
     type: z.literal("source_group"),
     source_group_id: z.string(),
@@ -9886,6 +7719,48 @@ var schematic_pin_styles = z.record(z.object({
     top_margin: length.optional(),
     bottom_margin: length.optional()
 }));
+var schematic_component_port_arrangement_by_size = z.object({
+    left_size: z.number(),
+    right_size: z.number(),
+    top_size: z.number().optional(),
+    bottom_size: z.number().optional()
+});
+expectTypesMatch(true);
+var schematic_component_port_arrangement_by_sides = z.object({
+    left_side: z.object({
+        pins: z.array(z.number()),
+        direction: z.enum([
+            "top-to-bottom",
+            "bottom-to-top"
+        ]).optional()
+    }).optional(),
+    right_side: z.object({
+        pins: z.array(z.number()),
+        direction: z.enum([
+            "top-to-bottom",
+            "bottom-to-top"
+        ]).optional()
+    }).optional(),
+    top_side: z.object({
+        pins: z.array(z.number()),
+        direction: z.enum([
+            "left-to-right",
+            "right-to-left"
+        ]).optional()
+    }).optional(),
+    bottom_side: z.object({
+        pins: z.array(z.number()),
+        direction: z.enum([
+            "left-to-right",
+            "right-to-left"
+        ]).optional()
+    }).optional()
+});
+expectTypesMatch(true);
+var port_arrangement = z.union([
+    schematic_component_port_arrangement_by_size,
+    schematic_component_port_arrangement_by_sides
+]);
 var schematic_component = z.object({
     type: z.literal("schematic_component"),
     rotation: rotation.default(0),
@@ -9897,46 +7772,11 @@ var schematic_component = z.object({
     pin_styles: schematic_pin_styles.optional(),
     box_width: length.optional(),
     symbol_name: z.string().optional(),
-    port_arrangement: z.union([
-        z.object({
-            left_size: z.number(),
-            right_size: z.number(),
-            top_size: z.number().optional(),
-            bottom_size: z.number().optional()
-        }),
-        z.object({
-            left_side: z.object({
-                pins: z.array(z.number()),
-                direction: z.enum([
-                    "top-to-bottom",
-                    "bottom-to-top"
-                ]).optional()
-            }).optional(),
-            right_side: z.object({
-                pins: z.array(z.number()),
-                direction: z.enum([
-                    "top-to-bottom",
-                    "bottom-to-top"
-                ]).optional()
-            }).optional(),
-            top_side: z.object({
-                pins: z.array(z.number()),
-                direction: z.enum([
-                    "left-to-right",
-                    "right-to-left"
-                ]).optional()
-            }).optional(),
-            bottom_side: z.object({
-                pins: z.array(z.number()),
-                direction: z.enum([
-                    "left-to-right",
-                    "right-to-left"
-                ]).optional()
-            }).optional()
-        })
-    ]).optional(),
-    port_labels: z.record(z.string()).optional()
+    port_arrangement: port_arrangement.optional(),
+    port_labels: z.record(z.string()).optional(),
+    symbol_display_value: z.string().optional()
 });
+expectTypesMatch(true);
 var schematic_line = z.object({
     type: z.literal("schematic_line"),
     schematic_component_id: z.string(),
@@ -9949,6 +7789,10 @@ var schematic_trace = z.object({
     type: z.literal("schematic_trace"),
     schematic_trace_id: z.string(),
     source_trace_id: z.string(),
+    junctions: z.array(z.object({
+        x: z.number(),
+        y: z.number()
+    })),
     edges: z.array(z.object({
         from: z.object({
             x: z.number(),
@@ -9958,10 +7802,12 @@ var schematic_trace = z.object({
             x: z.number(),
             y: z.number()
         }),
+        is_crossing: z.boolean().optional(),
         from_schematic_port_id: z.string().optional(),
         to_schematic_port_id: z.string().optional()
     }))
 });
+expectTypesMatch(true);
 var schematic_text = z.object({
     type: z.literal("schematic_text"),
     schematic_component_id: z.string(),
@@ -9978,7 +7824,8 @@ var schematic_text = z.object({
         "right",
         "top",
         "bottom"
-    ]).default("center")
+    ]).default("center"),
+    color: z.string().default("#000000")
 });
 var schematic_port = z.object({
     type: z.literal("schematic_port"),
@@ -9991,19 +7838,32 @@ var schematic_port = z.object({
         "down",
         "left",
         "right"
-    ]).optional()
+    ]).optional(),
+    distance_from_component_edge: z.number().optional(),
+    side_of_component: z.enum([
+        "top",
+        "bottom",
+        "left",
+        "right"
+    ]).optional(),
+    true_ccw_index: z.number().optional(),
+    pin_number: z.number().optional(),
+    display_pin_label: z.string().optional()
 }).describe("Defines a port on a schematic component");
+expectTypesMatch(true);
 var schematic_net_label = z.object({
     type: z.literal("schematic_net_label"),
     source_net_id: z.string(),
     center: point,
+    anchor_position: point.optional(),
     anchor_side: z.enum([
         "top",
         "bottom",
         "left",
         "right"
     ]),
-    text: z.string()
+    text: z.string(),
+    symbol_name: z.string().optional()
 });
 var schematic_error = z.object({
     schematic_error_id: z.string(),
@@ -10012,6 +7872,30 @@ var schematic_error = z.object({
     error_type: z.literal("schematic_port_not_found"),
     message: z.string()
 }).describe("Defines a schematic error on the schematic");
+var schematic_debug_object_base = z.object({
+    type: z.literal("schematic_debug_object"),
+    label: z.string().optional()
+});
+var schematic_debug_rect = schematic_debug_object_base.extend({
+    shape: z.literal("rect"),
+    center: point,
+    size: size
+});
+var schematic_debug_line = schematic_debug_object_base.extend({
+    shape: z.literal("line"),
+    start: point,
+    end: point
+});
+var schematic_debug_point = schematic_debug_object_base.extend({
+    shape: z.literal("point"),
+    center: point
+});
+var schematic_debug_object = z.discriminatedUnion("shape", [
+    schematic_debug_rect,
+    schematic_debug_line,
+    schematic_debug_point
+]);
+expectTypesMatch(true);
 var all_layers = [
     "top",
     "bottom",
@@ -10049,7 +7933,6 @@ var route_hint_point = z.object({
     to_layer: layer_ref.optional(),
     trace_width: distance.optional()
 });
-var expectTypesMatch = function(shouldBe) {};
 var pcb_component = z.object({
     type: z.literal("pcb_component"),
     pcb_component_id: getZodPrefixedIdWithDefault("pcb_component"),
@@ -10158,12 +8041,57 @@ var pcb_smtpad_rect = z.object({
     pcb_component_id: z.string().optional(),
     pcb_port_id: z.string().optional()
 });
+var pcb_smtpad_rotated_rect = z.object({
+    type: z.literal("pcb_smtpad"),
+    shape: z.literal("rotated_rect"),
+    pcb_smtpad_id: getZodPrefixedIdWithDefault("pcb_smtpad"),
+    x: distance,
+    y: distance,
+    width: z.number(),
+    height: z.number(),
+    ccw_rotation: rotation,
+    layer: layer_ref,
+    port_hints: z.array(z.string()).optional(),
+    pcb_component_id: z.string().optional(),
+    pcb_port_id: z.string().optional()
+});
 var pcb_smtpad = z.union([
     pcb_smtpad_circle,
-    pcb_smtpad_rect
+    pcb_smtpad_rect,
+    pcb_smtpad_rotated_rect
 ]).describe("Defines an SMT pad on the PCB");
 expectTypesMatch(true);
 expectTypesMatch(true);
+expectTypesMatch(true);
+var pcb_solder_paste_circle = z.object({
+    type: z.literal("pcb_solder_paste"),
+    shape: z.literal("circle"),
+    pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
+    x: distance,
+    y: distance,
+    radius: z.number(),
+    layer: layer_ref,
+    pcb_component_id: z.string().optional(),
+    pcb_smtpad_id: z.string().optional()
+});
+var pcb_solder_paste_rect = z.object({
+    type: z.literal("pcb_solder_paste"),
+    shape: z.literal("rect"),
+    pcb_solder_paste_id: getZodPrefixedIdWithDefault("pcb_solder_paste"),
+    x: distance,
+    y: distance,
+    width: z.number(),
+    height: z.number(),
+    layer: layer_ref,
+    pcb_component_id: z.string().optional(),
+    pcb_smtpad_id: z.string().optional()
+});
+var pcb_solder_paste = z.union([
+    pcb_solder_paste_circle,
+    pcb_solder_paste_rect
+]).describe("Defines solderpaste on the PCB");
+expectTypesMatch(true);
+expectTypesMatch(true);
 var pcb_text = z.object({
     type: z.literal("pcb_text"),
     pcb_text_id: getZodPrefixedIdWithDefault("pcb_text"),
@@ -10207,6 +8135,7 @@ var pcb_trace = z.object({
         "constant",
         "interpolated"
     ]).default("constant").optional(),
+    route_order_index: z.number().optional(),
     should_round_corners: z.boolean().optional(),
     route: z.array(z.union([
         z.object({
@@ -10257,7 +8186,8 @@ var pcb_via = z.object({
     hole_diameter: distance.default("0.25mm"),
     /** @deprecated */ from_layer: layer_ref.optional(),
     /** @deprecated */ to_layer: layer_ref.optional(),
-    layers: z.array(layer_ref)
+    layers: z.array(layer_ref),
+    pcb_trace_id: z.string().optional()
 }).describe("Defines a via on the PCB");
 expectTypesMatch(true);
 var pcb_board = z.object({
@@ -10266,6 +8196,8 @@ var pcb_board = z.object({
     width: length,
     height: length,
     center: point,
+    thickness: length.optional().default(1.4),
+    num_layers: z.number().optional().default(4),
     outline: z.array(point).optional()
 }).describe("Defines the board outline of the PCB");
 expectTypesMatch(true);
@@ -10312,6 +8244,7 @@ var pcb_silkscreen_text = z.object({
     pcb_component_id: z.string(),
     text: z.string(),
     layer: layer_ref,
+    is_mirrored: z.boolean().default(false).optional(),
     anchor_position: point.default({
         x: 0,
         y: 0
@@ -10406,6 +8339,14 @@ var pcb_keepout = z.object({
     // Specify layers where the keepout applies
     description: z.string().optional()
 }));
+var pcb_missing_footprint_error = z.object({
+    type: z.literal("pcb_missing_footprint_error"),
+    pcb_missing_footprint_error_id: getZodPrefixedIdWithDefault("pcb_missing_footprint_error"),
+    error_type: z.literal("pcb_missing_footprint_error"),
+    source_component_id: z.string(),
+    message: z.string()
+}).describe("Defines a missing footprint error on the PCB");
+expectTypesMatch(true);
 var cad_component = z.object({
     type: z.literal("cad_component"),
     cad_component_id: z.string(),
@@ -10435,8 +8376,13 @@ var any_circuit_element = z.union([
     source_simple_diode,
     source_simple_resistor,
     source_simple_power_source,
+    source_simple_battery,
+    source_simple_inductor,
+    source_simple_potentiometer,
+    source_simple_push_button,
     pcb_component,
     pcb_hole,
+    pcb_missing_footprint_error,
     pcb_plated_hole,
     pcb_keepout,
     pcb_port,
@@ -10444,6 +8390,7 @@ var any_circuit_element = z.union([
     pcb_trace,
     pcb_via,
     pcb_smtpad,
+    pcb_solder_paste,
     pcb_board,
     pcb_trace_hint,
     pcb_silkscreen_line,
@@ -10466,6 +8413,7 @@ var any_circuit_element = z.union([
     schematic_path,
     schematic_error,
     schematic_net_label,
+    schematic_debug_object,
     cad_component
 ]);
 var any_soup_element = any_circuit_element;
@@ -11970,7 +9918,6 @@ var LAYER_NAME_TO_COLOR = _object_spread({
     top: colors_default.board.copper.f,
     inner1: colors_default.board.copper.in1,
     inner2: colors_default.board.copper.in2,
-    inner3: colors_default.board.copper.in3,
     inner4: colors_default.board.copper.in4,
     inner5: colors_default.board.copper.in5,
     inner6: colors_default.board.copper.in6,
@@ -12115,6 +10062,39 @@ var Drawer = /*#__PURE__*/ function() {
                 }
             }
         },
+        {
+            key: "rotatedRect",
+            value: function rotatedRect(x, y, w, h, ccw_rotation, mesh_fill) {
+                var ctx = this.getLayerCtx();
+                this.applyAperture();
+                var _ref = _sliced_to_array((0, import_transformation_matrix3.applyToPoint)(this.transform, [
+                    x - w / 2,
+                    y - h / 2
+                ]), 2), x1$ = _ref[0], y1$ = _ref[1];
+                var _ref1 = _sliced_to_array((0, import_transformation_matrix3.applyToPoint)(this.transform, [
+                    x + w / 2,
+                    y + h / 2
+                ]), 2), x2$ = _ref1[0], y2$ = _ref1[1];
+                ctx.save();
+                var _ref2 = _sliced_to_array((0, import_transformation_matrix3.applyToPoint)(this.transform, [
+                    x,
+                    y
+                ]), 2), centerX = _ref2[0], centerY = _ref2[1];
+                ctx.translate(centerX, centerY);
+                ctx.rotate(ccw_rotation * Math.PI / 180);
+                ctx.translate(-centerX, -centerY);
+                if (mesh_fill) {
+                    ctx.beginPath();
+                    ctx.rect(x1$, y1$, x2$ - x1$, y2$ - y1$);
+                    ctx.clip();
+                    this.drawMeshPattern(x - w / 2, y - h / 2, w, h, 0.15);
+                    ctx.strokeRect(x1$, y1$, x2$ - x1$, y2$ - y1$);
+                } else {
+                    ctx.fillRect(x1$, y1$, x2$ - x1$, y2$ - y1$);
+                }
+                ctx.restore();
+            }
+        },
         {
             key: "circle",
             value: function circle(x, y, r, mesh_fill) {
@@ -12185,7 +10165,6 @@ var Drawer = /*#__PURE__*/ function() {
             value: function polygon(points) {
                 var _this = this;
                 if (points.length < 3) {
-                    console.warn("Polygon must have at least 3 points");
                     return;
                 }
                 this.applyAperture();
@@ -12506,6 +10485,13 @@ var drawRect = function(drawer, rect) {
     });
     drawer.rect(rect.x, rect.y, rect.w, rect.h, rect.mesh_fill);
 };
+var drawRotatedRect = function(drawer, rect) {
+    drawer.equip({
+        color: getColor(rect),
+        layer: rect.layer
+    });
+    drawer.rotatedRect(rect.x, rect.y, rect.w, rect.h, rect.ccw_rotation);
+};
 var drawCircle = function(drawer, circle) {
     drawer.equip({
         color: getColor(circle),
@@ -12541,6 +10527,13 @@ var drawPrimitive = function(drawer, primitive) {
         case "text":
             return drawText(drawer, primitive);
         case "rect":
+            var _primitive__element;
+            if (((_primitive__element = primitive._element) === null || _primitive__element === void 0 ? void 0 : _primitive__element.shape) === "rotated_rect") {
+                return drawRotatedRect(drawer, _object_spread_props(_object_spread({}, primitive), {
+                    ccw_rotation: primitive._element.ccw_rotation,
+                    mesh_fill: primitive.mesh_fill
+                }));
+            }
             return drawRect(drawer, primitive);
         case "circle":
             return drawCircle(drawer, primitive);
@@ -12804,7 +10797,7 @@ var convertElementToPrimitives = function(element, allElements) {
             }
         case "pcb_smtpad":
             {
-                if (element.shape === "rect") {
+                if (element.shape === "rect" || element.shape === "rotated_rect") {
                     var shape = element.shape, x = element.x, y = element.y, width1 = element.width, height1 = element.height, layer = element.layer;
                     return [
                         {
@@ -13747,7 +11740,7 @@ var import_css = require("@emotion/css");
 // package.json
 var package_default = {
     name: "@tscircuit/pcb-viewer",
-    version: "1.10.16",
+    version: "1.10.17",
     main: "dist/index.js",
     repository: "tscircuit/pcb-viewer",
     license: "MIT",
@@ -13756,7 +11749,9 @@ var package_default = {
         build: "tsup ./src/index.tsx --dts --sourcemap --outDir dist",
         yalc: "npm run build && yalc push",
         storybook: "storybook dev -p 6006",
-        "build-storybook": "storybook build"
+        "build-storybook": "storybook build",
+        format: "biome format . --write",
+        "format:check": "biome format ."
     },
     files: [
         "dist"
@@ -13777,7 +11772,7 @@ var package_default = {
         "@types/color": "^3.0.6",
         "@types/node": "18.7.23",
         "@types/react": "^18.3.3",
-        "circuit-json": "^0.0.77",
+        "circuit-json": "^0.0.106",
         next: "^14.1.4",
         react: "^18.2.0",
         "react-dom": "^18.2.0",