@tscircuit/curvy-trace-solver 0.0.1

package/dist/index.js

@@ -0,0 +1,1643 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/is-buffer/index.js
+var require_is_buffer = __commonJS({
+  "node_modules/is-buffer/index.js"(exports, module) {
+    "use strict";
+    module.exports = function(obj) {
+      return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer);
+    };
+    function isBuffer(obj) {
+      return !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+    }
+    function isSlowBuffer(obj) {
+      return typeof obj.readFloatLE === "function" && typeof obj.slice === "function" && isBuffer(obj.slice(0, 0));
+    }
+  }
+});
+
+// node_modules/kind-of/index.js
+var require_kind_of = __commonJS({
+  "node_modules/kind-of/index.js"(exports, module) {
+    "use strict";
+    var isBuffer = require_is_buffer();
+    var toString = Object.prototype.toString;
+    module.exports = function kindOf(val) {
+      if (typeof val === "undefined") {
+        return "undefined";
+      }
+      if (val === null) {
+        return "null";
+      }
+      if (val === true || val === false || val instanceof Boolean) {
+        return "boolean";
+      }
+      if (typeof val === "string" || val instanceof String) {
+        return "string";
+      }
+      if (typeof val === "number" || val instanceof Number) {
+        return "number";
+      }
+      if (typeof val === "function" || val instanceof Function) {
+        return "function";
+      }
+      if (typeof Array.isArray !== "undefined" && Array.isArray(val)) {
+        return "array";
+      }
+      if (val instanceof RegExp) {
+        return "regexp";
+      }
+      if (val instanceof Date) {
+        return "date";
+      }
+      var type = toString.call(val);
+      if (type === "[object RegExp]") {
+        return "regexp";
+      }
+      if (type === "[object Date]") {
+        return "date";
+      }
+      if (type === "[object Arguments]") {
+        return "arguments";
+      }
+      if (type === "[object Error]") {
+        return "error";
+      }
+      if (isBuffer(val)) {
+        return "buffer";
+      }
+      if (type === "[object Set]") {
+        return "set";
+      }
+      if (type === "[object WeakSet]") {
+        return "weakset";
+      }
+      if (type === "[object Map]") {
+        return "map";
+      }
+      if (type === "[object WeakMap]") {
+        return "weakmap";
+      }
+      if (type === "[object Symbol]") {
+        return "symbol";
+      }
+      if (type === "[object Int8Array]") {
+        return "int8array";
+      }
+      if (type === "[object Uint8Array]") {
+        return "uint8array";
+      }
+      if (type === "[object Uint8ClampedArray]") {
+        return "uint8clampedarray";
+      }
+      if (type === "[object Int16Array]") {
+        return "int16array";
+      }
+      if (type === "[object Uint16Array]") {
+        return "uint16array";
+      }
+      if (type === "[object Int32Array]") {
+        return "int32array";
+      }
+      if (type === "[object Uint32Array]") {
+        return "uint32array";
+      }
+      if (type === "[object Float32Array]") {
+        return "float32array";
+      }
+      if (type === "[object Float64Array]") {
+        return "float64array";
+      }
+      return "object";
+    };
+  }
+});
+
+// node_modules/rename-keys/index.js
+var require_rename_keys = __commonJS({
+  "node_modules/rename-keys/index.js"(exports, module) {
+    "use strict";
+    (function() {
+      "use strict";
+      function rename2(obj, fn) {
+        if (typeof fn !== "function") {
+          return obj;
+        }
+        var res = {};
+        for (var key in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            res[fn(key, obj[key]) || key] = obj[key];
+          }
+        }
+        return res;
+      }
+      if (typeof module !== "undefined" && module.exports) {
+        module.exports = rename2;
+      } else {
+        if (typeof define === "function" && define.amd) {
+          define([], function() {
+            return rename2;
+          });
+        } else {
+          window.rename = rename2;
+        }
+      }
+    })();
+  }
+});
+
+// node_modules/deep-rename-keys/index.js
+var require_deep_rename_keys = __commonJS({
+  "node_modules/deep-rename-keys/index.js"(exports, module) {
+    "use strict";
+    var typeOf = require_kind_of();
+    var rename2 = require_rename_keys();
+    module.exports = function renameDeep(obj, cb) {
+      var type = typeOf(obj);
+      if (type !== "object" && type !== "array") {
+        throw new Error("expected an object");
+      }
+      var res = [];
+      if (type === "object") {
+        obj = rename2(obj, cb);
+        res = {};
+      }
+      for (var key in obj) {
+        if (obj.hasOwnProperty(key)) {
+          var val = obj[key];
+          if (typeOf(val) === "object" || typeOf(val) === "array") {
+            res[key] = renameDeep(val, cb);
+          } else {
+            res[key] = val;
+          }
+        }
+      }
+      return res;
+    };
+  }
+});
+
+// node_modules/xml-reader/node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS({
+  "node_modules/xml-reader/node_modules/eventemitter3/index.js"(exports, module) {
+    "use strict";
+    var has = Object.prototype.hasOwnProperty;
+    var prefix = "~";
+    function Events() {
+    }
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__) prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function EventEmitter() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    EventEmitter.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0) return names;
+      for (name in events = this._events) {
+        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter.prototype.listeners = function listeners(event, exists) {
+      var evt = prefix ? prefix + event : event, available = this._events[evt];
+      if (exists) return !!available;
+      if (!available) return [];
+      if (available.fn) return [available.fn];
+      for (var i = 0, l = available.length, ee = new Array(l); i < l; i++) {
+        ee[i] = available[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter.prototype.on = function on(event, fn, context) {
+      var listener = new EE(fn, context || this), evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) this._events[evt] = listener, this._eventsCount++;
+      else if (!this._events[evt].fn) this._events[evt].push(listener);
+      else this._events[evt] = [this._events[evt], listener];
+      return this;
+    };
+    EventEmitter.prototype.once = function once(event, fn, context) {
+      var listener = new EE(fn, context || this, true), evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) this._events[evt] = listener, this._eventsCount++;
+      else if (!this._events[evt].fn) this._events[evt].push(listener);
+      else this._events[evt] = [this._events[evt], listener];
+      return this;
+    };
+    EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        if (--this._eventsCount === 0) this._events = new Events();
+        else delete this._events[evt];
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          if (--this._eventsCount === 0) this._events = new Events();
+          else delete this._events[evt];
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+        else if (--this._eventsCount === 0) this._events = new Events();
+        else delete this._events[evt];
+      }
+      return this;
+    };
+    EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt]) {
+          if (--this._eventsCount === 0) this._events = new Events();
+          else delete this._events[evt];
+        }
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+    EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+    EventEmitter.prototype.setMaxListeners = function setMaxListeners() {
+      return this;
+    };
+    EventEmitter.prefixed = prefix;
+    EventEmitter.EventEmitter = EventEmitter;
+    if ("undefined" !== typeof module) {
+      module.exports = EventEmitter;
+    }
+  }
+});
+
+// node_modules/xml-lexer/node_modules/eventemitter3/index.js
+var require_eventemitter32 = __commonJS({
+  "node_modules/xml-lexer/node_modules/eventemitter3/index.js"(exports, module) {
+    "use strict";
+    var has = Object.prototype.hasOwnProperty;
+    var prefix = "~";
+    function Events() {
+    }
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__) prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function EventEmitter() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    EventEmitter.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0) return names;
+      for (name in events = this._events) {
+        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter.prototype.listeners = function listeners(event, exists) {
+      var evt = prefix ? prefix + event : event, available = this._events[evt];
+      if (exists) return !!available;
+      if (!available) return [];
+      if (available.fn) return [available.fn];
+      for (var i = 0, l = available.length, ee = new Array(l); i < l; i++) {
+        ee[i] = available[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter.prototype.on = function on(event, fn, context) {
+      var listener = new EE(fn, context || this), evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) this._events[evt] = listener, this._eventsCount++;
+      else if (!this._events[evt].fn) this._events[evt].push(listener);
+      else this._events[evt] = [this._events[evt], listener];
+      return this;
+    };
+    EventEmitter.prototype.once = function once(event, fn, context) {
+      var listener = new EE(fn, context || this, true), evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) this._events[evt] = listener, this._eventsCount++;
+      else if (!this._events[evt].fn) this._events[evt].push(listener);
+      else this._events[evt] = [this._events[evt], listener];
+      return this;
+    };
+    EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        if (--this._eventsCount === 0) this._events = new Events();
+        else delete this._events[evt];
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          if (--this._eventsCount === 0) this._events = new Events();
+          else delete this._events[evt];
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+        else if (--this._eventsCount === 0) this._events = new Events();
+        else delete this._events[evt];
+      }
+      return this;
+    };
+    EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt]) {
+          if (--this._eventsCount === 0) this._events = new Events();
+          else delete this._events[evt];
+        }
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+    EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+    EventEmitter.prototype.setMaxListeners = function setMaxListeners() {
+      return this;
+    };
+    EventEmitter.prefixed = prefix;
+    EventEmitter.EventEmitter = EventEmitter;
+    if ("undefined" !== typeof module) {
+      module.exports = EventEmitter;
+    }
+  }
+});
+
+// node_modules/xml-lexer/dist/lexer.js
+var require_lexer = __commonJS({
+  "node_modules/xml-lexer/dist/lexer.js"(exports, module) {
+    "use strict";
+    function _defineProperty(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    var EventEmitter = require_eventemitter32();
+    var noop = function noop2() {
+    };
+    var State = {
+      data: "state-data",
+      cdata: "state-cdata",
+      tagBegin: "state-tag-begin",
+      tagName: "state-tag-name",
+      tagEnd: "state-tag-end",
+      attributeNameStart: "state-attribute-name-start",
+      attributeName: "state-attribute-name",
+      attributeNameEnd: "state-attribute-name-end",
+      attributeValueBegin: "state-attribute-value-begin",
+      attributeValue: "state-attribute-value"
+    };
+    var Action = {
+      lt: "action-lt",
+      gt: "action-gt",
+      space: "action-space",
+      equal: "action-equal",
+      quote: "action-quote",
+      slash: "action-slash",
+      char: "action-char",
+      error: "action-error"
+    };
+    var Type = {
+      text: "text",
+      openTag: "open-tag",
+      closeTag: "close-tag",
+      attributeName: "attribute-name",
+      attributeValue: "attribute-value"
+    };
+    var charToAction = {
+      " ": Action.space,
+      "	": Action.space,
+      "\n": Action.space,
+      "\r": Action.space,
+      "<": Action.lt,
+      ">": Action.gt,
+      '"': Action.quote,
+      "'": Action.quote,
+      "=": Action.equal,
+      "/": Action.slash
+    };
+    var getAction = function getAction2(char) {
+      return charToAction[char] || Action.char;
+    };
+    var create = function create2(options) {
+      var _State$data, _State$tagBegin, _State$tagName, _State$tagEnd, _State$attributeNameS, _State$attributeName, _State$attributeNameE, _State$attributeValue, _State$attributeValue2, _lexer$stateMachine;
+      options = Object.assign({ debug: false }, options);
+      var lexer = new EventEmitter();
+      var state = State.data;
+      var data = "";
+      var tagName = "";
+      var attrName = "";
+      var attrValue = "";
+      var isClosing = "";
+      var openingQuote = "";
+      var emit = function emit2(type, value) {
+        if (tagName[0] === "?" || tagName[0] === "!") {
+          return;
+        }
+        var event = { type, value };
+        if (options.debug) {
+          console.log("emit:", event);
+        }
+        lexer.emit("data", event);
+      };
+      lexer.stateMachine = (_lexer$stateMachine = {}, _defineProperty(_lexer$stateMachine, State.data, (_State$data = {}, _defineProperty(_State$data, Action.lt, function() {
+        if (data.trim()) {
+          emit(Type.text, data);
+        }
+        tagName = "";
+        isClosing = false;
+        state = State.tagBegin;
+      }), _defineProperty(_State$data, Action.char, function(char) {
+        data += char;
+      }), _State$data)), _defineProperty(_lexer$stateMachine, State.cdata, _defineProperty({}, Action.char, function(char) {
+        data += char;
+        if (data.substr(-3) === "]]>") {
+          emit(Type.text, data.slice(0, -3));
+          data = "";
+          state = State.data;
+        }
+      })), _defineProperty(_lexer$stateMachine, State.tagBegin, (_State$tagBegin = {}, _defineProperty(_State$tagBegin, Action.space, noop), _defineProperty(_State$tagBegin, Action.char, function(char) {
+        tagName = char;
+        state = State.tagName;
+      }), _defineProperty(_State$tagBegin, Action.slash, function() {
+        tagName = "";
+        isClosing = true;
+      }), _State$tagBegin)), _defineProperty(_lexer$stateMachine, State.tagName, (_State$tagName = {}, _defineProperty(_State$tagName, Action.space, function() {
+        if (isClosing) {
+          state = State.tagEnd;
+        } else {
+          state = State.attributeNameStart;
+          emit(Type.openTag, tagName);
+        }
+      }), _defineProperty(_State$tagName, Action.gt, function() {
+        if (isClosing) {
+          emit(Type.closeTag, tagName);
+        } else {
+          emit(Type.openTag, tagName);
+        }
+        data = "";
+        state = State.data;
+      }), _defineProperty(_State$tagName, Action.slash, function() {
+        state = State.tagEnd;
+        emit(Type.openTag, tagName);
+      }), _defineProperty(_State$tagName, Action.char, function(char) {
+        tagName += char;
+        if (tagName === "![CDATA[") {
+          state = State.cdata;
+          data = "";
+          tagName = "";
+        }
+      }), _State$tagName)), _defineProperty(_lexer$stateMachine, State.tagEnd, (_State$tagEnd = {}, _defineProperty(_State$tagEnd, Action.gt, function() {
+        emit(Type.closeTag, tagName);
+        data = "";
+        state = State.data;
+      }), _defineProperty(_State$tagEnd, Action.char, noop), _State$tagEnd)), _defineProperty(_lexer$stateMachine, State.attributeNameStart, (_State$attributeNameS = {}, _defineProperty(_State$attributeNameS, Action.char, function(char) {
+        attrName = char;
+        state = State.attributeName;
+      }), _defineProperty(_State$attributeNameS, Action.gt, function() {
+        data = "";
+        state = State.data;
+      }), _defineProperty(_State$attributeNameS, Action.space, noop), _defineProperty(_State$attributeNameS, Action.slash, function() {
+        isClosing = true;
+        state = State.tagEnd;
+      }), _State$attributeNameS)), _defineProperty(_lexer$stateMachine, State.attributeName, (_State$attributeName = {}, _defineProperty(_State$attributeName, Action.space, function() {
+        state = State.attributeNameEnd;
+      }), _defineProperty(_State$attributeName, Action.equal, function() {
+        emit(Type.attributeName, attrName);
+        state = State.attributeValueBegin;
+      }), _defineProperty(_State$attributeName, Action.gt, function() {
+        attrValue = "";
+        emit(Type.attributeName, attrName);
+        emit(Type.attributeValue, attrValue);
+        data = "";
+        state = State.data;
+      }), _defineProperty(_State$attributeName, Action.slash, function() {
+        isClosing = true;
+        attrValue = "";
+        emit(Type.attributeName, attrName);
+        emit(Type.attributeValue, attrValue);
+        state = State.tagEnd;
+      }), _defineProperty(_State$attributeName, Action.char, function(char) {
+        attrName += char;
+      }), _State$attributeName)), _defineProperty(_lexer$stateMachine, State.attributeNameEnd, (_State$attributeNameE = {}, _defineProperty(_State$attributeNameE, Action.space, noop), _defineProperty(_State$attributeNameE, Action.equal, function() {
+        emit(Type.attributeName, attrName);
+        state = State.attributeValueBegin;
+      }), _defineProperty(_State$attributeNameE, Action.gt, function() {
+        attrValue = "";
+        emit(Type.attributeName, attrName);
+        emit(Type.attributeValue, attrValue);
+        data = "";
+        state = State.data;
+      }), _defineProperty(_State$attributeNameE, Action.char, function(char) {
+        attrValue = "";
+        emit(Type.attributeName, attrName);
+        emit(Type.attributeValue, attrValue);
+        attrName = char;
+        state = State.attributeName;
+      }), _State$attributeNameE)), _defineProperty(_lexer$stateMachine, State.attributeValueBegin, (_State$attributeValue = {}, _defineProperty(_State$attributeValue, Action.space, noop), _defineProperty(_State$attributeValue, Action.quote, function(char) {
+        openingQuote = char;
+        attrValue = "";
+        state = State.attributeValue;
+      }), _defineProperty(_State$attributeValue, Action.gt, function() {
+        attrValue = "";
+        emit(Type.attributeValue, attrValue);
+        data = "";
+        state = State.data;
+      }), _defineProperty(_State$attributeValue, Action.char, function(char) {
+        openingQuote = "";
+        attrValue = char;
+        state = State.attributeValue;
+      }), _State$attributeValue)), _defineProperty(_lexer$stateMachine, State.attributeValue, (_State$attributeValue2 = {}, _defineProperty(_State$attributeValue2, Action.space, function(char) {
+        if (openingQuote) {
+          attrValue += char;
+        } else {
+          emit(Type.attributeValue, attrValue);
+          state = State.attributeNameStart;
+        }
+      }), _defineProperty(_State$attributeValue2, Action.quote, function(char) {
+        if (openingQuote === char) {
+          emit(Type.attributeValue, attrValue);
+          state = State.attributeNameStart;
+        } else {
+          attrValue += char;
+        }
+      }), _defineProperty(_State$attributeValue2, Action.gt, function(char) {
+        if (openingQuote) {
+          attrValue += char;
+        } else {
+          emit(Type.attributeValue, attrValue);
+          data = "";
+          state = State.data;
+        }
+      }), _defineProperty(_State$attributeValue2, Action.slash, function(char) {
+        if (openingQuote) {
+          attrValue += char;
+        } else {
+          emit(Type.attributeValue, attrValue);
+          isClosing = true;
+          state = State.tagEnd;
+        }
+      }), _defineProperty(_State$attributeValue2, Action.char, function(char) {
+        attrValue += char;
+      }), _State$attributeValue2)), _lexer$stateMachine);
+      var step = function step2(char) {
+        if (options.debug) {
+          console.log(state, char);
+        }
+        var actions = lexer.stateMachine[state];
+        var action = actions[getAction(char)] || actions[Action.error] || actions[Action.char];
+        action(char);
+      };
+      lexer.write = function(str) {
+        var len = str.length;
+        for (var i = 0; i < len; i++) {
+          step(str[i]);
+        }
+      };
+      return lexer;
+    };
+    module.exports = {
+      State,
+      Action,
+      Type,
+      create
+    };
+  }
+});
+
+// node_modules/xml-reader/dist/reader.js
+var require_reader = __commonJS({
+  "node_modules/xml-reader/dist/reader.js"(exports, module) {
+    "use strict";
+    var EventEmitter = require_eventemitter3();
+    var Lexer = require_lexer();
+    var Type = Lexer.Type;
+    var NodeType = {
+      element: "element",
+      text: "text"
+    };
+    var createNode = function createNode2(params) {
+      return Object.assign({
+        name: "",
+        type: NodeType.element,
+        value: "",
+        parent: null,
+        attributes: {},
+        children: []
+      }, params);
+    };
+    var create = function create2(options) {
+      options = Object.assign({
+        stream: false,
+        parentNodes: true,
+        doneEvent: "done",
+        tagPrefix: "tag:",
+        emitTopLevelOnly: false,
+        debug: false
+      }, options);
+      var lexer = void 0, rootNode = void 0, current = void 0, attrName = void 0;
+      var reader = new EventEmitter();
+      var handleLexerData = function handleLexerData2(data) {
+        switch (data.type) {
+          case Type.openTag:
+            if (current === null) {
+              current = rootNode;
+              current.name = data.value;
+            } else {
+              var node = createNode({
+                name: data.value,
+                parent: current
+              });
+              current.children.push(node);
+              current = node;
+            }
+            break;
+          case Type.closeTag:
+            var parent = current.parent;
+            if (!options.parentNodes) {
+              current.parent = null;
+            }
+            if (current.name !== data.value) {
+              break;
+            }
+            if (options.stream && parent === rootNode) {
+              rootNode.children = [];
+              current.parent = null;
+            }
+            if (!options.emitTopLevelOnly || parent === rootNode) {
+              reader.emit(options.tagPrefix + current.name, current);
+              reader.emit("tag", current.name, current);
+            }
+            if (current === rootNode) {
+              lexer.removeAllListeners("data");
+              reader.emit(options.doneEvent, current);
+              rootNode = null;
+            }
+            current = parent;
+            break;
+          case Type.text:
+            if (current) {
+              current.children.push(createNode({
+                type: NodeType.text,
+                value: data.value,
+                parent: options.parentNodes ? current : null
+              }));
+            }
+            break;
+          case Type.attributeName:
+            attrName = data.value;
+            current.attributes[attrName] = "";
+            break;
+          case Type.attributeValue:
+            current.attributes[attrName] = data.value;
+            break;
+        }
+      };
+      reader.reset = function() {
+        lexer = Lexer.create({ debug: options.debug });
+        lexer.on("data", handleLexerData);
+        rootNode = createNode();
+        current = null;
+        attrName = "";
+        reader.parse = lexer.write;
+      };
+      reader.reset();
+      return reader;
+    };
+    var parseSync2 = function parseSync3(xml, options) {
+      options = Object.assign({}, options, { stream: false, tagPrefix: ":" });
+      var reader = create(options);
+      var res = void 0;
+      reader.on("done", function(ast) {
+        res = ast;
+      });
+      reader.parse(xml);
+      return res;
+    };
+    module.exports = {
+      parseSync: parseSync2,
+      create,
+      NodeType
+    };
+  }
+});
+
+// node_modules/transformation-matrix/src/rotate.js
+var { cos, sin, PI } = Math;
+
+// node_modules/transformation-matrix/src/skew.js
+var { tan } = Math;
+
+// node_modules/svgson/dist/svgson.esm.js
+var import_deep_rename_keys = __toESM(require_deep_rename_keys());
+var import_xml_reader = __toESM(require_reader());
+
+// node_modules/@tscircuit/solver-utils/dist/index.js
+var BaseSolver = class {
+  MAX_ITERATIONS = 1e5;
+  solved = false;
+  failed = false;
+  iterations = 0;
+  progress = 0;
+  error = null;
+  activeSubSolver;
+  failedSubSolvers;
+  timeToSolve;
+  stats = {};
+  _setupDone = false;
+  setup() {
+    if (this._setupDone) return;
+    this._setup();
+    this._setupDone = true;
+  }
+  /** Override this method to perform setup logic */
+  _setup() {
+  }
+  /** DO NOT OVERRIDE! Override _step() instead */
+  step() {
+    if (!this._setupDone) {
+      this.setup();
+    }
+    if (this.solved) return;
+    if (this.failed) return;
+    this.iterations++;
+    try {
+      this._step();
+    } catch (e) {
+      this.error = `${this.constructor.name} error: ${e}`;
+      this.failed = true;
+      throw e;
+    }
+    if (!this.solved && this.iterations >= this.MAX_ITERATIONS) {
+      this.tryFinalAcceptance();
+    }
+    if (!this.solved && this.iterations >= this.MAX_ITERATIONS) {
+      this.error = `${this.constructor.name} ran out of iterations`;
+      this.failed = true;
+    }
+    if ("computeProgress" in this) {
+      this.progress = this.computeProgress();
+    }
+  }
+  /** Override this method to implement solver logic */
+  _step() {
+  }
+  getConstructorParams() {
+    throw new Error("getConstructorParams not implemented");
+  }
+  /**
+   * Override this method to return the standardized output of the solver.
+   * This method should only be called after the solver has completed successfully.
+   * Returns null by default - solvers with outputs should override this method.
+   */
+  getOutput() {
+    return null;
+  }
+  solve() {
+    const startTime = Date.now();
+    while (!this.solved && !this.failed) {
+      this.step();
+    }
+    const endTime = Date.now();
+    this.timeToSolve = endTime - startTime;
+  }
+  visualize() {
+    return {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: []
+    };
+  }
+  /**
+   * Called when the solver is about to fail, but we want to see if we have an
+   * "acceptable" or "passable" solution. Mostly used for optimizers that
+   * have an aggressive early stopping criterion.
+   */
+  tryFinalAcceptance() {
+  }
+  /**
+   * A lightweight version of the visualize method that can be used to stream
+   * progress
+   */
+  preview() {
+    return {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: []
+    };
+  }
+};
+
+// lib/visualization-utils/visualizeCurvyTraceProblem.ts
+var visualizeCurvyTraceProblem = (problem, outputTraces = []) => {
+  const graphics = {
+    arrows: [],
+    circles: [],
+    lines: [],
+    rects: [],
+    coordinateSystem: "cartesian",
+    points: [],
+    texts: [],
+    title: "Curvy Trace Problem"
+  };
+  graphics.lines.push({
+    points: [
+      { x: problem.bounds.minX, y: problem.bounds.minY },
+      { x: problem.bounds.maxX, y: problem.bounds.minY },
+      { x: problem.bounds.maxX, y: problem.bounds.maxY },
+      { x: problem.bounds.minX, y: problem.bounds.maxY },
+      { x: problem.bounds.minX, y: problem.bounds.minY }
+    ],
+    strokeColor: "rgba(0, 0, 0, 0.1)"
+  });
+  for (const waypointPair of problem.waypointPairs) {
+    graphics.points.push({
+      ...waypointPair.start,
+      label: `start ${waypointPair.networkId ?? ""}`,
+      color: getColorForNetworkId(waypointPair.networkId)
+    });
+    graphics.points.push({
+      ...waypointPair.end,
+      label: `end ${waypointPair.networkId ?? ""}`,
+      color: getColorForNetworkId(waypointPair.networkId)
+    });
+  }
+  for (const obstacle of problem.obstacles) {
+    graphics.rects.push({
+      center: obstacle.center,
+      width: obstacle.maxX - obstacle.minX,
+      height: obstacle.maxY - obstacle.minY,
+      fill: "rgba(128, 128, 128, 0.3)",
+      stroke: "rgba(128, 128, 128, 0.8)"
+    });
+  }
+  for (const trace of outputTraces) {
+    graphics.lines.push({
+      points: trace.points,
+      strokeColor: getColorForNetworkId(trace.networkId)
+    });
+  }
+  return graphics;
+};
+
+// lib/visualization-utils/index.ts
+var hashString = (str) => {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = str.charCodeAt(i) * 779 + ((hash << 5) - hash);
+  }
+  return hash;
+};
+var getColorForNetworkId = (networkId) => {
+  if (!networkId) return "rgba(0, 0, 0, 0.5)";
+  return `hsl(${hashString(networkId) % 360}, 100%, 50%)`;
+};
+
+// lib/geometry/getObstacleOuterSegments.ts
+var getObstacleOuterSegments = (obstacle) => {
+  const segments = [
+    [
+      { x: obstacle.minX, y: obstacle.minY },
+      { x: obstacle.maxX, y: obstacle.minY }
+    ],
+    [
+      { x: obstacle.maxX, y: obstacle.minY },
+      { x: obstacle.maxX, y: obstacle.maxY }
+    ],
+    [
+      { x: obstacle.maxX, y: obstacle.maxY },
+      { x: obstacle.minX, y: obstacle.maxY }
+    ],
+    [
+      { x: obstacle.minX, y: obstacle.maxY },
+      { x: obstacle.minX, y: obstacle.minY }
+    ]
+  ];
+  return segments;
+};
+
+// lib/CurvyTraceSolver.ts
+function getPerimeterT(p, bounds) {
+  const { minX, maxX, minY, maxY } = bounds;
+  const W = maxX - minX;
+  const H = maxY - minY;
+  const eps = 1e-6;
+  if (Math.abs(p.y - maxY) < eps) return p.x - minX;
+  if (Math.abs(p.x - maxX) < eps) return W + (maxY - p.y);
+  if (Math.abs(p.y - minY) < eps) return W + H + (maxX - p.x);
+  if (Math.abs(p.x - minX) < eps) return 2 * W + H + (p.y - minY);
+  return 0;
+}
+function getPerimeterPoint(t, bounds) {
+  const { minX, maxX, minY, maxY } = bounds;
+  const W = maxX - minX;
+  const H = maxY - minY;
+  const perimeter = 2 * W + 2 * H;
+  t = (t % perimeter + perimeter) % perimeter;
+  if (t <= W) return { x: minX + t, y: maxY };
+  if (t <= W + H) return { x: maxX, y: maxY - (t - W) };
+  if (t <= 2 * W + H) return { x: maxX - (t - W - H), y: minY };
+  return { x: minX, y: minY + (t - 2 * W - H) };
+}
+function sampleCubicBezierInline(p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y, points, numSamples) {
+  for (let i = 0; i <= numSamples; i++) {
+    const t = i / numSamples;
+    const mt = 1 - t;
+    const mt2 = mt * mt;
+    const mt3 = mt2 * mt;
+    const t2 = t * t;
+    const t3 = t2 * t;
+    const idx = i * 2;
+    points[idx] = mt3 * p0x + 3 * mt2 * t * p1x + 3 * mt * t2 * p2x + t3 * p3x;
+    points[idx + 1] = mt3 * p0y + 3 * mt2 * t * p1y + 3 * mt * t2 * p2y + t3 * p3y;
+  }
+}
+function sampleCubicBezier(p0, p1, p2, p3, numSamples) {
+  const points = [];
+  for (let i = 0; i <= numSamples; i++) {
+    const t = i / numSamples;
+    const mt = 1 - t;
+    const mt2 = mt * mt;
+    const mt3 = mt2 * mt;
+    const t2 = t * t;
+    const t3 = t2 * t;
+    points.push({
+      x: mt3 * p0.x + 3 * mt2 * t * p1.x + 3 * mt * t2 * p2.x + t3 * p3.x,
+      y: mt3 * p0.y + 3 * mt2 * t * p1.y + 3 * mt * t2 * p2.y + t3 * p3.y
+    });
+  }
+  return points;
+}
+function ptSegDistSq(px, py, sx, sy, ex, ey) {
+  const dx = ex - sx;
+  const dy = ey - sy;
+  const lenSq = dx * dx + dy * dy;
+  if (lenSq === 0) {
+    const dpx2 = px - sx;
+    const dpy2 = py - sy;
+    return dpx2 * dpx2 + dpy2 * dpy2;
+  }
+  const t = Math.max(0, Math.min(1, ((px - sx) * dx + (py - sy) * dy) / lenSq));
+  const projX = sx + t * dx;
+  const projY = sy + t * dy;
+  const dpx = px - projX;
+  const dpy = py - projY;
+  return dpx * dpx + dpy * dpy;
+}
+function segmentDistSq(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y) {
+  const d1 = (b2x - b1x) * (a1y - b1y) - (b2y - b1y) * (a1x - b1x);
+  const d2 = (b2x - b1x) * (a2y - b1y) - (b2y - b1y) * (a2x - b1x);
+  const d3 = (a2x - a1x) * (b1y - a1y) - (a2y - a1y) * (b1x - a1x);
+  const d4 = (a2x - a1x) * (b2y - a1y) - (a2y - a1y) * (b2x - a1x);
+  if ((d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0)) {
+    return 0;
+  }
+  return Math.min(
+    ptSegDistSq(a1x, a1y, b1x, b1y, b2x, b2y),
+    ptSegDistSq(a2x, a2y, b1x, b1y, b2x, b2y),
+    ptSegDistSq(b1x, b1y, a1x, a1y, a2x, a2y),
+    ptSegDistSq(b2x, b2y, a1x, a1y, a2x, a2y)
+  );
+}
+function chordContains(aT1, aT2, bT1, bT2, perimeter) {
+  const normalize = (t) => (t % perimeter + perimeter) % perimeter;
+  const a1 = normalize(aT1), a2 = normalize(aT2);
+  const b1 = normalize(bT1), b2 = normalize(bT2);
+  const [aMin, aMax] = a1 < a2 ? [a1, a2] : [a2, a1];
+  return b1 > aMin && b1 < aMax && b2 > aMin && b2 < aMax;
+}
+function getBoundsCenter(bounds) {
+  return {
+    x: (bounds.minX + bounds.maxX) / 2,
+    y: (bounds.minY + bounds.maxY) / 2
+  };
+}
+function computeTraceBounds(points, numPoints) {
+  let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+  for (let i = 0; i < numPoints; i++) {
+    const x = points[i * 2], y = points[i * 2 + 1];
+    if (x < minX) minX = x;
+    if (x > maxX) maxX = x;
+    if (y < minY) minY = y;
+    if (y > maxY) maxY = y;
+  }
+  return { minX, maxX, minY, maxY };
+}
+var OPT_SAMPLES = 5;
+var OUTPUT_SAMPLES = 20;
+var CurvyTraceSolver = class extends BaseSolver {
+  constructor(problem) {
+    super();
+    this.problem = problem;
+    for (const obstacle of this.problem.obstacles) {
+      obstacle.outerSegments = getObstacleOuterSegments(obstacle);
+    }
+    this.precomputeObstacles();
+  }
+  outputTraces = [];
+  traces = [];
+  optimizationStep = 0;
+  maxOptimizationSteps = 100;
+  // Typed arrays for faster sampling
+  sampledPoints = [];
+  traceBounds = [];
+  // Pre-computed obstacle segments as flat arrays
+  obstacleSegments = new Float64Array(0);
+  obstacleNetworkIds = [];
+  numObstacleSegments = 0;
+  // Collision pairs cache - which traces can possibly collide
+  collisionPairs = [];
+  lastCost = Infinity;
+  stagnantSteps = 0;
+  getConstructorParams() {
+    return this.problem;
+  }
+  precomputeObstacles() {
+    const { obstacles } = this.problem;
+    let totalSegments = 0;
+    for (const obs of obstacles) {
+      if (obs.outerSegments) totalSegments += obs.outerSegments.length;
+    }
+    this.obstacleSegments = new Float64Array(totalSegments * 4);
+    this.obstacleNetworkIds = [];
+    this.numObstacleSegments = totalSegments;
+    let idx = 0;
+    for (const obs of obstacles) {
+      if (obs.outerSegments) {
+        for (const seg of obs.outerSegments) {
+          this.obstacleSegments[idx++] = seg[0].x;
+          this.obstacleSegments[idx++] = seg[0].y;
+          this.obstacleSegments[idx++] = seg[1].x;
+          this.obstacleSegments[idx++] = seg[1].y;
+          this.obstacleNetworkIds.push(obs.networkId);
+        }
+      }
+    }
+  }
+  initializeTraces() {
+    const { bounds, waypointPairs } = this.problem;
+    const { minX, maxX, minY, maxY } = bounds;
+    const W = maxX - minX;
+    const H = maxY - minY;
+    const perimeter = 2 * W + 2 * H;
+    const center = getBoundsCenter(bounds);
+    const tracesWithT = waypointPairs.map((pair, idx) => ({
+      pair,
+      t1: getPerimeterT(pair.start, bounds),
+      t2: getPerimeterT(pair.end, bounds),
+      idx
+    }));
+    const nestingDepth = /* @__PURE__ */ new Map();
+    for (const trace of tracesWithT) {
+      let depth = 0;
+      for (const other of tracesWithT) {
+        if (trace.idx !== other.idx && chordContains(other.t1, other.t2, trace.t1, trace.t2, perimeter)) {
+          depth++;
+        }
+      }
+      nestingDepth.set(trace.idx, depth);
+    }
+    const maxDepth = Math.max(...Array.from(nestingDepth.values()), 1);
+    this.traces = tracesWithT.map(({ pair, t1, t2, idx }) => {
+      let dt = t2 - t1;
+      if (dt > perimeter / 2) dt -= perimeter;
+      if (dt < -perimeter / 2) dt += perimeter;
+      const tCtrl1 = t1 + dt * 0.33;
+      const tCtrl2 = t1 + dt * 0.67;
+      const pPerim1 = getPerimeterPoint(tCtrl1, bounds);
+      const pPerim2 = getPerimeterPoint(tCtrl2, bounds);
+      const pLinear1 = {
+        x: pair.start.x + (pair.end.x - pair.start.x) * 0.33,
+        y: pair.start.y + (pair.end.y - pair.start.y) * 0.33
+      };
+      const pLinear2 = {
+        x: pair.start.x + (pair.end.x - pair.start.x) * 0.67,
+        y: pair.start.y + (pair.end.y - pair.start.y) * 0.67
+      };
+      const midPoint = {
+        x: (pair.start.x + pair.end.x) / 2,
+        y: (pair.start.y + pair.end.y) / 2
+      };
+      const distToCenter = Math.hypot(
+        midPoint.x - center.x,
+        midPoint.y - center.y
+      );
+      const maxDist = Math.hypot(W / 2, H / 2);
+      const spatialDepth = 1 - distToCenter / maxDist;
+      const depth = nestingDepth.get(idx) || 0;
+      const normalizedDepth = depth / maxDepth;
+      const basePull = 0.3 + spatialDepth * 0.4;
+      const pullAmount = Math.max(0.05, basePull - normalizedDepth * 0.2);
+      return {
+        waypointPair: pair,
+        ctrl1: {
+          x: pLinear1.x * (1 - pullAmount) + pPerim1.x * pullAmount,
+          y: pLinear1.y * (1 - pullAmount) + pPerim1.y * pullAmount
+        },
+        ctrl2: {
+          x: pLinear2.x * (1 - pullAmount) + pPerim2.x * pullAmount,
+          y: pLinear2.y * (1 - pullAmount) + pPerim2.y * pullAmount
+        },
+        networkId: pair.networkId,
+        t1,
+        t2
+      };
+    });
+    this.sampledPoints = this.traces.map(
+      () => new Float64Array((OPT_SAMPLES + 1) * 2)
+    );
+    this.traceBounds = this.traces.map(() => ({
+      minX: 0,
+      maxX: 0,
+      minY: 0,
+      maxY: 0
+    }));
+    this.updateSampledTraces();
+    this.updateCollisionPairs();
+  }
+  updateSampledTraces() {
+    for (let i = 0; i < this.traces.length; i++) {
+      const trace = this.traces[i];
+      sampleCubicBezierInline(
+        trace.waypointPair.start.x,
+        trace.waypointPair.start.y,
+        trace.ctrl1.x,
+        trace.ctrl1.y,
+        trace.ctrl2.x,
+        trace.ctrl2.y,
+        trace.waypointPair.end.x,
+        trace.waypointPair.end.y,
+        this.sampledPoints[i],
+        OPT_SAMPLES
+      );
+      this.traceBounds[i] = computeTraceBounds(
+        this.sampledPoints[i],
+        OPT_SAMPLES + 1
+      );
+    }
+  }
+  updateSingleTraceSample(i) {
+    const trace = this.traces[i];
+    sampleCubicBezierInline(
+      trace.waypointPair.start.x,
+      trace.waypointPair.start.y,
+      trace.ctrl1.x,
+      trace.ctrl1.y,
+      trace.ctrl2.x,
+      trace.ctrl2.y,
+      trace.waypointPair.end.x,
+      trace.waypointPair.end.y,
+      this.sampledPoints[i],
+      OPT_SAMPLES
+    );
+    this.traceBounds[i] = computeTraceBounds(
+      this.sampledPoints[i],
+      OPT_SAMPLES + 1
+    );
+  }
+  // Determine which trace pairs could possibly collide based on bounding boxes
+  updateCollisionPairs() {
+    const { preferredSpacing } = this.problem;
+    this.collisionPairs = [];
+    for (let i = 0; i < this.traces.length; i++) {
+      for (let j = i + 1; j < this.traces.length; j++) {
+        const ti = this.traces[i], tj = this.traces[j];
+        if (ti.networkId && tj.networkId && ti.networkId === tj.networkId)
+          continue;
+        const bi = this.traceBounds[i], bj = this.traceBounds[j];
+        if (bi.maxX + preferredSpacing >= bj.minX && bj.maxX + preferredSpacing >= bi.minX && bi.maxY + preferredSpacing >= bj.minY && bj.maxY + preferredSpacing >= bi.minY) {
+          this.collisionPairs.push([i, j]);
+        }
+      }
+    }
+  }
+  computeTotalCost() {
+    const { preferredSpacing } = this.problem;
+    const spacingSq = preferredSpacing * preferredSpacing;
+    let cost = 0;
+    for (const [i, j] of this.collisionPairs) {
+      const pi = this.sampledPoints[i], pj = this.sampledPoints[j];
+      for (let a = 0; a < OPT_SAMPLES; a++) {
+        const a1x = pi[a * 2], a1y = pi[a * 2 + 1];
+        const a2x = pi[(a + 1) * 2], a2y = pi[(a + 1) * 2 + 1];
+        for (let b = 0; b < OPT_SAMPLES; b++) {
+          const b1x = pj[b * 2], b1y = pj[b * 2 + 1];
+          const b2x = pj[(b + 1) * 2], b2y = pj[(b + 1) * 2 + 1];
+          const distSq = segmentDistSq(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y);
+          if (distSq < spacingSq) {
+            const dist = Math.sqrt(distSq);
+            cost += (preferredSpacing - dist) ** 2;
+            if (distSq < 1e-18) cost += 20 * spacingSq;
+          }
+        }
+      }
+    }
+    for (let i = 0; i < this.traces.length; i++) {
+      const trace = this.traces[i];
+      const pi = this.sampledPoints[i];
+      const bi = this.traceBounds[i];
+      for (let obsIdx = 0; obsIdx < this.numObstacleSegments; obsIdx++) {
+        if (trace.networkId && this.obstacleNetworkIds[obsIdx] && trace.networkId === this.obstacleNetworkIds[obsIdx])
+          continue;
+        const obsBase = obsIdx * 4;
+        const ox1 = this.obstacleSegments[obsBase];
+        const oy1 = this.obstacleSegments[obsBase + 1];
+        const ox2 = this.obstacleSegments[obsBase + 2];
+        const oy2 = this.obstacleSegments[obsBase + 3];
+        const obsMinX = Math.min(ox1, ox2), obsMaxX = Math.max(ox1, ox2);
+        const obsMinY = Math.min(oy1, oy2), obsMaxY = Math.max(oy1, oy2);
+        if (bi.maxX + preferredSpacing < obsMinX || obsMaxX + preferredSpacing < bi.minX || bi.maxY + preferredSpacing < obsMinY || obsMaxY + preferredSpacing < bi.minY)
+          continue;
+        for (let a = 0; a < OPT_SAMPLES; a++) {
+          const a1x = pi[a * 2], a1y = pi[a * 2 + 1];
+          const a2x = pi[(a + 1) * 2], a2y = pi[(a + 1) * 2 + 1];
+          const distSq = segmentDistSq(a1x, a1y, a2x, a2y, ox1, oy1, ox2, oy2);
+          if (distSq < spacingSq) {
+            const dist = Math.sqrt(distSq);
+            cost += (preferredSpacing - dist) ** 2;
+            if (distSq < 1e-18) cost += 20 * spacingSq;
+          }
+        }
+      }
+    }
+    return cost;
+  }
+  computeCostForTrace(traceIdx) {
+    const { preferredSpacing } = this.problem;
+    const spacingSq = preferredSpacing * preferredSpacing;
+    const trace = this.traces[traceIdx];
+    const pi = this.sampledPoints[traceIdx];
+    const bi = this.traceBounds[traceIdx];
+    let cost = 0;
+    for (let j = 0; j < this.traces.length; j++) {
+      if (j === traceIdx) continue;
+      const other = this.traces[j];
+      if (trace.networkId && other.networkId && trace.networkId === other.networkId)
+        continue;
+      const bj = this.traceBounds[j];
+      if (bi.maxX + preferredSpacing < bj.minX || bj.maxX + preferredSpacing < bi.minX || bi.maxY + preferredSpacing < bj.minY || bj.maxY + preferredSpacing < bi.minY)
+        continue;
+      const pj = this.sampledPoints[j];
+      for (let a = 0; a < OPT_SAMPLES; a++) {
+        const a1x = pi[a * 2], a1y = pi[a * 2 + 1];
+        const a2x = pi[(a + 1) * 2], a2y = pi[(a + 1) * 2 + 1];
+        for (let b = 0; b < OPT_SAMPLES; b++) {
+          const b1x = pj[b * 2], b1y = pj[b * 2 + 1];
+          const b2x = pj[(b + 1) * 2], b2y = pj[(b + 1) * 2 + 1];
+          const distSq = segmentDistSq(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y);
+          if (distSq < spacingSq) {
+            const dist = Math.sqrt(distSq);
+            cost += (preferredSpacing - dist) ** 2;
+            if (distSq < 1e-18) cost += 20 * spacingSq;
+          }
+        }
+      }
+    }
+    for (let obsIdx = 0; obsIdx < this.numObstacleSegments; obsIdx++) {
+      if (trace.networkId && this.obstacleNetworkIds[obsIdx] && trace.networkId === this.obstacleNetworkIds[obsIdx])
+        continue;
+      const obsBase = obsIdx * 4;
+      const ox1 = this.obstacleSegments[obsBase];
+      const oy1 = this.obstacleSegments[obsBase + 1];
+      const ox2 = this.obstacleSegments[obsBase + 2];
+      const oy2 = this.obstacleSegments[obsBase + 3];
+      const obsMinX = Math.min(ox1, ox2), obsMaxX = Math.max(ox1, ox2);
+      const obsMinY = Math.min(oy1, oy2), obsMaxY = Math.max(oy1, oy2);
+      if (bi.maxX + preferredSpacing < obsMinX || obsMaxX + preferredSpacing < bi.minX || bi.maxY + preferredSpacing < obsMinY || obsMaxY + preferredSpacing < bi.minY)
+        continue;
+      for (let a = 0; a < OPT_SAMPLES; a++) {
+        const a1x = pi[a * 2], a1y = pi[a * 2 + 1];
+        const a2x = pi[(a + 1) * 2], a2y = pi[(a + 1) * 2 + 1];
+        const distSq = segmentDistSq(a1x, a1y, a2x, a2y, ox1, oy1, ox2, oy2);
+        if (distSq < spacingSq) {
+          const dist = Math.sqrt(distSq);
+          cost += (preferredSpacing - dist) ** 2;
+          if (distSq < 1e-18) cost += 20 * spacingSq;
+        }
+      }
+    }
+    return cost;
+  }
+  optimizeStep() {
+    const { bounds } = this.problem;
+    const { minX, maxX, minY, maxY } = bounds;
+    const progress = this.optimizationStep / this.maxOptimizationSteps;
+    const baseStep = 3.5 * (1 - progress) + 0.5;
+    const SQRT1_2 = Math.SQRT1_2;
+    const traceCosts = [];
+    for (let i = 0; i < this.traces.length; i++) {
+      traceCosts.push({ idx: i, cost: this.computeCostForTrace(i) });
+    }
+    traceCosts.sort((a, b) => b.cost - a.cost);
+    for (const { idx: i, cost: currentCost } of traceCosts) {
+      if (currentCost === 0) continue;
+      const trace = this.traces[i];
+      const steps = [baseStep, baseStep * 1.5, baseStep * 0.5];
+      for (const step of steps) {
+        const directions = [
+          { dx: step, dy: 0 },
+          { dx: -step, dy: 0 },
+          { dx: 0, dy: step },
+          { dx: 0, dy: -step },
+          { dx: step * SQRT1_2, dy: step * SQRT1_2 },
+          { dx: -step * SQRT1_2, dy: -step * SQRT1_2 },
+          { dx: step * SQRT1_2, dy: -step * SQRT1_2 },
+          { dx: -step * SQRT1_2, dy: step * SQRT1_2 }
+        ];
+        let bestCost = this.computeCostForTrace(i);
+        let bestCtrl1x = trace.ctrl1.x;
+        let bestCtrl1y = trace.ctrl1.y;
+        let bestCtrl2x = trace.ctrl2.x;
+        let bestCtrl2y = trace.ctrl2.y;
+        const origCtrl1x = trace.ctrl1.x;
+        const origCtrl1y = trace.ctrl1.y;
+        const origCtrl2x = trace.ctrl2.x;
+        const origCtrl2y = trace.ctrl2.y;
+        for (const dir of directions) {
+          trace.ctrl1.x = Math.max(minX, Math.min(maxX, origCtrl1x + dir.dx));
+          trace.ctrl1.y = Math.max(minY, Math.min(maxY, origCtrl1y + dir.dy));
+          this.updateSingleTraceSample(i);
+          const cost1 = this.computeCostForTrace(i);
+          if (cost1 < bestCost) {
+            bestCost = cost1;
+            bestCtrl1x = trace.ctrl1.x;
+            bestCtrl1y = trace.ctrl1.y;
+            bestCtrl2x = origCtrl2x;
+            bestCtrl2y = origCtrl2y;
+          }
+          trace.ctrl1.x = origCtrl1x;
+          trace.ctrl1.y = origCtrl1y;
+          trace.ctrl2.x = Math.max(minX, Math.min(maxX, origCtrl2x + dir.dx));
+          trace.ctrl2.y = Math.max(minY, Math.min(maxY, origCtrl2y + dir.dy));
+          this.updateSingleTraceSample(i);
+          const cost2 = this.computeCostForTrace(i);
+          if (cost2 < bestCost) {
+            bestCost = cost2;
+            bestCtrl1x = origCtrl1x;
+            bestCtrl1y = origCtrl1y;
+            bestCtrl2x = trace.ctrl2.x;
+            bestCtrl2y = trace.ctrl2.y;
+          }
+          trace.ctrl2.x = origCtrl2x;
+          trace.ctrl2.y = origCtrl2y;
+          trace.ctrl1.x = Math.max(minX, Math.min(maxX, origCtrl1x + dir.dx));
+          trace.ctrl1.y = Math.max(minY, Math.min(maxY, origCtrl1y + dir.dy));
+          trace.ctrl2.x = Math.max(minX, Math.min(maxX, origCtrl2x + dir.dx));
+          trace.ctrl2.y = Math.max(minY, Math.min(maxY, origCtrl2y + dir.dy));
+          this.updateSingleTraceSample(i);
+          const cost3 = this.computeCostForTrace(i);
+          if (cost3 < bestCost) {
+            bestCost = cost3;
+            bestCtrl1x = trace.ctrl1.x;
+            bestCtrl1y = trace.ctrl1.y;
+            bestCtrl2x = trace.ctrl2.x;
+            bestCtrl2y = trace.ctrl2.y;
+          }
+          trace.ctrl1.x = origCtrl1x;
+          trace.ctrl1.y = origCtrl1y;
+          trace.ctrl2.x = origCtrl2x;
+          trace.ctrl2.y = origCtrl2y;
+        }
+        trace.ctrl1.x = bestCtrl1x;
+        trace.ctrl1.y = bestCtrl1y;
+        trace.ctrl2.x = bestCtrl2x;
+        trace.ctrl2.y = bestCtrl2y;
+        this.updateSingleTraceSample(i);
+        if (bestCost < currentCost * 0.9) break;
+      }
+    }
+    if (this.optimizationStep % 10 === 0) {
+      this.updateCollisionPairs();
+    }
+  }
+  buildOutputTraces() {
+    this.outputTraces = this.traces.map((trace) => ({
+      waypointPair: trace.waypointPair,
+      points: sampleCubicBezier(
+        trace.waypointPair.start,
+        trace.ctrl1,
+        trace.ctrl2,
+        trace.waypointPair.end,
+        OUTPUT_SAMPLES
+      ),
+      networkId: trace.networkId
+    }));
+  }
+  _step() {
+    if (this.traces.length === 0) {
+      this.initializeTraces();
+      this.lastCost = this.computeTotalCost();
+      this.stagnantSteps = 0;
+    }
+    if (this.optimizationStep < this.maxOptimizationSteps) {
+      this.optimizeStep();
+      this.optimizationStep++;
+      const currentCost = this.computeTotalCost();
+      if (currentCost === 0) {
+        this.optimizationStep = this.maxOptimizationSteps;
+      } else if (currentCost >= this.lastCost * 0.99) {
+        this.stagnantSteps++;
+        if (this.stagnantSteps > 15) {
+          this.optimizationStep = this.maxOptimizationSteps;
+        }
+      } else {
+        this.stagnantSteps = 0;
+      }
+      this.lastCost = currentCost;
+    }
+    if (this.optimizationStep >= this.maxOptimizationSteps) {
+      this.buildOutputTraces();
+      this.solved = true;
+    }
+  }
+  visualize() {
+    if (this.traces.length > 0) {
+      this.buildOutputTraces();
+    }
+    return visualizeCurvyTraceProblem(this.problem, this.outputTraces);
+  }
+};
+export {
+  CurvyTraceSolver
+};
+/*! Bundled license information:
+
+is-buffer/index.js:
+  (*!
+   * Determine if an object is a Buffer
+   *
+   * @author   Feross Aboukhadijeh <https://feross.org>
+   * @license  MIT
+   *)
+
+deep-rename-keys/index.js:
+  (*!
+   * deep-rename-keys <https://github.com/jonschlinkert/deep-rename-keys>
+   *
+   * Copyright (c) 2015 Jon Schlinkert, contributors.
+   * Licensed under the MIT license.
+   *)
+*/