@modular-circuit/transpiler 0.0.77 → 0.0.80

package/build/converter/link_to_netlist/links/converters.js

@@ -1,7 +1,62 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+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.");
+};
 import { PortType, } from '@modular-circuit/electronics-model';
 import { CompositePortLinkConverterBase } from './converter_base';
-export class CanLogicLinkTester extends CompositePortLinkConverterBase {
-    get_signals() {
+var CanLogicLinkTester = /** @class */ (function (_super) {
+    __extends(CanLogicLinkTester, _super);
+    function CanLogicLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CanLogicLinkTester.prototype.get_signals = function () {
         if (!this.link)
             return [];
         // const txd = [this.link.controller.txd, this.link.transceiver.rxd, ...this.link.passive!.map((port) => port.rxd)]
@@ -9,7 +64,7 @@ export class CanLogicLinkTester extends CompositePortLinkConverterBase {
         return [
             {
                 name: 'txd',
-                ports: [
+                ports: __spreadArray([
                     {
                         parent: this.link.controller,
                         meta_port: this.link.controller.txd,
@@ -17,18 +72,17 @@ export class CanLogicLinkTester extends CompositePortLinkConverterBase {
                     {
                         parent: this.link.transceiver,
                         meta_port: this.link.transceiver.rxd,
-                    },
-                    ...this.link.passive.map((port) => {
-                        return {
-                            parent: port,
-                            meta_port: port.rxd,
-                        };
-                    }),
-                ],
+                    }
+                ], __read(this.link.passive.map(function (port) {
+                    return {
+                        parent: port,
+                        meta_port: port.rxd,
+                    };
+                })), false),
             },
             {
                 name: 'rxd',
-                ports: [
+                ports: __spreadArray([
                     {
                         parent: this.link.controller,
                         meta_port: this.link.controller.rxd,
@@ -36,37 +90,47 @@ export class CanLogicLinkTester extends CompositePortLinkConverterBase {
                     {
                         parent: this.link.transceiver,
                         meta_port: this.link.transceiver.txd,
-                    },
-                    ...this.link.passive.map((port) => {
-                        return {
-                            parent: port,
-                            meta_port: port.txd,
-                        };
-                    }),
-                ],
+                    }
+                ], __read(this.link.passive.map(function (port) {
+                    return {
+                        parent: port,
+                        meta_port: port.txd,
+                    };
+                })), false),
             },
         ];
-    }
-    init_link() {
-        const controllers = [];
-        const transceivers = [];
-        const passive = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.CanControllerPort: {
-                    controllers.push(v);
-                    break;
-                }
-                case PortType.CanTransceiverPort: {
-                    transceivers.push(v);
-                    break;
-                }
-                case PortType.CanPassivePort: {
-                    passive.push(v);
-                    break;
+    };
+    CanLogicLinkTester.prototype.init_link = function () {
+        var e_1, _a;
+        var controllers = [];
+        var transceivers = [];
+        var passive = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.CanControllerPort: {
+                        controllers.push(v);
+                        break;
+                    }
+                    case PortType.CanTransceiverPort: {
+                        transceivers.push(v);
+                        break;
+                    }
+                    case PortType.CanPassivePort: {
+                        passive.push(v);
+                        break;
+                    }
                 }
             }
         }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
         if (controllers.length !== 1) {
             return false;
         }
@@ -76,13 +140,19 @@ export class CanLogicLinkTester extends CompositePortLinkConverterBase {
         this.link = {
             controller: controllers[0],
             transceiver: transceivers[0],
-            passive,
+            passive: passive,
         };
         return true;
+    };
+    return CanLogicLinkTester;
+}(CompositePortLinkConverterBase));
+export { CanLogicLinkTester };
+var CanDiffLinkTester = /** @class */ (function (_super) {
+    __extends(CanDiffLinkTester, _super);
+    function CanDiffLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-}
-export class CanDiffLinkTester extends CompositePortLinkConverterBase {
-    get_signals() {
+    CanDiffLinkTester.prototype.get_signals = function () {
         if (!this.link)
             return [];
         // const canh = this.link.nodes.map((node) => node.canh)
@@ -90,50 +160,63 @@ export class CanDiffLinkTester extends CompositePortLinkConverterBase {
         return [
             {
                 name: 'canh',
-                ports: [
-                    ...this.link.nodes.map((port) => {
-                        return {
-                            parent: port,
-                            meta_port: port.canh,
-                        };
-                    }),
-                ],
+                ports: __spreadArray([], __read(this.link.nodes.map(function (port) {
+                    return {
+                        parent: port,
+                        meta_port: port.canh,
+                    };
+                })), false),
             },
             {
                 name: 'canl',
-                ports: [
-                    ...this.link.nodes.map((port) => {
-                        return {
-                            parent: port,
-                            meta_port: port.canl,
-                        };
-                    }),
-                ],
+                ports: __spreadArray([], __read(this.link.nodes.map(function (port) {
+                    return {
+                        parent: port,
+                        meta_port: port.canl,
+                    };
+                })), false),
             },
         ];
-    }
-    init_link() {
-        const nodes = [];
-        for (const v of this.ports) {
-            if (v.type === PortType.CanDiffPort) {
-                nodes.push(v);
+    };
+    CanDiffLinkTester.prototype.init_link = function () {
+        var e_2, _a;
+        var nodes = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                if (v.type === PortType.CanDiffPort) {
+                    nodes.push(v);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
+            finally { if (e_2) throw e_2.error; }
         }
         if (nodes.length === 0) {
             return false;
         }
         this.link = {
-            nodes,
+            nodes: nodes,
         };
         return true;
+    };
+    return CanDiffLinkTester;
+}(CompositePortLinkConverterBase));
+export { CanDiffLinkTester };
+var CrystalLinkTester = /** @class */ (function (_super) {
+    __extends(CrystalLinkTester, _super);
+    function CrystalLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-}
-export class CrystalLinkTester extends CompositePortLinkConverterBase {
-    get_signals() {
+    CrystalLinkTester.prototype.get_signals = function () {
         if (!this.link)
             return [];
-        const driver = this.link.driver;
-        const crystal = this.link.crystal;
+        var driver = this.link.driver;
+        var crystal = this.link.crystal;
         return [
             {
                 name: 'xtal',
@@ -162,22 +245,33 @@ export class CrystalLinkTester extends CompositePortLinkConverterBase {
                 ],
             },
         ];
-    }
-    init_link() {
-        const drivers = [];
-        const crystals = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.CrystalDriver: {
-                    drivers.push(v);
-                    break;
-                }
-                case PortType.CrystalPort: {
-                    crystals.push(v);
-                    break;
+    };
+    CrystalLinkTester.prototype.init_link = function () {
+        var e_3, _a;
+        var drivers = [];
+        var crystals = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.CrystalDriver: {
+                        drivers.push(v);
+                        break;
+                    }
+                    case PortType.CrystalPort: {
+                        crystals.push(v);
+                        break;
+                    }
                 }
             }
         }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
         if (drivers.length !== 1) {
             return false;
         }
@@ -189,10 +283,16 @@ export class CrystalLinkTester extends CompositePortLinkConverterBase {
             crystal: crystals[0],
         };
         return true;
+    };
+    return CrystalLinkTester;
+}(CompositePortLinkConverterBase));
+export { CrystalLinkTester };
+var SwdLinkTester = /** @class */ (function (_super) {
+    __extends(SwdLinkTester, _super);
+    function SwdLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-}
-export class SwdLinkTester extends CompositePortLinkConverterBase {
-    get_signals() {
+    SwdLinkTester.prototype.get_signals = function () {
         if (!this.link)
             return [];
         // const swdio = [this.link.host.swdio, this.link.device.swdio, ...this.link.pull!.map((port) => port.swdio)]
@@ -200,7 +300,7 @@ export class SwdLinkTester extends CompositePortLinkConverterBase {
         return [
             {
                 name: 'swdio',
-                ports: [
+                ports: __spreadArray([
                     {
                         parent: this.link.host,
                         meta_port: this.link.host.swdio,
@@ -208,18 +308,17 @@ export class SwdLinkTester extends CompositePortLinkConverterBase {
                     {
                         parent: this.link.device,
                         meta_port: this.link.device.swdio,
-                    },
-                    ...this.link.pull.map((port) => {
-                        return {
-                            parent: port,
-                            meta_port: port.swdio,
-                        };
-                    }),
-                ],
+                    }
+                ], __read(this.link.pull.map(function (port) {
+                    return {
+                        parent: port,
+                        meta_port: port.swdio,
+                    };
+                })), false),
             },
             {
                 name: 'swclk',
-                ports: [
+                ports: __spreadArray([
                     {
                         parent: this.link.host,
                         meta_port: this.link.host.swclk,
@@ -227,37 +326,47 @@ export class SwdLinkTester extends CompositePortLinkConverterBase {
                     {
                         parent: this.link.device,
                         meta_port: this.link.device.swclk,
-                    },
-                    ...this.link.pull.map((port) => {
-                        return {
-                            parent: port,
-                            meta_port: port.swclk,
-                        };
-                    }),
-                ],
+                    }
+                ], __read(this.link.pull.map(function (port) {
+                    return {
+                        parent: port,
+                        meta_port: port.swclk,
+                    };
+                })), false),
             },
         ];
-    }
-    init_link() {
-        const hosts = [];
-        const devices = [];
-        const pull = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.SwdHostPort: {
-                    hosts.push(v);
-                    break;
-                }
-                case PortType.SwdTargetPort: {
-                    devices.push(v);
-                    break;
-                }
-                case PortType.SwdPullPort: {
-                    pull.push(v);
-                    break;
+    };
+    SwdLinkTester.prototype.init_link = function () {
+        var e_4, _a;
+        var hosts = [];
+        var devices = [];
+        var pull = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.SwdHostPort: {
+                        hosts.push(v);
+                        break;
+                    }
+                    case PortType.SwdTargetPort: {
+                        devices.push(v);
+                        break;
+                    }
+                    case PortType.SwdPullPort: {
+                        pull.push(v);
+                        break;
+                    }
                 }
             }
         }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
         if (hosts.length !== 1) {
             return false;
         }
@@ -267,43 +376,45 @@ export class SwdLinkTester extends CompositePortLinkConverterBase {
         this.link = {
             host: hosts[0],
             device: devices[0],
-            pull,
+            pull: pull,
         };
         return true;
+    };
+    return SwdLinkTester;
+}(CompositePortLinkConverterBase));
+export { SwdLinkTester };
+var I2cLinkTester = /** @class */ (function (_super) {
+    __extends(I2cLinkTester, _super);
+    function I2cLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-}
-export class I2cLinkTester extends CompositePortLinkConverterBase {
-    get_signals() {
+    I2cLinkTester.prototype.get_signals = function () {
         if (!this.link)
             return [];
-        const scl = [
-            ...this.link.pull.map((device) => ({
-                parent: device,
-                meta_port: device.scl,
-            })),
+        var scl = __spreadArray(__spreadArray(__spreadArray([], __read(this.link.pull.map(function (device) { return ({
+            parent: device,
+            meta_port: device.scl,
+        }); })), false), [
             {
                 parent: this.link.controller,
                 meta_port: this.link.controller.scl,
-            },
-            ...this.link.targets.map((device) => ({
-                parent: device,
-                meta_port: device.scl,
-            })),
-        ];
-        const sda = [
-            ...this.link.pull.map((device) => ({
-                parent: device,
-                meta_port: device.sda,
-            })),
+            }
+        ], false), __read(this.link.targets.map(function (device) { return ({
+            parent: device,
+            meta_port: device.scl,
+        }); })), false);
+        var sda = __spreadArray(__spreadArray(__spreadArray([], __read(this.link.pull.map(function (device) { return ({
+            parent: device,
+            meta_port: device.sda,
+        }); })), false), [
             {
                 parent: this.link.controller,
                 meta_port: this.link.controller.sda,
-            },
-            ...this.link.targets.map((device) => ({
-                parent: device,
-                meta_port: device.sda,
-            })),
-        ];
+            }
+        ], false), __read(this.link.targets.map(function (device) { return ({
+            parent: device,
+            meta_port: device.sda,
+        }); })), false);
         return [
             {
                 name: 'scl',
@@ -314,27 +425,38 @@ export class I2cLinkTester extends CompositePortLinkConverterBase {
                 ports: sda,
             },
         ];
-    }
-    init_link() {
-        const pull = [];
-        const controllers = [];
-        const targets = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.I2cPullupPort: {
-                    pull.push(v);
-                    break;
-                }
-                case PortType.I2cController: {
-                    controllers.push(v);
-                    break;
-                }
-                case PortType.I2cTarget: {
-                    targets.push(v);
-                    break;
+    };
+    I2cLinkTester.prototype.init_link = function () {
+        var e_5, _a;
+        var pull = [];
+        var controllers = [];
+        var targets = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.I2cPullupPort: {
+                        pull.push(v);
+                        break;
+                    }
+                    case PortType.I2cController: {
+                        controllers.push(v);
+                        break;
+                    }
+                    case PortType.I2cTarget: {
+                        targets.push(v);
+                        break;
+                    }
                 }
             }
         }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
         if (controllers.length !== 1) {
             return false;
         }
@@ -342,19 +464,25 @@ export class I2cLinkTester extends CompositePortLinkConverterBase {
             return false;
         }
         this.link = {
-            pull,
+            pull: pull,
             controller: controllers[0],
-            targets,
+            targets: targets,
         };
         return true;
+    };
+    return I2cLinkTester;
+}(CompositePortLinkConverterBase));
+export { I2cLinkTester };
+var I2sLinkTester = /** @class */ (function (_super) {
+    __extends(I2sLinkTester, _super);
+    function I2sLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-}
-export class I2sLinkTester extends CompositePortLinkConverterBase {
-    get_signals() {
+    I2sLinkTester.prototype.get_signals = function () {
         if (!this.link)
             return [];
-        const controller = this.link.controller;
-        const target_receiver = this.link.target_receiver;
+        var controller = this.link.controller;
+        var target_receiver = this.link.target_receiver;
         // const sck = [controller.sck, target_receiver.sck]
         // const ws = [controller.ws, target_receiver.ws]
         // const sd = [controller.sd, target_receiver.sd]
@@ -399,22 +527,33 @@ export class I2sLinkTester extends CompositePortLinkConverterBase {
                 ],
             },
         ];
-    }
-    init_link() {
-        const controllers = [];
-        const target_receivers = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.I2sController: {
-                    controllers.push(v);
-                    break;
-                }
-                case PortType.I2sTargetReceiver: {
-                    target_receivers.push(v);
-                    break;
+    };
+    I2sLinkTester.prototype.init_link = function () {
+        var e_6, _a;
+        var controllers = [];
+        var target_receivers = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.I2sController: {
+                        controllers.push(v);
+                        break;
+                    }
+                    case PortType.I2sTargetReceiver: {
+                        target_receivers.push(v);
+                        break;
+                    }
                 }
             }
         }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
         if (controllers.length !== 1) {
             return false;
         }
@@ -426,74 +565,88 @@ export class I2sLinkTester extends CompositePortLinkConverterBase {
             target_receiver: target_receivers[0],
         };
         return true;
+    };
+    return I2sLinkTester;
+}(CompositePortLinkConverterBase));
+export { I2sLinkTester };
+var SpiLinkTester = /** @class */ (function (_super) {
+    __extends(SpiLinkTester, _super);
+    function SpiLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-}
-export class SpiLinkTester extends CompositePortLinkConverterBase {
-    get_signals() {
+    SpiLinkTester.prototype.get_signals = function () {
         if (!this.link)
             return [];
-        const controller = this.link.controller;
-        const peripherals = this.link.peripherals;
+        var controller = this.link.controller;
+        var peripherals = this.link.peripherals;
         // const sck = [controller.sck, ...peripherals.map((device) => device.sck)]
         // const miso = [controller.miso, ...peripherals.map((device) => device.miso)]
         // const mosi = [controller.mosi, ...peripherals.map((device) => device.mosi)]
         return [
             {
                 name: 'sck',
-                ports: [
+                ports: __spreadArray([
                     {
                         parent: controller,
                         meta_port: controller.sck,
-                    },
-                    ...peripherals.map((device) => ({
-                        parent: device,
-                        meta_port: device.sck,
-                    })),
-                ],
+                    }
+                ], __read(peripherals.map(function (device) { return ({
+                    parent: device,
+                    meta_port: device.sck,
+                }); })), false),
             },
             {
                 name: 'miso',
-                ports: [
+                ports: __spreadArray([
                     {
                         parent: controller,
                         meta_port: controller.miso,
-                    },
-                    ...peripherals.map((device) => ({
-                        parent: device,
-                        meta_port: device.miso,
-                    })),
-                ],
+                    }
+                ], __read(peripherals.map(function (device) { return ({
+                    parent: device,
+                    meta_port: device.miso,
+                }); })), false),
             },
             {
                 name: 'mosi',
-                ports: [
+                ports: __spreadArray([
                     {
                         parent: controller,
                         meta_port: controller.mosi,
-                    },
-                    ...peripherals.map((device) => ({
-                        parent: device,
-                        meta_port: device.mosi,
-                    })),
-                ],
+                    }
+                ], __read(peripherals.map(function (device) { return ({
+                    parent: device,
+                    meta_port: device.mosi,
+                }); })), false),
             },
         ];
-    }
-    init_link() {
-        const controllers = [];
-        const peripherals = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.SpiController: {
-                    controllers.push(v);
-                    break;
-                }
-                case PortType.SpiPeripheral: {
-                    peripherals.push(v);
-                    break;
+    };
+    SpiLinkTester.prototype.init_link = function () {
+        var e_7, _a;
+        var controllers = [];
+        var peripherals = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.SpiController: {
+                        controllers.push(v);
+                        break;
+                    }
+                    case PortType.SpiPeripheral: {
+                        peripherals.push(v);
+                        break;
+                    }
                 }
             }
         }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
         if (controllers.length !== 1) {
             return false;
         }
@@ -502,13 +655,19 @@ export class SpiLinkTester extends CompositePortLinkConverterBase {
         }
         this.link = {
             controller: controllers[0],
-            peripherals,
+            peripherals: peripherals,
         };
         return true;
+    };
+    return SpiLinkTester;
+}(CompositePortLinkConverterBase));
+export { SpiLinkTester };
+var SpeakerLinkTester = /** @class */ (function (_super) {
+    __extends(SpeakerLinkTester, _super);
+    function SpeakerLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-}
-export class SpeakerLinkTester extends CompositePortLinkConverterBase {
-    get_signals() {
+    SpeakerLinkTester.prototype.get_signals = function () {
         if (!this.link)
             return [];
         // const a = [this.link.source.a, this.link.sink.a]
@@ -541,22 +700,33 @@ export class SpeakerLinkTester extends CompositePortLinkConverterBase {
                 ],
             },
         ];
-    }
-    init_link() {
-        const sources = [];
-        const sinks = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.SpeakerDriverPort: {
-                    sources.push(v);
-                    break;
-                }
-                case PortType.SpeakerPort: {
-                    sinks.push(v);
-                    break;
+    };
+    SpeakerLinkTester.prototype.init_link = function () {
+        var e_8, _a;
+        var sources = [];
+        var sinks = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.SpeakerDriverPort: {
+                        sources.push(v);
+                        break;
+                    }
+                    case PortType.SpeakerPort: {
+                        sinks.push(v);
+                        break;
+                    }
                 }
             }
         }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
         if (sources.length !== 1) {
             return false;
         }
@@ -568,10 +738,16 @@ export class SpeakerLinkTester extends CompositePortLinkConverterBase {
             sink: sinks[0],
         };
         return true;
+    };
+    return SpeakerLinkTester;
+}(CompositePortLinkConverterBase));
+export { SpeakerLinkTester };
+var UartLinkTester = /** @class */ (function (_super) {
+    __extends(UartLinkTester, _super);
+    function UartLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-}
-export class UartLinkTester extends CompositePortLinkConverterBase {
-    get_signals() {
+    UartLinkTester.prototype.get_signals = function () {
         if (!this.link)
             return [];
         // const tx = [this.link.a.tx, this.link.b.rx]
@@ -604,13 +780,24 @@ export class UartLinkTester extends CompositePortLinkConverterBase {
                 ],
             },
         ];
-    }
-    init_link() {
-        const ports = [];
-        for (const v of this.ports) {
-            if (v.type === PortType.UartPort) {
-                ports.push(v);
+    };
+    UartLinkTester.prototype.init_link = function () {
+        var e_9, _a;
+        var ports = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                if (v.type === PortType.UartPort) {
+                    ports.push(v);
+                }
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
+            finally { if (e_9) throw e_9.error; }
         }
         if (ports.length !== 2) {
             return false;
@@ -620,10 +807,16 @@ export class UartLinkTester extends CompositePortLinkConverterBase {
             b: ports[1],
         };
         return true;
+    };
+    return UartLinkTester;
+}(CompositePortLinkConverterBase));
+export { UartLinkTester };
+var UsbLinkTester = /** @class */ (function (_super) {
+    __extends(UsbLinkTester, _super);
+    function UsbLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-}
-export class UsbLinkTester extends CompositePortLinkConverterBase {
-    get_signals() {
+    UsbLinkTester.prototype.get_signals = function () {
         if (!this.link)
             return [];
         // const dp = [this.link.host.dp, this.link.device.dp, ...this.link.passive!.map((port) => port.dp)]
@@ -631,7 +824,7 @@ export class UsbLinkTester extends CompositePortLinkConverterBase {
         return [
             {
                 name: 'dp',
-                ports: [
+                ports: __spreadArray([
                     {
                         parent: this.link.host,
                         meta_port: this.link.host.dp,
@@ -639,16 +832,15 @@ export class UsbLinkTester extends CompositePortLinkConverterBase {
                     {
                         parent: this.link.device,
                         meta_port: this.link.device.dp,
-                    },
-                    ...this.link.passive.map((port) => ({
-                        parent: port,
-                        meta_port: port.dp,
-                    })),
-                ],
+                    }
+                ], __read(this.link.passive.map(function (port) { return ({
+                    parent: port,
+                    meta_port: port.dp,
+                }); })), false),
             },
             {
                 name: 'dm',
-                ports: [
+                ports: __spreadArray([
                     {
                         parent: this.link.host,
                         meta_port: this.link.host.dm,
@@ -656,35 +848,45 @@ export class UsbLinkTester extends CompositePortLinkConverterBase {
                     {
                         parent: this.link.device,
                         meta_port: this.link.device.dm,
-                    },
-                    ...this.link.passive.map((port) => ({
-                        parent: port,
-                        meta_port: port.dm,
-                    })),
-                ],
+                    }
+                ], __read(this.link.passive.map(function (port) { return ({
+                    parent: port,
+                    meta_port: port.dm,
+                }); })), false),
             },
         ];
-    }
-    init_link() {
-        const hosts = [];
-        const devices = [];
-        const passive = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.UsbHostPort: {
-                    hosts.push(v);
-                    break;
-                }
-                case PortType.UsbDevicePort: {
-                    devices.push(v);
-                    break;
-                }
-                case PortType.UsbPassivePort: {
-                    passive.push(v);
-                    break;
+    };
+    UsbLinkTester.prototype.init_link = function () {
+        var e_10, _a;
+        var hosts = [];
+        var devices = [];
+        var passive = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.UsbHostPort: {
+                        hosts.push(v);
+                        break;
+                    }
+                    case PortType.UsbDevicePort: {
+                        devices.push(v);
+                        break;
+                    }
+                    case PortType.UsbPassivePort: {
+                        passive.push(v);
+                        break;
+                    }
                 }
             }
         }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
         if (hosts.length !== 1) {
             return false;
         }
@@ -694,13 +896,19 @@ export class UsbLinkTester extends CompositePortLinkConverterBase {
         this.link = {
             host: hosts[0],
             device: devices[0],
-            passive,
+            passive: passive,
         };
         return true;
+    };
+    return UsbLinkTester;
+}(CompositePortLinkConverterBase));
+export { UsbLinkTester };
+var UsbCcLinkTester = /** @class */ (function (_super) {
+    __extends(UsbCcLinkTester, _super);
+    function UsbCcLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-}
-export class UsbCcLinkTester extends CompositePortLinkConverterBase {
-    get_signals() {
+    UsbCcLinkTester.prototype.get_signals = function () {
         if (!this.link)
             return [];
         // const cc1 = [this.link.a.cc1, this.link.b.cc1]
@@ -733,14 +941,25 @@ export class UsbCcLinkTester extends CompositePortLinkConverterBase {
                 ],
             },
         ];
-    }
-    init_link() {
-        const nodes = [];
-        for (const v of this.ports) {
-            if (v.type === PortType.UsbCcPort) {
-                nodes.push(v);
+    };
+    UsbCcLinkTester.prototype.init_link = function () {
+        var e_11, _a;
+        var nodes = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                if (v.type === PortType.UsbCcPort) {
+                    nodes.push(v);
+                }
             }
         }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
         if (nodes.length !== 2) {
             return false;
         }
@@ -749,14 +968,20 @@ export class UsbCcLinkTester extends CompositePortLinkConverterBase {
             b: nodes[1],
         };
         return true;
+    };
+    return UsbCcLinkTester;
+}(CompositePortLinkConverterBase));
+export { UsbCcLinkTester };
+var Dvp8LinkTester = /** @class */ (function (_super) {
+    __extends(Dvp8LinkTester, _super);
+    function Dvp8LinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-}
-export class Dvp8LinkTester extends CompositePortLinkConverterBase {
-    get_signals() {
+    Dvp8LinkTester.prototype.get_signals = function () {
         if (!this.link)
             return [];
-        const host = this.link.host;
-        const cam = this.link.cam;
+        var host = this.link.host;
+        var cam = this.link.cam;
         // const digitalLinks = [
         //   [host.xclk, cam.xclk],
         //   [host.pclk, cam.pclk],
@@ -921,22 +1146,33 @@ export class Dvp8LinkTester extends CompositePortLinkConverterBase {
                 ],
             },
         ];
-    }
-    init_link() {
-        const hosts = [];
-        const cams = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case PortType.Dvp8Host: {
-                    hosts.push(v);
-                    break;
-                }
-                case PortType.Dvp8Camera: {
-                    cams.push(v);
-                    break;
+    };
+    Dvp8LinkTester.prototype.init_link = function () {
+        var e_12, _a;
+        var hosts = [];
+        var cams = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.Dvp8Host: {
+                        hosts.push(v);
+                        break;
+                    }
+                    case PortType.Dvp8Camera: {
+                        cams.push(v);
+                        break;
+                    }
                 }
             }
         }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
         if (hosts.length !== 1) {
             return false;
         }
@@ -948,5 +1184,7 @@ export class Dvp8LinkTester extends CompositePortLinkConverterBase {
             cam: cams[0],
         };
         return true;
-    }
-}
+    };
+    return Dvp8LinkTester;
+}(CompositePortLinkConverterBase));
+export { Dvp8LinkTester };