@gui-chat-plugin/present3d 0.0.1

package/dist/toThreeJS-EXFMlO7B.js

@@ -0,0 +1,2171 @@
+var P = Object.defineProperty;
+var x = (n, e, s) => e in n ? P(n, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : n[e] = s;
+var d = (n, e, s) => x(n, typeof e != "symbol" ? e + "" : e, s);
+import * as l from "three";
+import { Evaluator as M, Brush as B, INTERSECTION as g, SUBTRACTION as C, ADDITION as w } from "three-bvh-csg";
+const U = "present3D", k = {
+  type: "function",
+  name: U,
+  description: "Display interactive 3D visualizations using the full ShapeScript language with expressions, variables, control flow, and functions.",
+  parameters: {
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        description: "Title for the 3D visualization"
+      },
+      script: {
+        type: "string",
+        description: `ShapeScript code defining the 3D scene. Full language features supported.
+
+## SYNTAX OVERVIEW:
+
+### Expressions & Operators:
+- Arithmetic: +, -, *, /, % with proper precedence
+- Comparison: =, <>, <, <=, >, >=
+- Boolean: and, or, not
+- Parentheses for grouping: (2 + 3) * 4
+
+### Variables:
+define radius 2
+define red (1 0 0)
+sphere { size radius color red }
+
+### Control Flow:
+
+For loops with variables:
+for i in 1 to 5 {
+    cube { position (i * 2) 0 0 size 1 }
+}
+
+For loops with step:
+for i in 0 to 10 step 2 {
+    sphere { position 0 i 0 }
+}
+
+If/else conditionals:
+define showSphere 1
+if showSphere {
+    sphere { size 2 }
+} else {
+    cube { size 2 }
+}
+
+Switch statements:
+define shape 2
+switch shape {
+case 1
+    cube
+case 2
+    sphere
+else
+    cone
+}
+
+### Built-in Functions:
+
+Math: round, floor, ceil, abs, sign, sqrt, pow, min, max
+Trig: sin, cos, tan, asin, acos, atan, atan2 (uses radians)
+Vector: dot, cross, length, normalize, sum
+
+IMPORTANT: Function calls require NO space between name and parenthesis:
+- sin(x) ✓ function call
+- sin (x) ✗ NOT a function call (identifier + parenthesized expression)
+
+Examples:
+for i in 1 to 8 {
+    define angle (i * 0.785)  // 45 degrees in radians
+    cube { position (cos(angle) * 3) 0 (sin(angle) * 3) }
+}
+
+### Primitives & Properties:
+
+Shapes: cube, sphere, cylinder, cone, torus
+Properties: position X Y Z, rotation X Y Z, size X Y Z
+Materials: color R G B (0-1), opacity (0-1)
+
+### CSG Operations:
+union, difference, intersection, xor, stencil
+
+Example:
+difference {
+    sphere { size 2 color (1 0.5 0) }
+    cube { size 1.5 }
+}
+
+### Comments:
+// Single-line comment
+/* Multi-line
+   comment */
+
+## COMPLETE EXAMPLES:
+
+Linear arrangement with expressions:
+define spacing 1.5
+for i in 1 to 4 {
+    cylinder { position ((i - 2.5) * spacing) 0 0 size 0.4 1 }
+}
+
+Circular pattern:
+define count 12
+for i in 1 to count {
+    define angle ((i / count) * 6.283)  // 2 * PI
+    cube {
+        position (cos(angle) * 3) 0 (sin(angle) * 3)
+        color (i / count) 0.5 (1 - i / count)
+        size 0.5
+    }
+}
+
+Conditional geometry:
+define makeHollow 1
+if makeHollow {
+    difference {
+        sphere { size 2 color (1 0 0) }
+        sphere { size 1.7 }
+    }
+} else {
+    sphere { size 2 color (1 0 0) }
+}
+
+Mathematical visualization:
+for x in -5 to 5 {
+    for z in -5 to 5 {
+        define height (sin(x * 0.5) * cos(z * 0.5) * 2)
+        cube {
+            position (x * 0.3) height (z * 0.3)
+            size 0.25 (abs(height) + 0.1) 0.25
+            color (0.5 + height * 0.25) 0.3 (0.5 - height * 0.25)
+        }
+    }
+}`
+      }
+    },
+    required: ["title", "script"]
+  }
+}, O = async (n, e) => {
+  const { script: s, title: r } = e;
+  if (!s || s.trim() === "")
+    throw new Error("ShapeScript code is required but was not provided");
+  return {
+    message: `Created 3D visualization: ${r}`,
+    title: r,
+    data: { script: s },
+    instructions: "Acknowledge that the 3D visualization has been created and is displayed to the user. They can interact with it by rotating, zooming, and panning the camera."
+  };
+}, Y = {
+  toolDefinition: k,
+  execute: O,
+  generatingMessage: "Creating 3D visualization...",
+  waitingMessage: "Tell the user that the 3D visualization was created and will be presented shortly.",
+  isEnabled: () => !0
+}, H = O, Q = [
+  {
+    name: "Basic Shapes",
+    args: {
+      title: "Basic 3D Shapes",
+      script: `// Basic shapes demonstration
+cube { position -2 0 0 size 1 color (1 0.3 0.3) }
+sphere { position 0 0 0 size 1 color (0.3 1 0.3) }
+cylinder { position 2 0 0 size 0.5 1 color (0.3 0.3 1) }`
+    }
+  },
+  {
+    name: "Circular Pattern",
+    args: {
+      title: "Circular Pattern",
+      script: `// Create a circular pattern of cubes
+define count 12
+for i in 1 to count {
+    define angle ((i / count) * 6.283)
+    cube {
+        position (cos(angle) * 3) 0 (sin(angle) * 3)
+        color (i / count) 0.5 (1 - i / count)
+        size 0.5
+    }
+}`
+    }
+  },
+  {
+    name: "CSG Difference",
+    args: {
+      title: "Hollow Sphere",
+      script: `// Create a hollow sphere using CSG difference
+difference {
+    sphere { size 2 color (1 0.5 0) }
+    sphere { size 1.7 color (1 1 1) }
+    cube { position 0 0 2 size 2 }
+}`
+    }
+  }
+];
+var t = /* @__PURE__ */ ((n) => (n.CUBE = "CUBE", n.SPHERE = "SPHERE", n.CYLINDER = "CYLINDER", n.CONE = "CONE", n.TORUS = "TORUS", n.CIRCLE = "CIRCLE", n.SQUARE = "SQUARE", n.POLYGON = "POLYGON", n.EXTRUDE = "EXTRUDE", n.LOFT = "LOFT", n.LATHE = "LATHE", n.FILL = "FILL", n.HULL = "HULL", n.GROUP = "GROUP", n.PATH = "PATH", n.POINT = "POINT", n.CURVE = "CURVE", n.DETAIL = "DETAIL", n.BACKGROUND = "BACKGROUND", n.TEXTURE = "TEXTURE", n.UNION = "UNION", n.DIFFERENCE = "DIFFERENCE", n.INTERSECTION = "INTERSECTION", n.XOR = "XOR", n.STENCIL = "STENCIL", n.FOR = "FOR", n.IN = "IN", n.TO = "TO", n.STEP = "STEP", n.IF = "IF", n.ELSE = "ELSE", n.SWITCH = "SWITCH", n.CASE = "CASE", n.DEFINE = "DEFINE", n.OPTION = "OPTION", n.POSITION = "POSITION", n.ROTATION = "ROTATION", n.ORIENTATION = "ORIENTATION", n.SIZE = "SIZE", n.COLOR = "COLOR", n.OPACITY = "OPACITY", n.ROTATE = "ROTATE", n.TRANSLATE = "TRANSLATE", n.SCALE = "SCALE", n.NUMBER = "NUMBER", n.IDENTIFIER = "IDENTIFIER", n.STRING = "STRING", n.PLUS = "PLUS", n.MINUS = "MINUS", n.STAR = "STAR", n.DIVIDE = "DIVIDE", n.PERCENT = "PERCENT", n.LPAREN = "LPAREN", n.RPAREN = "RPAREN", n.LBRACKET = "LBRACKET", n.RBRACKET = "RBRACKET", n.DOT = "DOT", n.EQUALS = "EQUALS", n.NOT_EQUALS = "NOT_EQUALS", n.LESS = "LESS", n.LESS_EQUAL = "LESS_EQUAL", n.GREATER = "GREATER", n.GREATER_EQUAL = "GREATER_EQUAL", n.AND = "AND", n.OR = "OR", n.NOT = "NOT", n.LBRACE = "LBRACE", n.RBRACE = "RBRACE", n.COMMA = "COMMA", n.SLASH = "SLASH", n.NEWLINE = "NEWLINE", n.EOF = "EOF", n.COMMENT = "COMMENT", n))(t || {});
+class R extends Error {
+  constructor(e, s, r) {
+    super(
+      s !== void 0 && r !== void 0 ? `Parse error at line ${s}, column ${r}: ${e}` : `Parse error: ${e}`
+    ), this.line = s, this.column = r, this.name = "ParseError";
+  }
+}
+class D {
+  constructor(e) {
+    d(this, "input");
+    d(this, "pos", 0);
+    d(this, "line", 1);
+    d(this, "column", 1);
+    this.input = e;
+  }
+  peek(e = 0) {
+    return this.input[this.pos + e] || "";
+  }
+  advance() {
+    const e = this.input[this.pos++];
+    return e === `
+` ? (this.line++, this.column = 1) : this.column++, e;
+  }
+  skipWhitespace() {
+    for (; this.pos < this.input.length; ) {
+      const e = this.peek();
+      if (e === " " || e === "	" || e === "\r")
+        this.advance();
+      else if (e === "/" && this.peek(1) === "/")
+        for (; this.peek() && this.peek() !== `
+`; )
+          this.advance();
+      else if (e === "/" && this.peek(1) === "*") {
+        this.advance(), this.advance();
+        let s = 1;
+        for (; this.pos < this.input.length && s > 0; )
+          this.peek() === "/" && this.peek(1) === "*" ? (s++, this.advance(), this.advance()) : this.peek() === "*" && this.peek(1) === "/" ? (s--, this.advance(), this.advance()) : this.advance();
+      } else
+        break;
+    }
+  }
+  readNumber() {
+    const e = this.line, s = this.column;
+    let r = "";
+    for (this.peek() === "-" && (r += this.advance()); this.pos < this.input.length; ) {
+      const i = this.peek();
+      if (i >= "0" && i <= "9" || i === ".")
+        r += this.advance();
+      else
+        break;
+    }
+    return {
+      type: t.NUMBER,
+      value: parseFloat(r),
+      line: e,
+      column: s
+    };
+  }
+  readIdentifier() {
+    const e = this.line, s = this.column;
+    let r = "";
+    for (; this.pos < this.input.length; ) {
+      const o = this.peek();
+      if (o >= "a" && o <= "z" || o >= "A" && o <= "Z" || o >= "0" && o <= "9" || o === "_")
+        r += this.advance();
+      else
+        break;
+    }
+    return {
+      type: {
+        cube: t.CUBE,
+        sphere: t.SPHERE,
+        cylinder: t.CYLINDER,
+        cone: t.CONE,
+        torus: t.TORUS,
+        circle: t.CIRCLE,
+        square: t.SQUARE,
+        polygon: t.POLYGON,
+        extrude: t.EXTRUDE,
+        loft: t.LOFT,
+        lathe: t.LATHE,
+        fill: t.FILL,
+        hull: t.HULL,
+        group: t.GROUP,
+        path: t.PATH,
+        point: t.POINT,
+        curve: t.CURVE,
+        detail: t.DETAIL,
+        background: t.BACKGROUND,
+        texture: t.TEXTURE,
+        union: t.UNION,
+        difference: t.DIFFERENCE,
+        intersection: t.INTERSECTION,
+        xor: t.XOR,
+        stencil: t.STENCIL,
+        for: t.FOR,
+        in: t.IN,
+        to: t.TO,
+        step: t.STEP,
+        if: t.IF,
+        else: t.ELSE,
+        switch: t.SWITCH,
+        case: t.CASE,
+        define: t.DEFINE,
+        option: t.OPTION,
+        position: t.POSITION,
+        rotation: t.ROTATION,
+        orientation: t.ORIENTATION,
+        size: t.SIZE,
+        color: t.COLOR,
+        opacity: t.OPACITY,
+        rotate: t.ROTATE,
+        translate: t.TRANSLATE,
+        scale: t.SCALE,
+        and: t.AND,
+        or: t.OR,
+        not: t.NOT
+      }[r.toLowerCase()] || t.IDENTIFIER,
+      value: r,
+      line: e,
+      column: s
+    };
+  }
+  readString() {
+    const e = this.line, s = this.column;
+    let r = "";
+    for (this.advance(); this.pos < this.input.length; ) {
+      const i = this.peek();
+      if (i === '"') {
+        this.advance();
+        break;
+      } else if (i === "\\") {
+        this.advance();
+        const a = this.peek();
+        a === '"' || a === "\\" ? r += this.advance() : a === "n" ? (r += `
+`, this.advance()) : a === "t" ? (r += "	", this.advance()) : (r += a, this.advance());
+      } else
+        r += this.advance();
+    }
+    return {
+      type: t.STRING,
+      value: r,
+      line: e,
+      column: s
+    };
+  }
+  tokenize() {
+    const e = [];
+    for (; this.pos < this.input.length; ) {
+      const s = this.pos;
+      this.skipWhitespace();
+      const r = this.pos > s;
+      if (this.pos >= this.input.length) break;
+      const i = this.peek(), a = this.line, o = this.column;
+      if (i >= "0" && i <= "9" || i === "-" && this.peek(1) >= "0" && this.peek(1) <= "9" && (e.length === 0 || e[e.length - 1].type === t.LPAREN || e[e.length - 1].type === t.COMMA || e[e.length - 1].type === t.LBRACE || e[e.length - 1].type === t.LBRACKET || this.isOperator(e[e.length - 1].type))) {
+        const c = this.readNumber();
+        c.precedingWhitespace = r, e.push(c);
+      } else if (i >= "a" && i <= "z" || i >= "A" && i <= "Z") {
+        const c = this.readIdentifier();
+        c.precedingWhitespace = r, e.push(c);
+      } else if (i === '"') {
+        const c = this.readString();
+        c.precedingWhitespace = r, e.push(c);
+      } else if (i === "<" && this.peek(1) === ">")
+        this.advance(), this.advance(), e.push({
+          type: t.NOT_EQUALS,
+          value: "<>",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === "<" && this.peek(1) === "=")
+        this.advance(), this.advance(), e.push({
+          type: t.LESS_EQUAL,
+          value: "<=",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === ">" && this.peek(1) === "=")
+        this.advance(), this.advance(), e.push({
+          type: t.GREATER_EQUAL,
+          value: ">=",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === "+")
+        this.advance(), e.push({
+          type: t.PLUS,
+          value: "+",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === "-")
+        this.advance(), e.push({
+          type: t.MINUS,
+          value: "-",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === "*")
+        this.advance(), e.push({
+          type: t.STAR,
+          value: "*",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === "/")
+        this.advance(), e.push({
+          type: t.DIVIDE,
+          value: "/",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === "%")
+        this.advance(), e.push({
+          type: t.PERCENT,
+          value: "%",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === "(")
+        this.advance(), e.push({
+          type: t.LPAREN,
+          value: "(",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === ")")
+        this.advance(), e.push({
+          type: t.RPAREN,
+          value: ")",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === "[")
+        this.advance(), e.push({
+          type: t.LBRACKET,
+          value: "[",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === "]")
+        this.advance(), e.push({
+          type: t.RBRACKET,
+          value: "]",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === "{")
+        this.advance(), e.push({
+          type: t.LBRACE,
+          value: "{",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === "}")
+        this.advance(), e.push({
+          type: t.RBRACE,
+          value: "}",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === ",")
+        this.advance(), e.push({
+          type: t.COMMA,
+          value: ",",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === ".")
+        this.advance(), e.push({
+          type: t.DOT,
+          value: ".",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === "=")
+        this.advance(), e.push({
+          type: t.EQUALS,
+          value: "=",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === "<")
+        this.advance(), e.push({
+          type: t.LESS,
+          value: "<",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === ">")
+        this.advance(), e.push({
+          type: t.GREATER,
+          value: ">",
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else if (i === `
+`)
+        this.advance(), e.push({
+          type: t.NEWLINE,
+          value: `
+`,
+          line: a,
+          column: o,
+          precedingWhitespace: r
+        });
+      else
+        throw new R(`Unexpected character: '${i}'`, a, o);
+    }
+    return e.push({
+      type: t.EOF,
+      value: "",
+      line: this.line,
+      column: this.column,
+      precedingWhitespace: !1
+    }), e;
+  }
+  isOperator(e) {
+    return e === t.PLUS || e === t.MINUS || e === t.STAR || e === t.DIVIDE || e === t.PERCENT || e === t.EQUALS || e === t.NOT_EQUALS || e === t.LESS || e === t.LESS_EQUAL || e === t.GREATER || e === t.GREATER_EQUAL || e === t.AND || e === t.OR;
+  }
+}
+class F {
+  constructor(e) {
+    d(this, "tokens");
+    d(this, "pos", 0);
+    this.tokens = e;
+  }
+  current() {
+    return this.tokens[this.pos];
+  }
+  peek(e = 1) {
+    return this.tokens[this.pos + e] || this.tokens[this.tokens.length - 1];
+  }
+  advance() {
+    return this.tokens[this.pos++];
+  }
+  expect(e) {
+    const s = this.current();
+    if (s.type !== e)
+      throw new R(
+        `Expected ${e} but got ${s.type}`,
+        s.line,
+        s.column
+      );
+    return this.advance();
+  }
+  // Expect an identifier, but allow keywords to be used as identifiers
+  expectIdentifier() {
+    const e = this.current();
+    if (e.type === t.IDENTIFIER)
+      return this.advance();
+    if (typeof e.value == "string")
+      return this.advance();
+    throw new R(
+      `Expected identifier but got ${e.type}`,
+      e.line,
+      e.column
+    );
+  }
+  skipNewlines() {
+    for (; this.current().type === t.NEWLINE; )
+      this.advance();
+  }
+  // Expression parsing with precedence climbing
+  parseExpression(e = 0) {
+    let s = this.parsePrimary();
+    for (; ; ) {
+      const r = this.current(), i = this.getPrecedence(r.type);
+      if (i < e) break;
+      const a = this.tokenTypeToOperator(r.type);
+      if (!a) break;
+      this.advance();
+      const o = this.parseExpression(i + 1);
+      s = {
+        type: "binary",
+        operator: a,
+        left: s,
+        right: o
+      };
+    }
+    return s;
+  }
+  parsePrimary() {
+    const e = this.current();
+    if (e.type === t.MINUS || e.type === t.NOT)
+      return this.advance(), {
+        type: "unary",
+        operator: e.type === t.MINUS ? "-" : "not",
+        operand: this.parsePrimary()
+      };
+    if (e.type === t.LPAREN) {
+      this.advance();
+      const s = [];
+      if (s.push(this.parseExpression()), this.current().type === t.COMMA)
+        for (; this.current().type === t.COMMA && (this.advance(), this.current().type !== t.RPAREN); )
+          s.push(this.parseExpression());
+      else {
+        const r = this.current();
+        if ((r.type === t.NUMBER || r.type === t.IDENTIFIER || r.type === t.MINUS || r.type === t.LPAREN) && r.type !== t.RPAREN)
+          for (; ; ) {
+            const a = this.current();
+            if (a.type === t.NUMBER || a.type === t.IDENTIFIER || a.type === t.MINUS || a.type === t.LPAREN)
+              s.push(this.parseExpression());
+            else
+              break;
+          }
+      }
+      return this.expect(t.RPAREN), s.length === 1 ? s[0] : { type: "tuple", elements: s };
+    }
+    if (e.type === t.NUMBER)
+      return this.advance(), {
+        type: "number",
+        value: e.value
+      };
+    if (e.type === t.STRING)
+      return this.advance(), {
+        type: "identifier",
+        // Treat strings as special identifiers for now
+        name: e.value
+      };
+    if (e.type === t.IDENTIFIER) {
+      const s = e.value;
+      if (this.advance(), this.current().type === t.LPAREN && !this.current().precedingWhitespace) {
+        this.advance();
+        const r = [];
+        if (this.current().type !== t.RPAREN)
+          for (r.push(this.parseExpression()); this.current().type === t.COMMA && (this.advance(), this.current().type !== t.RPAREN); )
+            r.push(this.parseExpression());
+        return this.expect(t.RPAREN), {
+          type: "call",
+          name: s,
+          args: r
+        };
+      }
+      return {
+        type: "identifier",
+        name: s
+      };
+    }
+    if (typeof e.value == "string") {
+      const s = e.value;
+      return this.advance(), {
+        type: "identifier",
+        name: s
+      };
+    }
+    throw new R(
+      `Unexpected token in expression: ${e.type}`,
+      e.line,
+      e.column
+    );
+  }
+  getPrecedence(e) {
+    switch (e) {
+      case t.OR:
+        return 1;
+      case t.AND:
+        return 2;
+      case t.EQUALS:
+      case t.NOT_EQUALS:
+        return 3;
+      case t.LESS:
+      case t.LESS_EQUAL:
+      case t.GREATER:
+      case t.GREATER_EQUAL:
+        return 4;
+      case t.PLUS:
+      case t.MINUS:
+        return 5;
+      case t.STAR:
+      case t.DIVIDE:
+      case t.PERCENT:
+        return 6;
+      default:
+        return 0;
+    }
+  }
+  tokenTypeToOperator(e) {
+    switch (e) {
+      case t.PLUS:
+        return "+";
+      case t.MINUS:
+        return "-";
+      case t.STAR:
+        return "*";
+      case t.DIVIDE:
+        return "/";
+      case t.PERCENT:
+        return "%";
+      case t.EQUALS:
+        return "=";
+      case t.NOT_EQUALS:
+        return "<>";
+      case t.LESS:
+        return "<";
+      case t.LESS_EQUAL:
+        return "<=";
+      case t.GREATER:
+        return ">";
+      case t.GREATER_EQUAL:
+        return ">=";
+      case t.AND:
+        return "and";
+      case t.OR:
+        return "or";
+      default:
+        return null;
+    }
+  }
+  // Parse vector or expression
+  // Handles both: "x y z" (space-separated) and "(x, y, z)" (tuple)
+  parseVectorOrExpression() {
+    const e = this.parseExpression(), s = this.current(), r = s.type === t.IDENTIFIER && this.peek().type === t.LBRACE;
+    if ((s.type === t.NUMBER || s.type === t.IDENTIFIER || s.type === t.MINUS || s.type === t.LPAREN) && !r && s.type !== t.COMMA) {
+      const a = [e];
+      for (; ; ) {
+        const o = this.current(), c = o.type === t.IDENTIFIER && this.peek().type === t.LBRACE;
+        if ((o.type === t.NUMBER || o.type === t.IDENTIFIER || o.type === t.MINUS || o.type === t.LPAREN) && !c)
+          a.push(this.parseExpression());
+        else
+          break;
+      }
+      if (a.length > 1)
+        return { type: "tuple", elements: a };
+    }
+    return e.type === "tuple", e;
+  }
+  parseProperties() {
+    const e = {};
+    for (; this.current().type !== t.RBRACE && this.current().type !== t.EOF; ) {
+      switch (this.skipNewlines(), this.current().type) {
+        case t.POSITION:
+          this.advance(), e.position = this.parseVectorOrExpression();
+          break;
+        case t.ROTATION:
+          this.advance(), e.rotation = this.parseVectorOrExpression();
+          break;
+        case t.ORIENTATION:
+          this.advance(), e.orientation = this.parseVectorOrExpression();
+          break;
+        case t.SIZE:
+          this.advance(), e.size = this.parseVectorOrExpression();
+          break;
+        case t.COLOR:
+          this.advance(), e.color = this.parseVectorOrExpression();
+          break;
+        case t.OPACITY:
+          this.advance(), e.opacity = this.parseExpression();
+          break;
+        case t.RBRACE:
+          return e;
+        default:
+          return e;
+      }
+      this.skipNewlines();
+    }
+    return e;
+  }
+  parseBlockContents() {
+    this.skipNewlines();
+    const e = [];
+    for (; this.current().type !== t.RBRACE && this.current().type !== t.EOF; ) {
+      const s = this.parseNode();
+      s && e.push(s), this.skipNewlines();
+    }
+    return e;
+  }
+  parseBlock() {
+    this.expect(t.LBRACE);
+    const e = this.parseBlockContents();
+    return this.expect(t.RBRACE), e;
+  }
+  parseShape(e) {
+    this.advance();
+    let s = {};
+    return this.current().type === t.LBRACE && (this.expect(t.LBRACE), s = this.parseProperties(), this.expect(t.RBRACE)), {
+      type: "shape",
+      primitive: e,
+      properties: s
+    };
+  }
+  parseCSG(e) {
+    this.advance();
+    const s = this.parseBlock();
+    return {
+      type: "csg",
+      operation: e,
+      children: s
+    };
+  }
+  parseForLoop() {
+    this.advance();
+    let e = "i";
+    if (this.current().type === t.IDENTIFIER && (e = this.current().value, this.advance()), this.current().type === t.IN) {
+      this.advance();
+      const a = this.parseExpression();
+      if (this.current().type === t.TO) {
+        this.advance();
+        const o = this.parseExpression();
+        let c;
+        this.current().type === t.STEP && (this.advance(), c = this.parseExpression());
+        const u = this.parseBlock();
+        return {
+          type: "for",
+          variable: e,
+          from: a,
+          to: o,
+          step: c,
+          body: u
+        };
+      } else {
+        const o = this.parseBlock();
+        return {
+          type: "for",
+          variable: e,
+          from: { type: "number", value: 0 },
+          to: { type: "number", value: 0 },
+          iterableValues: a,
+          body: o
+        };
+      }
+    }
+    let s = { type: "number", value: 1 };
+    this.current().type === t.NUMBER && (s = this.parseExpression()), this.expect(t.TO);
+    const r = this.parseExpression(), i = this.parseBlock();
+    return {
+      type: "for",
+      variable: e,
+      from: s,
+      to: r,
+      body: i
+    };
+  }
+  parseIf() {
+    this.advance();
+    const e = this.parseExpression(), s = this.parseBlock();
+    let r;
+    return this.skipNewlines(), this.current().type === t.ELSE && (this.advance(), this.skipNewlines(), this.current().type === t.IF ? r = [this.parseIf()] : r = this.parseBlock()), {
+      type: "if",
+      condition: e,
+      thenBody: s,
+      elseBody: r
+    };
+  }
+  parseSwitch() {
+    this.advance();
+    const e = this.parseExpression();
+    this.expect(t.LBRACE), this.skipNewlines();
+    const s = [];
+    let r;
+    for (; this.current().type !== t.RBRACE && this.current().type !== t.EOF; ) {
+      if (this.current().type === t.CASE) {
+        this.advance();
+        const i = [];
+        for (i.push(this.parseExpression()); this.current().type !== t.NEWLINE && this.current().type !== t.LBRACE && this.current().type !== t.EOF; )
+          i.push(this.parseExpression());
+        this.skipNewlines();
+        let a;
+        if (this.current().type === t.LBRACE)
+          a = this.parseBlock();
+        else
+          for (a = []; this.current().type !== t.CASE && this.current().type !== t.ELSE && this.current().type !== t.RBRACE && this.current().type !== t.EOF; ) {
+            const o = this.parseNode();
+            o && a.push(o), this.skipNewlines();
+          }
+        s.push({ values: i, body: a });
+      } else if (this.current().type === t.ELSE)
+        if (this.advance(), this.skipNewlines(), this.current().type === t.LBRACE)
+          r = this.parseBlock();
+        else
+          for (r = []; this.current().type !== t.CASE && this.current().type !== t.RBRACE && this.current().type !== t.EOF; ) {
+            const i = this.parseNode();
+            i && r.push(i), this.skipNewlines();
+          }
+      else
+        this.skipNewlines(), this.current().type !== t.CASE && this.current().type !== t.ELSE && this.current().type !== t.RBRACE && this.advance();
+      this.skipNewlines();
+    }
+    return this.expect(t.RBRACE), {
+      type: "switch",
+      value: e,
+      cases: s,
+      defaultCase: r
+    };
+  }
+  parseDefine() {
+    this.advance();
+    const s = this.expectIdentifier().value;
+    if (this.current().type === t.LBRACE) {
+      this.advance();
+      const i = [], a = [];
+      for (; this.current().type !== t.RBRACE && this.current().type !== t.EOF; )
+        if (this.current().type === t.OPTION) {
+          this.advance();
+          const o = this.expectIdentifier().value, c = this.parseVectorOrExpression();
+          i.push({
+            type: "option",
+            name: o,
+            defaultValue: c
+          });
+        } else {
+          const o = this.parseNode();
+          o && a.push(o);
+        }
+      return this.expect(t.RBRACE), {
+        type: "define",
+        name: s,
+        options: i,
+        body: a
+      };
+    }
+    const r = this.parseVectorOrExpression();
+    return {
+      type: "define",
+      name: s,
+      value: r
+    };
+  }
+  parseDetail() {
+    return this.advance(), {
+      type: "detail",
+      value: this.parseExpression()
+    };
+  }
+  parseBackground() {
+    return this.advance(), {
+      type: "background",
+      value: this.parseExpression()
+    };
+  }
+  parseTexture() {
+    return this.advance(), {
+      type: "texture",
+      value: this.parseExpression()
+    };
+  }
+  parseGroup() {
+    this.advance(), this.expect(t.LBRACE);
+    const e = this.parseBlockContents();
+    return this.expect(t.RBRACE), {
+      type: "group",
+      children: e
+    };
+  }
+  parseBuilder(e) {
+    this.advance();
+    let s = !1;
+    this.current().type === t.PATH && (s = !0, this.advance()), this.expect(t.LBRACE), this.skipNewlines();
+    const r = {};
+    let i;
+    const a = [];
+    if (s) {
+      const o = [];
+      for (; this.current().type !== t.RBRACE && this.current().type !== t.EOF; ) {
+        const c = this.current();
+        if (c.type === t.POINT) {
+          this.advance();
+          const u = this.parsePathValue();
+          let p = { type: "number", value: 0 };
+          (this.current().type === t.NUMBER || this.current().type === t.MINUS || this.current().type === t.IDENTIFIER || this.current().type === t.LPAREN) && (p = this.parsePathValue()), o.push({ type: "point", x: u, y: p });
+        } else if (c.type === t.CURVE) {
+          this.advance();
+          const u = this.parsePathValue(), p = this.parsePathValue();
+          let E, f;
+          (this.current().type === t.NUMBER || this.current().type === t.MINUS || this.current().type === t.IDENTIFIER || this.current().type === t.LPAREN) && (E = this.parsePathValue(), (this.current().type === t.NUMBER || this.current().type === t.MINUS || this.current().type === t.IDENTIFIER || this.current().type === t.LPAREN) && (f = this.parsePathValue())), o.push({ type: "curve", x: u, y: p, controlX: E, controlY: f });
+        } else
+          break;
+        this.skipNewlines();
+      }
+      i = {
+        type: "path",
+        commands: o
+      };
+    } else
+      for (; this.current().type !== t.RBRACE && this.current().type !== t.EOF; ) {
+        const o = this.current();
+        if (o.type === t.PATH && e === "extrude") {
+          i = this.parsePath(), this.skipNewlines();
+          continue;
+        }
+        if (o.type === t.SIZE || o.type === t.COLOR || o.type === t.OPACITY || o.type === t.POSITION || o.type === t.ROTATION || o.type === t.ORIENTATION) {
+          const u = this.parseProperties();
+          Object.assign(r, u), this.skipNewlines();
+          continue;
+        }
+        const c = this.parseNode();
+        c && a.push(c), this.skipNewlines();
+      }
+    return this.expect(t.RBRACE), e === "extrude" ? {
+      type: "extrude",
+      path: i,
+      properties: r,
+      children: a.length > 0 ? a : void 0
+    } : (i && a.unshift(i), {
+      type: e,
+      properties: r,
+      children: a
+    });
+  }
+  parsePathValue() {
+    let e = this.parsePathPrimary();
+    for (; ; ) {
+      const s = this.current();
+      if (s.type === t.STAR || s.type === t.DIVIDE || s.type === t.PERCENT || s.type === t.PLUS || s.type === t.MINUS && !this.isStartOfNewValue()) {
+        const r = this.tokenTypeToOperator(s.type);
+        if (!r) break;
+        this.advance();
+        const i = this.parsePathPrimary();
+        e = {
+          type: "binary",
+          operator: r,
+          left: e,
+          right: i
+        };
+      } else
+        break;
+    }
+    return e;
+  }
+  isStartOfNewValue() {
+    const e = this.current();
+    return e.type !== t.MINUS ? !1 : !!e.precedingWhitespace && (this.peek().type === t.NUMBER || this.peek().type === t.IDENTIFIER || this.peek().type === t.LPAREN);
+  }
+  parsePathPrimary() {
+    const e = this.current();
+    if (e.type === t.LPAREN) {
+      this.advance();
+      const s = this.parseExpression();
+      return this.expect(t.RPAREN), s;
+    }
+    if (e.type === t.MINUS)
+      return this.advance(), {
+        type: "unary",
+        operator: "-",
+        operand: this.parsePathPrimary()
+      };
+    if (e.type === t.NUMBER) {
+      const s = e.value;
+      return this.advance(), {
+        type: "number",
+        value: s
+      };
+    }
+    if (e.type === t.IDENTIFIER) {
+      const s = e.value;
+      if (this.advance(), this.current().type === t.LPAREN && !this.current().precedingWhitespace) {
+        this.advance();
+        const r = [];
+        if (this.current().type !== t.RPAREN)
+          for (r.push(this.parseExpression()); this.current().type === t.COMMA; )
+            this.advance(), r.push(this.parseExpression());
+        return this.expect(t.RPAREN), {
+          type: "call",
+          name: s,
+          args: r
+        };
+      }
+      return {
+        type: "identifier",
+        name: s
+      };
+    }
+    throw new R(
+      `Expected path value, got ${e.type}`,
+      e.line,
+      e.column
+    );
+  }
+  parsePath() {
+    this.advance(), this.expect(t.LBRACE), this.skipNewlines();
+    const e = [];
+    for (; this.current().type !== t.RBRACE && this.current().type !== t.EOF; ) {
+      const s = this.current();
+      switch (s.type) {
+        case t.DEFINE: {
+          this.parseDefine();
+          break;
+        }
+        case t.DETAIL: {
+          this.advance();
+          const r = this.parseExpression();
+          e.push({ type: "detail", value: r });
+          break;
+        }
+        case t.POINT: {
+          this.advance();
+          const r = this.parsePathValue();
+          let i = { type: "number", value: 0 };
+          (this.current().type === t.NUMBER || this.current().type === t.MINUS || this.current().type === t.IDENTIFIER || this.current().type === t.LPAREN) && (i = this.parsePathValue()), e.push({ type: "point", x: r, y: i });
+          break;
+        }
+        case t.CURVE: {
+          this.advance();
+          const r = this.parsePathValue(), i = this.parsePathValue();
+          let a, o;
+          (this.current().type === t.NUMBER || this.current().type === t.MINUS || this.current().type === t.IDENTIFIER || this.current().type === t.LPAREN) && (a = this.parsePathValue(), (this.current().type === t.NUMBER || this.current().type === t.MINUS || this.current().type === t.IDENTIFIER || this.current().type === t.LPAREN) && (o = this.parsePathValue())), e.push({ type: "curve", x: r, y: i, controlX: a, controlY: o });
+          break;
+        }
+        case t.ROTATE: {
+          this.advance();
+          const r = this.parseExpression();
+          e.push({ type: "rotate", angle: r });
+          break;
+        }
+        case t.TRANSLATE: {
+          this.advance();
+          const r = this.parsePathValue(), i = this.parsePathValue();
+          e.push({ type: "translate", x: r, y: i });
+          break;
+        }
+        case t.FOR: {
+          this.advance();
+          let r = "_i";
+          this.current().type === t.IDENTIFIER && this.peek(1).type === t.IN && (r = this.current().value, this.advance(), this.expect(t.IN));
+          const i = this.parseExpression();
+          this.expect(t.TO);
+          const a = this.parseExpression(), o = this.current().type === t.STEP ? (this.advance(), this.parseExpression()) : { type: "number", value: 1 };
+          this.expect(t.LBRACE), this.skipNewlines();
+          const c = [];
+          for (; this.current().type !== t.RBRACE && this.current().type !== t.EOF; ) {
+            const u = this.current();
+            switch (u.type) {
+              case t.POINT: {
+                this.advance();
+                const p = this.parsePathValue();
+                let E = { type: "number", value: 0 };
+                (this.current().type === t.NUMBER || this.current().type === t.MINUS || this.current().type === t.IDENTIFIER || this.current().type === t.LPAREN) && (E = this.parsePathValue()), c.push({ type: "point", x: p, y: E });
+                break;
+              }
+              case t.CURVE: {
+                this.advance();
+                const p = this.parsePathValue(), E = this.parsePathValue();
+                let f, y;
+                (this.current().type === t.NUMBER || this.current().type === t.MINUS || this.current().type === t.IDENTIFIER || this.current().type === t.LPAREN) && (f = this.parsePathValue(), (this.current().type === t.NUMBER || this.current().type === t.MINUS || this.current().type === t.IDENTIFIER || this.current().type === t.LPAREN) && (y = this.parsePathValue())), c.push({ type: "curve", x: p, y: E, controlX: f, controlY: y });
+                break;
+              }
+              case t.ROTATE: {
+                this.advance();
+                const p = this.parseExpression();
+                c.push({ type: "rotate", angle: p });
+                break;
+              }
+              case t.TRANSLATE: {
+                this.advance();
+                const p = this.parsePathValue(), E = this.parsePathValue();
+                c.push({ type: "translate", x: p, y: E });
+                break;
+              }
+              default:
+                throw new R(
+                  `Unexpected token in path for loop: ${u.type}`,
+                  u.line,
+                  u.column
+                );
+            }
+            this.skipNewlines();
+          }
+          this.expect(t.RBRACE), e.push({
+            type: "for",
+            variable: r,
+            from: i,
+            to: a,
+            step: o,
+            commands: c
+          });
+          break;
+        }
+        default:
+          throw new R(
+            `Unexpected token in path: ${s.type}`,
+            s.line,
+            s.column
+          );
+      }
+      this.skipNewlines();
+    }
+    return this.expect(t.RBRACE), {
+      type: "path",
+      commands: e
+    };
+  }
+  parseNode() {
+    this.skipNewlines();
+    const e = this.current(), s = {
+      [t.CUBE]: "cube",
+      [t.SPHERE]: "sphere",
+      [t.CYLINDER]: "cylinder",
+      [t.CONE]: "cone",
+      [t.TORUS]: "torus",
+      [t.CIRCLE]: "circle",
+      [t.SQUARE]: "square",
+      [t.POLYGON]: "polygon"
+    }, r = {
+      [t.UNION]: "union",
+      [t.DIFFERENCE]: "difference",
+      [t.INTERSECTION]: "intersection",
+      [t.XOR]: "xor",
+      [t.STENCIL]: "stencil"
+    }, i = {
+      [t.EXTRUDE]: "extrude",
+      [t.LOFT]: "loft",
+      [t.LATHE]: "lathe",
+      [t.FILL]: "fill",
+      [t.HULL]: "hull"
+    }, a = {
+      [t.COLOR]: "color",
+      [t.ROTATE]: "rotate",
+      [t.TRANSLATE]: "translate",
+      [t.SCALE]: "scale",
+      [t.POSITION]: "translate",
+      // position is an alias for translate
+      [t.ORIENTATION]: "orientation"
+      // orientation sets absolute rotation (not relative like rotate)
+    };
+    if (e.type in s)
+      return this.parseShape(s[e.type]);
+    if (e.type in r)
+      return this.parseCSG(r[e.type]);
+    if (e.type in i)
+      return this.parseBuilder(i[e.type]);
+    if (e.type in a)
+      return this.advance(), {
+        type: a[e.type],
+        value: this.parseVectorOrExpression()
+      };
+    switch (e.type) {
+      case t.FOR:
+        return this.parseForLoop();
+      case t.IF:
+        return this.parseIf();
+      case t.SWITCH:
+        return this.parseSwitch();
+      case t.DEFINE:
+        return this.parseDefine();
+      case t.GROUP:
+        return this.parseGroup();
+      case t.DETAIL:
+        return this.parseDetail();
+      case t.BACKGROUND:
+        return this.parseBackground();
+      case t.TEXTURE:
+        return this.parseTexture();
+      case t.PATH:
+        return this.parsePath();
+      case t.RBRACE:
+      case t.EOF:
+        return null;
+      case t.IDENTIFIER: {
+        const o = e.value;
+        this.advance();
+        const c = {};
+        if (this.current().type === t.LBRACE) {
+          for (this.expect(t.LBRACE), this.skipNewlines(); this.current().type !== t.RBRACE && this.current().type !== t.EOF; ) {
+            if (this.current().type === t.POSITION || this.current().type === t.ROTATION || this.current().type === t.SIZE || this.current().type === t.COLOR || this.current().type === t.OPACITY) {
+              const u = this.parseProperties();
+              Object.assign(c, u);
+            } else if (this.current().type === t.IDENTIFIER) {
+              const u = this.current().value;
+              this.advance();
+              const p = this.parseVectorOrExpression();
+              c[u] = p;
+            } else
+              break;
+            this.skipNewlines();
+          }
+          this.expect(t.RBRACE);
+        }
+        return {
+          type: "customShape",
+          name: o,
+          properties: c
+        };
+      }
+      default:
+        throw new R(
+          `Unexpected token: ${e.type}`,
+          e.line,
+          e.column
+        );
+    }
+  }
+  parse() {
+    const e = [];
+    for (; this.current().type !== t.EOF; ) {
+      const s = this.parseNode();
+      s && e.push(s), this.skipNewlines();
+    }
+    return e;
+  }
+}
+function X(n) {
+  try {
+    const r = new D(n).tokenize().filter((a) => a.type !== t.NEWLINE);
+    return new F(r).parse();
+  } catch (e) {
+    throw e instanceof R ? e : new R(
+      e instanceof Error ? e.message : "Unknown parse error"
+    );
+  }
+}
+class L {
+  constructor() {
+    d(this, "scopes", []);
+    this.pushScope();
+  }
+  pushScope() {
+    this.scopes.push(/* @__PURE__ */ new Map());
+  }
+  popScope() {
+    this.scopes.length > 1 && this.scopes.pop();
+  }
+  set(e, s) {
+    this.scopes[this.scopes.length - 1].set(e, s);
+  }
+  get(e) {
+    for (let s = this.scopes.length - 1; s >= 0; s--)
+      if (this.scopes[s].has(e))
+        return this.scopes[s].get(e);
+  }
+  has(e) {
+    return this.get(e) !== void 0;
+  }
+}
+const T = {
+  // Arithmetic
+  round: (n) => Math.round(h(n)),
+  floor: (n) => Math.floor(h(n)),
+  ceil: (n) => Math.ceil(h(n)),
+  abs: (n) => Math.abs(h(n)),
+  sign: (n) => Math.sign(h(n)),
+  sqrt: (n) => Math.sqrt(h(n)),
+  pow: (n, e) => Math.pow(h(n), h(e)),
+  min: (...n) => Math.min(...n.map(h)),
+  max: (...n) => Math.max(...n.map(h)),
+  // Trigonometric (uses radians)
+  sin: (n) => Math.sin(h(n)),
+  cos: (n) => Math.cos(h(n)),
+  tan: (n) => Math.tan(h(n)),
+  asin: (n) => Math.asin(h(n)),
+  acos: (n) => Math.acos(h(n)),
+  atan: (n) => Math.atan(h(n)),
+  atan2: (n, e) => Math.atan2(h(n), h(e)),
+  // Vector operations
+  dot: (n, e) => {
+    const s = I(n), r = I(e);
+    let i = 0;
+    for (let a = 0; a < Math.min(s.length, r.length); a++)
+      i += h(s[a]) * h(r[a]);
+    return i;
+  },
+  cross: (n, e) => {
+    const s = I(n), r = I(e);
+    if (s.length < 3 || r.length < 3)
+      throw new Error("cross product requires 3D vectors");
+    const i = h(s[0]), a = h(s[1]), o = h(s[2]), c = h(r[0]), u = h(r[1]), p = h(r[2]);
+    return [a * p - o * u, o * c - i * p, i * u - a * c];
+  },
+  length: (n) => {
+    const e = I(n);
+    let s = 0;
+    for (const r of e) {
+      const i = h(r);
+      s += i * i;
+    }
+    return Math.sqrt(s);
+  },
+  normalize: (n) => {
+    const e = I(n), s = T.length(n);
+    return s === 0 ? e : e.map((r) => h(r) / s);
+  },
+  sum: (n) => I(n).reduce((s, r) => s + h(r), 0),
+  // String functions
+  join: (...n) => {
+    const e = n.length > 0 && typeof n[n.length - 1] == "string" ? n.pop() : "";
+    return n.map(String).join(e);
+  },
+  trim: (n) => String(n).trim(),
+  // Random (for procedural generation)
+  rand: () => Math.random()
+};
+function h(n) {
+  if (typeof n == "number") return n;
+  if (typeof n == "boolean") return n ? 1 : 0;
+  if (typeof n == "string") {
+    const e = parseFloat(n);
+    if (isNaN(e)) throw new Error(`Cannot convert "${n}" to number`);
+    return e;
+  }
+  if (Array.isArray(n) && n.length > 0)
+    return h(n[0]);
+  throw new Error(`Cannot convert ${typeof n} to number`);
+}
+function I(n) {
+  return Array.isArray(n) ? n : [n];
+}
+function b(n) {
+  return typeof n == "boolean" ? n : typeof n == "number" ? n !== 0 : typeof n == "string" || Array.isArray(n) ? n.length > 0 : !1;
+}
+class V {
+  constructor(e) {
+    d(this, "symbols");
+    this.symbols = e || new L();
+  }
+  getSymbols() {
+    return this.symbols;
+  }
+  evaluate(e) {
+    if (typeof e == "number" || typeof e == "string" || Array.isArray(e))
+      return e;
+    switch (e.type) {
+      case "number":
+        return e.value;
+      case "identifier": {
+        if (e.name === "rnd")
+          return Math.random();
+        const s = this.symbols.get(e.name);
+        if (s === void 0)
+          throw new Error(`Undefined variable: ${e.name}`);
+        return s;
+      }
+      case "binary": {
+        const s = this.evaluate(e.left), r = this.evaluate(e.right);
+        switch (e.operator) {
+          case "+":
+            if (Array.isArray(s) && Array.isArray(r)) {
+              const i = [...s];
+              for (let a = 0; a < i.length && a < r.length; a++)
+                i[a] = h(i[a]) + h(r[a]);
+              return i;
+            }
+            return h(s) + h(r);
+          case "-":
+            if (Array.isArray(s) && Array.isArray(r)) {
+              const i = [...s];
+              for (let a = 0; a < i.length && a < r.length; a++)
+                i[a] = h(i[a]) - h(r[a]);
+              return i;
+            }
+            return h(s) - h(r);
+          case "*":
+            if (Array.isArray(s) && Array.isArray(r)) {
+              const i = Math.min(s.length, r.length), a = [];
+              for (let o = 0; o < i; o++)
+                a.push(h(s[o]) * h(r[o]));
+              return a;
+            }
+            return Array.isArray(s) ? s.map((i) => h(i) * h(r)) : Array.isArray(r) ? r.map((i) => h(s) * h(i)) : h(s) * h(r);
+          case "/":
+            if (Array.isArray(s) && Array.isArray(r)) {
+              const i = Math.min(s.length, r.length), a = [];
+              for (let o = 0; o < i; o++)
+                a.push(h(s[o]) / h(r[o]));
+              return a;
+            }
+            return Array.isArray(s) ? s.map((i) => h(i) / h(r)) : h(s) / h(r);
+          case "%":
+            return h(s) % h(r);
+          case "=":
+            if (Array.isArray(s) && Array.isArray(r)) {
+              if (s.length !== r.length) return !1;
+              for (let i = 0; i < s.length; i++)
+                if (h(s[i]) !== h(r[i])) return !1;
+              return !0;
+            }
+            return s === r;
+          case "<>":
+            if (Array.isArray(s) && Array.isArray(r)) {
+              if (s.length !== r.length) return !0;
+              for (let i = 0; i < s.length; i++)
+                if (h(s[i]) !== h(r[i])) return !0;
+              return !1;
+            }
+            return s !== r;
+          case "<":
+            return h(s) < h(r);
+          case "<=":
+            return h(s) <= h(r);
+          case ">":
+            return h(s) > h(r);
+          case ">=":
+            return h(s) >= h(r);
+          case "and":
+            return b(s) && b(r);
+          case "or":
+            return b(s) || b(r);
+          default:
+            throw new Error(`Unknown binary operator: ${e.operator}`);
+        }
+      }
+      case "unary": {
+        const s = this.evaluate(e.operand);
+        switch (e.operator) {
+          case "-":
+            return Array.isArray(s) ? s.map((r) => -h(r)) : -h(s);
+          case "not":
+            return !b(s);
+          default:
+            throw new Error(`Unknown unary operator: ${e.operator}`);
+        }
+      }
+      case "call": {
+        const s = T[e.name.toLowerCase()];
+        if (!s)
+          throw new Error(`Unknown function: ${e.name}`);
+        const r = e.args.map((i) => this.evaluate(i));
+        return s(...r);
+      }
+      case "tuple":
+        return e.elements.map((s) => this.evaluate(s));
+      case "member":
+      case "subscript":
+        throw new Error(
+          `Member access and subscripting not yet implemented: ${e.type}`
+        );
+      default:
+        throw new Error(
+          `Unknown expression type: ${e.type}`
+        );
+    }
+  }
+  evaluateToNumber(e) {
+    const s = this.evaluate(e);
+    return h(s);
+  }
+  evaluateToBoolean(e) {
+    const s = this.evaluate(e);
+    return b(s);
+  }
+  evaluateToVector3(e) {
+    if (Array.isArray(e) && typeof e[0] == "number")
+      return e;
+    const s = this.evaluate(e);
+    if (Array.isArray(s)) {
+      const i = s.length > 0 ? h(s[0]) : 0, a = s.length > 1 ? h(s[1]) : 0, o = s.length > 2 ? h(s[2]) : 0;
+      return [i, a, o];
+    }
+    const r = h(s);
+    return [r, r, r];
+  }
+  evaluateToColor(e) {
+    if (Array.isArray(e) && typeof e[0] == "number")
+      return e;
+    const s = this.evaluate(e);
+    if (Array.isArray(s)) {
+      const i = s.length > 0 ? h(s[0]) : 0, a = s.length > 1 ? h(s[1]) : 0, o = s.length > 2 ? h(s[2]) : 0;
+      return [i, a, o];
+    }
+    const r = h(s);
+    return [r, r, r];
+  }
+}
+class G {
+  constructor(e = {}) {
+    d(this, "options");
+    d(this, "evaluator");
+    d(this, "symbols");
+    d(this, "detailLevel", 32);
+    // Default detail level for curved shapes
+    // Transform state stack for relative transforms
+    d(this, "transformStack", []);
+    this.options = e, this.symbols = new L(), this.evaluator = new V(this.symbols), this.pushTransform();
+  }
+  convert(e) {
+    const s = new l.Group();
+    for (const r of e) {
+      const i = this.convertNode(r);
+      i && s.add(i);
+    }
+    return s;
+  }
+  convertNode(e) {
+    switch (e.type) {
+      case "shape":
+        return this.convertShape(e);
+      case "csg":
+        return this.convertCSG(e);
+      case "block":
+        return this.convertBlock(e);
+      case "for":
+        return this.convertForLoop(e);
+      case "if":
+        return this.convertIf(e);
+      case "switch":
+        return this.convertSwitch(e);
+      case "define":
+        return this.handleDefine(e), null;
+      // Define doesn't create geometry
+      case "extrude":
+        return this.convertExtrude(e);
+      case "loft":
+        return this.convertLoft(e);
+      case "lathe":
+        return this.convertLathe(e);
+      case "fill":
+        return this.convertFill(e);
+      case "hull":
+        return this.convertHull(e);
+      case "group":
+        return this.convertBlock(e);
+      case "detail":
+        return this.handleDetail(e), null;
+      // Detail doesn't create geometry
+      case "color":
+        return this.handleColorCommand(e), null;
+      case "rotate":
+        return this.handleRotateCommand(e), null;
+      case "orientation":
+        return this.handleOrientationCommand(e), null;
+      case "translate":
+        return this.handleTranslateCommand(e), null;
+      case "scale":
+        return this.handleScaleCommand(e), null;
+      case "customShape":
+        return this.convertCustomShape(e);
+      default:
+        return console.warn(`Unknown node type: ${e.type}`), null;
+    }
+  }
+  convertBlock(e) {
+    const s = new l.Group();
+    this.symbols.pushScope(), this.pushTransform();
+    for (const r of e.children) {
+      const i = this.convertNode(r);
+      i && s.add(i);
+    }
+    return this.popTransform(), this.symbols.popScope(), s;
+  }
+  convertShape(e) {
+    const s = this.createGeometry(e), r = this.createMaterial(e), i = new l.Mesh(s, r);
+    return this.applyExplicitTransforms(i, e.properties), this.applyCurrentTransform(i), i;
+  }
+  createGeometry(e) {
+    let s = [1, 1, 1];
+    switch (e.properties.size && (s = this.evaluateVector3(e.properties.size)), s[1] === 0 && s[2] === 0 && s[0] !== 0 && (s = [s[0], s[0], s[0]]), e.primitive) {
+      case "cube":
+        return new l.BoxGeometry(s[0], s[1], s[2]);
+      case "sphere":
+        return new l.SphereGeometry(
+          s[0],
+          this.detailLevel,
+          this.detailLevel
+        );
+      case "cylinder": {
+        const r = e.properties.radiusTop ? this.evaluateNumber(e.properties.radiusTop) : s[0], i = e.properties.radiusBottom ? this.evaluateNumber(e.properties.radiusBottom) : s[0], a = e.properties.height ? this.evaluateNumber(e.properties.height) : s[1];
+        return new l.CylinderGeometry(
+          r,
+          i,
+          a,
+          this.detailLevel
+        );
+      }
+      case "cone": {
+        const r = s[0], i = e.properties.height ? this.evaluateNumber(e.properties.height) : s[1];
+        return new l.ConeGeometry(r, i, this.detailLevel);
+      }
+      case "torus": {
+        const r = e.properties.outerRadius ? this.evaluateNumber(e.properties.outerRadius) : s[0], i = e.properties.innerRadius ? this.evaluateNumber(e.properties.innerRadius) : 0.4;
+        return new l.TorusGeometry(
+          r,
+          i,
+          Math.max(3, Math.floor(this.detailLevel / 2)),
+          this.detailLevel
+        );
+      }
+      case "circle": {
+        const r = s[0] || 1;
+        return new l.CircleGeometry(r, this.detailLevel);
+      }
+      case "square": {
+        const r = s[0] || 1;
+        return new l.PlaneGeometry(r, r);
+      }
+      case "polygon": {
+        const r = s[0] || 1, i = 6;
+        return new l.CircleGeometry(r, i);
+      }
+      default:
+        return console.warn(`Unknown primitive: ${e.primitive}`), new l.BoxGeometry(1, 1, 1);
+    }
+  }
+  createMaterial(e) {
+    const s = e.properties.color ? this.evaluateColor(e.properties.color) : [0.8, 0.8, 0.8], r = new l.Color(s[0], s[1], s[2]), i = e.properties.opacity ? this.evaluateNumber(e.properties.opacity) : 1, a = i < 1;
+    return new l.MeshStandardMaterial({
+      color: r,
+      opacity: i,
+      transparent: a,
+      wireframe: this.options.wireframe ?? !1
+    });
+  }
+  convertCSG(e) {
+    if (e.children.length === 0)
+      return new l.Group();
+    const s = this.currentTransform().matrix.clone();
+    try {
+      const r = new M();
+      this.symbols.pushScope(), this.pushTransform();
+      const i = this.currentTransform();
+      i.matrix.identity(), i.color = void 0;
+      const a = [];
+      for (const u of e.children) {
+        const p = this.convertNode(u);
+        if (p instanceof l.Mesh) {
+          const E = p.clone();
+          E.updateMatrixWorld(!0), a.push(E);
+        } else p instanceof l.Group && p.traverse((E) => {
+          if (E instanceof l.Mesh) {
+            const f = E.clone();
+            f.updateMatrixWorld(!0), a.push(f);
+          }
+        });
+      }
+      if (this.popTransform(), this.symbols.popScope(), a.length === 0)
+        return new l.Group();
+      const o = a.map((u) => {
+        const p = new B(u.geometry, u.material);
+        return p.position.copy(u.position), p.rotation.copy(u.rotation), p.scale.copy(u.scale), p.updateMatrixWorld(!0), p;
+      });
+      let c = o[0];
+      for (let u = 1; u < o.length; u++) {
+        const p = o[u];
+        switch (e.operation) {
+          case "union":
+            c = r.evaluate(c, p, w);
+            break;
+          case "difference":
+            c = r.evaluate(c, p, C);
+            break;
+          case "intersection":
+            c = r.evaluate(c, p, g);
+            break;
+          case "xor": {
+            const E = r.evaluate(
+              c.clone(),
+              p.clone(),
+              C
+            ), f = r.evaluate(
+              p.clone(),
+              c.clone(),
+              C
+            );
+            c = r.evaluate(E, f, w);
+            break;
+          }
+          case "stencil":
+            c = r.evaluate(c, p, g);
+            break;
+        }
+      }
+      return c.material || (c.material = o[0].material), c.applyMatrix4(s), c.updateMatrixWorld(!0), c;
+    } catch {
+      const r = new l.Group();
+      this.symbols.pushScope();
+      for (const i of e.children) {
+        const a = this.convertNode(i);
+        a && r.add(a);
+      }
+      return this.symbols.popScope(), r.applyMatrix4(s), r.updateMatrixWorld(!0), r;
+    }
+  }
+  convertForLoop(e) {
+    const s = new l.Group();
+    if (this.symbols.pushScope(), this.pushTransform(), e.iterableValues) {
+      const r = this.evaluator.evaluate(e.iterableValues), i = Array.isArray(r) ? r : [r];
+      for (let a = 0; a < i.length; a++) {
+        this.symbols.set(e.variable, i[a]);
+        for (const o of e.body) {
+          const c = this.convertNode(o);
+          c && s.add(c);
+        }
+      }
+    } else {
+      const r = this.evaluateNumber(e.from), i = this.evaluateNumber(e.to), a = e.step ? this.evaluateNumber(e.step) : 1, o = [];
+      if (a > 0)
+        for (let c = r; c <= i; c += a)
+          o.push(c);
+      else if (a < 0)
+        for (let c = r; c >= i; c += a)
+          o.push(c);
+      for (let c = 0; c < o.length; c++) {
+        const u = o[c];
+        this.symbols.set(e.variable, u);
+        for (const p of e.body) {
+          const E = this.convertNode(p);
+          E && s.add(E);
+        }
+      }
+    }
+    return this.popTransform(), this.symbols.popScope(), s;
+  }
+  convertIf(e) {
+    const s = new l.Group(), r = this.evaluator.evaluateToBoolean(e.condition);
+    if (this.symbols.pushScope(), this.pushTransform(), r)
+      for (const i of e.thenBody) {
+        const a = this.convertNode(i);
+        a && s.add(a);
+      }
+    else if (e.elseBody)
+      for (const i of e.elseBody) {
+        const a = this.convertNode(i);
+        a && s.add(a);
+      }
+    return this.popTransform(), this.symbols.popScope(), s;
+  }
+  convertSwitch(e) {
+    const s = new l.Group(), r = this.evaluator.evaluate(e.value);
+    this.symbols.pushScope(), this.pushTransform();
+    let i = !1;
+    for (const a of e.cases) {
+      for (const o of a.values) {
+        const c = this.evaluator.evaluate(o);
+        if (this.valuesEqual(r, c)) {
+          for (const u of a.body) {
+            const p = this.convertNode(u);
+            p && s.add(p);
+          }
+          i = !0;
+          break;
+        }
+      }
+      if (i) break;
+    }
+    if (!i && e.defaultCase)
+      for (const a of e.defaultCase) {
+        const o = this.convertNode(a);
+        o && s.add(o);
+      }
+    return this.popTransform(), this.symbols.popScope(), s;
+  }
+  handleDefine(e) {
+    if (e.value !== void 0) {
+      const s = this.evaluator.evaluate(e.value);
+      this.symbols.set(e.name, s);
+    } else (e.body !== void 0 || e.options !== void 0) && this.symbols.set(e.name, e);
+  }
+  convertCustomShape(e) {
+    const s = this.symbols.get(e.name);
+    if (!s || typeof s != "object" || !("type" in s))
+      return console.warn(`Custom shape '${e.name}' not found`), null;
+    const r = s;
+    if (!r.body)
+      return console.warn(`Custom shape '${e.name}' has no body`), null;
+    if (this.symbols.pushScope(), this.pushTransform(), r.options)
+      for (const a of r.options) {
+        const o = this.evaluator.evaluate(a.defaultValue);
+        this.symbols.set(a.name, o);
+      }
+    for (const [a, o] of Object.entries(e.properties)) {
+      const c = this.evaluator.evaluate(o);
+      this.symbols.set(a, c);
+    }
+    const i = new l.Group();
+    for (const a of r.body) {
+      const o = this.convertNode(a);
+      o && i.add(o);
+    }
+    return this.popTransform(), this.symbols.popScope(), i;
+  }
+  pushTransform() {
+    var s;
+    const e = this.currentTransform();
+    this.transformStack.push({
+      matrix: e.matrix.clone(),
+      color: (s = e.color) == null ? void 0 : s.clone()
+    });
+  }
+  popTransform() {
+    this.transformStack.length > 1 && this.transformStack.pop();
+  }
+  currentTransform() {
+    return this.transformStack.length === 0 ? {
+      matrix: new l.Matrix4(),
+      color: void 0
+    } : this.transformStack[this.transformStack.length - 1];
+  }
+  applyCurrentTransform(e) {
+    const s = this.currentTransform();
+    e.applyMatrix4(s.matrix);
+  }
+  applyExplicitTransforms(e, s) {
+    if (s.position) {
+      const r = this.evaluateVector3(s.position);
+      e.position.set(...r);
+    }
+    if (s.rotation) {
+      const r = this.evaluateVector3(s.rotation);
+      e.rotation.set(...r);
+    }
+    if (s.orientation) {
+      const r = this.evaluateVector3(s.orientation);
+      e.rotation.set(...r);
+    }
+  }
+  handleDetail(e) {
+    this.detailLevel = this.evaluateNumber(e.value), this.symbols.set("detail", this.detailLevel);
+  }
+  handleColorCommand(e) {
+    const s = this.evaluateVector3OrColor(e.value);
+    this.currentTransform().color = new l.Color(
+      s[0],
+      s[1],
+      s[2]
+    );
+  }
+  handleRotateCommand(e) {
+    const s = this.evaluateVector3(e.value), r = this.currentTransform(), i = new l.Matrix4(), a = new l.Euler(
+      s[0] * Math.PI * 2,
+      s[1] * Math.PI * 2,
+      s[2] * Math.PI * 2,
+      "XYZ"
+    );
+    i.makeRotationFromEuler(a), r.matrix.multiply(i);
+  }
+  handleOrientationCommand(e) {
+    const s = this.evaluateVector3(e.value), r = this.currentTransform(), i = new l.Vector3(), a = new l.Vector3();
+    r.matrix.decompose(i, new l.Quaternion(), a);
+    const o = new l.Euler(
+      s[0] * Math.PI * 2,
+      s[1] * Math.PI * 2,
+      s[2] * Math.PI * 2,
+      "XYZ"
+    );
+    r.matrix.compose(
+      i,
+      new l.Quaternion().setFromEuler(o),
+      a
+    );
+  }
+  handleTranslateCommand(e) {
+    const s = this.currentTransform(), [r, i, a] = this.evaluateTranslateVector(e.value), o = new l.Matrix4().makeTranslation(r, i, a);
+    s.matrix.multiply(o);
+  }
+  handleScaleCommand(e) {
+    const s = this.evaluateVector3(e.value), r = this.currentTransform(), i = new l.Matrix4().makeScale(
+      s[0],
+      s[1],
+      s[2]
+    );
+    r.matrix.multiply(i);
+  }
+  convertExtrude(e) {
+    const s = e.path ? this.buildPath(e.path) : new l.Shape([new l.Vector2(0, 0)]), i = (e.properties.size ? this.evaluateVector3(e.properties.size) : [1, 1, 1])[2] || 1, a = new l.ExtrudeGeometry(s, {
+      depth: i,
+      bevelEnabled: !1,
+      curveSegments: Math.max(1, Math.floor(this.detailLevel / 4))
+    }), o = this.createMaterial(e), c = new l.Mesh(a, o);
+    return this.applyExplicitTransforms(c, e.properties), this.applyCurrentTransform(c), c;
+  }
+  buildPath(e) {
+    const s = new l.Shape();
+    let r = 0, i = 0, a = 0;
+    const o = (c) => {
+      switch (c.type) {
+        case "point": {
+          const u = this.evaluateNumber(c.x), p = this.evaluateNumber(c.y), E = Math.cos(a), f = Math.sin(a), y = u * E - p * f, v = u * f + p * E;
+          r += y, i += v, s.curves.length === 0 ? s.moveTo(r, i) : s.lineTo(r, i);
+          break;
+        }
+        case "curve": {
+          const u = this.evaluateNumber(c.x), p = this.evaluateNumber(c.y), E = Math.cos(a), f = Math.sin(a), y = u * E - p * f, v = u * f + p * E;
+          if (r += y, i += v, c.controlX !== void 0 && c.controlY !== void 0) {
+            const N = this.evaluateNumber(c.controlX), A = this.evaluateNumber(c.controlY), m = N * E - A * f, S = N * f + A * E;
+            s.quadraticCurveTo(
+              r + m,
+              i + S,
+              r,
+              i
+            );
+          } else
+            s.lineTo(r, i);
+          break;
+        }
+        case "rotate": {
+          const u = this.evaluateNumber(c.angle);
+          a += u * Math.PI * 2;
+          break;
+        }
+        case "translate": {
+          const u = this.evaluateNumber(c.x), p = this.evaluateNumber(c.y);
+          r += u, i += p;
+          break;
+        }
+        case "for": {
+          this.symbols.pushScope();
+          const u = this.evaluateNumber(c.from), p = this.evaluateNumber(c.to), E = c.step ? this.evaluateNumber(c.step) : 1, f = [];
+          if (E > 0)
+            for (let y = u; y <= p; y += E)
+              f.push(y);
+          else if (E < 0)
+            for (let y = u; y >= p; y += E)
+              f.push(y);
+          for (const y of f) {
+            this.symbols.set(c.variable, y);
+            for (const v of c.commands)
+              o(v);
+          }
+          this.symbols.popScope();
+          break;
+        }
+      }
+    };
+    for (const c of e.commands)
+      o(c);
+    return s;
+  }
+  convertLathe(e) {
+    this.symbols.pushScope(), this.pushTransform();
+    let s = null;
+    for (const f of e.children)
+      if (f.type === "path") {
+        s = f;
+        break;
+      }
+    if (!s)
+      return console.warn("Lathe requires a path child"), this.popTransform(), this.symbols.popScope(), new l.Group();
+    const r = [];
+    let i = 0, a = 0, o = 0;
+    const c = (f) => {
+      switch (f.type) {
+        case "point":
+        case "curve": {
+          const y = this.evaluateNumber(f.x), v = this.evaluateNumber(f.y), N = Math.cos(o), A = Math.sin(o), m = y * N - v * A, S = y * A + v * N;
+          i += m, a += S, r.push(new l.Vector2(i, a));
+          break;
+        }
+        case "rotate": {
+          const y = this.evaluateNumber(f.angle);
+          o += y * Math.PI * 2;
+          break;
+        }
+        case "translate": {
+          const y = this.evaluateNumber(f.x), v = this.evaluateNumber(f.y);
+          i += y, a += v;
+          break;
+        }
+        case "for": {
+          this.symbols.pushScope();
+          const y = this.evaluateNumber(f.from), v = this.evaluateNumber(f.to), N = f.step ? this.evaluateNumber(f.step) : 1, A = [];
+          if (N > 0)
+            for (let m = y; m <= v; m += N)
+              A.push(m);
+          else if (N < 0)
+            for (let m = y; m >= v; m += N)
+              A.push(m);
+          for (const m of A) {
+            this.symbols.set(f.variable, m);
+            for (const S of f.commands)
+              c(S);
+          }
+          this.symbols.popScope();
+          break;
+        }
+      }
+    };
+    for (const f of s.commands)
+      c(f);
+    if (r.length < 2)
+      return console.warn("Lathe path must have at least 2 points"), this.popTransform(), this.symbols.popScope(), new l.Group();
+    const u = new l.LatheGeometry(
+      r,
+      this.detailLevel
+      // Number of segments around the axis
+    ), p = this.createMaterial(e), E = new l.Mesh(u, p);
+    return this.applyExplicitTransforms(E, e.properties), this.applyCurrentTransform(E), this.popTransform(), this.symbols.popScope(), E;
+  }
+  convertGroupBuilder(e) {
+    this.symbols.pushScope(), this.pushTransform();
+    const s = new l.Group();
+    for (const r of e.children) {
+      const i = this.convertNode(r);
+      i && s.add(i);
+    }
+    return this.applyExplicitTransforms(s, e.properties), this.applyCurrentTransform(s), this.popTransform(), this.symbols.popScope(), s;
+  }
+  convertLoft(e) {
+    return this.convertGroupBuilder(e);
+  }
+  convertFill(e) {
+    this.symbols.pushScope(), this.pushTransform();
+    let s = null;
+    for (const c of e.children)
+      if (c.type === "path") {
+        s = c;
+        break;
+      }
+    if (!s)
+      return console.warn("Fill requires a path child"), this.popTransform(), this.symbols.popScope(), new l.Group();
+    const r = this.buildPath(s), i = new l.ShapeGeometry(r), a = this.createMaterial(e), o = new l.Mesh(i, a);
+    return this.applyExplicitTransforms(o, e.properties), this.applyCurrentTransform(o), this.popTransform(), this.symbols.popScope(), o;
+  }
+  convertHull(e) {
+    return this.convertGroupBuilder(e);
+  }
+  // Helper methods
+  evaluateNumber(e) {
+    return e === void 0 ? 0 : typeof e == "number" ? e : this.evaluator.evaluateToNumber(e);
+  }
+  evaluateVector3(e) {
+    return e === void 0 ? [0, 0, 0] : Array.isArray(e) && typeof e[0] == "number" ? e : this.evaluator.evaluateToVector3(e);
+  }
+  evaluateTranslateVector(e) {
+    const s = this.evaluator.evaluate(e);
+    if (typeof s == "number")
+      return [s, 0, 0];
+    if (Array.isArray(s)) {
+      const r = s.length > 0 && typeof s[0] == "number" ? s[0] : 0, i = s.length > 1 && typeof s[1] == "number" ? s[1] : 0, a = s.length > 2 && typeof s[2] == "number" ? s[2] : 0;
+      return [r, i, a];
+    }
+    return [0, 0, 0];
+  }
+  evaluateColor(e) {
+    return e === void 0 ? [0.8, 0.8, 0.8] : Array.isArray(e) && typeof e[0] == "number" ? e : this.evaluator.evaluateToColor(e);
+  }
+  evaluateVector3OrColor(e) {
+    const s = this.evaluator.evaluate(e), r = (i) => typeof i == "number" ? i : typeof i == "boolean" ? i ? 1 : 0 : typeof i == "string" ? parseFloat(i) || 0 : Array.isArray(i) && i.length > 0 ? r(i[0]) : 0;
+    if (typeof s == "number")
+      return [s, s, s];
+    if (Array.isArray(s)) {
+      if (s.length === 1)
+        return [r(s[0]), r(s[0]), r(s[0])];
+      if (s.length === 2)
+        return [r(s[0]), r(s[1]), 0];
+      if (s.length >= 3)
+        return [r(s[0]), r(s[1]), r(s[2])];
+    }
+    return [0.8, 0.8, 0.8];
+  }
+  valuesEqual(e, s) {
+    if (typeof e != typeof s) return !1;
+    if (Array.isArray(e) && Array.isArray(s)) {
+      if (e.length !== s.length) return !1;
+      for (let r = 0; r < e.length; r++)
+        if (!this.valuesEqual(e[r], s[r])) return !1;
+      return !0;
+    }
+    return e === s;
+  }
+}
+function $(n, e = {}) {
+  return new G(e).convert(n);
+}
+export {
+  U as T,
+  k as a,
+  O as b,
+  X as c,
+  $ as d,
+  H as e,
+  Y as p,
+  Q as s
+};