@yagejs-addons/dialogue 0.1.0 → 0.2.0

package/dist/chunk-GJQKZCOL.js

@@ -0,0 +1,983 @@
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/core/vars.ts
+function materialize(storage) {
+  const out = {};
+  for (const [name, value] of storage.entries()) out[name] = value;
+  return out;
+}
+__name(materialize, "materialize");
+var MemoryVariableStorage = class {
+  static {
+    __name(this, "MemoryVariableStorage");
+  }
+  map = /* @__PURE__ */ new Map();
+  constructor(initial) {
+    if (initial) for (const [name, value] of Object.entries(initial)) this.map.set(name, value);
+  }
+  get(name) {
+    return this.map.get(name);
+  }
+  set(name, value) {
+    this.map.set(name, value);
+  }
+  has(name) {
+    return this.map.has(name);
+  }
+  entries() {
+    return this.map.entries();
+  }
+  /** Drop everything — host-controlled reset (variables persist across plays by default). */
+  clear() {
+    this.map.clear();
+  }
+};
+function cells(defs) {
+  const read = /* @__PURE__ */ __name((name) => {
+    const cell = defs[name];
+    return typeof cell === "function" ? cell() : cell.get();
+  }, "read");
+  return {
+    get(name) {
+      return Object.hasOwn(defs, name) ? read(name) : void 0;
+    },
+    set(name, value) {
+      if (!Object.hasOwn(defs, name)) {
+        throw new Error(`dialogue: cells() has no accessor for "${name}"`);
+      }
+      const cell = defs[name];
+      if (typeof cell === "function" || cell.set === void 0) {
+        throw new Error(
+          `dialogue: "${name}" is read-only (a cells getter without a setter)`
+        );
+      }
+      cell.set(value);
+    },
+    has(name) {
+      return Object.hasOwn(defs, name);
+    },
+    *entries() {
+      for (const name of Object.keys(defs)) yield [name, read(name)];
+    }
+  };
+}
+__name(cells, "cells");
+function compose(...storages) {
+  if (storages.length === 0) {
+    throw new Error("dialogue: compose() needs at least one storage");
+  }
+  const last = storages[storages.length - 1];
+  return {
+    get(name) {
+      for (const s of storages) if (s.has(name)) return s.get(name);
+      return void 0;
+    },
+    set(name, value) {
+      for (const s of storages) {
+        if (s.has(name)) {
+          s.set(name, value);
+          return;
+        }
+      }
+      last.set(name, value);
+    },
+    has(name) {
+      return storages.some((s) => s.has(name));
+    },
+    *entries() {
+      const seen = /* @__PURE__ */ new Set();
+      for (const s of storages) {
+        for (const [name, value] of s.entries()) {
+          if (!seen.has(name)) {
+            seen.add(name);
+            yield [name, value];
+          }
+        }
+      }
+    }
+  };
+}
+__name(compose, "compose");
+
+// src/core/expr.ts
+function createScope(storage, functions) {
+  return {
+    get: /* @__PURE__ */ __name((name) => storage.get(name) ?? null, "get"),
+    call: /* @__PURE__ */ __name((fn, args) => {
+      const f = functions[fn];
+      if (!f) throw new Error(`dialogue: no function "${fn}" is installed`);
+      return f(...args);
+    }, "call"),
+    vars: /* @__PURE__ */ __name(() => materialize(storage), "vars")
+  };
+}
+__name(createScope, "createScope");
+function holds(condition, scope) {
+  return condition === void 0 ? true : evalCondition(condition, scope);
+}
+__name(holds, "holds");
+function evalCondition(condition, scope) {
+  if (typeof condition === "function") return condition(scope.vars());
+  if (typeof condition === "string") return truthy(scope.get(condition));
+  if (isExpr(condition)) return truthy(evaluate(condition, scope));
+  const { var: name, op, value } = condition;
+  if (op === "truthy") return truthy(scope.get(name));
+  if (op === "falsy") return !truthy(scope.get(name));
+  return truthy(
+    evaluate(
+      {
+        kind: "binary",
+        op,
+        left: { kind: "varRef", name },
+        right: { kind: "literal", value }
+      },
+      scope
+    )
+  );
+}
+__name(evalCondition, "evalCondition");
+function evaluate(expr, scope) {
+  switch (expr.kind) {
+    case "literal":
+      return expr.value;
+    case "varRef":
+      return scope.get(expr.name);
+    case "group":
+      return evaluate(expr.expr, scope);
+    case "call":
+      return scope.call(
+        expr.fn,
+        (expr.args ?? []).map((a) => evaluate(a, scope))
+      );
+    case "unary":
+      return applyUnary(expr.op, evaluate(expr.operand, scope));
+    case "binary": {
+      const { op } = expr;
+      if (op === "and" || op === "&&") {
+        return truthy(evaluate(expr.left, scope)) && truthy(evaluate(expr.right, scope));
+      }
+      if (op === "or" || op === "||") {
+        return truthy(evaluate(expr.left, scope)) || truthy(evaluate(expr.right, scope));
+      }
+      return applyBinary(op, evaluate(expr.left, scope), evaluate(expr.right, scope));
+    }
+  }
+}
+__name(evaluate, "evaluate");
+function isExpr(value) {
+  return typeof value === "object" && value !== null && "kind" in value;
+}
+__name(isExpr, "isExpr");
+function truthy(value) {
+  return Boolean(value);
+}
+__name(truthy, "truthy");
+function applyUnary(op, v) {
+  switch (op) {
+    case "not":
+    case "!":
+      return !truthy(v);
+    case "-":
+      return -num(v);
+  }
+}
+__name(applyUnary, "applyUnary");
+function applyBinary(op, l, r) {
+  switch (op) {
+    case "==":
+    case "eq":
+    case "is":
+      return l === r;
+    case "!=":
+    case "neq":
+      return l !== r;
+    case ">":
+    case "gt":
+      return num(l) > num(r);
+    case "<":
+    case "lt":
+      return num(l) < num(r);
+    case ">=":
+    case "gte":
+      return num(l) >= num(r);
+    case "<=":
+    case "lte":
+      return num(l) <= num(r);
+    // `and`/`or` (and `&&`/`||`) are short-circuited in evaluate() and never
+    // reach here; `xor` needs both operands, so it stays.
+    case "xor":
+    case "^":
+      return truthy(l) !== truthy(r);
+    case "+":
+      return typeof l === "string" || typeof r === "string" ? `${str(l)}${str(r)}` : num(l) + num(r);
+    case "-":
+      return num(l) - num(r);
+    case "*":
+      return num(l) * num(r);
+    case "/":
+      return num(l) / num(r);
+    case "%":
+      return num(l) % num(r);
+    default:
+      throw new Error(`dialogue: unknown binary operator "${op}"`);
+  }
+}
+__name(applyBinary, "applyBinary");
+function num(v) {
+  return typeof v === "number" ? v : Number(v);
+}
+__name(num, "num");
+function str(v) {
+  return v === null ? "" : String(v);
+}
+__name(str, "str");
+
+// src/core/i18n.ts
+var IdentityI18n = class {
+  constructor(locale = "en") {
+    this.locale = locale;
+  }
+  locale;
+  static {
+    __name(this, "IdentityI18n");
+  }
+  t(_key, fallback, params) {
+    return params ? interpolate(fallback, params) : fallback;
+  }
+};
+var TOKEN = /\{(\w+)\}/g;
+function interpolate(text, params) {
+  return text.replace(
+    TOKEN,
+    (whole, name) => Object.hasOwn(params, name) ? String(params[name]) : whole
+  );
+}
+__name(interpolate, "interpolate");
+function tokensIn(text) {
+  const names = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(TOKEN)) names.add(m[1]);
+  return [...names];
+}
+__name(tokensIn, "tokensIn");
+
+// src/core/validate.ts
+var DialogueScriptError = class extends Error {
+  static {
+    __name(this, "DialogueScriptError");
+  }
+};
+var DialoguePlayError = class extends Error {
+  static {
+    __name(this, "DialoguePlayError");
+  }
+};
+var NUMERIC_OPS = /* @__PURE__ */ new Set([">", ">=", "<", "<="]);
+var NUMERIC_EXPR_OPS = /* @__PURE__ */ new Set([
+  ">",
+  "<",
+  ">=",
+  "<=",
+  "gt",
+  "lt",
+  "gte",
+  "lte",
+  "-",
+  "*",
+  "/",
+  "%"
+]);
+var BUILTIN_COMMANDS = /* @__PURE__ */ new Set(["set"]);
+function operandRequirement(op) {
+  if (op === "+") return "numberOrString";
+  return NUMERIC_EXPR_OPS.has(op) ? "number" : null;
+}
+__name(operandRequirement, "operandRequirement");
+var analysisCache = /* @__PURE__ */ new WeakMap();
+function analyzeScript(script) {
+  const cached = analysisCache.get(script);
+  if (cached) return cached;
+  const analysis = computeAnalysis(script);
+  analysisCache.set(script, analysis);
+  return analysis;
+}
+__name(analyzeScript, "analyzeScript");
+function computeAnalysis(script) {
+  const declaredTypes = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(script.declare ?? {})) {
+    declaredTypes.set(name, valueType(value));
+  }
+  const readVars = /* @__PURE__ */ new Set();
+  const setTargets = /* @__PURE__ */ new Set();
+  const calledFunctions = /* @__PURE__ */ new Set();
+  const commandTypes = /* @__PURE__ */ new Set();
+  const collectExpr = /* @__PURE__ */ __name((expr, where) => {
+    switch (expr.kind) {
+      case "literal":
+        return;
+      case "varRef":
+        readVars.add(expr.name);
+        return;
+      case "call":
+        calledFunctions.add(expr.fn);
+        for (const arg of expr.args ?? []) collectExpr(arg, where);
+        return;
+      case "group":
+        collectExpr(expr.expr, where);
+        return;
+      case "unary":
+        collectExpr(expr.operand, where);
+        return;
+      case "binary":
+        collectExpr(expr.left, where);
+        collectExpr(expr.right, where);
+        checkBinaryOperands(expr, where);
+        return;
+    }
+  }, "collectExpr");
+  const checkBinaryOperands = /* @__PURE__ */ __name((expr, where) => {
+    const req = operandRequirement(expr.op);
+    if (!req) return;
+    const expected = req === "numberOrString" ? "a number or string" : "a number";
+    for (const operand of [expr.left, expr.right]) {
+      if (operand.kind === "literal") {
+        const t = valueType(operand.value);
+        if (t === "number" || req === "numberOrString" && t === "string") continue;
+        throw new DialogueScriptError(
+          `${where}: operator "${expr.op}" expects ${expected}, got ${t}`
+        );
+      }
+      if (operand.kind === "varRef" && req === "number") {
+        const t = declaredTypes.get(operand.name);
+        if (t !== void 0 && t !== "number" && t !== "null") {
+          throw new DialogueScriptError(
+            `${where}: operator "${expr.op}" needs a number; "${operand.name}" is ${t}`
+          );
+        }
+      }
+    }
+  }, "checkBinaryOperands");
+  const checkTokens = /* @__PURE__ */ __name((text) => {
+    if (!text) return;
+    for (const token of tokensIn(text)) readVars.add(token);
+  }, "checkTokens");
+  const checkCondition = /* @__PURE__ */ __name((condition, where) => {
+    if (condition === void 0 || typeof condition === "function") return;
+    if (typeof condition === "string") {
+      readVars.add(condition);
+      return;
+    }
+    if (isExpr(condition)) {
+      collectExpr(condition, where);
+      return;
+    }
+    readVars.add(condition.var);
+    if (NUMERIC_OPS.has(condition.op)) {
+      const t = declaredTypes.get(condition.var);
+      if (t !== void 0 && t !== "number" && t !== "null") {
+        throw new DialogueScriptError(
+          `${where}: operator "${condition.op}" needs a number; "${condition.var}" is ${t}`
+        );
+      }
+      if (typeof condition.value !== "number") {
+        throw new DialogueScriptError(
+          `${where}: operator "${condition.op}" compares against a number, got ${typeof condition.value}`
+        );
+      }
+    }
+  }, "checkCondition");
+  const checkSetLiteralType = /* @__PURE__ */ __name((target, value, where) => {
+    const declared = declaredTypes.get(target);
+    if (declared !== void 0 && declared !== "null" && value !== null && typeof value !== declared) {
+      throw new DialogueScriptError(
+        `${where}: set "${target}" expects ${declared}, got ${typeof value}`
+      );
+    }
+  }, "checkSetLiteralType");
+  const checkCommands = /* @__PURE__ */ __name((commands, where) => {
+    for (const cmd of commands ?? []) {
+      if (cmd.type === "set") {
+        const target = cmd["var"];
+        if (typeof target !== "string") {
+          throw new DialogueScriptError(`${where}: set command has no string "var"`);
+        }
+        setTargets.add(target);
+        const value = cmd["value"];
+        if (value === void 0) {
+          throw new DialogueScriptError(`${where}: set "${target}" has no value`);
+        }
+        if (isExpr(value)) {
+          collectExpr(value, where);
+          if (value.kind === "literal") checkSetLiteralType(target, value.value, where);
+        } else {
+          checkSetLiteralType(target, value, where);
+        }
+        continue;
+      }
+      if (!BUILTIN_COMMANDS.has(cmd.type)) commandTypes.add(cmd.type);
+    }
+  }, "checkCommands");
+  for (const speaker of Object.values(script.speakers ?? {})) {
+    checkTokens(speaker.name);
+  }
+  for (const node of Object.values(script.nodes)) {
+    const where = `node "${node.id}"`;
+    for (const step of node.steps) {
+      switch (step.kind) {
+        case "say": {
+          const s = step;
+          checkTokens(s.text);
+          checkCommands(s.commands, `${where} say`);
+          break;
+        }
+        case "choice": {
+          const c = step;
+          checkTokens(c.text);
+          for (const opt of c.options) {
+            checkTokens(opt.text);
+            checkTokens(opt.disabledReason);
+            checkCondition(opt.condition, `${where} choice option "${opt.text}"`);
+            checkCommands(opt.commands, `${where} choice option "${opt.text}"`);
+          }
+          break;
+        }
+        case "command": {
+          const cs = step;
+          checkCommands(cs.commands, `${where} command`);
+          checkCondition(cs.condition, `${where} command`);
+          break;
+        }
+        default:
+          break;
+      }
+    }
+  }
+  return { declaredTypes, readVars, setTargets, calledFunctions, commandTypes };
+}
+__name(computeAnalysis, "computeAnalysis");
+function validatePlay(analysis, env) {
+  for (const [name, type] of analysis.declaredTypes) {
+    if (type === "null" || !env.storage.has(name)) continue;
+    const current = env.storage.get(name);
+    if (current !== void 0 && current !== null && typeof current !== type) {
+      throw new DialoguePlayError(
+        `declared default for "${name}" is ${type} but storage already holds ${typeof current}`
+      );
+    }
+  }
+  for (const name of analysis.readVars) {
+    if (!analysis.declaredTypes.has(name) && !env.storage.has(name) && !analysis.setTargets.has(name)) {
+      throw new DialoguePlayError(
+        `script reads "${name}" but nothing provides it (no declared default, no storage value, no \`set\`; for an argument read use a function call)`
+      );
+    }
+  }
+  for (const fn of analysis.calledFunctions) {
+    if (!Object.hasOwn(env.functions, fn)) {
+      throw new DialoguePlayError(
+        `script calls function "${fn}" but no such function is installed`
+      );
+    }
+  }
+  for (const target of analysis.setTargets) {
+    if (Object.hasOwn(env.functions, target)) {
+      throw new DialoguePlayError(
+        `set target "${target}" is a function (read-only); functions cannot be assigned`
+      );
+    }
+  }
+  if (env.fallbackCommand === void 0) {
+    const unhandled = [...analysis.commandTypes].filter((t) => !Object.hasOwn(env.commands, t));
+    if (unhandled.length > 0) {
+      throw new DialoguePlayError(
+        `no handler for command type(s): ${unhandled.join(", ")} (add to commands, or set fallbackCommand)`
+      );
+    }
+  }
+}
+__name(validatePlay, "validatePlay");
+function valueType(value) {
+  if (value === null) return "null";
+  if (typeof value === "string") return "string";
+  if (typeof value === "number") return "number";
+  return "boolean";
+}
+__name(valueType, "valueType");
+
+// src/core/expr-parse.ts
+var DialogueExprError = class extends DialogueScriptError {
+  static {
+    __name(this, "DialogueExprError");
+  }
+  line;
+  col;
+  constructor(message, line, col) {
+    super(`${message} (at ${line}:${col})`);
+    this.name = "DialogueExprError";
+    this.line = line;
+    this.col = col;
+  }
+};
+function parseExpr(src) {
+  const tokens = tokenize(src);
+  return new Parser(tokens).parse();
+}
+__name(parseExpr, "parseExpr");
+var KEYWORDS = {
+  and: "&&",
+  or: "||",
+  not: "!",
+  xor: "xor",
+  is: "==",
+  eq: "==",
+  neq: "!=",
+  gt: ">",
+  lt: "<",
+  gte: ">=",
+  lte: "<=",
+  true: "true",
+  false: "false",
+  null: "null"
+};
+var isDigit = /* @__PURE__ */ __name((c) => c >= "0" && c <= "9", "isDigit");
+var isIdentStart = /* @__PURE__ */ __name((c) => c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c === "_" || c === "$", "isIdentStart");
+var isIdentPart = /* @__PURE__ */ __name((c) => isIdentStart(c) || isDigit(c) || c === ".", "isIdentPart");
+function tokenize(src) {
+  const tokens = [];
+  let i = 0;
+  let line = 1;
+  let col = 1;
+  const advance = /* @__PURE__ */ __name((n = 1) => {
+    for (let k = 0; k < n; k++) {
+      if (src[i] === "\n") {
+        line++;
+        col = 1;
+      } else {
+        col++;
+      }
+      i++;
+    }
+  }, "advance");
+  while (i < src.length) {
+    const c = src[i];
+    if (c === " " || c === "	" || c === "\n" || c === "\r") {
+      advance();
+      continue;
+    }
+    const startLine = line;
+    const startCol = col;
+    if (isDigit(c)) {
+      let text = "";
+      while (i < src.length && isDigit(src[i])) {
+        text += src[i];
+        advance();
+      }
+      if (src[i] === "." && isDigit(src[i + 1] ?? "")) {
+        text += ".";
+        advance();
+        while (i < src.length && isDigit(src[i])) {
+          text += src[i];
+          advance();
+        }
+      }
+      tokens.push({ kind: "number", value: Number(text), line: startLine, col: startCol });
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      const quote = c;
+      advance();
+      let text = "";
+      while (i < src.length && src[i] !== quote) {
+        if (src[i] === "\\") {
+          advance();
+          if (i >= src.length) break;
+          text += unescape(src[i]);
+        } else {
+          text += src[i];
+        }
+        advance();
+      }
+      if (src[i] !== quote) {
+        throw new DialogueExprError("unterminated string literal", startLine, startCol);
+      }
+      advance();
+      tokens.push({ kind: "string", value: text, line: startLine, col: startCol });
+      continue;
+    }
+    if (isIdentStart(c)) {
+      let text = "";
+      while (i < src.length && isIdentPart(src[i])) {
+        text += src[i];
+        advance();
+      }
+      const keyword = KEYWORDS[text];
+      if (keyword === void 0) {
+        tokens.push({ kind: "ident", value: text, line: startLine, col: startCol });
+      } else if (keyword === "true" || keyword === "false" || keyword === "null") {
+        const value = keyword === "true" ? true : keyword === "false" ? false : null;
+        tokens.push({ kind: keyword, value, line: startLine, col: startCol });
+      } else {
+        tokens.push({ kind: keyword, line: startLine, col: startCol });
+      }
+      continue;
+    }
+    const two = src.slice(i, i + 2);
+    if (two === "&&" || two === "||" || two === "==" || two === "!=" || two === ">=" || two === "<=") {
+      tokens.push({ kind: two, line: startLine, col: startCol });
+      advance(2);
+      continue;
+    }
+    if (c === ">" || c === "<" || c === "!" || c === "+" || c === "-" || c === "(" || c === ")" || c === ",") {
+      tokens.push({ kind: c, line: startLine, col: startCol });
+      advance();
+      continue;
+    }
+    throw new DialogueExprError(`unexpected character "${c}"`, startLine, startCol);
+  }
+  tokens.push({ kind: "eof", line, col });
+  return tokens;
+}
+__name(tokenize, "tokenize");
+function unescape(c) {
+  switch (c) {
+    case "n":
+      return "\n";
+    case "t":
+      return "	";
+    case "r":
+      return "\r";
+    default:
+      return c;
+  }
+}
+__name(unescape, "unescape");
+var INFIX_BP = {
+  "||": 1,
+  "&&": 2,
+  "==": 3,
+  "!=": 3,
+  ">": 3,
+  "<": 3,
+  ">=": 3,
+  "<=": 3,
+  "+": 4,
+  "-": 4
+};
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  tokens;
+  static {
+    __name(this, "Parser");
+  }
+  pos = 0;
+  parse() {
+    const expr = this.parseBinary(0);
+    const t = this.peek();
+    if (t.kind !== "eof") {
+      throw new DialogueExprError(`unexpected trailing token "${describe(t)}"`, t.line, t.col);
+    }
+    return expr;
+  }
+  parseBinary(minBp) {
+    let left = this.parseUnary();
+    for (; ; ) {
+      const t = this.peek();
+      const bp = INFIX_BP[t.kind];
+      if (bp === void 0 || bp < minBp) break;
+      this.next();
+      const right = this.parseBinary(bp + 1);
+      left = { kind: "binary", op: t.kind, left, right };
+    }
+    return left;
+  }
+  parseUnary() {
+    const t = this.peek();
+    if (t.kind === "!" || t.kind === "-") {
+      this.next();
+      const operand = this.parseUnary();
+      return { kind: "unary", op: t.kind === "!" ? "!" : "-", operand };
+    }
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    const t = this.peek();
+    switch (t.kind) {
+      case "number":
+      case "string":
+        this.next();
+        return { kind: "literal", value: t.value };
+      case "true":
+      case "false":
+      case "null":
+        this.next();
+        return { kind: "literal", value: t.value };
+      case "ident": {
+        this.next();
+        const name = t.value;
+        if (this.peek().kind === "(") {
+          this.next();
+          const args = this.parseArgs();
+          return { kind: "call", fn: name, args };
+        }
+        return { kind: "varRef", name };
+      }
+      case "(": {
+        this.next();
+        const inner = this.parseBinary(0);
+        this.expect(")");
+        return { kind: "group", expr: inner };
+      }
+      default:
+        throw new DialogueExprError(`unexpected ${describe(t)}`, t.line, t.col);
+    }
+  }
+  /** Parse a comma-separated argument list; the opening `(` is already consumed. */
+  parseArgs() {
+    const args = [];
+    if (this.peek().kind === ")") {
+      this.next();
+      return args;
+    }
+    for (; ; ) {
+      args.push(this.parseBinary(0));
+      const t = this.peek();
+      if (t.kind === ",") {
+        this.next();
+        continue;
+      }
+      if (t.kind === ")") {
+        this.next();
+        return args;
+      }
+      throw new DialogueExprError(`expected "," or ")" in argument list, got ${describe(t)}`, t.line, t.col);
+    }
+  }
+  expect(kind) {
+    const t = this.peek();
+    if (t.kind !== kind) {
+      throw new DialogueExprError(`expected "${kind}", got ${describe(t)}`, t.line, t.col);
+    }
+    this.next();
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  next() {
+    return this.tokens[this.pos++];
+  }
+};
+function describe(t) {
+  if (t.kind === "eof") return "end of input";
+  if (t.kind === "ident") return `"${String(t.value)}"`;
+  if (t.kind === "string") return `string "${String(t.value)}"`;
+  if (t.kind === "number") return `number ${String(t.value)}`;
+  return `"${t.kind}"`;
+}
+__name(describe, "describe");
+
+// src/core/formats/canonical.ts
+function loadScript(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new DialogueScriptError("script must be an object");
+  }
+  if (!raw.id) throw new DialogueScriptError("script.id is required");
+  if (!raw.nodes || typeof raw.nodes !== "object") {
+    throw new DialogueScriptError(`script "${raw.id}" has no nodes`);
+  }
+  const nodeIds = Object.keys(raw.nodes);
+  if (nodeIds.length === 0) {
+    throw new DialogueScriptError(`script "${raw.id}" has no nodes`);
+  }
+  const start = raw.start ?? nodeIds[0];
+  if (!raw.nodes[start]) {
+    throw new DialogueScriptError(`start node "${start}" not found in "${raw.id}"`);
+  }
+  for (const [key, speaker] of Object.entries(raw.speakers ?? {})) {
+    if (speaker.id !== key) {
+      throw new DialogueScriptError(
+        `speaker key "${key}" != speaker.id "${speaker.id}"`
+      );
+    }
+  }
+  for (const [id, node] of Object.entries(raw.nodes)) {
+    validateNode(raw, id, node);
+  }
+  const resolved = resolveExpressions(raw);
+  const script = Object.freeze({ ...resolved, start });
+  analyzeScript(script);
+  return script;
+}
+__name(loadScript, "loadScript");
+function validateNode(script, id, node) {
+  if (node.id !== id) {
+    throw new DialogueScriptError(`node key "${id}" != node.id "${node.id}"`);
+  }
+  if (!Array.isArray(node.steps) || node.steps.length === 0) {
+    throw new DialogueScriptError(`node "${id}" has no steps`);
+  }
+  for (const step of node.steps) validateStep(script, id, step);
+}
+__name(validateNode, "validateNode");
+function validateStep(script, nodeId, step) {
+  const targetExists = /* @__PURE__ */ __name((t) => {
+    if (t !== void 0 && !script.nodes[t]) {
+      throw new DialogueScriptError(
+        `node "${nodeId}": jump target "${t}" does not exist`
+      );
+    }
+  }, "targetExists");
+  const speakerExists = /* @__PURE__ */ __name((s) => {
+    if (s !== void 0 && !script.speakers?.[s]) {
+      throw new DialogueScriptError(
+        `node "${nodeId}": speaker "${s}" is not in script.speakers`
+      );
+    }
+  }, "speakerExists");
+  switch (step.kind) {
+    case "say":
+      if (typeof step.text !== "string") {
+        throw new DialogueScriptError(`node "${nodeId}": say.text must be a string`);
+      }
+      speakerExists(step.speaker);
+      break;
+    case "choice":
+      if (!Array.isArray(step.options) || step.options.length === 0) {
+        throw new DialogueScriptError(`node "${nodeId}": choice has no options`);
+      }
+      speakerExists(step.speaker);
+      for (const opt of step.options) targetExists(opt.target);
+      break;
+    case "command":
+      targetExists(step.target);
+      break;
+    case "goto":
+      if (step.target === void 0) {
+        throw new DialogueScriptError(`node "${nodeId}": goto has no target`);
+      }
+      targetExists(step.target);
+      break;
+    case "end":
+      break;
+    default:
+      throw new DialogueScriptError(
+        `node "${nodeId}": unknown step kind "${step.kind}"`
+      );
+  }
+}
+__name(validateStep, "validateStep");
+function resolveExpressions(script) {
+  let nodesChanged = false;
+  const nodes = {};
+  for (const [id, node] of Object.entries(script.nodes)) {
+    let stepsChanged = false;
+    const steps = node.steps.map((step) => {
+      const next = resolveStep(step);
+      if (next !== step) stepsChanged = true;
+      return next;
+    });
+    if (stepsChanged) {
+      nodes[id] = { ...node, steps };
+      nodesChanged = true;
+    } else {
+      nodes[id] = node;
+    }
+  }
+  return nodesChanged ? { ...script, nodes } : script;
+}
+__name(resolveExpressions, "resolveExpressions");
+function resolveStep(step) {
+  switch (step.kind) {
+    case "say":
+      return resolveSay(step);
+    case "choice":
+      return resolveChoice(step);
+    case "command":
+      return resolveCommandStep(step);
+    case "goto":
+    case "end":
+      return step;
+  }
+}
+__name(resolveStep, "resolveStep");
+function resolveSay(step) {
+  const commands = rewriteCommands(step.commands);
+  return commands ? { ...step, commands } : step;
+}
+__name(resolveSay, "resolveSay");
+function resolveCommandStep(step) {
+  const condition = rewriteCondition(step.condition);
+  const commands = rewriteCommands(step.commands);
+  if (!condition && !commands) return step;
+  return {
+    ...step,
+    ...condition ? { condition } : {},
+    ...commands ? { commands } : {}
+  };
+}
+__name(resolveCommandStep, "resolveCommandStep");
+function resolveChoice(step) {
+  let changed = false;
+  const options = step.options.map((opt) => {
+    const next = rewriteOption(opt);
+    if (next) {
+      changed = true;
+      return next;
+    }
+    return opt;
+  });
+  return changed ? { ...step, options } : step;
+}
+__name(resolveChoice, "resolveChoice");
+function rewriteOption(opt) {
+  const condition = rewriteCondition(opt.condition);
+  const commands = rewriteCommands(opt.commands);
+  if (!condition && !commands) return void 0;
+  return {
+    ...opt,
+    ...condition ? { condition } : {},
+    ...commands ? { commands } : {}
+  };
+}
+__name(rewriteOption, "rewriteOption");
+function rewriteCondition(condition) {
+  return typeof condition === "string" ? parseExpr(condition) : void 0;
+}
+__name(rewriteCondition, "rewriteCondition");
+function rewriteCommands(commands) {
+  if (!commands) return void 0;
+  let changed = false;
+  const out = commands.map((cmd) => {
+    if (cmd.type === "set" && typeof cmd.value === "string") {
+      changed = true;
+      return { ...cmd, value: parseExpr(cmd.value) };
+    }
+    return cmd;
+  });
+  return changed ? out : void 0;
+}
+__name(rewriteCommands, "rewriteCommands");
+
+export {
+  materialize,
+  MemoryVariableStorage,
+  cells,
+  compose,
+  createScope,
+  holds,
+  evalCondition,
+  evaluate,
+  isExpr,
+  IdentityI18n,
+  interpolate,
+  DialogueScriptError,
+  DialoguePlayError,
+  analyzeScript,
+  validatePlay,
+  DialogueExprError,
+  parseExpr,
+  loadScript
+};
+//# sourceMappingURL=chunk-GJQKZCOL.js.map