lbrnts 0.0.1

package/dist/index.js

@@ -0,0 +1,1424 @@
+// lib/xml-parsing/parseXml.ts
+import { XMLParser } from "fast-xml-parser";
+var parser = new XMLParser({
+  ignoreAttributes: false,
+  // keep attributes
+  attributeNamePrefix: "@_",
+  // Use @_ prefix, we'll normalize to $ below
+  allowBooleanAttributes: true,
+  parseAttributeValue: false,
+  // keep as strings; we'll coerce per-class
+  ignoreDeclaration: true
+  // ignore <?xml ...?> declaration
+});
+var parseXml = (xml) => {
+  const raw = parser.parse(xml);
+  function normalize(value) {
+    if (value === null || typeof value !== "object") return value;
+    if (Array.isArray(value)) return value.map(normalize);
+    const out = {};
+    const attrs = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (k.startsWith("@_")) {
+        attrs[k.slice(2)] = v;
+      } else if (k === "#text") {
+        out._ = v;
+      } else {
+        out[k] = normalize(v);
+      }
+    }
+    if (Object.keys(attrs).length) out.$ = attrs;
+    return out;
+  }
+  const rootKey = Object.keys(raw)[0];
+  if (!rootKey) {
+    throw new Error("Failed to parse XML: no root element found");
+  }
+  const root = normalize(raw[rootKey]);
+  return { [rootKey]: root };
+};
+
+// lib/classes/LightBurnBaseElement.ts
+var LightBurnBaseElement = class _LightBurnBaseElement {
+  token;
+  static token;
+  getChildren() {
+    return [];
+  }
+  getStringIndented() {
+    return this.getString().split("\n").map((line) => `  ${line}`).join("\n");
+  }
+  getString() {
+    const children = this.getChildren();
+    if (children.length === 0) {
+      return `(${this.token})`;
+    }
+    const lines = [`(${this.token}`];
+    for (const p of children) {
+      lines.push(p.getStringIndented());
+    }
+    lines.push(")");
+    return lines.join("\n");
+  }
+  get [Symbol.toStringTag]() {
+    return this.getString();
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.getString();
+  }
+  // =========================== STATIC METHODS ===========================
+  static elementRegistry = {};
+  static shapeRegistry = {};
+  /**
+   * Should be called after class definition to register the class for parsing
+   */
+  static register(token, klass) {
+    if (token.startsWith("Shape.")) {
+      _LightBurnBaseElement.shapeRegistry[token] = klass;
+    } else {
+      _LightBurnBaseElement.elementRegistry[token] = klass;
+    }
+  }
+  /**
+   * Parse an XML string into registered LightBurnBaseElement instances
+   */
+  static parse(xml) {
+    const ShapePath2 = _LightBurnBaseElement.shapeRegistry["Shape.Path"];
+    if (ShapePath2 && typeof ShapePath2.clearTemplateRegistry === "function") {
+      ShapePath2.clearTemplateRegistry();
+    }
+    const xmlJson = parseXml(xml);
+    return _LightBurnBaseElement.parseXmlJson(xmlJson);
+  }
+  static fromXmlJson(node) {
+    throw new Error(
+      `"${_LightBurnBaseElement.name}" class has not implemented fromXmlJson`
+    );
+  }
+  static parseXmlJson(xmlJson) {
+    if (xmlJson && typeof xmlJson === "object" && !Array.isArray(xmlJson) && !("$" in xmlJson || "_" in xmlJson)) {
+      const keys = Object.keys(xmlJson);
+      if (keys.length === 1) {
+        const rootTag = keys[0];
+        const rootNode = xmlJson[rootTag];
+        return _LightBurnBaseElement.instantiateElement(rootTag, rootNode);
+      }
+    }
+    if (Array.isArray(xmlJson)) {
+      return xmlJson.map((item) => _LightBurnBaseElement.parseXmlJson(item));
+    }
+    if (typeof xmlJson === "number" || typeof xmlJson === "string" || typeof xmlJson === "boolean" || xmlJson === null) {
+      return xmlJson;
+    }
+    throw new Error(`Couldn't parse XML JSON: ${JSON.stringify(xmlJson)}`);
+  }
+  static instantiateElement(tag, node) {
+    if (tag === "Shape") {
+      const type = node.$?.Type;
+      if (!type) {
+        throw new Error("Shape element missing Type attribute");
+      }
+      const shapeToken = `Shape.${type}`;
+      const ShapeClass = _LightBurnBaseElement.shapeRegistry[shapeToken];
+      if (ShapeClass) {
+        return ShapeClass.fromXmlJson(node);
+      }
+      throw new Error(`Unknown shape type "${type}"`);
+    }
+    const ElementClass = _LightBurnBaseElement.elementRegistry[tag];
+    if (ElementClass) {
+      return ElementClass.fromXmlJson(node);
+    }
+    throw new Error(`Unknown element "${tag}"`);
+  }
+};
+
+// lib/classes/elements/_coerce.ts
+function num(v, defaultValue = 0) {
+  if (v === null || v === void 0) return defaultValue;
+  if (typeof v === "number") return v;
+  const parsed = Number(v);
+  return Number.isNaN(parsed) ? defaultValue : parsed;
+}
+function boolish(v, defaultValue = false) {
+  if (v === null || v === void 0) return defaultValue;
+  if (typeof v === "boolean") return v;
+  if (typeof v === "string") {
+    const lower = v.toLowerCase();
+    if (lower === "true" || lower === "1") return true;
+    if (lower === "false" || lower === "0") return false;
+  }
+  if (typeof v === "number") return v !== 0;
+  return defaultValue;
+}
+function str(v, defaultValue = "") {
+  if (v === null || v === void 0) return defaultValue;
+  return String(v);
+}
+
+// lib/classes/elements/LightBurnProject.ts
+var LightBurnProject = class _LightBurnProject extends LightBurnBaseElement {
+  appVersion;
+  formatVersion;
+  materialHeight;
+  mirrorX;
+  mirrorY;
+  children = [];
+  constructor(init) {
+    super();
+    this.token = "LightBurnProject";
+    if (init) {
+      if (init.appVersion !== void 0) this.appVersion = init.appVersion;
+      if (init.formatVersion !== void 0)
+        this.formatVersion = init.formatVersion;
+      if (init.materialHeight !== void 0)
+        this.materialHeight = init.materialHeight;
+      if (init.mirrorX !== void 0) this.mirrorX = init.mirrorX;
+      if (init.mirrorY !== void 0) this.mirrorY = init.mirrorY;
+      if (init.children !== void 0) this.children = init.children;
+    }
+  }
+  static fromXmlJson(node) {
+    const project = new _LightBurnProject();
+    if (node.$) {
+      project.appVersion = str(node.$.AppVersion, void 0);
+      project.formatVersion = str(node.$.FormatVersion, void 0);
+      project.materialHeight = num(node.$.MaterialHeight, void 0);
+      project.mirrorX = boolish(node.$.MirrorX, void 0);
+      project.mirrorY = boolish(node.$.MirrorY, void 0);
+    }
+    const childTags = [
+      "Thumbnail",
+      "VariableText",
+      "UIPrefs",
+      "CutSetting",
+      "Shape",
+      "Notes"
+    ];
+    for (const tag of childTags) {
+      const childNode = node[tag];
+      if (childNode) {
+        if (Array.isArray(childNode)) {
+          for (const item of childNode) {
+            project.children.push(
+              LightBurnBaseElement.instantiateElement(tag, item)
+            );
+          }
+        } else {
+          project.children.push(
+            LightBurnBaseElement.instantiateElement(tag, childNode)
+          );
+        }
+      }
+    }
+    return project;
+  }
+  getChildren() {
+    return this.children;
+  }
+};
+LightBurnBaseElement.register("LightBurnProject", LightBurnProject);
+
+// lib/classes/elements/CutSetting.ts
+var CutSetting = class _CutSetting extends LightBurnBaseElement {
+  _type = "Cut";
+  _index;
+  _name;
+  _priority;
+  _minPower;
+  _maxPower;
+  _minPower2;
+  _maxPower2;
+  _speed;
+  _kerf;
+  _zOffset;
+  _enablePowerRamp;
+  _rampLength;
+  _numPasses;
+  _zPerPass;
+  _perforate;
+  _dotMode;
+  _scanOpt;
+  _interval;
+  _angle;
+  _overScanning;
+  _lineAngle;
+  constructor(init) {
+    super();
+    this.token = "CutSetting";
+    if (init) {
+      if (init.type !== void 0) this._type = init.type;
+      if (init.index !== void 0) this._index = init.index;
+      if (init.name !== void 0) this._name = init.name;
+      if (init.priority !== void 0) this._priority = init.priority;
+      if (init.minPower !== void 0) this._minPower = init.minPower;
+      if (init.maxPower !== void 0) this._maxPower = init.maxPower;
+      if (init.minPower2 !== void 0) this._minPower2 = init.minPower2;
+      if (init.maxPower2 !== void 0) this._maxPower2 = init.maxPower2;
+      if (init.speed !== void 0) this._speed = init.speed;
+      if (init.kerf !== void 0) this._kerf = init.kerf;
+      if (init.zOffset !== void 0) this._zOffset = init.zOffset;
+      if (init.enablePowerRamp !== void 0)
+        this._enablePowerRamp = init.enablePowerRamp;
+      if (init.rampLength !== void 0) this._rampLength = init.rampLength;
+      if (init.numPasses !== void 0) this._numPasses = init.numPasses;
+      if (init.zPerPass !== void 0) this._zPerPass = init.zPerPass;
+      if (init.perforate !== void 0) this._perforate = init.perforate;
+      if (init.dotMode !== void 0) this._dotMode = init.dotMode;
+      if (init.scanOpt !== void 0) this._scanOpt = init.scanOpt;
+      if (init.interval !== void 0) this._interval = init.interval;
+      if (init.angle !== void 0) this._angle = init.angle;
+      if (init.overScanning !== void 0)
+        this._overScanning = init.overScanning;
+      if (init.lineAngle !== void 0) this._lineAngle = init.lineAngle;
+    }
+  }
+  get type() {
+    return this._type;
+  }
+  set type(value) {
+    this._type = value;
+  }
+  get index() {
+    return this._index;
+  }
+  set index(value) {
+    this._index = value;
+  }
+  get name() {
+    return this._name;
+  }
+  set name(value) {
+    this._name = value;
+  }
+  get priority() {
+    return this._priority;
+  }
+  set priority(value) {
+    this._priority = value;
+  }
+  get minPower() {
+    return this._minPower;
+  }
+  set minPower(value) {
+    this._minPower = value;
+  }
+  get maxPower() {
+    return this._maxPower;
+  }
+  set maxPower(value) {
+    this._maxPower = value;
+  }
+  get minPower2() {
+    return this._minPower2;
+  }
+  set minPower2(value) {
+    this._minPower2 = value;
+  }
+  get maxPower2() {
+    return this._maxPower2;
+  }
+  set maxPower2(value) {
+    this._maxPower2 = value;
+  }
+  get speed() {
+    return this._speed;
+  }
+  set speed(value) {
+    this._speed = value;
+  }
+  get kerf() {
+    return this._kerf;
+  }
+  set kerf(value) {
+    this._kerf = value;
+  }
+  get zOffset() {
+    return this._zOffset;
+  }
+  set zOffset(value) {
+    this._zOffset = value;
+  }
+  get enablePowerRamp() {
+    return this._enablePowerRamp;
+  }
+  set enablePowerRamp(value) {
+    this._enablePowerRamp = value;
+  }
+  get rampLength() {
+    return this._rampLength;
+  }
+  set rampLength(value) {
+    this._rampLength = value;
+  }
+  get numPasses() {
+    return this._numPasses;
+  }
+  set numPasses(value) {
+    this._numPasses = value;
+  }
+  get zPerPass() {
+    return this._zPerPass;
+  }
+  set zPerPass(value) {
+    this._zPerPass = value;
+  }
+  get perforate() {
+    return this._perforate;
+  }
+  set perforate(value) {
+    this._perforate = value;
+  }
+  get dotMode() {
+    return this._dotMode;
+  }
+  set dotMode(value) {
+    this._dotMode = value;
+  }
+  get scanOpt() {
+    return this._scanOpt;
+  }
+  set scanOpt(value) {
+    this._scanOpt = value;
+  }
+  get interval() {
+    return this._interval;
+  }
+  set interval(value) {
+    this._interval = value;
+  }
+  get angle() {
+    return this._angle;
+  }
+  set angle(value) {
+    this._angle = value;
+  }
+  get overScanning() {
+    return this._overScanning;
+  }
+  set overScanning(value) {
+    this._overScanning = value;
+  }
+  get lineAngle() {
+    return this._lineAngle;
+  }
+  set lineAngle(value) {
+    this._lineAngle = value;
+  }
+  static fromXmlJson(node) {
+    const cs = new _CutSetting();
+    if (node.$) {
+      cs.type = str(node.$.type, "Cut");
+    }
+    const getChildValue = (key) => {
+      const child = node[key];
+      return child?.$?.Value;
+    };
+    cs.index = num(getChildValue("index"), void 0);
+    cs.name = str(getChildValue("name"), void 0);
+    cs.priority = num(getChildValue("priority"), void 0);
+    cs.minPower = num(getChildValue("minPower"), void 0);
+    cs.maxPower = num(getChildValue("maxPower"), void 0);
+    cs.minPower2 = num(getChildValue("minPower2"), void 0);
+    cs.maxPower2 = num(getChildValue("maxPower2"), void 0);
+    cs.speed = num(getChildValue("speed"), void 0);
+    cs.kerf = num(getChildValue("kerf"), void 0);
+    cs.zOffset = num(getChildValue("zOffset"), void 0);
+    cs.enablePowerRamp = boolish(getChildValue("enablePowerRamp"), void 0);
+    cs.rampLength = num(getChildValue("rampLength"), void 0);
+    cs.numPasses = num(getChildValue("numPasses"), void 0);
+    cs.zPerPass = num(getChildValue("zPerPass"), void 0);
+    cs.perforate = boolish(getChildValue("perforate"), void 0);
+    cs.dotMode = boolish(getChildValue("dotMode"), void 0);
+    cs.scanOpt = str(getChildValue("scanOpt"), void 0);
+    cs.interval = num(getChildValue("interval"), void 0);
+    cs.angle = num(getChildValue("angle"), void 0);
+    cs.overScanning = num(getChildValue("overScanning"), void 0);
+    cs.lineAngle = num(getChildValue("lineAngle"), void 0);
+    return cs;
+  }
+};
+LightBurnBaseElement.register("CutSetting", CutSetting);
+
+// lib/classes/elements/Notes.ts
+var Notes = class _Notes extends LightBurnBaseElement {
+  showOnLoad;
+  text;
+  constructor() {
+    super();
+    this.token = "Notes";
+  }
+  static fromXmlJson(node) {
+    const notes = new _Notes();
+    if (node.$) {
+      notes.showOnLoad = boolish(node.$.ShowOnLoad, void 0);
+      notes.text = str(node.$.Notes, void 0);
+    }
+    return notes;
+  }
+};
+LightBurnBaseElement.register("Notes", Notes);
+
+// lib/classes/elements/VariableText.ts
+var VariableText = class _VariableText extends LightBurnBaseElement {
+  start;
+  end;
+  current;
+  increment;
+  autoAdvance;
+  constructor() {
+    super();
+    this.token = "VariableText";
+  }
+  static fromXmlJson(node) {
+    const vt = new _VariableText();
+    if (node.Start?.$) {
+      vt.start = num(node.Start.$.Value, void 0);
+    }
+    if (node.End?.$) {
+      vt.end = num(node.End.$.Value, void 0);
+    }
+    if (node.Current?.$) {
+      vt.current = num(node.Current.$.Value, void 0);
+    }
+    if (node.Increment?.$) {
+      vt.increment = num(node.Increment.$.Value, void 0);
+    }
+    if (node.AutoAdvance?.$) {
+      vt.autoAdvance = boolish(node.AutoAdvance.$.Value, void 0);
+    }
+    return vt;
+  }
+};
+LightBurnBaseElement.register("VariableText", VariableText);
+
+// lib/classes/elements/UIPrefs.ts
+var UIPrefs = class _UIPrefs extends LightBurnBaseElement {
+  prefs = {};
+  constructor() {
+    super();
+    this.token = "UIPrefs";
+  }
+  static fromXmlJson(node) {
+    const ui = new _UIPrefs();
+    for (const [key, value] of Object.entries(node)) {
+      if (key !== "$" && key !== "_" && value && typeof value === "object") {
+        const val = value.$?.Value;
+        if (val !== void 0) {
+          ui.prefs[key] = str(val);
+        }
+      }
+    }
+    return ui;
+  }
+};
+LightBurnBaseElement.register("UIPrefs", UIPrefs);
+
+// lib/classes/elements/Thumbnail.ts
+var Thumbnail = class _Thumbnail extends LightBurnBaseElement {
+  pngBase64;
+  constructor() {
+    super();
+    this.token = "Thumbnail";
+  }
+  static fromXmlJson(node) {
+    const thumbnail = new _Thumbnail();
+    if (node.$) {
+      thumbnail.pngBase64 = str(node.$.Source, void 0);
+    }
+    return thumbnail;
+  }
+};
+LightBurnBaseElement.register("Thumbnail", Thumbnail);
+
+// lib/classes/elements/shapes/ShapeBase.ts
+var ShapeBase = class extends LightBurnBaseElement {
+  cutIndex;
+  locked;
+  xform;
+  static readCommon(node) {
+    const common = {};
+    if (node.$) {
+      if (node.$.CutIndex !== void 0) {
+        common.cutIndex = num(node.$.CutIndex, void 0);
+      }
+      if (node.$.Locked !== void 0) {
+        common.locked = boolish(node.$.Locked, void 0);
+      }
+    }
+    const xformNode = node.XForm;
+    if (xformNode) {
+      const xformText = typeof xformNode === "string" ? xformNode : str(xformNode._, "");
+      if (xformText) {
+        const parts = xformText.trim().split(/\s+/).map(Number);
+        if (parts.length === 6) {
+          common.xform = parts;
+        }
+      }
+    }
+    return common;
+  }
+};
+
+// lib/classes/elements/shapes/ShapeEllipse.ts
+var ShapeEllipse = class _ShapeEllipse extends ShapeBase {
+  rx;
+  ry;
+  constructor() {
+    super();
+    this.token = "Shape.Ellipse";
+  }
+  static fromXmlJson(node) {
+    const ellipse = new _ShapeEllipse();
+    const common = ShapeBase.readCommon(node);
+    Object.assign(ellipse, common);
+    if (node.$) {
+      ellipse.rx = num(node.$.Rx, void 0);
+      ellipse.ry = num(node.$.Ry, void 0);
+    }
+    return ellipse;
+  }
+};
+LightBurnBaseElement.register("Shape.Ellipse", ShapeEllipse);
+
+// lib/classes/elements/shapes/ShapeRect.ts
+var ShapeRect = class _ShapeRect extends ShapeBase {
+  w;
+  h;
+  cr;
+  constructor() {
+    super();
+    this.token = "Shape.Rect";
+  }
+  static fromXmlJson(node) {
+    const rect = new _ShapeRect();
+    const common = ShapeBase.readCommon(node);
+    Object.assign(rect, common);
+    if (node.$) {
+      rect.w = num(node.$.W, void 0);
+      rect.h = num(node.$.H, void 0);
+      rect.cr = num(node.$.Cr, void 0);
+    }
+    return rect;
+  }
+};
+LightBurnBaseElement.register("Shape.Rect", ShapeRect);
+
+// lib/classes/elements/shapes/ShapePath.ts
+var ShapePath = class _ShapePath extends ShapeBase {
+  verts = [];
+  prims = [];
+  isClosed = true;
+  // Whether the path is closed (default) or open
+  // Static registry to track shape templates by VertID/PrimID
+  static templateRegistry = /* @__PURE__ */ new Map();
+  constructor(init) {
+    super();
+    this.token = "Shape.Path";
+    if (init) {
+      if (init.verts !== void 0) this.verts = init.verts;
+      if (init.prims !== void 0) this.prims = init.prims;
+      if (init.isClosed !== void 0) this.isClosed = init.isClosed;
+      if (init.cutIndex !== void 0) this.cutIndex = init.cutIndex;
+      if (init.locked !== void 0) this.locked = init.locked;
+      if (init.xform !== void 0) this.xform = init.xform;
+    }
+  }
+  static clearTemplateRegistry() {
+    _ShapePath.templateRegistry.clear();
+  }
+  static fromXmlJson(node) {
+    const path = new _ShapePath();
+    const common = ShapeBase.readCommon(node);
+    Object.assign(path, common);
+    const vertID = num(node.$?.VertID, void 0);
+    const primID = num(node.$?.PrimID, void 0);
+    const templateKey = `${vertID}_${primID}`;
+    const vertList = node.VertList;
+    if (vertList) {
+      if (typeof vertList === "string") {
+        path.verts = _ShapePath.parseEncodedVertList(vertList);
+      } else if (vertList.Vert) {
+        const verts = Array.isArray(vertList.Vert) ? vertList.Vert : [vertList.Vert];
+        for (const v of verts) {
+          if (v.$) {
+            path.verts.push({
+              x: num(v.$.x, 0),
+              y: num(v.$.y, 0),
+              c: num(v.$.c, void 0)
+            });
+          }
+        }
+      }
+    }
+    const primList = node.PrimList;
+    if (primList) {
+      if (typeof primList === "string") {
+        const isOpen = primList.includes("Open");
+        path.isClosed = !isOpen;
+        const primCount = isOpen ? path.verts.length - 1 : path.verts.length;
+        for (let i = 0; i < primCount; i++) {
+          path.prims.push({ type: 0 });
+        }
+      } else if (primList.Prim) {
+        const prims = Array.isArray(primList.Prim) ? primList.Prim : [primList.Prim];
+        for (const p of prims) {
+          if (p.$) {
+            path.prims.push({
+              type: num(p.$.type, 0)
+            });
+          }
+        }
+      }
+    }
+    const primPolyline = node.PrimPolyline;
+    if (primPolyline && typeof primPolyline === "string") {
+      path.prims = _ShapePath.parseEncodedPrimPolyline(primPolyline);
+    }
+    if (path.verts.length > 0 && vertID !== void 0 && primID !== void 0) {
+      _ShapePath.templateRegistry.set(templateKey, {
+        verts: path.verts,
+        prims: path.prims,
+        isClosed: path.isClosed
+      });
+    }
+    if (path.verts.length === 0 && vertID !== void 0 && primID !== void 0) {
+      const template = _ShapePath.templateRegistry.get(templateKey);
+      if (template) {
+        path.verts = template.verts.map((v) => ({ ...v }));
+        path.prims = template.prims.map((p) => ({ ...p }));
+        path.isClosed = template.isClosed;
+      }
+    }
+    if (path.verts.length > 0 && path.prims.length === 0) {
+      path.prims = _ShapePath.generatePrimsFromVerts(path.verts, primID);
+    }
+    return path;
+  }
+  /**
+   * Parse encoded VertList string format
+   * Format: V{x} {y}c{flag}x{flag}c{flag}x{c1x}c{flag}y{c1y}...
+   * Example: V2.1156745 -12.3306c0x1c1x1.5871694c1y-12.3306
+   *
+   * Control points are encoded as:
+   * - c0x{value}c0y{value} = control point 0 (when both present)
+   * - c1x{value}c1y{value} = control point 1 (when both present)
+   * - c{num}x{num} alone (like c0x1) = flag, not a coordinate
+   */
+  static parseEncodedVertList(encoded) {
+    const verts = [];
+    const parts = encoded.split("V").filter((p) => p.trim());
+    for (const part of parts) {
+      const match = part.match(/^([-\d.]+)\s+([-\d.]+)/);
+      if (match) {
+        const x = parseFloat(match[1]);
+        const y = parseFloat(match[2]);
+        const vert = { x, y };
+        const cMatch = part.match(/c(\d+)/);
+        if (cMatch) {
+          vert.c = parseInt(cMatch[1], 10);
+        }
+        const c0xMatch = part.match(/c0x([-\d.]+)/);
+        const c0yMatch = part.match(/c0y([-\d.]+)/);
+        const c1xMatch = part.match(/c1x([-\d.]+)/);
+        const c1yMatch = part.match(/c1y([-\d.]+)/);
+        if (c0xMatch && c0yMatch && (c0xMatch[1].includes(".") || c0xMatch[1].length > 1)) {
+          vert.c0x = parseFloat(c0xMatch[1]);
+          vert.c0y = parseFloat(c0yMatch[1]);
+        }
+        if (c1xMatch && c1yMatch && (c1xMatch[1].includes(".") || c1xMatch[1].length > 1)) {
+          vert.c1x = parseFloat(c1xMatch[1]);
+          vert.c1y = parseFloat(c1yMatch[1]);
+        }
+        verts.push(vert);
+      }
+    }
+    return verts;
+  }
+  /**
+   * Parse encoded PrimPolyline string format
+   * This typically contains line-to commands, each prim is type 0 (LineTo)
+   */
+  static parseEncodedPrimPolyline(encoded) {
+    const prims = [];
+    const vertCount = (encoded.match(/[-\d.]+\s+[-\d.]+/g) || []).length;
+    for (let i = 0; i < vertCount; i++) {
+      prims.push({ type: 0 });
+    }
+    return prims;
+  }
+  /**
+   * Generate primitives from vertices based on PrimID
+   * PrimID meanings:
+   * - 0: Simple polyline (all LineTo)
+   * - 2: Rounded rectangle with bezier curves at corners
+   * - 3: Other curve type
+   */
+  static generatePrimsFromVerts(verts, primID) {
+    const prims = [];
+    if (verts.length === 0) {
+      return prims;
+    }
+    if (primID === 2 && verts.length === 8) {
+      for (let i = 0; i < 8; i++) {
+        prims.push({ type: i % 2 === 0 ? 0 : 1 });
+      }
+    } else {
+      for (let i = 0; i < verts.length; i++) {
+        prims.push({ type: 0 });
+      }
+    }
+    return prims;
+  }
+};
+LightBurnBaseElement.register("Shape.Path", ShapePath);
+
+// lib/classes/elements/shapes/ShapeText.ts
+var ShapeText = class _ShapeText extends ShapeBase {
+  text;
+  font;
+  backupPath;
+  constructor() {
+    super();
+    this.token = "Shape.Text";
+  }
+  static fromXmlJson(node) {
+    const text = new _ShapeText();
+    const common = ShapeBase.readCommon(node);
+    Object.assign(text, common);
+    if (node.$) {
+      text.text = str(node.$.Text, void 0);
+      text.font = str(node.$.Font, void 0);
+    }
+    const backupPath = node.BackupPath;
+    if (backupPath) {
+      text.backupPath = ShapePath.fromXmlJson(backupPath);
+    }
+    return text;
+  }
+};
+LightBurnBaseElement.register("Shape.Text", ShapeText);
+
+// lib/classes/elements/shapes/ShapeGroup.ts
+var ShapeGroup = class _ShapeGroup extends ShapeBase {
+  children = [];
+  constructor() {
+    super();
+    this.token = "Shape.Group";
+  }
+  static fromXmlJson(node) {
+    const group = new _ShapeGroup();
+    const common = ShapeBase.readCommon(node);
+    Object.assign(group, common);
+    const shapes = node.Shape;
+    if (shapes) {
+      if (Array.isArray(shapes)) {
+        for (const shape of shapes) {
+          group.children.push(
+            LightBurnBaseElement.instantiateElement("Shape", shape)
+          );
+        }
+      } else {
+        group.children.push(
+          LightBurnBaseElement.instantiateElement("Shape", shapes)
+        );
+      }
+    }
+    return group;
+  }
+  getChildren() {
+    return this.children;
+  }
+};
+LightBurnBaseElement.register("Shape.Group", ShapeGroup);
+
+// lib/classes/elements/shapes/ShapeBitmap.ts
+var ShapeBitmap = class _ShapeBitmap extends ShapeBase {
+  _w;
+  _h;
+  _dataBase64;
+  _grayscale;
+  _dpi;
+  _ditherMode;
+  _halftone;
+  _negative;
+  _brightnessAdjust;
+  _contrastAdjust;
+  _gammaAdjust;
+  constructor() {
+    super();
+    this.token = "Shape.Bitmap";
+  }
+  get w() {
+    return this._w;
+  }
+  set w(value) {
+    this._w = value;
+  }
+  get h() {
+    return this._h;
+  }
+  set h(value) {
+    this._h = value;
+  }
+  get dataBase64() {
+    return this._dataBase64;
+  }
+  set dataBase64(value) {
+    this._dataBase64 = value;
+  }
+  get grayscale() {
+    return this._grayscale;
+  }
+  set grayscale(value) {
+    this._grayscale = value;
+  }
+  get dpi() {
+    return this._dpi;
+  }
+  set dpi(value) {
+    this._dpi = value;
+  }
+  get ditherMode() {
+    return this._ditherMode;
+  }
+  set ditherMode(value) {
+    this._ditherMode = value;
+  }
+  get halftone() {
+    return this._halftone;
+  }
+  set halftone(value) {
+    this._halftone = value;
+  }
+  get negative() {
+    return this._negative;
+  }
+  set negative(value) {
+    this._negative = value;
+  }
+  get brightnessAdjust() {
+    return this._brightnessAdjust;
+  }
+  set brightnessAdjust(value) {
+    this._brightnessAdjust = value;
+  }
+  get contrastAdjust() {
+    return this._contrastAdjust;
+  }
+  set contrastAdjust(value) {
+    this._contrastAdjust = value;
+  }
+  get gammaAdjust() {
+    return this._gammaAdjust;
+  }
+  set gammaAdjust(value) {
+    this._gammaAdjust = value;
+  }
+  static fromXmlJson(node) {
+    const bitmap = new _ShapeBitmap();
+    const common = ShapeBase.readCommon(node);
+    Object.assign(bitmap, common);
+    if (node.$) {
+      bitmap.w = num(node.$.W, void 0);
+      bitmap.h = num(node.$.H, void 0);
+      bitmap.grayscale = boolish(node.$.Grayscale, void 0);
+      bitmap.negative = boolish(node.$.Negative, void 0);
+      bitmap.dataBase64 = str(node.$.Data, void 0);
+    }
+    const getChildValue = (key) => {
+      const child = node[key];
+      return child?.$?.Value;
+    };
+    bitmap.dpi = num(getChildValue("DPI"), void 0);
+    bitmap.ditherMode = str(getChildValue("DitherMode"), void 0);
+    bitmap.halftone = boolish(getChildValue("Halftone"), void 0);
+    bitmap.brightnessAdjust = num(getChildValue("BrightnessAdjust"), void 0);
+    bitmap.contrastAdjust = num(getChildValue("ContrastAdjust"), void 0);
+    bitmap.gammaAdjust = num(getChildValue("GammaAdjust"), void 0);
+    return bitmap;
+  }
+};
+LightBurnBaseElement.register("Shape.Bitmap", ShapeBitmap);
+
+// lib/svg-gen/index.ts
+import { stringify } from "svgson";
+
+// lib/svg-gen/assemble.ts
+function assembleSvg(children, layout) {
+  return {
+    name: "svg",
+    type: "element",
+    value: "",
+    attributes: {
+      xmlns: "http://www.w3.org/2000/svg",
+      width: String(layout.width),
+      height: String(layout.height),
+      viewBox: layout.viewBox,
+      style: "background-color: white;"
+    },
+    children: [
+      {
+        name: "rect",
+        type: "element",
+        value: "",
+        attributes: {
+          x: String(layout.bg.x),
+          y: String(layout.bg.y),
+          width: String(layout.bg.width),
+          height: String(layout.bg.height),
+          fill: "white"
+        },
+        children: []
+      },
+      {
+        name: "g",
+        type: "element",
+        value: "",
+        attributes: {
+          transform: `matrix(1 0 0 -1 0 ${layout.flipY})`
+        },
+        children
+      }
+    ]
+  };
+}
+
+// lib/svg-gen/collect.ts
+function collectShapes(root) {
+  const out = [];
+  const pushFrom = (el) => {
+    if (el instanceof ShapeBase) {
+      out.push(el);
+    } else if (el instanceof LightBurnProject) {
+      for (const c of el.children) {
+        if (c instanceof ShapeBase) {
+          out.push(c);
+        }
+      }
+    }
+  };
+  Array.isArray(root) ? root.forEach(pushFrom) : pushFrom(root);
+  return out;
+}
+
+// lib/svg-gen/options.ts
+var DEFAULT_OPTIONS = {
+  margin: 10
+};
+
+// lib/svg-gen/layout.ts
+function computeLayout(bbox, options) {
+  const margin = options?.margin ?? DEFAULT_OPTIONS.margin;
+  const isEmpty = bbox.minX === Infinity || bbox.maxX === -Infinity;
+  if (isEmpty) {
+    bbox = { minX: 0, minY: 0, maxX: 100, maxY: 100 };
+  }
+  const minX = Math.min(0, bbox.minX) - margin;
+  const minY = Math.min(0, bbox.minY) - margin;
+  const maxX = Math.max(0, bbox.maxX) + margin;
+  const maxY = Math.max(0, bbox.maxY) + margin;
+  const width = maxX - minX;
+  const height = maxY - minY;
+  const viewBox = `${minX} ${minY} ${width} ${height}`;
+  const flipY = maxY + minY;
+  return {
+    viewBox,
+    width,
+    height,
+    flipY,
+    bg: { x: minX, y: minY, width, height }
+  };
+}
+
+// lib/svg-gen/_math.ts
+import {
+  applyToPoint,
+  compose,
+  identity as matrixIdentity,
+  toSVG
+} from "transformation-matrix";
+function arrayToMatrix(arr) {
+  const [a, b, c, d, e, f] = arr;
+  return { a, b, c, d, e, f };
+}
+function apply(m, p) {
+  return applyToPoint(m, p);
+}
+function matToSvg(m) {
+  return toSVG(m);
+}
+function identity() {
+  return matrixIdentity();
+}
+function emptyBox() {
+  return {
+    minX: Number.POSITIVE_INFINITY,
+    minY: Number.POSITIVE_INFINITY,
+    maxX: Number.NEGATIVE_INFINITY,
+    maxY: Number.NEGATIVE_INFINITY
+  };
+}
+function boxUnion(a, b) {
+  return {
+    minX: Math.min(a.minX, b.minX),
+    minY: Math.min(a.minY, b.minY),
+    maxX: Math.max(a.maxX, b.maxX),
+    maxY: Math.max(a.maxY, b.maxY)
+  };
+}
+function addPts(bb, pts) {
+  for (const p of pts) {
+    bb.minX = Math.min(bb.minX, p.x);
+    bb.minY = Math.min(bb.minY, p.y);
+    bb.maxX = Math.max(bb.maxX, p.x);
+    bb.maxY = Math.max(bb.maxY, p.y);
+  }
+  return bb;
+}
+
+// lib/svg-gen/node-helpers.ts
+var g = (attrs, children = []) => ({
+  name: "g",
+  type: "element",
+  value: "",
+  attributes: attrs,
+  children
+});
+var leaf = (name, attrs) => ({
+  name,
+  type: "element",
+  value: "",
+  attributes: attrs,
+  children: []
+});
+var textNode = (value) => ({
+  name: "",
+  type: "text",
+  value,
+  attributes: {},
+  children: []
+});
+
+// lib/svg-gen/registry/shape-bitmap.ts
+var bitmapRenderer = {
+  match: (s) => s instanceof ShapeBitmap,
+  bbox: (bmp) => {
+    const w = bmp.w || 0;
+    const h = bmp.h || 0;
+    const xform = bmp.xform ? arrayToMatrix(bmp.xform) : identity();
+    const corners = [
+      { x: 0, y: 0 },
+      { x: w, y: 0 },
+      { x: w, y: h },
+      { x: 0, y: h }
+    ];
+    return addPts(
+      emptyBox(),
+      corners.map((p) => apply(xform, p))
+    );
+  },
+  toSvg: (bmp) => {
+    const xform = bmp.xform ? arrayToMatrix(bmp.xform) : identity();
+    const transform = matToSvg(xform);
+    const w = bmp.w || 0;
+    const h = bmp.h || 0;
+    const data = bmp.dataBase64 || "";
+    return g({ transform }, [
+      leaf("image", {
+        href: `data:image/png;base64,${data}`,
+        x: "0",
+        y: "0",
+        width: String(w),
+        height: String(h)
+      })
+    ]);
+  }
+};
+
+// lib/svg-gen/palette.ts
+var LIGHTBURN_COLORS = {
+  0: "#000000",
+  // C00 - Black
+  1: "#0000FF",
+  // C01 - Blue
+  2: "#FF0000",
+  // C02 - Red
+  3: "#00FF00",
+  // C03 - Green
+  4: "#FFFF00",
+  // C04 - Yellow
+  5: "#FF8000",
+  // C05 - Orange
+  6: "#00FFFF",
+  // C06 - Cyan
+  7: "#FF00FF",
+  // C07 - Magenta
+  8: "#C0C0C0",
+  // C08 - Light Gray
+  9: "#808080",
+  // C09 - Gray
+  10: "#800000",
+  // C10 - Maroon
+  11: "#008000",
+  // C11 - Dark Green
+  12: "#000080",
+  // C12 - Navy
+  13: "#808000",
+  // C13 - Olive
+  14: "#800080",
+  // C14 - Purple
+  15: "#008080",
+  // C15 - Teal
+  16: "#A0A0A0",
+  // C16 - Gray
+  17: "#8080C0",
+  // C17 - Light Blue/Purple
+  18: "#FFC0C0",
+  // C18 - Light Pink
+  19: "#0080FF",
+  // C19 - Bright Blue
+  20: "#FF0080",
+  // C20 - Hot Pink/Magenta
+  21: "#00FF80",
+  // C21 - Spring Green
+  22: "#FF8040",
+  // C22 - Light Orange/Peach
+  23: "#FFC0FF",
+  // C23 - Light Magenta/Pink
+  24: "#FF80C0"
+  // C24 - Pink
+};
+function colorForCutIndex(cutIndex) {
+  if (cutIndex === void 0) return "black";
+  return LIGHTBURN_COLORS[cutIndex] || "black";
+}
+
+// lib/svg-gen/registry/shape-ellipse.ts
+var ellipseRenderer = {
+  match: (s) => s instanceof ShapeEllipse,
+  bbox: (el) => {
+    const rx = el.rx || 0;
+    const ry = el.ry || 0;
+    const xform = el.xform ? arrayToMatrix(el.xform) : identity();
+    const extremes = [
+      { x: rx, y: 0 },
+      { x: -rx, y: 0 },
+      { x: 0, y: ry },
+      { x: 0, y: -ry }
+    ];
+    return addPts(
+      emptyBox(),
+      extremes.map((p) => apply(xform, p))
+    );
+  },
+  toSvg: (el) => {
+    const xform = el.xform ? arrayToMatrix(el.xform) : identity();
+    const transform = matToSvg(xform);
+    const rx = el.rx || 0;
+    const ry = el.ry || 0;
+    const stroke = colorForCutIndex(el.cutIndex);
+    const child = rx === ry ? leaf("circle", {
+      cx: "0",
+      cy: "0",
+      r: String(rx),
+      fill: "none",
+      stroke
+    }) : leaf("ellipse", {
+      cx: "0",
+      cy: "0",
+      rx: String(rx),
+      ry: String(ry),
+      fill: "none",
+      stroke
+    });
+    return g({ transform }, [child]);
+  }
+};
+
+// lib/svg-gen/registry/shape-group.ts
+var groupRenderer = {
+  match: (s) => s instanceof ShapeGroup,
+  bbox: (grp) => {
+    return grp.children.filter((c) => c instanceof ShapeBase).reduce((bb, c) => boxUnion(bb, bboxOfShape(c)), emptyBox());
+  },
+  toSvg: (grp) => {
+    const xform = grp.xform ? arrayToMatrix(grp.xform) : identity();
+    const transform = matToSvg(xform);
+    const children = grp.children.filter((c) => c instanceof ShapeBase).map(svgForShape);
+    return g({ transform }, children);
+  }
+};
+
+// lib/svg-gen/registry/shape-path.ts
+var pathRenderer = {
+  match: (s) => s instanceof ShapePath,
+  bbox: (p) => {
+    const xform = p.xform ? arrayToMatrix(p.xform) : identity();
+    const pts = p.verts.map((v) => apply(xform, { x: v.x, y: v.y }));
+    return addPts(emptyBox(), pts);
+  },
+  toSvg: (p) => {
+    const xform = p.xform ? arrayToMatrix(p.xform) : identity();
+    const transform = matToSvg(xform);
+    const stroke = colorForCutIndex(p.cutIndex);
+    let d = "";
+    for (let i = 0; i < p.prims.length; i++) {
+      const prim = p.prims[i];
+      const startV = p.verts[i];
+      const endV = p.verts[(i + 1) % p.verts.length];
+      if (i === 0) {
+        d += `M ${startV.x} ${startV.y}`;
+      }
+      if (prim.type === 0) {
+        d += ` L ${endV.x} ${endV.y}`;
+      } else if (prim.type === 1) {
+        const c0x = startV.c0x ?? startV.x;
+        const c0y = startV.c0y ?? startV.y;
+        const c1x = endV.c1x ?? endV.x;
+        const c1y = endV.c1y ?? endV.y;
+        d += ` C ${c0x} ${c0y} ${c1x} ${c1y} ${endV.x} ${endV.y}`;
+      }
+    }
+    if (d.length > 0 && p.isClosed) {
+      d += " Z";
+    }
+    return g({ transform }, [
+      leaf("path", {
+        d,
+        fill: "none",
+        stroke,
+        "stroke-width": "0.1"
+      })
+    ]);
+  }
+};
+
+// lib/svg-gen/registry/shape-rect.ts
+var rectRenderer = {
+  match: (s) => s instanceof ShapeRect,
+  bbox: (rect) => {
+    const w = rect.w || 0;
+    const h = rect.h || 0;
+    const xform = rect.xform ? arrayToMatrix(rect.xform) : identity();
+    const corners = [
+      { x: 0, y: 0 },
+      { x: w, y: 0 },
+      { x: w, y: h },
+      { x: 0, y: h }
+    ];
+    return addPts(
+      emptyBox(),
+      corners.map((p) => apply(xform, p))
+    );
+  },
+  toSvg: (rect) => {
+    const xform = rect.xform ? arrayToMatrix(rect.xform) : identity();
+    const transform = matToSvg(xform);
+    const w = rect.w || 0;
+    const h = rect.h || 0;
+    const cr = rect.cr || 0;
+    const stroke = colorForCutIndex(rect.cutIndex);
+    return g({ transform }, [
+      leaf("rect", {
+        x: "0",
+        y: "0",
+        width: String(w),
+        height: String(h),
+        rx: String(cr),
+        ry: String(cr),
+        fill: "none",
+        stroke
+      })
+    ]);
+  }
+};
+
+// lib/svg-gen/registry/shape-text.ts
+var textRenderer = {
+  match: (s) => s instanceof ShapeText,
+  bbox: (t) => {
+    const xform = t.xform ? arrayToMatrix(t.xform) : identity();
+    if (t.backupPath && t.backupPath.verts.length) {
+      const pts = t.backupPath.verts.map(
+        (v) => apply(xform, { x: v.x, y: v.y })
+      );
+      return addPts(emptyBox(), pts);
+    }
+    return addPts(emptyBox(), [
+      apply(xform, { x: 0, y: 0 }),
+      apply(xform, { x: 100, y: 50 })
+    ]);
+  },
+  toSvg: (t) => {
+    const xform = t.xform ? arrayToMatrix(t.xform) : identity();
+    const transform = matToSvg(xform);
+    const stroke = colorForCutIndex(t.cutIndex);
+    const text = t.text || "";
+    return g({ transform }, [
+      {
+        name: "text",
+        type: "element",
+        value: "",
+        attributes: { x: "0", y: "0", fill: stroke },
+        children: [textNode(text)]
+      }
+    ]);
+  }
+};
+
+// lib/svg-gen/registry/index.ts
+var REGISTRY = [
+  rectRenderer,
+  ellipseRenderer,
+  pathRenderer,
+  bitmapRenderer,
+  textRenderer,
+  groupRenderer
+];
+function findRenderer(shape) {
+  const r = REGISTRY.find((r2) => r2.match(shape));
+  if (!r) throw new Error(`No renderer for ${shape.token}`);
+  return r;
+}
+function bboxOfShape(shape) {
+  return findRenderer(shape).bbox(shape);
+}
+function svgForShape(shape) {
+  return findRenderer(shape).toSvg(shape);
+}
+function measure(shapes) {
+  return shapes.reduce((acc, s) => boxUnion(acc, bboxOfShape(s)), emptyBox());
+}
+function renderAll(shapes) {
+  return shapes.map(svgForShape);
+}
+
+// lib/svg-gen/index.ts
+function generateLightBurnSvg(root, options) {
+  const shapes = collectShapes(root);
+  const bbox = measure(shapes);
+  const layout = computeLayout(bbox, options);
+  const nodes = renderAll(shapes);
+  const svgTree = assembleSvg(nodes, layout);
+  return stringify(svgTree);
+}
+export {
+  LightBurnBaseElement as BaseLightBurnElement,
+  CutSetting,
+  LightBurnBaseElement,
+  LightBurnProject,
+  Notes,
+  ShapeBase,
+  ShapeBitmap,
+  ShapeEllipse,
+  ShapeGroup,
+  ShapePath,
+  ShapeRect,
+  ShapeText,
+  Thumbnail,
+  UIPrefs,
+  VariableText,
+  generateLightBurnSvg,
+  parseXml
+};