simple-circuit-engine 0.0.13 → 0.0.14

package/dist/{core-b6Q8w2sn.js → core-HH6iRWtB.js}

@@ -1,19 +1,19 @@
-function dt(e) {
+function yt(e) {
   let t, n, i;
   return typeof e == "object" ? (t = e.hashFunction, n = e.expiring, i = e.tags) : t = e, (s, r, a) => {
-    if (a.value != null) a.value = W(a.value, t, n, i);
-    else if (a.get != null) a.get = W(a.get, t, n, i);
+    if (a.value != null) a.value = X(a.value, t, n, i);
+    else if (a.get != null) a.get = X(a.get, t, n, i);
     else throw "Only put a Memoize() decorator on a method or get accessor.";
   };
 }
-function Se(e, t) {
-  return dt({
+function _e(e, t) {
+  return yt({
     expiring: e,
     hashFunction: t
   });
 }
-var D = /* @__PURE__ */ new Map();
-function W(e, t, n = 0, i) {
+var _ = /* @__PURE__ */ new Map();
+function X(e, t, n = 0, i) {
   const s = /* @__PURE__ */ Symbol("__memoized_map__");
   return function(...r) {
     let a;
@@ -24,26 +24,26 @@ function W(e, t, n = 0, i) {
       value: /* @__PURE__ */ new Map()
     });
     let o = this[s];
-    if (Array.isArray(i)) for (const c of i) D.has(c) ? D.get(c).push(o) : D.set(c, [o]);
+    if (Array.isArray(i)) for (const u of i) _.has(u) ? _.get(u).push(o) : _.set(u, [o]);
     if (t || r.length > 0 || n > 0) {
-      let c;
-      t === !0 ? c = r.map((d) => d.toString()).join("!") : t ? c = t.apply(this, r) : c = r[0];
-      const p = `${c}__timestamp`;
-      let l = !1;
-      if (n > 0) if (!o.has(p)) l = !0;
+      let u;
+      t === !0 ? u = r.map((d) => d.toString()).join("!") : t ? u = t.apply(this, r) : u = r[0];
+      const l = `${u}__timestamp`;
+      let p = !1;
+      if (n > 0) if (!o.has(l)) p = !0;
       else {
-        let d = o.get(p);
-        l = Date.now() - d > n;
+        let d = o.get(l);
+        p = Date.now() - d > n;
       }
-      o.has(c) && !l ? a = o.get(c) : (a = e.apply(this, r), o.set(c, a), n > 0 && o.set(p, Date.now()));
+      o.has(u) && !p ? a = o.get(u) : (a = e.apply(this, r), o.set(u, a), n > 0 && o.set(l, Date.now()));
     } else {
-      const c = this;
-      o.has(c) ? a = o.get(c) : (a = e.apply(this, r), o.set(c, a));
+      const u = this;
+      o.has(u) ? a = o.get(u) : (a = e.apply(this, r), o.set(u, a));
     }
     return a;
   };
 }
-var O = class X {
+var D = class j {
   constructor(t, n, i) {
     this.x = t, this.y = n, this.z = i;
   }
@@ -58,13 +58,13 @@ var O = class X {
     };
   }
   static fromJSON(t) {
-    return new X(t.x, t.y, t.z);
+    return new j(t.x, t.y, t.z);
   }
   toString() {
     return `Position(${this.x}, ${this.y}, ${this.z})`;
   }
-}, Q = class q {
-  constructor(t = new O(0, 15, 15), n = new O(0, 0, 0), i = 75, s = 0.1, r = 1e3) {
+}, tt = class et {
+  constructor(t = new D(0, 15, 15), n = new D(0, 0, 0), i = 75, s = 0.1, r = 1e3) {
     this.position = t, this.lookAtPosition = n, this.fov = i, this.near = s, this.far = r;
   }
   toJSON() {
@@ -77,12 +77,12 @@ var O = class X {
     };
   }
   static fromJSON(t) {
-    return new q(O.fromJSON(t.position), O.fromJSON(t.lookAtPosition), t.fov, t.near, t.far);
+    return new et(D.fromJSON(t.position), D.fromJSON(t.lookAtPosition), t.fov, t.near, t.far);
   }
   toString() {
     return `CameraOptions(position: ${this.position.toString()}, lookAt: ${this.lookAtPosition.toString()}, fov: ${this.fov}, near: ${this.near}, far: ${this.far})`;
   }
-}, V = class K {
+}, H = class it {
   constructor(t, n) {
     if (this.x = t, this.y = n, !Number.isInteger(t) || !Number.isInteger(n)) throw new TypeError(`Position coordinates must be integers (got x=${t}, y=${n})`);
   }
@@ -96,42 +96,42 @@ var O = class X {
     };
   }
   static fromJSON(t) {
-    return new K(t.x, t.y);
+    return new it(t.x, t.y);
   }
   toString() {
     return `Position(${this.x}, ${this.y})`;
   }
 };
-function ht(e, t, n = 1 / 0) {
+function vt(e, t, n = 1 / 0) {
   if (e.length === 0) return 0;
   if (e.length === 1) return 1;
   let i = 1;
   for (let s = 0; s < e.length - 1; s++) {
-    const r = e[s], a = e[s + 1], o = gt(t, r, a);
+    const r = e[s], a = e[s + 1], o = St(t, r, a);
     o < n && (n = o, i = s + 1);
   }
   return i;
 }
-function gt(e, t, n) {
+function St(e, t, n) {
   const i = n.x - t.x, s = n.y - t.y, r = i * i + s * s;
   if (r === 0) return Math.sqrt((e.x - t.x) ** 2 + (e.y - t.y) ** 2);
-  const a = Math.max(0, Math.min(1, ((e.x - t.x) * i + (e.y - t.y) * s) / r)), o = t.x + a * i, c = t.y + a * s;
-  return Math.sqrt((e.x - o) ** 2 + (e.y - c) ** 2);
+  const a = Math.max(0, Math.min(1, ((e.x - t.x) * i + (e.y - t.y) * s) / r)), o = t.x + a * i, u = t.y + a * s;
+  return Math.sqrt((e.x - o) ** 2 + (e.y - u) ** 2);
 }
-function M(e, t = 5) {
+function V(e, t = 5) {
   if (e.length <= 2) return [...e];
   const n = [e[0]];
   for (let i = 1; i < e.length - 1; i++) {
     const s = n[n.length - 1], r = e[i], a = e[i + 1];
-    ft(s, r, a, t) || n.push(r);
+    wt(s, r, a, t) || n.push(r);
   }
   return n.push(e[e.length - 1]), n;
 }
-function ft(e, t, n, i = 5) {
+function wt(e, t, n, i = 5) {
   const s = (t.x - e.x) * (n.y - e.y) - (t.y - e.y) * (n.x - e.x);
   return Math.abs(s) <= i;
 }
-var yt = class Y {
+var mt = class nt {
   constructor(t) {
     if (this.angle = t, !Number.isInteger(t)) throw new TypeError(`Rotation angle must be an integer (got ${t})`);
   }
@@ -139,7 +139,7 @@ var yt = class Y {
     return this.angle;
   }
   static fromJSON(t) {
-    return new Y(t);
+    return new nt(t);
   }
   equals(t) {
     return this.angle === t.angle;
@@ -148,7 +148,7 @@ var yt = class Y {
     return `Rotation(${this.angle}°)`;
   }
 };
-function $() {
+function J() {
   if (typeof crypto < "u" && crypto.randomUUID) return crypto.randomUUID();
   const e = "0123456789abcdef", t = [
     8,
@@ -168,19 +168,19 @@ function $() {
   const i = n.join("-").split("");
   return i[14] = "4", i[19] = e[parseInt(i[19] ?? "0", 16) & 3 | 8] ?? "0", i.join("");
 }
-var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
+var st = "0.0.14", h = /* @__PURE__ */ (function(e) {
   return e.Voltage = "Voltage", e.Current = "Current", e;
-})({}), P = /* @__PURE__ */ (function(e) {
+})({}), w = /* @__PURE__ */ (function(e) {
   return e.Pin = "Pin", e.BranchingPoint = "BranchingPoint", e;
-})({}), we = [
+})({}), Ve = [
   "CMOS1",
   "TTL1",
   "Sandbox"
-], j = "CMOS1", u = /* @__PURE__ */ (function(e) {
-  return e.Cube = "cube", e.Label = "label", e.Battery = "battery", e.Switch = "switch", e.DoubleThrowSwitch = "doubleThrowSwitch", e.Lightbulb = "lightbulb", e.Relay = "relay", e.SmallLED = "smallLED", e.RectangleLED = "rectangleLED", e.Clock = "clock", e.Inverter = "inverter", e.NandGate = "nandGate", e.Nand4Gate = "nand4Gate", e.Nand8Gate = "nand8Gate", e.NorGate = "norGate", e.Nor4Gate = "nor4Gate", e.Nor8Gate = "nor8Gate", e.XorGate = "xorGate", e.Xor4Gate = "xor4Gate", e.Xor8Gate = "xor8Gate", e.HalfAdder = "halfAdder", e.Adder = "adder", e.EightBitAdder = "eightBitAdder", e.EightBitOnesComplement = "eightBitOnesComplement", e;
+], rt = "CMOS1", c = /* @__PURE__ */ (function(e) {
+  return e.Cube = "cube", e.Label = "label", e.Battery = "battery", e.Switch = "switch", e.DoubleThrowSwitch = "doubleThrowSwitch", e.Lightbulb = "lightbulb", e.Relay = "relay", e.SmallLED = "smallLED", e.RectangleLED = "rectangleLED", e.Clock = "clock", e.Inverter = "inverter", e.NandGate = "nandGate", e.Nand4Gate = "nand4Gate", e.Nand8Gate = "nand8Gate", e.NorGate = "norGate", e.Nor4Gate = "nor4Gate", e.Nor8Gate = "nor8Gate", e.XorGate = "xorGate", e.Xor4Gate = "xor4Gate", e.Xor8Gate = "xor8Gate", e.HalfAdder = "halfAdder", e.Adder = "adder", e.EightBitAdder = "eightBitAdder", e.EightBitOnesComplement = "eightBitOnesComplement", e.OneInput = "oneInput", e.TwoInput = "twoInput", e.FourInput = "fourInput", e.EightInput = "eightInput", e.OneLight = "oneLight", e.TwoLight = "twoLight", e.FourLight = "fourLight", e.EightLight = "eightLight", e;
 })({}), I = {
-  [u.Switch]: {
-    id: u.Switch,
+  [c.Switch]: {
+    id: c.Switch,
     pins: /* @__PURE__ */ new Map([["input", { subtype: "free" }], ["output", { subtype: "free" }]]),
     config: /* @__PURE__ */ new Map([
       ["initialState", "open"],
@@ -188,8 +188,8 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       ["size", "1"]
     ])
   },
-  [u.DoubleThrowSwitch]: {
-    id: u.DoubleThrowSwitch,
+  [c.DoubleThrowSwitch]: {
+    id: c.DoubleThrowSwitch,
     pins: /* @__PURE__ */ new Map([
       ["input1", { subtype: "free" }],
       ["input2", { subtype: "free" }],
@@ -201,24 +201,24 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       ["size", "1"]
     ])
   },
-  [u.Battery]: {
-    id: u.Battery,
+  [c.Battery]: {
+    id: c.Battery,
     pins: /* @__PURE__ */ new Map([["cathode", {
       subtype: "mainVcc",
-      sourceType: g.Voltage
+      sourceType: h.Voltage
     }], ["anode", {
       subtype: "mainGnd",
-      sourceType: g.Current
+      sourceType: h.Current
     }]]),
     config: /* @__PURE__ */ new Map([])
   },
-  [u.Lightbulb]: {
-    id: u.Lightbulb,
+  [c.Lightbulb]: {
+    id: c.Lightbulb,
     pins: /* @__PURE__ */ new Map([["pin1", { subtype: "free" }], ["pin2", { subtype: "free" }]]),
     config: /* @__PURE__ */ new Map([["transitionSpan", "1"], ["size", "1"]])
   },
-  [u.Relay]: {
-    id: u.Relay,
+  [c.Relay]: {
+    id: c.Relay,
     pins: /* @__PURE__ */ new Map([
       ["cmd_in", { subtype: "free" }],
       ["cmd_out", { subtype: "free" }],
@@ -231,8 +231,8 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       ["initializationOrder", ""]
     ])
   },
-  [u.SmallLED]: {
-    id: u.SmallLED,
+  [c.SmallLED]: {
+    id: c.SmallLED,
     pins: /* @__PURE__ */ new Map([["pin1", { subtype: "free" }], ["pin2", { subtype: "free" }]]),
     config: /* @__PURE__ */ new Map([
       ["transitionSpan", "1"],
@@ -242,8 +242,8 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       ["ywRatio", "1"]
     ])
   },
-  [u.RectangleLED]: {
-    id: u.RectangleLED,
+  [c.RectangleLED]: {
+    id: c.RectangleLED,
     pins: /* @__PURE__ */ new Map([["pin1", { subtype: "free" }], ["pin2", { subtype: "free" }]]),
     config: /* @__PURE__ */ new Map([
       ["transitionSpan", "1"],
@@ -254,61 +254,64 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       ["ywRatio", "1"]
     ])
   },
-  [u.Cube]: {
-    id: u.Cube,
+  [c.Cube]: {
+    id: c.Cube,
     pins: /* @__PURE__ */ new Map([]),
     config: /* @__PURE__ */ new Map([["color", "red"]])
   },
-  [u.Label]: {
-    id: u.Label,
+  [c.Label]: {
+    id: c.Label,
     pins: /* @__PURE__ */ new Map([]),
     config: /* @__PURE__ */ new Map([["text", "Label"], ["size", "1"]])
   },
-  [u.Clock]: {
-    id: u.Clock,
+  [c.Clock]: {
+    id: c.Clock,
     pins: /* @__PURE__ */ new Map([
       ["vcc", {
         subtype: "vcc",
-        sourceType: g.Voltage
+        sourceType: h.Voltage
       }],
       ["output", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["gnd", {
         subtype: "gnd",
-        sourceType: g.Current
+        sourceType: h.Current
       }]
     ]),
     config: /* @__PURE__ */ new Map([["startHigh", "true"], ["halfPeriod", "2"]])
   },
-  [u.Inverter]: {
-    id: u.Inverter,
+  [c.Inverter]: {
+    id: c.Inverter,
     pins: /* @__PURE__ */ new Map([
       ["vcc", {
         subtype: "vcc",
-        sourceType: g.Voltage
+        sourceType: h.Voltage
       }],
       ["input", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["output", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["gnd", {
         subtype: "gnd",
-        sourceType: g.Current
+        sourceType: h.Current
       }]
     ]),
     config: /* @__PURE__ */ new Map([
@@ -318,37 +321,40 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       ["initializationOrder", ""]
     ])
   },
-  [u.NandGate]: {
-    id: u.NandGate,
+  [c.NandGate]: {
+    id: c.NandGate,
     pins: /* @__PURE__ */ new Map([
       ["vcc", {
         subtype: "vcc",
-        sourceType: g.Voltage
+        sourceType: h.Voltage
       }],
-      ["input1", {
+      ["input-0", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 0
+          index: 0,
+          size: 2
         }
       }],
-      ["input2", {
+      ["input-1", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 1
+          index: 1,
+          size: 2
         }
       }],
       ["output", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["gnd", {
         subtype: "gnd",
-        sourceType: g.Current
+        sourceType: h.Current
       }]
     ]),
     config: /* @__PURE__ */ new Map([
@@ -358,51 +364,56 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       ["initializationOrder", ""]
     ])
   },
-  [u.Nand4Gate]: {
-    id: u.Nand4Gate,
+  [c.Nand4Gate]: {
+    id: c.Nand4Gate,
     pins: /* @__PURE__ */ new Map([
       ["vcc", {
         subtype: "vcc",
-        sourceType: g.Voltage
+        sourceType: h.Voltage
       }],
-      ["input1", {
+      ["input-0", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 0
+          index: 0,
+          size: 4
         }
       }],
-      ["input2", {
+      ["input-1", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 1
+          index: 1,
+          size: 4
         }
       }],
-      ["input3", {
+      ["input-2", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 2
+          index: 2,
+          size: 4
         }
       }],
-      ["input4", {
+      ["input-3", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 3
+          index: 3,
+          size: 4
         }
       }],
       ["output", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["gnd", {
         subtype: "gnd",
-        sourceType: g.Current
+        sourceType: h.Current
       }]
     ]),
     config: /* @__PURE__ */ new Map([
@@ -412,79 +423,88 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       ["initializationOrder", ""]
     ])
   },
-  [u.Nand8Gate]: {
-    id: u.Nand8Gate,
+  [c.Nand8Gate]: {
+    id: c.Nand8Gate,
     pins: /* @__PURE__ */ new Map([
       ["vcc", {
         subtype: "vcc",
-        sourceType: g.Voltage
+        sourceType: h.Voltage
       }],
-      ["input1", {
+      ["input-0", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 0
+          index: 0,
+          size: 8
         }
       }],
-      ["input2", {
+      ["input-1", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 1
+          index: 1,
+          size: 8
         }
       }],
-      ["input3", {
+      ["input-2", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 2
+          index: 2,
+          size: 8
         }
       }],
-      ["input4", {
+      ["input-3", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 3
+          index: 3,
+          size: 8
         }
       }],
-      ["input5", {
+      ["input-4", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 4
+          index: 4,
+          size: 8
         }
       }],
-      ["input6", {
+      ["input-5", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 5
+          index: 5,
+          size: 8
         }
       }],
-      ["input7", {
+      ["input-6", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 6
+          index: 6,
+          size: 8
         }
       }],
-      ["input8", {
+      ["input-7", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 7
+          index: 7,
+          size: 8
         }
       }],
       ["output", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["gnd", {
         subtype: "gnd",
-        sourceType: g.Current
+        sourceType: h.Current
       }]
     ]),
     config: /* @__PURE__ */ new Map([
@@ -494,37 +514,40 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       ["initializationOrder", ""]
     ])
   },
-  [u.NorGate]: {
-    id: u.NorGate,
+  [c.NorGate]: {
+    id: c.NorGate,
     pins: /* @__PURE__ */ new Map([
       ["vcc", {
         subtype: "vcc",
-        sourceType: g.Voltage
+        sourceType: h.Voltage
       }],
-      ["input1", {
+      ["input-0", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 0
+          index: 0,
+          size: 2
         }
       }],
-      ["input2", {
+      ["input-1", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 1
+          index: 1,
+          size: 2
         }
       }],
       ["output", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["gnd", {
         subtype: "gnd",
-        sourceType: g.Current
+        sourceType: h.Current
       }]
     ]),
     config: /* @__PURE__ */ new Map([
@@ -534,51 +557,56 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       ["initializationOrder", ""]
     ])
   },
-  [u.Nor4Gate]: {
-    id: u.Nor4Gate,
+  [c.Nor4Gate]: {
+    id: c.Nor4Gate,
     pins: /* @__PURE__ */ new Map([
       ["vcc", {
         subtype: "vcc",
-        sourceType: g.Voltage
+        sourceType: h.Voltage
       }],
-      ["input1", {
+      ["input-0", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 0
+          index: 0,
+          size: 4
         }
       }],
-      ["input2", {
+      ["input-1", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 1
+          index: 1,
+          size: 4
         }
       }],
-      ["input3", {
+      ["input-2", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 2
+          index: 2,
+          size: 4
         }
       }],
-      ["input4", {
+      ["input-3", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 3
+          index: 3,
+          size: 4
         }
       }],
       ["output", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["gnd", {
         subtype: "gnd",
-        sourceType: g.Current
+        sourceType: h.Current
       }]
     ]),
     config: /* @__PURE__ */ new Map([
@@ -588,79 +616,88 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       ["initializationOrder", ""]
     ])
   },
-  [u.Nor8Gate]: {
-    id: u.Nor8Gate,
+  [c.Nor8Gate]: {
+    id: c.Nor8Gate,
     pins: /* @__PURE__ */ new Map([
       ["vcc", {
         subtype: "vcc",
-        sourceType: g.Voltage
+        sourceType: h.Voltage
       }],
-      ["input1", {
+      ["input-0", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 0
+          index: 0,
+          size: 8
         }
       }],
-      ["input2", {
+      ["input-1", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 1
+          index: 1,
+          size: 8
         }
       }],
-      ["input3", {
+      ["input-2", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 2
+          index: 2,
+          size: 8
         }
       }],
-      ["input4", {
+      ["input-3", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 3
+          index: 3,
+          size: 8
         }
       }],
-      ["input5", {
+      ["input-4", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 4
+          index: 4,
+          size: 8
         }
       }],
-      ["input6", {
+      ["input-5", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 5
+          index: 5,
+          size: 8
         }
       }],
-      ["input7", {
+      ["input-6", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 6
+          index: 6,
+          size: 8
         }
       }],
-      ["input8", {
+      ["input-7", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 7
+          index: 7,
+          size: 8
         }
       }],
       ["output", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["gnd", {
         subtype: "gnd",
-        sourceType: g.Current
+        sourceType: h.Current
       }]
     ]),
     config: /* @__PURE__ */ new Map([
@@ -670,37 +707,40 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       ["initializationOrder", ""]
     ])
   },
-  [u.XorGate]: {
-    id: u.XorGate,
+  [c.XorGate]: {
+    id: c.XorGate,
     pins: /* @__PURE__ */ new Map([
       ["vcc", {
         subtype: "vcc",
-        sourceType: g.Voltage
+        sourceType: h.Voltage
       }],
-      ["input1", {
+      ["input-0", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 0
+          index: 0,
+          size: 2
         }
       }],
-      ["input2", {
+      ["input-1", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 1
+          index: 1,
+          size: 2
         }
       }],
       ["output", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["gnd", {
         subtype: "gnd",
-        sourceType: g.Current
+        sourceType: h.Current
       }]
     ]),
     config: /* @__PURE__ */ new Map([
@@ -710,51 +750,56 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       ["initializationOrder", ""]
     ])
   },
-  [u.Xor4Gate]: {
-    id: u.Xor4Gate,
+  [c.Xor4Gate]: {
+    id: c.Xor4Gate,
     pins: /* @__PURE__ */ new Map([
       ["vcc", {
         subtype: "vcc",
-        sourceType: g.Voltage
+        sourceType: h.Voltage
       }],
-      ["input1", {
+      ["input-0", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 0
+          index: 0,
+          size: 4
         }
       }],
-      ["input2", {
+      ["input-1", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 1
+          index: 1,
+          size: 4
         }
       }],
-      ["input3", {
+      ["input-2", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 2
+          index: 2,
+          size: 4
         }
       }],
-      ["input4", {
+      ["input-3", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 3
+          index: 3,
+          size: 4
         }
       }],
       ["output", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["gnd", {
         subtype: "gnd",
-        sourceType: g.Current
+        sourceType: h.Current
       }]
     ]),
     config: /* @__PURE__ */ new Map([
@@ -764,79 +809,88 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       ["initializationOrder", ""]
     ])
   },
-  [u.Xor8Gate]: {
-    id: u.Xor8Gate,
+  [c.Xor8Gate]: {
+    id: c.Xor8Gate,
     pins: /* @__PURE__ */ new Map([
       ["vcc", {
         subtype: "vcc",
-        sourceType: g.Voltage
+        sourceType: h.Voltage
       }],
-      ["input1", {
+      ["input-0", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 0
+          index: 0,
+          size: 8
         }
       }],
-      ["input2", {
+      ["input-1", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 1
+          index: 1,
+          size: 8
         }
       }],
-      ["input3", {
+      ["input-2", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 2
+          index: 2,
+          size: 8
         }
       }],
-      ["input4", {
+      ["input-3", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 3
+          index: 3,
+          size: 8
         }
       }],
-      ["input5", {
+      ["input-4", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 4
+          index: 4,
+          size: 8
         }
       }],
-      ["input6", {
+      ["input-5", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 5
+          index: 5,
+          size: 8
         }
       }],
-      ["input7", {
+      ["input-6", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 6
+          index: 6,
+          size: 8
         }
       }],
-      ["input8", {
+      ["input-7", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 7
+          index: 7,
+          size: 8
         }
       }],
       ["output", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["gnd", {
         subtype: "gnd",
-        sourceType: g.Current
+        sourceType: h.Current
       }]
     ]),
     config: /* @__PURE__ */ new Map([
@@ -846,44 +900,48 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       ["initializationOrder", ""]
     ])
   },
-  [u.HalfAdder]: {
-    id: u.HalfAdder,
+  [c.HalfAdder]: {
+    id: c.HalfAdder,
     pins: /* @__PURE__ */ new Map([
       ["vcc", {
         subtype: "vcc",
-        sourceType: g.Voltage
+        sourceType: h.Voltage
       }],
       ["inputA", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 0
+          index: 0,
+          size: 2
         }
       }],
       ["inputB", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 1
+          index: 1,
+          size: 2
         }
       }],
       ["sum", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "sum",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["carry", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "carry",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["gnd", {
         subtype: "gnd",
-        sourceType: g.Current
+        sourceType: h.Current
       }]
     ]),
     config: /* @__PURE__ */ new Map([
@@ -892,51 +950,56 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       ["initializationOrder", ""]
     ])
   },
-  [u.Adder]: {
-    id: u.Adder,
+  [c.Adder]: {
+    id: c.Adder,
     pins: /* @__PURE__ */ new Map([
       ["vcc", {
         subtype: "vcc",
-        sourceType: g.Voltage
+        sourceType: h.Voltage
       }],
       ["carryIn", {
         subtype: "logicInput",
         logicPinData: {
           interface: "carryIn",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["inputA", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 0
+          index: 0,
+          size: 2
         }
       }],
       ["inputB", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 1
+          index: 1,
+          size: 2
         }
       }],
       ["sum", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "sum",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["carryOut", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "carryOut",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["gnd", {
         subtype: "gnd",
-        sourceType: g.Current
+        sourceType: h.Current
       }]
     ]),
     config: /* @__PURE__ */ new Map([
@@ -945,344 +1008,875 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       ["initializationOrder", ""]
     ])
   },
-  [u.EightBitAdder]: {
-    id: u.EightBitAdder,
+  [c.EightBitAdder]: {
+    id: c.EightBitAdder,
     pins: /* @__PURE__ */ new Map([
       ["vcc", {
         subtype: "vcc",
-        sourceType: g.Voltage
+        sourceType: h.Voltage
       }],
       ["carryIn", {
         subtype: "logicInput",
         logicPinData: {
           interface: "carryIn",
-          index: 0
+          index: 0,
+          size: 1
         }
       }],
       ["inputA-0", {
         subtype: "logicInput",
         logicPinData: {
           interface: "inputA",
-          index: 0
+          index: 0,
+          size: 8
         }
       }],
       ["inputA-1", {
         subtype: "logicInput",
         logicPinData: {
           interface: "inputA",
-          index: 1
+          index: 1,
+          size: 8
         }
       }],
       ["inputA-2", {
         subtype: "logicInput",
         logicPinData: {
           interface: "inputA",
-          index: 2
+          index: 2,
+          size: 8
         }
       }],
       ["inputA-3", {
         subtype: "logicInput",
         logicPinData: {
           interface: "inputA",
-          index: 3
+          index: 3,
+          size: 8
         }
       }],
       ["inputA-4", {
         subtype: "logicInput",
         logicPinData: {
           interface: "inputA",
-          index: 4
+          index: 4,
+          size: 8
         }
       }],
       ["inputA-5", {
         subtype: "logicInput",
         logicPinData: {
           interface: "inputA",
-          index: 5
+          index: 5,
+          size: 8
         }
       }],
       ["inputA-6", {
         subtype: "logicInput",
         logicPinData: {
           interface: "inputA",
-          index: 6
+          index: 6,
+          size: 8
         }
       }],
       ["inputA-7", {
         subtype: "logicInput",
         logicPinData: {
           interface: "inputA",
-          index: 7
+          index: 7,
+          size: 8
         }
       }],
       ["inputB-0", {
         subtype: "logicInput",
         logicPinData: {
           interface: "inputB",
-          index: 0
+          index: 0,
+          size: 8
         }
       }],
       ["inputB-1", {
         subtype: "logicInput",
         logicPinData: {
           interface: "inputB",
-          index: 1
+          index: 1,
+          size: 8
         }
       }],
       ["inputB-2", {
         subtype: "logicInput",
         logicPinData: {
           interface: "inputB",
-          index: 2
+          index: 2,
+          size: 8
         }
       }],
       ["inputB-3", {
         subtype: "logicInput",
         logicPinData: {
           interface: "inputB",
-          index: 3
+          index: 3,
+          size: 8
         }
       }],
       ["inputB-4", {
         subtype: "logicInput",
         logicPinData: {
           interface: "inputB",
-          index: 4
+          index: 4,
+          size: 8
         }
       }],
       ["inputB-5", {
         subtype: "logicInput",
         logicPinData: {
           interface: "inputB",
-          index: 5
+          index: 5,
+          size: 8
         }
       }],
       ["inputB-6", {
         subtype: "logicInput",
         logicPinData: {
           interface: "inputB",
-          index: 6
+          index: 6,
+          size: 8
         }
       }],
       ["inputB-7", {
         subtype: "logicInput",
         logicPinData: {
           interface: "inputB",
-          index: 7
+          index: 7,
+          size: 8
         }
       }],
       ["sum-0", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "sum",
-          index: 0
+          index: 0,
+          size: 8
         }
       }],
       ["sum-1", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "sum",
-          index: 1
+          index: 1,
+          size: 8
         }
       }],
       ["sum-2", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "sum",
-          index: 2
+          index: 2,
+          size: 8
         }
       }],
       ["sum-3", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "sum",
-          index: 3
+          index: 3,
+          size: 8
         }
       }],
       ["sum-4", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "sum",
-          index: 4
+          index: 4,
+          size: 8
         }
       }],
       ["sum-5", {
         subtype: "logicOutput",
         logicPinData: {
-          interface: "sum",
-          index: 5
+          interface: "sum",
+          index: 5,
+          size: 8
+        }
+      }],
+      ["sum-6", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "sum",
+          index: 6,
+          size: 8
+        }
+      }],
+      ["sum-7", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "sum",
+          index: 7,
+          size: 8
+        }
+      }],
+      ["carryOut", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "carryOut",
+          index: 0,
+          size: 1
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: h.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["transitionSpan", "4"],
+      ["initializationOrder", ""]
+    ])
+  },
+  [c.EightBitOnesComplement]: {
+    id: c.EightBitOnesComplement,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: h.Voltage
+      }],
+      ["invert", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "invert",
+          index: 0,
+          size: 1
+        }
+      }],
+      ["input-0", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 0,
+          size: 8
+        }
+      }],
+      ["input-1", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 1,
+          size: 8
+        }
+      }],
+      ["input-2", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 2,
+          size: 8
+        }
+      }],
+      ["input-3", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 3,
+          size: 8
+        }
+      }],
+      ["input-4", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 4,
+          size: 8
+        }
+      }],
+      ["input-5", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 5,
+          size: 8
+        }
+      }],
+      ["input-6", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 6,
+          size: 8
+        }
+      }],
+      ["input-7", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 7,
+          size: 8
+        }
+      }],
+      ["output-0", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0,
+          size: 8
+        }
+      }],
+      ["output-1", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 1,
+          size: 8
+        }
+      }],
+      ["output-2", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 2,
+          size: 8
+        }
+      }],
+      ["output-3", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 3,
+          size: 8
+        }
+      }],
+      ["output-4", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 4,
+          size: 8
+        }
+      }],
+      ["output-5", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 5,
+          size: 8
+        }
+      }],
+      ["output-6", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 6,
+          size: 8
+        }
+      }],
+      ["output-7", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 7,
+          size: 8
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: h.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["transitionSpan", "3"],
+      ["initializationOrder", ""]
+    ])
+  },
+  [c.OneInput]: {
+    id: c.OneInput,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: h.Voltage
+      }],
+      ["output-0", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0,
+          size: 1
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: h.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["initialState", "0"],
+      ["transitionSpan", "1"],
+      ["size", "1"]
+    ])
+  },
+  [c.TwoInput]: {
+    id: c.TwoInput,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: h.Voltage
+      }],
+      ["output-0", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0,
+          size: 2
+        }
+      }],
+      ["output-1", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 1,
+          size: 2
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: h.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["initialState", "0"],
+      ["transitionSpan", "1"],
+      ["size", "1"]
+    ])
+  },
+  [c.FourInput]: {
+    id: c.FourInput,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: h.Voltage
+      }],
+      ["output-0", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0,
+          size: 4
+        }
+      }],
+      ["output-1", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 1,
+          size: 4
+        }
+      }],
+      ["output-2", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 2,
+          size: 4
+        }
+      }],
+      ["output-3", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 3,
+          size: 4
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: h.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["initialState", "0"],
+      ["transitionSpan", "1"],
+      ["size", "1"]
+    ])
+  },
+  [c.EightInput]: {
+    id: c.EightInput,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: h.Voltage
+      }],
+      ["output-0", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0,
+          size: 8
+        }
+      }],
+      ["output-1", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 1,
+          size: 8
+        }
+      }],
+      ["output-2", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 2,
+          size: 8
+        }
+      }],
+      ["output-3", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 3,
+          size: 8
+        }
+      }],
+      ["output-4", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 4,
+          size: 8
+        }
+      }],
+      ["output-5", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 5,
+          size: 8
+        }
+      }],
+      ["output-6", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 6,
+          size: 8
+        }
+      }],
+      ["output-7", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 7,
+          size: 8
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: h.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["initialState", "00"],
+      ["transitionSpan", "1"],
+      ["size", "1"]
+    ])
+  },
+  [c.OneLight]: {
+    id: c.OneLight,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: h.Voltage
+      }],
+      ["input-0", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 0,
+          size: 1
+        }
+      }],
+      ["output-0", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0,
+          size: 1
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: h.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([["transitionSpan", "2"], ["size", "1"]])
+  },
+  [c.TwoLight]: {
+    id: c.TwoLight,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: h.Voltage
+      }],
+      ["input-0", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 0,
+          size: 2
+        }
+      }],
+      ["input-1", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 1,
+          size: 2
+        }
+      }],
+      ["output-0", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0,
+          size: 2
+        }
+      }],
+      ["output-1", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 1,
+          size: 2
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: h.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([["transitionSpan", "2"], ["size", "1"]])
+  },
+  [c.FourLight]: {
+    id: c.FourLight,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: h.Voltage
+      }],
+      ["input-0", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 0,
+          size: 4
+        }
+      }],
+      ["input-1", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 1,
+          size: 4
+        }
+      }],
+      ["input-2", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 2,
+          size: 4
+        }
+      }],
+      ["input-3", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 3,
+          size: 4
+        }
+      }],
+      ["output-0", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0,
+          size: 4
         }
       }],
