@modular-circuit/perc 0.0.54 → 0.0.57

package/build/erc/parameter_propagation/link_testers/tester_impl.js

@@ -1,10 +1,58 @@
-"use strict";
 // add the other testers following the  AnalogLinkTester
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Dvp8LinkTester = exports.UsbCcLinkTester = exports.UsbLinkTester = exports.UartLinkTester = exports.TouchLinkTester = exports.SpeakerLinkTester = exports.SpiLinkTester = exports.I2sLinkTester = exports.I2cLinkTester = exports.SwdLinkTester = exports.CrystalLinkTester = exports.CanDiffLinkTester = exports.CanLogicLinkTester = exports.GroundLinkTester = exports.VoltageLinkTester = exports.DigitalLinkTester = exports.AnalogLinkTester = void 0;
-const electronics_model_1 = require("@modular-circuit/electronics-model");
-const link_tester_base_1 = require("./link_tester_base");
-const report_1 = require("../../../report");
+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 __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);
+    }
+    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));
+};
+import { PortType, all_range_are_defined, contains, filter_defined_range, hull, interests, intersection, r_div, range_is_defined, sum, } from '@modular-circuit/electronics-model';
+import { CompositePortLinkTesterBase, LinkTesterBase } from './link_tester_base';
+import { PP_DUPLICATED_SOURCES, PP_ILLEGAL_CONNECTION, PP_IMPEDANCE_SIGNAL_INTEGRITY, PP_INCOMPATIBLE_DIGITAL_THRESHOLDS, PP_INCOMPATIBLE_SIGNAL_LEVELS, PP_INCOMPATIBLE_VOLTAGE_LEVELS, PP_NOT_DRIVEN, PP_OVER_DRIVEN, PP_REQUIRES_CONNECTED_SOURCE_OR_BIDIR, PP_SIGNAL_LEVELS_NOT_CONTAINED_WITHIN_VOLTAGE, } from '../../../report';
 /**
     self.assign(self.sink_impedance, 1 / (1 / self.sinks.map_extract(lambda x: x.impedance)).sum())
     self.require(self.source.impedance.upper() <= self.sink_impedance.lower() * 0.1)  # about 10x for signal integrity
@@ -18,86 +66,102 @@ const report_1 = require("../../../report");
     self.assign(self.current_limits, self.source.current_limits)
     self.require(self.current_limits.contains(self.current_drawn), "overcurrent")
  */
