simple-circuit-engine 0.0.11 → 0.0.13

package/dist/core-b6Q8w2sn.js

@@ -0,0 +1,3560 @@
+function dt(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);
+    else throw "Only put a Memoize() decorator on a method or get accessor.";
+  };
+}
+function Se(e, t) {
+  return dt({
+    expiring: e,
+    hashFunction: t
+  });
+}
+var D = /* @__PURE__ */ new Map();
+function W(e, t, n = 0, i) {
+  const s = /* @__PURE__ */ Symbol("__memoized_map__");
+  return function(...r) {
+    let a;
+    this.hasOwnProperty(s) || Object.defineProperty(this, s, {
+      configurable: !1,
+      enumerable: !1,
+      writable: !1,
+      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 (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;
+      else {
+        let d = o.get(p);
+        l = 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()));
+    } else {
+      const c = this;
+      o.has(c) ? a = o.get(c) : (a = e.apply(this, r), o.set(c, a));
+    }
+    return a;
+  };
+}
+var O = class X {
+  constructor(t, n, i) {
+    this.x = t, this.y = n, this.z = i;
+  }
+  equals(t) {
+    return this.x === t.x && this.y === t.y && this.z === t.z;
+  }
+  toJSON() {
+    return {
+      x: this.x,
+      y: this.y,
+      z: this.z
+    };
+  }
+  static fromJSON(t) {
+    return new X(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) {
+    this.position = t, this.lookAtPosition = n, this.fov = i, this.near = s, this.far = r;
+  }
+  toJSON() {
+    return {
+      position: this.position.toJSON(),
+      lookAtPosition: this.lookAtPosition.toJSON(),
+      fov: this.fov,
+      near: this.near,
+      far: this.far
+    };
+  }
+  static fromJSON(t) {
+    return new q(O.fromJSON(t.position), O.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 {
+  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})`);
+  }
+  equals(t) {
+    return this.x === t.x && this.y === t.y;
+  }
+  toJSON() {
+    return {
+      x: this.x,
+      y: this.y
+    };
+  }
+  static fromJSON(t) {
+    return new K(t.x, t.y);
+  }
+  toString() {
+    return `Position(${this.x}, ${this.y})`;
+  }
+};
+function ht(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);
+    o < n && (n = o, i = s + 1);
+  }
+  return i;
+}
+function gt(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);
+}
+function M(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);
+  }
+  return n.push(e[e.length - 1]), n;
+}
+function ft(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 {
+  constructor(t) {
+    if (this.angle = t, !Number.isInteger(t)) throw new TypeError(`Rotation angle must be an integer (got ${t})`);
+  }
+  toJSON() {
+    return this.angle;
+  }
+  static fromJSON(t) {
+    return new Y(t);
+  }
+  equals(t) {
+    return this.angle === t.angle;
+  }
+  toString() {
+    return `Rotation(${this.angle}°)`;
+  }
+};
+function $() {
+  if (typeof crypto < "u" && crypto.randomUUID) return crypto.randomUUID();
+  const e = "0123456789abcdef", t = [
+    8,
+    4,
+    4,
+    4,
+    12
+  ], n = [];
+  for (const s of t) {
+    let r = "";
+    for (let a = 0; a < s; a++) {
+      const o = Math.floor(Math.random() * 16);
+      r += e[o];
+    }
+    n.push(r);
+  }
+  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) {
+  return e.Voltage = "Voltage", e.Current = "Current", e;
+})({}), P = /* @__PURE__ */ (function(e) {
+  return e.Pin = "Pin", e.BranchingPoint = "BranchingPoint", e;
+})({}), we = [
+  "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;
+})({}), I = {
+  [u.Switch]: {
+    id: u.Switch,
+    pins: /* @__PURE__ */ new Map([["input", { subtype: "free" }], ["output", { subtype: "free" }]]),
+    config: /* @__PURE__ */ new Map([
+      ["initialState", "open"],
+      ["transitionSpan", "1"],
+      ["size", "1"]
+    ])
+  },
+  [u.DoubleThrowSwitch]: {
+    id: u.DoubleThrowSwitch,
+    pins: /* @__PURE__ */ new Map([
+      ["input1", { subtype: "free" }],
+      ["input2", { subtype: "free" }],
+      ["output", { subtype: "free" }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["initialState", "input1"],
+      ["transitionSpan", "1"],
+      ["size", "1"]
+    ])
+  },
+  [u.Battery]: {
+    id: u.Battery,
+    pins: /* @__PURE__ */ new Map([["cathode", {
+      subtype: "mainVcc",
+      sourceType: g.Voltage
+    }], ["anode", {
+      subtype: "mainGnd",
+      sourceType: g.Current
+    }]]),
+    config: /* @__PURE__ */ new Map([])
+  },
+  [u.Lightbulb]: {
+    id: u.Lightbulb,
+    pins: /* @__PURE__ */ new Map([["pin1", { subtype: "free" }], ["pin2", { subtype: "free" }]]),
+    config: /* @__PURE__ */ new Map([["transitionSpan", "1"], ["size", "1"]])
+  },
+  [u.Relay]: {
+    id: u.Relay,
+    pins: /* @__PURE__ */ new Map([
+      ["cmd_in", { subtype: "free" }],
+      ["cmd_out", { subtype: "free" }],
+      ["power_in", { subtype: "free" }],
+      ["power_out", { subtype: "free" }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["activationLogic", "positive"],
+      ["transitionSpan", "1"],
+      ["initializationOrder", ""]
+    ])
+  },
+  [u.SmallLED]: {
+    id: u.SmallLED,
+    pins: /* @__PURE__ */ new Map([["pin1", { subtype: "free" }], ["pin2", { subtype: "free" }]]),
+    config: /* @__PURE__ */ new Map([
+      ["transitionSpan", "1"],
+      ["idleColor", "white"],
+      ["activeColor", "#ffff00"],
+      ["size", "1"],
+      ["ywRatio", "1"]
+    ])
+  },
+  [u.RectangleLED]: {
+    id: u.RectangleLED,
+    pins: /* @__PURE__ */ new Map([["pin1", { subtype: "free" }], ["pin2", { subtype: "free" }]]),
+    config: /* @__PURE__ */ new Map([
+      ["transitionSpan", "1"],
+      ["idleColor", "white"],
+      ["activeColor", "#ffff00"],
+      ["size", "1"],
+      ["hwRatio", "1"],
+      ["ywRatio", "1"]
+    ])
+  },
+  [u.Cube]: {
+    id: u.Cube,
+    pins: /* @__PURE__ */ new Map([]),
+    config: /* @__PURE__ */ new Map([["color", "red"]])
+  },
+  [u.Label]: {
+    id: u.Label,
+    pins: /* @__PURE__ */ new Map([]),
+    config: /* @__PURE__ */ new Map([["text", "Label"], ["size", "1"]])
+  },
+  [u.Clock]: {
+    id: u.Clock,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: g.Voltage
+      }],
+      ["output", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: g.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([["startHigh", "true"], ["halfPeriod", "2"]])
+  },
+  [u.Inverter]: {
+    id: u.Inverter,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: g.Voltage
+      }],
+      ["input", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 0
+        }
+      }],
+      ["output", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: g.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "negative"],
+      ["transitionSpan", "1"],
+      ["initializationOrder", ""]
+    ])
+  },
+  [u.NandGate]: {
+    id: u.NandGate,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: g.Voltage
+      }],
+      ["input1", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 0
+        }
+      }],
+      ["input2", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 1
+        }
+      }],
+      ["output", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: g.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "negative"],
+      ["transitionSpan", "1"],
+      ["initializationOrder", ""]
+    ])
+  },
+  [u.Nand4Gate]: {
+    id: u.Nand4Gate,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: g.Voltage
+      }],
+      ["input1", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 0
+        }
+      }],
+      ["input2", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 1
+        }
+      }],
+      ["input3", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 2
+        }
+      }],
+      ["input4", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 3
+        }
+      }],
+      ["output", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: g.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "negative"],
+      ["transitionSpan", "2"],
+      ["initializationOrder", ""]
+    ])
+  },
+  [u.Nand8Gate]: {
+    id: u.Nand8Gate,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: g.Voltage
+      }],
+      ["input1", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 0
+        }
+      }],
+      ["input2", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 1
+        }
+      }],
+      ["input3", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 2
+        }
+      }],
+      ["input4", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 3
+        }
+      }],
+      ["input5", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 4
+        }
+      }],
+      ["input6", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 5
+        }
+      }],
+      ["input7", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 6
+        }
+      }],
+      ["input8", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 7
+        }
+      }],
+      ["output", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: g.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "negative"],
+      ["transitionSpan", "3"],
+      ["initializationOrder", ""]
+    ])
+  },
+  [u.NorGate]: {
+    id: u.NorGate,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: g.Voltage
+      }],
+      ["input1", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 0
+        }
+      }],
+      ["input2", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 1
+        }
+      }],
+      ["output", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: g.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "negative"],
+      ["transitionSpan", "1"],
+      ["initializationOrder", ""]
+    ])
+  },
+  [u.Nor4Gate]: {
+    id: u.Nor4Gate,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: g.Voltage
+      }],
+      ["input1", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 0
+        }
+      }],
+      ["input2", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 1
+        }
+      }],
+      ["input3", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 2
+        }
+      }],
+      ["input4", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 3
+        }
+      }],
+      ["output", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: g.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "negative"],
+      ["transitionSpan", "2"],
+      ["initializationOrder", ""]
+    ])
+  },
+  [u.Nor8Gate]: {
+    id: u.Nor8Gate,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: g.Voltage
+      }],
+      ["input1", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 0
+        }
+      }],
+      ["input2", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 1
+        }
+      }],
+      ["input3", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 2
+        }
+      }],
+      ["input4", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 3
+        }
+      }],
+      ["input5", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 4
+        }
+      }],
+      ["input6", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 5
+        }
+      }],
+      ["input7", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 6
+        }
+      }],
+      ["input8", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 7
+        }
+      }],
+      ["output", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: g.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "negative"],
+      ["transitionSpan", "3"],
+      ["initializationOrder", ""]
+    ])
+  },
+  [u.XorGate]: {
+    id: u.XorGate,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: g.Voltage
+      }],
+      ["input1", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 0
+        }
+      }],
+      ["input2", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 1
+        }
+      }],
+      ["output", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: g.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "positive"],
+      ["transitionSpan", "2"],
+      ["initializationOrder", ""]
+    ])
+  },
+  [u.Xor4Gate]: {
+    id: u.Xor4Gate,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: g.Voltage
+      }],
+      ["input1", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 0
+        }
+      }],
+      ["input2", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 1
+        }
+      }],
+      ["input3", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 2
+        }
+      }],
+      ["input4", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 3
+        }
+      }],
+      ["output", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: g.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "positive"],
+      ["transitionSpan", "4"],
+      ["initializationOrder", ""]
+    ])
+  },
+  [u.Xor8Gate]: {
+    id: u.Xor8Gate,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: g.Voltage
+      }],
+      ["input1", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 0
+        }
+      }],
+      ["input2", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 1
+        }
+      }],
+      ["input3", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 2
+        }
+      }],
+      ["input4", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 3
+        }
+      }],
+      ["input5", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 4
+        }
+      }],
+      ["input6", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 5
+        }
+      }],
+      ["input7", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 6
+        }
+      }],
+      ["input8", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 7
+        }
+      }],
+      ["output", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: g.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "positive"],
+      ["transitionSpan", "6"],
+      ["initializationOrder", ""]
+    ])
+  },
+  [u.HalfAdder]: {
+    id: u.HalfAdder,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: g.Voltage
+      }],
+      ["inputA", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 0
+        }
+      }],
+      ["inputB", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 1
+        }
+      }],
+      ["sum", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "sum",
+          index: 0
+        }
+      }],
+      ["carry", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "carry",
+          index: 0
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: g.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["transitionSpan", "2"],
+      ["initializationOrder", ""]
+    ])
+  },
+  [u.Adder]: {
+    id: u.Adder,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: g.Voltage
+      }],
+      ["carryIn", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "carryIn",
+          index: 0
+        }
+      }],
+      ["inputA", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 0
+        }
+      }],
+      ["inputB", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 1
+        }
+      }],
+      ["sum", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "sum",
+          index: 0
+        }
+      }],
+      ["carryOut", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "carryOut",
+          index: 0
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: g.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["transitionSpan", "4"],
+      ["initializationOrder", ""]
+    ])
+  },
+  [u.EightBitAdder]: {
+    id: u.EightBitAdder,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: g.Voltage
+      }],
+      ["carryIn", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "carryIn",
+          index: 0
+        }
+      }],
+      ["inputA-0", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "inputA",
+          index: 0
+        }
+      }],
+      ["inputA-1", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "inputA",
+          index: 1
+        }
+      }],
+      ["inputA-2", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "inputA",
+          index: 2
+        }
+      }],
+      ["inputA-3", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "inputA",
+          index: 3
+        }
+      }],
+      ["inputA-4", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "inputA",
+          index: 4
+        }
+      }],
+      ["inputA-5", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "inputA",
+          index: 5
+        }
+      }],
+      ["inputA-6", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "inputA",
+          index: 6
+        }
+      }],
+      ["inputA-7", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "inputA",
+          index: 7
+        }
+      }],
+      ["inputB-0", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "inputB",
+          index: 0
+        }
+      }],
+      ["inputB-1", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "inputB",
+          index: 1
+        }
+      }],
+      ["inputB-2", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "inputB",
+          index: 2
+        }
+      }],
+      ["inputB-3", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "inputB",
+          index: 3
+        }
+      }],
+      ["inputB-4", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "inputB",
+          index: 4
+        }
+      }],
+      ["inputB-5", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "inputB",
+          index: 5
+        }
+      }],
+      ["inputB-6", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "inputB",
+          index: 6
+        }
+      }],
+      ["inputB-7", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "inputB",
+          index: 7
+        }
+      }],
+      ["sum-0", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "sum",
+          index: 0
+        }
+      }],
+      ["sum-1", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "sum",
+          index: 1
+        }
+      }],
+      ["sum-2", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "sum",
+          index: 2
+        }
+      }],
+      ["sum-3", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "sum",
+          index: 3
+        }
+      }],
+      ["sum-4", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "sum",
+          index: 4
+        }
+      }],
+      ["sum-5", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "sum",
+          index: 5
+        }
+      }],
+      ["sum-6", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "sum",
+          index: 6
+        }
+      }],
+      ["sum-7", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "sum",
+          index: 7
+        }
+      }],
+      ["carryOut", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "carryOut",
+          index: 0
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: g.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["transitionSpan", "4"],
+      ["initializationOrder", ""]
+    ])
+  },
+  [u.EightBitOnesComplement]: {
+    id: u.EightBitOnesComplement,
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: g.Voltage
+      }],
+      ["invert", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "invert",
+          index: 0
+        }
+      }],
+      ["input-0", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 0
+        }
+      }],
+      ["input-1", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 1
+        }
+      }],
+      ["input-2", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 2
+        }
+      }],
+      ["input-3", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 3
+        }
+      }],
+      ["input-4", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 4
+        }
+      }],
+      ["input-5", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 5
+        }
+      }],
+      ["input-6", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 6
+        }
+      }],
+      ["input-7", {
+        subtype: "logicInput",
+        logicPinData: {
+          interface: "input",
+          index: 7
+        }
+      }],
+      ["output-0", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 0
+        }
+      }],
+      ["output-1", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 1
+        }
+      }],
+      ["output-2", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 2
+        }
+      }],
+      ["output-3", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 3
+        }
+      }],
+      ["output-4", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 4
+        }
+      }],
+      ["output-5", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 5
+        }
+      }],
+      ["output-6", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 6
+        }
+      }],
+      ["output-7", {
+        subtype: "logicOutput",
+        logicPinData: {
+          interface: "output",
+          index: 7
+        }
+      }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: g.Current
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["transitionSpan", "3"],
+      ["initializationOrder", ""]
+    ])
+  }
+}, L = class tt {
+  id;
+  type;
+  component;
+  pinLabel;
+  position;
+  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;
+  }
+  getPosition(t) {
+    if (this.type === P.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}`);
+      return n.position;
+    }
+    if (!this.position) throw new Error("Branching point node missing position");
+    return this.position;
+  }
+  setPosition(t) {
+    Object.defineProperty(this, "position", {
+      value: t,
+      writable: !1,
+      enumerable: !0,
+      configurable: !0
+    });
+  }
+  setSourceType(t) {
+    Object.defineProperty(this, "source", {
+      value: t,
+      writable: !0,
+      enumerable: !0,
+      configurable: !0
+    });
+  }
+  toJSON() {
+    const t = {
+      id: this.id,
+      type: this.type,
+      source: this.source || null,
+      subtype: this.subtype
+    };
+    return this.type === P.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");
+    return Object.defineProperty(i, "id", {
+      value: t.id,
+      writable: !1,
+      enumerable: !0,
+      configurable: !1
+    }), i;
+  }
+}, E = class et {
+  id;
+  node1;
+  node2;
+  intermediatePositions;
+  constructor(t, n, i = []) {
+    this.id = $(), this.node1 = t, this.node2 = n, this.intermediatePositions = i;
+  }
+  isStraightLine() {
+    return this.intermediatePositions.length === 0;
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      node1: this.node1,
+      node2: this.node2,
+      intermediatePositions: this.intermediatePositions.map((t) => t.toJSON())
+    };
+  }
+  static fromJSON(t) {
+    const n = t.intermediatePositions.map((s) => V.fromJSON(s)), i = new et(t.node1, t.node2, n);
+    return Object.defineProperty(i, "id", {
+      value: t.id,
+      writable: !1,
+      enumerable: !0,
+      configurable: !1
+    }), i;
+  }
+}, z = class it {
+  id;
+  type;
+  position;
+  rotation;
+  pins;
+  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);
+      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;
+  }
+  getPinLabel(t) {
+    const n = this.pins.indexOf(t);
+    if (n === -1) return;
+    const i = I[this.type].pins.keys();
+    return Array.from(i)[n] || void 0;
+  }
+  getPinMetadata(t) {
+    const n = this.getPinLabel(t);
+    if (n)
+      return I[this.type].pins.get(n);
+  }
+  setAllParameters(t) {
+    this.config = new Map(t);
+  }
+  setParameter(t, n) {
+    this.config.set(t, n);
+  }
+  setPosition(t) {
+    Object.defineProperty(this, "position", {
+      value: t,
+      writable: !1,
+      enumerable: !0,
+      configurable: !0
+    });
+  }
+  setRotation(t) {
+    Object.defineProperty(this, "rotation", {
+      value: t,
+      writable: !1,
+      enumerable: !0,
+      configurable: !0
+    });
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      type: this.type,
+      position: this.position.toJSON(),
+      rotation: this.rotation.toJSON(),
+      pins: [...this.pins],
+      config: Object.fromEntries(this.config),
+      editable: this.editable
+    };
+  }
+  static fromJSON(t) {
+    const n = new it(t.type, V.fromJSON(t.position), yt.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,
+      enumerable: !0,
+      configurable: !1
+    }), n;
+  }
+}, H = class nt {
+  constructor(t = "Untitled Circuit", n = j) {
+    this.name = t, this.defaultLogicFamily = n;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      defaultLogicFamily: this.defaultLogicFamily
+    };
+  }
+  static fromJSON(t) {
+    return new nt(t.name, t.defaultLogicFamily);
+  }
+}, F = class st {
+  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})`);
+  }
+  toJSON() {
+    return {
+      version: this.version,
+      options: this.options.toJSON(),
+      size: this.size,
+      divisions: this.divisions,
+      cameraOptions: this.cameraOptions.toJSON()
+    };
+  }
+  static fromJSON(t) {
+    t.version !== "0.0.11" && console.warn(`This version of the engine supports v${Z} 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));
+  }
+  toString() {
+    return `CircuitMetadata(${this.version}, ${this.options.name}, ${this.options.defaultLogicFamily}, ${this.size}, ${this.divisions}, ${this.cameraOptions.toString()})`;
+  }
+}, vt = {
+  2: 1,
+  4: 1,
+  8: 2,
+  16: 2
+}, St = {
+  2: 2,
+  4: 2,
+  8: 3,
+  16: 3
+}, wt = {
+  2: 1,
+  4: 2,
+  8: 2,
+  16: 3
+}, mt = {
+  2: 2,
+  4: 3,
+  8: 3,
+  16: 4
+};
+function bt(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;
+  }
+}
+function Ct(e) {
+  return [
+    u.Inverter,
+    u.NandGate,
+    u.Nand4Gate,
+    u.Nand8Gate,
+    u.NorGate,
+    u.Nor4Gate,
+    u.Nor8Gate,
+    u.XorGate,
+    u.Xor4Gate,
+    u.Xor8Gate
+  ].includes(e);
+}
+function Pt(e, t) {
+  switch (e) {
+    case u.Inverter:
+      return {
+        gateFamily: t === "negative" ? "NOT" : "Buffer",
+        inputCount: 1
+      };
+    case u.NandGate:
+      return {
+        gateFamily: t === "negative" ? "NAND" : "AND",
+        inputCount: 2
+      };
+    case u.Nand4Gate:
+      return {
+        gateFamily: t === "negative" ? "NAND" : "AND",
+        inputCount: 4
+      };
+    case u.Nand8Gate:
+      return {
+        gateFamily: t === "negative" ? "NAND" : "AND",
+        inputCount: 8
+      };
+    case u.NorGate:
+      return {
+        gateFamily: t === "negative" ? "NOR" : "OR",
+        inputCount: 2
+      };
+    case u.Nor4Gate:
+      return {
+        gateFamily: t === "negative" ? "NOR" : "OR",
+        inputCount: 4
+      };
+    case u.Nor8Gate:
+      return {
+        gateFamily: t === "negative" ? "NOR" : "OR",
+        inputCount: 8
+      };
+    case u.XorGate:
+      return {
+        gateFamily: t === "negative" ? "XNOR" : "XOR",
+        inputCount: 2
+      };
+    case u.Xor4Gate:
+      return {
+        gateFamily: t === "negative" ? "XNOR" : "XOR",
+        inputCount: 4
+      };
+    case u.Xor8Gate:
+      return {
+        gateFamily: t === "negative" ? "XNOR" : "XOR",
+        inputCount: 8
+      };
+    default:
+      return null;
+  }
+}
+function xt(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;
+  if (t === "XOR") return Math.log2(n) * 2;
+  if (t === "XNOR") return Math.log2(n) * 2 + 1;
+  if (e === "CMOS1") {
+    const i = Math.log2(n);
+    switch (t) {
+      case "NAND":
+        return i;
+      case "NOR":
+        return i;
+      case "AND":
+        return i + 1;
+      case "OR":
+        return i + 1;
+    }
+  }
+  if (e === "TTL1") {
+    let i;
+    switch (t) {
+      case "NAND":
+        i = vt;
+        break;
+      case "AND":
+        i = St;
+        break;
+      case "NOR":
+        i = wt;
+        break;
+      case "OR":
+        i = mt;
+        break;
+    }
+    const s = i[n];
+    if (s === void 0) throw new Error(`Unsupported input count ${n} for TTL1 ${t}`);
+    return s;
+  }
+  throw new Error(`Unsupported logic family: ${e}`);
+}
+var me = class rt {
+  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();
+  }
+  get name() {
+    return this.metadata.options.name;
+  }
+  set name(t) {
+    if (typeof t != "string" || t.trim() === "") throw new TypeError("Circuit name must be a non-empty string");
+    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);
+    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);
+    }
+    return Object.defineProperty(a, "pins", {
+      value: o,
+      writable: !1,
+      enumerable: !0,
+      configurable: !1
+    }), this.components.set(a.id, a), a;
+  }
+  resolveTransitionSpan(t) {
+    if (!t.config.has("transitionSpan")) return;
+    const n = bt(t);
+    n && t.config.set("transitionSpan", String(n));
+  }
+  removeComponent(t) {
+    const n = this.components.get(t);
+    if (!n) throw new Error(`Component ${t} does not exist`);
+    const i = [], s = [];
+    for (const r of n.pins) {
+      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);
+      }
+      this.enodes.delete(r), s.push(r);
+    }
+    return this.components.delete(t), {
+      deletedWires: i,
+      deletedENodes: s
+    };
+  }
+  hasComponent(t) {
+    return this.components.has(t);
+  }
+  getComponent(t) {
+    return this.components.get(t);
+  }
+  getAllComponents() {
+    return Array.from(this.components.values());
+  }
+  getAllComponentsByType(t) {
+    const n = [];
+    for (const i of this.components.values()) i.type === t && n.push(i);
+    return n;
+  }
+  getFirstComponentOfType(t) {
+    for (const n of this.components.values()) if (n.type === t) return n;
+  }
+  getENode(t) {
+    return this.enodes.get(t);
+  }
+  getAllENodes() {
+    return Array.from(this.enodes.values());
+  }
+  addBranchingPoint(t, n) {
+    const i = new L(P.BranchingPoint, void 0, void 0, t, n);
+    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.`);
+    const i = {}, s = this.getWiresByNode(t);
+    if (s.length === 1 || s.length > 2) {
+      const r = [];
+      for (const a of s)
+        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 });
+    }
+    return this.enodes.delete(t), i;
+  }
+  addWire(t, n, i) {
+    if (t === n) return /* @__PURE__ */ new Error("Cannot create wire connecting node to itself");
+    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 || []);
+    return this.wires.set(a.id, a), s.wires.add(a.id), r.wires.add(a.id), a;
+  }
+  removeWire(t) {
+    const n = this.wires.get(t);
+    if (!n) throw new Error(`Wire ${t} does not exist`);
+    const i = this.enodes.get(n.node1), s = this.enodes.get(n.node2);
+    i && i.wires.delete(t), s && s.wires.delete(t), this.wires.delete(t);
+  }
+  splitWire(t, n, i = null) {
+    const s = this.wires.get(t);
+    if (!s) throw new Error(`Wire ${t} does not exist`);
+    const r = this.enodes.get(s.node1), a = this.enodes.get(s.node2);
+    if (!r || !a) throw new Error(`Wire ${t} is connected to non-existent ENodes`);
+    const o = [
+      r.getPosition(this),
+      ...s.intermediatePositions,
+      a.getPosition(this)
+    ], c = ht(o, n), p = o.slice(1, c), l = o.slice(c, 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 = [];
+    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}`);
+    }
+    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}`);
+    }
+    return {
+      branchingPoint: d,
+      wires: y
+    };
+  }
+  getWireBetweenNodes(t, n) {
+    const i = this.enodes.get(t);
+    if (i)
+      for (const s of i.wires) {
+        const r = this.wires.get(s);
+        if (r && (r.node2 === n || r.node1 === n)) return r;
+      }
+  }
+  getWire(t) {
+    return this.wires.get(t);
+  }
+  getAllWires() {
+    return Array.from(this.wires.values());
+  }
+  getWiresByNode(t) {
+    const n = this.enodes.get(t);
+    if (!n) return [];
+    const i = [];
+    for (const s of n.wires) {
+      const r = this.wires.get(s);
+      r && i.push(r);
+    }
+    return i;
+  }
+  getWiresByComponent(t) {
+    const n = this.components.get(t);
+    if (!n) return [];
+    const i = [];
+    for (const s of n.pins) i.push(...this.getWiresByNode(s));
+    return i;
+  }
+  getNodesByWire(t) {
+    const n = this.wires.get(t);
+    if (!n) return;
+    const i = this.enodes.get(n.node1), s = this.enodes.get(n.node2);
+    if (!(!i || !s))
+      return [i, s];
+  }
+  hasWireBetween(t, n) {
+    const i = this.enodes.get(t);
+    if (!i) return !1;
+    for (const s of i.wires) {
+      const r = this.wires.get(s);
+      if (r && (r.node2 === n || r.node1 === n)) return !0;
+    }
+    return !1;
+  }
+  getComponentsOfPins(t) {
+    const n = /* @__PURE__ */ new Set();
+    for (const i of t) {
+      const s = this.enodes.get(i);
+      s?.component && n.add(s.component);
+    }
+    return n;
+  }
+  getComponentPinByLabel(t, n) {
+    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;
+        i++;
+      }
+    }
+  }
+  updateWireIntermediatePositions(t, n, i = !1) {
+    const s = this.wires.get(t);
+    if (!s) throw new Error(`Wire ${t} does not exist`);
+    if (i) {
+      const r = M([
+        this.enodes.get(s.node1).getPosition(this),
+        ...n,
+        this.enodes.get(s.node2).getPosition(this)
+      ], 10);
+      s.intermediatePositions = r.slice(1, r.length - 1);
+    } else s.intermediatePositions = n;
+    return s;
+  }
+  simplifyWireIntermediatePositions(t) {
+    const n = this.wires.get(t);
+    if (!n) throw new Error(`Wire ${t} does not exist`);
+    const i = M([
+      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;
+  }
+  updateENodeSourceType(t, n) {
+    const i = this.enodes.get(t);
+    if (!i) throw new Error(`ENode ${t} does not exist`);
+    i.source = n || void 0;
+  }
+  getEnclosingSize(t = 0) {
+    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;
+      const s = i.position;
+      s && (n = Math.max(n, Math.abs(s.x), Math.abs(s.y)));
+    }
+    for (const i of this.wires.values()) for (const s of i.intermediatePositions) n = Math.max(n, Math.abs(s.x), Math.abs(s.y));
+    return Math.ceil(n * 2 + Math.max(t, 0));
+  }
+  toJSON() {
+    return {
+      metadata: this.metadata.toJSON(),
+      components: this.getAllComponents().map((t) => t.toJSON()),
+      enodes: this.getAllENodes().map((t) => t.toJSON()),
+      wires: this.getAllWires().map((t) => t.toJSON())
+    };
+  }
+  static fromJSON(t) {
+    const n = F.fromJSON(t.metadata), i = new rt(n.options);
+    i.metadata = n;
+    for (const s of t.components) {
+      const r = z.fromJSON(s);
+      i.components.set(r.id, r);
+    }
+    for (const s of t.enodes) {
+      const r = L.fromJSON(s);
+      i.enodes.set(r.id, r);
+    }
+    if (t.wires) for (const s of t.wires) {
+      const r = E.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 = {
+  MIN_TPS: 1,
+  MAX_TPS: 100,
+  DEFAULT_TPS: 3,
+  DEFAULT_INTERVAL_MS: 500
+}, at = {
+  TRANSITION_SPAN_TICKS: 1,
+  TRANSITION_USER_SPAN_MS: 200
+};
+function T(...e) {
+  return {
+    hasVoltage: e.some((t) => t.hasVoltage),
+    hasCurrent: e.some((t) => t.hasCurrent),
+    locked: !1
+  };
+}
+var J = class ot {
+  tick;
+  nodeStates;
+  wireStates;
+  componentStates;
+  constructor(t) {
+    if (t < 0 || !Number.isInteger(t)) throw new RangeError(`Tick must be a non-negative integer (got ${t})`);
+    this.tick = t, this.nodeStates = /* @__PURE__ */ new Map(), this.wireStates = /* @__PURE__ */ new Map(), this.componentStates = /* @__PURE__ */ new Map();
+  }
+  setTick(t) {
+    this.tick = t;
+  }
+  clone() {
+    const t = new ot(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 });
+    const s = /* @__PURE__ */ new Map();
+    for (const [r, a] of this.componentStates.entries()) s.set(r, Object.assign(Object.create(Object.getPrototypeOf(a)), a));
+    return Object.defineProperty(t, "nodeStates", {
+      value: n,
+      writable: !1,
+      configurable: !1,
+      enumerable: !0
+    }), Object.defineProperty(t, "wireStates", {
+      value: i,
+      writable: !1,
+      configurable: !1,
+      enumerable: !0
+    }), Object.defineProperty(t, "componentStates", {
+      value: s,
+      writable: !1,
+      configurable: !1,
+      enumerable: !0
+    }), t;
+  }
+}, b = class {
+  componentId;
+  _state;
+  _startTick;
+  _expirationTick;
+  _nextState;
+  parameters = /* @__PURE__ */ new Map();
+  pinStates = /* @__PURE__ */ new Map();
+  constructor(e, t) {
+    this.componentId = e, this._state = t, this._startTick = 0, this._expirationTick = -1, this._nextState = null;
+  }
+  get state() {
+    return this._state;
+  }
+  setState(e, t) {
+    this._state = e, this._startTick = t, this._expirationTick = -1, this._nextState = null;
+  }
+  get startTick() {
+    return this._startTick;
+  }
+  get expirationTick() {
+    return this._expirationTick;
+  }
+  get nextState() {
+    return this._nextState;
+  }
+  get hasExpiration() {
+    return this._expirationTick >= 0 && !!this._nextState && this._nextState !== this.state;
+  }
+  setNextState(e, t) {
+    this._nextState = e, this._expirationTick = t;
+  }
+}, It = class extends b {
+  constructor(e) {
+    super(e, "on");
+  }
+}, Tt = class extends b {
+  constructor(e, t = "off") {
+    super(e, t);
+  }
+  get isLit() {
+    return this.state === "on" || this.state === "goingOn";
+  }
+}, ct = class extends b {
+  constructor(e, t = "off") {
+    super(e, t);
+  }
+  get isLit() {
+    return this.state === "on" || this.state === "goingOn";
+  }
+}, Ot = class extends ct {
+}, Et = class extends b {
+  constructor(e, t = "open") {
+    super(e, t);
+  }
+  get isInTransition() {
+    return this.state === "closing" || this.state === "opening";
+  }
+  get isClosed() {
+    return this.state === "closed" || this.state === "closing";
+  }
+}, Nt = class extends b {
+  constructor(e, t = "open") {
+    super(e, t);
+  }
+  get isInTransition() {
+    return this.state === "closing" || this.state === "opening";
+  }
+  get isClosed() {
+    return this.state === "closed" || this.state === "closing";
+  }
+}, At = class extends b {
+  constructor(e, t = "input1") {
+    super(e, t);
+  }
+  get isInTransition() {
+    return this.state === "1to2" || this.state === "2to1";
+  }
+}, Bt = class extends b {
+  constructor(e) {
+    super(e, "high");
+  }
+}, w = class extends b {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+  get isInTransition() {
+    return this.state === "rising" || this.state === "falling";
+  }
+  get isHigh() {
+    return this.state === "high";
+  }
+}, Dt = class extends w {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}, Mt = class extends w {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}, Lt = class extends w {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}, kt = class extends w {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}, Gt = class extends w {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}, _t = class extends w {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}, Vt = class extends w {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}, $t = class extends w {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}, Rt = class extends w {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}, Wt = class extends w {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}, A = class extends b {
+  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.startsWith("to");
+  }
+  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;
+  }
+}, zt = class extends A {
+  constructor(e, t = "0") {
+    super(e, 2, t);
+  }
+  get sumHigh() {
+    return this.isOutputHigh(0);
+  }
+  get carryHigh() {
+    return this.isOutputHigh(1);
+  }
+}, Ht = class extends A {
+  constructor(e, t = "0") {
+    super(e, 2, t);
+  }
+  get sumHigh() {
+    return this.isOutputHigh(0);
+  }
+  get carryOutHigh() {
+    return this.isOutputHigh(1);
+  }
+}, Ft = class extends A {
+  constructor(e, t = "0000") {
+    super(e, 16, t);
+  }
+  isSumHigh(e) {
+    return this.isOutputHigh(2 * e);
+  }
+  isStageCarryHigh(e) {
+    return this.isOutputHigh(2 * e + 1);
+  }
+  isCarryOutHigh() {
+    return this.isStageCarryHigh(7);
+  }
+}, Jt = class extends A {
+  constructor(e, t = "000") {
+    super(e, 9, t);
+  }
+  isOutputBitHigh(e) {
+    return this.isOutputHigh(e);
+  }
+  isInvertHigh() {
+    return this.isOutputHigh(8);
+  }
+}, Ce = class {
+  behaviors;
+  constructor() {
+    this.behaviors = /* @__PURE__ */ new Map();
+  }
+  register(e) {
+    if (!e) throw new TypeError("Behavior cannot be null or undefined");
+    if (!e.componentType || e.componentType.trim() === "") throw new TypeError("Behavior componentType cannot be empty");
+    return this.behaviors.set(e.componentType, e), this;
+  }
+  registerAll(e) {
+    e.forEach((t) => this.register(t));
+  }
+  get(e) {
+    return this.behaviors.get(e);
+  }
+  has(e) {
+    return this.behaviors.has(e);
+  }
+  unregister(e) {
+    return this.behaviors.delete(e);
+  }
+  clear() {
+    this.behaviors.clear();
+  }
+  getRegisteredTypes() {
+    return Array.from(this.behaviors.keys());
+  }
+  size() {
+    return this.behaviors.size;
+  }
+}, C = class {
+  _componentType;
+  constructor(e) {
+    this._componentType = e;
+  }
+  get componentType() {
+    return this._componentType;
+  }
+  get typeMetadata() {
+    const e = I[this._componentType];
+    if (!e) throw new Error(`Unknown metadata for Component type ${this._componentType}`);
+    return e;
+  }
+  getPinStates(e, t) {
+    const n = /* @__PURE__ */ new Map();
+    for (const i of e.pins) n.set(e.getPinLabel(i), t.get(i));
+    return n;
+  }
+  getChangedPins(e, t) {
+    const n = /* @__PURE__ */ new Set();
+    for (const [i, s] of e) {
+      if (!t.has(i)) continue;
+      const r = t.get(i);
+      (s.hasVoltage !== r?.hasVoltage || s.hasCurrent !== r?.hasCurrent) && n.add(i);
+    }
+    return n;
+  }
+  onStart(e, t) {
+    return null;
+  }
+  onPinsChange(e, t, n, i) {
+    return {
+      componentState: t,
+      hasChanged: !1,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    };
+  }
+  allowConductivity(e, t, n, i, s) {
+    return !1;
+  }
+  onUserCommand(e, t, n) {
+    return {
+      componentState: t,
+      hasChanged: !1,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    };
+  }
+  onEventFiring(e, t, n) {
+    return {
+      componentState: t,
+      hasChanged: !1,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    };
+  }
+};
+function x(e) {
+  const t = parseInt(e.get("transitionSpan") || "", 10);
+  return isNaN(t) || t < 1 ? at.TRANSITION_SPAN_TICKS : t;
+}
+var Ut = class extends C {
+  constructor() {
+    super(u.Battery);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType) throw new Error(`Invalid component type for BatteryBehavior: ${e.type}`);
+    return new It(e.id);
+  }
+}, R = 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);
+    return n ? (t.state === "off" || t.state === "goingOff") && (s = !0, t.setState("goingOn", i), t.setNextState("on", i + o), r.push({
+      targetId: e.id,
+      scheduledAtTick: t.startTick,
+      readyAtTick: t.expirationTick,
+      type: "GoingOnEnd",
+      parameters: void 0
+    })) : (t.state === "on" || t.state === "goingOn") && (s = !0, t.setState("goingOff", i), t.setNextState("off", i + o), r.push({
+      targetId: e.id,
+      scheduledAtTick: t.startTick,
+      readyAtTick: t.expirationTick,
+      type: "GoingOffEnd",
+      parameters: void 0
+    })), {
+      componentState: t,
+      hasChanged: s,
+      shouldCancelPending: !0,
+      scheduledEvents: r
+    };
+  }
+  allowConductivity(e, t, n, i, s) {
+    return !0;
+  }
+  onEventFiring(e, t, n) {
+    let i = !1;
+    return n.type === "GoingOffEnd" ? t.state !== "off" && (i = !0, t.setState("off", n.readyAtTick)) : n.type === "GoingOnEnd" && t.state !== "on" && (i = !0, t.setState("on", n.readyAtTick)), {
+      componentState: t,
+      hasChanged: i,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    };
+  }
+}, Xt = class extends R {
+  constructor() {
+    super(u.Lightbulb);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType) throw new Error(`Invalid component type for lightbulbBehavior: ${e.type}`);
+    return new Tt(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;
+    return this.getBehavior(e, t, a, i);
+  }
+}, Qt = class extends R {
+  constructor() {
+    super(u.RectangleLED);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType) throw new Error(`Invalid component type for RectangleLEDBehavior: ${e.type}`);
+    return new Ot(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;
+    return this.getBehavior(e, t, a, i);
+  }
+};
+function qt(e) {
+  const t = parseInt(e.get("transitionSpan") || "", 10);
+  return isNaN(t) || t < 1 ? at.TRANSITION_SPAN_TICKS : t;
+}
+var Kt = class extends C {
+  constructor() {
+    super(u.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);
+  }
+  allowConductivity(e, t, n, i, s) {
+    if (i === s) return !0;
+    const r = e.getPinLabel(i), a = e.getPinLabel(s);
+    if (!r || !a) return !1;
+    const o = [r, a];
+    return o.includes("cmd_in") && o.includes("cmd_out") ? !0 : o.includes("power_in") && o.includes("power_out") ? t.state === "closed" || t.state === "opening" : !1;
+  }
+  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")));
+    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) {
+      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({
+          targetId: e.id,
+          scheduledAtTick: t.startTick,
+          readyAtTick: t.expirationTick,
+          type: "ClosingEnd",
+          parameters: /* @__PURE__ */ new Map([["exclusive", "true"]])
+        });
+      }
+    } 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({
+        targetId: e.id,
+        scheduledAtTick: t.startTick,
+        readyAtTick: t.expirationTick,
+        type: "OpeningEnd",
+        parameters: /* @__PURE__ */ new Map([["exclusive", "true"]])
+      });
+    }
+    return {
+      componentState: t,
+      hasChanged: l,
+      shouldCancelPending: l,
+      scheduledEvents: d
+    };
+  }
+  onEventFiring(e, t, n) {
+    let i = !1;
+    return n.type === "ClosingEnd" ? t.state !== "closed" && (t.setState("closed", n.readyAtTick), i = !0) : n.type === "OpeningEnd" && t.state !== "open" && (t.setState("open", n.readyAtTick), i = !0), {
+      componentState: t,
+      hasChanged: i,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    };
+  }
+}, Yt = class extends R {
+  constructor() {
+    super(u.SmallLED);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType) throw new Error(`Invalid component type for SmallLEDBehavior: ${e.type}`);
+    return new ct(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;
+    return this.getBehavior(e, t, a, i);
+  }
+}, Zt = class extends C {
+  constructor() {
+    super(u.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);
+  }
+  allowConductivity(e, t, n, i, s) {
+    return t.state === "closed" || t.state === "opening";
+  }
+  onPinsChange(e, t, n, i) {
+    const s = this.getPinStates(e, n), r = t.pinStates;
+    t.pinStates = s;
+    const a = this.getChangedPins(s, r);
+    return a.size < 1 || !a.has("output") ? {
+      componentState: t,
+      hasChanged: !1,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    } : {
+      componentState: t,
+      hasChanged: !0,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    };
+  }
+  onUserCommand(e, t, n) {
+    let i = !1;
+    const s = [], r = x(e.config);
+    return n.type === "toggle_switch" && ["open", "closed"].includes(t.state) && (t.setState(t.state === "open" ? "closing" : "opening", n.scheduledAtTick), t.setNextState(t.state === "closing" ? "closed" : "open", n.scheduledAtTick + r), i = !0, s.push({
+      targetId: e.id,
+      scheduledAtTick: t.startTick,
+      readyAtTick: t.expirationTick,
+      type: t.state === "closing" ? "ClosingEnd" : "OpeningEnd",
+      parameters: /* @__PURE__ */ new Map([["exclusive", "true"]])
+    })), {
+      componentState: t,
+      hasChanged: i,
+      shouldCancelPending: !0,
+      scheduledEvents: s
+    };
+  }
+  onEventFiring(e, t, n) {
+    let i = !1;
+    return n.type === "ClosingEnd" ? t.state !== "closed" && (t.setState("closed", n.readyAtTick), i = !0) : n.type === "OpeningEnd" && t.state !== "open" && (t.setState("open", n.readyAtTick), i = !0), {
+      componentState: t,
+      hasChanged: i,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    };
+  }
+}, jt = class extends C {
+  constructor() {
+    super(u.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);
+  }
+  allowConductivity(e, t, n, i, s) {
+    if (i === s) return !0;
+    const r = e.getPinLabel(i), a = e.getPinLabel(s);
+    if (!r || !a) return !1;
+    const o = [r, a];
+    return o.includes("output") && o.includes("input1") ? t.state === "input1" || t.state === "1to2" : o.includes("output") && o.includes("input2") ? t.state === "input2" || t.state === "2to1" : !1;
+  }
+  onPinsChange(e, t, n, i) {
+    const s = this.getPinStates(e, n), r = t.pinStates;
+    t.pinStates = s;
+    const a = this.getChangedPins(s, r);
+    return a.size < 1 || !a.has("output") ? {
+      componentState: t,
+      hasChanged: !1,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    } : {
+      componentState: t,
+      hasChanged: !0,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    };
+  }
+  onUserCommand(e, t, n) {
+    let i = !1;
+    const s = [], r = x(e.config);
+    return n.type === "toggle_switch" && ["input1", "input2"].includes(t.state) && (t.setState(t.state === "input1" ? "1to2" : "2to1", n.scheduledAtTick), t.setNextState(t.state === "1to2" ? "input2" : "input1", n.scheduledAtTick + r), i = !0, s.push({
+      targetId: e.id,
+      scheduledAtTick: t.startTick,
+      readyAtTick: t.expirationTick,
+      type: t.state === "1to2" ? "ContactedInput2" : "ContactedInput1",
+      parameters: /* @__PURE__ */ new Map([["exclusive", "true"]])
+    })), {
+      componentState: t,
+      hasChanged: i,
+      shouldCancelPending: !0,
+      scheduledEvents: s
+    };
+  }
+  onEventFiring(e, t, n) {
+    let i = !1;
+    return n.type === "ContactedInput2" ? t.state !== "input2" && (t.setState("input2", n.readyAtTick), i = !0) : n.type === "ContactedInput1" && t.state !== "input1" && (t.setState("input1", n.readyAtTick), i = !0), {
+      componentState: t,
+      hasChanged: i,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    };
+  }
+}, te = class extends C {
+  constructor() {
+    super(u.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";
+    t.setState(n ? "high" : "low", 0);
+    const i = Number(e.config.get("halfPeriod"));
+    return t.setNextState(n ? "low" : "high", i), t;
+  }
+  allowConductivity(e, t, n, i, s) {
+    if (i === s) return !0;
+    const r = e.getPinLabel(i), a = e.getPinLabel(s);
+    if (!r || !a) return !1;
+    const o = [r, a];
+    return o.includes("gnd") && o.includes("vcc") ? !1 : o.includes("gnd") && o.includes("output") ? t.state === "low" : o.includes("vcc") && o.includes("output") ? t.state === "high" : !1;
+  }
+  onStart(e, t) {
+    const i = Number(e.config.get("halfPeriod"));
+    return t.setNextState(t.state === "high" ? "low" : "high", 0 + i), {
+      componentState: t,
+      hasChanged: !0,
+      shouldCancelPending: !0,
+      scheduledEvents: [{
+        targetId: e.id,
+        scheduledAtTick: t.startTick,
+        readyAtTick: t.expirationTick,
+        type: "tick",
+        parameters: /* @__PURE__ */ new Map([["exclusive", "true"]])
+      }]
+    };
+  }
+  onEventFiring(e, t, n) {
+    if (n.type !== "tick") return {
+      componentState: t,
+      hasChanged: !1,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    };
+    const i = Number(e.config.get("halfPeriod"));
+    return t.setState(t.state === "high" ? "low" : "high", n.readyAtTick), t.setNextState(t.state === "high" ? "low" : "high", n.readyAtTick + i), {
+      componentState: t,
+      hasChanged: !0,
+      shouldCancelPending: !0,
+      scheduledEvents: [{
+        targetId: e.id,
+        scheduledAtTick: t.startTick,
+        readyAtTick: t.expirationTick,
+        type: "tick",
+        parameters: /* @__PURE__ */ new Map([["exclusive", "true"]])
+      }]
+    };
+  }
+}, m = class extends C {
+  vccGuardBehavior(e, t, n) {
+    if (t.get("vcc").hasVoltage) return null;
+    let i = !1, s = !1;
+    return e.state !== "low" && (e.setState("low", n), i = !0, s = !0), {
+      componentState: e,
+      hasChanged: i,
+      shouldCancelPending: s,
+      scheduledEvents: []
+    };
+  }
+  nonLogicInputGuardBehavior(e, t, n) {
+    let i = !1;
+    const s = this.typeMetadata.pins;
+    for (const [o, c] of t) {
+      if (!s.has(o)) continue;
+      const p = s.get(o);
+      if (p && p?.subtype === "logicInput") {
+        if (c.hasVoltage && c.hasCurrent) {
+          i = !0;
+          break;
+        }
+        if (!c.hasVoltage && !c.hasCurrent) {
+          i = !0;
+          break;
+        }
+      }
+    }
+    if (!i) return null;
+    let r = !1, a = !1;
+    return e.state !== "indeterminate" && (e.setState("indeterminate", n), r = !0, a = !0), {
+      componentState: e,
+      hasChanged: r,
+      shouldCancelPending: a,
+      scheduledEvents: []
+    };
+  }
+  getBehavior(e, t, n, i) {
+    if (![
+      "low",
+      "rising",
+      "high",
+      "falling",
+      "indeterminate"
+    ].includes(t.state))
+      return t.setState("low", i), {
+        componentState: t,
+        hasChanged: !0,
+        shouldCancelPending: !0,
+        scheduledEvents: []
+      };
+    const s = x(e.config), r = t.expirationTick < 1 ? s : Math.max(i - t.startTick, 1);
+    if (n) {
+      if (t.state === "low" || t.state === "falling" || t.state === "indeterminate")
+        return t.setState("rising", i), t.setNextState("high", i + r), {
+          componentState: t,
+          hasChanged: !0,
+          shouldCancelPending: !0,
+          scheduledEvents: [{
+            targetId: e.id,
+            scheduledAtTick: t.startTick,
+            readyAtTick: t.expirationTick,
+            type: "RisingComplete",
+            parameters: void 0
+          }]
+        };
+      if (t.state === "rising" || t.state === "high") return {
+        componentState: t,
+        hasChanged: !1,
+        shouldCancelPending: !1,
+        scheduledEvents: []
+      };
+    }
+    return t.state === "falling" || t.state === "low" ? {
+      componentState: t,
+      hasChanged: !1,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    } : t.state === "high" || t.state === "rising" || t.state === "indeterminate" ? (t.setState("falling", i), t.setNextState("low", i + r), {
+      componentState: t,
+      hasChanged: !0,
+      shouldCancelPending: !0,
+      scheduledEvents: [{
+        targetId: e.id,
+        scheduledAtTick: t.startTick,
+        readyAtTick: t.expirationTick,
+        type: "FallingComplete",
+        parameters: void 0
+      }]
+    }) : (t.setState("low", i), {
+      componentState: t,
+      hasChanged: !0,
+      shouldCancelPending: !0,
+      scheduledEvents: []
+    });
+  }
+  allowConductivity(e, t, n, i, s) {
+    if (i === s) return !0;
+    const r = e.getPinLabel(i), a = e.getPinLabel(s);
+    if (!r || !a) return !1;
+    const o = [r, a];
+    return o.includes("vcc") && o.includes("output") ? t.state === "high" || t.state === "falling" : o.includes("gnd") && o.includes("output") ? t.state === "low" || t.state === "rising" : !1;
+  }
+  onEventFiring(e, t, n) {
+    let i = !1;
+    return n.type === "RisingComplete" ? t.state !== "high" && (i = !0, t.setState("high", n.readyAtTick)) : n.type === "FallingComplete" && t.state !== "low" && (i = !0, t.setState("low", n.readyAtTick)), {
+      componentState: t,
+      hasChanged: i,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    };
+  }
+}, ee = class extends m {
+  constructor() {
+    super(u.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);
+  }
+  onPinsChange(e, t, n, i) {
+    const s = this.getPinStates(e, n);
+    t.pinStates = s;
+    const r = this.vccGuardBehavior(t, s, i);
+    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);
+  }
+}, ie = class extends m {
+  constructor() {
+    super(u.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);
+  }
+  onPinsChange(e, t, n, i) {
+    const s = this.getPinStates(e, n);
+    t.pinStates = s;
+    const r = this.vccGuardBehavior(t, s, i);
+    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);
+  }
+}, ne = class extends m {
+  constructor() {
+    super(u.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);
+  }
+  onPinsChange(e, t, n, i) {
+    const s = this.getPinStates(e, n);
+    t.pinStates = s;
+    const r = this.vccGuardBehavior(t, s, i);
+    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);
+  }
+}, se = class extends m {
+  constructor() {
+    super(u.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);
+  }
+  onPinsChange(e, t, n, i) {
+    const s = this.getPinStates(e, n);
+    t.pinStates = s;
+    const r = this.vccGuardBehavior(t, s, i);
+    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);
+  }
+}, re = class extends m {
+  constructor() {
+    super(u.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);
+  }
+  onPinsChange(e, t, n, i) {
+    const s = this.getPinStates(e, n);
+    t.pinStates = s;
+    const r = this.vccGuardBehavior(t, s, i);
+    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);
+  }
+}, ae = class extends m {
+  constructor() {
+    super(u.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);
+  }
+  onPinsChange(e, t, n, i) {
+    const s = this.getPinStates(e, n);
+    t.pinStates = s;
+    const r = this.vccGuardBehavior(t, s, i);
+    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);
+  }
+}, oe = class extends m {
+  constructor() {
+    super(u.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);
+  }
+  onPinsChange(e, t, n, i) {
+    const s = this.getPinStates(e, n);
+    t.pinStates = s;
+    const r = this.vccGuardBehavior(t, s, i);
+    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);
+  }
+}, ce = class extends m {
+  constructor() {
+    super(u.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);
+  }
+  onPinsChange(e, t, n, i) {
+    const s = this.getPinStates(e, n);
+    t.pinStates = s;
+    const r = this.vccGuardBehavior(t, s, i);
+    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);
+  }
+}, ue = class extends m {
+  constructor() {
+    super(u.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);
+  }
+  onPinsChange(e, t, n, i) {
+    const s = this.getPinStates(e, n);
+    t.pinStates = s;
+    const r = this.vccGuardBehavior(t, s, i);
+    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);
+  }
+}, le = class extends m {
+  constructor() {
+    super(u.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);
+  }
+  onPinsChange(e, t, n, i) {
+    const s = this.getPinStates(e, n);
+    t.pinStates = s;
+    const r = this.vccGuardBehavior(t, s, i);
+    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);
+  }
+}, B = 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);
+    if (o) return o;
+    const c = this.computeTargetStableState(s);
+    return this.scheduleTransition(e, r, c, i);
+  }
+  onEventFiring(e, t, n) {
+    if (!n.type.startsWith("to")) return this.noChange(t);
+    const i = n.type.slice(2);
+    return t.state === i ? this.noChange(t) : (t.setState(i, n.readyAtTick), t.parameters.delete("prevState"), {
+      componentState: t,
+      hasChanged: !0,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    });
+  }
+  allowConductivity(e, t, n, i, s) {
+    if (i === s) return !0;
+    const r = t.effectiveState;
+    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;
+    const d = t;
+    return (parseInt(r, 16) >> (c.logicPinData.interface === "sum" ? c.logicPinData.index * 2 : d.outputCount - 1) & 1) === 1 ? l === 1 : l === -1;
+  }
+  vccGuardBehavior(e, t, n) {
+    if (t.get("vcc").hasVoltage) return null;
+    const i = e.allLowState;
+    return e.state === i ? {
+      componentState: e,
+      hasChanged: !1,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    } : (e.setState(i, n), e.parameters.delete("prevState"), {
+      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" ? {
+      componentState: e,
+      hasChanged: !1,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    } : (e.setState("indeterminate", n), e.parameters.delete("prevState"), {
+      componentState: e,
+      hasChanged: !0,
+      shouldCancelPending: !0,
+      scheduledEvents: []
+    }) : null;
+  }
+  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), {
+      componentState: t,
+      hasChanged: !0,
+      shouldCancelPending: !0,
+      scheduledEvents: [{
+        targetId: e.id,
+        scheduledAtTick: t.startTick,
+        readyAtTick: t.expirationTick,
+        type: s,
+        parameters: void 0
+      }]
+    };
+  }
+  noChange(e) {
+    return {
+      componentState: e,
+      hasChanged: !1,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    };
+  }
+}, pe = class extends B {
+  constructor() {
+    super(u.HalfAdder);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType) throw new Error(`Invalid component type for HalfAdderBehavior: ${e.type}`);
+    return new zt(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 {
+  constructor() {
+    super(u.Adder);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType) throw new Error(`Invalid component type for AdderBehavior: ${e.type}`);
+    return new Ht(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 {
+  constructor() {
+    super(u.EightBitAdder);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType) throw new Error(`Invalid component type for EightBitAdderBehavior: ${e.type}`);
+    return new Ft(e.id, "0000");
+  }
+  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);
+    if (o) return o;
+    if (i === 0) {
+      const h = this.computeTargetStableState(s);
+      return this.scheduleTransition(e, r, h, i);
+    }
+    const c = r.effectiveState, p = c === "indeterminate" ? 0 : parseInt(c, 16), l = 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);
+    }
+    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), {
+      componentState: r,
+      hasChanged: !0,
+      shouldCancelPending: !0,
+      scheduledEvents: [{
+        targetId: e.id,
+        scheduledAtTick: i,
+        readyAtTick: i + f,
+        type: `to${y}`,
+        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;
+    if (r.state === i) return this.noChange(r);
+    if (r.setState(i, n.readyAtTick), r.parameters.delete("prevState"), s >= N) 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 {
+      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), {
+      componentState: r,
+      hasChanged: !0,
+      shouldCancelPending: !1,
+      scheduledEvents: [{
+        targetId: e.id,
+        scheduledAtTick: n.readyAtTick,
+        readyAtTick: n.readyAtTick + h,
+        type: `to${v}`,
+        parameters: /* @__PURE__ */ new Map([["nextStage", `${s + 1}`]])
+      }]
+    };
+  }
+  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;
+    }
+    return _(n);
+  }
+};
+function k(e, t, n) {
+  return {
+    sum: e !== t !== n,
+    carry: e && t || e && n || t && n
+  };
+}
+function G(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) {
+  return e.toString(16).padStart(4, "0");
+}
+var U = 8, ge = class extends B {
+  constructor() {
+    super(u.EightBitOnesComplement);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType) throw new Error(`Invalid component type for EightBitOnesComplementBehavior: ${e.type}`);
+    return new Jt(e.id, "000");
+  }
+  allowConductivity(e, t, n, i, s) {
+    if (i === s) return !0;
+    const r = t.effectiveState;
+    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;
+  }
+  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");
+  }
+}, fe = class {
+  heap;
+  constructor() {
+    this.heap = [];
+  }
+  schedule(e) {
+    if (e.readyAtTick < e.scheduledAtTick) throw new RangeError(`readyAtTick (${e.readyAtTick}) cannot be before scheduledAtTick (${e.scheduledAtTick})`);
+    this.heap.push(e), this.bubbleUp(this.heap.length - 1);
+  }
+  getReadyEvents(e) {
+    const t = [];
+    for (; this.heap.length > 0 && this.heap[0].readyAtTick <= e; ) {
+      const n = this.extractMin();
+      n && t.push(n);
+    }
+    return t.sort((n, i) => n.readyAtTick === i.readyAtTick ? n.scheduledAtTick - i.scheduledAtTick : n.readyAtTick - i.readyAtTick), t;
+  }
+  hasEvents() {
+    return this.heap.length > 0;
+  }
+  clear() {
+    this.heap = [];
+  }
+  scheduleMany(e, t) {
+    for (const n of e) if (n.readyAtTick < n.scheduledAtTick) throw new RangeError(`readyAtTick (${n.readyAtTick}) cannot be before scheduledAtTick (${n.scheduledAtTick})`);
+    t && t.size > 0 && (this.heap = this.heap.filter((n) => !t.has(n.targetId)));
+    for (const n of e) this.heap.push(n);
+    (e.length > 0 || t && t.size > 0) && this.rebuildHeap();
+  }
+  removeEventsForTarget(e) {
+    const t = this.heap.length;
+    return this.heap = this.heap.filter((n) => n.targetId !== e), this.heap.length !== t && this.rebuildHeap(), t - this.heap.length;
+  }
+  size() {
+    return this.heap.length;
+  }
+  rebuildHeap() {
+    for (let e = Math.floor(this.heap.length / 2) - 1; e >= 0; e--) this.bubbleDown(e);
+  }
+  bubbleUp(e) {
+    for (; e > 0; ) {
+      const t = Math.floor((e - 1) / 2);
+      if (this.heap[e].readyAtTick < this.heap[t].readyAtTick)
+        [this.heap[e], this.heap[t]] = [this.heap[t], this.heap[e]], e = t;
+      else break;
+    }
+  }
+  bubbleDown(e) {
+    const t = this.heap.length;
+    for (; ; ) {
+      const n = 2 * e + 1, i = 2 * e + 2;
+      let s = e;
+      if (n < t && this.heap[n].readyAtTick < this.heap[s].readyAtTick && (s = n), i < t && this.heap[i].readyAtTick < this.heap[s].readyAtTick && (s = i), s !== e)
+        [this.heap[e], this.heap[s]] = [this.heap[s], this.heap[e]], e = s;
+      else break;
+    }
+  }
+  extractMin() {
+    if (this.heap.length === 0) return;
+    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 {
+  dirtyComponents;
+  dirtyWires;
+  dirtyEnodes;
+  constructor() {
+    this.dirtyComponents = /* @__PURE__ */ new Set(), this.dirtyWires = /* @__PURE__ */ new Set(), this.dirtyEnodes = /* @__PURE__ */ new Set();
+  }
+  markComponentDirty(e) {
+    this.dirtyComponents.add(e);
+  }
+  markWireDirty(e) {
+    this.dirtyWires.add(e);
+  }
+  markEnodeDirty(e) {
+    this.dirtyEnodes.add(e);
+  }
+  setDirtyComponents(e) {
+    this.dirtyComponents = new Set(e);
+  }
+  setDirtyEnodes(e) {
+    this.dirtyEnodes = new Set(e);
+  }
+  setDirtyWires(e) {
+    this.dirtyWires = new Set(e);
+  }
+  getDirtyElements() {
+    const e = {
+      components: new Set(this.dirtyComponents),
+      wires: new Set(this.dirtyWires),
+      enodes: new Set(this.dirtyEnodes)
+    };
+    return this.clear(), e;
+  }
+  hasDirtyElements() {
+    return this.dirtyComponents.size > 0 || this.dirtyWires.size > 0 || this.dirtyEnodes.size > 0;
+  }
+  clear() {
+    this.dirtyComponents.clear(), this.dirtyWires.clear(), this.dirtyEnodes.clear();
+  }
+  getDirtyComponentCount() {
+    return this.dirtyComponents.size;
+  }
+  getDirtyWireCount() {
+    return this.dirtyWires.size;
+  }
+  getDirtyEnodeCount() {
+    return this.dirtyEnodes.size;
+  }
+}, ve = class {
+  currentState;
+  history;
+  historyEnabled;
+  historyLimit;
+  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;
+  }
+  getCurrentState() {
+    return this.currentState;
+  }
+  getCurrentTick() {
+    return this.currentState.tick;
+  }
+  advanceToNextTick() {
+    const e = this.currentState.tick + 1;
+    return this.historyEnabled && this.saveToHistory(this.currentState.clone()), this.currentState.tick = e, this.currentState;
+  }
+  getStateAtTick(e) {
+    if (this.historyEnabled)
+      return this.history.find((t) => t.tick === e);
+  }
+  getHistory() {
+    return this.historyEnabled ? [...this.history].sort((e, t) => e.tick - t.tick) : [];
+  }
+  getOldestTick() {
+    if (!(!this.historyEnabled || this.history.length === 0))
+      return Math.min(...this.history.map((e) => e.tick));
+  }
+  getNewestHistoricalTick() {
+    if (!(!this.historyEnabled || this.history.length === 0))
+      return Math.max(...this.history.map((e) => e.tick));
+  }
+  clearHistory() {
+    this.history = [], this.historyWriteIndex = 0;
+  }
+  reset() {
+    this.currentState = new J(0), this.clearHistory();
+  }
+  isHistoryEnabled() {
+    return this.historyEnabled;
+  }
+  getHistoryLimit() {
+    return this.historyLimit;
+  }
+  getHistorySize() {
+    return this.history.length;
+  }
+  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 {
+  circuit;
+  stateManager;
+  eventQueue;
+  commands;
+  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();
+    try {
+      this.initializeState();
+    } catch (i) {
+      throw console.error("Error during CircuitRunner initialization:", i), i;
+    }
+  }
+  tick() {
+    const e = this.eventQueue.size(), t = this.stateManager.getCurrentTick(), n = this.applyReadyEvents(t + 1), i = this.updateState(t + 1);
+    i.firedEventCount = n.length, i.processedCommandCount = this.processCommands().length, i.scheduledEventCount = this.eventQueue.size() + i.firedEventCount - e;
+    for (const s of n) s.hasChanged && this.dirtyTracker.markComponentDirty(s.componentState.componentId);
+    return i.componentUpdateCount = this.dirtyTracker.getDirtyComponentCount(), this.stateManager.advanceToNextTick(), i.endTick = this.stateManager.getCurrentTick(), i;
+  }
+  tickN(e) {
+    if (e < 1) throw new RangeError(`Tick count must be at least 1 (got ${e})`);
+    const t = [];
+    for (let n = 0; n < e; n++) t.push(this.tick());
+    return t;
+  }
+  reset() {
+    this.stateManager.reset(), this.eventQueue.clear(), this.dirtyTracker.clear(), this.initializeState();
+  }
+  getCurrentTick() {
+    return this.stateManager.getCurrentTick();
+  }
+  getCurrentState() {
+    return this.stateManager.getCurrentState();
+  }
+  getEnodeState(e) {
+    return this.stateManager.getCurrentState().nodeStates.get(e);
+  }
+  getWireState(e) {
+    return this.stateManager.getCurrentState().wireStates.get(e);
+  }
+  getComponentState(e) {
+    return this.stateManager.getCurrentState().componentStates.get(e);
+  }
+  getStateAtTick(e) {
+    return this.stateManager.getStateAtTick(e);
+  }
+  hasBehavior(e) {
+    return this.behaviorRegistry.has(e);
+  }
+  submitCommand(e) {
+    if (!this.circuit.hasComponent(e.targetId)) throw Error(`Cannot submit command for unknown component ID '${e.targetId}'`);
+    return this.commands.has(e.targetId) ? !1 : (e.scheduledAtTick = this.getCurrentTick(), this.commands.set(e.targetId, e), !0);
+  }
+  processCommands() {
+    const e = this.stateManager.getCurrentState(), t = [], n = /* @__PURE__ */ new Set(), i = [];
+    for (const s of this.commands.values()) {
+      const r = this.circuit.getComponent(s.targetId), a = this.behaviorRegistry.get(r.type).onUserCommand(r, e.componentStates.get(r.id), s);
+      a.shouldCancelPending && n.add(r.id);
+      for (const o of a.scheduledEvents) i.push(o);
+      t.push(a), a.hasChanged && this.dirtyTracker.markComponentDirty(r.id);
+    }
+    return this.eventQueue.scheduleMany(i, n), this.commands.clear(), t;
+  }
+  getInitializationOrder(e) {
+    const t = e.get("initializationOrder");
+    if (!t || t === "") return 0;
+    const n = parseInt(t, 10);
+    return isNaN(n) ? 0 : n;
+  }
+  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 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 c of this.circuit.getAllWires()) e.wireStates.set(c.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);
+    }
+    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));
+    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);
+          if (!d) continue;
+          const y = e.componentStates.get(l.id);
+          if (!y) continue;
+          this.propagateConductivity();
+          const f = d.onStart(l, y);
+          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);
+            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 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;
+  }
+  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);
+    }));
+    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);
+    }
+    return this.eventQueue.scheduleMany(p, c), 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,
+      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));
+      }
+      for (const h of l) {
+        const S = e.nodeStates.get(h);
+        S && !S.locked && S[v] && (S[v] = !1, o.add(h));
+      }
+      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 h of d) {
+        const S = e.wireStates.get(h);
+        S && S[v] && (S[v] = !1, c.add(h));
+      }
+      return {
+        updatedNodes: o,
+        updatedWires: c
+      };
+    }, { updatedNodes: n, updatedWires: i } = t(g.Voltage), { updatedNodes: s, updatedWires: r } = t(g.Current);
+    return {
+      updatedNodes: /* @__PURE__ */ new Set([...n, ...s]),
+      updatedWires: /* @__PURE__ */ new Set([...i, ...r])
+    };
+  }
+  computeReachability(e, t, n) {
+    const i = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), r = [];
+    for (const a of t)
+      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);
+      }
+      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)));
+      }
+    }
+    return {
+      nodes: i,
+      wires: s
+    };
+  }
+  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);
+    }
+    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 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 Te(e) {
+  return e.register(new pe()).register(new de()).register(new he()).register(new ge()), 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
+};
+
+//# sourceMappingURL=core-b6Q8w2sn.js.map