-      ["sum-6", {
+      ["output-1", {
         subtype: "logicOutput",
         logicPinData: {
-          interface: "sum",
-          index: 6
+          interface: "output",
+          index: 1,
+          size: 4
         }
       }],
-      ["sum-7", {
+      ["output-2", {
         subtype: "logicOutput",
         logicPinData: {
-          interface: "sum",
-          index: 7
+          interface: "output",
+          index: 2,
+          size: 4
         }
       }],
-      ["carryOut", {
+      ["output-3", {
         subtype: "logicOutput",
         logicPinData: {
-          interface: "carryOut",
-          index: 0
+          interface: "output",
+          index: 3,
+          size: 4
         }
       }],
       ["gnd", {
         subtype: "gnd",
-        sourceType: g.Current
+        sourceType: h.Current
       }]
     ]),
-    config: /* @__PURE__ */ new Map([
-      ["defaultLogicFamily", "CMOS1"],
-      ["transitionSpan", "4"],
-      ["initializationOrder", ""]
-    ])
+    config: /* @__PURE__ */ new Map([["transitionSpan", "2"], ["size", "1"]])
   },
-  [u.EightBitOnesComplement]: {
-    id: u.EightBitOnesComplement,
+  [c.EightLight]: {
+    id: c.EightLight,
     pins: /* @__PURE__ */ new Map([
       ["vcc", {
         subtype: "vcc",
-        sourceType: g.Voltage
-      }],
-      ["invert", {
-        subtype: "logicInput",
-        logicPinData: {
-          interface: "invert",
-          index: 0
-        }
+        sourceType: h.Voltage
       }],
       ["input-0", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 0
+          index: 0,
+          size: 8
         }
       }],
       ["input-1", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 1
+          index: 1,
+          size: 8
         }
       }],
       ["input-2", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 2
+          index: 2,
+          size: 8
         }
       }],
       ["input-3", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 3
+          index: 3,
+          size: 8
         }
       }],
       ["input-4", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 4
+          index: 4,
+          size: 8
         }
       }],
       ["input-5", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 5
+          index: 5,
+          size: 8
         }
       }],
       ["input-6", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 6
+          index: 6,
+          size: 8
         }
       }],
       ["input-7", {
         subtype: "logicInput",
         logicPinData: {
           interface: "input",
-          index: 7
+          index: 7,
+          size: 8
         }
       }],
       ["output-0", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 0
+          index: 0,
+          size: 8
         }
       }],
       ["output-1", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 1
+          index: 1,
+          size: 8
         }
       }],
       ["output-2", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 2
+          index: 2,
+          size: 8
         }
       }],
       ["output-3", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 3
+          index: 3,
+          size: 8
         }
       }],
       ["output-4", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 4
+          index: 4,
+          size: 8
         }
       }],
       ["output-5", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 5
+          index: 5,
+          size: 8
         }
       }],
       ["output-6", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 6
+          index: 6,
+          size: 8
         }
       }],
       ["output-7", {
         subtype: "logicOutput",
         logicPinData: {
           interface: "output",
-          index: 7
+          index: 7,
+          size: 8
         }
       }],
       ["gnd", {
         subtype: "gnd",
-        sourceType: g.Current
+        sourceType: h.Current
       }]
     ]),
