@gui-chat-plugin/present3d 0.0.1 → 0.0.3

package/dist/toThreeJS-EXFMlO7B.js

@@ -1,2171 +0,0 @@
-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
-};