-class AnalogLinkTester extends link_tester_base_1.LinkTesterBase {
-    init_link() {
-        const sources = [];
-        const sinks = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case electronics_model_1.PortType.AnalogSource: {
-                    sources.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.AnalogSink: {
-                    sinks.push(v);
-                    break;
+var AnalogLinkTester = /** @class */ (function (_super) {
+    __extends(AnalogLinkTester, _super);
+    function AnalogLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AnalogLinkTester.prototype.init_link = function () {
+        var e_1, _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.AnalogSource: {
+                        sources.push(v);
+                        break;
+                    }
+                    case PortType.AnalogSink: {
+                        sinks.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 (sources.length === 0) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'Requires a connected analog source'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'Requires a connected analog source'));
             return false;
         }
         if (sources.length > 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'Multiple analog sources are not allowed'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'Multiple analog sources are not allowed'));
             return false;
         }
         this.link = {
             source: sources[0],
-            sinks,
+            sinks: sinks,
         };
         return true;
-    }
-    check_parameter_propagation() {
+    };
+    AnalogLinkTester.prototype.check_parameter_propagation = function () {
         if (!this.link)
             return;
-        const source = this.link.source;
-        const sinks = this.link.sinks;
-        const source_id = this.ctx.port_id.get(source);
-        if ((0, electronics_model_1.range_is_defined)(source.impedance)) {
-            const all_sinks_impedance = (0, electronics_model_1.filter_defined_range)(sinks.map((v) => v.impedance));
+        var source = this.link.source;
+        var sinks = this.link.sinks;
+        var source_id = this.ctx.port_id.get(source);
+        if (range_is_defined(source.impedance)) {
+            var all_sinks_impedance = filter_defined_range(sinks.map(function (v) { return v.impedance; }));
             if (all_sinks_impedance.length > 0) {
-                const sink_impedance = (0, electronics_model_1.r_div)((0, electronics_model_1.sum)(all_sinks_impedance.map((v) => (0, electronics_model_1.r_div)(v, 1))), 1);
+                var sink_impedance = r_div(sum(all_sinks_impedance.map(function (v) { return r_div(v, 1); })), 1);
                 if (source.impedance.upper > sink_impedance.lower * 0.1) {
-                    this.ctx.report.erc_errors.push((0, report_1.PP_IMPEDANCE_SIGNAL_INTEGRITY)(this.all_port_ids));
+                    this.ctx.report.erc_errors.push(PP_IMPEDANCE_SIGNAL_INTEGRITY(this.all_port_ids));
                 }
             }
         }
-        if ((0, electronics_model_1.range_is_defined)(source.voltage_out)) {
-            const all_voltage_limits = (0, electronics_model_1.filter_defined_range)(sinks.map((v) => v.voltage_limits));
+        if (range_is_defined(source.voltage_out)) {
+            var all_voltage_limits = filter_defined_range(sinks.map(function (v) { return v.voltage_limits; }));
             if (all_voltage_limits.length > 0) {
-                const voltage_limits = (0, electronics_model_1.intersection)(all_voltage_limits);
-                if (!(0, electronics_model_1.interests)(voltage_limits, source.voltage_out)) {
-                    this.ctx.report.erc_errors.push((0, report_1.PP_INCOMPATIBLE_VOLTAGE_LEVELS)(source_id));
+                var voltage_limits = intersection(all_voltage_limits);
+                if (!interests(voltage_limits, source.voltage_out)) {
+                    this.ctx.report.erc_errors.push(PP_INCOMPATIBLE_VOLTAGE_LEVELS(source_id));
                 }
             }
         }
-        if ((0, electronics_model_1.all_range_are_defined)(source.signal_out, source.voltage_out)) {
-            if (!(0, electronics_model_1.interests)(source.voltage_out, source.signal_out)) {
-                this.ctx.report.erc_errors.push((0, report_1.PP_SIGNAL_LEVELS_NOT_CONTAINED_WITHIN_VOLTAGE)(source_id));
+        if (all_range_are_defined(source.signal_out, source.voltage_out)) {
+            if (!interests(source.voltage_out, source.signal_out)) {
+                this.ctx.report.erc_errors.push(PP_SIGNAL_LEVELS_NOT_CONTAINED_WITHIN_VOLTAGE(source_id));
             }
         }
-        if ((0, electronics_model_1.range_is_defined)(source.signal_out)) {
-            const all_sinks_signal_limits = (0, electronics_model_1.filter_defined_range)(sinks.map((v) => v.signal_limits));
+        if (range_is_defined(source.signal_out)) {
+            var all_sinks_signal_limits = filter_defined_range(sinks.map(function (v) { return v.signal_limits; }));
             if (all_sinks_signal_limits.length > 0) {
-                const signal_limits = (0, electronics_model_1.intersection)(all_sinks_signal_limits);
-                if (!(0, electronics_model_1.interests)(signal_limits, source.signal_out)) {
-                    this.ctx.report.erc_errors.push((0, report_1.PP_INCOMPATIBLE_SIGNAL_LEVELS)(source_id));
+                var signal_limits = intersection(all_sinks_signal_limits);
+                if (!interests(signal_limits, source.signal_out)) {
+                    this.ctx.report.erc_errors.push(PP_INCOMPATIBLE_SIGNAL_LEVELS(source_id));
                 }
             }
         }
-        if ((0, electronics_model_1.range_is_defined)(source.current_limits)) {
-            const all_sinks_current_drawn = (0, electronics_model_1.filter_defined_range)(sinks.map((v) => v.current_drawn));
+        if (range_is_defined(source.current_limits)) {
+            var all_sinks_current_drawn = filter_defined_range(sinks.map(function (v) { return v.current_drawn; }));
             if (all_sinks_current_drawn.length > 0) {
-                const current_drawn = (0, electronics_model_1.sum)(all_sinks_current_drawn);
-                if ((0, electronics_model_1.interests)(current_drawn, source.current_limits)) {
-                    this.ctx.report.erc_errors.push((0, report_1.PP_OVER_DRIVEN)([source_id], 'current'));
+                var current_drawn = sum(all_sinks_current_drawn);
+                if (interests(current_drawn, source.current_limits)) {
+                    this.ctx.report.erc_errors.push(PP_OVER_DRIVEN([source_id], 'current'));
                 }
             }
         }
-    }
-}
-exports.AnalogLinkTester = AnalogLinkTester;
+    };
+    return AnalogLinkTester;
+}(LinkTesterBase));
+export { AnalogLinkTester };
 /**
  
     voltage_hull = self.bidirs.hull(lambda x: x.voltage_out)
@@ -160,79 +224,96 @@ exports.AnalogLinkTester = AnalogLinkTester;
 
 
  */
-class DigitalLinkTester extends link_tester_base_1.LinkTesterBase {
-    init_link() {
-        const sinks = [];
-        const sources = [];
-        const bidirs = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case electronics_model_1.PortType.DigitalSource: {
-                    sources.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.DigitalSink: {
-                    sinks.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.DigitalBidir: {
-                    bidirs.push(v);
-                    break;
+var DigitalLinkTester = /** @class */ (function (_super) {
+    __extends(DigitalLinkTester, _super);
+    function DigitalLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DigitalLinkTester.prototype.init_link = function () {
+        var e_2, _a;
+        var sinks = [];
+        var sources = [];
+        var bidirs = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.DigitalSource: {
+                        sources.push(v);
+                        break;
+                    }
+                    case PortType.DigitalSink: {
+                        sinks.push(v);
+                        break;
+                    }
+                    case PortType.DigitalBidir: {
+                        bidirs.push(v);
+                        break;
+                    }
                 }
             }
         }
+        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; }
+        }
         this.link = {
-            sources,
-            sinks,
-            bidirs,
+            sources: sources,
+            sinks: sinks,
+            bidirs: bidirs,
         };
         return true;
-    }
-    check_parameter_propagation() {
+    };
+    DigitalLinkTester.prototype.check_parameter_propagation = function () {
+        var _a, _b, _c;
         if (!this.link)
             return;
-        const sources = this.link.sources ?? [];
-        const sinks = this.link.sinks ?? [];
-        const bidirs = this.link.bidirs ?? [];
-        const all_defined_voltage = (0, electronics_model_1.filter_defined_range)(...bidirs.map((v) => v.voltage_out), ...sources.map((v) => v.voltage_out));
+        var sources = (_a = this.link.sources) !== null && _a !== void 0 ? _a : [];
+        var sinks = (_b = this.link.sinks) !== null && _b !== void 0 ? _b : [];
+        var bidirs = (_c = this.link.bidirs) !== null && _c !== void 0 ? _c : [];
+        var all_defined_voltage = filter_defined_range.apply(void 0, __spreadArray(__spreadArray([], __read(bidirs.map(function (v) { return v.voltage_out; })), false), __read(sources.map(function (v) { return v.voltage_out; })), false));
         if (all_defined_voltage.length > 0) {
-            const voltage = (0, electronics_model_1.hull)(all_defined_voltage);
-            const all_defined_voltage_limits = (0, electronics_model_1.filter_defined_range)(sinks.map((v) => v.voltage_limits));
+            var voltage = hull(all_defined_voltage);
+            var all_defined_voltage_limits = filter_defined_range(sinks.map(function (v) { return v.voltage_limits; }));
             if (all_defined_voltage_limits.length > 0) {
-                const voltage_limits = (0, electronics_model_1.intersection)(all_defined_voltage_limits);
-                if (!(0, electronics_model_1.contains)(voltage_limits, voltage)) {
-                    this.ctx.report.erc_errors.push((0, report_1.PP_OVER_DRIVEN)(this.all_port_ids, 'voltage'));
+                var voltage_limits = intersection(all_defined_voltage_limits);
+                if (!contains(voltage_limits, voltage)) {
+                    this.ctx.report.erc_errors.push(PP_OVER_DRIVEN(this.all_port_ids, 'voltage'));
                 }
             }
         }
-        const all_defined_current_limits = (0, electronics_model_1.filter_defined_range)(...bidirs.map((v) => v.current_limits), ...sources.map((v) => v.current_limits));
+        var all_defined_current_limits = filter_defined_range.apply(void 0, __spreadArray(__spreadArray([], __read(bidirs.map(function (v) { return v.current_limits; })), false), __read(sources.map(function (v) { return v.current_limits; })), false));
         if (all_defined_current_limits.length > 0) {
-            const current_limits = (0, electronics_model_1.sum)(all_defined_current_limits);
-            const all_defined_current_drawn = (0, electronics_model_1.filter_defined_range)(sinks.map((v) => v.current_drawn));
+            var current_limits = sum(all_defined_current_limits);
+            var all_defined_current_drawn = filter_defined_range(sinks.map(function (v) { return v.current_drawn; }));
             if (all_defined_current_drawn.length > 0) {
-                const current_drawn = (0, electronics_model_1.sum)(all_defined_current_drawn);
-                if ((0, electronics_model_1.interests)(current_drawn, current_limits)) {
-                    this.ctx.report.erc_errors.push((0, report_1.PP_OVER_DRIVEN)(this.all_port_ids, 'current'));
+                var current_drawn = sum(all_defined_current_drawn);
+                if (interests(current_drawn, current_limits)) {
+                    this.ctx.report.erc_errors.push(PP_OVER_DRIVEN(this.all_port_ids, 'current'));
                 }
             }
         }
-        const all_defined_output_thresholds = (0, electronics_model_1.filter_defined_range)(...bidirs.map((v) => v.output_thresholds), ...sources.map((v) => v.output_thresholds));
+        var all_defined_output_thresholds = filter_defined_range.apply(void 0, __spreadArray(__spreadArray([], __read(bidirs.map(function (v) { return v.output_thresholds; })), false), __read(sources.map(function (v) { return v.output_thresholds; })), false));
         if (all_defined_output_thresholds.length > 0) {
-            const output_thresholds = (0, electronics_model_1.intersection)(all_defined_output_thresholds);
-            const all_defined_input_thresholds = (0, electronics_model_1.filter_defined_range)(sinks.map((v) => v.input_thresholds));
+            var output_thresholds = intersection(all_defined_output_thresholds);
+            var all_defined_input_thresholds = filter_defined_range(sinks.map(function (v) { return v.input_thresholds; }));
             if (all_defined_input_thresholds.length > 0) {
-                const input_thresholds = (0, electronics_model_1.hull)(all_defined_input_thresholds);
-                if (!(0, electronics_model_1.contains)(output_thresholds, input_thresholds)) {
-                    this.ctx.report.erc_errors.push((0, report_1.PP_INCOMPATIBLE_DIGITAL_THRESHOLDS)(this.all_port_ids));
+                var input_thresholds = hull(all_defined_input_thresholds);
+                if (!contains(output_thresholds, input_thresholds)) {
+                    this.ctx.report.erc_errors.push(PP_INCOMPATIBLE_DIGITAL_THRESHOLDS(this.all_port_ids));
                 }
             }
         }
         if (!sources.length && !bidirs.length) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_REQUIRES_CONNECTED_SOURCE_OR_BIDIR)(this.all_port_ids));
+            this.ctx.report.erc_errors.push(PP_REQUIRES_CONNECTED_SOURCE_OR_BIDIR(this.all_port_ids));
         }
-    }
-}
-exports.DigitalLinkTester = DigitalLinkTester;
+    };
+    return DigitalLinkTester;
+}(LinkTesterBase));
+export { DigitalLinkTester };
 /**
   self.assign(self.voltage, self.source.voltage_out)
   self.assign(self.voltage_limits, self.sinks.intersection(lambda x: x.voltage_limits))
@@ -242,60 +323,76 @@ exports.DigitalLinkTester = DigitalLinkTester;
   self.assign(self.current_drawn, self.sinks.sum(lambda x: x.current_draw))
   self.require(self.current_limits.contains(self.current_drawn), "overcurrent")
  */
-class VoltageLinkTester extends link_tester_base_1.LinkTesterBase {
-    check_parameter_propagation() {
-        const source = this.link.source;
-        const sinks = this.link.sinks;
-        if ((0, electronics_model_1.range_is_defined)(source.voltage_out)) {
-            const all_voltage_limits = (0, electronics_model_1.filter_defined_range)(sinks.map((v) => v.voltage_limits));
+var VoltageLinkTester = /** @class */ (function (_super) {
+    __extends(VoltageLinkTester, _super);
+    function VoltageLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    VoltageLinkTester.prototype.check_parameter_propagation = function () {
+        var source = this.link.source;
+        var sinks = this.link.sinks;
+        if (range_is_defined(source.voltage_out)) {
+            var all_voltage_limits = filter_defined_range(sinks.map(function (v) { return v.voltage_limits; }));
             if (all_voltage_limits.length > 0) {
-                const voltage_limits = (0, electronics_model_1.intersection)(all_voltage_limits);
-                if (!(0, electronics_model_1.interests)(voltage_limits, source.voltage_out)) {
-                    this.ctx.report.erc_errors.push((0, report_1.PP_OVER_DRIVEN)(this.all_port_ids, 'voltage'));
+                var voltage_limits = intersection(all_voltage_limits);
+                if (!interests(voltage_limits, source.voltage_out)) {
+                    this.ctx.report.erc_errors.push(PP_OVER_DRIVEN(this.all_port_ids, 'voltage'));
                 }
             }
         }
-        if ((0, electronics_model_1.range_is_defined)(source.current_limits)) {
-            const all_sinks_current_drawn = (0, electronics_model_1.filter_defined_range)(sinks.map((v) => v.current_drawn));
+        if (range_is_defined(source.current_limits)) {
+            var all_sinks_current_drawn = filter_defined_range(sinks.map(function (v) { return v.current_drawn; }));
             if (all_sinks_current_drawn.length > 0) {
-                const current_drawn = (0, electronics_model_1.sum)(all_sinks_current_drawn);
-                if ((0, electronics_model_1.interests)(current_drawn, source.current_limits)) {
-                    this.ctx.report.erc_errors.push((0, report_1.PP_OVER_DRIVEN)(this.all_port_ids, 'current'));
+                var current_drawn = sum(all_sinks_current_drawn);
+                if (interests(current_drawn, source.current_limits)) {
+                    this.ctx.report.erc_errors.push(PP_OVER_DRIVEN(this.all_port_ids, 'current'));
                 }
             }
         }
-    }
-    init_link() {
-        const sources = [];
-        const sinks = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case electronics_model_1.PortType.VoltageSource: {
-                    sources.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.VoltageSink: {
-                    sinks.push(v);
-                    break;
+    };
+    VoltageLinkTester.prototype.init_link = function () {
+        var e_3, _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.VoltageSource: {
+                        sources.push(v);
+                        break;
+                    }
+                    case PortType.VoltageSink: {
+                        sinks.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 (sources.length === 0) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_NOT_DRIVEN)(this.all_port_ids));
+            this.ctx.report.erc_errors.push(PP_NOT_DRIVEN(this.all_port_ids));
             return false;
         }
         if (sources.length > 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_DUPLICATED_SOURCES)(this.all_port_ids));
+            this.ctx.report.erc_errors.push(PP_DUPLICATED_SOURCES(this.all_port_ids));
             return false;
         }
         this.link = {
             source: sources[0],
-            sinks,
+            sinks: sinks,
         };
         return true;
-    }
-}
-exports.VoltageLinkTester = VoltageLinkTester;
+    };
+    return VoltageLinkTester;
+}(LinkTesterBase));
+export { VoltageLinkTester };
 /*
   self.description = DescriptionString(
       "<b>voltage</b>: ", DescriptionString.FormatUnits(self.voltage, "V"),
@@ -307,182 +404,267 @@ exports.VoltageLinkTester = VoltageLinkTester;
   self.assign(self.voltage_limits, self.gnds.intersection(lambda x: x.voltage_limits))
   self.require(self.voltage_limits.contains(self.voltage), "overvoltage")
  */
-class GroundLinkTester extends link_tester_base_1.LinkTesterBase {
-    check_parameter_propagation() {
+var GroundLinkTester = /** @class */ (function (_super) {
+    __extends(GroundLinkTester, _super);
+    function GroundLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    GroundLinkTester.prototype.check_parameter_propagation = function () {
         if (!this.link)
             return;
-        const ref = this.link.ref;
-        const gnds = this.link.gnds;
-        let voltage = ref?.voltage_out;
-        if (!voltage || !(0, electronics_model_1.range_is_defined)(voltage))
+        var ref = this.link.ref;
+        var gnds = this.link.gnds;
+        var voltage = ref === null || ref === void 0 ? void 0 : ref.voltage_out;
+        if (!voltage || !range_is_defined(voltage))
             voltage = { lower: 0, upper: 0 };
-        const all_defined_voltage_limits = (0, electronics_model_1.filter_defined_range)(gnds.map((v) => v.voltage_limits));
+        var all_defined_voltage_limits = filter_defined_range(gnds.map(function (v) { return v.voltage_limits; }));
         if (all_defined_voltage_limits.length > 0) {
-            const voltage_limits = (0, electronics_model_1.intersection)(all_defined_voltage_limits);
-            if (!(0, electronics_model_1.interests)(voltage_limits, voltage)) {
-                this.ctx.report.erc_errors.push((0, report_1.PP_OVER_DRIVEN)(this.all_port_ids, 'voltage'));
+            var voltage_limits = intersection(all_defined_voltage_limits);
+            if (!interests(voltage_limits, voltage)) {
+                this.ctx.report.erc_errors.push(PP_OVER_DRIVEN(this.all_port_ids, 'voltage'));
             }
         }
-    }
-    init_link() {
-        const refs = [];
-        const gnds = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case electronics_model_1.PortType.GroundReference: {
-                    refs.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.Ground: {
-                    gnds.push(v);
-                    break;
+    };
+    GroundLinkTester.prototype.init_link = function () {
+        var e_4, _a;
+        var refs = [];
+        var gnds = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.GroundReference: {
+                        refs.push(v);
+                        break;
+                    }
+                    case PortType.Ground: {
+                        gnds.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 (refs.length > 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'Cannot connect multiple ground references to a ground.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'Cannot connect multiple ground references to a ground.'));
             return false;
         }
         this.link = {
             ref: refs[0],
-            gnds,
+            gnds: gnds,
         };
         return true;
-    }
-}
-exports.GroundLinkTester = GroundLinkTester;
+    };
+    return GroundLinkTester;
+}(LinkTesterBase));
+export { GroundLinkTester };
 /**
     self.txd = self.connect(self.controller.txd, self.transceiver.txd, self.passive.map_extract(lambda port: port.txd),
                             flatten=True)
     self.rxd = self.connect(self.controller.rxd, self.transceiver.rxd, self.passive.map_extract(lambda port: port.rxd),
                             flatten=True)
  */
-class CanLogicLinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
-    check_parameter_propagation() {
+var CanLogicLinkTester = /** @class */ (function (_super) {
+    __extends(CanLogicLinkTester, _super);
+    function CanLogicLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CanLogicLinkTester.prototype.check_parameter_propagation = function () {
+        var e_5, _a;
         if (!this.link)
             return;
-        const txd_tester = new DigitalLinkTester(this.ctx, [
+        var txd_tester = new DigitalLinkTester(this.ctx, __spreadArray([
             this.link.controller.txd,
-            this.link.transceiver.rxd,
-            ...this.link.passive.map((port) => port.rxd),
-        ]);
-        const rxd_tester = new DigitalLinkTester(this.ctx, [
+            this.link.transceiver.rxd
+        ], __read(this.link.passive.map(function (port) { return port.rxd; })), false));
+        var rxd_tester = new DigitalLinkTester(this.ctx, __spreadArray([
             this.link.controller.rxd,
-            this.link.transceiver.txd,
-            ...this.link.passive.map((port) => port.txd),
-        ]);
-        for (const tst of [txd_tester, rxd_tester])
-            tst.test();
-    }
-    init_link() {
-        const controllers = [];
-        const transceivers = [];
-        const passive = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case electronics_model_1.PortType.CanControllerPort: {
-                    controllers.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.CanTransceiverPort: {
-                    transceivers.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.CanPassivePort: {
-                    passive.push(v);
-                    break;
+            this.link.transceiver.txd
+        ], __read(this.link.passive.map(function (port) { return port.txd; })), false));
+        try {
+            for (var _b = __values([txd_tester, rxd_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        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; }
+        }
+    };
+    CanLogicLinkTester.prototype.init_link = function () {
+        var e_6, _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_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) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one controller port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one controller port.'));
             return false;
         }
         if (transceivers.length !== 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one transceiver port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one transceiver port.'));
             return false;
         }
         this.link = {
             controller: controllers[0],
             transceiver: transceivers[0],
-            passive,
+            passive: passive,
         };
         return true;
-    }
-}
-exports.CanLogicLinkTester = CanLogicLinkTester;
+    };
+    return CanLogicLinkTester;
+}(CompositePortLinkTesterBase));
+export { CanLogicLinkTester };
 /**
     self.canh = self.connect(self.nodes.map_extract(lambda node: node.canh),
                              flatten=True)
     self.canl = self.connect(self.nodes.map_extract(lambda node: node.canl),
                              flatten=True)
  */
-class CanDiffLinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
-    check_parameter_propagation() {
+var CanDiffLinkTester = /** @class */ (function (_super) {
+    __extends(CanDiffLinkTester, _super);
+    function CanDiffLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CanDiffLinkTester.prototype.check_parameter_propagation = function () {
+        var e_7, _a;
         if (!this.link)
             return;
-        const canh_tester = new DigitalLinkTester(this.ctx, this.link.nodes.map((node) => node.canh));
-        const canl_tester = new DigitalLinkTester(this.ctx, this.link.nodes.map((node) => node.canl));
-        for (const tst of [canh_tester, canl_tester])
-            tst.test();
-    }
-    init_link() {
-        const nodes = [];
-        for (const v of this.ports) {
-            if (v.type === electronics_model_1.PortType.CanDiffPort) {
-                nodes.push(v);
+        var canh_tester = new DigitalLinkTester(this.ctx, this.link.nodes.map(function (node) { return node.canh; }));
+        var canl_tester = new DigitalLinkTester(this.ctx, this.link.nodes.map(function (node) { return node.canl; }));
+        try {
+            for (var _b = __values([canh_tester, canl_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        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; }
+        }
+    };
+    CanDiffLinkTester.prototype.init_link = function () {
+        var e_8, _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_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 (nodes.length === 0) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'Requires at least one CAN differential port'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'Requires at least one CAN differential port'));
             return false;
         }
         this.link = {
-            nodes,
+            nodes: nodes,
         };
         return true;
-    }
-}
-exports.CanDiffLinkTester = CanDiffLinkTester;
+    };
+    return CanDiffLinkTester;
+}(CompositePortLinkTesterBase));
+export { CanDiffLinkTester };
 /**
     self.require(self.driver.frequency_limits.contains(self.frequency))
 
     self.xi = self.connect(self.driver.xtal_in, self.crystal.xtal_in)
     self.xo = self.connect(self.driver.xtal_out, self.crystal.xtal_out)
  */
-class CrystalLinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
-    check_parameter_propagation() {
+var CrystalLinkTester = /** @class */ (function (_super) {
+    __extends(CrystalLinkTester, _super);
+    function CrystalLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CrystalLinkTester.prototype.check_parameter_propagation = function () {
         if (!this.link)
             return;
-        const driver = this.link.driver;
-        const crystal = this.link.crystal;
-        if ((0, electronics_model_1.all_range_are_defined)(driver.frequency_limits, crystal.frequency)) {
-            if (!(0, electronics_model_1.contains)(driver.frequency_limits, crystal.frequency)) {
-                this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'Frequency out of range'));
+        var driver = this.link.driver;
+        var crystal = this.link.crystal;
+        if (all_range_are_defined(driver.frequency_limits, crystal.frequency)) {
+            if (!contains(driver.frequency_limits, crystal.frequency)) {
+                this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'Frequency out of range'));
             }
         }
-    }
-    init_link() {
-        const drivers = [];
-        const crystals = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case electronics_model_1.PortType.CrystalDriver: {
-                    drivers.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.CrystalPort: {
-                    crystals.push(v);
-                    break;
+    };
+    CrystalLinkTester.prototype.init_link = function () {
+        var e_9, _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_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 (drivers.length !== 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one crystal driver port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one crystal driver port.'));
             return false;
         }
         if (crystals.length !== 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one crystal port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one crystal port.'));
             return false;
         }
         this.link = {
@@ -490,69 +672,96 @@ class CrystalLinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
             crystal: crystals[0],
         };
         return true;
-    }
-}
-exports.CrystalLinkTester = CrystalLinkTester;
+    };
+    return CrystalLinkTester;
+}(CompositePortLinkTesterBase));
+export { CrystalLinkTester };
 /**
     self.swdio = self.connect(self.host.swdio, self.device.swdio, self.pull.map_extract(lambda port: port.swdio),
                               flatten=True)
     self.swclk = self.connect(self.host.swclk, self.device.swclk, self.pull.map_extract(lambda port: port.swclk),
                               flatten=True)
  */
-class SwdLinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
-    check_parameter_propagation() {
+var SwdLinkTester = /** @class */ (function (_super) {
+    __extends(SwdLinkTester, _super);
+    function SwdLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SwdLinkTester.prototype.check_parameter_propagation = function () {
+        var e_10, _a;
         if (!this.link)
             return;
-        const swdio_tester = new DigitalLinkTester(this.ctx, [
+        var swdio_tester = new DigitalLinkTester(this.ctx, __spreadArray([
             this.link.host.swdio,
-            this.link.device.swdio,
-            ...this.link.pull.map((port) => port.swdio),
-        ]);
-        const swclk_tester = new DigitalLinkTester(this.ctx, [
+            this.link.device.swdio
+        ], __read(this.link.pull.map(function (port) { return port.swdio; })), false));
+        var swclk_tester = new DigitalLinkTester(this.ctx, __spreadArray([
             this.link.host.swclk,
-            this.link.device.swclk,
-            ...this.link.pull.map((port) => port.swclk),
-        ]);
-        for (const tst of [swdio_tester, swclk_tester])
-            tst.test();
-    }
-    init_link() {
-        const hosts = [];
-        const devices = [];
-        const pull = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case electronics_model_1.PortType.SwdHostPort: {
-                    hosts.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.SwdTargetPort: {
-                    devices.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.SwdPullPort: {
-                    pull.push(v);
-                    break;
+            this.link.device.swclk
+        ], __read(this.link.pull.map(function (port) { return port.swclk; })), false));
+        try {
+            for (var _b = __values([swdio_tester, swclk_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        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; }
+        }
+    };
+    SwdLinkTester.prototype.init_link = function () {
+        var e_11, _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_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 (hosts.length !== 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one SWD host port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one SWD host port.'));
             return false;
         }
         if (devices.length !== 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one SWD target port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one SWD target port.'));
             return false;
         }
         this.link = {
             host: hosts[0],
             device: devices[0],
-            pull,
+            pull: pull,
         };
         return true;
-    }
-}
-exports.SwdLinkTester = SwdLinkTester;
+    };
+    return SwdLinkTester;
+}(CompositePortLinkTesterBase));
+export { SwdLinkTester };
 /**
     self.require(self.pull.any_connected() | self.controller.has_pullup)
     self.require(self.pull.length() <= 1, "at most one pullup")
@@ -564,109 +773,160 @@ exports.SwdLinkTester = SwdLinkTester;
                             self.controller.sda, self.targets.map_extract(lambda device: device.sda),
                             flatten=True)
  */
-class I2cLinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
-    check_parameter_propagation() {
+var I2cLinkTester = /** @class */ (function (_super) {
+    __extends(I2cLinkTester, _super);
+    function I2cLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    I2cLinkTester.prototype.check_parameter_propagation = function () {
+        var e_12, _a;
         if (!this.link)
             return;
-        const scl_tester = new DigitalLinkTester(this.ctx, [
-            ...this.link.pull.map((device) => device.scl),
-            this.link.controller.scl,
-            ...this.link.targets.map((device) => device.scl),
-        ]);
-        const sda_tester = new DigitalLinkTester(this.ctx, [
-            ...this.link.pull.map((device) => device.sda),
-            this.link.controller.sda,
-            ...this.link.targets.map((device) => device.sda),
-        ]);
-        for (const tst of [scl_tester, sda_tester])
-            tst.test();
+        var scl_tester = new DigitalLinkTester(this.ctx, __spreadArray(__spreadArray(__spreadArray([], __read(this.link.pull.map(function (device) { return device.scl; })), false), [
+            this.link.controller.scl
+        ], false), __read(this.link.targets.map(function (device) { return device.scl; })), false));
+        var sda_tester = new DigitalLinkTester(this.ctx, __spreadArray(__spreadArray(__spreadArray([], __read(this.link.pull.map(function (device) { return device.sda; })), false), [
+            this.link.controller.sda
+        ], false), __read(this.link.targets.map(function (device) { return device.sda; })), false));
+        try {
+            for (var _b = __values([scl_tester, sda_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        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 (!this.link.pull.length && !this.link.controller.has_pullup) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'Requires at least one pullup'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'Requires at least one pullup'));
         }
         if (this.link.pull.length > 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'At most one pullup allowed'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'At most one pullup allowed'));
         }
-        const addresses = this.link.targets.map((target) => target.addresses);
+        var addresses = this.link.targets.map(function (target) { return target.addresses; });
         if (new Set(addresses).size !== addresses.length) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'Conflicting addresses on I2C bus'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'Conflicting addresses on I2C bus'));
         }
-    }
-    init_link() {
-        const pull = [];
-        const controllers = [];
-        const targets = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case electronics_model_1.PortType.I2cPullupPort: {
-                    pull.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.I2cController: {
-                    controllers.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.I2cTarget: {
-                    targets.push(v);
-                    break;
+    };
+    I2cLinkTester.prototype.init_link = function () {
+        var e_13, _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_13_1) { e_13 = { error: e_13_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_13) throw e_13.error; }
+        }
         if (controllers.length !== 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one I2C controller port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one I2C controller port.'));
             return false;
         }
         if (targets.length === 0) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be at least one I2C target port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be at least one I2C target port.'));
             return false;
         }
         this.link = {
-            pull,
+            pull: pull,
             controller: controllers[0],
-            targets,
+            targets: targets,
         };
         return true;
-    }
-}
-exports.I2cLinkTester = I2cLinkTester;
+    };
+    return I2cLinkTester;
+}(CompositePortLinkTesterBase));
+export { I2cLinkTester };
 /**
     self.sck = self.connect(self.controller.sck, self.target_receiver.sck)
     self.ws = self.connect(self.controller.ws, self.target_receiver.ws)
     self.sd = self.connect(self.controller.sd, self.target_receiver.sd)
 
  */
-class I2sLinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
-    check_parameter_propagation() {
+var I2sLinkTester = /** @class */ (function (_super) {
+    __extends(I2sLinkTester, _super);
+    function I2sLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    I2sLinkTester.prototype.check_parameter_propagation = function () {
+        var e_14, _a;
         if (!this.link)
             return;
-        const controller = this.link.controller;
-        const target_receiver = this.link.target_receiver;
-        const sck_tester = new DigitalLinkTester(this.ctx, [controller.sck, target_receiver.sck]);
-        const ws_tester = new DigitalLinkTester(this.ctx, [controller.ws, target_receiver.ws]);
-        const sd_tester = new DigitalLinkTester(this.ctx, [controller.sd, target_receiver.sd]);
-        for (const tst of [sck_tester, ws_tester, sd_tester])
-            tst.test();
-    }
-    init_link() {
-        const controllers = [];
-        const target_receivers = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case electronics_model_1.PortType.I2sController: {
-                    controllers.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.I2sTargetReceiver: {
-                    target_receivers.push(v);
-                    break;
+        var controller = this.link.controller;
+        var target_receiver = this.link.target_receiver;
+        var sck_tester = new DigitalLinkTester(this.ctx, [controller.sck, target_receiver.sck]);
+        var ws_tester = new DigitalLinkTester(this.ctx, [controller.ws, target_receiver.ws]);
+        var sd_tester = new DigitalLinkTester(this.ctx, [controller.sd, target_receiver.sd]);
+        try {
+            for (var _b = __values([sck_tester, ws_tester, sd_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_14) throw e_14.error; }
+        }
+    };
+    I2sLinkTester.prototype.init_link = function () {
+        var e_15, _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_15_1) { e_15 = { error: e_15_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_15) throw e_15.error; }
+        }
         if (controllers.length !== 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one I2S controller port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one I2S controller port.'));
             return false;
         }
         if (target_receivers.length !== 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one I2S target receiver port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one I2S target receiver port.'));
             return false;
         }
         this.link = {
@@ -674,9 +934,10 @@ class I2sLinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
             target_receiver: target_receivers[0],
         };
         return true;
-    }
-}
-exports.I2sLinkTester = I2sLinkTester;
+    };
+    return I2sLinkTester;
+}(CompositePortLinkTesterBase));
+export { I2sLinkTester };
 /**
     self.sck = self.connect(self.controller.sck, self.peripherals.map_extract(lambda device: device.sck),
                             flatten=True)
@@ -686,83 +947,138 @@ exports.I2sLinkTester = I2sLinkTester;
                              flatten=True)
 
  */
-class SpiLinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
-    check_parameter_propagation() {
+var SpiLinkTester = /** @class */ (function (_super) {
+    __extends(SpiLinkTester, _super);
+    function SpiLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SpiLinkTester.prototype.check_parameter_propagation = function () {
+        var e_16, _a;
         if (!this.link)
             return;
-        const controller = this.link.controller;
-        const peripherals = this.link.peripherals;
-        const sck_tester = new DigitalLinkTester(this.ctx, [controller.sck, ...peripherals.map((device) => device.sck)]);
-        const miso_tester = new DigitalLinkTester(this.ctx, [controller.miso, ...peripherals.map((device) => device.miso)]);
-        const mosi_tester = new DigitalLinkTester(this.ctx, [controller.mosi, ...peripherals.map((device) => device.mosi)]);
-        for (const tst of [sck_tester, miso_tester, mosi_tester])
-            tst.test();
-    }
-    init_link() {
-        const controllers = [];
-        const peripherals = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case electronics_model_1.PortType.SpiController: {
-                    controllers.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.SpiPeripheral: {
-                    peripherals.push(v);
-                    break;
+        var controller = this.link.controller;
+        var peripherals = this.link.peripherals;
+        var sck_tester = new DigitalLinkTester(this.ctx, __spreadArray([controller.sck], __read(peripherals.map(function (device) { return device.sck; })), false));
+        var miso_tester = new DigitalLinkTester(this.ctx, __spreadArray([controller.miso], __read(peripherals.map(function (device) { return device.miso; })), false));
+        var mosi_tester = new DigitalLinkTester(this.ctx, __spreadArray([controller.mosi], __read(peripherals.map(function (device) { return device.mosi; })), false));
+        try {
+            for (var _b = __values([sck_tester, miso_tester, mosi_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        catch (e_16_1) { e_16 = { error: e_16_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_16) throw e_16.error; }
+        }
+    };
+    SpiLinkTester.prototype.init_link = function () {
+        var e_17, _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_17_1) { e_17 = { error: e_17_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_17) throw e_17.error; }
+        }
         if (controllers.length !== 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one SPI controller port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one SPI controller port.'));
             return false;
         }
         if (peripherals.length === 0) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be at least one SPI peripheral port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be at least one SPI peripheral port.'));
             return false;
         }
         this.link = {
             controller: controllers[0],
-            peripherals,
+            peripherals: peripherals,
         };
         return true;
-    }
-}
-exports.SpiLinkTester = SpiLinkTester;
+    };
+    return SpiLinkTester;
+}(CompositePortLinkTesterBase));
+export { SpiLinkTester };
 /**
     self.a = self.connect(self.source.a, self.sink.a)
     self.b = self.connect(self.source.b, self.sink.b)
  */
-class SpeakerLinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
-    check_parameter_propagation() {
+var SpeakerLinkTester = /** @class */ (function (_super) {
+    __extends(SpeakerLinkTester, _super);
+    function SpeakerLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SpeakerLinkTester.prototype.check_parameter_propagation = function () {
+        var e_18, _a;
         if (!this.link)
             return;
-        const a_tester = new AnalogLinkTester(this.ctx, [this.link.source.a, this.link.sink.a]);
-        const b_tester = new AnalogLinkTester(this.ctx, [this.link.source.b, this.link.sink.b]);
-        for (const tst of [a_tester, b_tester])
-            tst.test();
-    }
-    init_link() {
-        const sources = [];
-        const sinks = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case electronics_model_1.PortType.SpeakerDriverPort: {
-                    sources.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.SpeakerPort: {
-                    sinks.push(v);
-                    break;
+        var a_tester = new AnalogLinkTester(this.ctx, [this.link.source.a, this.link.sink.a]);
+        var b_tester = new AnalogLinkTester(this.ctx, [this.link.source.b, this.link.sink.b]);
+        try {
+            for (var _b = __values([a_tester, b_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        catch (e_18_1) { e_18 = { error: e_18_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_18) throw e_18.error; }
+        }
+    };
+    SpeakerLinkTester.prototype.init_link = function () {
+        var e_19, _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_19_1) { e_19 = { error: e_19_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_19) throw e_19.error; }
+        }
         if (sources.length !== 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one speaker driver port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one speaker driver port.'));
             return false;
         }
         if (sinks.length !== 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one speaker port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one speaker port.'));
             return false;
         }
         this.link = {
@@ -770,35 +1086,51 @@ class SpeakerLinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
             sink: sinks[0],
         };
         return true;
-    }
-}
-exports.SpeakerLinkTester = SpeakerLinkTester;
+    };
+    return SpeakerLinkTester;
+}(CompositePortLinkTesterBase));
+export { SpeakerLinkTester };
 /**
     self.driver = self.Port(TouchDriver())
     self.pad = self.Port(TouchPadPort())
  */
-class TouchLinkTester extends link_tester_base_1.LinkTesterBase {
-    init_link() {
-        const drivers = [];
-        const pads = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case electronics_model_1.PortType.TouchDriver: {
-                    drivers.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.TouchPadPort: {
-                    pads.push(v);
-                    break;
+var TouchLinkTester = /** @class */ (function (_super) {
+    __extends(TouchLinkTester, _super);
+    function TouchLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TouchLinkTester.prototype.init_link = function () {
+        var e_20, _a;
+        var drivers = [];
+        var pads = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.TouchDriver: {
+                        drivers.push(v);
+                        break;
+                    }
+                    case PortType.TouchPadPort: {
+                        pads.push(v);
+                        break;
+                    }
                 }
             }
         }
+        catch (e_20_1) { e_20 = { error: e_20_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_20) throw e_20.error; }
+        }
         if (drivers.length !== 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one touch driver port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one touch driver port.'));
             return false;
         }
         if (pads.length !== 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one touch pad port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one touch pad port.'));
             return false;
         }
         this.link = {
@@ -806,35 +1138,63 @@ class TouchLinkTester extends link_tester_base_1.LinkTesterBase {
             pad: pads[0],
         };
         return true;
-    }
-    check_parameter_propagation() {
+    };
+    TouchLinkTester.prototype.check_parameter_propagation = function () {
         return;
-    }
-}
-exports.TouchLinkTester = TouchLinkTester;
+    };
+    return TouchLinkTester;
+}(LinkTesterBase));
+export { TouchLinkTester };
 /**
     self.a_tx = self.connect(self.a.tx, self.b.rx)
     self.b_tx = self.connect(self.b.tx, self.a.rx)
 
  */
-class UartLinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
-    check_parameter_propagation() {
+var UartLinkTester = /** @class */ (function (_super) {
+    __extends(UartLinkTester, _super);
+    function UartLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UartLinkTester.prototype.check_parameter_propagation = function () {
+        var e_21, _a;
         if (!this.link)
             return;
-        const tx_tester = new DigitalLinkTester(this.ctx, [this.link.a.tx, this.link.b.rx]);
-        const rx_tester = new DigitalLinkTester(this.ctx, [this.link.b.tx, this.link.a.rx]);
-        for (const tst of [tx_tester, rx_tester])
-            tst.test();
-    }
-    init_link() {
-        const ports = [];
-        for (const v of this.ports) {
-            if (v.type === electronics_model_1.PortType.UartPort) {
-                ports.push(v);
+        var tx_tester = new DigitalLinkTester(this.ctx, [this.link.a.tx, this.link.b.rx]);
+        var rx_tester = new DigitalLinkTester(this.ctx, [this.link.b.tx, this.link.a.rx]);
+        try {
+            for (var _b = __values([tx_tester, rx_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        catch (e_21_1) { e_21 = { error: e_21_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_21) throw e_21.error; }
+        }
+    };
+    UartLinkTester.prototype.init_link = function () {
+        var e_22, _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_22_1) { e_22 = { error: e_22_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
+            finally { if (e_22) throw e_22.error; }
         }
         if (ports.length !== 2) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly two UART ports.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly two UART ports.'));
             return false;
         }
         this.link = {
@@ -842,9 +1202,10 @@ class UartLinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
             b: ports[1],
         };
         return true;
-    }
-}
-exports.UartLinkTester = UartLinkTester;
+    };
+    return UartLinkTester;
+}(CompositePortLinkTesterBase));
+export { UartLinkTester };
 /**
 
     self.d_P = self.connect(self.host.dp, self.device.dp, self.passive.map_extract(lambda port: port.dp),
@@ -852,83 +1213,136 @@ exports.UartLinkTester = UartLinkTester;
     self.d_N = self.connect(self.host.dm, self.device.dm, self.passive.map_extract(lambda port: port.dm),
                             flatten=True)
  */
-class UsbLinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
-    check_parameter_propagation() {
+var UsbLinkTester = /** @class */ (function (_super) {
+    __extends(UsbLinkTester, _super);
+    function UsbLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UsbLinkTester.prototype.check_parameter_propagation = function () {
+        var e_23, _a;
         if (!this.link)
             return;
-        const dp_tester = new DigitalLinkTester(this.ctx, [
+        var dp_tester = new DigitalLinkTester(this.ctx, __spreadArray([
             this.link.host.dp,
-            this.link.device.dp,
-            ...this.link.passive.map((port) => port.dp),
-        ]);
-        const dm_tester = new DigitalLinkTester(this.ctx, [
+            this.link.device.dp
+        ], __read(this.link.passive.map(function (port) { return port.dp; })), false));
+        var dm_tester = new DigitalLinkTester(this.ctx, __spreadArray([
             this.link.host.dm,
-            this.link.device.dm,
-            ...this.link.passive.map((port) => port.dm),
-        ]);
-        for (const tst of [dp_tester, dm_tester])
-            tst.test();
-    }
-    init_link() {
-        const hosts = [];
-        const devices = [];
-        const passive = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case electronics_model_1.PortType.UsbHostPort: {
-                    hosts.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.UsbDevicePort: {
-                    devices.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.UsbPassivePort: {
-                    passive.push(v);
-                    break;
+            this.link.device.dm
+        ], __read(this.link.passive.map(function (port) { return port.dm; })), false));
+        try {
+            for (var _b = __values([dp_tester, dm_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        catch (e_23_1) { e_23 = { error: e_23_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_23) throw e_23.error; }
+        }
+    };
+    UsbLinkTester.prototype.init_link = function () {
+        var e_24, _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_24_1) { e_24 = { error: e_24_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_24) throw e_24.error; }
+        }
         if (hosts.length !== 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one USB host port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one USB host port.'));
             return false;
         }
         if (devices.length !== 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one USB device port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one USB device port.'));
             return false;
         }
         this.link = {
             host: hosts[0],
             device: devices[0],
-            passive,
+            passive: passive,
         };
         return true;
-    }
-}
-exports.UsbLinkTester = UsbLinkTester;
+    };
+    return UsbLinkTester;
+}(CompositePortLinkTesterBase));
+export { UsbLinkTester };
 /**
     self.cc1 = self.Port(DigitalBidir(pullup_capable=pullup_capable))
     self.cc2 = self.Port(DigitalBidir(pullup_capable=pullup_capable))
 
  */
-class UsbCcLinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
-    check_parameter_propagation() {
+var UsbCcLinkTester = /** @class */ (function (_super) {
+    __extends(UsbCcLinkTester, _super);
+    function UsbCcLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UsbCcLinkTester.prototype.check_parameter_propagation = function () {
+        var e_25, _a;
         if (!this.link)
             return;
-        const cc1_tester = new DigitalLinkTester(this.ctx, [this.link.a.cc1, this.link.b.cc1]);
-        const cc2_tester = new DigitalLinkTester(this.ctx, [this.link.a.cc2, this.link.b.cc2]);
-        for (const tst of [cc1_tester, cc2_tester])
-            tst.test();
-    }
-    init_link() {
-        const nodes = [];
-        for (const v of this.ports) {
-            if (v.type === electronics_model_1.PortType.UsbCcPort) {
-                nodes.push(v);
+        var cc1_tester = new DigitalLinkTester(this.ctx, [this.link.a.cc1, this.link.b.cc1]);
+        var cc2_tester = new DigitalLinkTester(this.ctx, [this.link.a.cc2, this.link.b.cc2]);
+        try {
+            for (var _b = __values([cc1_tester, cc2_tester]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tst = _c.value;
+                tst.test();
+            }
+        }
+        catch (e_25_1) { e_25 = { error: e_25_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_25) throw e_25.error; }
+        }
+    };
+    UsbCcLinkTester.prototype.init_link = function () {
+        var e_26, _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_26_1) { e_26 = { error: e_26_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_26) throw e_26.error; }
+        }
         if (nodes.length !== 2) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly two CC ports.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly two CC ports.'));
             return false;
         }
         this.link = {
@@ -936,9 +1350,10 @@ class UsbCcLinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
             b: nodes[1],
         };
         return true;
-    }
-}
-exports.UsbCcLinkTester = UsbCcLinkTester;
+    };
+    return UsbCcLinkTester;
+}(CompositePortLinkTesterBase));
+export { UsbCcLinkTester };
 /**
 
     self.xclk = self.connect(self.host.xclk, self.cam.xclk)
@@ -956,13 +1371,18 @@ exports.UsbCcLinkTester = UsbCcLinkTester;
     self.y7 = self.connect(self.host.y7, self.cam.y7)
 
  */
-class Dvp8LinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
-    check_parameter_propagation() {
+var Dvp8LinkTester = /** @class */ (function (_super) {
+    __extends(Dvp8LinkTester, _super);
+    function Dvp8LinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Dvp8LinkTester.prototype.check_parameter_propagation = function () {
+        var e_27, _a;
         if (!this.link)
             return;
-        const host = this.link.host;
-        const cam = this.link.cam;
-        const digitalLinks = [
+        var host = this.link.host;
+        var cam = this.link.cam;
+        var digitalLinks = [
             [host.xclk, cam.xclk],
             [host.pclk, cam.pclk],
             [host.href, cam.href],
@@ -976,32 +1396,53 @@ class Dvp8LinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
             [host.y6, cam.y6],
             [host.y7, cam.y7],
         ];
-        for (const [hostPort, camPort] of digitalLinks) {
-            const tester = new DigitalLinkTester(this.ctx, [hostPort, camPort]);
-            tester.test();
+        try {
+            for (var digitalLinks_1 = __values(digitalLinks), digitalLinks_1_1 = digitalLinks_1.next(); !digitalLinks_1_1.done; digitalLinks_1_1 = digitalLinks_1.next()) {
+                var _b = __read(digitalLinks_1_1.value, 2), hostPort = _b[0], camPort = _b[1];
+                var tester = new DigitalLinkTester(this.ctx, [hostPort, camPort]);
+                tester.test();
+            }
         }
-    }
-    init_link() {
-        const hosts = [];
-        const cams = [];
-        for (const v of this.ports) {
-            switch (v.type) {
-                case electronics_model_1.PortType.Dvp8Host: {
-                    hosts.push(v);
-                    break;
-                }
-                case electronics_model_1.PortType.Dvp8Camera: {
-                    cams.push(v);
-                    break;
+        catch (e_27_1) { e_27 = { error: e_27_1 }; }
+        finally {
+            try {
+                if (digitalLinks_1_1 && !digitalLinks_1_1.done && (_a = digitalLinks_1.return)) _a.call(digitalLinks_1);
+            }
+            finally { if (e_27) throw e_27.error; }
+        }
+    };
+    Dvp8LinkTester.prototype.init_link = function () {
+        var e_28, _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_28_1) { e_28 = { error: e_28_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_28) throw e_28.error; }
+        }
         if (hosts.length !== 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one DVP8 host port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one DVP8 host port.'));
             return false;
         }
         if (cams.length !== 1) {
-            this.ctx.report.erc_errors.push((0, report_1.PP_ILLEGAL_CONNECTION)(this.all_port_ids, 'There must be exactly one DVP8 camera port.'));
+            this.ctx.report.erc_errors.push(PP_ILLEGAL_CONNECTION(this.all_port_ids, 'There must be exactly one DVP8 camera port.'));
             return false;
         }
         this.link = {
@@ -1009,6 +1450,7 @@ class Dvp8LinkTester extends link_tester_base_1.CompositePortLinkTesterBase {
             cam: cams[0],
         };
         return true;
-    }
-}
-exports.Dvp8LinkTester = Dvp8LinkTester;
+    };
+    return Dvp8LinkTester;
+}(CompositePortLinkTesterBase));
+export { Dvp8LinkTester };