-    config: /* @__PURE__ */ new Map([
-      ["defaultLogicFamily", "CMOS1"],
-      ["transitionSpan", "3"],
-      ["initializationOrder", ""]
-    ])
+    config: /* @__PURE__ */ new Map([["transitionSpan", "2"], ["size", "1"]])
   }
-}, L = class tt {
+}, $ = class at {
   id;
   type;
   component;
@@ -1291,11 +1885,12 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
   wires;
   source;
   subtype;
-  constructor(t, n, i, s, r = void 0, a = "free") {
-    this.id = $(), this.type = t, this.component = n, this.pinLabel = i, this.position = s, this.wires = /* @__PURE__ */ new Set(), this.source = r, this.subtype = a;
+  logicMetadata;
+  constructor(t, n, i, s, r = void 0, a = "free", o) {
+    this.id = J(), this.type = t, this.component = n, this.pinLabel = i, this.position = s, this.wires = /* @__PURE__ */ new Set(), this.source = r, this.subtype = a, this.logicMetadata = o;
   }
   getPosition(t) {
-    if (this.type === P.Pin) {
+    if (this.type === w.Pin) {
       if (!this.component) throw new Error("Pin node missing component reference");
       const n = t.getComponent(this.component);
       if (!n) throw new Error(`Component ${this.component} not found for pin node ${this.id}`);
@@ -1325,12 +1920,13 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       id: this.id,
       type: this.type,
       source: this.source || null,
-      subtype: this.subtype
+      subtype: this.subtype,
+      logicMetadata: this.logicMetadata || null
     };
-    return this.type === P.Pin ? (t.component = this.component || null, t.pinLabel = this.pinLabel || null) : t.position = this.position?.toJSON() || null, t;
+    return this.type === w.Pin ? (t.component = this.component || null, t.pinLabel = this.pinLabel || null) : t.position = this.position?.toJSON() || null, t;
   }
   static fromJSON(t) {
-    const n = t.position ? V.fromJSON(t.position) : void 0, i = new tt(t.type, t.component || void 0, t.pinLabel || void 0, n, t.source || void 0, t.subtype ?? "free");
+    const n = t.position ? H.fromJSON(t.position) : void 0, i = new at(t.type, t.component || void 0, t.pinLabel || void 0, n, t.source || void 0, t.subtype ?? "free", t.logicMetadata || void 0);
     return Object.defineProperty(i, "id", {
       value: t.id,
       writable: !1,
@@ -1338,13 +1934,13 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       configurable: !1
     }), i;
   }
-}, E = class et {
+}, N = class ot {
   id;
   node1;
   node2;
   intermediatePositions;
   constructor(t, n, i = []) {
-    this.id = $(), this.node1 = t, this.node2 = n, this.intermediatePositions = i;
+    this.id = J(), this.node1 = t, this.node2 = n, this.intermediatePositions = i;
   }
   isStraightLine() {
     return this.intermediatePositions.length === 0;
@@ -1358,7 +1954,7 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
     };
   }
   static fromJSON(t) {
-    const n = t.intermediatePositions.map((s) => V.fromJSON(s)), i = new et(t.node1, t.node2, n);
+    const n = t.intermediatePositions.map((s) => H.fromJSON(s)), i = new ot(t.node1, t.node2, n);
     return Object.defineProperty(i, "id", {
       value: t.id,
       writable: !1,
@@ -1366,7 +1962,7 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       configurable: !1
     }), i;
   }
-}, z = class it {
+}, Q = class ut {
   id;
   type;
   position;
@@ -1375,8 +1971,8 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
   config;
   editable;
   constructor(t, n, i, s, r = !0) {
-    if (this.id = $(), this.type = t, this.position = n, this.rotation = i, new Set(s).size !== s.length) {
-      const a = s.filter((o, c) => s.indexOf(o) !== c);
+    if (this.id = J(), this.type = t, this.position = n, this.rotation = i, new Set(s).size !== s.length) {
+      const a = s.filter((o, u) => s.indexOf(o) !== u);
       throw new Error(`Duplicate pin names are not allowed: ${[...new Set(a)].join(", ")}`);
     }
     this.pins = s, this.config = new Map(I[t].config), this.editable = r;
@@ -1392,6 +1988,22 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
     if (n)
       return I[this.type].pins.get(n);
   }
+  getPinIdByInterface(t, n) {
+    let i = 0;
+    for (const s of I[this.type].pins.values()) {
+      const r = s.logicPinData;
+      if (r && r.interface === t && r.index === n) return this.pins[i];
+      i++;
+    }
+  }
+  getInterfaceMaxIndex(t) {
+    let n = -1;
+    for (const i of I[this.type].pins.values()) {
+      const s = i.logicPinData;
+      s?.interface === t && s.index > n && (n = s.index);
+    }
+    return n;
+  }
   setAllParameters(t) {
     this.config = new Map(t);
   }
@@ -1426,7 +2038,7 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
     };
   }
   static fromJSON(t) {
-    const n = new it(t.type, V.fromJSON(t.position), yt.fromJSON(t.rotation), t.pins, t.editable);
+    const n = new ut(t.type, H.fromJSON(t.position), mt.fromJSON(t.rotation), t.pins, t.editable);
     return n.config = new Map(Object.entries(t.config)), Object.defineProperty(n, "id", {
       value: t.id,
       writable: !1,
@@ -1434,8 +2046,8 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
       configurable: !1
     }), n;
   }
-}, H = class nt {
-  constructor(t = "Untitled Circuit", n = j) {
+}, q = class ct {
+  constructor(t = "Untitled Circuit", n = rt) {
     this.name = t, this.defaultLogicFamily = n;
   }
   toJSON() {
@@ -1445,9 +2057,9 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
     };
   }
   static fromJSON(t) {
-    return new nt(t.name, t.defaultLogicFamily);
+    return new ct(t.name, t.defaultLogicFamily);
   }
-}, F = class st {
+}, K = class pt {
   constructor(t, n, i, s, r) {
     if (this.version = t, this.options = n, this.size = i, this.divisions = s, this.cameraOptions = r, !Number.isInteger(i) || !Number.isInteger(s)) throw new TypeError(`Size and divisions must be integers (got size=${i}, divisions=${s})`);
   }
@@ -1461,104 +2073,104 @@ var Z = "0.0.11", g = /* @__PURE__ */ (function(e) {
     };
   }
   static fromJSON(t) {
-    t.version !== "0.0.11" && console.warn(`This version of the engine supports v${Z} circuit version files. 
+    t.version !== "0.0.14" && console.warn(`This version of the engine supports v${st} circuit version files. 
       Unexpected behavior may occurs loading v${t.version}.`);
-    const n = t.options ? H.fromJSON(t.options) : new H("Untitled Circuit", j);
-    return new st(t.version, n, t.size, t.divisions, Q.fromJSON(t.cameraOptions));
+    const n = t.options ? q.fromJSON(t.options) : new q("Untitled Circuit", rt);
+    return new pt(t.version, n, t.size, t.divisions, tt.fromJSON(t.cameraOptions));
   }
   toString() {
     return `CircuitMetadata(${this.version}, ${this.options.name}, ${this.options.defaultLogicFamily}, ${this.size}, ${this.divisions}, ${this.cameraOptions.toString()})`;
   }
-}, vt = {
+}, bt = {
   2: 1,
   4: 1,
   8: 2,
   16: 2
-}, St = {
+}, Ct = {
   2: 2,
   4: 2,
   8: 3,
   16: 3
-}, wt = {
+}, Pt = {
   2: 1,
   4: 2,
   8: 2,
   16: 3
-}, mt = {
+}, xt = {
   2: 2,
   4: 3,
   8: 3,
   16: 4
 };
-function bt(e) {
+function It(e) {
   const t = e.config.get("defaultLogicFamily");
-  if (!(!t || t === "Sandbox") && Ct(e.type)) {
-    const n = e.config.get("activationLogic") ?? "negative", i = Pt(e.type, n);
-    return i && xt(t, i.gateFamily, i.inputCount) || void 0;
+  if (!(!t || t === "Sandbox") && Tt(e.type)) {
+    const n = e.config.get("activationLogic") ?? "negative", i = Ot(e.type, n);
+    return i && Et(t, i.gateFamily, i.inputCount) || void 0;
   }
 }
-function Ct(e) {
+function Tt(e) {
   return [
-    u.Inverter,
-    u.NandGate,
-    u.Nand4Gate,
-    u.Nand8Gate,
-    u.NorGate,
-    u.Nor4Gate,
-    u.Nor8Gate,
-    u.XorGate,
-    u.Xor4Gate,
-    u.Xor8Gate
+    c.Inverter,
+    c.NandGate,
+    c.Nand4Gate,
+    c.Nand8Gate,
+    c.NorGate,
+    c.Nor4Gate,
+    c.Nor8Gate,
+    c.XorGate,
+    c.Xor4Gate,
+    c.Xor8Gate
   ].includes(e);
 }
-function Pt(e, t) {
+function Ot(e, t) {
   switch (e) {
-    case u.Inverter:
+    case c.Inverter:
       return {
         gateFamily: t === "negative" ? "NOT" : "Buffer",
         inputCount: 1
       };
-    case u.NandGate:
+    case c.NandGate:
       return {
         gateFamily: t === "negative" ? "NAND" : "AND",
         inputCount: 2
       };
-    case u.Nand4Gate:
+    case c.Nand4Gate:
       return {
         gateFamily: t === "negative" ? "NAND" : "AND",
         inputCount: 4
       };
-    case u.Nand8Gate:
+    case c.Nand8Gate:
       return {
         gateFamily: t === "negative" ? "NAND" : "AND",
         inputCount: 8
       };
-    case u.NorGate:
+    case c.NorGate:
       return {
         gateFamily: t === "negative" ? "NOR" : "OR",
         inputCount: 2
       };
-    case u.Nor4Gate:
+    case c.Nor4Gate:
       return {
         gateFamily: t === "negative" ? "NOR" : "OR",
         inputCount: 4
       };
-    case u.Nor8Gate:
+    case c.Nor8Gate:
       return {
         gateFamily: t === "negative" ? "NOR" : "OR",
         inputCount: 8
       };
-    case u.XorGate:
+    case c.XorGate:
       return {
         gateFamily: t === "negative" ? "XNOR" : "XOR",
         inputCount: 2
       };
-    case u.Xor4Gate:
+    case c.Xor4Gate:
       return {
         gateFamily: t === "negative" ? "XNOR" : "XOR",
         inputCount: 4
       };
-    case u.Xor8Gate:
+    case c.Xor8Gate:
       return {
         gateFamily: t === "negative" ? "XNOR" : "XOR",
         inputCount: 8
@@ -1567,7 +2179,7 @@ function Pt(e, t) {
       return null;
   }
 }
-function xt(e, t, n) {
+function Et(e, t, n) {
   if (e === "Sandbox") throw new Error("computeGateDelay must not be called for Sandbox family");
   if (t === "NOT") return 1;
   if (t === "Buffer") return 2;
@@ -1590,16 +2202,16 @@ function xt(e, t, n) {
     let i;
     switch (t) {
       case "NAND":
-        i = vt;
+        i = bt;
         break;
       case "AND":
-        i = St;
+        i = Ct;
         break;
       case "NOR":
-        i = wt;
+        i = Pt;
         break;
       case "OR":
-        i = mt;
+        i = xt;
         break;
     }
     const s = i[n];
@@ -1608,13 +2220,13 @@ function xt(e, t, n) {
   }
   throw new Error(`Unsupported logic family: ${e}`);
 }
-var me = class rt {
+var $e = class lt {
   metadata;
   components;
   enodes;
   wires;
   constructor(t) {
-    this.metadata = new F(Z, t, 10, 10, new Q()), this.components = /* @__PURE__ */ new Map(), this.enodes = /* @__PURE__ */ new Map(), this.wires = /* @__PURE__ */ new Map();
+    this.metadata = new K(st, t, 10, 10, new tt()), this.components = /* @__PURE__ */ new Map(), this.enodes = /* @__PURE__ */ new Map(), this.wires = /* @__PURE__ */ new Map();
   }
   get name() {
     return this.metadata.options.name;
@@ -1624,13 +2236,13 @@ var me = class rt {
     this.metadata.options.name = t;
   }
   addComponent(t, n, i, s) {
-    const r = I[t], a = new z(t, n, i, []);
-    if (s) for (const [c, p] of s) a.config.set(c, p);
+    const r = I[t], a = new Q(t, n, i, []);
+    if (s) for (const [u, l] of s) a.config.set(u, l);
     a.config.has("defaultLogicFamily") && !a.config.get("defaultLogicFamily") && a.config.set("defaultLogicFamily", this.metadata.options.defaultLogicFamily), this.resolveTransitionSpan(a);
     const o = [];
-    for (const [c, p] of r.pins) {
-      const l = new L(P.Pin, a.id, c, void 0, p.sourceType, p.subtype);
-      this.enodes.set(l.id, l), o.push(l.id);
+    for (const [u, l] of r.pins) {
+      const p = new $(w.Pin, a.id, u, void 0, l.sourceType, l.subtype, l.logicPinData);
+      this.enodes.set(p.id, p), o.push(p.id);
     }
     return Object.defineProperty(a, "pins", {
       value: o,
@@ -1641,7 +2253,7 @@ var me = class rt {
   }
   resolveTransitionSpan(t) {
     if (!t.config.has("transitionSpan")) return;
-    const n = bt(t);
+    const n = It(t);
     n && t.config.set("transitionSpan", String(n));
   }
   removeComponent(t) {
@@ -1652,8 +2264,8 @@ var me = class rt {
       const a = this.enodes.get(r);
       if (a) {
         const o = Array.from(a.wires);
-        for (const c of o)
-          this.removeWire(c), i.push(c);
+        for (const u of o)
+          this.removeWire(u), i.push(u);
       }
       this.enodes.delete(r), s.push(r);
     }
@@ -1686,13 +2298,13 @@ var me = class rt {
     return Array.from(this.enodes.values());
   }
   addBranchingPoint(t, n) {
-    const i = new L(P.BranchingPoint, void 0, void 0, t, n);
+    const i = new $(w.BranchingPoint, void 0, void 0, t, n, void 0, void 0);
     return this.enodes.set(i.id, i), i;
   }
   removeBranchingPoint(t) {
     const n = this.enodes.get(t);
     if (!n) throw new Error(`Enode ${t} does not exist`);
-    if (n.type !== P.BranchingPoint) throw new Error(`Enode ${t} is not a branching point, it must be removed with its component.`);
+    if (n.type !== w.BranchingPoint) throw new Error(`Enode ${t} is not a branching point, it must be removed with its component.`);
     const i = {}, s = this.getWiresByNode(t);
     if (s.length === 1 || s.length > 2) {
       const r = [];
@@ -1700,11 +2312,11 @@ var me = class rt {
         this.removeWire(a.id), r.push(a.id);
       Object.assign(i, { deletedWires: r });
     } else if (s.length === 2) {
-      const r = s[0], a = s[1], o = r.node1 === t ? r.node2 : r.node1, c = a.node1 === t ? a.node2 : a.node1, p = [];
-      o === r.node1 ? p.push(...r.intermediatePositions) : o === r.node2 && p.push(...[...r.intermediatePositions].reverse()), p.push(n.getPosition(this)), c === a.node1 ? p.push(...[...a.intermediatePositions].reverse()) : c === a.node2 && p.push(...a.intermediatePositions), this.removeWire(r.id), this.removeWire(a.id);
-      const l = this.addWire(o, c, p);
-      if (l instanceof Error) throw new Error(`Failed to merge wires at branching point ${t}: ${l.message}`);
-      Object.assign(i, { mergedWires: [r.id, a.id] }), Object.assign(i, { newWire: l });
+      const r = s[0], a = s[1], o = r.node1 === t ? r.node2 : r.node1, u = a.node1 === t ? a.node2 : a.node1, l = [];
+      o === r.node1 ? l.push(...r.intermediatePositions) : o === r.node2 && l.push(...[...r.intermediatePositions].reverse()), l.push(n.getPosition(this)), u === a.node1 ? l.push(...[...a.intermediatePositions].reverse()) : u === a.node2 && l.push(...a.intermediatePositions), this.removeWire(r.id), this.removeWire(a.id);
+      const p = this.addWire(o, u, l);
+      if (p instanceof Error) throw new Error(`Failed to merge wires at branching point ${t}: ${p.message}`);
+      Object.assign(i, { mergedWires: [r.id, a.id] }), Object.assign(i, { newWire: p });
     }
     return this.enodes.delete(t), i;
   }
@@ -1713,7 +2325,7 @@ var me = class rt {
     const s = this.enodes.get(t), r = this.enodes.get(n);
     if (!s || !r) return /* @__PURE__ */ new Error("Wire requires at least one existing ENode");
     if (this.hasWireBetween(t, n)) return /* @__PURE__ */ new Error("Duplicate wire between same nodes");
-    const a = new E(t, n, i || []);
+    const a = new N(t, n, i || []);
     return this.wires.set(a.id, a), s.wires.add(a.id), r.wires.add(a.id), a;
   }
   removeWire(t) {
@@ -1731,24 +2343,24 @@ var me = class rt {
       r.getPosition(this),
       ...s.intermediatePositions,
       a.getPosition(this)
-    ], c = ht(o, n), p = o.slice(1, c), l = o.slice(c, o.length - 1);
+    ], u = vt(o, n), l = o.slice(1, u), p = o.slice(u, o.length - 1);
     this.wires.delete(t), r.wires.delete(t), a.wires.delete(t);
     let d;
     if (i) if (this.enodes.get(i)) d = this.enodes.get(i);
     else throw new Error(`Target ENode ${i} does not exist`);
     else d = this.addBranchingPoint(n);
-    const y = [];
+    const g = [];
     if ((!d.component || r.component !== d.component) && !this.hasWireBetween(r.id, d.id)) {
-      const f = this.addWire(r.id, d.id, p);
-      f instanceof E ? (this.simplifyWireIntermediatePositions(f.id), y.push(f)) : console.warn(`Failure to create wire at split : ${f.message}`);
+      const f = this.addWire(r.id, d.id, l);
+      f instanceof N ? (this.simplifyWireIntermediatePositions(f.id), g.push(f)) : console.warn(`Failure to create wire at split : ${f.message}`);
     }
     if ((!d.component || a.component !== d.component) && !this.hasWireBetween(a.id, d.id)) {
-      const f = this.addWire(d.id, a.id, l);
-      f instanceof E ? (this.simplifyWireIntermediatePositions(f.id), y.push(f)) : console.warn(`Failure to create wire at split : ${f.message}`);
+      const f = this.addWire(d.id, a.id, p);
+      f instanceof N ? (this.simplifyWireIntermediatePositions(f.id), g.push(f)) : console.warn(`Failure to create wire at split : ${f.message}`);
     }
     return {
       branchingPoint: d,
-      wires: y
+      wires: g
     };
   }
   getWireBetweenNodes(t, n) {
@@ -1810,9 +2422,9 @@ var me = class rt {
     let i = 0;
     const s = I[t.type], r = Array.from(s.pins.keys());
     for (const a of t.pins) {
-      const o = this.enodes.get(a), c = r[i];
-      if (c) {
-        if (o && c === n) return o;
+      const o = this.enodes.get(a), u = r[i];
+      if (u) {
+        if (o && u === n) return o;
         i++;
       }
     }
@@ -1821,7 +2433,7 @@ var me = class rt {
     const s = this.wires.get(t);
     if (!s) throw new Error(`Wire ${t} does not exist`);
     if (i) {
-      const r = M([
+      const r = V([
         this.enodes.get(s.node1).getPosition(this),
         ...n,
         this.enodes.get(s.node2).getPosition(this)
@@ -1833,12 +2445,12 @@ var me = class rt {
   simplifyWireIntermediatePositions(t) {
     const n = this.wires.get(t);
     if (!n) throw new Error(`Wire ${t} does not exist`);
-    const i = M([
+    const i = V([
       this.enodes.get(n.node1).getPosition(this),
       ...n.intermediatePositions,
       this.enodes.get(n.node2).getPosition(this)
     ], 5);
-    return n.intermediatePositions = i.slice(1, i.length - 1), n.intermediatePositions = M(n.intermediatePositions), n;
+    return n.intermediatePositions = i.slice(1, i.length - 1), n.intermediatePositions = V(n.intermediatePositions), n;
   }
   updateENodeSourceType(t, n) {
     const i = this.enodes.get(t);
@@ -1849,7 +2461,7 @@ var me = class rt {
     let n = 0;
     for (const i of this.components.values()) n = Math.max(n, Math.abs(i.position.x), Math.abs(i.position.y));
     for (const i of this.enodes.values()) {
-      if (i.type === P.Pin) continue;
+      if (i.type === w.Pin) continue;
       const s = i.position;
       s && (n = Math.max(n, Math.abs(s.x), Math.abs(s.y)));
     }
@@ -1865,41 +2477,166 @@ var me = class rt {
     };
   }
   static fromJSON(t) {
-    const n = F.fromJSON(t.metadata), i = new rt(n.options);
+    const n = K.fromJSON(t.metadata), i = new lt(n.options);
     i.metadata = n;
     for (const s of t.components) {
-      const r = z.fromJSON(s);
+      const r = Q.fromJSON(s);
       i.components.set(r.id, r);
     }
     for (const s of t.enodes) {
-      const r = L.fromJSON(s);
+      const r = $.fromJSON(s);
       i.enodes.set(r.id, r);
     }
     if (t.wires) for (const s of t.wires) {
-      const r = E.fromJSON(s);
+      const r = N.fromJSON(s);
       i.wires.set(r.id, r);
       const a = i.enodes.get(r.node1), o = i.enodes.get(r.node2);
       a && a.wires.add(r.id), o && o.wires.add(r.id);
     }
     return i;
   }
-}, be = {
+};
+function We(e, t) {
+  const n = /* @__PURE__ */ new Map(), i = e.getENode(t);
+  if (!i || i.type !== w.BranchingPoint) return n;
+  const s = /* @__PURE__ */ new Set([t]), r = [{
+    id: t,
+    edges: 0
+  }];
+  for (; r.length > 0; ) {
+    const { id: a, edges: o } = r.shift();
+    for (const u of e.getWiresByNode(a)) {
+      const l = u.node1 === a ? u.node2 : u.node1, p = e.getENode(l);
+      if (!p) continue;
+      const d = o + 1;
+      if (p.type === w.Pin) {
+        const g = d, f = n.get(l);
+        (f === void 0 || g < f) && n.set(l, g);
+        continue;
+      }
+      s.has(l) || (s.add(l), r.push({
+        id: l,
+        edges: d
+      }));
+    }
+  }
+  return n;
+}
+function Re(e, t) {
+  const n = /* @__PURE__ */ new Map(), i = e.getENode(t);
+  if (!i || i.type !== w.BranchingPoint) return n;
+  const s = /* @__PURE__ */ new Set([t]), r = [{
+    id: t,
+    edges: 0,
+    parent: t
+  }];
+  for (; r.length > 0; ) {
+    const { id: a, edges: o } = r.shift();
+    for (const u of e.getWiresByNode(a)) {
+      const l = u.node1 === a ? u.node2 : u.node1, p = e.getENode(l);
+      if (!p) continue;
+      const d = o + 1;
+      if (p.type === w.Pin) {
+        const g = d, f = n.get(l);
+        (f === void 0 || g < f.Dl) && n.set(l, {
+          Dl: g,
+          predecessor: a
+        });
+        continue;
+      }
+      s.has(l) || (s.add(l), r.push({
+        id: l,
+        edges: d,
+        parent: a
+      }));
+    }
+  }
+  return n;
+}
+function Fe(e, t, n) {
+  if (n <= 0) return [];
+  const i = e.getENode(t);
+  if (!i || i.type !== w.Pin) return [];
+  const s = n, r = [], a = /* @__PURE__ */ new Set([t]), o = [{
+    id: t,
+    edges: 0
+  }];
+  for (; o.length > 0; ) {
+    const { id: u, edges: l } = o.shift();
+    if (!(l > s))
+      for (const p of e.getWiresByNode(u)) {
+        const d = p.node1 === u ? p.node2 : p.node1;
+        if (a.has(d)) continue;
+        const g = e.getENode(d);
+        if (!g) continue;
+        const f = l + 1;
+        if (g.type !== w.Pin) {
+          if (a.add(d), f === s) {
+            r.push(d);
+            continue;
+          }
+          o.push({
+            id: d,
+            edges: f
+          });
+        }
+      }
+  }
+  return r;
+}
+function He(e, t, n) {
+  if (n <= 0) return [];
+  const i = e.getENode(t);
+  if (!i || i.type !== w.Pin) return [];
+  const s = n, r = [], a = /* @__PURE__ */ new Set([t]), o = [{
+    id: t,
+    edges: 0,
+    parent: t
+  }];
+  for (; o.length > 0; ) {
+    const { id: u, edges: l } = o.shift();
+    if (!(l > s))
+      for (const p of e.getWiresByNode(u)) {
+        const d = p.node1 === u ? p.node2 : p.node1;
+        if (a.has(d)) continue;
+        const g = e.getENode(d);
+        if (!g) continue;
+        const f = l + 1;
+        if (g.type !== w.Pin) {
+          if (a.add(d), f === s) {
+            r.push({
+              id: d,
+              predecessor: u
+            });
+            continue;
+          }
+          o.push({
+            id: d,
+            edges: f,
+            parent: u
+          });
+        }
+      }
+  }
+  return r;
+}
+var Je = {
   MIN_TPS: 1,
   MAX_TPS: 100,
   DEFAULT_TPS: 3,
   DEFAULT_INTERVAL_MS: 500
-}, at = {
+}, dt = {
   TRANSITION_SPAN_TICKS: 1,
   TRANSITION_USER_SPAN_MS: 200
 };
-function T(...e) {
+function O(...e) {
   return {
     hasVoltage: e.some((t) => t.hasVoltage),
     hasCurrent: e.some((t) => t.hasCurrent),
     locked: !1
   };
 }
-var J = class ot {
+var Y = class ht {
   tick;
   nodeStates;
   wireStates;
@@ -1912,7 +2649,7 @@ var J = class ot {
     this.tick = t;
   }
   clone() {
-    const t = new ot(this.tick), n = /* @__PURE__ */ new Map();
+    const t = new ht(this.tick), n = /* @__PURE__ */ new Map();
     for (const [r, a] of this.nodeStates.entries()) n.set(r, { ...a });
     const i = /* @__PURE__ */ new Map();
     for (const [r, a] of this.wireStates.entries()) i.set(r, { ...a });
@@ -1935,7 +2672,7 @@ var J = class ot {
       enumerable: !0
     }), t;
   }
-}, b = class {
+}, m = class {
   componentId;
   _state;
   _startTick;
@@ -1967,26 +2704,26 @@ var J = class ot {
   setNextState(e, t) {
     this._nextState = e, this._expirationTick = t;
   }
-}, It = class extends b {
+}, Dt = class extends m {
   constructor(e) {
     super(e, "on");
   }
-}, Tt = class extends b {
+}, Nt = class extends m {
   constructor(e, t = "off") {
     super(e, t);
   }
   get isLit() {
     return this.state === "on" || this.state === "goingOn";
   }
-}, ct = class extends b {
+}, gt = class extends m {
   constructor(e, t = "off") {
     super(e, t);
   }
   get isLit() {
     return this.state === "on" || this.state === "goingOn";
   }
-}, Ot = class extends ct {
-}, Et = class extends b {
+}, Mt = class extends gt {
+}, Lt = class extends m {
   constructor(e, t = "open") {
     super(e, t);
   }
@@ -1996,7 +2733,7 @@ var J = class ot {
   get isClosed() {
     return this.state === "closed" || this.state === "closing";
   }
-}, Nt = class extends b {
+}, zt = class extends m {
   constructor(e, t = "open") {
     super(e, t);
   }
@@ -2006,18 +2743,18 @@ var J = class ot {
   get isClosed() {
     return this.state === "closed" || this.state === "closing";
   }
-}, At = class extends b {
+}, Bt = class extends m {
   constructor(e, t = "input1") {
     super(e, t);
   }
   get isInTransition() {
     return this.state === "1to2" || this.state === "2to1";
   }
-}, Bt = class extends b {
+}, At = class extends m {
   constructor(e) {
     super(e, "high");
   }
-}, w = class extends b {
+}, b = class extends m {
   constructor(e, t = "low") {
     super(e, t);
   }
@@ -2027,47 +2764,47 @@ var J = class ot {
   get isHigh() {
     return this.state === "high";
   }
-}, Dt = class extends w {
+}, kt = class extends b {
   constructor(e, t = "low") {
     super(e, t);
   }
-}, Mt = class extends w {
+}, Gt = class extends b {
   constructor(e, t = "low") {
     super(e, t);
   }
-}, Lt = class extends w {
+}, _t = class extends b {
   constructor(e, t = "low") {
     super(e, t);
   }
-}, kt = class extends w {
+}, Vt = class extends b {
   constructor(e, t = "low") {
     super(e, t);
   }
-}, Gt = class extends w {
+}, $t = class extends b {
   constructor(e, t = "low") {
     super(e, t);
   }
-}, _t = class extends w {
+}, Wt = class extends b {
   constructor(e, t = "low") {
     super(e, t);
   }
-}, Vt = class extends w {
+}, Rt = class extends b {
   constructor(e, t = "low") {
     super(e, t);
   }
-}, $t = class extends w {
+}, Ft = class extends b {
   constructor(e, t = "low") {
     super(e, t);
   }
-}, Rt = class extends w {
+}, Ht = class extends b {
   constructor(e, t = "low") {
     super(e, t);
   }
-}, Wt = class extends w {
+}, Jt = class extends b {
   constructor(e, t = "low") {
     super(e, t);
   }
-}, A = class extends b {
+}, L = class extends m {
   outputCount;
   hexDigitCount;
   allLowState;
@@ -2084,7 +2821,7 @@ var J = class ot {
     const t = this.effectiveState;
     return t === "indeterminate" ? !1 : (parseInt(t, 16) >> e & 1) === 1;
   }
-}, zt = class extends A {
+}, Ut = class extends L {
   constructor(e, t = "0") {
     super(e, 2, t);
   }
@@ -2094,7 +2831,7 @@ var J = class ot {
   get carryHigh() {
     return this.isOutputHigh(1);
   }
-}, Ht = class extends A {
+}, Xt = class extends L {
   constructor(e, t = "0") {
     super(e, 2, t);
   }
@@ -2104,7 +2841,7 @@ var J = class ot {
   get carryOutHigh() {
     return this.isOutputHigh(1);
   }
-}, Ft = class extends A {
+}, Qt = class extends L {
   constructor(e, t = "0000") {
     super(e, 16, t);
   }
@@ -2117,7 +2854,7 @@ var J = class ot {
   isCarryOutHigh() {
     return this.isStageCarryHigh(7);
   }
-}, Jt = class extends A {
+}, qt = class extends L {
   constructor(e, t = "000") {
     super(e, 9, t);
   }
@@ -2127,7 +2864,97 @@ var J = class ot {
   isInvertHigh() {
     return this.isOutputHigh(8);
   }
-}, Ce = class {
+}, z = class extends m {
+  outputCount;
+  hexDigitCount;
+  allLowState;
+  constructor(e, t, n) {
+    super(e, n), this.outputCount = t, this.hexDigitCount = Math.ceil(t / 4), this.allLowState = "0".repeat(this.hexDigitCount);
+  }
+  get isInTransition() {
+    return this.state === "moving";
+  }
+  get effectiveState() {
+    return this.isInTransition ? this.parameters.get("prevState") ?? this.allLowState : this.state;
+  }
+  isOutputHigh(e) {
+    const t = this.effectiveState;
+    return (parseInt(t, 16) >> e & 1) === 1;
+  }
+  getPendingMove(e) {
+    const t = this.parameters.get(String(e));
+    if (!t) return null;
+    const n = t.split("-");
+    if (n.length !== 3) return null;
+    const i = parseInt(n[0], 10), s = parseInt(n[1], 10), r = parseInt(n[2], 10);
+    return isNaN(i) || isNaN(s) || isNaN(r) ? null : {
+      target: i === 1 ? 1 : 0,
+      startTick: s,
+      endTick: r
+    };
+  }
+}, Kt = class extends z {
+  constructor(e, t = "0") {
+    super(e, 1, t);
+  }
+}, Yt = class extends z {
+  constructor(e, t = "0") {
+    super(e, 2, t);
+  }
+}, Zt = class extends z {
+  constructor(e, t = "0") {
+    super(e, 4, t);
+  }
+}, jt = class extends z {
+  constructor(e, t = "00") {
+    super(e, 8, t);
+  }
+}, B = class extends m {
+  lightCount;
+  hexDigitCount;
+  allLowState;
+  constructor(e, t, n) {
+    super(e, n), this.lightCount = t, this.hexDigitCount = Math.ceil(t / 4), this.allLowState = "0".repeat(this.hexDigitCount);
+  }
+  get isInTransition() {
+    return this.state === "moving";
+  }
+  get effectiveState() {
+    return this.isInTransition ? this.parameters.get("prevState") ?? this.allLowState : this.state;
+  }
+  isOutputHigh(e) {
+    const t = this.effectiveState;
+    return t === "indeterminate" ? !1 : (parseInt(t, 16) >> e & 1) === 1;
+  }
+  getPendingMove(e) {
+    const t = this.parameters.get(String(e));
+    if (!t) return null;
+    const n = t.split("-");
+    if (n.length !== 3) return null;
+    const i = parseInt(n[0], 10), s = parseInt(n[1], 10), r = parseInt(n[2], 10);
+    return isNaN(i) || isNaN(s) || isNaN(r) ? null : {
+      target: i === 1 ? 1 : 0,
+      startTick: s,
+      endTick: r
+    };
+  }
+}, te = class extends B {
+  constructor(e, t = "0") {
+    super(e, 1, t);
+  }
+}, ee = class extends B {
+  constructor(e, t = "0") {
+    super(e, 2, t);
+  }
+}, ie = class extends B {
+  constructor(e, t = "0") {
+    super(e, 4, t);
+  }
+}, ne = class extends B {
+  constructor(e, t = "00") {
+    super(e, 8, t);
+  }
+}, Ue = class {
   behaviors;
   constructor() {
     this.behaviors = /* @__PURE__ */ new Map();
@@ -2218,17 +3045,17 @@ var J = class ot {
 };
 function x(e) {
   const t = parseInt(e.get("transitionSpan") || "", 10);
-  return isNaN(t) || t < 1 ? at.TRANSITION_SPAN_TICKS : t;
+  return isNaN(t) || t < 1 ? dt.TRANSITION_SPAN_TICKS : t;
 }
-var Ut = class extends C {
+var se = class extends C {
   constructor() {
-    super(u.Battery);
+    super(c.Battery);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for BatteryBehavior: ${e.type}`);
-    return new It(e.id);
+    return new Dt(e.id);
   }
-}, R = class extends C {
+}, U = class extends C {
   getBehavior(e, t, n, i) {
     let s = !1;
     const r = [], a = x(e.config), o = t.expirationTick < 1 ? a : Math.max(i - t.startTick, 1);
@@ -2263,47 +3090,47 @@ var Ut = class extends C {
       scheduledEvents: []
     };
   }
-}, Xt = class extends R {
+}, re = class extends U {
   constructor() {
-    super(u.Lightbulb);
+    super(c.Lightbulb);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for lightbulbBehavior: ${e.type}`);
-    return new Tt(e.id);
+    return new Nt(e.id);
   }
   onPinsChange(e, t, n, i) {
     const s = this.getPinStates(e, n);
     t.pinStates = s;
-    const r = T(s.get("pin1"), s.get("pin2")), a = r.hasVoltage && r.hasCurrent;
+    const r = O(s.get("pin1"), s.get("pin2")), a = r.hasVoltage && r.hasCurrent;
     return this.getBehavior(e, t, a, i);
   }
-}, Qt = class extends R {
+}, ae = class extends U {
   constructor() {
-    super(u.RectangleLED);
+    super(c.RectangleLED);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for RectangleLEDBehavior: ${e.type}`);
-    return new Ot(e.id);
+    return new Mt(e.id);
   }
   onPinsChange(e, t, n, i) {
     const s = this.getPinStates(e, n);
     t.pinStates = s;
-    const r = T(s.get("pin1"), s.get("pin2")), a = r.hasVoltage && r.hasCurrent;
+    const r = O(s.get("pin1"), s.get("pin2")), a = r.hasVoltage && r.hasCurrent;
     return this.getBehavior(e, t, a, i);
   }
 };
