@modular-circuit/transpiler 0.0.63 → 0.0.65

package/build/converter/kicad_sexpr/eeschema/printer.js

@@ -1,226 +1,287 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SCHEMATIC_PRINTER = void 0;
-const electronics_model_1 = require("@modular-circuit/electronics-model");
-const ir_1 = require("@modular-circuit/ir");
-const utils_1 = require("@modular-circuit/utils");
-const utils_2 = require("../../../utils");
-const SCOPE_START = '\n\t';
-const SPACE = ' ';
-const SCOPE_END = '\n';
-const IGNORE_BOOLEANS = new Set(['power']);
-class SCHEMATIC_PRINTER {
-    schematic(sch) {
-        const lib_symbols = (() => {
-            if (!sch.lib_symbols?.symbols.length)
-                return '';
-            return `${SCOPE_START}(lib_symbols ${sch.lib_symbols?.symbols.map((it) => this.lib_symbol(it)).join(`${SCOPE_END}`)}\t)`;
-        })();
-        const labels = (() => {
-            if (!sch.labels?.length)
-                return '';
-            return `${SCOPE_START}${sch.labels.map((it) => this.label(it)).join(`${SCOPE_END}`)}`;
-        })();
-        const sch_sheets = (() => {
-            if (!sch.sheets?.length)
-                return '';
-            return `${SCOPE_START}${sch.sheets.map((it) => this.sch_sheet(it)).join(`${SCOPE_END}`)}\t`;
-        })();
-        const sch_symbols = (() => {
-            if (!sch.symbols?.length)
-                return '';
-            return `${SCOPE_START}${sch.symbols.map((it) => this.sch_symbol(it)).join(`${SCOPE_END}`)}\t`;
-        })();
-        return `
-(kicad_sch
-    (version ${utils_2.SCH_VERSION})
-    (generator "${utils_2.GENERATOR_NAME}")
-    (generator_version "${utils_2.GENERATOR_VERSION}")
-    (uuid "${(0, utils_1.gen_uuid)()}")
-    (paper "${utils_2.PAPER}")${lib_symbols}${labels}${sch_symbols}${sch_sheets}
-)
-    `;
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
     }
-    power(power) {
-        return power ? '(power)' : '';
-    }
-    pin_display_opt(opt) {
-        if (!opt)
-            return;
-        const offset = (off) => (off ? `(offset ${off})` : '');
-        const hide = (h) => (h ? 'hide' : '');
-        const pin_numbers = `${opt.pin_numbers ? `(pin_numbers ${offset(opt.pin_numbers.offset)}  ${hide(opt.pin_numbers.hide)})` : ''}`;
-        const pin_names = `${opt.pin_names ? `(pin_names ${offset(opt.pin_names.offset)}  ${hide(opt.pin_names.hide)})` : ''}`;
-        return `${pin_numbers}
-    ${pin_names}
-    `;
-    }
-    lib_symbol(lib_symbol) {
-        return `
-      (symbol "${lib_symbol.name}" ${this.power(lib_symbol.power)}
-      ${this.pin_display_opt(lib_symbol)}
-      ${this.booleans(lib_symbol)}
-      ${this.fields(lib_symbol.properties)}
-      ${this.pin_defs(lib_symbol.pins)}
-      ${this.drawings(lib_symbol.drawings)}
-      ${this.lib_children(lib_symbol.children)}
-)
-    `;
-    }
-    lib_children(libs) {
-        if (!libs)
-            return '';
-        return libs.map((i) => this.lib_symbol(i)).join(SCOPE_END);
-    }
-    pts(points) {
-        return `(pts ${points.map((i) => `(xy ${i.x} ${i.y} )`).join(SPACE)})`;
-    }
-    drawings(draws) {
-        if (!draws)
-            return;
-        return draws.map((i) => this.drawing(i)).join(SCOPE_END);
-    }
-    drawing(draw) {
-        if (!('shape' in draw))
-            throw new Error(`Unhandled drawing ${draw}`);
-        switch (draw.shape) {
-            case ir_1.SHAPE_T.POLY:
-                return `(polyline
-          ${this.pts(draw.pts)}
-          ${this.stroke(draw.stroke)}
-          ${this.fill(draw.fill)}
-				)`;
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
         }
-        throw new Error(`Unhandled drawing ${draw}`);
-    }
-    pin_defs(defs) {
-        if (!defs)
-            return;
-        return defs.map((it) => this.pin_def(it)).join(SCOPE_END);
-    }
-    pin_def(def) {
-        return `(pin ${electronics_model_1.READABLE_ELECTRICAL_PINTYPE[def.type]} ${def.shape}
-					${this.at(def.at)}
-					(length ${def.length})
-					(name "${def.name.text}"
-            ${this.effects(def.name.effects)}
-					)
-					(number "${def.number.text}"
-            ${this.effects(def.number.effects)}
-					)
-				)`;
-    }
-    label(label) {
-        return `	(${label.label_type} "${label.text}"
-		${this.at(label.at)}
-    ${this.fields_autoplaced()}
-    ${this.effects(label.effects)}
-		${this.uuid(label.uuid)}
-	)`;
-    }
-    unit(c) {
-        return `(unit ${c})`;
-    }
-    sch_symbol(sch_symbol) {
-        return `(symbol
-		${this.lib_id(sch_symbol.lib_id)}
-		${this.at(sch_symbol.at)}
-		${this.unit(sch_symbol.unit)}
-    ${this.booleans(sch_symbol)}
-		${this.fields(sch_symbol.properties)}
-    ${sch_symbol.pins.map((pin) => this.sch_symbol_pin(pin)).join(SCOPE_START)}
-	)`;
-    }
-    lib_id(id) {
-        if (!id)
-            return;
-        return `(lib_id "${id}")`;
-    }
-    sch_symbol_pin(pin) {
-        return `(pin "${pin.number}" ${this.uuid(pin.uuid)})`;
-    }
-    sch_sheet(sheet) {
-        return `(sheet 
-    ${this.at(sheet.at)}
-    ${this.size(sheet.size)}
-    ${this.fields_autoplaced()}
-    ${this.stroke(sheet.stroke)}
-    ${this.fill(sheet.fill)}
-    ${this.uuid(sheet.uuid)}
-    ${this.fields(sheet.fields)}
-    ${sheet.pins.map((sheet_pin) => this.sch_sheet_pin(sheet_pin)).join(SCOPE_START)}
-    )`;
-    }
-    sch_sheet_pin(sheet_pin) {
-        return `(pin "${sheet_pin.text}" ${sheet_pin.shape}
-			${this.at(sheet_pin.at)}
-            ${this.effects(sheet_pin.effects)}
-			${this.uuid(sheet_pin.uuid)}
-		)`;
-    }
-    at(pos) {
-        return `(at ${pos.position.x} ${pos.position.y} ${pos.rotation === undefined ? '' : pos.rotation})`;
-    }
-    uuid(id) {
-        return `(uuid "${id}")`;
-    }
-    effects(e) {
-        return `(effects
-      (font
-        (size ${e.font.size.x} ${e.font.size.y})
-      )${this.justify(e.justify)}${e.hide ? '(hide yes)' : ''}
-    )`;
-    }
-    justify(justify) {
-        if (!justify)
-            return;
-        return `(justify ${justify.horizontal} ${justify.vertical})`;
-    }
-    booleans(it) {
-        if (typeof it !== 'object' || !it)
-            return;
-        const res = [];
-        for (const [k, v] of Object.entries(it)) {
-            if (typeof v === 'boolean' && !IGNORE_BOOLEANS.has(k))
-                res.push(`( ${k} ${v ? 'yes' : 'no'} )`);
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
         }
-        return res.join(SCOPE_START);
-    }
-    fields(fields) {
-        if (!fields)
-            return;
-        return fields.map((f) => this.field(f)).join(SCOPE_START);
     }
-    field(field) {
-        return `(property "${field.name}" "${field.text}"
-			${this.at(field.at)}
-            ${this.effects(field.effects)}
-		)`;
-    }
-    fill(f) {
-        if (!f)
-            return;
-        return `(fill${f.type ? ` (type ${f.type})` : ''} ${this.color(f.color)})`;
-    }
-    size(s) {
-        return `(size ${s.x} ${s.y})`;
-    }
-    fields_autoplaced() {
-        return '(fields_autoplaced yes)';
-    }
-    stroke(s) {
-        if (!s)
-            return;
-        return `(stroke
-			(width ${s.width})
-			(type ${s.type})
-      ${this.color(s.color)}
-		)`;
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
     }
-    color(c) {
-        if (!c)
-            return;
-        return `(color ${c.r} ${c.g} ${c.b} ${c.a})`;
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
     }
-}
-exports.SCHEMATIC_PRINTER = SCHEMATIC_PRINTER;
+    return ar;
+};
+import { READABLE_ELECTRICAL_PINTYPE } from '@modular-circuit/electronics-model';
+import { SHAPE_T, } from '@modular-circuit/ir';
+import { gen_uuid } from '@modular-circuit/utils';
+import { GENERATOR_NAME, GENERATOR_VERSION, PAPER, SCH_VERSION, filterNullOrUndefined } from '../../../utils';
+var SCOPE_START = '\n\t';
+var SPACE = ' ';
+var SCOPE_END = '\n';
+var IGNORE_BOOLEANS = new Set(['power']);
+var SCHEMATIC_PRINTER = function () {
+    var _a;
+    var _instanceExtraInitializers = [];
+    var _power_decorators;
+    var _pin_display_opt_decorators;
+    var _lib_children_decorators;
+    var _drawings_decorators;
+    var _pin_defs_decorators;
+    var _unit_decorators;
+    var _lib_id_decorators;
+    var _justify_decorators;
+    var _fields_decorators;
+    var _fill_decorators;
+    var _stroke_decorators;
+    var _color_decorators;
+    return _a = /** @class */ (function () {
+            function SCHEMATIC_PRINTER() {
+                __runInitializers(this, _instanceExtraInitializers);
+            }
+            SCHEMATIC_PRINTER.prototype.schematic = function (sch) {
+                var _this = this;
+                var lib_symbols = (function () {
+                    var _b, _c;
+                    if (!((_b = sch.lib_symbols) === null || _b === void 0 ? void 0 : _b.symbols.length))
+                        return '';
+                    return "".concat(SCOPE_START, "(lib_symbols ").concat((_c = sch.lib_symbols) === null || _c === void 0 ? void 0 : _c.symbols.map(function (it) { return _this.lib_symbol(it); }).join("".concat(SCOPE_END)), "\t)");
+                })();
+                var labels = (function () {
+                    var _b;
+                    if (!((_b = sch.labels) === null || _b === void 0 ? void 0 : _b.length))
+                        return '';
+                    return "".concat(SCOPE_START).concat(sch.labels.map(function (it) { return _this.label(it); }).join("".concat(SCOPE_END)));
+                })();
+                var sch_sheets = (function () {
+                    var _b;
+                    if (!((_b = sch.sheets) === null || _b === void 0 ? void 0 : _b.length))
+                        return '';
+                    return "".concat(SCOPE_START).concat(sch.sheets.map(function (it) { return _this.sch_sheet(it); }).join("".concat(SCOPE_END)), "\t");
+                })();
+                var sch_symbols = (function () {
+                    var _b;
+                    if (!((_b = sch.symbols) === null || _b === void 0 ? void 0 : _b.length))
+                        return '';
+                    return "".concat(SCOPE_START).concat(sch.symbols.map(function (it) { return _this.sch_symbol(it); }).join("".concat(SCOPE_END)), "\t");
+                })();
+                return "\n(kicad_sch\n    (version ".concat(SCH_VERSION, ")\n    (generator \"").concat(GENERATOR_NAME, "\")\n    (generator_version \"").concat(GENERATOR_VERSION, "\")\n    (uuid \"").concat(gen_uuid(), "\")\n    (paper \"").concat(PAPER, "\")").concat(lib_symbols).concat(labels).concat(sch_symbols).concat(sch_sheets, "\n)\n    ");
+            };
+            SCHEMATIC_PRINTER.prototype.power = function (power) {
+                return power ? '(power)' : '';
+            };
+            SCHEMATIC_PRINTER.prototype.pin_display_opt = function (opt) {
+                if (!opt)
+                    return;
+                var offset = function (off) { return (off ? "(offset ".concat(off, ")") : ''); };
+                var hide = function (h) { return (h ? 'hide' : ''); };
+                var pin_numbers = "".concat(opt.pin_numbers ? "(pin_numbers ".concat(offset(opt.pin_numbers.offset), "  ").concat(hide(opt.pin_numbers.hide), ")") : '');
+                var pin_names = "".concat(opt.pin_names ? "(pin_names ".concat(offset(opt.pin_names.offset), "  ").concat(hide(opt.pin_names.hide), ")") : '');
+                return "".concat(pin_numbers, "\n    ").concat(pin_names, "\n    ");
+            };
+            SCHEMATIC_PRINTER.prototype.lib_symbol = function (lib_symbol) {
+                return "\n      (symbol \"".concat(lib_symbol.name, "\" ").concat(this.power(lib_symbol.power), "\n      ").concat(this.pin_display_opt(lib_symbol), "\n      ").concat(this.booleans(lib_symbol), "\n      ").concat(this.fields(lib_symbol.properties), "\n      ").concat(this.pin_defs(lib_symbol.pins), "\n      ").concat(this.drawings(lib_symbol.drawings), "\n      ").concat(this.lib_children(lib_symbol.children), "\n)\n    ");
+            };
+            SCHEMATIC_PRINTER.prototype.lib_children = function (libs) {
+                var _this = this;
+                if (!libs)
+                    return '';
+                return libs.map(function (i) { return _this.lib_symbol(i); }).join(SCOPE_END);
+            };
+            SCHEMATIC_PRINTER.prototype.pts = function (points) {
+                return "(pts ".concat(points.map(function (i) { return "(xy ".concat(i.x, " ").concat(i.y, " )"); }).join(SPACE), ")");
+            };
+            SCHEMATIC_PRINTER.prototype.drawings = function (draws) {
+                var _this = this;
+                if (!draws)
+                    return;
+                return draws.map(function (i) { return _this.drawing(i); }).join(SCOPE_END);
+            };
+            SCHEMATIC_PRINTER.prototype.drawing = function (draw) {
+                if (!('shape' in draw))
+                    throw new Error("Unhandled drawing ".concat(draw));
+                switch (draw.shape) {
+                    case SHAPE_T.POLY:
+                        return "(polyline\n          ".concat(this.pts(draw.pts), "\n          ").concat(this.stroke(draw.stroke), "\n          ").concat(this.fill(draw.fill), "\n\t\t\t\t)");
+                }
+                throw new Error("Unhandled drawing ".concat(draw));
+            };
+            SCHEMATIC_PRINTER.prototype.pin_defs = function (defs) {
+                var _this = this;
+                if (!defs)
+                    return;
+                return defs.map(function (it) { return _this.pin_def(it); }).join(SCOPE_END);
+            };
+            SCHEMATIC_PRINTER.prototype.pin_def = function (def) {
+                return "(pin ".concat(READABLE_ELECTRICAL_PINTYPE[def.type], " ").concat(def.shape, "\n\t\t\t\t\t").concat(this.at(def.at), "\n\t\t\t\t\t(length ").concat(def.length, ")\n\t\t\t\t\t(name \"").concat(def.name.text, "\"\n            ").concat(this.effects(def.name.effects), "\n\t\t\t\t\t)\n\t\t\t\t\t(number \"").concat(def.number.text, "\"\n            ").concat(this.effects(def.number.effects), "\n\t\t\t\t\t)\n\t\t\t\t)");
+            };
+            SCHEMATIC_PRINTER.prototype.label = function (label) {
+                return "\t(".concat(label.label_type, " \"").concat(label.text, "\"\n\t\t").concat(this.at(label.at), "\n    ").concat(this.fields_autoplaced(), "\n    ").concat(this.effects(label.effects), "\n\t\t").concat(this.uuid(label.uuid), "\n\t)");
+            };
+            SCHEMATIC_PRINTER.prototype.unit = function (c) {
+                return "(unit ".concat(c, ")");
+            };
+            SCHEMATIC_PRINTER.prototype.sch_symbol = function (sch_symbol) {
+                var _this = this;
+                return "(symbol\n\t\t".concat(this.lib_id(sch_symbol.lib_id), "\n\t\t").concat(this.at(sch_symbol.at), "\n\t\t").concat(this.unit(sch_symbol.unit), "\n    ").concat(this.booleans(sch_symbol), "\n\t\t").concat(this.fields(sch_symbol.properties), "\n    ").concat(sch_symbol.pins.map(function (pin) { return _this.sch_symbol_pin(pin); }).join(SCOPE_START), "\n\t)");
+            };
+            SCHEMATIC_PRINTER.prototype.lib_id = function (id) {
+                if (!id)
+                    return;
+                return "(lib_id \"".concat(id, "\")");
+            };
+            SCHEMATIC_PRINTER.prototype.sch_symbol_pin = function (pin) {
+                return "(pin \"".concat(pin.number, "\" ").concat(this.uuid(pin.uuid), ")");
+            };
+            SCHEMATIC_PRINTER.prototype.sch_sheet = function (sheet) {
+                var _this = this;
+                return "(sheet \n    ".concat(this.at(sheet.at), "\n    ").concat(this.size(sheet.size), "\n    ").concat(this.fields_autoplaced(), "\n    ").concat(this.stroke(sheet.stroke), "\n    ").concat(this.fill(sheet.fill), "\n    ").concat(this.uuid(sheet.uuid), "\n    ").concat(this.fields(sheet.fields), "\n    ").concat(sheet.pins.map(function (sheet_pin) { return _this.sch_sheet_pin(sheet_pin); }).join(SCOPE_START), "\n    )");
+            };
+            SCHEMATIC_PRINTER.prototype.sch_sheet_pin = function (sheet_pin) {
+                return "(pin \"".concat(sheet_pin.text, "\" ").concat(sheet_pin.shape, "\n\t\t\t").concat(this.at(sheet_pin.at), "\n            ").concat(this.effects(sheet_pin.effects), "\n\t\t\t").concat(this.uuid(sheet_pin.uuid), "\n\t\t)");
+            };
+            SCHEMATIC_PRINTER.prototype.at = function (pos) {
+                return "(at ".concat(pos.position.x, " ").concat(pos.position.y, " ").concat(pos.rotation === undefined ? '' : pos.rotation, ")");
+            };
+            SCHEMATIC_PRINTER.prototype.uuid = function (id) {
+                return "(uuid \"".concat(id, "\")");
+            };
+            SCHEMATIC_PRINTER.prototype.effects = function (e) {
+                return "(effects\n      (font\n        (size ".concat(e.font.size.x, " ").concat(e.font.size.y, ")\n      )").concat(this.justify(e.justify)).concat(e.hide ? '(hide yes)' : '', "\n    )");
+            };
+            SCHEMATIC_PRINTER.prototype.justify = function (justify) {
+                if (!justify)
+                    return;
+                return "(justify ".concat(justify.horizontal, " ").concat(justify.vertical, ")");
+            };
+            SCHEMATIC_PRINTER.prototype.booleans = function (it) {
+                var e_1, _b;
+                if (typeof it !== 'object' || !it)
+                    return;
+                var res = [];
+                try {
+                    for (var _c = __values(Object.entries(it)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var _e = __read(_d.value, 2), k = _e[0], v = _e[1];
+                        if (typeof v === 'boolean' && !IGNORE_BOOLEANS.has(k))
+                            res.push("( ".concat(k, " ").concat(v ? 'yes' : 'no', " )"));
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                return res.join(SCOPE_START);
+            };
+            SCHEMATIC_PRINTER.prototype.fields = function (fields) {
+                var _this = this;
+                if (!fields)
+                    return;
+                return fields.map(function (f) { return _this.field(f); }).join(SCOPE_START);
+            };
+            SCHEMATIC_PRINTER.prototype.field = function (field) {
+                return "(property \"".concat(field.name, "\" \"").concat(field.text, "\"\n\t\t\t").concat(this.at(field.at), "\n            ").concat(this.effects(field.effects), "\n\t\t)");
+            };
+            SCHEMATIC_PRINTER.prototype.fill = function (f) {
+                if (!f)
+                    return;
+                return "(fill".concat(f.type ? " (type ".concat(f.type, ")") : '', " ").concat(this.color(f.color), ")");
+            };
+            SCHEMATIC_PRINTER.prototype.size = function (s) {
+                return "(size ".concat(s.x, " ").concat(s.y, ")");
+            };
+            SCHEMATIC_PRINTER.prototype.fields_autoplaced = function () {
+                return '(fields_autoplaced yes)';
+            };
+            SCHEMATIC_PRINTER.prototype.stroke = function (s) {
+                if (!s)
+                    return;
+                return "(stroke\n\t\t\t(width ".concat(s.width, ")\n\t\t\t(type ").concat(s.type, ")\n      ").concat(this.color(s.color), "\n\t\t)");
+            };
+            SCHEMATIC_PRINTER.prototype.color = function (c) {
+                if (!c)
+                    return;
+                return "(color ".concat(c.r, " ").concat(c.g, " ").concat(c.b, " ").concat(c.a, ")");
+            };
+            return SCHEMATIC_PRINTER;
+        }()),
+        (function () {
+            var _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _power_decorators = [filterNullOrUndefined];
+            _pin_display_opt_decorators = [filterNullOrUndefined];
+            _lib_children_decorators = [filterNullOrUndefined];
+            _drawings_decorators = [filterNullOrUndefined];
+            _pin_defs_decorators = [filterNullOrUndefined];
+            _unit_decorators = [filterNullOrUndefined];
+            _lib_id_decorators = [filterNullOrUndefined];
+            _justify_decorators = [filterNullOrUndefined];
+            _fields_decorators = [filterNullOrUndefined];
+            _fill_decorators = [filterNullOrUndefined];
+            _stroke_decorators = [filterNullOrUndefined];
+            _color_decorators = [filterNullOrUndefined];
+            __esDecorate(_a, null, _power_decorators, { kind: "method", name: "power", static: false, private: false, access: { has: function (obj) { return "power" in obj; }, get: function (obj) { return obj.power; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _pin_display_opt_decorators, { kind: "method", name: "pin_display_opt", static: false, private: false, access: { has: function (obj) { return "pin_display_opt" in obj; }, get: function (obj) { return obj.pin_display_opt; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _lib_children_decorators, { kind: "method", name: "lib_children", static: false, private: false, access: { has: function (obj) { return "lib_children" in obj; }, get: function (obj) { return obj.lib_children; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _drawings_decorators, { kind: "method", name: "drawings", static: false, private: false, access: { has: function (obj) { return "drawings" in obj; }, get: function (obj) { return obj.drawings; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _pin_defs_decorators, { kind: "method", name: "pin_defs", static: false, private: false, access: { has: function (obj) { return "pin_defs" in obj; }, get: function (obj) { return obj.pin_defs; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _unit_decorators, { kind: "method", name: "unit", static: false, private: false, access: { has: function (obj) { return "unit" in obj; }, get: function (obj) { return obj.unit; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _lib_id_decorators, { kind: "method", name: "lib_id", static: false, private: false, access: { has: function (obj) { return "lib_id" in obj; }, get: function (obj) { return obj.lib_id; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _justify_decorators, { kind: "method", name: "justify", static: false, private: false, access: { has: function (obj) { return "justify" in obj; }, get: function (obj) { return obj.justify; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _fields_decorators, { kind: "method", name: "fields", static: false, private: false, access: { has: function (obj) { return "fields" in obj; }, get: function (obj) { return obj.fields; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _fill_decorators, { kind: "method", name: "fill", static: false, private: false, access: { has: function (obj) { return "fill" in obj; }, get: function (obj) { return obj.fill; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _stroke_decorators, { kind: "method", name: "stroke", static: false, private: false, access: { has: function (obj) { return "stroke" in obj; }, get: function (obj) { return obj.stroke; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _color_decorators, { kind: "method", name: "color", static: false, private: false, access: { has: function (obj) { return "color" in obj; }, get: function (obj) { return obj.color; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+}();
+export { SCHEMATIC_PRINTER };

package/build/converter/kicad_sexpr/index.js

@@ -1,18 +1,2 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./eeschema"), exports);
-__exportStar(require("./pcb"), exports);
+export * from './eeschema';
+export * from './pcb';

package/build/converter/kicad_sexpr/pcb/index.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/build/converter/link_to_netlist/context.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });