@processandtools/rp-article-designer 1.0.0

package/dist/index.js

@@ -0,0 +1,2571 @@
+var Be = Object.defineProperty;
+var He = (e, t, r) => t in e ? Be(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var C = (e, t, r) => He(e, typeof t != "symbol" ? t + "" : t, r);
+import { jsx as f, jsxs as O, Fragment as pe } from "react/jsx-runtime";
+import { createContext as le, useState as re, useCallback as Ie, useMemo as $, useEffect as Ue, useContext as V, Fragment as Ze } from "react";
+import { Edges as Ke, Text as Ye } from "@react-three/drei";
+const F = le(void 0);
+function We({ data: e, children: t, names: r }) {
+  const i = e, [n, s] = re(i), [a, o] = re(null), [l, u] = re(null), h = Ie((S) => ({
+    anglElems: n.anglelem.filter((T) => T.NAME === S),
+    anglZones: n.anglzone.filter((T) => T.NAME === S),
+    anglPrims: n.anglprim.filter((T) => T.NAME === S),
+    anglClies: n.anglclie.filter((T) => T.NAME === S),
+    anglGrtxs: n.anglgrtx.filter((T) => T.NAME === S)
+  }), [n]), { anglElems: m, anglZones: p, anglPrims: E, anglClies: y, anglGrtxs: c } = $(() => r && r.length > 0 ? {
+    anglElems: n.anglelem.filter((S) => r.includes(S.NAME)),
+    anglZones: n.anglzone.filter((S) => r.includes(S.NAME)),
+    anglPrims: n.anglprim.filter((S) => r.includes(S.NAME)),
+    anglClies: n.anglclie.filter((S) => r.includes(S.NAME)),
+    anglGrtxs: n.anglgrtx.filter((S) => r.includes(S.NAME))
+  } : {
+    anglElems: n.anglelem,
+    anglZones: n.anglzone,
+    anglPrims: n.anglprim,
+    anglClies: n.anglclie,
+    anglGrtxs: n.anglgrtx
+  }, [n, r]), D = {
+    anglElems: m,
+    anglZones: p,
+    anglPrims: E,
+    anglClies: y,
+    anglGrtxs: c,
+    selectedElem: a,
+    setSelectedElem: o,
+    hoveredElem: l,
+    setHoveredElem: u,
+    updateAnglPrim: (S, T, _) => {
+      s((k) => ({
+        ...k,
+        anglprim: k.anglprim.map(
+          (w) => w.NAME === S ? { ...w, [T]: _ } : w
+        )
+      }));
+    },
+    updateAnglElem: (S, T, _, k) => {
+      s((w) => ({
+        ...w,
+        anglelem: w.anglelem.map(
+          (b) => b.TREEID === T && b.NAME === S ? { ...b, [_]: k } : b
+        )
+      }));
+    },
+    updateAnglZone: (S, T, _, k) => {
+      s((w) => ({
+        ...w,
+        anglzone: w.anglzone.map(
+          (b) => b.TREEID === T && b.NAME === S ? { ...b, [_]: k } : b
+        )
+      }));
+    },
+    updateAnglClie: (S, T, _, k, w) => {
+      s((b) => ({
+        ...b,
+        anglclie: b.anglclie.map(
+          (L) => L.TREEID === T && L.TAGNAME === _ && L.DATATYPE === w && L.NAME === S ? {
+            ...L,
+            TAGVALUE: k,
+            DATE_LASTCHANGE: (/* @__PURE__ */ new Date()).toISOString()
+          } : L
+        )
+      }));
+    },
+    updateAnglGrtx: (S, T, _, k) => {
+      s((w) => ({
+        ...w,
+        anglgrtx: w.anglgrtx.map(
+          (b) => b.TREEID === T && b.NUM === _ && b.NAME === S ? {
+            ...b,
+            TEXT: k,
+            DATE_LASTCHANGE: (/* @__PURE__ */ new Date()).toISOString()
+          } : b
+        )
+      }));
+    },
+    // Multi-article support
+    getArticleData: h,
+    allData: n
+  };
+  return /* @__PURE__ */ f(F.Provider, { value: D, children: t });
+}
+const _e = le(null);
+function be({ children: e, articleName: t, dimensionOverrides: r }) {
+  const i = {
+    articleName: t,
+    dimensionOverrides: r
+  };
+  return /* @__PURE__ */ f(_e.Provider, { value: i, children: e });
+}
+const ke = le(void 0);
+var P = /* @__PURE__ */ ((e) => (e[e.Surface = 3] = "Surface", e[e.Material = 4] = "Material", e[e.Numeric = 100] = "Numeric", e[e.Text = 120] = "Text", e))(P || {});
+function me(e) {
+  return new Map(e.map((t) => [t.NAME, t]));
+}
+function ce(e, t, r = /* @__PURE__ */ new Set()) {
+  const i = t.get(e);
+  if (!i) return;
+  if (r.has(e)) {
+    console.error(`Circular dependency: ${[...r, e].join(" -> ")}`);
+    return;
+  }
+  const n = i.WERT;
+  if (n.startsWith("$") && i.TYP != P.Text) {
+    const a = n.slice(1);
+    return r.add(e), ce(a, t, r);
+  }
+  const s = Number(n);
+  return isNaN(s) ? n : s;
+}
+function Ae(e, t, r) {
+  const i = r.get(e);
+  if (!i)
+    return console.warn(`Variable ${e} not found`), r;
+  const n = new Map(r);
+  return n.set(e, { ...i, WERT: String(t) }), n;
+}
+function de(e, t) {
+  return e.replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (r, i) => {
+    const n = ce(i, t);
+    return n !== void 0 ? String(n) : r;
+  });
+}
+function ge(e) {
+  return /\$[A-Za-z_][A-Za-z0-9_]*/g.test(e);
+}
+function Xe(e) {
+  const t = e.matchAll(/\$([A-Za-z_][A-Za-z0-9_]*)/g);
+  return Array.from(t, (r) => r[1]);
+}
+const nr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createVariableTree: me,
+  extractVariableNames: Xe,
+  getValue: ce,
+  hasVariables: ge,
+  resolveString: de,
+  setValue: Ae
+}, Symbol.toStringTag, { value: "Module" }));
+function je({ children: e, imosVariables: t }) {
+  const [r, i] = re(() => me(t));
+  Ue(() => {
+    i(me(t));
+  }, [t]);
+  const n = Ie((a, o) => {
+    i((l) => Ae(a, o, l));
+  }, []), s = { tree: r, setValue: n };
+  return /* @__PURE__ */ f(ke.Provider, { value: s, children: e });
+}
+const De = le(null), Ne = (e) => {
+  const t = Number(e);
+  return isNaN(t) ? null : t;
+}, Y = (e) => e == null ? "" : String(e), z = (e, t, r) => {
+  const i = Ne(e), n = Ne(t);
+  return i === null || n === null ? !1 : r(i, n);
+}, K = (e, t, r) => e == null || t == null ? !1 : r(Y(e), Y(t)), qe = {
+  // Equality
+  "=": (e, t) => e == null || t == null ? e === t : Y(e).trim() === Y(t).trim(),
+  "!=": (e, t) => e == null || t == null ? e !== t : Y(e).trim() !== Y(t).trim(),
+  // Numeric comparisons - all use compareNumbers helper
+  ">": (e, t) => z(e, t, (r, i) => r > i),
+  "<": (e, t) => z(e, t, (r, i) => r < i),
+  ">=": (e, t) => z(e, t, (r, i) => r >= i),
+  "<=": (e, t) => z(e, t, (r, i) => r <= i),
+  // HTML entity versions - reuse same logic
+  "&gt;": (e, t) => z(e, t, (r, i) => r > i),
+  "&gt;=": (e, t) => z(e, t, (r, i) => r >= i),
+  "&lt;": (e, t) => z(e, t, (r, i) => r < i),
+  "&lt;=": (e, t) => z(e, t, (r, i) => r <= i),
+  // String operations - all use compareStrings helper
+  B: (e, t) => K(e, t, (r, i) => r.startsWith(i)),
+  "!B": (e, t) => K(e, t, (r, i) => !r.startsWith(i)),
+  E: (e, t) => K(e, t, (r, i) => r.endsWith(i)),
+  "!E": (e, t) => K(e, t, (r, i) => !r.endsWith(i)),
+  C: (e, t) => K(e, t, (r, i) => r.includes(i)),
+  "!C": (e, t) => K(e, t, (r, i) => !r.includes(i))
+}, Je = {
+  "Zusatzfilter 3": "filter3",
+  "Zusatzfilter 4": "filter4"
+  // Add more mappings as needed
+};
+function we(e, t = {}) {
+  const { variableTree: r, dataType: i, silent: n = !1, allowFunctions: s = !0 } = t, a = /^(.+?)\s*(mm|cm|m|in|ft|px|pt|%|deg|rad)$/i, o = {
+    value: void 0,
+    original: e,
+    resolved: e,
+    hadVariables: !1,
+    wasEvaluated: !1
+  };
+  try {
+    let l = e.trim(), u;
+    if (a.test(l)) {
+      const h = l.match(a);
+      h && (l = h[1].trim(), u = h[2]);
+    }
+    r && ge(l) && (o.hadVariables = !0, l = de(l, r), o.resolved = l), Ce(l) ? (o.wasEvaluated = !0, o.value = Le(l, s)) : Ee(l) ? (o.wasEvaluated = !0, o.value = Se(l, s)) : o.value = et(l, i);
+  } catch (l) {
+    o.error = l instanceof Error ? l.message : String(l), n || console.error(`[ExpressionResolver] Failed to resolve: "${e}"`, l), o.value = e;
+  }
+  return o;
+}
+function se(e, t = {}) {
+  return we(e, t).value;
+}
+function Ce(e) {
+  return !e || typeof e != "string" ? !1 : /^\s*IF\s*\(/i.test(e.trim());
+}
+function Le(e, t = !0) {
+  const i = e.trim().match(/^IF\s*\((.*)\)\s*$/i);
+  if (!i)
+    throw new Error(`Invalid IF statement: ${e}`);
+  const n = i[1], s = Qe(n);
+  if (s.length !== 3)
+    throw new Error(`IF statement must have exactly 3 parts: IF(condition, trueValue, falseValue). Got: ${s.length} parts`);
+  const [a, o, l] = s, h = ie(a.trim(), t) ? o.trim() : l.trim();
+  if (Ce(h))
+    return Le(h, t);
+  if (Ee(h))
+    return Se(h, t);
+  {
+    const m = Number(h);
+    return isNaN(m) ? h : m;
+  }
+}
+function Qe(e) {
+  const t = [];
+  let r = "", i = 0;
+  for (let n = 0; n < e.length; n++) {
+    const s = e[n];
+    s === "(" ? (i++, r += s) : s === ")" ? (i--, r += s) : s === "," && i === 0 ? (t.push(r), r = "") : r += s;
+  }
+  return r && t.push(r), t;
+}
+function ie(e, t) {
+  if (/\bAND\b/i.test(e))
+    return e.split(/\bAND\b/i).every((u) => ie(u.trim(), t));
+  if (/\bOR\b/i.test(e))
+    return e.split(/\bOR\b/i).some((u) => ie(u.trim(), t));
+  if (/^\s*NOT\s+/i.test(e)) {
+    const l = e.replace(/^\s*NOT\s+/i, "").trim();
+    return !ie(l, t);
+  }
+  const r = e.match(/(.+?)(<=|>=|!=|<>|=|<|>)(.+)/);
+  if (!r)
+    throw new Error(`Invalid condition: ${e}`);
+  const [, i, n, s] = r, a = Te(i.trim(), t), o = Te(s.trim(), t);
+  switch (n) {
+    case "=":
+      return a === o;
+    case "!=":
+    case "<>":
+      return a !== o;
+    case "<":
+      return a < o;
+    case ">":
+      return a > o;
+    case "<=":
+      return a <= o;
+    case ">=":
+      return a >= o;
+    default:
+      throw new Error(`Unknown operator: ${n}`);
+  }
+}
+function Te(e, t) {
+  if (e.startsWith('"') && e.endsWith('"') || e.startsWith("'") && e.endsWith("'"))
+    return e.slice(1, -1);
+  if (Ee(e))
+    return Se(e, t);
+  const r = Number(e);
+  return isNaN(r) ? e : r;
+}
+function Ee(e) {
+  if (!e || typeof e != "string") return !1;
+  const t = e.trim();
+  return /[+\-*/()]/.test(t) ? /^[\d\s+\-*/().,a-z]+$/i.test(t) : !1;
+}
+const he = /* @__PURE__ */ new Map();
+function Se(e, t = !0) {
+  const r = e.trim(), i = `${r}:${t}`;
+  if (he.has(i))
+    return he.get(i);
+  let n = r.replace(/\s+/g, "");
+  if (t && (n = n.replace(/round\(/g, "Math.round(").replace(/floor\(/g, "Math.floor(").replace(/ceil\(/g, "Math.ceil(").replace(/abs\(/g, "Math.abs(").replace(/min\(/g, "Math.min(").replace(/max\(/g, "Math.max(").replace(/pow\(/g, "Math.pow(").replace(/sqrt\(/g, "Math.sqrt(")), !(t ? /^[\d+\-*/().,a-zA-Z]+$/ : /^[\d+\-*/().]+$/).test(n))
+    throw new Error(`Expression contains invalid characters: ${e}`);
+  if (!n)
+    throw new Error("Empty expression");
+  try {
+    const a = Function(`'use strict'; return (${n})`)();
+    if (typeof a != "number" || isNaN(a))
+      throw new Error(`Expression did not evaluate to a number: ${e}`);
+    return he.set(i, a), a;
+  } catch (a) {
+    throw new Error(`Failed to evaluate expression: ${e} - ${a}`);
+  }
+}
+function et(e, t) {
+  if (!t) {
+    const r = Number(e);
+    return isNaN(r) ? e : r;
+  }
+  switch (t.toUpperCase()) {
+    case "FL":
+      return parseFloat(e);
+    case "IN":
+      return parseInt(e, 10);
+    case "CI":
+    case "CS":
+    case "ST":
+      return e;
+    case "DA":
+      return new Date(e).toISOString();
+    default:
+      const r = Number(e);
+      return isNaN(r) ? e : r;
+  }
+}
+const tt = (e) => Je[e] || e, W = class W {
+};
+C(W, "evaluateTree", (t, r, i) => t ? t.roots.every((n) => W.evaluateNode(n, r, i)) : !1), C(W, "evaluateNode", (t, r, i) => {
+  if (!t) return !1;
+  if (t.kind === "comparison") {
+    let n = t.data.LEFTVALUE;
+    const s = tt(t.data.LEFTVALUE);
+    r[s] !== void 0 ? n = r[s] : n = se(t.data.LEFTVALUE, { variableTree: i, dataType: t.data.DATATYPE, silent: !0 });
+    const a = se(t.data.RIGHTVALUE, { variableTree: i, dataType: t.data.DATATYPE, silent: !0 });
+    return qe[t.data.COMPARISONTYPE](n, a);
+  }
+  if (t.kind === "operation") {
+    const n = t.children.map((s) => W.evaluateNode(s, r, i));
+    switch (t.data.OPSTRING) {
+      case "AND":
+        return n.every(Boolean);
+      case "OR":
+        return n.some(Boolean);
+      case "NOT":
+        return !n.every(Boolean);
+      case "NOT OR":
+        return !n.some(Boolean);
+      default:
+        return !1;
+    }
+  }
+  return !1;
+});
+let ae = W;
+class Me {
+  static evaluate(t, r, i) {
+    const n = t.nodes.find((s) => s.conditionId === 0 || s.conditionTree === null);
+    for (const s of t.nodes) {
+      if (s.conditionId === 0 || s.conditionTree === null) continue;
+      if (ae.evaluateTree(s.conditionTree, r, i))
+        return {
+          lindiv: s.lindiv,
+          nodeNum: s.nodeNum,
+          matched: !0,
+          isDefault: !1,
+          descriptorType: t.descriptor.DESC_TYPE
+        };
+    }
+    if (n)
+      return {
+        lindiv: n.lindiv,
+        nodeNum: n.nodeNum,
+        matched: !1,
+        isDefault: !0,
+        descriptorType: t.descriptor.DESC_TYPE
+      };
+    throw new Error("No matching node found and no default node exists");
+  }
+  static findAllNonDefaultMatches(t, r, i) {
+    const n = [];
+    for (const s of t.nodes) {
+      if (s.conditionId === 0 || s.conditionTree === null) continue;
+      ae.evaluateTree(s.conditionTree, r, i) && n.push(s);
+    }
+    return n;
+  }
+}
+class rt {
+  constructor(t, r) {
+    C(this, "descriptors");
+    C(this, "variableTree");
+    this.descriptors = new Map(
+      t.map((i) => [i.descriptor.NAME, i])
+    ), this.variableTree = r;
+  }
+  evaluate(t, r) {
+    const i = this.getDescriptor(t);
+    if (!i)
+      throw new Error(`Descriptor not found: ${t}`);
+    return Me.evaluate(i, r, this.variableTree);
+  }
+  getDescriptor(t) {
+    return this.descriptors.get(t);
+  }
+  hasDescriptor(t) {
+    return this.descriptors.has(t);
+  }
+  getDescriptorNames() {
+    return Array.from(this.descriptors.keys());
+  }
+  getDescriptorsByType(t) {
+    return Array.from(this.descriptors.values()).filter(
+      (r) => r.descriptor.DESC_TYPE === t
+    );
+  }
+  findAllMatches(t, r) {
+    const i = this.getDescriptor(t);
+    if (!i)
+      throw new Error(`Descriptor not found: ${t}`);
+    return Me.findAllNonDefaultMatches(i, r, this.variableTree);
+  }
+  getStats() {
+    const t = {};
+    for (const r of this.descriptors.values()) {
+      const i = r.descriptor.DESC_TYPE;
+      t[i] = (t[i] || 0) + 1;
+    }
+    return {
+      total: this.descriptors.size,
+      byType: t,
+      names: this.getDescriptorNames()
+    };
+  }
+}
+function j() {
+  const e = V(ke);
+  if (!e)
+    throw new Error("useVariables must be used within a VariableProvider");
+  const { tree: t, setValue: r } = e, i = $(() => (a) => ce(a, t), [t]), n = $(() => (a) => de(a, t), [t]), s = $(() => (a) => ge(a), []);
+  return {
+    tree: t,
+    // Variable tree
+    getValue: i,
+    // Get variable value
+    resolveString: n,
+    // Resolve string with variables
+    hasVariables: s,
+    // Check if string has variables
+    setValue: r
+    // Set variable value (updates tree state)
+  };
+}
+function it({ children: e, descriptorData: t }) {
+  const r = j(), i = $(() => new rt(
+    t,
+    r.tree
+  ), [t, r]);
+  return /* @__PURE__ */ f(De.Provider, { value: i, children: e });
+}
+var x = /* @__PURE__ */ ((e) => (e._2D_TOP = "2D_TOP", e._2D_FRONT = "2D_FRONT", e._3D = "3D", e))(x || {});
+const fe = 0, nt = 1, Oe = (e) => e + ".0", Pe = (e) => e + ".1", Ve = (e) => e + ".2", Re = (e) => e + ".3", ve = (e) => e.substring(0, e.lastIndexOf(".")), st = (e) => {
+  const t = ve(e), i = ($e(e) + 3) % 4;
+  return `${t}.${i}`;
+}, at = (e) => {
+  const t = ve(e), i = ($e(e) + 1) % 4;
+  return `${t}.${i}`;
+}, $e = (e) => parseInt(e.substring(e.lastIndexOf(".") + 1)), X = {
+  IAC_THICKNESS: "IAC_THICKNESS",
+  // sides and dividers (shelf / partitions)
+  IAC_BOTTOMSHELFTHICKNESS: "IAC_BOTTOMSHELFTHICKNESS",
+  // for bottom shelf
+  IAC_TOPSHELFTHICKNESS: "IAC_TOPSHELFTHICKNESS"
+  // for top shelf
+}, v = 1;
+function Q() {
+  const e = V(F);
+  if (e === void 0)
+    throw new Error("useData must be used within a DataProvider");
+  return e;
+}
+function ee() {
+  const e = V(_e);
+  if (!e)
+    throw new Error("useArticle must be used within an ArticleProvider");
+  return e;
+}
+function ne(e, t, r) {
+  const { getArticleData: i } = Q(), { articleName: n } = ee(), { anglClies: s } = i(n), a = s.find((l) => l.TREEID === e && l.DATATYPE === r && l.TAGNAME === t);
+  return a ? {
+    thickness: Number(a.TAGVALUE)
+  } : null;
+}
+function ot(e) {
+  const { getArticleData: t } = Q(), { resolveString: r } = j(), { articleName: i } = ee(), n = t(i).anglGrtxs;
+  if (!n) return null;
+  const s = n.filter((o) => o.TREEID === e), a = /* @__PURE__ */ new Map();
+  return s.map((o) => a.set(`AD zone info0${o.NUM + 1}`, r(o.TEXT))), {
+    zoneInfo: a
+  };
+}
+function ue(e) {
+  const { getArticleData: t } = Q(), { articleName: r } = ee(), { anglZones: i } = t(r), n = i.find((a) => a.TREEID === e), s = i.filter((a) => a.TREEID.substring(0, a.TREEID.lastIndexOf(".")) === e);
+  return s.sort((a, o) => a.TREEID.localeCompare(o.TREEID, void 0, { numeric: !0 })), n ? {
+    // Zone data
+    currentZone: n,
+    children: s,
+    // Shelf properties
+    get topShelfCP() {
+      return n?.TOPSHELF;
+    },
+    get bottomShelfCP() {
+      return n?.BOTSHELF;
+    },
+    zoneInfo() {
+      return ot(e)?.zoneInfo;
+    },
+    // Thickness calculations
+    getClieThk(a, o) {
+      return this.topShelfCP === "" ? 0 : ne(a, o, nt)?.thickness || 0;
+    },
+    get topShelfThk() {
+      return this.getClieThk(e, X.IAC_TOPSHELFTHICKNESS);
+    },
+    get bottomShelfThk() {
+      return this.getClieThk(e, X.IAC_BOTTOMSHELFTHICKNESS);
+    },
+    get dividerThk() {
+      return this.getClieThk(e, X.IAC_THICKNESS);
+    }
+  } : null;
+}
+function te(e) {
+  const { getArticleData: t } = Q(), { articleName: r } = ee(), { resolveString: i } = j(), { anglElems: n } = t(r), s = n.find((M) => M.TREEID === e), a = ve(e), o = ue(a);
+  if (!s) return null;
+  const l = s.CPNAME === "" ? 0 : ne(e, X.IAC_THICKNESS, fe)?.thickness || 0, u = ne(at(e), X.IAC_THICKNESS, fe)?.thickness || 0, h = ne(st(e), X.IAC_THICKNESS, fe)?.thickness || 0, m = s.CPNAME === "" ? 0 : s.INSETFOR !== "" ? se(i(s.INSETFOR)) : Number(s.INSET), p = (typeof m == "string" ? 0 : m) || 0, E = s.MANINFO || "black", y = s.CPNAME, c = o?.topShelfThk || 0, d = o?.bottomShelfThk || 0, g = {
+    start: Number(s.STARTOFFS) || 0,
+    end: Number(s.ENDOFFS) || 0,
+    top: Number(s.TOPOFFS) || 0,
+    bottom: Number(s.BOTOFFS) || 0
+  }, I = {
+    start: s.STARTTRIM,
+    end: s.ENDTRIM,
+    top: s.TOPTRIM,
+    bottom: s.BOTTRIM
+  }, N = {
+    top: I.top === "S" ? c : 0,
+    bottom: I.bottom === "S" ? d : 0
+  };
+  return {
+    TREEID: e,
+    thk: l,
+    nxtThk: u,
+    prvThk: h,
+    inset: p,
+    color: E,
+    CPNAME: y,
+    topThk: c,
+    bottomThk: d,
+    oversize: g,
+    trim: I,
+    elmTrimThk: N
+  };
+}
+var A = class extends Error {
+  constructor(e) {
+    super(`Evaluation Error: ${e}`), this.name = "EvaluationError";
+  }
+}, H, lt = (H = class {
+  constructor() {
+    C(this, "cache", /* @__PURE__ */ new Map());
+    C(this, "source", "");
+    C(this, "tokens", []);
+    C(this, "start", 0);
+    C(this, "current", 0);
+    C(this, "errors", []);
+  }
+  reportError(t) {
+    this.errors.push(t);
+  }
+  scan(t) {
+    if (this.cache.has(t)) {
+      const r = this.cache.get(t);
+      return this.cache.delete(t), this.cache.set(t, r), r;
+    }
+    try {
+      this.source = t;
+      const r = this.preformScan();
+      if (this.cache.set(this.source, r), this.cache.size > 3) {
+        const i = this.cache.keys().next().value;
+        this.cache.delete(i);
+      }
+      return r;
+    } catch (r) {
+      throw console.error(r), new Error(r instanceof Error ? r.message : String(r));
+    }
+  }
+  preformScan() {
+    this.resetState();
+    try {
+      if (this.source.includes("<") || this.source.includes(">"))
+        throw new Error("Angle brackets are not allowed in the input string");
+      if (this.source.length === 0)
+        throw new Error("Empty input string");
+      for (this.start = 0, this.current = 0, this.tokens = [], this.start === 0 && this.addToken("LEFT_ANGLE_BRACKET", "<"); !this.isAtEnd(); ) {
+        this.start = this.current;
+        const t = this.peek();
+        switch (t) {
+          case ":":
+            this.addToken("RIGHT_ANGLE_BRACKET", ">"), this.addToken("LEFT_ANGLE_BRACKET", "<"), this.advance();
+            break;
+          case " ":
+          case "\r":
+          case "	":
+          case `
+`:
+            this.advance();
+            break;
+          case "0":
+          case "1":
+          case "2":
+          case "3":
+          case "4":
+          case "5":
+          case "6":
+          case "7":
+          case "8":
+          case "9":
+          case ".":
+            this.scanNumber();
+            break;
+          case "$":
+            this.scanVariable();
+            break;
+          case "+":
+          case "-":
+          case "*":
+          case "/":
+            this.addToken("OPERATOR", t), this.advance();
+            break;
+          case "(":
+            this.addToken("PAREN_OPEN", "("), this.advance();
+            break;
+          case ")":
+            this.addToken("PAREN_CLOSE", ")"), this.advance();
+            break;
+          case "{":
+            this.current != 0 && this.tokens[this.tokens.length - 1].type != "OPERATOR" && this.addToken("OPERATOR", "*"), this.addToken("BRACE_OPEN", "{"), this.addToken("LEFT_ANGLE_BRACKET", "<"), this.advance();
+            break;
+          case "}":
+            this.addToken("RIGHT_ANGLE_BRACKET", ">"), this.addToken("BRACE_CLOSE", "}"), this.advance();
+            break;
+          case "[":
+            this.addToken("OPERATOR", "~"), this.addToken("BRACKET_OPEN", "["), this.advance();
+            break;
+          case "]":
+            this.addToken("BRACKET_CLOSE", "]"), this.advance();
+            break;
+          case "m":
+            this.peekNext() === "m" ? this.scanMm() : this.scanIdentifierOrFunction();
+            break;
+          default:
+            this.isAlpha(t) ? this.scanIdentifierOrFunction() : this.reportError(
+              `Unexpected character: ${t} at position: ${this.current}`
+            );
+        }
+      }
+      if (this.addToken("RIGHT_ANGLE_BRACKET", ">"), this.addToken("EOF", ""), this.errors.length > 0)
+        throw new Error(this.errors.join(`,
+`));
+      return this.tokens;
+    } catch (t) {
+      throw new Error(t instanceof Error ? t.message : String(t));
+    }
+  }
+  isAtEnd() {
+    return this.current >= this.source.length;
+  }
+  advance() {
+    return this.source.charAt(this.current++);
+  }
+  peek() {
+    return this.isAtEnd() ? "\0" : this.source.charAt(this.current);
+  }
+  peekNext() {
+    return this.current + 1 >= this.source.length ? "\0" : this.source.charAt(this.current + 1);
+  }
+  addToken(t, r) {
+    this.tokens.push({
+      type: t,
+      lexeme: r || (t ? this.source.substring(this.start, this.current) : ""),
+      position: this.start
+    });
+  }
+  isDigit(t) {
+    return /^[0-9]$/.test(t);
+  }
+  isAlpha(t) {
+    return /^[a-zA-Z]$/.test(t);
+  }
+  scanNumber() {
+    for (; this.isDigit(this.peek()); )
+      this.advance();
+    if (this.peek() === ".")
+      for (this.advance(), this.isDigit(this.peek()) || this.reportError(
+        "Expected digit after decimal point at position: " + this.current
+      ); this.isDigit(this.peek()); )
+        this.advance();
+    this.addToken(
+      "NUMBER"
+      /* NUMBER */
+    );
+  }
+  scanVariable() {
+    for (this.advance(); /[a-zA-Z0-9_]/.test(this.peek()); )
+      this.advance();
+    const t = this.source.substring(this.start + 1, this.current);
+    if (t.endsWith("mm")) {
+      const r = t.substring(0, t.length - 2);
+      r && r.length > 0 ? (this.addToken("VARIABLE", r), this.addToken("UNIT", "mm")) : this.reportError("Variable name cannot be empty or $mm");
+    } else
+      this.addToken("VARIABLE", t);
+  }
+  scanMm() {
+    this.advance(), this.advance(), this.addToken("UNIT", "mm");
+  }
+  scanIdentifierOrFunction() {
+    const t = ["X", "Y", "n"];
+    for (; this.isAlpha(this.peek()); )
+      this.advance();
+    const r = this.source.substring(this.start, this.current), i = H.MATHEMATICAL_FUNCTIONS[r.toLocaleLowerCase()];
+    i != null ? this.addToken(i, r) : t.includes(r) ? this.addToken("SPECIAL_VARIABLE", r) : this.reportError(
+      `Unknown identifier: ${r} at position: ${this.current}`
+    );
+  }
+  resetState() {
+    this.tokens = [], this.start = 0, this.current = 0, this.errors = [];
+  }
+}, C(H, "MATHEMATICAL_FUNCTIONS", {
+  abs: "FUNCTION",
+  acos: "FUNCTION",
+  asin: "FUNCTION",
+  atan: "FUNCTION",
+  bog2deg: "FUNCTION",
+  cos: "FUNCTION",
+  deg2bog: "FUNCTION",
+  in2mm: "FUNCTION",
+  ln: "FUNCTION",
+  log: "FUNCTION",
+  log10: "FUNCTION",
+  max: "FUNCTION",
+  maxunder: "FUNCTION",
+  mm2in: "FUNCTION",
+  nextto: "FUNCTION",
+  pi: "FUNCTION",
+  pow: "FUNCTION",
+  round: "FUNCTION",
+  sin: "FUNCTION",
+  sqr: "FUNCTION",
+  tab: "FUNCTION",
+  tan: "FUNCTION"
+  /* FUNCTION */
+}), H), ct = class {
+  constructor() {
+    C(this, "cache", /* @__PURE__ */ new Map());
+    C(this, "tokens", []);
+    C(this, "current", 0);
+    C(this, "resetCurrent", () => {
+      this.current = 0;
+    });
+  }
+  parse(e) {
+    if (this.cache.has(e)) {
+      const t = this.cache.get(e);
+      return this.cache.delete(e), this.cache.set(e, t), t;
+    }
+    try {
+      this.tokens = e;
+      const t = this.performParse(e);
+      if (this.cache.set(e, t), this.cache.size > 3) {
+        const r = this.cache.keys().next().value;
+        this.cache.delete(r);
+      }
+      return t;
+    } catch (t) {
+      throw new Error(t instanceof Error ? t.message : String(t));
+    }
+  }
+  performParse(e) {
+    if (this.resetCurrent(), this.tokens.length === 0)
+      throw new Error("No tokens to parse.");
+    try {
+      return this.expression();
+    } catch (t) {
+      throw new Error(t instanceof Error ? t.message : String(t));
+    }
+  }
+  checkMillimeterSuffix() {
+    if (this.isAtEnd()) return !1;
+    const e = this.peek();
+    return e.type === "UNIT" && e.lexeme === "mm";
+  }
+  consumeMillimeterSuffix() {
+    return this.checkMillimeterSuffix() ? (this.advance(), !0) : !1;
+  }
+  sections() {
+    const e = [];
+    if (!this.check(
+      "LEFT_ANGLE_BRACKET"
+      /* ANGLE_BRACKET_OPEN */
+    ))
+      return this.expression();
+    for (; this.check(
+      "LEFT_ANGLE_BRACKET"
+      /* ANGLE_BRACKET_OPEN */
+    ); ) {
+      this.advance();
+      let t = this.expression();
+      this.consume(
+        "RIGHT_ANGLE_BRACKET",
+        "Expected '>' after section expression."
+      ), e.push({
+        type: "Section",
+        nodes: t,
+        hasMillimeterSuffix: this.consumeMillimeterSuffix()
+      });
+    }
+    if (e.length === 1) {
+      const t = e[0];
+      return t.type === "Section" && t.nodes.type === "Section" ? t.nodes : t;
+    }
+    return {
+      type: "Sections",
+      sections: e
+    };
+  }
+  expression() {
+    try {
+      let e = this.term();
+      for (; !this.isAtEnd() && this.check(
+        "OPERATOR"
+        /* OPERATOR */
+      ) && ["+", "-"].includes(this.peek().lexeme); ) {
+        this.advance();
+        const t = this.previous().lexeme, r = this.term();
+        e = {
+          type: "BinaryExpression",
+          left: e,
+          operator: t,
+          right: r
+        };
+      }
+      return e;
+    } catch (e) {
+      throw new Error(
+        `Failed to parse expression: ${e.message}`
+      );
+    }
+  }
+  term() {
+    try {
+      let e = this.factor();
+      for (; !this.isAtEnd() && this.check(
+        "OPERATOR"
+        /* OPERATOR */
+      ) && ["*", "/", "~"].includes(this.peek().lexeme); ) {
+        this.advance();
+        const t = this.previous().lexeme, r = this.factor();
+        if (r.type === "SpecialVariable" && r.name === "n")
+          throw new Error(
+            'Invalid usage: "n" cannot appear on the right-hand side of an operator'
+          );
+        e = {
+          type: "BinaryExpression",
+          left: e,
+          operator: t,
+          right: r
+        };
+      }
+      return e;
+    } catch (e) {
+      throw new Error(`Failed to parse term: ${e.message}`);
+    }
+  }
+  factor() {
+    try {
+      if (this.check(
+        "OPERATOR"
+        /* OPERATOR */
+      ) && ["-", "+"].includes(this.peek().lexeme)) {
+        this.advance();
+        const e = this.previous().lexeme, t = this.factor();
+        return {
+          type: "UnaryExpression",
+          operator: e,
+          right: t
+        };
+      }
+      return this.primary();
+    } catch (e) {
+      throw new Error(`Failed to parse factor: ${e.message}`);
+    }
+  }
+  primary() {
+    try {
+      if (this.check(
+        "NUMBER"
+        /* NUMBER */
+      ))
+        return this.advance(), {
+          type: "NumberLiteral",
+          value: parseFloat(this.previous().lexeme),
+          hasMillimeterSuffix: this.consumeMillimeterSuffix()
+        };
+      if (this.check(
+        "VARIABLE"
+        /* VARIABLE */
+      ))
+        return this.advance(), {
+          type: "Variable",
+          name: this.previous().lexeme,
+          hasMillimeterSuffix: this.consumeMillimeterSuffix()
+        };
+      if (this.check(
+        "SPECIAL_VARIABLE"
+        /* SPECIAL_VARIABLE */
+      ))
+        return this.advance(), {
+          type: "SpecialVariable",
+          name: this.previous().lexeme,
+          hasMillimeterSuffix: this.previous().lexeme === "n"
+        };
+      if (this.check(
+        "FUNCTION"
+        /* FUNCTION */
+      )) {
+        this.advance();
+        const e = this.previous().lexeme;
+        this.consume(
+          "PAREN_OPEN",
+          `Expected '(' after function name '${e}'.`
+        );
+        const t = this.expression();
+        return this.consume(
+          "PAREN_CLOSE",
+          "Expected ')' after function arguments."
+        ), {
+          type: "FunctionCall",
+          name: e,
+          arg: t,
+          hasMillimeterSuffix: this.consumeMillimeterSuffix()
+        };
+      }
+      if (this.check(
+        "PAREN_OPEN"
+        /* PAREN_OPEN */
+      )) {
+        this.advance();
+        const e = this.expression();
+        if (!e)
+          throw new Error("Expected expression inside parentheses.");
+        return this.consume("PAREN_CLOSE", "Expected ')' after expression."), {
+          type: "Grouping",
+          expression: e,
+          hasMillimeterSuffix: this.consumeMillimeterSuffix()
+        };
+      }
+      if (this.check(
+        "PAREN_CLOSE"
+        /* PAREN_CLOSE */
+      ))
+        throw new Error("Unexpected ')' without a matching '('.");
+      if (this.check(
+        "BRACE_OPEN"
+        /* BRACE_OPEN */
+      )) {
+        this.advance();
+        let e = this.sections();
+        return this.consume("BRACE_CLOSE", "Expected '}' after expression."), e.type === "Section" && e.nodes.type === "Section" && (e = e.nodes), {
+          type: "Repeated",
+          toRepeat: e,
+          hasMillimeterSuffix: this.consumeMillimeterSuffix()
+        };
+      }
+      if (this.check(
+        "LEFT_ANGLE_BRACKET"
+        /* ANGLE_BRACKET_OPEN */
+      ))
+        return this.sections();
+      throw new Error(`Unexpected token: ${this.peek().lexeme}`);
+    } catch (e) {
+      throw new Error(`Failed to parse primary: ${e.message}`);
+    }
+  }
+  check(e) {
+    return this.isAtEnd() ? !1 : this.peek().type === e;
+  }
+  advance() {
+    return this.isAtEnd() || this.current++, this.previous();
+  }
+  consume(e, t) {
+    if (this.check(e)) return this.advance();
+    throw new Error(t);
+  }
+  isAtEnd() {
+    return this.current >= this.tokens.length;
+  }
+  peek() {
+    return this.tokens[this.current];
+  }
+  previous() {
+    return this.tokens[this.current - 1];
+  }
+}, xe = (e) => e.type === "SpecialVariable" && e.name === "n";
+function ut(e, t) {
+  if (e.right.type === "SpecialVariable" && e.right.name === "n")
+    return new A(
+      "Cannot have n in the right side of an expression"
+    );
+  const r = xe(e.left) ? e.left : this.evaluate(e.left), i = xe(e.right) ? e.right : this.evaluate(e.right);
+  if (r instanceof A) return r;
+  if (i instanceof A) return i;
+  const n = r.type === "NumberLiteral" && i.type === "NumberLiteral", s = n ? r.hasMillimeterSuffix === i.hasMillimeterSuffix : !1, a = (o) => o.type === "Repeated";
+  switch (e.operator) {
+    case "+":
+      return n && s && t?.isInsideGroup == !1 ? {
+        type: "NumberLiteral",
+        value: r.value + i.value,
+        hasMillimeterSuffix: r.hasMillimeterSuffix === !0 || i.hasMillimeterSuffix === !0,
+        spreadMm: r.spreadMm || i.spreadMm
+      } : n && t?.isInsideGroup == !0 ? {
+        type: "NumberLiteral",
+        value: r.value + i.value,
+        spreadMm: r.hasMillimeterSuffix || i.hasMillimeterSuffix
+      } : {
+        type: "BinaryExpression",
+        operator: "+",
+        left: r,
+        right: i
+      };
+    case "*":
+      return n && t?.isInsideGroup == !0 ? {
+        type: "NumberLiteral",
+        value: r.value * i.value,
+        hasMillimeterSuffix: r.hasMillimeterSuffix === !0 || i.hasMillimeterSuffix === !0,
+        spreadMm: r.spreadMm || i.spreadMm
+      } : a(i) && r.type === "NumberLiteral" ? {
+        type: "Repeated",
+        toRepeat: i.toRepeat,
+        times: Math.round(r.value),
+        hasMillimeterSuffix: i.type === "NumberLiteral" && i.hasMillimeterSuffix || !1
+      } : t?.isInsideGroup == !1 && r.type !== "SpecialVariable" && r.name !== "n" ? new A("cannot have * outside of group") : r.type === "SpecialVariable" ? {
+        type: "BinaryExpression",
+        operator: "*",
+        left: r,
+        right: {
+          type: "NumberLiteral",
+          value: i.value,
+          hasMillimeterSuffix: !0
+        }
+      } : {
+        type: "BinaryExpression",
+        operator: "*",
+        left: r,
+        right: i,
+        hasMillimeterSuffix: r.hasMillimeterSuffix || i.hasMillimeterSuffix
+      };
+    case "/":
+      if (n && t?.isInsideGroup == !0)
+        return {
+          type: "NumberLiteral",
+          value: r.value / i.value,
+          hasMillimeterSuffix: r.hasMillimeterSuffix === !0 || i.hasMillimeterSuffix === !0
+        };
+      if (t?.isInsideGroup == !1)
+        return new A("cannot have  / outside of group");
+    case "-":
+      return n && s && t?.isInsideGroup == !1 ? {
+        type: "NumberLiteral",
+        value: r.value - i.value,
+        hasMillimeterSuffix: r.hasMillimeterSuffix === !0 || i.hasMillimeterSuffix === !0,
+        spreadMm: r.spreadMm || i.spreadMm
+      } : n && t?.isInsideGroup == !0 ? {
+        type: "NumberLiteral",
+        value: r.value - i.value,
+        spreadMm: r.hasMillimeterSuffix || i.hasMillimeterSuffix
+      } : {
+        type: "BinaryExpression",
+        operator: "-",
+        left: r,
+        right: i
+      };
+    default:
+      throw new A("Invalid Operator");
+  }
+}
+function ht(e, t) {
+  const r = this.evaluate(e.arg);
+  if (r instanceof A)
+    throw new A("Error in function arguments");
+  switch (e.name.toLowerCase()) {
+    case "abs":
+      return {
+        type: "NumberLiteral",
+        value: Math.abs(r.value),
+        hasMillimeterSuffix: r.hasMillimeterSuffix,
+        spreadMm: t?.isInsideGroup === !1
+      };
+    case "acos":
+      return {
+        type: "NumberLiteral",
+        value: Math.acos(r.value),
+        hasMillimeterSuffix: r.hasMillimeterSuffix,
+        spreadMm: t?.isInsideGroup === !1
+      };
+    case "asin":
+      return {
+        type: "NumberLiteral",
+        value: Math.asin(r.value),
+        hasMillimeterSuffix: r.hasMillimeterSuffix,
+        spreadMm: t?.isInsideGroup === !1
+      };
+    case "atan":
+      return {
+        type: "NumberLiteral",
+        value: Math.atan(r.value),
+        hasMillimeterSuffix: r.hasMillimeterSuffix,
+        spreadMm: t?.isInsideGroup === !1
+      };
+    case "cos":
+      return {
+        type: "NumberLiteral",
+        value: Math.cos(r.value),
+        hasMillimeterSuffix: r.hasMillimeterSuffix,
+        spreadMm: t?.isInsideGroup === !1
+      };
+    case "sin":
+      return {
+        type: "NumberLiteral",
+        value: Math.sin(r.value),
+        hasMillimeterSuffix: r.hasMillimeterSuffix,
+        spreadMm: t?.isInsideGroup === !1
+      };
+    case "tan":
+      return {
+        type: "NumberLiteral",
+        value: Math.tan(r.value),
+        hasMillimeterSuffix: r.hasMillimeterSuffix,
+        spreadMm: t?.isInsideGroup === !1
+      };
+    case "round":
+      return {
+        type: "NumberLiteral",
+        value: Math.round(r.value),
+        hasMillimeterSuffix: r.hasMillimeterSuffix,
+        spreadMm: t?.isInsideGroup === !1
+      };
+    case "bog2deg":
+      return {
+        type: "NumberLiteral",
+        value: r.value * (180 / Math.PI),
+        hasMillimeterSuffix: r.hasMillimeterSuffix,
+        spreadMm: t?.isInsideGroup === !1
+      };
+    case "deg2bog":
+      return {
+        type: "NumberLiteral",
+        value: r.value * (Math.PI / 180),
+        hasMillimeterSuffix: r.hasMillimeterSuffix,
+        spreadMm: t?.isInsideGroup === !1
+      };
+    case "in2mm":
+      return {
+        type: "NumberLiteral",
+        value: r.value * 25.4,
+        hasMillimeterSuffix: r.hasMillimeterSuffix,
+        spreadMm: t?.isInsideGroup === !1
+      };
+    case "mm2in":
+      return {
+        type: "NumberLiteral",
+        value: r.value / 25.4,
+        hasMillimeterSuffix: r.hasMillimeterSuffix,
+        spreadMm: t?.isInsideGroup === !1
+      };
+    case "ln":
+      return {
+        type: "NumberLiteral",
+        value: Math.log(r.value),
+        hasMillimeterSuffix: r.hasMillimeterSuffix,
+        spreadMm: t?.isInsideGroup === !1
+      };
+    case "log10":
+      return {
+        type: "NumberLiteral",
+        value: Math.log10(r.value),
+        hasMillimeterSuffix: r.hasMillimeterSuffix,
+        spreadMm: t?.isInsideGroup === !1
+      };
+    default:
+      throw new A("Function not implemented");
+  }
+}
+function ft(e) {
+  if (!this.variables || !(e.name in this.variables))
+    throw new A(`Variable ${e.name} is not defined.`);
+  return {
+    type: "NumberLiteral",
+    value: this.variables[e.name],
+    hasMillimeterSuffix: e.hasMillimeterSuffix
+  };
+}
+var mt = class {
+  constructor() {
+    C(this, "nestingLevel", 0);
+    C(this, "variables", {});
+    // evaluate binary expression
+    C(this, "evaluateBinaryExpression");
+    C(this, "evaluateFunction");
+    C(this, "evaluateVariable");
+    this.evaluateBinaryExpression = ut.bind(this), this.evaluateFunction = ht.bind(this), this.evaluateVariable = ft.bind(this);
+  }
+  evaluate(e, t = { isInsideGroup: !1 }, r) {
+    this.nestingLevel++;
+    try {
+      if (r && (this.variables = r), this.isSections(e))
+        return this.evaluateSections(e, t);
+      if (this.isSection(e)) {
+        const i = this.evaluate(e.nodes, t);
+        return i instanceof A ? new A(
+          `Error in section ${JSON.stringify(e)}`
+        ) : { ...e, nodes: i };
+      }
+      if (this.isNumberLiteral(e))
+        if (t.isInsideGroup) {
+          if (e.hasMillimeterSuffix)
+            return { ...e, spreadMm: !0 };
+        } else
+          return e;
+      if (this.isGrouping(e)) {
+        t = { ...t, isInsideGroup: !0 };
+        const i = this.evaluate(e.expression, t);
+        return i instanceof A ? i : {
+          ...i,
+          hasMillimeterSuffix: e.hasMillimeterSuffix
+        };
+      }
+      if (this.isRepeated(e)) {
+        const i = this.evaluate(e.toRepeat);
+        return i instanceof A ? i : { ...e, toRepeat: i };
+      }
+      if (this.isBinaryExpression(e))
+        return this.evaluateBinaryExpression(e, t);
+      if (this.isUnaryExpression(e))
+        return {
+          type: "NumberLiteral",
+          value: e.operator === "-" ? -1 * e.right.value : e.right.value,
+          hasMillimeterSuffix: e.right.hasMillimeterSuffix
+        };
+      if (this.isFunctionCall(e))
+        return this.evaluateFunction(e, t);
+      if (this.isVariable(e)) {
+        if (this.variables)
+          return this.evaluateVariable(e);
+        throw new A("No variables defined.");
+      }
+      throw new A(`unsupported node type: ${e.type}`);
+    } catch (i) {
+      throw new A(i.message);
+    } finally {
+      this.nestingLevel--;
+    }
+  }
+  isUnaryExpression(e) {
+    return e.type === "UnaryExpression";
+  }
+  isNumberLiteral(e) {
+    return e.type === "NumberLiteral";
+  }
+  isVariable(e) {
+    return e.type === "Variable" || e.type === "SpecialVariable";
+  }
+  isBinaryExpression(e) {
+    return e.type === "BinaryExpression";
+  }
+  isFunctionCall(e) {
+    return e.type === "FunctionCall";
+  }
+  isGrouping(e) {
+    return e.type === "Grouping";
+  }
+  isRepeated(e) {
+    return e.type === "Repeated";
+  }
+  isSections(e) {
+    return e.type === "Sections";
+  }
+  isSection(e) {
+    return e.type === "Section";
+  }
+  evaluateSections(e, t = { isInsideGroup: !1 }) {
+    return { type: "Sections", sections: e.sections.map((i) => {
+      const n = this.evaluate(i.nodes);
+      if (n instanceof A) throw n;
+      return { type: "Section", nodes: n };
+    }) };
+  }
+};
+function G(e, t) {
+  if (!e)
+    throw new A(
+      `unsupported node type to traverse: ${JSON.stringify(e)}`
+    );
+  t(e), e.type === "Sections" && Array.isArray(e.sections) ? e.sections.forEach((r) => G(r, t)) : e.type === "Section" && e.nodes ? G(e.nodes, t) : e.type;
+}
+var pt = class {
+  accumulateIncorporatedThicknesses(e, t, r, i, n, s, a, o, l) {
+    let u = 0;
+    if (a === "M")
+      for (let h = 1; h < e.sections.length - 1; h++)
+        u += i;
+    if (a === "O")
+      for (let h = 1; h < e.sections.length - 1; h++)
+        u += i * 2;
+    return n === "M" && (u += t / 2), n === "O" && (u += t), s === "M" && (u += t / 2), s === "O" && (u += t), l === "M" && (u += r / 2), l === "O" && (u += r), o === "M" && (u += r / 2), o === "O" && (u += r), u;
+  }
+}, dt = class {
+  calculateSections(e, t = 500, r = 0, i) {
+    try {
+      if (e instanceof A)
+        throw e;
+      if (e.type !== "Sections" && e.type !== "Section")
+        throw new A(
+          `Expected Sections or Section, got ${JSON.stringify(e)}`
+        );
+      let n = { type: "Sections", sections: [] };
+      if (e.type === "Sections")
+        for (const c of e.sections)
+          if (c.nodes.type === "Repeated" && c.nodes.times) {
+            for (let d = 0; d < (c.nodes?.times ?? 0); d++)
+              if (c.nodes.toRepeat.type === "Section")
+                n.sections.push(
+                  c.nodes.toRepeat
+                );
+              else if (c.nodes.toRepeat.type === "Sections")
+                for (const g of c.nodes.toRepeat.sections)
+                  n.sections.push(g);
+          } else
+            n.sections.push(c);
+      else e.type === "Section" && n.sections.push(e);
+      if (i) {
+        const d = new pt().accumulateIncorporatedThicknesses(
+          n,
+          i.startPanelThk,
+          i.endPanelThk,
+          r,
+          i.sizerefout1,
+          i.sizerefedg1,
+          i.sizerefmid,
+          i.sizerefedg2,
+          i.sizerefout2
+        );
+      }
+      n.sections.forEach((c) => {
+        let d = !1;
+        G(c, (g) => {
+          g.type === "NumberLiteral" ? g?.spreadMm === !0 && (d = !0) : g.type === "BinaryExpression" && g.left.type === "NumberLiteral" && (g.left?.spreadMm === !0 && (d = !0), g.right?.spreadMm === !0 && (d = !0));
+        }), d && G(c, (g) => {
+          g.type === "NumberLiteral" ? g.hasMillimeterSuffix = !0 : g.type === "BinaryExpression" && (g.left.type === "NumberLiteral" && (g.left.hasMillimeterSuffix = !0), g.right.type === "NumberLiteral" && (g.right.hasMillimeterSuffix = !0));
+        });
+      });
+      let s = 0;
+      const a = (c) => {
+        if (r && c.type === "Section" && (s += r), c.type === "NumberLiteral")
+          c.hasMillimeterSuffix === !0 && (s += c.value);
+        else if (c.type === "BinaryExpression") {
+          const d = c;
+          d.left.type === "NumberLiteral" && d.right.type === "NumberLiteral" && (d.left.hasMillimeterSuffix === !0 && (s += d.left.value), d.right.hasMillimeterSuffix === !0 && (s += d.right.value));
+        }
+      };
+      if (n.sections.forEach(
+        (c) => G(c, a)
+      ), s > t)
+        throw new A("Total length exceeded");
+      let o = t - s + r, l = 0;
+      const u = (c) => {
+        if (c.type === "BinaryExpression") {
+          const d = c;
+          if (d.right.type === "NumberLiteral" && d.left.type === "SpecialVariable" && d.left.name === "n" && d.operator === "*") {
+            l = Math.floor(
+              o / (d.right.value + r)
+            );
+            const g = (l - 1) * r, I = l * d.right.value;
+            o += -g - I;
+          }
+        }
+      };
+      n.sections.forEach(
+        (c) => G(c, u)
+      );
+      let h = 0;
+      const m = (c) => {
+        c.type === "BinaryExpression" && (c.left.type === "NumberLiteral" && c.left.hasMillimeterSuffix === !1 && (h += c.left.value), c.right.type === "NumberLiteral" && c.right.hasMillimeterSuffix === !1 && (h += c.right.value)), c.type === "NumberLiteral" && c.hasMillimeterSuffix === !1 && (h += c.value);
+      };
+      n.sections.forEach((c) => {
+        G(c, m);
+      });
+      const p = o / h, E = [], y = (c) => {
+        let d = 0, g = 0;
+        if (c.type === "NumberLiteral")
+          c.hasMillimeterSuffix === !1 && (d += c.value * p), c.hasMillimeterSuffix === !0 && (g += c.value), E.push(Number((d + g).toFixed(2)));
+        else if (c.type === "BinaryExpression" && (c.left.type === "NumberLiteral" && c.right.type === "NumberLiteral" && (c.left.hasMillimeterSuffix === !1 && (d += c.left.value * p), c.left.hasMillimeterSuffix === !0 && (g += c.left.value), c.right.hasMillimeterSuffix === !1 && (d += c.right.value * p), c.right.hasMillimeterSuffix === !0 && (g += c.right.value), E.push(Number((d + g).toFixed(2)))), c.left.type === "SpecialVariable" && c.left.name === "n" && c.right.type === "NumberLiteral")) {
+          g += c.right.value;
+          for (let I = 0; I < l; I++)
+            c.right.hasMillimeterSuffix === !0 && E.push(Number(g.toFixed(2)));
+        }
+      };
+      return n.sections.forEach((c) => {
+        G(c, y);
+      }), E;
+    } catch {
+      return new A("Error calculating sections");
+    }
+  }
+}, gt = new lt(), Et = new ct(), St = new mt(), vt = (e, t, r, i) => {
+  try {
+    const n = gt.scan(e), s = Et.parse(n), a = St.evaluate(s, {}, i);
+    if (a && !(a instanceof A)) {
+      const l = new dt().calculateSections(a, t, r);
+      if (l && l instanceof A) throw new Error(l.message);
+      return l;
+    }
+    return a || new A("Unknown error during evaluation.");
+  } catch (n) {
+    return new A(n.message);
+  }
+};
+function Nt(e) {
+  const t = /^(\d+)\*\{(\d+)\}$/, r = e.match(t);
+  if (r) {
+    const i = parseInt(r[1], 10), n = r[2];
+    return i > 0 ? Array(i).fill(n).join(":") : "";
+  }
+  return e;
+}
+function Tt(e) {
+  const t = e.trim().match(/^(\d+(?:\.\d+)?)\s*\*\s*\{.+\}$/);
+  return t ? Number(t[1]) : e;
+}
+function Mt(e, t, r) {
+  let i = 0;
+  const { LINDIV1: n, DIVDIR: s, HORDEFTYPE: a, DIVELEM1: o } = e;
+  let l = "width";
+  if (n === "") return { divisionType: l, zone_dimensions: [], divided_length_list: [] };
+  if (s === "H")
+    if (a === "W")
+      i = t.width, l = "width";
+    else if (a === "D")
+      i = t.depth, l = "depth";
+    else if (a === "P")
+      if (o === 0 || o === 2)
+        i = t.width, l = "width";
+      else if (o === 1 || o === 3)
+        i = t.depth, l = "depth";
+      else
+        throw new Error("Unhandled case: DIVELEM1 = " + o);
+    else
+      throw new Error("Unhandled case: HORDEFTYPE = " + a);
+  else if (s === "V")
+    i = t.height, l = "height";
+  else if (s === "A")
+    i = t.width, l = "article";
+  else if (s === "I")
+    i = t.width, l = "independent";
+  else
+    throw new Error("Unhandled case: DIVDIR = " + s);
+  let u = [];
+  const h = Nt(n);
+  if (l === "independent") {
+    const p = Tt(n);
+    u = Array(p).fill(i);
+  } else l === "article" ? u = [i] : u = vt(h, i, r);
+  return Array.isArray(u) ? (a === "P" && (o === 2 || o === 3) && (u = [...u].reverse()), {
+    zone_dimensions: u.map((p) => {
+      if (l === "width")
+        return {
+          width: p,
+          height: t.height,
+          depth: t.depth
+        };
+      if (l === "depth")
+        return {
+          width: t.width,
+          height: t.height,
+          depth: p
+        };
+      if (l === "height")
+        return {
+          width: t.width,
+          height: p,
+          depth: t.depth
+        };
+      if (l === "article" || l === "independent")
+        return {
+          width: t.width,
+          height: t.height,
+          depth: t.depth
+        };
+      throw new Error("Unhandled case: DIVDIR = " + s);
+    }),
+    divisionType: l,
+    divided_length_list: u
+  }) : { divisionType: l, zone_dimensions: [], divided_length_list: [] };
+}
+function xt({
+  divisionType: e,
+  parentDimensions: t,
+  lengthList: r,
+  childTREEIDs: i,
+  dividerThk: n
+}) {
+  const s = -t.width / 2, a = -t.depth / 2, o = -t.height / 2;
+  return {
+    childPositions: r.reduce((u, h, m) => {
+      let p = 0, E = 0, y = 0, c;
+      return e === "width" ? (p = s + u.cumulativeX + h / 2, E = 0, y = 0, c = {
+        width: h,
+        height: t.height,
+        depth: t.depth
+      }, u.cumulativeX += h + n) : e === "depth" ? (p = 0, E = a + u.cumulativeY + h / 2, y = 0, c = {
+        width: t.width,
+        height: t.height,
+        depth: h
+      }, u.cumulativeY += h + n) : e === "independent" || e === "article" ? (p = 0, E = 0, y = 0, c = {
+        width: h,
+        height: t.height,
+        depth: t.depth
+      }) : (p = 0, E = 0, y = o + u.cumulativeZ + h / 2, c = {
+        width: t.width,
+        height: h,
+        depth: t.depth
+      }, u.cumulativeZ += h + n), u.positions.push({
+        x: p,
+        y: E,
+        z: y,
+        zone_dims: c,
+        TREEID: i[m]
+      }), u;
+    }, { cumulativeX: 0, cumulativeY: 0, cumulativeZ: 0, positions: [] }).positions,
+    dividerType: e
+  };
+}
+function yt(e) {
+  return {
+    front: te(Oe(e)),
+    left: te(Re(e)),
+    right: te(Pe(e)),
+    back: te(Ve(e))
+  };
+}
+function It(e, t, r) {
+  return {
+    front: e.front?.thk || 0,
+    right: e.right?.thk || 0,
+    back: e.back?.thk || 0,
+    left: e.left?.thk || 0,
+    top: t,
+    bottom: r
+  };
+}
+function _t(e) {
+  return {
+    front: e.front?.inset || 0,
+    right: e.right?.inset || 0,
+    back: e.back?.inset || 0,
+    left: e.left?.inset || 0
+  };
+}
+function bt(e, t) {
+  return {
+    dimensions: {
+      width: e.width - t.left - t.right,
+      height: e.height,
+      depth: e.depth - t.front - t.back
+    },
+    position: {
+      x: t.left / 2 - t.right / 2,
+      y: t.front / 2 - t.back / 2,
+      z: 0
+    }
+  };
+}
+function kt(e, t) {
+  return {
+    dimensions: {
+      width: e.dimensions.width - t.left - t.right,
+      height: e.dimensions.height - t.top - t.bottom,
+      depth: e.dimensions.depth - t.front - t.back
+    },
+    position: {
+      x: t.left / 2 - t.right / 2,
+      y: t.front / 2 - t.back / 2,
+      z: t.bottom / 2 - t.top / 2
+    }
+  };
+}
+function At(e, t, r, i) {
+  return t.divisionType ? xt({
+    divisionType: t.divisionType,
+    parentDimensions: e,
+    lengthList: t.divided_length_list,
+    childTREEIDs: i,
+    dividerThk: Number(r) || 0
+  }) : { childPositions: [], dividerType: "height" };
+}
+function Dt(e, t, r, i) {
+  if (!r)
+    return { childPositions: [], dividerType: "height" };
+  const n = Mt(r, e.dimensions, t);
+  return At(
+    e.dimensions,
+    n,
+    t,
+    i
+  );
+}
+function U({
+  length: e,
+  width: t,
+  thk: r,
+  material: i = "gray",
+  opacity: n = 0.2,
+  isSelected: s = !1,
+  isHovered: a = !1,
+  onClick: o,
+  onPointerEnter: l,
+  onPointerLeave: u
+}) {
+  const h = s ? "#ff6b00" : a ? "#0066ff" : i, m = s ? 0.8 : a ? 0.6 : n;
+  return /* @__PURE__ */ f("group", { children: /* @__PURE__ */ O(
+    "mesh",
+    {
+      onClick: o,
+      onPointerEnter: l,
+      onPointerLeave: u,
+      children: [
+        /* @__PURE__ */ f("boxGeometry", { args: [e / v, t / v, r / v] }),
+        /* @__PURE__ */ f(
+          "meshStandardMaterial",
+          {
+            color: h,
+            opacity: m,
+            transparent: !0
+          }
+        ),
+        /* @__PURE__ */ f(Ke, { color: s ? "#ff6b00" : a ? "#0066ff" : "black" })
+      ]
+    }
+  ) });
+}
+function wt(e, t, r = 0, i = 0) {
+  const n = e / 2, s = t / 2, a = n, o = s;
+  return `
+        ${a},${-o}
+        ${-a},${-o}
+        ${-a + r},${o}
+        ${a - i},${o}
+    `.trim().replace(/\s+/g, " ");
+}
+function Z({
+  dim_x: e,
+  dim_y: t,
+  fill: r = "lightgray",
+  text: i = "",
+  stroke_width: n = 2,
+  rotate: s = 0,
+  isSelected: a = !1,
+  isHovered: o = !1,
+  onClick: l,
+  onMouseEnter: u,
+  onMouseLeave: h,
+  startPanelThk: m = 0,
+  endPanelThk: p = 0
+}) {
+  const E = wt(
+    e,
+    t,
+    m,
+    p
+  ), y = a ? "#ff6b00" : o ? "#0066ff" : "black", c = a ? n * 2 : o ? n * 1.5 : n, d = a ? 0.8 : o ? 0.7 : 0.5;
+  return /* @__PURE__ */ O("g", { transform: `rotate(${s})`, children: [
+    /* @__PURE__ */ f(
+      "polygon",
+      {
+        points: E,
+        stroke: y,
+        strokeWidth: c,
+        fill: r,
+        strokeLinejoin: "bevel",
+        strokeMiterlimit: "1",
+        opacity: d,
+        onClick: l,
+        onMouseEnter: u,
+        onMouseLeave: h,
+        style: { cursor: l ? "pointer" : "default" }
+      }
+    ),
+    /* @__PURE__ */ f(
+      "text",
+      {
+        transform: "scale(1,-1)",
+        x: 0,
+        y: 0,
+        textAnchor: "middle",
+        dominantBaseline: "middle",
+        fontSize: 14,
+        children: i
+      }
+    )
+  ] });
+}
+function Ct({ TREEID: e, dimension: t, view: r, helper: i }) {
+  const n = i.front, s = V(F);
+  if (!n || !s) return;
+  const { selectedElem: a, setSelectedElem: o, hoveredElem: l, setHoveredElem: u } = s, { CPNAME: h } = n;
+  if (!h) return null;
+  const { elmTrimThk: m } = n, p = i.left?.thk, E = i.right?.thk, y = (n.trim.start === "S" ? p : 0) ?? 0, c = (n.trim.end === "S" ? E : 0) ?? 0, d = (n.trim.start === "M" ? p : 0) ?? 0, g = (n.trim.end === "M" ? E : 0) ?? 0, I = t.height - m.top - m.bottom + n.oversize.top + n.oversize.bottom, N = t.width - y - c + n.oversize.start + n.oversize.end, M = n.thk, D = -(n.oversize.start / 2 - n.oversize.end / 2 - y / 2 + c / 2), S = n.oversize.bottom / 2 - n.oversize.top / 2 + m.bottom / 2 - m.top / 2, T = -(t.depth / 2 - M / 2), _ = a === e, k = l === e, w = () => {
+    console.log("handleClick", e), o(_ ? null : e);
+  }, b = () => {
+    u(e);
+  }, L = () => {
+    u(null);
+  };
+  return r === x._3D ? /* @__PURE__ */ f("group", { position: [D / v, T / v, S / v], rotation: [Math.PI / 2, 0, Math.PI / 2], children: /* @__PURE__ */ f(
+    U,
+    {
+      length: I,
+      width: N,
+      thk: M,
+      treeId: e,
+      isSelected: _,
+      isHovered: k,
+      onClick: w,
+      onPointerEnter: b,
+      onPointerLeave: L
+    }
+  ) }) : /* @__PURE__ */ f("g", { transform: `translate(${D},${r === x._2D_TOP ? T : S}) rotate(0)`, children: /* @__PURE__ */ f(
+    Z,
+    {
+      dim_x: N,
+      dim_y: r === x._2D_TOP ? M : I,
+      text: "front " + I + " x " + N + " x " + M,
+      treeId: e,
+      isSelected: _,
+      isHovered: k,
+      onClick: w,
+      onMouseEnter: b,
+      onMouseLeave: L,
+      startPanelThk: r === x._2D_TOP ? d : 0,
+      endPanelThk: r === x._2D_TOP ? g : 0
+    }
+  ) });
+}
+const J = ({ view: e = x._3D, position: t = [0, 0, 0], rotation: r = [0, 0, 0], children: i }) => {
+  if (e === x._3D)
+    return /* @__PURE__ */ f(
+      "group",
+      {
+        position: [t[0] / v, t[1] / v, t[2] / v],
+        rotation: r,
+        children: i
+      }
+    );
+  const n = t[0], s = e === x._2D_TOP ? t[1] : t[2], a = r[2] * (180 / Math.PI);
+  return /* @__PURE__ */ f("g", { transform: `translate(${n},${s}) rotate(${a})`, children: i });
+};
+function Lt({ TREEID: e, dimension: t, view: r, helper: i }) {
+  const n = i.left, s = V(F);
+  if (!n || !s) return;
+  const { selectedElem: a, setSelectedElem: o, hoveredElem: l, setHoveredElem: u } = s, { CPNAME: h } = n;
+  if (!h) return null;
+  const { elmTrimThk: m } = n, p = i.back?.thk, E = i.front?.thk, y = (n.trim.start === "S" ? p : 0) ?? 0, c = (n.trim.end === "S" ? E : 0) ?? 0, d = (n.trim.start === "M" ? p : 0) ?? 0, g = (n.trim.end === "M" ? E : 0) ?? 0, I = t.height - m.top - m.bottom + n.oversize.top + n.oversize.bottom, N = t.depth - y - c + n.oversize.start + n.oversize.end, M = n.thk, D = -(t.width / 2 - M / 2), S = n.oversize.start / 2 - n.oversize.end / 2 - y / 2 + c / 2, T = n.oversize.bottom / 2 - n.oversize.top / 2 + m.bottom / 2 - m.top / 2, _ = a === e, k = l === e, w = () => {
+    o(_ ? null : e);
+  }, b = () => {
+    u(e);
+  }, L = () => {
+    u(null);
+  };
+  return r === x._3D ? /* @__PURE__ */ f("group", { position: [D / v, S / v, T / v], rotation: [0, Math.PI / 2, 0], children: /* @__PURE__ */ f(
+    U,
+    {
+      length: I,
+      width: N,
+      thk: M,
+      treeId: e,
+      isSelected: _,
+      isHovered: k,
+      onClick: w,
+      onPointerEnter: b,
+      onPointerLeave: L
+    }
+  ) }) : /* @__PURE__ */ f("g", { transform: `translate(${D},${r === x._2D_TOP ? S : T}) rotate(90)`, children: /* @__PURE__ */ f(
+    Z,
+    {
+      dim_x: r === x._2D_TOP ? N : I,
+      dim_y: M,
+      text: "left " + I + " x " + N + " x " + M,
+      treeId: e,
+      rotate: 180,
+      isSelected: _,
+      isHovered: k,
+      onClick: w,
+      onMouseEnter: b,
+      onMouseLeave: L,
+      startPanelThk: r === x._2D_TOP ? d : 0,
+      endPanelThk: r === x._2D_TOP ? g : 0
+    }
+  ) });
+}
+function Ot({ TREEID: e, dimension: t, view: r, helper: i }) {
+  const n = i.back, s = V(F);
+  if (!n || !s) return;
+  const { selectedElem: a, setSelectedElem: o, hoveredElem: l, setHoveredElem: u } = s, { CPNAME: h } = n;
+  if (!h) return null;
+  const { elmTrimThk: m } = n, p = i.right?.thk, E = i.left?.thk, y = (n.trim.start === "S" ? p : 0) ?? 0, c = (n.trim.end === "S" ? E : 0) ?? 0, d = (n.trim.start === "M" ? p : 0) ?? 0, g = (n.trim.end === "M" ? E : 0) ?? 0, I = t.height - m.top - m.bottom + n.oversize.top + n.oversize.bottom, N = t.width - y - c + n.oversize.start + n.oversize.end, M = n.thk, D = n.oversize.start / 2 - n.oversize.end / 2 - y / 2 + c / 2, S = t.depth / 2 - M / 2, T = n.oversize.bottom / 2 - n.oversize.top / 2 + m.bottom / 2 - m.top / 2, _ = a === e, k = l === e, w = () => {
+    o(_ ? null : e);
+  }, b = () => {
+    u(e);
+  }, L = () => {
+    u(null);
+  };
+  return r === x._3D ? /* @__PURE__ */ O("group", { position: [D / v, S / v, T / v], rotation: [Math.PI / 2, 0, Math.PI / 2], children: [
+    /* @__PURE__ */ f(
+      U,
+      {
+        length: I,
+        width: N,
+        thk: M,
+        treeId: e,
+        isSelected: _,
+        isHovered: k,
+        onClick: w,
+        onPointerEnter: b,
+        onPointerLeave: L
+      }
+    ),
+    /* @__PURE__ */ f(Ye, { position: [0, 0, 0], color: "blue", fontSize: 20, children: e })
+  ] }) : /* @__PURE__ */ f("g", { transform: `translate(${D},${r === x._2D_TOP ? S : T}) rotate(0)`, children: /* @__PURE__ */ f(
+    Z,
+    {
+      dim_x: N,
+      dim_y: r === x._2D_TOP ? M : I,
+      text: "Back " + I + " x " + N + " x " + M,
+      treeId: e,
+      isSelected: _,
+      rotate: 180,
+      isHovered: k,
+      onClick: w,
+      onMouseEnter: b,
+      onMouseLeave: L,
+      startPanelThk: r === x._2D_TOP ? d : 0,
+      endPanelThk: r === x._2D_TOP ? g : 0
+    }
+  ) });
+}
+function Pt({ TREEID: e, dimension: t, view: r, helper: i }) {
+  const n = i.right, s = V(F);
+  if (!n || !s) return;
+  const { selectedElem: a, setSelectedElem: o, hoveredElem: l, setHoveredElem: u } = s, { CPNAME: h } = n;
+  if (!h) return null;
+  const { elmTrimThk: m } = n, p = i.front?.thk, E = i.back?.thk, y = (n.trim.start === "S" ? p : 0) ?? 0, c = (n.trim.end === "S" ? E : 0) ?? 0, d = (n.trim.start === "M" ? p : 0) ?? 0, g = (n.trim.end === "M" ? E : 0) ?? 0, I = t.height - m.top - m.bottom + n.oversize.top + n.oversize.bottom, N = t.depth - y - c + n.oversize.start + n.oversize.end, M = n.thk, D = t.width / 2 - M / 2, S = -(n.oversize.start / 2 - n.oversize.end / 2 - y / 2 + c / 2), T = n.oversize.bottom / 2 + n.oversize.top / 2 + m.bottom / 2 - m.top / 2, _ = a === e, k = l === e, w = () => {
+    o(_ ? null : e);
+  }, b = () => {
+    u(e);
+  }, L = () => {
+    u(null);
+  };
+  return r === x._3D ? /* @__PURE__ */ f("group", { position: [D / v, S / v, T / v], rotation: [0, Math.PI / 2, 0], children: /* @__PURE__ */ f(
+    U,
+    {
+      length: I,
+      width: N,
+      thk: M,
+      treeId: e,
+      isSelected: _,
+      isHovered: k,
+      onClick: w,
+      onPointerEnter: b,
+      onPointerLeave: L
+    }
+  ) }) : /* @__PURE__ */ f("g", { transform: `translate(${D},${r === x._2D_TOP ? S : T}) rotate(90)`, children: /* @__PURE__ */ f(
+    Z,
+    {
+      dim_x: r === x._2D_TOP ? N : I,
+      dim_y: M,
+      text: "right " + I + " x " + N + " x " + M,
+      treeId: e,
+      isSelected: _,
+      isHovered: k,
+      onClick: w,
+      onMouseEnter: b,
+      onMouseLeave: L,
+      startPanelThk: r === x._2D_TOP ? d : 0,
+      endPanelThk: r === x._2D_TOP ? g : 0
+    }
+  ) });
+}
+function Vt({ TREEID: e, dimension: t, view: r, helper: i }) {
+  const n = ue(e), s = V(F);
+  if (!n || !s) return;
+  const { selectedElem: a, setSelectedElem: o, hoveredElem: l, setHoveredElem: u } = s, { topShelfCP: h } = n;
+  if (!h) return;
+  const m = (i.front?.trim.top !== "S" ? i.front?.thk : 0) ?? 0, p = (i.back?.trim.top !== "S" ? i.back?.thk : 0) ?? 0, E = (i.left?.trim.top !== "S" ? i.left?.thk : 0) ?? 0, y = (i.right?.trim.top !== "S" ? i.right?.thk : 0) ?? 0, c = t.width - E - y, d = t.depth - p - m, g = n.topShelfThk, I = E / 2 - y / 2, N = -(p / 2 - m / 2), M = t.height / 2 - g / 2, D = a === e, S = l === e, T = () => {
+    o(D ? null : e);
+  }, _ = () => {
+    u(e);
+  }, k = () => {
+    u(null);
+  };
+  return r === x._3D ? /* @__PURE__ */ f("group", { position: [I / v, N / v, M / v], rotation: [0, 0, 0], children: /* @__PURE__ */ f(
+    U,
+    {
+      length: c,
+      width: d,
+      thk: g,
+      opacity: 0.8,
+      treeId: e,
+      isSelected: D,
+      isHovered: S,
+      onClick: T,
+      onPointerEnter: _,
+      onPointerLeave: k
+    }
+  ) }) : /* @__PURE__ */ f("g", { transform: `translate(${I},${r === x._2D_TOP ? N : M})`, children: /* @__PURE__ */ f(
+    Z,
+    {
+      dim_x: c,
+      dim_y: r === x._2D_TOP ? d : g,
+      text: "Top " + e + "   --  " + c + " x " + d + " x " + g,
+      treeId: e,
+      isSelected: D,
+      isHovered: S,
+      onClick: T,
+      onMouseEnter: _,
+      onMouseLeave: k
+    }
+  ) });
+}
+function Rt({ TREEID: e, dimension: t, view: r, helper: i }) {
+  const n = ue(e), s = V(F);
+  if (!n || !s) return;
+  const { selectedElem: a, setSelectedElem: o, hoveredElem: l, setHoveredElem: u } = s, { bottomShelfCP: h } = n;
+  if (!h) return;
+  const m = (i.front?.trim.bottom !== "S" ? i.front?.thk : 0) ?? 0, p = (i.back?.trim.bottom !== "S" ? i.back?.thk : 0) ?? 0, E = (i.left?.trim.bottom !== "S" ? i.left?.thk : 0) ?? 0, y = (i.right?.trim.bottom !== "S" ? i.right?.thk : 0) ?? 0, c = t.width - E - y, d = t.depth - p - m, g = n.bottomShelfThk, I = E / 2 - y / 2, N = -(p / 2 - m / 2), M = -(t.height / 2 - g / 2), D = a === e, S = l === e, T = () => {
+    o(D ? null : e);
+  }, _ = () => {
+    u(e);
+  }, k = () => {
+    u(null);
+  };
+  return r === x._3D ? /* @__PURE__ */ f("group", { position: [I / v, N / v, M / v], rotation: [0, 0, 0], children: /* @__PURE__ */ f(
+    U,
+    {
+      length: c,
+      width: d,
+      thk: g,
+      opacity: 0.8,
+      treeId: e,
+      isSelected: D,
+      isHovered: S,
+      onClick: T,
+      onPointerEnter: _,
+      onPointerLeave: k
+    }
+  ) }) : /* @__PURE__ */ f("g", { transform: `translate(${I},${r === x._2D_TOP ? N : M})`, children: /* @__PURE__ */ f(
+    Z,
+    {
+      dim_x: c,
+      dim_y: r === x._2D_TOP ? d : g,
+      text: "Bot " + c + " x " + d + " x " + g,
+      treeId: e,
+      isSelected: D,
+      isHovered: S,
+      onClick: T,
+      onMouseEnter: _,
+      onMouseLeave: k
+    }
+  ) });
+}
+function $t() {
+  const e = V(De);
+  if (!e)
+    throw new Error(
+      "useDescriptorManager must be used within a DescriptorProvider"
+    );
+  return e;
+}
+function Ft(e, t, r, i = {}) {
+  const { throwOnError: n = !1 } = i;
+  if (!e.hasDescriptor(t))
+    throw new Error(`Descriptor ${t} not found`);
+  return $(() => {
+    try {
+      return {
+        result: e.evaluate(t, r),
+        error: null,
+        success: !0
+      };
+    } catch (s) {
+      const a = s instanceof Error ? s.message : "Unknown error";
+      if (n)
+        throw s;
+      return {
+        result: null,
+        error: a,
+        success: !1
+      };
+    }
+  }, [e, t, r, n]);
+}
+function sr(e, t, r) {
+  return $(() => {
+    try {
+      const i = e.findAllMatches(t, r);
+      return {
+        matches: i,
+        error: null,
+        count: i.length
+      };
+    } catch (i) {
+      const n = i instanceof Error ? i.message : "Unknown error";
+      return {
+        matches: [],
+        error: n,
+        count: 0
+      };
+    }
+  }, [e, t, r]);
+}
+const R = {
+  LINEAR_DIVISION: "linear-division",
+  ARTICLE: "article"
+}, B = {
+  STRING: "string",
+  // Direct value
+  DESCRIPTOR: "descriptor"
+  // Value from descriptor evaluation
+}, ye = {
+  // Check if divider is linear division (any source)
+  linearDivision: (e) => e.type === R.LINEAR_DIVISION,
+  // Check if divider is article (any source)
+  article: (e) => e.type === R.ARTICLE
+}, zt = {
+  // Check if linear division uses direct string formula
+  string: (e) => e.type === R.LINEAR_DIVISION && e.valueSource === B.STRING,
+  // Check if linear division uses descriptor
+  descriptor: (e) => e.type === R.LINEAR_DIVISION && e.valueSource === B.DESCRIPTOR
+}, oe = {
+  // Check if article uses direct string name
+  string: (e) => e.type === R.ARTICLE && e.valueSource === B.STRING,
+  // Check if article uses descriptor
+  descriptor: (e) => e.type === R.ARTICLE && e.valueSource === B.DESCRIPTOR
+}, q = {
+  // Create a linear division with string formula
+  linearDivisionString(e, t, r, i, n, s, a, o) {
+    return {
+      TREEID: e,
+      type: R.LINEAR_DIVISION,
+      valueSource: B.STRING,
+      DIVDIR: t,
+      DIVTYPE: r,
+      HORDEFTYPE: i,
+      LINDIV1: n,
+      DIVELEM1: s,
+      DIVIDER: "",
+      formula: a,
+      thickness: o
+    };
+  },
+  // Create a linear division with descriptor reference
+  // Create linear division with descriptor reference
+  linearDivisionDescriptor(e, t, r, i, n, s, a, o) {
+    return {
+      TREEID: e,
+      type: R.LINEAR_DIVISION,
+      valueSource: B.DESCRIPTOR,
+      DIVDIR: t,
+      DIVTYPE: r,
+      HORDEFTYPE: i,
+      LINDIV1: n,
+      DIVELEM1: s,
+      DIVIDER: "",
+      descriptorName: a,
+      thickness: o
+    };
+  },
+  // Create an article divider
+  // Create article with direct name string
+  articleString(e, t, r, i, n, s, a) {
+    return {
+      TREEID: e,
+      type: R.ARTICLE,
+      valueSource: B.STRING,
+      DIVDIR: t,
+      DIVTYPE: r,
+      HORDEFTYPE: i,
+      LINDIV1: n,
+      DIVELEM1: s,
+      DIVIDER: a,
+      articleName: a
+    };
+  },
+  // Create article with descriptor reference
+  articleDescriptor(e, t, r, i, n, s, a) {
+    return {
+      TREEID: e,
+      type: R.ARTICLE,
+      valueSource: B.DESCRIPTOR,
+      DIVDIR: t,
+      DIVTYPE: r,
+      HORDEFTYPE: i,
+      LINDIV1: n,
+      DIVELEM1: s,
+      DIVIDER: a,
+      descriptorName: a
+    };
+  },
+  // Smart factory: Automatically determines type and source
+  fromZoneData(e, t) {
+    const r = (i) => i.trim().startsWith("#");
+    if (e.DIVDIR === "A") {
+      if (r(e.DIVIDER)) {
+        const i = e.DIVIDER.replace("#", "").trim();
+        return q.articleDescriptor(
+          e.TREEID,
+          e.DIVDIR,
+          e.DIVTYPE,
+          e.HORDEFTYPE,
+          e.LINDIV1,
+          e.DIVELEM1,
+          i
+        );
+      }
+      return q.articleString(
+        e.TREEID,
+        e.DIVDIR,
+        e.DIVTYPE,
+        e.HORDEFTYPE,
+        e.LINDIV1,
+        e.DIVELEM1,
+        e.DIVIDER
+      );
+    }
+    if (r(e.LINDIV1)) {
+      const i = e.LINDIV1.replace("#", "").trim();
+      return q.linearDivisionDescriptor(
+        e.TREEID,
+        e.DIVDIR,
+        e.DIVTYPE,
+        e.HORDEFTYPE,
+        e.LINDIV1,
+        e.DIVELEM1,
+        i,
+        t
+      );
+    }
+    return q.linearDivisionString(
+      e.TREEID,
+      e.DIVDIR,
+      e.DIVTYPE,
+      e.HORDEFTYPE,
+      e.LINDIV1,
+      e.DIVELEM1,
+      e.LINDIV1,
+      t
+    );
+  }
+};
+function Gt(e) {
+  if (!e) return "width";
+  const t = {
+    0: "width",
+    1: "depth",
+    2: "width",
+    3: "depth"
+  };
+  return e.DIVDIR === "V" ? "height" : e.HORDEFTYPE === "W" ? "width" : e.HORDEFTYPE === "D" ? "depth" : e.HORDEFTYPE === "P" ? t[e.DIVELEM1] ?? "width" : "width";
+}
+function Bt(e, t) {
+  return t ? t[e] : 0;
+}
+function Ht(e, t) {
+  const r = e;
+  if (Kt(e))
+    return {
+      value: e.startsWith("#") ? e.slice(1) : e,
+      original: r,
+      isReference: !0
+    };
+  if (/^\d+:\d+$/.test(e))
+    return {
+      value: e,
+      original: r,
+      isReference: !1
+    };
+  const { format: i, expression: n, suffix: s } = Zt(e);
+  let a = n;
+  a = a.replace(/^\((.+)\)$/, "$1");
+  const l = we(a, {
+    variableTree: t,
+    allowFunctions: !0,
+    // Enable round(), floor(), etc.
+    dataType: "FL",
+    silent: !0
+  }).value ?? n;
+  let u;
+  switch (i) {
+    case "expr:ratio":
+      u = `${l}${s}`;
+      break;
+    case "ratio:expr":
+      u = `${s}${l}`;
+      break;
+    case "expr*{ratio}":
+      u = `${l}${s}`;
+      break;
+    case "simple":
+      u = String(l);
+      break;
+  }
+  return {
+    value: u,
+    original: r,
+    isReference: !1
+  };
+}
+function Ut(e, t) {
+  return Ht(e, t).value;
+}
+function Zt(e) {
+  const r = e.trim().replace(/^\((.+)\)$/, "$1"), i = r.match(/^(\d+|n):(.+?)(mm|cm)?$/);
+  if (i) {
+    const [, a, o, l] = i;
+    return {
+      format: "ratio:expr",
+      expression: o.trim(),
+      suffix: l ? `${a}:${l}` : `${a}:`
+    };
+  }
+  const n = r.match(/^(.+?)(mm|cm)?:(\d+)$/);
+  if (n) {
+    const [, a, o, l] = n;
+    return {
+      format: "expr:ratio",
+      expression: a.trim(),
+      suffix: o ? `${o}:${l}` : `:${l}`
+    };
+  }
+  const s = r.match(/^(.+?)(\*)?{(\d+)}$/);
+  if (s) {
+    const [, a, o, l] = s;
+    return {
+      format: "expr*{ratio}",
+      expression: a.trim(),
+      suffix: o ? `*{${l}}` : `{${l}}`
+    };
+  }
+  return {
+    format: "simple",
+    expression: r,
+    suffix: ""
+  };
+}
+function Kt(e) {
+  return e.startsWith("#") ? !0 : e.includes("(") || /[+\-*/]/.test(e) ? !1 : /^[A-Za-z0-9_-]+$/.test(e) ? !0 : !/^\d+:\d+$/.test(e);
+}
+function Yt({ divider: e, inputData: t }) {
+  const r = $t(), { resolveString: i } = j(), { result: n, error: s } = Ft(r, e.descriptorName, t, { throwOnError: !1 }), a = $(() => e ? oe.string(e) ? e.articleName : oe.descriptor(e) && n?.lindiv ? n.lindiv : "" : "", [e, n]);
+  return {
+    updatedDivider: $(() => {
+      if (e)
+        return n?.lindiv != null ? {
+          ...e,
+          LINDIV1: Ut(i(n.lindiv)),
+          // Replace the descriptor reference with actual formula
+          articleName: a
+        } : { ...e, LINDIV1: i(e.LINDIV1) };
+    }, [e, n, a, i])
+  };
+}
+const Wt = {
+  width: {
+    rotation: [0, Math.PI / 2, 0],
+    get3D: (e, t) => ({ length: e.height, width: e.depth, thk: t }),
+    get2DTop: (e, t) => ({ dim_x: e.depth, dim_y: t, rotate: 90 }),
+    get2DFront: (e, t) => ({ dim_x: e.height, dim_y: t, rotate: 90 })
+  },
+  height: {
+    rotation: [0, 0, 0],
+    get3D: (e, t) => ({ length: e.width, width: e.depth, thk: t }),
+    get2DTop: (e) => ({ dim_x: e.width, dim_y: e.depth }),
+    get2DFront: (e, t) => ({ dim_x: e.width, dim_y: t })
+  },
+  depth: {
+    rotation: [Math.PI / 2, 0, Math.PI / 2],
+    get3D: (e, t) => ({ length: e.height, width: e.width, thk: t }),
+    get2DTop: (e, t) => ({ dim_x: e.width, dim_y: t }),
+    get2DFront: (e) => ({ dim_x: e.width, dim_y: e.height })
+  },
+  article: {
+    rotation: [0, 0, 0],
+    get3D: (e, t) => ({ length: e.width, width: e.depth, thk: t }),
+    get2DTop: (e) => ({ dim_x: e.width, dim_y: e.depth }),
+    get2DFront: (e, t) => ({ dim_x: e.width, dim_y: t })
+  },
+  independent: {
+    rotation: [0, 0, 0],
+    get3D: (e, t) => ({ length: e.width, width: e.depth, thk: t }),
+    get2DTop: (e) => ({ dim_x: e.width, dim_y: e.depth }),
+    get2DFront: (e, t) => ({ dim_x: e.width, dim_y: t })
+  }
+}, Xt = (e, t, r) => ({
+  x: e === "width" ? r.width / 2 + t / 2 : 0,
+  y: e === "depth" ? r.depth / 2 + t / 2 : 0,
+  z: e === "height" ? r.height / 2 + t / 2 : 0
+});
+function jt({ divider: e, view: t, childrenPositon: r, dividerThk: i }) {
+  const n = V(F), s = r.dividerType, a = r.childPositions, o = Wt[s];
+  if (!n) return null;
+  const { selectedElem: l, setSelectedElem: u, hoveredElem: h, setHoveredElem: m } = n;
+  return a.map((p, E) => {
+    const c = !(E === a.length - 1) && i !== 0, d = Xt(s, i, p.zone_dims), g = o.get3D(p.zone_dims, i), I = t === x._2D_TOP ? o.get2DTop(p.zone_dims, i) : o.get2DFront(p.zone_dims, i), N = `${e.TREEID} divider`, M = l === N, D = h === N;
+    return /* @__PURE__ */ f(Ze, { children: /* @__PURE__ */ O(J, { view: t, position: [p.x / v, p.y / v, p.z / v], children: [
+      /* @__PURE__ */ f(J, { view: t, position: [d.x / v, d.y / v, d.z / v], rotation: o.rotation, children: c && /* @__PURE__ */ O(pe, { children: [
+        /* @__PURE__ */ f("group", { children: /* @__PURE__ */ O("mesh", { children: [
+          /* @__PURE__ */ f(
+            "boxGeometry",
+            {
+              args: [g.length, g.width, g.thk]
+            }
+          ),
+          /* @__PURE__ */ f("meshStandardMaterial", { color: "blue", transparent: !0, opacity: 0.3 })
+        ] }) }),
+        t === x._3D ? /* @__PURE__ */ f(
+          U,
+          {
+            ...g,
+            opacity: 1,
+            treeId: N,
+            isSelected: M,
+            isHovered: D,
+            onClick: () => u(M ? null : N),
+            onPointerEnter: () => m(N),
+            onPointerLeave: () => m(null)
+          }
+        ) : /* @__PURE__ */ f(
+          Z,
+          {
+            ...I,
+            text: N,
+            treeId: N,
+            isSelected: M,
+            isHovered: D,
+            onClick: () => u(M ? null : N),
+            onMouseEnter: () => m(N),
+            onMouseLeave: () => m(null)
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ f(ze, { TREEID: p.TREEID, dimension: p.zone_dims, view: t })
+    ] }) }, E);
+  });
+}
+function qt({ view: e, remainingZone: t, articleName: r }) {
+  return /* @__PURE__ */ f(
+    be,
+    {
+      articleName: r,
+      dimensionOverrides: {
+        width: t.dimensions.width,
+        height: t.dimensions.height,
+        depth: t.dimensions.depth
+      },
+      children: /* @__PURE__ */ f(
+        J,
+        {
+          view: e,
+          position: [
+            t.position.x / v,
+            t.position.y / v,
+            t.position.z / v
+          ],
+          children: /* @__PURE__ */ f(Ge, { view: e })
+        }
+      )
+    }
+  );
+}
+function Jt({ childrenPositon: e, dividerThk: t, divider: r, view: i, remainingZone: n }) {
+  if (ye.linearDivision(r))
+    return e ? /* @__PURE__ */ f(jt, { view: i, childrenPositon: e, dividerThk: t, divider: r, remainingZone: n }) : null;
+  if (ye.article(r)) {
+    const s = oe.string(r) ? r.articleName : r.LINDIV1;
+    return !n || s === "" ? null : /* @__PURE__ */ f(qt, { view: i, articleName: s, remainingZone: n });
+  }
+  return null;
+}
+function Fe() {
+  const { getArticleData: e } = Q(), { articleName: t, dimensionOverrides: r } = ee(), { resolveString: i } = j(), { anglPrims: n } = e(t);
+  if (n.length === 0) throw new Error(`No prims found for article: ${t}`);
+  const s = n[0], a = (l, u) => {
+    const h = typeof l == "string" && l !== "" ? se(i(l)) : u;
+    return parseFloat(String(h)) || 0;
+  }, o = {
+    width: r?.width ?? a(s.DIMCALCFX, s.SIZEX),
+    height: r?.height ?? a(s.DIMCALCFZ, s.SIZEZ),
+    depth: r?.depth ?? a(s.DIMCALCFY, s.SIZEY)
+  };
+  return {
+    current_prim: s,
+    prim_dims: o
+  };
+}
+function ze({ TREEID: e, dimension: t, view: r = x._3D }) {
+  console.log(`===================================== Zone Start ${e} =====================================`);
+  const i = ue(e), n = i?.zoneInfo(), s = i?.dividerThk || 0, a = Fe(), o = yt(e), l = It(o, i?.topShelfThk || 0, i?.bottomShelfThk || 0), u = _t(o), h = bt(t, u), m = kt(h, l), p = $(() => {
+    if (i)
+      return q.fromZoneData(i.currentZone, s);
+  }, [i, s]), E = n ? Object.fromEntries(n) : {}, y = Gt(p), c = Bt(y, m.dimensions);
+  E["AD article width"] = a?.prim_dims.width.toString(), E["AD article height"] = a?.prim_dims.height.toString(), E["AD article depth"] = a?.prim_dims.depth.toString(), E[0] = "0", E.X = c.toString();
+  const d = p ? zt.descriptor(p) : !1, g = p ? oe.descriptor(p) : !1, N = d || g ? Yt({ divider: p, inputData: E }).updatedDivider : p, M = Dt(m, s, N, i?.children.map((D) => D.TREEID) || []);
+  return (e === "0" || e === "0") && (console.log("start dimensions ", t), console.log("border inset", u), console.log("border thk", l), console.log("zone dimensions ", h.dimensions), console.log("position => ", h.position), console.log("remaining dimensions ", m.dimensions), console.log("remaining position => ", m.position)), /* @__PURE__ */ f(pe, { children: /* @__PURE__ */ O(J, { view: r, position: [h.position.x / v, h.position.y / v, h.position.z / v], children: [
+    o.front?.CPNAME && /* @__PURE__ */ f(Ct, { view: r, TREEID: Oe(e), dimension: h.dimensions, helper: o }),
+    o.left?.CPNAME && /* @__PURE__ */ f(Lt, { view: r, TREEID: Re(e), dimension: h.dimensions, helper: o }),
+    o.back?.CPNAME && /* @__PURE__ */ f(Ot, { view: r, TREEID: Ve(e), dimension: h.dimensions, helper: o }),
+    o.right?.CPNAME && /* @__PURE__ */ f(Pt, { view: r, TREEID: Pe(e), dimension: h.dimensions, helper: o }),
+    i?.topShelfCP && /* @__PURE__ */ f(Vt, { view: r, TREEID: e, dimension: h.dimensions, helper: o }),
+    i?.bottomShelfCP && /* @__PURE__ */ f(Rt, { view: r, TREEID: e, dimension: h.dimensions, helper: o }),
+    /* @__PURE__ */ f(J, { view: r, position: [m.position.x / v, m.position.y / v, m.position.z / v], children: N && /* @__PURE__ */ f(Jt, { remainingZone: m, divider: N, view: r, childrenPositon: M, dividerThk: s }) })
+  ] }) });
+}
+const Qt = "scale(1,-1)";
+function Ge({ view: e = x._3D }) {
+  console.log("=========================================================  Designer   ===============================================================================================");
+  const r = Fe().prim_dims, i = /* @__PURE__ */ f(ze, { TREEID: "0", view: e, dimension: r }), n = e === x._3D ? i : /* @__PURE__ */ f("g", { transform: Qt, children: i });
+  return console.log(n), n;
+}
+function ar({ view: e, data: t, articleName: r }) {
+  const i = t.descriptors, n = t.variables, s = t.anglprim.map((a) => a.NAME);
+  return /* @__PURE__ */ f(pe, { children: /* @__PURE__ */ f(We, { names: s, data: t, children: /* @__PURE__ */ f(be, { articleName: r, children: /* @__PURE__ */ f(je, { imosVariables: n, children: /* @__PURE__ */ f(it, { descriptorData: i, children: /* @__PURE__ */ f(Ge, { view: e }) }) }) }) }) });
+}
+function or() {
+  const { tree: e, getValue: t, setValue: r } = j(), i = (o, l) => {
+    const u = Number(l);
+    r(o, isNaN(u) ? l : u);
+  }, s = (() => {
+    const o = {
+      [P.Numeric]: { type: P.Numeric, label: "Dimensions (Numeric)", variables: [] },
+      [P.Surface]: { type: P.Surface, label: "Surfaces", variables: [] },
+      [P.Material]: { type: P.Material, label: "Materials", variables: [] },
+      [P.Text]: { type: P.Text, label: "Text", variables: [] }
+    };
+    return Array.from(e.entries()).forEach(([l, u]) => {
+      const h = t(l), m = u.WERT.startsWith("$");
+      o[u.TYP]?.variables.push({
+        name: l,
+        value: h ?? "undefined",
+        reference: m ? u.WERT : void 0,
+        rawType: u.TYP
+      });
+    }), Object.values(o).filter((l) => l.variables.length > 0);
+  })(), a = (o) => {
+    const l = o.rawType === P.Numeric, u = typeof o.value == "number" ? o.value : Number(o.value);
+    return l && !isNaN(u) ? /* @__PURE__ */ O("div", { className: "var-controller__slider-container", children: [
+      /* @__PURE__ */ f(
+        "input",
+        {
+          type: "range",
+          min: 0,
+          max: 2e4,
+          value: u,
+          onChange: (h) => i(o.name, h.target.value),
+          className: "var-controller__slider"
+        }
+      ),
+      /* @__PURE__ */ f(
+        "input",
+        {
+          type: "number",
+          value: u,
+          onChange: (h) => i(o.name, h.target.value),
+          onBlur: (h) => i(o.name, h.target.value),
+          className: "var-controller__number-input",
+          min: 0,
+          max: 2e4
+        }
+      )
+    ] }) : /* @__PURE__ */ f(
+      "input",
+      {
+        type: "text",
+        value: o.value,
+        onChange: (h) => i(o.name, h.target.value),
+        onBlur: (h) => i(o.name, h.target.value),
+        className: "var-controller__text-input"
+      }
+    );
+  };
+  return /* @__PURE__ */ O("div", { className: "var-controller", children: [
+    /* @__PURE__ */ f("h2", { children: "Variable Controller" }),
+    /* @__PURE__ */ O("p", { className: "var-controller__header", children: [
+      "Total variables: ",
+      e.size
+    ] }),
+    s.map((o) => /* @__PURE__ */ O("section", { className: "var-controller__section", children: [
+      /* @__PURE__ */ O("h3", { className: "var-controller__section-title", children: [
+        o.label,
+        " (",
+        o.variables.length,
+        ")"
+      ] }),
+      /* @__PURE__ */ O("table", { className: "var-controller__table", children: [
+        /* @__PURE__ */ f("thead", { children: /* @__PURE__ */ O("tr", { children: [
+          /* @__PURE__ */ f("th", { style: { width: "25%" }, children: "Variable Name" }),
+          /* @__PURE__ */ f("th", { style: { width: "35%" }, children: "Current Value" }),
+          /* @__PURE__ */ f("th", { style: { width: "25%" }, children: "Reference" }),
+          /* @__PURE__ */ f("th", { className: "center", style: { width: "15%" }, children: "Type" })
+        ] }) }),
+        /* @__PURE__ */ f("tbody", { children: o.variables.map((l) => /* @__PURE__ */ O("tr", { children: [
+          /* @__PURE__ */ f("td", { className: "var-controller__var-name", children: l.name }),
+          /* @__PURE__ */ f("td", { children: a(l) }),
+          /* @__PURE__ */ f("td", { className: "var-controller__reference", children: l.reference || "-" }),
+          /* @__PURE__ */ f("td", { style: { textAlign: "center" }, children: /* @__PURE__ */ f("span", { className: "var-controller__type-badge", children: o.type }) })
+        ] }, l.name)) })
+      ] })
+    ] }, o.type)),
+    /* @__PURE__ */ O("section", { className: "var-controller__stats", children: [
+      /* @__PURE__ */ f("h4", { children: "Quick Stats" }),
+      /* @__PURE__ */ f("ul", { children: s.map((o) => /* @__PURE__ */ O("li", { children: [
+        o.label,
+        ": ",
+        o.variables.length,
+        " variables"
+      ] }, o.type)) })
+    ] })
+  ] });
+}
+const lr = "1.0.0";
+export {
+  _e as ArticleContext,
+  ar as ArticleDesigner,
+  be as ArticleProvider,
+  F as DataContext,
+  We as DataProvider,
+  De as DescriptorContext,
+  it as DescriptorProvider,
+  Ge as Designer,
+  lr as VERSION,
+  x as VIEW,
+  or as VarController,
+  ke as VariableContext,
+  je as VariableProvider,
+  nr as VariableResolver,
+  ze as Zone,
+  Yt as ZoneDescriptor,
+  ee as useArticle,
+  Q as useData,
+  Ft as useDescriptorEvaluation,
+  $t as useDescriptorManager,
+  sr as useDescriptorMatches,
+  j as useVariables
+};