-function qt(e) {
+function oe(e) {
   const t = parseInt(e.get("transitionSpan") || "", 10);
-  return isNaN(t) || t < 1 ? at.TRANSITION_SPAN_TICKS : t;
+  return isNaN(t) || t < 1 ? dt.TRANSITION_SPAN_TICKS : t;
 }
-var Kt = class extends C {
+var ue = class extends C {
   constructor() {
-    super(u.Relay);
+    super(c.Relay);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for RelayBehavior: ${e.type}`);
     const t = e.config.get("activationLogic") === "negative" ? "closed" : "open";
-    return new Et(e.id, t);
+    return new Lt(e.id, t);
   }
   allowConductivity(e, t, n, i, s) {
     if (i === s) return !0;
@@ -2314,16 +3141,16 @@ var Kt = class extends C {
   }
   onPinsChange(e, t, n, i) {
     const s = this.getPinStates(e, n);
-    s.set("cmd_in*cmd_out", T(s.get("cmd_in"), s.get("cmd_out"))), s.set("power_in*power_out", T(s.get("power_in"), s.get("power_out")));
+    s.set("cmd_in*cmd_out", O(s.get("cmd_in"), s.get("cmd_out"))), s.set("power_in*power_out", O(s.get("power_in"), s.get("power_out")));
     const r = t.pinStates;
     t.pinStates = s;
-    const a = this.getChangedPins(s, r), o = s.get("cmd_in*cmd_out"), c = o.hasVoltage && o.hasCurrent, p = e.config.get("activationLogic") === "negative" ? !c : c;
-    let l = a.size > 0;
-    const d = [], y = qt(e.config);
-    if (p) {
+    const a = this.getChangedPins(s, r), o = s.get("cmd_in*cmd_out"), u = o.hasVoltage && o.hasCurrent, l = e.config.get("activationLogic") === "negative" ? !u : u;
+    let p = a.size > 0;
+    const d = [], g = oe(e.config);
+    if (l) {
       if (t.state === "open" || t.state === "opening") {
-        let f = t.state === "open" ? y : Math.max(i - t.startTick, 1);
-        l = !0, t.setState("closing", i), t.setNextState("closed", i + f), d.push({
+        let f = t.state === "open" ? g : Math.max(i - t.startTick, 1);
+        p = !0, t.setState("closing", i), t.setNextState("closed", i + f), d.push({
           targetId: e.id,
           scheduledAtTick: t.startTick,
           readyAtTick: t.expirationTick,
@@ -2332,8 +3159,8 @@ var Kt = class extends C {
         });
       }
     } else if (t.state === "closed" || t.state === "closing") {
-      let f = t.state === "closed" ? y : Math.max(i - t.startTick, 1);
-      l = !0, t.setState("opening", i), t.setNextState("open", i + f), d.push({
+      let f = t.state === "closed" ? g : Math.max(i - t.startTick, 1);
+      p = !0, t.setState("opening", i), t.setNextState("open", i + f), d.push({
         targetId: e.id,
         scheduledAtTick: t.startTick,
         readyAtTick: t.expirationTick,
@@ -2343,8 +3170,8 @@ var Kt = class extends C {
     }
     return {
       componentState: t,
-      hasChanged: l,
-      shouldCancelPending: l,
+      hasChanged: p,
+      shouldCancelPending: p,
       scheduledEvents: d
     };
   }
@@ -2357,28 +3184,28 @@ var Kt = class extends C {
       scheduledEvents: []
     };
   }
-}, Yt = class extends R {
+}, ce = class extends U {
   constructor() {
-    super(u.SmallLED);
+    super(c.SmallLED);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for SmallLEDBehavior: ${e.type}`);
-    return new ct(e.id);
+    return new gt(e.id);
   }
   onPinsChange(e, t, n, i) {
     const s = this.getPinStates(e, n);
     t.pinStates = s;
-    const r = T(s.get("pin1"), s.get("pin2")), a = r.hasVoltage && r.hasCurrent;
+    const r = O(s.get("pin1"), s.get("pin2")), a = r.hasVoltage && r.hasCurrent;
     return this.getBehavior(e, t, a, i);
   }
-}, Zt = class extends C {
+}, pe = class extends C {
   constructor() {
-    super(u.Switch);
+    super(c.Switch);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for SwitchBehavior: ${e.type}`);
     const t = e.config.get("initialState") || "open";
-    return new Nt(e.id, t);
+    return new zt(e.id, t);
   }
   allowConductivity(e, t, n, i, s) {
     return t.state === "closed" || t.state === "opening";
@@ -2424,14 +3251,14 @@ var Kt = class extends C {
       scheduledEvents: []
     };
   }
-}, jt = class extends C {
+}, le = class extends C {
   constructor() {
-    super(u.DoubleThrowSwitch);
+    super(c.DoubleThrowSwitch);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for DoubleThrowSwitchBehavior: ${e.type}`);
     const t = e.config.get("initialState") || "input1";
-    return new At(e.id, t);
+    return new Bt(e.id, t);
   }
   allowConductivity(e, t, n, i, s) {
     if (i === s) return !0;
@@ -2481,13 +3308,13 @@ var Kt = class extends C {
       scheduledEvents: []
     };
   }
-}, te = class extends C {
+}, de = class extends C {
   constructor() {
-    super(u.Clock);
+    super(c.Clock);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for ClockBehavior: ${e.type}`);
-    const t = new Bt(e.id), n = e.config.get("startHigh") == "true";
+    const t = new At(e.id), n = e.config.get("startHigh") == "true";
     t.setState(n ? "high" : "low", 0);
     const i = Number(e.config.get("halfPeriod"));
     return t.setNextState(n ? "low" : "high", i), t;
@@ -2535,7 +3362,7 @@ var Kt = class extends C {
       }]
     };
   }
-}, m = class extends C {
+}, P = class extends C {
   vccGuardBehavior(e, t, n) {
     if (t.get("vcc").hasVoltage) return null;
     let i = !1, s = !1;
@@ -2549,15 +3376,15 @@ var Kt = class extends C {
   nonLogicInputGuardBehavior(e, t, n) {
     let i = !1;
     const s = this.typeMetadata.pins;
-    for (const [o, c] of t) {
+    for (const [o, u] of t) {
       if (!s.has(o)) continue;
-      const p = s.get(o);
-      if (p && p?.subtype === "logicInput") {
-        if (c.hasVoltage && c.hasCurrent) {
+      const l = s.get(o);
+      if (l && l?.subtype === "logicInput") {
+        if (u.hasVoltage && u.hasCurrent) {
           i = !0;
           break;
         }
-        if (!c.hasVoltage && !c.hasCurrent) {
+        if (!u.hasVoltage && !u.hasCurrent) {
           i = !0;
           break;
         }
@@ -2647,14 +3474,14 @@ var Kt = class extends C {
       scheduledEvents: []
     };
   }
-}, ee = class extends m {
+}, he = class extends P {
   constructor() {
-    super(u.Inverter);
+    super(c.Inverter);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for InverterBehavior: ${e.type}`);
     const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
-    return new Dt(e.id, t);
+    return new kt(e.id, t);
   }
   onPinsChange(e, t, n, i) {
     const s = this.getPinStates(e, n);
@@ -2663,17 +3490,17 @@ var Kt = class extends C {
     if (r) return r;
     const a = this.nonLogicInputGuardBehavior(t, s, i);
     if (a) return a;
-    const o = s.get("input").hasVoltage, c = e.config.get("activationLogic") === "negative" ? !o : o;
-    return this.getBehavior(e, t, c, i);
+    const o = s.get("input").hasVoltage, u = e.config.get("activationLogic") === "negative" ? !o : o;
+    return this.getBehavior(e, t, u, i);
   }
-}, ie = class extends m {
+}, ge = class extends P {
   constructor() {
-    super(u.NandGate);
+    super(c.NandGate);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for NandGateBehavior: ${e.type}`);
     const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
-    return new Mt(e.id, t);
+    return new Gt(e.id, t);
   }
   onPinsChange(e, t, n, i) {
     const s = this.getPinStates(e, n);
@@ -2682,17 +3509,17 @@ var Kt = class extends C {
     if (r) return r;
     const a = this.nonLogicInputGuardBehavior(t, s, i);
     if (a) return a;
-    const o = s.get("input1").hasVoltage && s.get("input2").hasVoltage, c = e.config.get("activationLogic") === "negative" ? !o : o;
-    return this.getBehavior(e, t, c, i);
+    const o = s.get("input-0").hasVoltage && s.get("input-1").hasVoltage, u = e.config.get("activationLogic") === "negative" ? !o : o;
+    return this.getBehavior(e, t, u, i);
   }
-}, ne = class extends m {
+}, fe = class extends P {
   constructor() {
-    super(u.Nand4Gate);
+    super(c.Nand4Gate);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for Nand4GateBehavior: ${e.type}`);
     const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
-    return new Lt(e.id, t);
+    return new _t(e.id, t);
   }
   onPinsChange(e, t, n, i) {
     const s = this.getPinStates(e, n);
@@ -2701,17 +3528,17 @@ var Kt = class extends C {
     if (r) return r;
     const a = this.nonLogicInputGuardBehavior(t, s, i);
     if (a) return a;
-    const o = s.get("input1").hasVoltage && s.get("input2").hasVoltage && s.get("input3").hasVoltage && s.get("input4").hasVoltage, c = e.config.get("activationLogic") === "negative" ? !o : o;
-    return this.getBehavior(e, t, c, i);
+    const o = s.get("input-0").hasVoltage && s.get("input-1").hasVoltage && s.get("input-2").hasVoltage && s.get("input-3").hasVoltage, u = e.config.get("activationLogic") === "negative" ? !o : o;
+    return this.getBehavior(e, t, u, i);
   }
-}, se = class extends m {
+}, ye = class extends P {
   constructor() {
-    super(u.Nand8Gate);
+    super(c.Nand8Gate);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for Nand8GateBehavior: ${e.type}`);
     const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
-    return new kt(e.id, t);
+    return new Vt(e.id, t);
   }
   onPinsChange(e, t, n, i) {
     const s = this.getPinStates(e, n);
@@ -2720,17 +3547,17 @@ var Kt = class extends C {
     if (r) return r;
     const a = this.nonLogicInputGuardBehavior(t, s, i);
     if (a) return a;
-    const o = s.get("input1").hasVoltage && s.get("input2").hasVoltage && s.get("input3").hasVoltage && s.get("input4").hasVoltage && s.get("input5").hasVoltage && s.get("input6").hasVoltage && s.get("input7").hasVoltage && s.get("input8").hasVoltage, c = e.config.get("activationLogic") === "negative" ? !o : o;
-    return this.getBehavior(e, t, c, i);
+    const o = s.get("input-0").hasVoltage && s.get("input-1").hasVoltage && s.get("input-2").hasVoltage && s.get("input-3").hasVoltage && s.get("input-4").hasVoltage && s.get("input-5").hasVoltage && s.get("input-6").hasVoltage && s.get("input-7").hasVoltage, u = e.config.get("activationLogic") === "negative" ? !o : o;
+    return this.getBehavior(e, t, u, i);
   }
-}, re = class extends m {
+}, ve = class extends P {
   constructor() {
-    super(u.NorGate);
+    super(c.NorGate);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for NorGateBehavior: ${e.type}`);
     const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
-    return new Gt(e.id, t);
+    return new $t(e.id, t);
   }
   onPinsChange(e, t, n, i) {
     const s = this.getPinStates(e, n);
@@ -2739,17 +3566,17 @@ var Kt = class extends C {
     if (r) return r;
     const a = this.nonLogicInputGuardBehavior(t, s, i);
     if (a) return a;
-    const o = s.get("input1").hasVoltage || s.get("input2").hasVoltage, c = e.config.get("activationLogic") === "negative" ? !o : o;
-    return this.getBehavior(e, t, c, i);
+    const o = s.get("input-0").hasVoltage || s.get("input-1").hasVoltage, u = e.config.get("activationLogic") === "negative" ? !o : o;
+    return this.getBehavior(e, t, u, i);
   }
-}, ae = class extends m {
+}, Se = class extends P {
   constructor() {
-    super(u.Nor4Gate);
+    super(c.Nor4Gate);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for Nor4GateBehavior: ${e.type}`);
     const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
-    return new _t(e.id, t);
+    return new Wt(e.id, t);
   }
   onPinsChange(e, t, n, i) {
     const s = this.getPinStates(e, n);
@@ -2758,17 +3585,17 @@ var Kt = class extends C {
     if (r) return r;
     const a = this.nonLogicInputGuardBehavior(t, s, i);
     if (a) return a;
-    const o = s.get("input1").hasVoltage || s.get("input2").hasVoltage || s.get("input3").hasVoltage || s.get("input4").hasVoltage, c = e.config.get("activationLogic") === "negative" ? !o : o;
-    return this.getBehavior(e, t, c, i);
+    const o = s.get("input-0").hasVoltage || s.get("input-1").hasVoltage || s.get("input-2").hasVoltage || s.get("input-3").hasVoltage, u = e.config.get("activationLogic") === "negative" ? !o : o;
+    return this.getBehavior(e, t, u, i);
   }
-}, oe = class extends m {
+}, we = class extends P {
   constructor() {
-    super(u.Nor8Gate);
+    super(c.Nor8Gate);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for Nor8GateBehavior: ${e.type}`);
     const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
-    return new Vt(e.id, t);
+    return new Rt(e.id, t);
   }
   onPinsChange(e, t, n, i) {
     const s = this.getPinStates(e, n);
@@ -2777,17 +3604,17 @@ var Kt = class extends C {
     if (r) return r;
     const a = this.nonLogicInputGuardBehavior(t, s, i);
     if (a) return a;
-    const o = s.get("input1").hasVoltage || s.get("input2").hasVoltage || s.get("input3").hasVoltage || s.get("input4").hasVoltage || s.get("input5").hasVoltage || s.get("input6").hasVoltage || s.get("input7").hasVoltage || s.get("input8").hasVoltage, c = e.config.get("activationLogic") === "negative" ? !o : o;
-    return this.getBehavior(e, t, c, i);
+    const o = s.get("input-0").hasVoltage || s.get("input-1").hasVoltage || s.get("input-2").hasVoltage || s.get("input-3").hasVoltage || s.get("input-4").hasVoltage || s.get("input-5").hasVoltage || s.get("input-6").hasVoltage || s.get("input-7").hasVoltage, u = e.config.get("activationLogic") === "negative" ? !o : o;
+    return this.getBehavior(e, t, u, i);
   }
-}, ce = class extends m {
+}, me = class extends P {
   constructor() {
-    super(u.XorGate);
+    super(c.XorGate);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for XorGateBehavior: ${e.type}`);
     const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
-    return new $t(e.id, t);
+    return new Ft(e.id, t);
   }
   onPinsChange(e, t, n, i) {
     const s = this.getPinStates(e, n);
@@ -2796,17 +3623,17 @@ var Kt = class extends C {
     if (r) return r;
     const a = this.nonLogicInputGuardBehavior(t, s, i);
     if (a) return a;
-    const o = s.get("input1").hasVoltage !== s.get("input2").hasVoltage, c = e.config.get("activationLogic") === "negative" ? !o : o;
-    return this.getBehavior(e, t, c, i);
+    const o = s.get("input-0").hasVoltage !== s.get("input-1").hasVoltage, u = e.config.get("activationLogic") === "negative" ? !o : o;
+    return this.getBehavior(e, t, u, i);
   }
-}, ue = class extends m {
+}, be = class extends P {
   constructor() {
-    super(u.Xor4Gate);
+    super(c.Xor4Gate);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for Xor4GateBehavior: ${e.type}`);
     const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
-    return new Rt(e.id, t);
+    return new Ht(e.id, t);
   }
   onPinsChange(e, t, n, i) {
     const s = this.getPinStates(e, n);
@@ -2815,17 +3642,17 @@ var Kt = class extends C {
     if (r) return r;
     const a = this.nonLogicInputGuardBehavior(t, s, i);
     if (a) return a;
-    const o = ((s.get("input1").hasVoltage ? 1 : 0) + (s.get("input2").hasVoltage ? 1 : 0) + (s.get("input3").hasVoltage ? 1 : 0) + (s.get("input4").hasVoltage ? 1 : 0)) % 2 === 1, c = e.config.get("activationLogic") === "negative" ? !o : o;
-    return this.getBehavior(e, t, c, i);
+    const o = ((s.get("input-0").hasVoltage ? 1 : 0) + (s.get("input-1").hasVoltage ? 1 : 0) + (s.get("input-2").hasVoltage ? 1 : 0) + (s.get("input-3").hasVoltage ? 1 : 0)) % 2 === 1, u = e.config.get("activationLogic") === "negative" ? !o : o;
+    return this.getBehavior(e, t, u, i);
   }
-}, le = class extends m {
+}, Ce = class extends P {
   constructor() {
-    super(u.Xor8Gate);
+    super(c.Xor8Gate);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for Xor8GateBehavior: ${e.type}`);
     const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
-    return new Wt(e.id, t);
+    return new Jt(e.id, t);
   }
   onPinsChange(e, t, n, i) {
     const s = this.getPinStates(e, n);
@@ -2834,10 +3661,10 @@ var Kt = class extends C {
     if (r) return r;
     const a = this.nonLogicInputGuardBehavior(t, s, i);
     if (a) return a;
-    const o = ((s.get("input1").hasVoltage ? 1 : 0) + (s.get("input2").hasVoltage ? 1 : 0) + (s.get("input3").hasVoltage ? 1 : 0) + (s.get("input4").hasVoltage ? 1 : 0) + (s.get("input5").hasVoltage ? 1 : 0) + (s.get("input6").hasVoltage ? 1 : 0) + (s.get("input7").hasVoltage ? 1 : 0) + (s.get("input8").hasVoltage ? 1 : 0)) % 2 === 1, c = e.config.get("activationLogic") === "negative" ? !o : o;
-    return this.getBehavior(e, t, c, i);
+    const o = ((s.get("input-0").hasVoltage ? 1 : 0) + (s.get("input-1").hasVoltage ? 1 : 0) + (s.get("input-2").hasVoltage ? 1 : 0) + (s.get("input-3").hasVoltage ? 1 : 0) + (s.get("input-4").hasVoltage ? 1 : 0) + (s.get("input-5").hasVoltage ? 1 : 0) + (s.get("input-6").hasVoltage ? 1 : 0) + (s.get("input-7").hasVoltage ? 1 : 0)) % 2 === 1, u = e.config.get("activationLogic") === "negative" ? !o : o;
+    return this.getBehavior(e, t, u, i);
   }
-}, B = class extends C {
+}, A = class extends C {
   onPinsChange(e, t, n, i) {
     const s = this.getPinStates(e, n);
     t.pinStates = s;
@@ -2845,8 +3672,8 @@ var Kt = class extends C {
     if (a) return a;
     const o = this.nonLogicInputGuardBehavior(r, s, i);
     if (o) return o;
-    const c = this.computeTargetStableState(s);
-    return this.scheduleTransition(e, r, c, i);
+    const u = this.computeTargetStableState(s);
+    return this.scheduleTransition(e, r, u, i);
   }
   onEventFiring(e, t, n) {
     if (!n.type.startsWith("to")) return this.noChange(t);
@@ -2864,12 +3691,12 @@ var Kt = class extends C {
     if (r === "indeterminate") return !1;
     const a = e.getPinMetadata(i), o = e.getPinMetadata(s);
     if (!a || !o) return !1;
-    let c, p = 0;
-    if (a.subtype === "logicOutput" && (p++, c = a), o.subtype === "logicOutput" && (p++, c = o), p !== 1 || !c?.logicPinData) return !1;
-    let l = 0;
-    if (l += a.subtype === "vcc" ? 1 : a.subtype === "gnd" ? -1 : 0, l += o.subtype === "vcc" ? 1 : o.subtype === "gnd" ? -1 : 0, l !== 1 && l !== -1) return !1;
+    let u, l = 0;
+    if (a.subtype === "logicOutput" && (l++, u = a), o.subtype === "logicOutput" && (l++, u = o), l !== 1 || !u?.logicPinData) return !1;
+    let p = 0;
+    if (p += a.subtype === "vcc" ? 1 : a.subtype === "gnd" ? -1 : 0, p += o.subtype === "vcc" ? 1 : o.subtype === "gnd" ? -1 : 0, p !== 1 && p !== -1) return !1;
     const d = t;
-    return (parseInt(r, 16) >> (c.logicPinData.interface === "sum" ? c.logicPinData.index * 2 : d.outputCount - 1) & 1) === 1 ? l === 1 : l === -1;
+    return (parseInt(r, 16) >> (u.logicPinData.interface === "sum" ? u.logicPinData.index * 2 : d.outputCount - 1) & 1) === 1 ? p === 1 : p === -1;
   }
   vccGuardBehavior(e, t, n) {
     if (t.get("vcc").hasVoltage) return null;
@@ -2911,8 +3738,8 @@ var Kt = class extends C {
   scheduleTransition(e, t, n, i) {
     const s = `to${n}`;
     if (t.state === n || t.state === s) return this.noChange(t);
-    const r = x(e.config), a = t.expirationTick < 1 ? r : Math.max(i - t.startTick, 1), o = t.effectiveState, c = o === "indeterminate" ? t.allLowState : o;
-    return t.setState(s, i), t.setNextState(n, i + a), t.parameters.set("prevState", c), {
+    const r = x(e.config), a = t.expirationTick < 1 ? r : Math.max(i - t.startTick, 1), o = t.effectiveState, u = o === "indeterminate" ? t.allLowState : o;
+    return t.setState(s, i), t.setNextState(n, i + a), t.parameters.set("prevState", u), {
       componentState: t,
       hasChanged: !0,
       shouldCancelPending: !0,
@@ -2933,37 +3760,37 @@ var Kt = class extends C {
       scheduledEvents: []
     };
   }
-}, pe = class extends B {
+}, Pe = class extends A {
   constructor() {
-    super(u.HalfAdder);
+    super(c.HalfAdder);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for HalfAdderBehavior: ${e.type}`);
-    return new zt(e.id, "0");
+    return new Ut(e.id, "0");
   }
   computeTargetStableState(e) {
     const t = e.get("inputA").hasVoltage, n = e.get("inputB").hasVoltage;
     return ((t !== n ? 1 : 0) | (t && n ? 2 : 0)).toString(16);
   }
