@elucim/dsl 0.1.0

package/dist/index.js

@@ -0,0 +1,1533 @@
+import { easeOutBounce as K, easeOutElastic as X, easeOutBack as Y, easeInBack as J, easeInOutExpo as Z, easeOutExpo as ee, easeInExpo as te, easeInOutSine as re, easeOutSine as ae, easeInSine as ie, easeInOutQuart as ne, easeOutQuart as se, easeInQuart as ce, easeInOutCubic as le, easeOutCubic as ue, easeInCubic as he, easeInOutQuad as fe, easeOutQuad as oe, easeInQuad as ye, linear as ge, spring as me, cubicBezier as be, Presentation as de, Player as xe, Scene as ve, Slide as we, Parallel as ke, Stagger as $e, Morph as Se, Transform as Ie, Write as Ce, Draw as Ae, FadeOut as Ee, FadeIn as Oe, BarChart as ze, LaTeX as Fe, Graph as Pe, Matrix as Me, VectorField as We, Vector as Ne, FunctionPlot as _e, Axes as Re, Text as De, Polygon as Te, Rect as Le, Arrow as je, Line as pe, Circle as qe, Sequence as Ue } from "@elucim/core";
+import { jsxs as L, jsx as s } from "react/jsx-runtime";
+import z from "react";
+const M = {
+  sin: Math.sin,
+  cos: Math.cos,
+  tan: Math.tan,
+  asin: Math.asin,
+  acos: Math.acos,
+  atan: Math.atan,
+  atan2: (e, r) => Math.atan2(e, r),
+  sqrt: Math.sqrt,
+  abs: Math.abs,
+  log: Math.log10,
+  ln: Math.log,
+  exp: Math.exp,
+  floor: Math.floor,
+  ceil: Math.ceil,
+  round: Math.round,
+  min: (...e) => Math.min(...e),
+  max: (...e) => Math.max(...e),
+  sign: Math.sign,
+  pow: Math.pow
+}, j = {
+  PI: Math.PI,
+  E: Math.E,
+  TAU: Math.PI * 2
+};
+function _(e) {
+  const r = [];
+  let t = 0;
+  for (; t < e.length; ) {
+    const a = e[t];
+    if (/\s/.test(a)) {
+      t++;
+      continue;
+    }
+    if (/[0-9]/.test(a) || a === "." && t + 1 < e.length && /[0-9]/.test(e[t + 1])) {
+      let n = "";
+      const l = t;
+      for (; t < e.length && /[0-9.]/.test(e[t]); )
+        n += e[t++];
+      r.push({ type: "NUMBER", value: n, pos: l });
+      continue;
+    }
+    if (/[a-zA-Z_]/.test(a)) {
+      let n = "";
+      const l = t;
+      for (; t < e.length && /[a-zA-Z0-9_]/.test(e[t]); )
+        n += e[t++];
+      r.push({ type: "IDENT", value: n, pos: l });
+      continue;
+    }
+    const i = t;
+    switch (t++, a) {
+      case "+":
+        r.push({ type: "PLUS", value: "+", pos: i });
+        break;
+      case "-":
+        r.push({ type: "MINUS", value: "-", pos: i });
+        break;
+      case "*":
+        r.push({ type: "STAR", value: "*", pos: i });
+        break;
+      case "/":
+        r.push({ type: "SLASH", value: "/", pos: i });
+        break;
+      case "^":
+        r.push({ type: "CARET", value: "^", pos: i });
+        break;
+      case "(":
+        r.push({ type: "LPAREN", value: "(", pos: i });
+        break;
+      case ")":
+        r.push({ type: "RPAREN", value: ")", pos: i });
+        break;
+      case "[":
+        r.push({ type: "LBRACKET", value: "[", pos: i });
+        break;
+      case "]":
+        r.push({ type: "RBRACKET", value: "]", pos: i });
+        break;
+      case ",":
+        r.push({ type: "COMMA", value: ",", pos: i });
+        break;
+      default:
+        throw new b(`Unexpected character '${a}'`, i);
+    }
+  }
+  return r.push({ type: "EOF", value: "", pos: t }), r;
+}
+class R {
+  constructor(r) {
+    this.pos = 0, this.tokens = r;
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  advance() {
+    const r = this.tokens[this.pos];
+    return this.pos++, r;
+  }
+  expect(r) {
+    const t = this.peek();
+    if (t.type !== r)
+      throw new b(
+        `Expected ${r} but got ${t.type} ('${t.value}')`,
+        t.pos
+      );
+    return this.advance();
+  }
+  // Entry point
+  parse() {
+    const r = this.parseExpression();
+    if (this.peek().type !== "EOF") {
+      const t = this.peek();
+      throw new b(
+        `Unexpected token '${t.value}' after expression`,
+        t.pos
+      );
+    }
+    return r;
+  }
+  // expression = term (('+' | '-') term)*
+  parseExpression() {
+    let r = this.parseTerm();
+    for (; this.peek().type === "PLUS" || this.peek().type === "MINUS"; ) {
+      const t = this.advance().value, a = this.parseTerm();
+      r = { kind: "binary", op: t, left: r, right: a };
+    }
+    return r;
+  }
+  // term = power (('*' | '/') power)*
+  parseTerm() {
+    let r = this.parsePower();
+    for (; this.peek().type === "STAR" || this.peek().type === "SLASH"; ) {
+      const t = this.advance().value, a = this.parsePower();
+      r = { kind: "binary", op: t, left: r, right: a };
+    }
+    return r;
+  }
+  // power = unary ('^' power)?  (right-associative)
+  parsePower() {
+    const r = this.parseUnary();
+    if (this.peek().type === "CARET") {
+      this.advance();
+      const t = this.parsePower();
+      return { kind: "binary", op: "^", left: r, right: t };
+    }
+    return r;
+  }
+  // unary = ('+' | '-') unary | primary
+  parseUnary() {
+    return this.peek().type === "MINUS" ? (this.advance(), { kind: "unary", op: "-", operand: this.parseUnary() }) : this.peek().type === "PLUS" ? (this.advance(), this.parseUnary()) : this.parsePrimary();
+  }
+  // primary = NUMBER | IDENT ('(' args ')')? | '(' expression ')' | '[' elements ']'
+  parsePrimary() {
+    const r = this.peek();
+    if (r.type === "NUMBER")
+      return this.advance(), { kind: "number", value: parseFloat(r.value) };
+    if (r.type === "IDENT") {
+      this.advance();
+      const t = r.value;
+      if (this.peek().type === "LPAREN") {
+        this.advance();
+        const a = [];
+        if (this.peek().type !== "RPAREN")
+          for (a.push(this.parseExpression()); this.peek().type === "COMMA"; )
+            this.advance(), a.push(this.parseExpression());
+        if (this.expect("RPAREN"), !Object.prototype.hasOwnProperty.call(M, t))
+          throw new b(
+            `Unknown function '${t}'. Available: ${Object.keys(M).join(", ")}`,
+            r.pos
+          );
+        return { kind: "call", name: t, args: a };
+      }
+      return Object.prototype.hasOwnProperty.call(j, t) ? { kind: "number", value: j[t] } : { kind: "variable", name: t };
+    }
+    if (r.type === "LPAREN") {
+      this.advance();
+      const t = this.parseExpression();
+      return this.expect("RPAREN"), t;
+    }
+    if (r.type === "LBRACKET") {
+      this.advance();
+      const t = [];
+      if (this.peek().type !== "RBRACKET")
+        for (t.push(this.parseExpression()); this.peek().type === "COMMA"; )
+          this.advance(), t.push(this.parseExpression());
+      return this.expect("RBRACKET"), { kind: "array", elements: t };
+    }
+    throw new b(
+      `Unexpected token '${r.value}'`,
+      r.pos
+    );
+  }
+}
+function d(e, r) {
+  switch (e.kind) {
+    case "number":
+      return e.value;
+    case "variable":
+      if (Object.prototype.hasOwnProperty.call(r, e.name)) return r[e.name];
+      throw new b(`Unknown variable '${e.name}'`, 0);
+    case "unary":
+      const t = d(e.operand, r);
+      return e.op === "-" ? -t : t;
+    case "binary": {
+      const a = d(e.left, r), i = d(e.right, r);
+      switch (e.op) {
+        case "+":
+          return a + i;
+        case "-":
+          return a - i;
+        case "*":
+          return a * i;
+        case "/":
+          return i === 0 ? 1 / 0 : a / i;
+        case "^":
+          return Math.pow(a, i);
+      }
+      break;
+    }
+    case "call": {
+      const a = M[e.name], i = e.args.map((n) => d(n, r));
+      return a(...i);
+    }
+    case "array":
+      return e.elements.map((a) => d(a, r));
+  }
+  throw new b("Invalid AST node", 0);
+}
+class b extends Error {
+  constructor(r, t) {
+    super(r), this.name = "ExpressionError", this.position = t;
+  }
+}
+function Be(e) {
+  const r = _(e), t = new R(r).parse();
+  return (a) => d(t, a);
+}
+function Ve(e) {
+  const r = _(e), t = new R(r).parse();
+  if (t.kind !== "array" || t.elements.length !== 2)
+    throw new b(
+      'Vector expression must be an array of 2 elements, e.g. "[-y, x]"',
+      0
+    );
+  return (a) => d(t, a);
+}
+function U(e) {
+  try {
+    const r = _(e);
+    return new R(r).parse(), null;
+  } catch (r) {
+    return r instanceof b ? `${r.message} (at position ${r.position})` : String(r);
+  }
+}
+const W = {
+  linear: ge,
+  easeInQuad: ye,
+  easeOutQuad: oe,
+  easeInOutQuad: fe,
+  easeInCubic: he,
+  easeOutCubic: ue,
+  easeInOutCubic: le,
+  easeInQuart: ce,
+  easeOutQuart: se,
+  easeInOutQuart: ne,
+  easeInSine: ie,
+  easeOutSine: ae,
+  easeInOutSine: re,
+  easeInExpo: te,
+  easeOutExpo: ee,
+  easeInOutExpo: Z,
+  easeInBack: J,
+  easeOutBack: Y,
+  easeOutElastic: X,
+  easeOutBounce: K
+};
+function c(e) {
+  if (e !== void 0) {
+    if (typeof e == "string") {
+      const r = W[e];
+      if (!r) {
+        const t = Object.keys(W), a = t.find((n) => n.toLowerCase() === e.toLowerCase()), i = a ? ` Did you mean '${a}'?` : "";
+        throw new Error(`Unknown easing '${e}'.${i} Available: ${t.join(", ")}`);
+      }
+      return r;
+    }
+    if (e.type === "spring")
+      return me({
+        stiffness: e.stiffness,
+        damping: e.damping,
+        mass: e.mass
+      });
+    if (e.type === "cubicBezier")
+      return be(e.x1, e.y1, e.x2, e.y2);
+    throw new Error(`Unknown easing type: ${e.type}`);
+  }
+}
+const F = Object.keys(W);
+function He(e) {
+  const r = [];
+  if (!e || typeof e != "object")
+    return r.push({ path: "", message: "Document must be an object", severity: "error" }), { valid: !1, errors: r };
+  const t = e;
+  return t.version !== "1.0" && r.push({ path: "version", message: `Expected version "1.0", got "${t.version}"`, severity: "error" }), !t.root || typeof t.root != "object" ? (r.push({ path: "root", message: 'Missing or invalid "root" node', severity: "error" }), { valid: r.filter((a) => a.severity === "error").length === 0, errors: r }) : (Ge(t.root, "root", r), {
+    valid: r.filter((a) => a.severity === "error").length === 0,
+    errors: r
+  });
+}
+const p = ["scene", "player", "presentation"], P = [
+  "sequence",
+  "group",
+  "circle",
+  "line",
+  "arrow",
+  "rect",
+  "polygon",
+  "text",
+  "axes",
+  "functionPlot",
+  "vectorField",
+  "vector",
+  "matrix",
+  "graph",
+  "latex",
+  "barChart",
+  "fadeIn",
+  "fadeOut",
+  "draw",
+  "write",
+  "transform",
+  "morph",
+  "stagger",
+  "parallel",
+  "player",
+  "scene"
+], q = ["none", "fade", "slide-left", "slide-up", "zoom"];
+function Ge(e, r, t) {
+  const a = e.type;
+  if (!p.includes(a)) {
+    t.push({ path: `${r}.type`, message: `Root type must be one of: ${p.join(", ")}. Got "${a}"`, severity: "error" });
+    return;
+  }
+  a === "scene" || a === "player" ? B(e, r, a, t) : a === "presentation" && Qe(e, r, t);
+}
+function B(e, r, t, a) {
+  gt(e, "durationInFrames", r, a), o(e, "width", r, a), o(e, "height", r, a), o(e, "fps", r, a), x(e, "background", r, a), t === "player" && ($(e, "controls", r, a), $(e, "loop", r, a), $(e, "autoPlay", r, a)), w(e, r, a);
+}
+function Qe(e, r, t) {
+  if (o(e, "width", r, t), o(e, "height", r, t), x(e, "background", r, t), o(e, "transitionDuration", r, t), $(e, "showHud", r, t), $(e, "showNotes", r, t), e.transition !== void 0 && (q.includes(e.transition) || t.push({
+    path: `${r}.transition`,
+    message: `Invalid transition "${e.transition}". Must be one of: ${q.join(", ")}`,
+    severity: "error"
+  })), !Array.isArray(e.slides)) {
+    t.push({ path: `${r}.slides`, message: 'Presentation must have a "slides" array', severity: "error" });
+    return;
+  }
+  e.slides.length === 0 && t.push({ path: `${r}.slides`, message: "Presentation must have at least one slide", severity: "warning" }), e.slides.forEach((a, i) => {
+    Ke(a, `${r}.slides[${i}]`, t);
+  });
+}
+function Ke(e, r, t) {
+  if (!e || typeof e != "object") {
+    t.push({ path: r, message: "Slide must be an object", severity: "error" });
+    return;
+  }
+  x(e, "title", r, t), x(e, "notes", r, t), x(e, "background", r, t), e.children !== void 0 && (Array.isArray(e.children) ? e.children.forEach((a, i) => {
+    V(a, `${r}.children[${i}]`, t);
+  }) : t.push({ path: `${r}.children`, message: "Slide children must be an array", severity: "error" }));
+}
+function w(e, r, t) {
+  if (!Array.isArray(e.children)) {
+    t.push({ path: `${r}.children`, message: 'Expected "children" array', severity: "error" });
+    return;
+  }
+  e.children.forEach((a, i) => {
+    V(a, `${r}.children[${i}]`, t);
+  });
+}
+function V(e, r, t) {
+  if (!e || typeof e != "object") {
+    t.push({ path: r, message: "Element must be an object", severity: "error" });
+    return;
+  }
+  const a = e.type;
+  if (!a || !P.includes(a)) {
+    const i = a ? H(a, P) : "";
+    t.push({
+      path: `${r}.type`,
+      message: `Unknown element type "${a}".${i} Valid types: ${P.join(", ")}`,
+      severity: "error"
+    });
+    return;
+  }
+  switch (a) {
+    case "circle":
+      Xe(e, r, t);
+      break;
+    case "line":
+      Ye(e, r, t);
+      break;
+    case "arrow":
+      Je(e, r, t);
+      break;
+    case "rect":
+      Ze(e, r, t);
+      break;
+    case "polygon":
+      et(e, r, t);
+      break;
+    case "text":
+      tt(e, r, t);
+      break;
+    case "axes":
+      rt(e, r, t);
+      break;
+    case "functionPlot":
+      at(e, r, t);
+      break;
+    case "vector":
+      it(e, r, t);
+      break;
+    case "vectorField":
+      nt(e, r, t);
+      break;
+    case "matrix":
+      st(e, r, t);
+      break;
+    case "graph":
+      ct(e, r, t);
+      break;
+    case "latex":
+      lt(e, r, t);
+      break;
+    case "sequence":
+      ut(e, r, t);
+      break;
+    case "group":
+    case "parallel":
+      w(e, r, t);
+      break;
+    case "fadeIn":
+    case "fadeOut":
+    case "draw":
+    case "write":
+      ht(e, r, t);
+      break;
+    case "transform":
+      ft(e, r, t);
+      break;
+    case "morph":
+      ot(e, r, t);
+      break;
+    case "stagger":
+      yt(e, r, t);
+      break;
+    case "scene":
+    case "player":
+      B(e, r, a, t);
+      break;
+  }
+}
+function Xe(e, r, t) {
+  u(e, "cx", r, t), u(e, "cy", r, t), N(e, "r", r, t), y(e, r, t);
+}
+function Ye(e, r, t) {
+  u(e, "x1", r, t), u(e, "y1", r, t), u(e, "x2", r, t), u(e, "y2", r, t), y(e, r, t);
+}
+function Je(e, r, t) {
+  u(e, "x1", r, t), u(e, "y1", r, t), u(e, "x2", r, t), u(e, "y2", r, t), y(e, r, t);
+}
+function Ze(e, r, t) {
+  u(e, "x", r, t), u(e, "y", r, t), N(e, "width", r, t), N(e, "height", r, t), y(e, r, t);
+}
+function et(e, r, t) {
+  Array.isArray(e.points) ? e.points.length < 3 ? t.push({ path: `${r}.points`, message: "Polygon requires at least 3 points", severity: "error" }) : e.points.forEach((a, i) => {
+    (!Array.isArray(a) || a.length !== 2 || typeof a[0] != "number" || typeof a[1] != "number") && t.push({ path: `${r}.points[${i}]`, message: "Each point must be [number, number]", severity: "error" });
+  }) : t.push({ path: `${r}.points`, message: 'Polygon requires a "points" array', severity: "error" }), y(e, r, t);
+}
+function tt(e, r, t) {
+  u(e, "x", r, t), u(e, "y", r, t), typeof e.content != "string" && t.push({ path: `${r}.content`, message: 'Text requires a "content" string', severity: "error" }), y(e, r, t);
+}
+function rt(e, r, t) {
+  v(e, "domain", r, t), v(e, "range", r, t), v(e, "origin", r, t), y(e, r, t);
+}
+function at(e, r, t) {
+  if (typeof e.fn != "string")
+    t.push({ path: `${r}.fn`, message: 'FunctionPlot requires a "fn" expression string', severity: "error" });
+  else {
+    const a = U(e.fn);
+    a && t.push({ path: `${r}.fn`, message: `Invalid expression: ${a}`, severity: "error" });
+  }
+  v(e, "domain", r, t), y(e, r, t);
+}
+function it(e, r, t) {
+  (!Array.isArray(e.to) || e.to.length !== 2) && t.push({ path: `${r}.to`, message: 'Vector requires a "to" array of [number, number]', severity: "error" }), v(e, "from", r, t), y(e, r, t);
+}
+function nt(e, r, t) {
+  if (typeof e.fn != "string")
+    t.push({ path: `${r}.fn`, message: 'VectorField requires a "fn" expression string', severity: "error" });
+  else {
+    const a = U(e.fn);
+    a && t.push({ path: `${r}.fn`, message: `Invalid vector expression: ${a}`, severity: "error" });
+  }
+  v(e, "domain", r, t), v(e, "range", r, t), y(e, r, t);
+}
+function st(e, r, t) {
+  Array.isArray(e.values) ? e.values.forEach((a, i) => {
+    Array.isArray(a) || t.push({ path: `${r}.values[${i}]`, message: "Each matrix row must be an array", severity: "error" });
+  }) : t.push({ path: `${r}.values`, message: 'Matrix requires a "values" 2D array', severity: "error" }), y(e, r, t);
+}
+function ct(e, r, t) {
+  if (!Array.isArray(e.nodes))
+    t.push({ path: `${r}.nodes`, message: 'Graph requires a "nodes" array', severity: "error" });
+  else {
+    const a = /* @__PURE__ */ new Set();
+    e.nodes.forEach((i, n) => {
+      typeof i.id != "string" ? t.push({ path: `${r}.nodes[${n}].id`, message: 'Graph node requires a string "id"', severity: "error" }) : (a.has(i.id) && t.push({ path: `${r}.nodes[${n}].id`, message: `Duplicate node id "${i.id}"`, severity: "error" }), a.add(i.id)), u(i, "x", `${r}.nodes[${n}]`, t), u(i, "y", `${r}.nodes[${n}]`, t);
+    }), Array.isArray(e.edges) && e.edges.forEach((i, n) => {
+      (typeof i.from != "string" || !a.has(i.from)) && t.push({ path: `${r}.edges[${n}].from`, message: `Edge "from" references unknown node "${i.from}"`, severity: "error" }), (typeof i.to != "string" || !a.has(i.to)) && t.push({ path: `${r}.edges[${n}].to`, message: `Edge "to" references unknown node "${i.to}"`, severity: "error" });
+    });
+  }
+  y(e, r, t);
+}
+function lt(e, r, t) {
+  typeof e.expression != "string" && t.push({ path: `${r}.expression`, message: 'LaTeX requires an "expression" string', severity: "error" }), u(e, "x", r, t), u(e, "y", r, t), y(e, r, t);
+}
+function ut(e, r, t) {
+  u(e, "from", r, t), mt(e, "durationInFrames", r, t), w(e, r, t);
+}
+function ht(e, r, t) {
+  o(e, "duration", r, t), S(e, r, t), w(e, r, t);
+}
+function ft(e, r, t) {
+  if (o(e, "duration", r, t), S(e, r, t), e.translate !== void 0) {
+    const a = e.translate;
+    (!a || typeof a != "object") && t.push({ path: `${r}.translate`, message: "translate must be { from: [x,y], to: [x,y] }", severity: "error" });
+  }
+  if (e.scale !== void 0) {
+    const a = e.scale;
+    (!a || typeof a != "object" || typeof a.from != "number" || typeof a.to != "number") && t.push({ path: `${r}.scale`, message: "scale must be { from: number, to: number }", severity: "error" });
+  }
+  if (e.rotate !== void 0) {
+    const a = e.rotate;
+    (!a || typeof a != "object" || typeof a.from != "number" || typeof a.to != "number") && t.push({ path: `${r}.rotate`, message: "rotate must be { from: number, to: number }", severity: "error" });
+  }
+  if (e.opacity !== void 0) {
+    const a = e.opacity;
+    (!a || typeof a != "object" || typeof a.from != "number" || typeof a.to != "number") && t.push({ path: `${r}.opacity`, message: "opacity must be { from: number, to: number }", severity: "error" });
+  }
+  w(e, r, t);
+}
+function ot(e, r, t) {
+  o(e, "duration", r, t), S(e, r, t), x(e, "fromColor", r, t), x(e, "toColor", r, t), w(e, r, t);
+}
+function yt(e, r, t) {
+  o(e, "staggerDelay", r, t), S(e, r, t), w(e, r, t);
+}
+function y(e, r, t) {
+  o(e, "fadeIn", r, t), o(e, "fadeOut", r, t), o(e, "draw", r, t), S(e, r, t);
+}
+function S(e, r, t) {
+  if (e.easing !== void 0) {
+    if (typeof e.easing == "string") {
+      if (!F.includes(e.easing)) {
+        const a = H(e.easing, F);
+        t.push({
+          path: `${r}.easing`,
+          message: `Unknown easing "${e.easing}".${a} Available: ${F.join(", ")}`,
+          severity: "error"
+        });
+      }
+      return;
+    }
+    if (typeof e.easing == "object" && e.easing !== null) {
+      const a = e.easing;
+      if (a.type === "spring") return;
+      if (a.type === "cubicBezier") {
+        for (const i of ["x1", "y1", "x2", "y2"])
+          typeof a[i] != "number" && t.push({ path: `${r}.easing.${i}`, message: `cubicBezier requires numeric "${i}"`, severity: "error" });
+        return;
+      }
+      t.push({ path: `${r}.easing.type`, message: 'Easing object type must be "spring" or "cubicBezier"', severity: "error" });
+      return;
+    }
+    t.push({ path: `${r}.easing`, message: 'Easing must be a string name or { type: "spring"|"cubicBezier", ... }', severity: "error" });
+  }
+}
+function u(e, r, t, a) {
+  typeof e[r] != "number" && a.push({ path: `${t}.${r}`, message: `Required numeric field "${r}" is missing or not a number`, severity: "error" });
+}
+function N(e, r, t, a) {
+  (typeof e[r] != "number" || e[r] <= 0) && a.push({ path: `${t}.${r}`, message: `"${r}" must be a positive number`, severity: "error" });
+}
+function gt(e, r, t, a) {
+  const i = e[r];
+  (typeof i != "number" || i <= 0 || !Number.isInteger(i)) && a.push({ path: `${t}.${r}`, message: `"${r}" must be a positive integer`, severity: "error" });
+}
+function o(e, r, t, a) {
+  e[r] !== void 0 && (typeof e[r] != "number" || e[r] <= 0) && a.push({ path: `${t}.${r}`, message: `"${r}" must be a positive number`, severity: "error" });
+}
+function mt(e, r, t, a) {
+  const i = e[r];
+  i !== void 0 && (typeof i != "number" || i <= 0 || !Number.isInteger(i)) && a.push({ path: `${t}.${r}`, message: `"${r}" must be a positive integer`, severity: "error" });
+}
+function x(e, r, t, a) {
+  e[r] !== void 0 && typeof e[r] != "string" && a.push({ path: `${t}.${r}`, message: `"${r}" must be a string`, severity: "error" });
+}
+function $(e, r, t, a) {
+  e[r] !== void 0 && typeof e[r] != "boolean" && a.push({ path: `${t}.${r}`, message: `"${r}" must be a boolean`, severity: "error" });
+}
+function v(e, r, t, a) {
+  const i = e[r];
+  i !== void 0 && (!Array.isArray(i) || i.length !== 2 || typeof i[0] != "number" || typeof i[1] != "number") && a.push({ path: `${t}.${r}`, message: `"${r}" must be [number, number]`, severity: "error" });
+}
+function H(e, r) {
+  const t = e.toLowerCase(), a = r.find((n) => n.toLowerCase() === t);
+  if (a) return ` Did you mean '${a}'?`;
+  const i = r.find((n) => n.toLowerCase().startsWith(t.slice(0, 4)));
+  return i ? ` Did you mean '${i}'?` : "";
+}
+function Ct({ dsl: e, className: r, style: t }) {
+  const a = He(e);
+  return a.valid ? /* @__PURE__ */ s("div", { className: r, style: t, "data-testid": "dsl-root", children: bt(e.root) }) : /* @__PURE__ */ L(
+    "div",
+    {
+      className: r,
+      style: { color: "#ff6b6b", fontFamily: "monospace", padding: 16, ...t },
+      "data-testid": "dsl-error",
+      children: [
+        /* @__PURE__ */ s("strong", { children: "Elucim DSL Validation Errors:" }),
+        /* @__PURE__ */ s("ul", { children: a.errors.filter((i) => i.severity === "error").map((i, n) => /* @__PURE__ */ L("li", { children: [
+          i.path,
+          ": ",
+          i.message
+        ] }, n)) })
+      ]
+    }
+  );
+}
+function bt(e) {
+  switch (e.type) {
+    case "scene":
+      return G(e);
+    case "player":
+      return Q(e);
+    case "presentation":
+      return dt(e);
+  }
+}
+function G(e) {
+  return /* @__PURE__ */ s(
+    ve,
+    {
+      width: e.width,
+      height: e.height,
+      fps: e.fps,
+      durationInFrames: e.durationInFrames,
+      background: e.background,
+      children: e.children.map((r, t) => f(r, t))
+    }
+  );
+}
+function Q(e) {
+  return /* @__PURE__ */ s(
+    xe,
+    {
+      width: e.width,
+      height: e.height,
+      fps: e.fps,
+      durationInFrames: e.durationInFrames,
+      background: e.background,
+      controls: e.controls,
+      loop: e.loop,
+      autoPlay: e.autoPlay,
+      children: e.children.map((r, t) => f(r, t))
+    }
+  );
+}
+function dt(e) {
+  return /* @__PURE__ */ s(
+    de,
+    {
+      width: e.width,
+      height: e.height,
+      background: e.background,
+      transition: e.transition,
+      transitionDuration: e.transitionDuration,
+      showHUD: e.showHud,
+      showNotes: e.showNotes,
+      children: e.slides.map((r, t) => xt(r, t))
+    }
+  );
+}
+function xt(e, r) {
+  var t;
+  return /* @__PURE__ */ s(we, { title: e.title, notes: e.notes, background: e.background, children: (t = e.children) == null ? void 0 : t.map((a, i) => f(a, i)) }, r);
+}
+function f(e, r) {
+  switch (e.type) {
+    case "sequence":
+      return /* @__PURE__ */ s(Ue, { from: e.from, durationInFrames: e.durationInFrames, name: e.name, children: e.children.map((t, a) => f(t, a)) }, r);
+    case "group":
+      return /* @__PURE__ */ s(z.Fragment, { children: e.children.map((t, a) => f(t, a)) }, r);
+    case "circle":
+      return /* @__PURE__ */ s(
+        qe,
+        {
+          cx: e.cx,
+          cy: e.cy,
+          r: e.r,
+          fill: e.fill,
+          stroke: e.stroke,
+          strokeWidth: e.strokeWidth,
+          opacity: e.opacity,
+          fadeIn: e.fadeIn,
+          fadeOut: e.fadeOut,
+          draw: e.draw,
+          easing: c(e.easing)
+        },
+        r
+      );
+    case "line":
+      return /* @__PURE__ */ s(
+        pe,
+        {
+          x1: e.x1,
+          y1: e.y1,
+          x2: e.x2,
+          y2: e.y2,
+          stroke: e.stroke,
+          strokeWidth: e.strokeWidth,
+          strokeDasharray: e.strokeDasharray,
+          opacity: e.opacity,
+          fadeIn: e.fadeIn,
+          fadeOut: e.fadeOut,
+          draw: e.draw,
+          easing: c(e.easing)
+        },
+        r
+      );
+    case "arrow":
+      return /* @__PURE__ */ s(
+        je,
+        {
+          x1: e.x1,
+          y1: e.y1,
+          x2: e.x2,
+          y2: e.y2,
+          stroke: e.stroke,
+          strokeWidth: e.strokeWidth,
+          headSize: e.headSize,
+          strokeDasharray: e.strokeDasharray,
+          opacity: e.opacity,
+          fadeIn: e.fadeIn,
+          fadeOut: e.fadeOut,
+          draw: e.draw,
+          easing: c(e.easing)
+        },
+        r
+      );
+    case "rect":
+      return /* @__PURE__ */ s(
+        Le,
+        {
+          x: e.x,
+          y: e.y,
+          width: e.width,
+          height: e.height,
+          fill: e.fill,
+          stroke: e.stroke,
+          strokeWidth: e.strokeWidth,
+          rx: e.rx,
+          ry: e.ry,
+          strokeDasharray: e.strokeDasharray,
+          opacity: e.opacity,
+          fadeIn: e.fadeIn,
+          fadeOut: e.fadeOut,
+          draw: e.draw,
+          easing: c(e.easing)
+        },
+        r
+      );
+    case "polygon":
+      return /* @__PURE__ */ s(
+        Te,
+        {
+          points: e.points,
+          fill: e.fill,
+          stroke: e.stroke,
+          strokeWidth: e.strokeWidth,
+          closed: e.closed,
+          opacity: e.opacity,
+          fadeIn: e.fadeIn,
+          fadeOut: e.fadeOut,
+          draw: e.draw,
+          easing: c(e.easing)
+        },
+        r
+      );
+    case "text":
+      return /* @__PURE__ */ s(
+        De,
+        {
+          x: e.x,
+          y: e.y,
+          fill: e.fill,
+          fontSize: e.fontSize,
+          fontFamily: e.fontFamily,
+          fontWeight: e.fontWeight,
+          textAnchor: e.textAnchor,
+          dominantBaseline: e.dominantBaseline,
+          opacity: e.opacity,
+          fadeIn: e.fadeIn,
+          fadeOut: e.fadeOut,
+          easing: c(e.easing),
+          children: e.content
+        },
+        r
+      );
+    case "axes":
+      return /* @__PURE__ */ s(
+        Re,
+        {
+          domain: e.domain,
+          range: e.range,
+          origin: e.origin,
+          scale: e.scale,
+          showGrid: e.showGrid,
+          showTicks: e.showTicks,
+          showLabels: e.showLabels,
+          tickStep: e.tickStep,
+          axisColor: e.axisColor,
+          gridColor: e.gridColor,
+          labelColor: e.labelColor,
+          labelFontSize: e.labelFontSize,
+          fadeIn: e.fadeIn,
+          fadeOut: e.fadeOut,
+          draw: e.draw,
+          easing: c(e.easing)
+        },
+        r
+      );
+    case "functionPlot": {
+      const t = Be(e.fn);
+      return /* @__PURE__ */ s(
+        _e,
+        {
+          fn: (a) => t({ x: a }),
+          domain: e.domain,
+          yClamp: e.yClamp,
+          origin: e.origin,
+          scale: e.scale,
+          color: e.color,
+          strokeWidth: e.strokeWidth,
+          samples: e.samples,
+          draw: e.draw,
+          easing: c(e.easing),
+          opacity: e.opacity
+        },
+        r
+      );
+    }
+    case "vector":
+      return /* @__PURE__ */ s(
+        Ne,
+        {
+          from: e.from,
+          to: e.to,
+          origin: e.origin,
+          scale: e.scale,
+          color: e.color,
+          strokeWidth: e.strokeWidth,
+          headSize: e.headSize,
+          label: e.label,
+          labelOffset: e.labelOffset,
+          labelColor: e.labelColor,
+          labelFontSize: e.labelFontSize,
+          fadeIn: e.fadeIn,
+          fadeOut: e.fadeOut,
+          draw: e.draw,
+          easing: c(e.easing)
+        },
+        r
+      );
+    case "vectorField": {
+      const t = Ve(e.fn);
+      return /* @__PURE__ */ s(
+        We,
+        {
+          fn: (a, i) => t({ x: a, y: i }),
+          domain: e.domain,
+          range: e.range,
+          step: e.step,
+          origin: e.origin,
+          scale: e.scale,
+          arrowScale: e.arrowScale,
+          color: e.color,
+          strokeWidth: e.strokeWidth,
+          headSize: e.headSize,
+          normalize: e.normalize,
+          maxLength: e.maxLength,
+          fadeIn: e.fadeIn,
+          fadeOut: e.fadeOut,
+          easing: c(e.easing)
+        },
+        r
+      );
+    }
+    case "matrix":
+      return /* @__PURE__ */ s(
+        Me,
+        {
+          values: e.values,
+          x: e.x,
+          y: e.y,
+          cellSize: e.cellSize,
+          color: e.color,
+          bracketColor: e.bracketColor,
+          fontSize: e.fontSize,
+          fadeIn: e.fadeIn,
+          fadeOut: e.fadeOut,
+          easing: c(e.easing)
+        },
+        r
+      );
+    case "graph":
+      return /* @__PURE__ */ s(
+        Pe,
+        {
+          nodes: e.nodes,
+          edges: e.edges,
+          nodeColor: e.nodeColor,
+          nodeRadius: e.nodeRadius,
+          edgeColor: e.edgeColor,
+          edgeWidth: e.edgeWidth,
+          labelColor: e.labelColor,
+          labelFontSize: e.labelFontSize,
+          fadeIn: e.fadeIn,
+          fadeOut: e.fadeOut,
+          easing: c(e.easing)
+        },
+        r
+      );
+    case "latex":
+      return /* @__PURE__ */ s(
+        Fe,
+        {
+          expression: e.expression,
+          x: e.x,
+          y: e.y,
+          color: e.color,
+          fontSize: e.fontSize,
+          align: e.align,
+          fadeIn: e.fadeIn,
+          fadeOut: e.fadeOut,
+          easing: c(e.easing)
+        },
+        r
+      );
+    case "barChart":
+      return /* @__PURE__ */ s(
+        ze,
+        {
+          bars: e.bars,
+          x: e.x,
+          y: e.y,
+          width: e.width,
+          height: e.height,
+          barColor: e.barColor,
+          labelColor: e.labelColor,
+          labelFontSize: e.labelFontSize,
+          showValues: e.showValues,
+          maxValue: e.maxValue,
+          gap: e.gap,
+          valueFormat: e.valueFormat,
+          fadeIn: e.fadeIn,
+          fadeOut: e.fadeOut,
+          easing: c(e.easing)
+        },
+        r
+      );
+    case "fadeIn":
+      return /* @__PURE__ */ s(Oe, { duration: e.duration, easing: c(e.easing), children: e.children.map((t, a) => f(t, a)) }, r);
+    case "fadeOut":
+      return /* @__PURE__ */ s(Ee, { duration: e.duration, totalFrames: e.totalFrames, easing: c(e.easing), children: e.children.map((t, a) => f(t, a)) }, r);
+    case "draw":
+      return /* @__PURE__ */ s(Ae, { duration: e.duration, pathLength: e.pathLength, easing: c(e.easing), children: f(e.children[0], 0) }, r);
+    case "write":
+      return /* @__PURE__ */ s(Ce, { duration: e.duration, easing: c(e.easing), children: e.children.map((t, a) => f(t, a)) }, r);
+    case "transform":
+      return /* @__PURE__ */ s(
+        Ie,
+        {
+          duration: e.duration,
+          easing: c(e.easing),
+          translate: e.translate,
+          scale: e.scale,
+          rotate: e.rotate,
+          opacity: e.opacity,
+          children: e.children.map((t, a) => f(t, a))
+        },
+        r
+      );
+    case "morph":
+      return /* @__PURE__ */ s(
+        Se,
+        {
+          duration: e.duration,
+          easing: c(e.easing),
+          fromColor: e.fromColor,
+          toColor: e.toColor,
+          fromOpacity: e.fromOpacity,
+          toOpacity: e.toOpacity,
+          fromScale: e.fromScale,
+          toScale: e.toScale,
+          children: e.children.map((t, a) => f(t, a))
+        },
+        r
+      );
+    case "stagger":
+      return /* @__PURE__ */ s($e, { staggerDelay: e.staggerDelay, easing: c(e.easing), children: e.children.map((t, a) => f(t, a)) }, r);
+    case "parallel":
+      return /* @__PURE__ */ s(ke, { children: e.children.map((t, a) => f(t, a)) }, r);
+    case "scene":
+      return /* @__PURE__ */ s(z.Fragment, { children: G(e) }, r);
+    case "player":
+      return /* @__PURE__ */ s(z.Fragment, { children: Q(e) }, r);
+    default:
+      return null;
+  }
+}
+class vt {
+  constructor(r, t = 30, a = 900, i = 640) {
+    this.elements = [], this.cursor = 0, this.theme = r, this._fps = t, this._width = a, this._height = i;
+  }
+  get width() {
+    return this._width;
+  }
+  get height() {
+    return this._height;
+  }
+  get fps() {
+    return this._fps;
+  }
+  get cx() {
+    return this._width / 2;
+  }
+  get cy() {
+    return this._height / 2;
+  }
+  /** Current animation frame cursor */
+  get frame() {
+    return this.cursor;
+  }
+  /** Advance the cursor by N frames */
+  wait(r) {
+    return this.cursor += r, this;
+  }
+  /** Set cursor to an absolute frame */
+  at(r) {
+    return this.cursor = r, this;
+  }
+  // ─── High-level helpers ──────────────────────────────────────────────
+  /** Large centered title text */
+  title(r, t) {
+    return this.addAtCursor({
+      type: "fadeIn",
+      duration: 15,
+      children: [{
+        type: "text",
+        x: this.cx,
+        y: (t == null ? void 0 : t.y) ?? 55,
+        content: r,
+        fontSize: (t == null ? void 0 : t.fontSize) ?? 28,
+        fill: (t == null ? void 0 : t.color) ?? this.theme.title,
+        textAnchor: "middle",
+        fontWeight: "bold"
+      }]
+    }, 15);
+  }
+  /** Smaller subtitle text */
+  subtitle(r, t) {
+    return this.addAtCursor({
+      type: "fadeIn",
+      duration: 12,
+      children: [{
+        type: "text",
+        x: this.cx,
+        y: (t == null ? void 0 : t.y) ?? 95,
+        content: r,
+        fontSize: (t == null ? void 0 : t.fontSize) ?? 16,
+        fill: (t == null ? void 0 : t.color) ?? this.theme.subtitle,
+        textAnchor: "middle"
+      }]
+    }, 10);
+  }
+  /** Add a LaTeX expression */
+  latex(r, t) {
+    const a = (t == null ? void 0 : t.fadeIn) ?? 15;
+    return this.addAtCursor({
+      type: "fadeIn",
+      duration: a,
+      children: [{
+        type: "latex",
+        expression: r,
+        x: (t == null ? void 0 : t.x) ?? this.cx,
+        y: (t == null ? void 0 : t.y) ?? 300,
+        fontSize: (t == null ? void 0 : t.fontSize) ?? 28,
+        color: (t == null ? void 0 : t.color) ?? this.theme.primary,
+        align: "center"
+      }]
+    }, (t == null ? void 0 : t.advance) ?? 10);
+  }
+  /** Add text at a position */
+  text(r, t) {
+    const a = t.fadeIn ?? 15, i = t.advance ?? 5;
+    return this.addAtCursor({
+      type: "fadeIn",
+      duration: a,
+      children: [{
+        type: "text",
+        x: t.x,
+        y: t.y,
+        content: r,
+        fontSize: t.fontSize ?? 14,
+        fill: t.color ?? this.theme.text,
+        textAnchor: t.anchor ?? "middle",
+        fontWeight: t.fontWeight,
+        fontFamily: t.fontFamily
+      }]
+    }, i);
+  }
+  /** Add an arrow */
+  arrow(r, t, a, i, n) {
+    const l = (n == null ? void 0 : n.fadeIn) ?? 12, k = {
+      type: "arrow",
+      x1: r,
+      y1: t,
+      x2: a,
+      y2: i,
+      stroke: (n == null ? void 0 : n.color) ?? this.theme.primary,
+      strokeWidth: (n == null ? void 0 : n.strokeWidth) ?? 2,
+      headSize: (n == null ? void 0 : n.headSize) ?? 8,
+      strokeDasharray: n != null && n.dashed ? "6 3" : void 0,
+      fadeIn: l
+    };
+    return this.addAtCursor(k, (n == null ? void 0 : n.advance) ?? 3);
+  }
+  /** Add a line */
+  line(r, t, a, i, n) {
+    const l = (n == null ? void 0 : n.fadeIn) ?? 12;
+    return this.addAtCursor({
+      type: "line",
+      x1: r,
+      y1: t,
+      x2: a,
+      y2: i,
+      stroke: (n == null ? void 0 : n.color) ?? this.theme.muted,
+      strokeWidth: (n == null ? void 0 : n.strokeWidth) ?? 1,
+      strokeDasharray: n != null && n.dashed ? "6 3" : void 0,
+      fadeIn: l
+    }, (n == null ? void 0 : n.advance) ?? 3);
+  }
+  /** Add a rectangle */
+  rect(r, t, a, i, n) {
+    const l = (n == null ? void 0 : n.fadeIn) ?? 12;
+    return this.addAtCursor({
+      type: "rect",
+      x: r,
+      y: t,
+      width: a,
+      height: i,
+      fill: (n == null ? void 0 : n.fill) ?? "none",
+      stroke: (n == null ? void 0 : n.stroke) ?? this.theme.boxStroke,
+      strokeWidth: (n == null ? void 0 : n.strokeWidth) ?? 1.5,
+      rx: (n == null ? void 0 : n.rx) ?? 6,
+      strokeDasharray: n != null && n.dashed ? "6 3" : void 0,
+      fadeIn: l
+    }, (n == null ? void 0 : n.advance) ?? 5);
+  }
+  /** Add a circle */
+  circle(r, t, a, i) {
+    const n = (i == null ? void 0 : i.fadeIn) ?? 12;
+    return this.addAtCursor({
+      type: "circle",
+      cx: r,
+      cy: t,
+      r: a,
+      fill: (i == null ? void 0 : i.fill) ?? "none",
+      stroke: (i == null ? void 0 : i.stroke) ?? this.theme.primary,
+      strokeWidth: (i == null ? void 0 : i.strokeWidth) ?? 2,
+      fadeIn: n
+    }, (i == null ? void 0 : i.advance) ?? 5);
+  }
+  /** Add a bar chart */
+  barChart(r, t) {
+    const a = t.fadeIn ?? 20;
+    return this.addAtCursor({
+      type: "barChart",
+      bars: r,
+      x: t.x,
+      y: t.y,
+      width: t.width,
+      height: t.height,
+      barColor: t.barColor ?? this.theme.primary,
+      labelColor: t.labelColor ?? this.theme.text,
+      labelFontSize: t.labelFontSize,
+      maxValue: t.maxValue,
+      valueFormat: t.valueFormat,
+      gap: t.gap,
+      showValues: t.showValues,
+      fadeIn: a
+    }, 10);
+  }
+  /** Add a matrix visualization */
+  matrix(r, t) {
+    const a = (t == null ? void 0 : t.fadeIn) ?? 20;
+    return this.addAtCursor({
+      type: "matrix",
+      values: r,
+      x: (t == null ? void 0 : t.x) ?? this.cx,
+      y: (t == null ? void 0 : t.y) ?? 300,
+      cellSize: (t == null ? void 0 : t.cellSize) ?? 50,
+      color: (t == null ? void 0 : t.color) ?? this.theme.text,
+      bracketColor: (t == null ? void 0 : t.bracketColor) ?? this.theme.primary,
+      fontSize: t == null ? void 0 : t.fontSize,
+      fadeIn: a
+    }, 10);
+  }
+  /** Add a graph (nodes + edges) */
+  graph(r, t, a) {
+    const i = (a == null ? void 0 : a.fadeIn) ?? 20;
+    return this.addAtCursor({
+      type: "graph",
+      nodes: r,
+      edges: t,
+      nodeColor: (a == null ? void 0 : a.nodeColor) ?? this.theme.secondary,
+      edgeColor: (a == null ? void 0 : a.edgeColor) ?? this.theme.muted,
+      labelColor: (a == null ? void 0 : a.labelColor) ?? "#fff",
+      nodeRadius: a == null ? void 0 : a.nodeRadius,
+      edgeWidth: a == null ? void 0 : a.edgeWidth,
+      fadeIn: i
+    }, 10);
+  }
+  // ─── Layout helpers ──────────────────────────────────────────────────
+  /**
+   * Render a horizontal row of labeled boxes.
+   * Returns the box positions for follow-up arrows, etc.
+   */
+  boxRow(r, t) {
+    const a = (t == null ? void 0 : t.boxWidth) ?? 80, i = (t == null ? void 0 : t.boxHeight) ?? 40, n = (t == null ? void 0 : t.gap) ?? 12, l = (t == null ? void 0 : t.y) ?? 250, k = r.length * a + (r.length - 1) * n, I = (this._width - k) / 2;
+    t == null || t.fadeIn;
+    const C = r.map((m, h) => {
+      const g = I + h * (a + n);
+      return { x: g, y: l, w: a, h: i, cx: g + a / 2, cy: l + i / 2 };
+    }), A = r.map((m, h) => {
+      var D, T;
+      const g = C[h], E = ((D = t == null ? void 0 : t.colors) == null ? void 0 : D[h]) ?? this.theme.boxFill, O = ((T = t == null ? void 0 : t.strokeColors) == null ? void 0 : T[h]) ?? this.theme.boxStroke;
+      return {
+        type: "group",
+        children: [
+          {
+            type: "rect",
+            x: g.x,
+            y: g.y,
+            width: a,
+            height: i,
+            fill: E,
+            stroke: O,
+            strokeWidth: 1.5,
+            rx: 6
+          },
+          {
+            type: "text",
+            x: g.cx,
+            y: g.cy + 5,
+            content: m,
+            fontSize: (t == null ? void 0 : t.fontSize) ?? 13,
+            fill: (t == null ? void 0 : t.textColor) ?? this.theme.text,
+            textAnchor: "middle",
+            fontFamily: t == null ? void 0 : t.fontFamily
+          }
+        ]
+      };
+    });
+    return this.addAtCursor({
+      type: "stagger",
+      staggerDelay: 3,
+      children: A
+    }, 8 + r.length * 2), C;
+  }
+  /**
+   * Render a vertical stack of labeled boxes.
+   */
+  boxColumn(r, t) {
+    const a = (t == null ? void 0 : t.boxWidth) ?? 160, i = (t == null ? void 0 : t.boxHeight) ?? 36, n = (t == null ? void 0 : t.gap) ?? 8, l = (t == null ? void 0 : t.y) ?? 150, k = (t == null ? void 0 : t.x) ?? this.cx;
+    t == null || t.fadeIn;
+    const I = r.map((A, m) => {
+      const h = l + m * (i + n);
+      return { x: k - a / 2, y: h, w: a, h: i, cx: k, cy: h + i / 2 };
+    }), C = r.map((A, m) => {
+      var E, O;
+      const h = I[m], g = ((E = t == null ? void 0 : t.colors) == null ? void 0 : E[m]) ?? this.theme.boxFill;
+      return {
+        type: "group",
+        children: [
+          {
+            type: "rect",
+            x: h.x,
+            y: h.y,
+            width: a,
+            height: i,
+            fill: g,
+            stroke: (O = t == null ? void 0 : t.colors) != null && O[m] ? t.colors[m] : this.theme.boxStroke,
+            strokeWidth: 1.5,
+            rx: 6
+          },
+          {
+            type: "text",
+            x: h.cx,
+            y: h.cy + 5,
+            content: A,
+            fontSize: (t == null ? void 0 : t.fontSize) ?? 13,
+            fill: (t == null ? void 0 : t.textColor) ?? this.theme.text,
+            textAnchor: "middle"
+          }
+        ]
+      };
+    });
+    return this.addAtCursor({
+      type: "stagger",
+      staggerDelay: 3,
+      children: C
+    }, 8 + r.length * 2), I;
+  }
+  /**
+   * Draw arrows connecting sequential positions (e.g., output of boxRow/boxColumn).
+   */
+  connectDown(r, t) {
+    const a = [];
+    for (let i = 0; i < r.length - 1; i++) {
+      const n = r[i], l = r[i + 1];
+      a.push({
+        type: "arrow",
+        x1: n.cx,
+        y1: n.y + n.h + 2,
+        x2: l.cx,
+        y2: l.y - 2,
+        stroke: (t == null ? void 0 : t.color) ?? this.theme.muted,
+        strokeWidth: 1.5,
+        headSize: (t == null ? void 0 : t.headSize) ?? 6
+      });
+    }
+    return this.addAtCursor({
+      type: "stagger",
+      staggerDelay: 2,
+      children: a
+    }, 5 + r.length * 2);
+  }
+  /**
+   * Draw arrows between two rows of boxes (fan-out pattern).
+   */
+  connectRows(r, t, a) {
+    const i = [];
+    if (r.length === t.length)
+      for (let n = 0; n < r.length; n++)
+        i.push({
+          type: "arrow",
+          x1: r[n].cx,
+          y1: r[n].y + r[n].h + 2,
+          x2: t[n].cx,
+          y2: t[n].y - 2,
+          stroke: (a == null ? void 0 : a.color) ?? this.theme.muted,
+          strokeWidth: 1.5,
+          headSize: (a == null ? void 0 : a.headSize) ?? 6
+        });
+    return this.addAtCursor({
+      type: "fadeIn",
+      duration: 15,
+      children: i
+    }, 15);
+  }
+  // ─── Raw element access ──────────────────────────────────────────────
+  /** Add any raw ElementNode at the current cursor position */
+  add(r, t = 0) {
+    return this.addAtCursor(r, t);
+  }
+  /** Add a raw element at a specific frame (doesn't move cursor) */
+  addAt(r, t) {
+    return this.elements.push({
+      type: "sequence",
+      from: r,
+      children: [t]
+    }), this;
+  }
+  /** Add multiple raw elements simultaneously at current cursor */
+  addAll(r, t = 0) {
+    return this.addAtCursor({
+      type: "group",
+      children: r
+    }, t);
+  }
+  // ─── Internal ────────────────────────────────────────────────────────
+  addAtCursor(r, t) {
+    return this.elements.push({
+      type: "sequence",
+      from: this.cursor,
+      children: [r]
+    }), this.cursor += t, this;
+  }
+  /** Build the slide's player node with all timed elements */
+  _build() {
+    const r = Math.max(this.cursor + 60, 90);
+    return { elements: this.elements, durationInFrames: r };
+  }
+}
+const wt = {
+  background: "#0a0a1e",
+  title: "#e0e7ff",
+  subtitle: "#94a3b8",
+  primary: "#4fc3f7",
+  secondary: "#a78bfa",
+  tertiary: "#f472b6",
+  muted: "#64748b",
+  text: "#c8d6e5",
+  boxFill: "rgba(79,195,247,0.12)",
+  boxStroke: "#4fc3f7",
+  success: "#34d399",
+  warning: "#fbbf24",
+  error: "#f87171",
+  palette: ["#4fc3f7", "#a78bfa", "#f472b6", "#34d399", "#fbbf24", "#fb923c", "#6366f1", "#22d3ee"]
+}, At = {
+  background: "#f8fafc",
+  title: "#1e293b",
+  subtitle: "#64748b",
+  primary: "#2563eb",
+  secondary: "#7c3aed",
+  tertiary: "#db2777",
+  muted: "#94a3b8",
+  text: "#334155",
+  boxFill: "rgba(37,99,235,0.08)",
+  boxStroke: "#2563eb",
+  success: "#16a34a",
+  warning: "#d97706",
+  error: "#dc2626",
+  palette: ["#2563eb", "#7c3aed", "#db2777", "#16a34a", "#d97706", "#ea580c", "#4f46e5", "#0891b2"]
+};
+class kt {
+  constructor(r, t, a) {
+    this._slides = [], this._title = r, this._theme = t ?? wt, this._opts = {
+      width: 900,
+      height: 640,
+      fps: 30,
+      transition: "fade",
+      transitionDuration: 10,
+      showHud: !0,
+      showNotes: !0,
+      ...a
+    };
+  }
+  /** Add a slide */
+  slide(r, t, a) {
+    return this._slides.push({ title: r, build: t, notes: a == null ? void 0 : a.notes, background: a == null ? void 0 : a.background }), this;
+  }
+  /** Build the final ElucimDocument */
+  build() {
+    const r = this._slides.map((a) => {
+      const i = new vt(
+        this._theme,
+        this._opts.fps,
+        this._opts.width,
+        this._opts.height
+      );
+      a.build(i);
+      const { elements: n, durationInFrames: l } = i._build();
+      return {
+        type: "slide",
+        title: a.title,
+        notes: a.notes,
+        background: a.background,
+        children: [{
+          type: "player",
+          width: this._opts.width,
+          height: this._opts.height,
+          fps: this._opts.fps,
+          durationInFrames: l,
+          controls: !1,
+          loop: !1,
+          autoPlay: !0,
+          children: n
+        }]
+      };
+    });
+    return {
+      version: "1.0",
+      root: {
+        type: "presentation",
+        width: this._opts.width,
+        height: this._opts.height,
+        background: this._theme.background,
+        transition: this._opts.transition,
+        transitionDuration: this._opts.transitionDuration,
+        showHud: this._opts.showHud,
+        showNotes: this._opts.showNotes,
+        slides: r
+      }
+    };
+  }
+  /** Build and return as JSON string (for saving to file) */
+  toJSON(r = !0) {
+    return JSON.stringify(this.build(), null, r ? 2 : void 0);
+  }
+}
+function Et(e, r, t) {
+  return new kt(e, r, t);
+}
+export {
+  Ct as DslRenderer,
+  kt as PresentationBuilder,
+  vt as SlideBuilder,
+  Be as compileExpression,
+  Ve as compileVectorExpression,
+  wt as darkTheme,
+  At as lightTheme,
+  Et as presentation,
+  c as resolveEasing,
+  He as validate,
+  U as validateExpression
+};