-}, de = class extends B {
+}, xe = class extends A {
   constructor() {
-    super(u.Adder);
+    super(c.Adder);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for AdderBehavior: ${e.type}`);
-    return new Ht(e.id, "0");
+    return new Xt(e.id, "0");
   }
   computeTargetStableState(e) {
     const t = e.get("inputA").hasVoltage, n = e.get("inputB").hasVoltage, i = e.get("carryIn").hasVoltage, s = (t ? 1 : 0) + (n ? 1 : 0) + (i ? 1 : 0);
     return ((s % 2 === 1 ? 1 : 0) | (s >= 2 ? 2 : 0)).toString(16);
   }
-}, N = 8, he = class extends B {
+}, M = 8, Ie = class extends A {
   constructor() {
-    super(u.EightBitAdder);
+    super(c.EightBitAdder);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for EightBitAdderBehavior: ${e.type}`);
-    return new Ft(e.id, "0000");
+    return new Qt(e.id, "0000");
   }
   onPinsChange(e, t, n, i) {
     const s = this.getPinStates(e, n);
@@ -2973,19 +3800,19 @@ var Kt = class extends C {
     const o = this.nonLogicInputGuardBehavior(r, s, i);
     if (o) return o;
     if (i === 0) {
-      const h = this.computeTargetStableState(s);
-      return this.scheduleTransition(e, r, h, i);
+      const y = this.computeTargetStableState(s);
+      return this.scheduleTransition(e, r, y, i);
     }
-    const c = r.effectiveState, p = c === "indeterminate" ? 0 : parseInt(c, 16), l = s.get("carryIn").hasVoltage;
+    const u = r.effectiveState, l = u === "indeterminate" ? 0 : parseInt(u, 16), p = s.get("carryIn").hasVoltage;
     let d = 0;
-    for (let h = 0; h < N; h++) {
-      const S = s.get(`inputA-${h}`).hasVoltage, ut = s.get(`inputB-${h}`).hasVoltage, { sum: lt, carry: pt } = k(S, ut, h === 0 ? l : (p >> 2 * (h - 1) + 1 & 1) === 1);
-      d = G(d, h, lt, pt);
+    for (let y = 0; y < M; y++) {
+      const S = s.get(`inputA-${y}`).hasVoltage, T = s.get(`inputB-${y}`).hasVoltage, { sum: E, carry: ft } = W(S, T, y === 0 ? p : (l >> 2 * (y - 1) + 1 & 1) === 1);
+      d = R(d, y, E, ft);
     }
-    const y = _(d);
-    if (y === c) return this.noChange(t);
-    const f = x(e.config), v = c === "indeterminate" ? r.allLowState : c;
-    return r.setState(`to${y}`, i), r.setNextState(y, i + f), r.parameters.set("prevState", v), {
+    const g = F(d);
+    if (g === u) return this.noChange(t);
+    const f = x(e.config), v = u === "indeterminate" ? r.allLowState : u;
+    return r.setState(`to${g}`, i), r.setNextState(g, i + f), r.parameters.set("prevState", v), {
       componentState: r,
       hasChanged: !0,
       shouldCancelPending: !0,
@@ -2993,37 +3820,37 @@ var Kt = class extends C {
         targetId: e.id,
         scheduledAtTick: i,
         readyAtTick: i + f,
-        type: `to${y}`,
+        type: `to${g}`,
         parameters: /* @__PURE__ */ new Map([["nextStage", "1"]])
       }]
     };
   }
   onEventFiring(e, t, n) {
     if (!n.type.startsWith("to")) return this.noChange(t);
-    const i = n.type.slice(2), s = parseInt(n.parameters?.get("nextStage") ?? `${N}`), r = t;
+    const i = n.type.slice(2), s = parseInt(n.parameters?.get("nextStage") ?? `${M}`), r = t;
     if (r.state === i) return this.noChange(r);
-    if (r.setState(i, n.readyAtTick), r.parameters.delete("prevState"), s >= N) return {
+    if (r.setState(i, n.readyAtTick), r.parameters.delete("prevState"), s >= M) return {
       componentState: r,
       hasChanged: !0,
       shouldCancelPending: !1,
       scheduledEvents: []
     };
-    const a = parseInt(i, 16), o = (a >> 2 * (s - 1) + 1 & 1) === 1, c = r.pinStates.get(`inputA-${s}`).hasVoltage, p = r.pinStates.get(`inputB-${s}`).hasVoltage, { sum: l, carry: d } = k(c, p, o), y = (a >> 2 * s & 1) === 1, f = (a >> 2 * s + 1 & 1) === 1;
-    if (l === y && d === f) return {
+    const a = parseInt(i, 16), o = (a >> 2 * (s - 1) + 1 & 1) === 1, u = r.pinStates.get(`inputA-${s}`).hasVoltage, l = r.pinStates.get(`inputB-${s}`).hasVoltage, { sum: p, carry: d } = W(u, l, o), g = (a >> 2 * s & 1) === 1, f = (a >> 2 * s + 1 & 1) === 1;
+    if (p === g && d === f) return {
       componentState: r,
       hasChanged: !0,
       shouldCancelPending: !1,
       scheduledEvents: []
     };
-    const v = _(G(a, s, l, d)), h = x(e.config);
-    return r.setState(`to${v}`, n.readyAtTick), r.setNextState(v, n.readyAtTick + h), r.parameters.set("prevState", i), {
+    const v = F(R(a, s, p, d)), y = x(e.config);
+    return r.setState(`to${v}`, n.readyAtTick), r.setNextState(v, n.readyAtTick + y), r.parameters.set("prevState", i), {
       componentState: r,
       hasChanged: !0,
       shouldCancelPending: !1,
       scheduledEvents: [{
         targetId: e.id,
         scheduledAtTick: n.readyAtTick,
-        readyAtTick: n.readyAtTick + h,
+        readyAtTick: n.readyAtTick + y,
         type: `to${v}`,
         parameters: /* @__PURE__ */ new Map([["nextStage", `${s + 1}`]])
       }]
@@ -3031,34 +3858,34 @@ var Kt = class extends C {
   }
   computeTargetStableState(e) {
     let t = e.get("carryIn").hasVoltage, n = 0;
-    for (let i = 0; i < N; i++) {
-      const s = e.get(`inputA-${i}`).hasVoltage, r = e.get(`inputB-${i}`).hasVoltage, a = k(s, r, t);
-      n = G(n, i, a.sum, a.carry), t = a.carry;
+    for (let i = 0; i < M; i++) {
+      const s = e.get(`inputA-${i}`).hasVoltage, r = e.get(`inputB-${i}`).hasVoltage, a = W(s, r, t);
+      n = R(n, i, a.sum, a.carry), t = a.carry;
     }
-    return _(n);
+    return F(n);
   }
 };
-function k(e, t, n) {
+function W(e, t, n) {
   return {
     sum: e !== t !== n,
     carry: e && t || e && n || t && n
   };
 }
-function G(e, t, n, i) {
+function R(e, t, n, i) {
   const s = 2 * t, r = s + 1;
   let a = e;
   return a = a & ~(1 << s) | (n ? 1 : 0) << s, a = a & ~(1 << r) | (i ? 1 : 0) << r, a;
 }
-function _(e) {
+function F(e) {
   return e.toString(16).padStart(4, "0");
 }
-var U = 8, ge = class extends B {
+var Z = 8, Te = class extends A {
   constructor() {
-    super(u.EightBitOnesComplement);
+    super(c.EightBitOnesComplement);
   }
   createInitialState(e) {
     if (e.type !== this._componentType) throw new Error(`Invalid component type for EightBitOnesComplementBehavior: ${e.type}`);
-    return new Jt(e.id, "000");
+    return new qt(e.id, "000");
   }
   allowConductivity(e, t, n, i, s) {
     if (i === s) return !0;
@@ -3066,18 +3893,274 @@ var U = 8, ge = class extends B {
     if (r === "indeterminate") return !1;
     const a = e.getPinMetadata(i), o = e.getPinMetadata(s);
     if (!a || !o) return !1;
-    let c, p = 0;
-    if (a.subtype === "logicOutput" && (p++, c = a), o.subtype === "logicOutput" && (p++, c = o), p !== 1 || !c?.logicPinData) return !1;
-    let l = 0;
-    return l += a.subtype === "vcc" ? 1 : a.subtype === "gnd" ? -1 : 0, l += o.subtype === "vcc" ? 1 : o.subtype === "gnd" ? -1 : 0, l !== 1 && l !== -1 ? !1 : (parseInt(r, 16) >> c.logicPinData.index & 1) === 1 ? l === 1 : l === -1;
+    let u, l = 0;
+    if (a.subtype === "logicOutput" && (l++, u = a), o.subtype === "logicOutput" && (l++, u = o), l !== 1 || !u?.logicPinData) return !1;
+    let p = 0;
+    return p += a.subtype === "vcc" ? 1 : a.subtype === "gnd" ? -1 : 0, p += o.subtype === "vcc" ? 1 : o.subtype === "gnd" ? -1 : 0, p !== 1 && p !== -1 ? !1 : (parseInt(r, 16) >> u.logicPinData.index & 1) === 1 ? p === 1 : p === -1;
   }
   computeTargetStableState(e) {
     const t = e.get("invert").hasVoltage;
     let n = 0;
-    for (let i = 0; i < U; i++) e.get(`input-${i}`).hasVoltage !== t && (n |= 1 << i);
-    return t && (n |= 1 << U), n.toString(16).padStart(3, "0");
+    for (let i = 0; i < Z; i++) e.get(`input-${i}`).hasVoltage !== t && (n |= 1 << i);
+    return t && (n |= 1 << Z), n.toString(16).padStart(3, "0");
+  }
+}, k = class extends C {
+  onPinsChange(e, t, n, i) {
+    const s = this.getPinStates(e, n);
+    t.pinStates = s;
+    const r = t;
+    return s.get("vcc").hasVoltage ? this.noChange(t) : r.state === r.allLowState && r.parameters.size === 0 ? this.noChange(t) : (r.parameters.clear(), r.setState(r.allLowState, i), {
+      componentState: r,
+      hasChanged: !0,
+      shouldCancelPending: !0,
+      scheduledEvents: []
+    });
+  }
+  onUserCommand(e, t, n) {
+    if (n.type !== "toggle_switch") return this.noChange(t);
+    const i = t, s = n.parameters?.get("index");
+    if (s === void 0) return this.noChange(t);
+    const r = parseInt(s, 10);
+    if (isNaN(r) || r < 0 || r >= i.outputCount) return this.noChange(t);
+    const a = i.pinStates.get("vcc");
+    if (a && !a.hasVoltage) return this.noChange(t);
+    if (i.parameters.has(String(r))) return this.noChange(t);
+    const o = n.scheduledAtTick, u = o + x(e.config), l = i.effectiveState, p = (parseInt(l, 16) >> r & 1) === 0 ? 1 : 0;
+    return i.isInTransition || (i.parameters.set("prevState", l), i.setState("moving", o)), i.parameters.set(String(r), `${p}-${o}-${u}`), {
+      componentState: i,
+      hasChanged: !0,
+      shouldCancelPending: !1,
+      scheduledEvents: [{
+        targetId: e.id,
+        scheduledAtTick: o,
+        readyAtTick: u,
+        type: "switchChanged",
+        parameters: /* @__PURE__ */ new Map([["index", String(r)], ["target", String(p)]])
+      }]
+    };
+  }
+  onEventFiring(e, t, n) {
+    if (n.type !== "switchChanged") return this.noChange(t);
+    const i = t, s = n.parameters?.get("index"), r = n.parameters?.get("target");
+    if (s === void 0 || r === void 0) return this.noChange(t);
+    const a = parseInt(s, 10);
+    if (isNaN(a) || !i.parameters.has(String(a))) return this.noChange(t);
+    const o = parseInt(r, 10) === 1 ? 1 : 0, u = i.parameters.get("prevState") ?? i.allLowState;
+    let l = parseInt(u, 16);
+    l = l & ~(1 << a) | o << a;
+    const p = l.toString(16).padStart(i.hexDigitCount, "0");
+    return i.parameters.delete(String(a)), Array.from(i.parameters.keys()).some((d) => d !== "prevState") ? (i.parameters.set("prevState", p), {
+      componentState: i,
+      hasChanged: !0,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    }) : (i.parameters.delete("prevState"), i.setState(p, n.readyAtTick), {
+      componentState: i,
+      hasChanged: !0,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    });
+  }
+  allowConductivity(e, t, n, i, s) {
+    if (i === s) return !0;
+    const r = t, a = e.getPinMetadata(i), o = e.getPinMetadata(s);
+    if (!a || !o) return !1;
+    let u, l = 0;
+    if (a.subtype === "logicOutput" && (l++, u = a), o.subtype === "logicOutput" && (l++, u = o), l !== 1 || !u?.logicPinData) return !1;
+    let p = 0;
+    return p += a.subtype === "vcc" ? 1 : a.subtype === "gnd" ? -1 : 0, p += o.subtype === "vcc" ? 1 : o.subtype === "gnd" ? -1 : 0, p !== 1 && p !== -1 ? !1 : r.isOutputHigh(u.logicPinData.index) ? p === 1 : p === -1;
+  }
+  noChange(e) {
+    return {
+      componentState: e,
+      hasChanged: !1,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    };
+  }
+}, Oe = class extends k {
+  constructor() {
+    super(c.OneInput);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType) throw new Error(`Invalid component type for OneInputBehavior: ${e.type}`);
+    const t = e.config.get("initialState") || "0";
+    return new Kt(e.id, t);
+  }
+}, Ee = class extends k {
+  constructor() {
+    super(c.TwoInput);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType) throw new Error(`Invalid component type for TwoInputBehavior: ${e.type}`);
+    const t = e.config.get("initialState") || "0";
+    return new Yt(e.id, t);
+  }
+}, De = class extends k {
+  constructor() {
+    super(c.FourInput);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType) throw new Error(`Invalid component type for FourInputBehavior: ${e.type}`);
+    const t = e.config.get("initialState") || "0";
+    return new Zt(e.id, t);
+  }
+}, Ne = class extends k {
+  constructor() {
+    super(c.EightInput);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType) throw new Error(`Invalid component type for EightInputBehavior: ${e.type}`);
+    const t = e.config.get("initialState") || "00";
+    return new jt(e.id, t);
+  }
+}, G = class extends C {
+  onPinsChange(e, t, n, i) {
+    const s = this.getPinStates(e, n);
+    t.pinStates = s;
+    const r = t, a = this.vccGuardBehavior(r, s, i);
+    if (a) return a;
+    const o = this.nonLogicInputGuardBehavior(r, s, i);
+    return o || this.scheduleInputTransitions(e, r, s, i);
+  }
+  onEventFiring(e, t, n) {
+    if (n.type !== "lightChanged") return this.noChange(t);
+    const i = t, s = n.parameters?.get("index"), r = n.parameters?.get("target");
+    if (s === void 0 || r === void 0) return this.noChange(t);
+    const a = parseInt(s, 10);
+    if (isNaN(a)) return this.noChange(t);
+    const o = i.getPendingMove(a);
+    if (!o) return this.noChange(t);
+    if (o.endTick !== n.readyAtTick) return this.noChange(t);
+    const u = o.target, l = i.parameters.get("prevState") ?? i.allLowState;
+    let p = parseInt(l, 16);
+    p = p & ~(1 << a) | u << a;
+    const d = p.toString(16).padStart(i.hexDigitCount, "0");
+    return i.parameters.delete(String(a)), Array.from(i.parameters.keys()).some((g) => g !== "prevState") ? (i.parameters.set("prevState", d), {
+      componentState: i,
+      hasChanged: !0,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    }) : (i.parameters.delete("prevState"), i.setState(d, n.readyAtTick), {
+      componentState: i,
+      hasChanged: !0,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    });
+  }
+  allowConductivity(e, t, n, i, s) {
+    if (i === s) return !0;
+    const r = t;
+    if (r.effectiveState === "indeterminate") return !1;
+    const a = e.getPinMetadata(i), o = e.getPinMetadata(s);
+    if (!a || !o) return !1;
+    let u, l = 0;
+    if (a.subtype === "logicOutput" && (l++, u = a), o.subtype === "logicOutput" && (l++, u = o), l !== 1 || !u?.logicPinData) return !1;
+    let p = 0;
+    return p += a.subtype === "vcc" ? 1 : a.subtype === "gnd" ? -1 : 0, p += o.subtype === "vcc" ? 1 : o.subtype === "gnd" ? -1 : 0, p !== 1 && p !== -1 ? !1 : r.isOutputHigh(u.logicPinData.index) ? p === 1 : p === -1;
+  }
+  vccGuardBehavior(e, t, n) {
+    return t.get("vcc").hasVoltage ? null : e.state === e.allLowState && e.parameters.size === 0 ? this.noChange(e) : (e.parameters.clear(), e.setState(e.allLowState, n), {
+      componentState: e,
+      hasChanged: !0,
+      shouldCancelPending: !0,
+      scheduledEvents: []
+    });
+  }
+  nonLogicInputGuardBehavior(e, t, n) {
+    const i = this.typeMetadata.pins;
+    let s = !1;
+    for (const [r, a] of t) {
+      const o = i.get(r);
+      if (!(!o || o.subtype !== "logicInput") && (a.hasVoltage && a.hasCurrent || !a.hasVoltage && !a.hasCurrent)) {
+        s = !0;
+        break;
+      }
+    }
+    return s ? e.state === "indeterminate" && e.parameters.size === 0 ? this.noChange(e) : (e.parameters.clear(), e.setState("indeterminate", n), {
+      componentState: e,
+      hasChanged: !0,
+      shouldCancelPending: !0,
+      scheduledEvents: []
+    }) : null;
+  }
+  scheduleInputTransitions(e, t, n, i) {
+    const s = x(e.config), r = t.effectiveState === "indeterminate" ? t.allLowState : t.effectiveState, a = parseInt(r, 16), o = [];
+    let u = !1;
+    for (let l = 0; l < t.lightCount; l++) {
+      const p = n.get(`input-${l}`);
+      if (!p) continue;
+      const d = p.hasVoltage ? 1 : 0, g = t.getPendingMove(l), f = a >> l & 1;
+      if (g) {
+        if (g.target === d) continue;
+        const S = Math.max(g.endTick - g.startTick, 1), T = i, E = T + S;
+        t.parameters.set(String(l), `${d}-${T}-${E}`), o.push({
+          targetId: e.id,
+          scheduledAtTick: T,
+          readyAtTick: E,
+          type: "lightChanged",
+          parameters: /* @__PURE__ */ new Map([["index", String(l)], ["target", String(d)]])
+        }), u = !0;
+        continue;
+      }
+      if (f === d) continue;
+      const v = i, y = v + s;
+      t.isInTransition || (t.parameters.set("prevState", r), t.setState("moving", v)), t.parameters.set(String(l), `${d}-${v}-${y}`), o.push({
+        targetId: e.id,
+        scheduledAtTick: v,
+        readyAtTick: y,
+        type: "lightChanged",
+        parameters: /* @__PURE__ */ new Map([["index", String(l)], ["target", String(d)]])
+      }), u = !0;
+    }
+    return u ? {
+      componentState: t,
+      hasChanged: !0,
+      shouldCancelPending: !1,
+      scheduledEvents: o
+    } : this.noChange(t);
+  }
+  noChange(e) {
+    return {
+      componentState: e,
+      hasChanged: !1,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    };
+  }
+}, Me = class extends G {
+  constructor() {
+    super(c.OneLight);
   }
-}, fe = class {
+  createInitialState(e) {
+    if (e.type !== this._componentType) throw new Error(`Invalid component type for OneLightBehavior: ${e.type}`);
+    return new te(e.id, "0");
+  }
+}, Le = class extends G {
+  constructor() {
+    super(c.TwoLight);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType) throw new Error(`Invalid component type for TwoLightBehavior: ${e.type}`);
+    return new ee(e.id, "0");
+  }
+}, ze = class extends G {
+  constructor() {
+    super(c.FourLight);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType) throw new Error(`Invalid component type for FourLightBehavior: ${e.type}`);
+    return new ie(e.id, "0");
+  }
+}, Be = class extends G {
+  constructor() {
+    super(c.EightLight);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType) throw new Error(`Invalid component type for EightLightBehavior: ${e.type}`);
+    return new ne(e.id, "00");
+  }
+}, Ae = class {
   heap;
   constructor() {
     this.heap = [];
@@ -3139,7 +4222,7 @@ var U = 8, ge = class extends B {
     const e = this.heap[0], t = this.heap.pop();
     return this.heap.length > 0 && t && (this.heap[0] = t, this.bubbleDown(0)), e;
   }
-}, ye = class {
+}, ke = class {
   dirtyComponents;
   dirtyWires;
   dirtyEnodes;
@@ -3187,7 +4270,7 @@ var U = 8, ge = class extends B {
   getDirtyEnodeCount() {
     return this.dirtyEnodes.size;
   }
-}, ve = class {
+}, Ge = class {
   currentState;
   history;
   historyEnabled;
@@ -3195,7 +4278,7 @@ var U = 8, ge = class extends B {
   historyWriteIndex;
   constructor(e = !1, t = 1e3) {
     if (t < 1) throw new RangeError(`historyLimit must be at least 1 (got ${t})`);
-    this.historyEnabled = e, this.historyLimit = t, this.currentState = new J(0), this.history = [], this.historyWriteIndex = 0;
+    this.historyEnabled = e, this.historyLimit = t, this.currentState = new Y(0), this.history = [], this.historyWriteIndex = 0;
   }
   getCurrentState() {
     return this.currentState;
@@ -3226,7 +4309,7 @@ var U = 8, ge = class extends B {
     this.history = [], this.historyWriteIndex = 0;
   }
   reset() {
-    this.currentState = new J(0), this.clearHistory();
+    this.currentState = new Y(0), this.clearHistory();
   }
   isHistoryEnabled() {
     return this.historyEnabled;
@@ -3240,7 +4323,7 @@ var U = 8, ge = class extends B {
   saveToHistory(e) {
     this.history.length < this.historyLimit ? this.history.push(e) : (this.history[this.historyWriteIndex] = e, this.historyWriteIndex = (this.historyWriteIndex + 1) % this.historyLimit);
   }
-}, Pe = class {
+}, Xe = class {
   circuit;
   stateManager;
   eventQueue;
@@ -3248,7 +4331,7 @@ var U = 8, ge = class extends B {
   dirtyTracker;
   behaviorRegistry;
   constructor(e, t, n = {}) {
-    this.circuit = e, this.behaviorRegistry = t, this.stateManager = new ve(n.enableHistory ?? !1, n.historyLimit ?? 1e3), this.eventQueue = new fe(), this.commands = /* @__PURE__ */ new Map(), this.dirtyTracker = new ye();
+    this.circuit = e, this.behaviorRegistry = t, this.stateManager = new Ge(n.enableHistory ?? !1, n.historyLimit ?? 1e3), this.eventQueue = new Ae(), this.commands = /* @__PURE__ */ new Map(), this.dirtyTracker = new ke();
     try {
       this.initializeState();
     } catch (i) {
@@ -3313,110 +4396,110 @@ var U = 8, ge = class extends B {
   }
   initializeState() {
     const e = this.stateManager.getCurrentState();
-    for (const c of this.circuit.getAllComponents()) {
-      if (c.pins.length < 1) continue;
-      const p = this.behaviorRegistry.get(c.type);
-      if (!p) continue;
-      const l = p.createInitialState(c);
-      e.componentStates.set(c.id, l), this.dirtyTracker.markComponentDirty(c.id);
+    for (const u of this.circuit.getAllComponents()) {
+      if (u.pins.length < 1) continue;
+      const l = this.behaviorRegistry.get(u.type);
+      if (!l) continue;
+      const p = l.createInitialState(u);
+      e.componentStates.set(u.id, p), this.dirtyTracker.markComponentDirty(u.id);
     }
-    for (const c of this.circuit.getAllENodes()) e.nodeStates.set(c.id, {
-      hasVoltage: c.source === g.Voltage,
-      hasCurrent: c.source === g.Current,
-      locked: !!c.source
+    for (const u of this.circuit.getAllENodes()) e.nodeStates.set(u.id, {
+      hasVoltage: u.source === h.Voltage,
+      hasCurrent: u.source === h.Current,
+      locked: !!u.source
     });
-    for (const c of this.circuit.getAllWires()) e.wireStates.set(c.id, {
+    for (const u of this.circuit.getAllWires()) e.wireStates.set(u.id, {
       hasVoltage: !1,
       hasCurrent: !1,
       locked: !1
     });
     const t = this.circuit.getAllComponents(), n = /* @__PURE__ */ new Map();
-    for (const c of t) {
-      const p = this.getInitializationOrder(c.config), l = n.get(p) ?? [];
-      l.push(c), n.set(p, l);
+    for (const u of t) {
+      const l = this.getInitializationOrder(u.config), p = n.get(l) ?? [];
+      p.push(u), n.set(l, p);
     }
-    const i = Array.from(n.keys()).sort((c, p) => c - p);
-    for (const c of i) n.get(c).sort((p, l) => p.id.localeCompare(l.id));
+    const i = Array.from(n.keys()).sort((u, l) => u - l);
+    for (const u of i) n.get(u).sort((l, p) => l.id.localeCompare(p.id));
     let s = !0, r = 0;
     const a = 100;
     for (; s && r < a; ) {
       s = !1, r++;
-      for (const c of i) {
-        const p = n.get(c);
-        for (const l of p) {
-          const d = this.behaviorRegistry.get(l.type);
+      for (const u of i) {
+        const l = n.get(u);
+        for (const p of l) {
+          const d = this.behaviorRegistry.get(p.type);
           if (!d) continue;
-          const y = e.componentStates.get(l.id);
-          if (!y) continue;
+          const g = e.componentStates.get(p.id);
+          if (!g) continue;
           this.propagateConductivity();
-          const f = d.onStart(l, y);
+          const f = d.onStart(p, g);
           if (f) {
-            e.componentStates.set(l.id, f.componentState), f.shouldCancelPending && this.eventQueue.removeEventsForTarget(l.id);
-            for (const h of f.scheduledEvents) this.eventQueue.schedule(h);
+            e.componentStates.set(p.id, f.componentState), f.shouldCancelPending && this.eventQueue.removeEventsForTarget(p.id);
+            for (const y of f.scheduledEvents) this.eventQueue.schedule(y);
             continue;
           }
-          const v = d.onPinsChange(l, y, e.nodeStates, 0);
-          v.hasChanged && (s = !0, e.componentStates.set(l.id, v.componentState));
-          for (const h of v.scheduledEvents) {
-            const S = d.onEventFiring(l, y, h);
-            S.hasChanged && (s = !0, e.componentStates.set(l.id, S.componentState));
+          const v = d.onPinsChange(p, g, e.nodeStates, 0);
+          v.hasChanged && (s = !0, e.componentStates.set(p.id, v.componentState));
+          for (const y of v.scheduledEvents) {
+            const S = d.onEventFiring(p, g, y);
+            S.hasChanged && (s = !0, e.componentStates.set(p.id, S.componentState));
           }
         }
       }
     }
     const o = this.updateState(0);
-    return this.dirtyTracker.setDirtyComponents(/* @__PURE__ */ new Set([...this.circuit.getAllComponents().map((c) => c.id)])), this.dirtyTracker.setDirtyEnodes(/* @__PURE__ */ new Set([...this.circuit.getAllENodes().map((c) => c.id)])), this.dirtyTracker.setDirtyWires(/* @__PURE__ */ new Set([...this.circuit.getAllWires().map((c) => c.id)])), o;
+    return this.dirtyTracker.setDirtyComponents(/* @__PURE__ */ new Set([...this.circuit.getAllComponents().map((u) => u.id)])), this.dirtyTracker.setDirtyEnodes(/* @__PURE__ */ new Set([...this.circuit.getAllENodes().map((u) => u.id)])), this.dirtyTracker.setDirtyWires(/* @__PURE__ */ new Set([...this.circuit.getAllWires().map((u) => u.id)])), o;
   }
   updateState(e) {
     const t = this.stateManager.getCurrentState(), { updatedNodes: n, updatedWires: i } = this.propagateConductivity(), s = this.circuit.getComponentsOfPins(n), r = [], a = /* @__PURE__ */ new Set();
     let o = Array.from(s);
-    e === 0 && (o = o.sort((l, d) => {
-      const y = this.circuit.getComponent(l), f = this.circuit.getComponent(d), v = this.getInitializationOrder(y.config), h = this.getInitializationOrder(f.config);
-      return v !== h ? v - h : l.localeCompare(d);
+    e === 0 && (o = o.sort((p, d) => {
+      const g = this.circuit.getComponent(p), f = this.circuit.getComponent(d), v = this.getInitializationOrder(g.config), y = this.getInitializationOrder(f.config);
+      return v !== y ? v - y : p.localeCompare(d);
     }));
-    const c = /* @__PURE__ */ new Set(), p = [];
-    for (const l of o) {
-      const d = this.circuit.getComponent(l), y = this.behaviorRegistry.get(d.type);
-      if (!y) continue;
-      const f = y.onPinsChange(d, t.componentStates.get(l), t.nodeStates, e);
-      f.shouldCancelPending && c.add(l), f.hasChanged && (a.add(l), r.push(f));
-      for (const v of f.scheduledEvents) p.push(v);
+    const u = /* @__PURE__ */ new Set(), l = [];
+    for (const p of o) {
+      const d = this.circuit.getComponent(p), g = this.behaviorRegistry.get(d.type);
+      if (!g) continue;
+      const f = g.onPinsChange(d, t.componentStates.get(p), t.nodeStates, e);
+      f.shouldCancelPending && u.add(p), f.hasChanged && (a.add(p), r.push(f));
+      for (const v of f.scheduledEvents) l.push(v);
     }
-    return this.eventQueue.scheduleMany(p, c), this.dirtyTracker.setDirtyComponents(a), this.dirtyTracker.setDirtyEnodes(n), this.dirtyTracker.setDirtyWires(i), {
+    return this.eventQueue.scheduleMany(l, u), this.dirtyTracker.setDirtyComponents(a), this.dirtyTracker.setDirtyEnodes(n), this.dirtyTracker.setDirtyWires(i), {
       startTick: this.getCurrentTick(),
       endTick: this.getCurrentTick(),
       componentUpdateCount: a.size,
       nodeUpdateCount: n.size,
       wireUpdateCount: i.size,
       processedCommandCount: 0,
-      scheduledEventCount: p.length,
+      scheduledEventCount: l.length,
       firedEventCount: 0
     };
   }
   propagateConductivity() {
     const e = this.stateManager.getCurrentState(), t = (a) => {
-      const o = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Set(), p = this.circuit.getAllENodes().filter((h) => h.source == a).map((h) => h.id), l = /* @__PURE__ */ new Set([...this.circuit.getAllENodes().filter((h) => !h.source).map((h) => h.id)]), d = /* @__PURE__ */ new Set([...this.circuit.getAllWires().map((h) => h.id)]), { nodes: y, wires: f } = this.computeReachability(a, p, e.componentStates), v = a == g.Voltage ? "hasVoltage" : "hasCurrent";
-      for (const h of y) {
-        const S = e.nodeStates.get(h);
-        S && !S.locked && (S[v] || (S[v] = !0, o.add(h)), l.delete(h));
+      const o = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Set(), l = this.circuit.getAllENodes().filter((y) => y.source == a).map((y) => y.id), p = /* @__PURE__ */ new Set([...this.circuit.getAllENodes().filter((y) => !y.source).map((y) => y.id)]), d = /* @__PURE__ */ new Set([...this.circuit.getAllWires().map((y) => y.id)]), { nodes: g, wires: f } = this.computeReachability(a, l, e.componentStates), v = a == h.Voltage ? "hasVoltage" : "hasCurrent";
+      for (const y of g) {
+        const S = e.nodeStates.get(y);
+        S && !S.locked && (S[v] || (S[v] = !0, o.add(y)), p.delete(y));
       }
-      for (const h of l) {
-        const S = e.nodeStates.get(h);
-        S && !S.locked && S[v] && (S[v] = !1, o.add(h));
+      for (const y of p) {
+        const S = e.nodeStates.get(y);
+        S && !S.locked && S[v] && (S[v] = !1, o.add(y));
       }
-      for (const h of f) {
-        const S = e.wireStates.get(h);
-        S && (S[v] || (S[v] = !0, c.add(h)), d.delete(h));
+      for (const y of f) {
+        const S = e.wireStates.get(y);
+        S && (S[v] || (S[v] = !0, u.add(y)), d.delete(y));
       }
-      for (const h of d) {
-        const S = e.wireStates.get(h);
-        S && S[v] && (S[v] = !1, c.add(h));
+      for (const y of d) {
+        const S = e.wireStates.get(y);
+        S && S[v] && (S[v] = !1, u.add(y));
       }
       return {
         updatedNodes: o,
-        updatedWires: c
+        updatedWires: u
       };
-    }, { updatedNodes: n, updatedWires: i } = t(g.Voltage), { updatedNodes: s, updatedWires: r } = t(g.Current);
+    }, { updatedNodes: n, updatedWires: i } = t(h.Voltage), { updatedNodes: s, updatedWires: r } = t(h.Current);
     return {
       updatedNodes: /* @__PURE__ */ new Set([...n, ...s]),
       updatedWires: /* @__PURE__ */ new Set([...i, ...r])
@@ -3428,19 +4511,19 @@ var U = 8, ge = class extends B {
       r.push(a), i.add(a);
     for (; r.length > 0; ) {
       const a = r.shift();
-      for (const c of this.circuit.getWiresByNode(a)) {
-        const p = c.node1 === a ? c.node2 : c.node1;
-        i.has(p) || (i.add(p), r.push(p)), s.has(c.id) || s.add(c.id);
+      for (const u of this.circuit.getWiresByNode(a)) {
+        const l = u.node1 === a ? u.node2 : u.node1;
+        i.has(l) || (i.add(l), r.push(l)), s.has(u.id) || s.add(u.id);
       }
       const o = this.circuit.getENode(a);
-      if (o.type === P.Pin) {
-        const c = this.circuit.getComponent(o.component), p = this.behaviorRegistry.get(c.type);
-        if (!p) continue;
-        const l = c.getPinMetadata(a);
-        if (l?.subtype === "logicInput" || l?.subtype === "logicOutput") continue;
-        const d = n.get(c.id);
-        for (const y of c.pins)
-          y !== a && (i.has(y) || p.allowConductivity(c, d, e, a, y) && (i.add(y), r.push(y)));
+      if (o.type === w.Pin) {
+        const u = this.circuit.getComponent(o.component), l = this.behaviorRegistry.get(u.type);
+        if (!l) continue;
+        const p = u.getPinMetadata(a);
+        if (p?.subtype === "logicInput" || p?.subtype === "logicOutput") continue;
+        const d = n.get(u.id);
+        for (const g of u.pins)
+          g !== a && (i.has(g) || l.allowConductivity(u, d, e, a, g) && (i.add(g), r.push(g)));
       }
     }
     return {
@@ -3451,110 +4534,138 @@ var U = 8, ge = class extends B {
   applyReadyEvents(e) {
     const t = this.stateManager.getCurrentState(), n = this.eventQueue.getReadyEvents(e), i = [], s = /* @__PURE__ */ new Set(), r = [];
     for (const a of n) {
-      const o = this.circuit.getComponent(a.targetId), c = this.behaviorRegistry.get(o.type);
-      if (!c) continue;
-      const p = t.componentStates.get(o.id), l = c.onEventFiring(o, p, a);
-      l.shouldCancelPending && s.add(o.id);
-      for (const d of l.scheduledEvents) r.push(d);
-      i.push(l);
+      const o = this.circuit.getComponent(a.targetId), u = this.behaviorRegistry.get(o.type);
+      if (!u) continue;
+      const l = t.componentStates.get(o.id), p = u.onEventFiring(o, l, a);
+      p.shouldCancelPending && s.add(o.id);
+      for (const d of p.scheduledEvents) r.push(d);
+      i.push(p);
     }
     return this.eventQueue.scheduleMany(r, s), i;
   }
 };
-function xe(e) {
-  return e.register(new Ut()).register(new Xt()).register(new Qt()).register(new Kt()).register(new Yt()).register(new Zt()).register(new jt()).register(new te()), e;
+function Qe(e) {
+  return e.register(new se()).register(new re()).register(new ae()).register(new ue()).register(new ce()).register(new pe()).register(new le()).register(new de()), e;
+}
+function qe(e) {
+  return e.register(new he()).register(new ge()).register(new fe()).register(new ye()).register(new ve()).register(new Se()).register(new we()).register(new me()).register(new be()).register(new Ce()), e;
 }
-function Ie(e) {
-  return e.register(new ee()).register(new ie()).register(new ne()).register(new se()).register(new re()).register(new ae()).register(new oe()).register(new ce()).register(new ue()).register(new le()), e;
+function Ke(e) {
+  return e.register(new Pe()).register(new xe()).register(new Ie()).register(new Te()), e;
 }
-function Te(e) {
-  return e.register(new pe()).register(new de()).register(new he()).register(new ge()), e;
+function Ye(e) {
+  return e.register(new Oe()).register(new Ee()).register(new De()).register(new Ne()).register(new Me()).register(new Le()).register(new ze()).register(new Be()), e;
 }
 export {
-  Tt as $,
-  x as A,
-  Se as At,
-  Vt as B,
-  jt as C,
-  yt as Ct,
-  Qt as D,
-  Q as Dt,
-  Kt as E,
-  M as Et,
-  zt as F,
-  Mt as G,
-  Gt as H,
-  A as I,
-  At as J,
-  Dt as K,
-  Wt as L,
-  Jt as M,
-  Ft as N,
-  Xt as O,
-  O as Ot,
-  Ht as P,
-  ct as Q,
-  Rt as R,
-  te as S,
-  $ as St,
-  Yt as T,
-  ht as Tt,
-  kt as U,
-  _t as V,
-  Lt as W,
-  Et as X,
-  Nt as Y,
-  Ot as Z,
-  re as _,
-  I as _t,
-  ve as a,
-  at,
-  ie as b,
-  g as bt,
-  ge as c,
-  xt as ct,
-  pe as d,
-  H as dt,
-  It as et,
-  le as f,
-  z as ft,
-  ae as g,
-  Z as gt,
-  oe as h,
-  we as ht,
-  Pe as i,
-  be as it,
-  Ce as j,
-  Ut as k,
-  dt as kt,
-  he as l,
-  bt as lt,
-  ce as m,
-  L as mt,
-  xe as n,
-  J as nt,
-  ye as o,
-  me as ot,
-  ue as p,
-  E as pt,
-  Bt as q,
-  Ie as r,
-  T as rt,
-  fe as s,
-  Pt as st,
-  Te as t,
-  b as tt,
-  de as u,
-  F as ut,
-  se as v,
-  u as vt,
-  Zt as w,
-  V as wt,
-  ee as x,
-  P as xt,
-  ne as y,
-  j as yt,
-  $t as z
+  qt as $,
+  D as $t,
+  fe as A,
+  Re as At,
+  se as B,
+  Ve as Bt,
+  Ce as C,
+  Y as Ct,
+  Se as D,
+  Fe as Dt,
+  we as E,
+  dt as Et,
+  pe as F,
+  K as Ft,
+  ee as G,
+  h as Gt,
+  Ue as H,
+  I as Ht,
+  ce as I,
+  q as It,
+  jt as J,
+  mt as Jt,
+  te as K,
+  w as Kt,
+  ue as L,
+  Q as Lt,
+  he as M,
+  Ot as Mt,
+  de as N,
+  Et as Nt,
+  ve as O,
+  He as Ot,
+  le as P,
+  It as Pt,
+  z as Q,
+  tt as Qt,
+  ae as R,
+  N as Rt,
+  Pe as S,
+  m as St,
+  me as T,
+  Je as Tt,
+  ne as U,
+  c as Ut,
+  x as V,
+  st as Vt,
+  ie as W,
+  rt as Wt,
+  Yt as X,
+  vt as Xt,
+  Zt as Y,
+  H as Yt,
+  Kt as Z,
+  V as Zt,
+  Oe as _,
+  Lt as _t,
+  Xe as a,
+  Ht as at,
+  Ie as b,
+  Nt as bt,
+  Ae as c,
+  Wt as ct,
+  Le as d,
+  _t as dt,
+  yt as en,
+  Qt as et,
+  Me as f,
+  Gt as ft,
+  Ee as g,
+  zt as gt,
+  De as h,
+  Bt as ht,
+  Ye as i,
+  Jt as it,
+  ge as j,
+  $e as jt,
+  ye as k,
+  We as kt,
+  Be as l,
+  $t as lt,
+  Ne as m,
+  At as mt,
+  Qe as n,
+  Ut as nt,
+  Ge as o,
+  Ft as ot,
+  G as p,
+  kt as pt,
+  B as q,
+  J as qt,
+  qe as r,
+  L as rt,
+  ke as s,
+  Rt as st,
+  Ke as t,
+  _e as tn,
+  Xt as tt,
+  ze as u,
+  Vt as ut,
+  k as v,
+  Mt as vt,
+  be as w,
+  O as wt,
+  xe as x,
+  Dt as xt,
+  Te as y,
+  gt as yt,
+  re as z,
+  $ as zt
 };
 
-//# sourceMappingURL=core-b6Q8w2sn.js.map
+//# sourceMappingURL=core-HH6iRWtB.js.map