@cimplify/cli 0.15.3 → 0.16.0

package/dist/chunk-JKECUAAV.mjs

@@ -0,0 +1,2169 @@
+#!/usr/bin/env node
+import { diagnostic } from './chunk-SGT5IJVW.mjs';
+import { gunzipSync, constants } from 'zlib';
+import ts from 'typescript';
+
+var NATIVE_MAGIC = [
+  { bytes: [127, 69, 76, 70], what: "an ELF native binary" },
+  { bytes: [254, 237, 250, 206], what: "a Mach-O native binary" },
+  { bytes: [254, 237, 250, 207], what: "a Mach-O native binary" },
+  { bytes: [206, 250, 237, 254], what: "a Mach-O native binary" },
+  { bytes: [207, 250, 237, 254], what: "a Mach-O native binary" },
+  { bytes: [202, 254, 186, 190], what: "a universal binary or Java class file" },
+  { bytes: [77, 90], what: "a Windows executable" },
+  { bytes: [100, 101, 120, 10], what: "Android bytecode" },
+  { bytes: [198, 31, 188, 3, 193, 3, 25, 31], what: "Hermes bytecode" },
+  { bytes: [71, 68, 80, 67], what: "an exported Godot pack" }
+];
+var ARCHIVE_MAGIC = [
+  { bytes: [80, 75, 3, 4], what: "a zip archive" },
+  { bytes: [31, 139], what: "a gzip archive" },
+  { bytes: [66, 90, 104], what: "a bzip2 archive" },
+  { bytes: [253, 55, 122, 88, 90, 0], what: "an xz archive" },
+  { bytes: [55, 122, 188, 175, 39, 28], what: "a 7z archive" },
+  { bytes: [40, 181, 47, 253], what: "a zstd archive" }
+];
+var WASM_MAGIC = [0, 97, 115, 109];
+var GZIP_MAGIC = [31, 139];
+var SPZ_MAGIC = [78, 71, 83, 80];
+var SPZ_EXTENSION = ".spz";
+var SPZ_PROBE_BYTES = 4096;
+var REFUSED_EXTENSIONS = {
+  ".node": "a native addon",
+  ".so": "a native library",
+  ".dylib": "a native library",
+  ".dll": "a native library",
+  ".exe": "a native executable",
+  ".a": "a native archive",
+  ".o": "a native object file",
+  ".lib": "a native library",
+  ".jsc": "compiled JavaScript bytecode",
+  ".hbc": "Hermes bytecode",
+  ".pck": "an exported Godot pack",
+  ".class": "Java bytecode",
+  ".jar": "a Java archive",
+  ".dex": "Android bytecode",
+  ".pyc": "Python bytecode",
+  ".bin": "an opaque binary",
+  ".zip": "an archive",
+  ".tar": "an archive",
+  ".tgz": "an archive",
+  ".gz": "an archive"
+};
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".mts", ".cts", ".tsx", ".js", ".mjs", ".cjs", ".jsx"]);
+var MAX_LINE_CHARS = 1e3;
+var DENSE_FILE_BYTES = 4096;
+var MIN_WHITESPACE_RATIO = 0.06;
+var MAX_HEX_IDENTIFIERS = 4;
+var MAX_ESCAPES = 64;
+var MAX_STRING_LITERAL_CHARS = 8192;
+var MAX_CHAR_CODE_ARGS = 24;
+var HEX_IDENTIFIER = /\b_0x[0-9a-fA-F]{4,}\b/g;
+var ESCAPE_SEQUENCE = /\\x[0-9a-fA-F]{2}|\\u[0-9a-fA-F]{4}/g;
+var CHAR_CODE_CALL = /String\.fromCharCode\(([^)]*)\)/g;
+var BUNDLE_SIGNATURES = ["__webpack_require__", "parcelRequire", "__vite_ssr_import__", "System.register("];
+var LONG_STRING = new RegExp(`(["'\`])[A-Za-z0-9+/=_-]{${MAX_STRING_LITERAL_CHARS},}\\1`);
+var CH_LF = 10;
+var CH_SPACE = 32;
+var CH_TAB = 9;
+var CH_CR = 13;
+function extensionOf(filePath) {
+  const slash = filePath.lastIndexOf("/");
+  const dot = filePath.lastIndexOf(".");
+  return dot > slash + 1 ? filePath.slice(dot).toLowerCase() : "";
+}
+function isCodePath(filePath) {
+  return CODE_EXTENSIONS.has(extensionOf(filePath));
+}
+function startsWith(bytes, magic) {
+  if (bytes.length < magic.length) return false;
+  for (let i = 0; i < magic.length; i++) if (bytes[i] !== magic[i]) return false;
+  return true;
+}
+function isWasm(file) {
+  return extensionOf(file.path) === ".wasm" || startsWith(file.bytes, WASM_MAGIC);
+}
+function isGzipSpz(file) {
+  if (extensionOf(file.path) !== SPZ_EXTENSION || !startsWith(file.bytes, GZIP_MAGIC)) return false;
+  try {
+    const head = gunzipSync(file.bytes.subarray(0, SPZ_PROBE_BYTES), { finishFlush: constants.Z_SYNC_FLUSH });
+    return startsWith(head, SPZ_MAGIC);
+  } catch {
+    return false;
+  }
+}
+function binaryRefusal(file) {
+  const byExtension = REFUSED_EXTENSIONS[extensionOf(file.path)];
+  if (byExtension !== void 0) return byExtension;
+  for (const m of NATIVE_MAGIC) if (startsWith(file.bytes, m.bytes)) return m.what;
+  if (isGzipSpz(file)) return null;
+  for (const m of ARCHIVE_MAGIC) if (startsWith(file.bytes, m.bytes)) return m.what;
+  return null;
+}
+function denseShape(bytes) {
+  let longest = 0;
+  let longestLineNumber = 1;
+  let current = 0;
+  let line = 1;
+  let whitespace = 0;
+  for (let i = 0; i < bytes.length; i++) {
+    const c = bytes[i];
+    if (c === CH_LF) {
+      if (current > longest) {
+        longest = current;
+        longestLineNumber = line;
+      }
+      current = 0;
+      line++;
+      whitespace++;
+      continue;
+    }
+    if (c === CH_SPACE || c === CH_TAB || c === CH_CR) whitespace++;
+    current++;
+  }
+  if (current > longest) {
+    longest = current;
+    longestLineNumber = line;
+  }
+  return { longestLine: longest, longestLineNumber, whitespace };
+}
+function countMatches(text, pattern) {
+  pattern.lastIndex = 0;
+  let n = 0;
+  while (pattern.exec(text) !== null) n++;
+  return n;
+}
+function obfuscationReason(text) {
+  for (const signature of BUNDLE_SIGNATURES) {
+    if (text.includes(signature)) return `it is bundler output (${signature}); upload the original source`;
+  }
+  if (countMatches(text, HEX_IDENTIFIER) > MAX_HEX_IDENTIFIERS) return "it uses machine-generated _0x identifiers";
+  if (countMatches(text, ESCAPE_SEQUENCE) > MAX_ESCAPES) return "it hides text behind escape sequences";
+  CHAR_CODE_CALL.lastIndex = 0;
+  for (let m = CHAR_CODE_CALL.exec(text); m !== null; m = CHAR_CODE_CALL.exec(text)) {
+    if (m[1].split(",").length > MAX_CHAR_CODE_ARGS) return "it builds strings from character codes";
+  }
+  if (LONG_STRING.test(text)) return "it embeds an encoded payload in a string literal";
+  return null;
+}
+function checkRefusals(files, wasm) {
+  const out = [];
+  for (const file of files) {
+    if (isWasm(file)) {
+      if (!wasm.approved(file.digest)) {
+        out.push(
+          diagnostic(
+            "refusal.wasm",
+            `WebAssembly module ${file.digest} is not in the approved module registry; WASM is admitted only when Cimplify built it from reviewed source`,
+            file.path,
+            null
+          )
+        );
+      }
+      continue;
+    }
+    const binary = binaryRefusal(file);
+    if (binary !== null) {
+      out.push(diagnostic("refusal.binary", `this file is ${binary}; upload source, never binaries or bytecode`, file.path, null));
+      continue;
+    }
+    if (!isCodePath(file.path)) continue;
+    const shape = denseShape(file.bytes);
+    if (shape.longestLine > MAX_LINE_CHARS) {
+      out.push(
+        diagnostic(
+          "refusal.minified",
+          `line ${shape.longestLineNumber} is ${shape.longestLine} characters; minified code is refused, upload the original source`,
+          file.path,
+          { line: shape.longestLineNumber, column: 1 }
+        )
+      );
+      continue;
+    }
+    if (file.bytes.length > DENSE_FILE_BYTES && shape.whitespace / file.bytes.length < MIN_WHITESPACE_RATIO) {
+      out.push(diagnostic("refusal.minified", "this file has almost no whitespace; minified code is refused", file.path, null));
+      continue;
+    }
+    const reason = obfuscationReason(file.bytes.toString("utf8"));
+    if (reason !== null) out.push(diagnostic("refusal.obfuscated", `obfuscated code is refused: ${reason}`, file.path, null));
+  }
+  return out;
+}
+
+// src/interactives/build/assets.ts
+var KIND_BY_EXTENSION = {
+  ".png": "texture",
+  ".jpg": "texture",
+  ".jpeg": "texture",
+  ".webp": "texture",
+  ".avif": "texture",
+  ".ktx2": "texture",
+  ".basis": "texture",
+  ".gltf": "mesh",
+  ".glb": "mesh",
+  ".ogg": "audio",
+  ".opus": "audio",
+  ".mp3": "audio",
+  ".m4a": "audio",
+  ".aac": "audio",
+  ".wav": "audio",
+  ".ttf": "font",
+  ".otf": "font",
+  ".woff": "font",
+  ".woff2": "font",
+  ".wasm": "wasm"
+};
+function assetKind(path) {
+  return KIND_BY_EXTENSION[extensionOf(path)] ?? "data";
+}
+var PASSTHROUGH_CONVERTER = {
+  id: "passthrough@1",
+  convert(path, bytes) {
+    return { path, kind: assetKind(path), bytes };
+  }
+};
+var GLOB_SPECIAL = /[.+^${}()|[\]\\]/g;
+function compileGlob(pattern) {
+  let out = "^";
+  for (let i = 0; i < pattern.length; i++) {
+    const c = pattern[i];
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        i++;
+        if (pattern[i + 1] === "/") {
+          i++;
+          out += "(?:[^/]+/)*";
+        } else {
+          out += ".*";
+        }
+      } else {
+        out += "[^/]*";
+      }
+    } else if (c === "?") {
+      out += "[^/]";
+    } else {
+      out += c.replace(GLOB_SPECIAL, "\\$&");
+    }
+  }
+  return new RegExp(`${out}$`);
+}
+function compileGroups(groups) {
+  return { groups, matchers: groups.map((g) => g.assets.map(compileGlob)) };
+}
+function groupOf(compiled, path) {
+  for (let g = 0; g < compiled.matchers.length; g++) {
+    const patterns = compiled.matchers[g];
+    for (let p = 0; p < patterns.length; p++) if (patterns[p].test(path)) return g;
+  }
+  return -1;
+}
+
+// src/interactives/scripting/ts/bytecode.ts
+var BYTECODE_VERSION = 6;
+var TYPES_VERSION = 1;
+var VARINT_PAYLOAD = 127;
+var VARINT_CONTINUE = 128;
+var VARINT_SHIFT = 7;
+var LINE_GAP_LOG2 = 0;
+var LINEINFO_PRESENT = 1;
+var DEBUGINFO_ABSENT = 0;
+var BYTE_MASK = 255;
+var NUMBER_BYTES = 8;
+var WORD_BYTES = 4;
+var ConstantTag = {
+  NIL: 0,
+  BOOLEAN: 1,
+  NUMBER: 2,
+  STRING: 3
+};
+var Out = class {
+  bytes = [];
+  u8(value) {
+    this.bytes.push(value & BYTE_MASK);
+  }
+  u32(value) {
+    for (let i = 0; i < WORD_BYTES; i++) this.u8(value >>> i * 8);
+  }
+  i32(value) {
+    this.u32(value | 0);
+  }
+  f64(value) {
+    const view = new DataView(new ArrayBuffer(NUMBER_BYTES));
+    view.setFloat64(0, value, true);
+    for (let i = 0; i < NUMBER_BYTES; i++) this.u8(view.getUint8(i));
+  }
+  varint(value) {
+    let v = value >>> 0;
+    do {
+      let byte = v & VARINT_PAYLOAD;
+      v >>>= VARINT_SHIFT;
+      if (v !== 0) byte |= VARINT_CONTINUE;
+      this.u8(byte);
+    } while (v !== 0);
+  }
+  raw(data) {
+    for (const b of data) this.bytes.push(b);
+  }
+  finish() {
+    return Uint8Array.from(this.bytes);
+  }
+};
+var StringTable = class {
+  index = /* @__PURE__ */ new Map();
+  list = [];
+  ref(value) {
+    const found = this.index.get(value);
+    if (found !== void 0) return found;
+    this.list.push(value);
+    const id = this.list.length;
+    this.index.set(value, id);
+    return id;
+  }
+};
+function utf8(value) {
+  return new TextEncoder().encode(value);
+}
+function writeLines(out, lines) {
+  out.u8(LINEINFO_PRESENT);
+  out.u8(LINE_GAP_LOG2);
+  for (let j = 0; j < lines.length; j++) out.u8(0);
+  let previous = 0;
+  for (const line of lines) {
+    out.i32(line - previous);
+    previous = line;
+  }
+}
+function writeBytecode(protos, main) {
+  const strings = new StringTable();
+  for (const proto of protos) {
+    for (const k of proto.constants) if (k.kind === "string") strings.ref(k.value);
+    if (proto.debugName !== null) strings.ref(proto.debugName);
+  }
+  const out = new Out();
+  out.u8(BYTECODE_VERSION);
+  out.u8(TYPES_VERSION);
+  out.varint(strings.list.length);
+  for (const s of strings.list) {
+    const bytes = utf8(s);
+    out.varint(bytes.length);
+    out.raw(bytes);
+  }
+  out.varint(protos.length);
+  for (const proto of protos) {
+    out.u8(proto.maxStackSize);
+    out.u8(proto.numParams);
+    out.u8(proto.numUpvalues);
+    out.u8(proto.isVararg ? 1 : 0);
+    out.u8(0);
+    out.varint(0);
+    out.varint(proto.code.length);
+    for (const word of proto.code) out.u32(word);
+    out.varint(proto.constants.length);
+    for (const k of proto.constants) {
+      switch (k.kind) {
+        case "nil":
+          out.u8(ConstantTag.NIL);
+          break;
+        case "boolean":
+          out.u8(ConstantTag.BOOLEAN);
+          out.u8(k.value ? 1 : 0);
+          break;
+        case "number":
+          out.u8(ConstantTag.NUMBER);
+          out.f64(k.value);
+          break;
+        case "string":
+          out.u8(ConstantTag.STRING);
+          out.varint(strings.ref(k.value));
+          break;
+      }
+    }
+    out.varint(proto.children.length);
+    for (const child of proto.children) out.varint(child);
+    out.varint(proto.lineDefined);
+    out.varint(proto.debugName === null ? 0 : strings.ref(proto.debugName));
+    writeLines(out, proto.lines);
+    out.u8(DEBUGINFO_ABSENT);
+  }
+  out.varint(main);
+  return out.finish();
+}
+
+// src/interactives/scripting/ts/lib.ts
+var LIB_FILE = "rive.d.ts";
+var GLOBAL_RENAMES = /* @__PURE__ */ new Map([["Math", "math"]]);
+var MATH_RENAMES = /* @__PURE__ */ new Map([["PI", "pi"]]);
+var TOOL_LIB_SOURCE = `
+interface ProductionRead {
+  id?: string | number;
+  depth?: number;
+}
+interface Production {
+  readonly kinds: () => any;
+  readonly read: (request?: ProductionRead) => any;
+  readonly edit: (changes: object[]) => any;
+  readonly undo: () => any;
+  readonly redo: () => any;
+}
+declare const production: Production;
+`;
+var LIB_SOURCE = `
+interface Array<T> {
+  length: number;
+  [n: number]: T;
+  push(item: T): number;
+  pop(): T | undefined;
+}
+interface ReadonlyArray<T> {
+  readonly length: number;
+  readonly [n: number]: T;
+}
+interface Boolean {}
+interface Function {}
+interface CallableFunction {}
+interface NewableFunction {}
+interface IArguments {}
+interface Number {}
+interface Object {}
+interface RegExp {}
+interface String {
+  readonly length: number;
+  toUpperCase(): string;
+  toLowerCase(): string;
+  substring(start: number, end?: number): string;
+}
+interface TemplateStringsArray extends ReadonlyArray<string> {}
+type Record<K extends string, T> = { [P in K]: T };
+type Partial<T> = { [P in keyof T]?: T[P] };
+
+interface Math {
+  readonly PI: number;
+  abs(x: number): number;
+  acos(x: number): number;
+  asin(x: number): number;
+  atan(x: number): number;
+  atan2(y: number, x: number): number;
+  ceil(x: number): number;
+  cos(x: number): number;
+  exp(x: number): number;
+  floor(x: number): number;
+  log(x: number): number;
+  max(...values: number[]): number;
+  min(...values: number[]): number;
+  pow(x: number, y: number): number;
+  sin(x: number): number;
+  sqrt(x: number): number;
+  tan(x: number): number;
+}
+declare const Math: Math;
+declare function print(...values: unknown[]): void;
+declare function tostring(value: unknown): string;
+
+declare class Vector {
+  private constructor();
+  static xy(x: number, y: number): Vector;
+  readonly x: number;
+  readonly y: number;
+}
+
+declare class Mat2D {
+  private constructor();
+  static identity(): Mat2D;
+  static withTranslation(x: number, y: number): Mat2D;
+  static withRotation(radians: number): Mat2D;
+  static withScale(x: number, y: number): Mat2D;
+  xx: number;
+  xy: number;
+  yx: number;
+  yy: number;
+  tx: number;
+  ty: number;
+}
+
+declare class Color {
+  private constructor();
+  static rgb(r: number, g: number, b: number): number;
+  static rgba(r: number, g: number, b: number, a: number): number;
+  static lerp(from: number, to: number, t: number): number;
+}
+
+declare class Path {
+  private constructor();
+  static new(): Path;
+  moveTo(point: Vector): void;
+  lineTo(point: Vector): void;
+  quadTo(control: Vector, to: Vector): void;
+  cubicTo(first: Vector, second: Vector, to: Vector): void;
+  close(): void;
+  reset(): void;
+}
+
+interface PaintDescription {
+  color?: number;
+  thickness?: number;
+  style?: "fill" | "stroke";
+}
+
+declare class Paint {
+  private constructor();
+  static new(): Paint;
+  static with(description: PaintDescription): Paint;
+  color: number;
+  thickness: number;
+  style: "fill" | "stroke";
+}
+
+declare class Renderer {
+  private constructor();
+  drawPath(path: Path, paint: Paint): void;
+  clipPath(path: Path): void;
+  save(): void;
+  restore(): void;
+  transform(matrix: Mat2D): void;
+}
+
+declare class NumberProperty {
+  private constructor();
+  value: number;
+}
+
+declare class StringProperty {
+  private constructor();
+  value: string;
+}
+
+declare class BooleanProperty {
+  private constructor();
+  value: boolean;
+}
+
+declare class ViewModel {
+  private constructor();
+  getNumber(name: string): NumberProperty | undefined;
+  getString(name: string): StringProperty | undefined;
+  getBoolean(name: string): BooleanProperty | undefined;
+}
+
+declare class Context {
+  private constructor();
+  viewModel(): ViewModel | undefined;
+  markNeedsUpdate(): void;
+}
+`;
+
+// src/interactives/scripting/ts/emit.ts
+var Op = {
+  LOADNIL: 2,
+  LOADB: 3,
+  LOADN: 4,
+  LOADK: 5,
+  MOVE: 6,
+  GETGLOBAL: 7,
+  SETGLOBAL: 8,
+  GETUPVAL: 9,
+  SETUPVAL: 10,
+  CLOSEUPVALS: 11,
+  GETTABLE: 13,
+  SETTABLE: 14,
+  GETTABLEKS: 15,
+  SETTABLEKS: 16,
+  NEWCLOSURE: 19,
+  NAMECALL: 20,
+  CALL: 21,
+  RETURN: 22,
+  JUMP: 23,
+  JUMPBACK: 24,
+  JUMPIFNOT: 26,
+  JUMPIFEQ: 27,
+  JUMPIFLE: 28,
+  JUMPIFLT: 29,
+  JUMPIFNOTEQ: 30,
+  JUMPIFNOTLE: 31,
+  JUMPIFNOTLT: 32,
+  ADD: 33,
+  SUB: 34,
+  MUL: 35,
+  DIV: 36,
+  POW: 38,
+  ADDK: 39,
+  SUBK: 40,
+  CONCAT: 49,
+  MINUS: 51,
+  LENGTH: 52,
+  NEWTABLE: 53,
+  SETLIST: 55,
+  PREPVARARGS: 65,
+  CAPTURE: 70
+};
+var CAPTURE_REF = 1;
+var CAPTURE_UPVAL = 2;
+var MAX_REGISTERS = 255;
+var MAX_UPVALUES = 200;
+var MAX_ARGUMENT = 255;
+var LOADN_MIN = -32768;
+var LOADN_MAX = 32767;
+var D_MIN = -32768;
+var D_MAX = 32767;
+var A_SHIFT = 8;
+var B_SHIFT = 16;
+var C_SHIFT = 24;
+var BYTE = 255;
+var D_MASK = 65535;
+var TWO_WORD_OPS = /* @__PURE__ */ new Set([
+  Op.GETGLOBAL,
+  Op.SETGLOBAL,
+  Op.GETTABLEKS,
+  Op.SETTABLEKS,
+  Op.NAMECALL,
+  Op.JUMPIFEQ,
+  Op.JUMPIFLE,
+  Op.JUMPIFLT,
+  Op.JUMPIFNOTEQ,
+  Op.JUMPIFNOTLE,
+  Op.JUMPIFNOTLT,
+  Op.NEWTABLE,
+  Op.SETLIST
+]);
+var CompileLimit = class extends Error {
+};
+function field(value, what) {
+  if (value < 0 || value > MAX_ARGUMENT) throw new CompileLimit(`${what} ${value} does not fit in a byte`);
+  return value;
+}
+function abc(op, a, b, c) {
+  return (op | field(a, "A") << A_SHIFT | field(b, "B") << B_SHIFT | field(c, "C") << C_SHIFT) >>> 0;
+}
+function ad(op, a, d) {
+  if (d < D_MIN || d > D_MAX) throw new CompileLimit(`jump or constant ${d} does not fit in 16 bits`);
+  return (op | field(a, "A") << A_SHIFT | (d & D_MASK) << B_SHIFT) >>> 0;
+}
+var FunctionBuilder = class {
+  constructor(numParams, isVararg, debugName, lineDefined) {
+    this.numParams = numParams;
+    this.isVararg = isVararg;
+    this.debugName = debugName;
+    this.lineDefined = lineDefined;
+    this.top = numParams;
+    this.maxStack = numParams;
+  }
+  numParams;
+  isVararg;
+  debugName;
+  lineDefined;
+  code = [];
+  lines = [];
+  constants = [];
+  children = [];
+  upvalues = [];
+  constantIndex = /* @__PURE__ */ new Map();
+  top = 0;
+  maxStack = 0;
+  line = 1;
+  lastLabel = -1;
+  push(word) {
+    this.code.push(word);
+    this.lines.push(this.line);
+    return this.code.length - 1;
+  }
+  emit(word, aux) {
+    const at = this.push(word);
+    const op = word & BYTE;
+    if (TWO_WORD_OPS.has(op)) this.push(aux ?? 0);
+    return at;
+  }
+  reserve(count) {
+    const base = this.top;
+    this.top += count;
+    if (this.top > MAX_REGISTERS) throw new CompileLimit("the function needs more than 255 registers");
+    if (this.top > this.maxStack) this.maxStack = this.top;
+    return base;
+  }
+  release(mark) {
+    this.top = mark;
+  }
+  constant(k) {
+    const key = k.kind === "number" ? `n:${Object.is(k.value, -0) ? "-0" : String(k.value)}` : k.kind === "string" ? `s:${k.value}` : k.kind === "boolean" ? `b:${k.value}` : "nil";
+    const found = this.constantIndex.get(key);
+    if (found !== void 0) return found;
+    this.constants.push(k);
+    const index = this.constants.length - 1;
+    this.constantIndex.set(key, index);
+    return index;
+  }
+  string(value) {
+    return this.constant({ kind: "string", value });
+  }
+  number(value) {
+    return this.constant({ kind: "number", value });
+  }
+  loadNumber(target, value) {
+    if (Number.isInteger(value) && value >= LOADN_MIN && value <= LOADN_MAX && !Object.is(value, -0)) {
+      this.emit(ad(Op.LOADN, target, value));
+    } else {
+      this.emit(ad(Op.LOADK, target, this.number(value)));
+    }
+  }
+  loadString(target, value) {
+    this.emit(ad(Op.LOADK, target, this.string(value)));
+  }
+  label() {
+    return { target: -1, patches: [] };
+  }
+  here(label) {
+    label.target = this.code.length;
+    this.lastLabel = label.target;
+    for (const at of label.patches) this.patch(at, label.target);
+  }
+  patch(at, target) {
+    const word = this.code[at];
+    const op = word & BYTE;
+    const delta = target - (at + 1);
+    if (delta < D_MIN || delta > D_MAX) throw new CompileLimit("a jump spans more than 32767 instructions");
+    this.code[at] = (word & D_MASK | (delta & D_MASK) << B_SHIFT) >>> 0;
+    if (op === Op.JUMP && delta <= 0) this.code[at] = (this.code[at] & ~BYTE | Op.JUMPBACK) >>> 0;
+  }
+  jumpTo(op, a, label, aux) {
+    const at = this.emit(ad(op, a, 0), aux);
+    if (label.target >= 0) {
+      const delta = label.target - (at + 1);
+      if (op !== Op.JUMP && delta <= 0) throw new CompileLimit("a conditional jump goes backwards");
+      this.patch(at, label.target);
+    } else {
+      label.patches.push(at);
+    }
+  }
+  jump(label) {
+    this.jumpTo(Op.JUMP, 0, label);
+  }
+  upvalue(ref) {
+    const found = this.upvalues.findIndex((u) => u.kind === ref.kind && u.index === ref.index);
+    if (found >= 0) return found;
+    if (this.upvalues.length >= MAX_UPVALUES) throw new CompileLimit("a function captures more than 200 upvalues");
+    this.upvalues.push(ref);
+    return this.upvalues.length - 1;
+  }
+  endsWithTerminator() {
+    if (this.code.length === 0) return false;
+    let pc = 0;
+    let last = -1;
+    while (pc < this.code.length) {
+      last = pc;
+      pc += TWO_WORD_OPS.has(this.code[pc] & BYTE) ? 2 : 1;
+    }
+    const op = this.code[last] & BYTE;
+    return op === Op.RETURN || op === Op.JUMP || op === Op.JUMPBACK;
+  }
+  finish() {
+    if (!this.endsWithTerminator() || this.lastLabel === this.code.length) this.emit(abc(Op.RETURN, 0, 1, 0));
+    return {
+      maxStackSize: Math.max(this.maxStack, 1),
+      numParams: this.numParams,
+      numUpvalues: this.upvalues.length,
+      isVararg: this.isVararg,
+      code: this.code,
+      lines: this.lines,
+      constants: this.constants,
+      children: this.children,
+      lineDefined: this.lineDefined,
+      debugName: this.debugName
+    };
+  }
+};
+
+// src/interactives/scripting/ts/lower.ts
+var RESULTS_NONE = 1;
+var RESULTS_ONE = 2;
+var ARGS_OFFSET = 1;
+var NAMECALL_ARGS_OFFSET = 2;
+var LIST_BATCH = 32;
+var ARRAY_BASE = 1;
+var TRUE = 1;
+var FALSE = 0;
+var SKIP_ONE = 1;
+var QUOTE_CHARS = 40;
+var TOO_LARGE = "this script is too large to run; split its longest functions into smaller ones";
+var Refusal = class extends Error {
+  constructor(node, message) {
+    super(message);
+    this.node = node;
+  }
+  node;
+};
+var FnState = class {
+  constructor(b, parent) {
+    this.b = b;
+    this.parent = parent;
+  }
+  b;
+  parent;
+  scopes = [];
+  loops = [];
+  selfKey = null;
+};
+function numberOf(node) {
+  return Number(node.text.replace(/_/g, ""));
+}
+function functionScopeOf(node) {
+  let current = node.parent;
+  while (current !== void 0) {
+    if (ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current) || ts.isMethodDeclaration(current) || ts.isConstructorDeclaration(current) || ts.isSourceFile(current)) {
+      return current;
+    }
+    if (ts.isPropertyDeclaration(current) && ts.isClassDeclaration(current.parent)) {
+      return current.parent;
+    }
+    current = current.parent;
+  }
+  return node;
+}
+function declarationScope(declaration) {
+  if (ts.isParameter(declaration)) return declaration.parent;
+  if (ts.isFunctionDeclaration(declaration) || ts.isClassDeclaration(declaration)) return functionScopeOf(declaration);
+  return functionScopeOf(declaration);
+}
+var Lowering = class {
+  constructor(checker, source) {
+    this.checker = checker;
+    this.source = source;
+  }
+  checker;
+  source;
+  protos = [];
+  captured = /* @__PURE__ */ new Set();
+  selfKeys = /* @__PURE__ */ new Map();
+  fn;
+  refuse(node, message) {
+    throw new Refusal(node, message);
+  }
+  quoted(node) {
+    const text = node.getText(this.source).split("\n")[0]?.trim() ?? "";
+    return text.length > QUOTE_CHARS ? `'${text.slice(0, QUOTE_CHARS)}...'` : `'${text}'`;
+  }
+  isAmbient(symbol) {
+    const declarations = symbol.declarations ?? [];
+    return declarations.length > 0 && declarations.every((d) => d.getSourceFile().fileName === LIB_FILE);
+  }
+  symbolOf(node) {
+    const symbol = this.checker.getSymbolAtLocation(node);
+    if (symbol !== void 0 && ts.isShorthandPropertyAssignment(node.parent) && node.parent.name === node) {
+      return this.checker.getShorthandAssignmentValueSymbol(node.parent) ?? symbol;
+    }
+    return symbol;
+  }
+  selfKeyOf(scope) {
+    let key = this.selfKeys.get(scope);
+    if (key === void 0) {
+      key = {};
+      this.selfKeys.set(scope, key);
+    }
+    return key;
+  }
+  thisScope(node) {
+    let scope = functionScopeOf(node);
+    while (ts.isArrowFunction(scope)) scope = functionScopeOf(scope);
+    if (ts.isConstructorDeclaration(scope)) return scope.parent;
+    return scope;
+  }
+  findCaptures() {
+    const visit = (node) => {
+      if (ts.isClassDeclaration(node) && node.name !== void 0) {
+        const symbol = this.symbolOf(node.name);
+        if (symbol !== void 0) this.captured.add(symbol);
+      }
+      if (ts.isIdentifier(node)) {
+        const symbol = this.symbolOf(node);
+        const declaration = symbol?.valueDeclaration ?? symbol?.declarations?.[0];
+        if (symbol !== void 0 && declaration !== void 0 && !this.isAmbient(symbol)) {
+          let use = functionScopeOf(node);
+          let owner = declarationScope(declaration);
+          if (ts.isConstructorDeclaration(use)) use = use.parent;
+          if (ts.isConstructorDeclaration(owner)) owner = owner.parent;
+          if (use !== owner) this.captured.add(symbol);
+        }
+      } else if (node.kind === ts.SyntaxKind.ThisKeyword) {
+        let use = functionScopeOf(node);
+        if (ts.isConstructorDeclaration(use)) use = use.parent;
+        const owner = this.thisScope(node);
+        if (use !== owner) this.captured.add(this.selfKeyOf(owner));
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(this.source);
+  }
+  compileModule() {
+    this.findCaptures();
+    const b = new FunctionBuilder(0, true, null, 1);
+    this.fn = new FnState(b, null);
+    b.emit(abc(Op.PREPVARARGS, 0, 0, 0));
+    const scope = this.openScope();
+    const result = b.reserve(1);
+    b.emit(abc(Op.LOADNIL, result, 0, 0));
+    this.declareBlock(this.source.statements);
+    for (const statement of this.source.statements) {
+      if (ts.isExportAssignment(statement)) {
+        this.at(statement);
+        this.exprTo(statement.expression, result);
+        continue;
+      }
+      if (ts.isFunctionDeclaration(statement) && this.isDefaultExport(statement)) {
+        this.at(statement);
+        this.closureTo(statement, result, "default");
+        continue;
+      }
+      this.statement(statement);
+    }
+    this.closeScope(scope, true);
+    b.emit(abc(Op.RETURN, result, 2, 0));
+    this.protos.push(b.finish());
+    return this.protos.length - 1;
+  }
+  isDefaultExport(node) {
+    const flags = ts.getCombinedModifierFlags(node);
+    return (flags & ts.ModifierFlags.Default) !== 0;
+  }
+  at(node) {
+    const { line } = this.source.getLineAndCharacterOfPosition(node.getStart(this.source));
+    this.fn.b.line = line + 1;
+  }
+  openScope() {
+    const scope = { vars: /* @__PURE__ */ new Map(), firstReg: this.fn.b.top, captured: false };
+    this.fn.scopes.push(scope);
+    return scope;
+  }
+  closeScope(scope, closeUpvalues) {
+    const popped = this.fn.scopes.pop();
+    if (popped !== scope) throw new CompileLimit("scope stack out of order");
+    const lowest = this.lowestCaptured([scope]);
+    if (closeUpvalues && lowest >= 0) this.fn.b.emit(abc(Op.CLOSEUPVALS, lowest, 0, 0));
+    this.fn.b.release(scope.firstReg);
+  }
+  lowestCaptured(scopes) {
+    let lowest = -1;
+    for (const scope of scopes) {
+      for (const [key, reg] of scope.vars) {
+        if (this.captured.has(key) && (lowest < 0 || reg < lowest)) lowest = reg;
+      }
+    }
+    return lowest;
+  }
+  emitReturn(reg, countPlusOne) {
+    const lowest = this.lowestCaptured(this.fn.scopes);
+    if (lowest >= 0) this.fn.b.emit(abc(Op.CLOSEUPVALS, lowest, 0, 0));
+    this.fn.b.emit(abc(Op.RETURN, reg, countPlusOne, 0));
+  }
+  declare(key) {
+    const scope = this.fn.scopes[this.fn.scopes.length - 1];
+    const reg = this.fn.b.reserve(1);
+    scope.vars.set(key, reg);
+    if (this.captured.has(key)) scope.captured = true;
+    return reg;
+  }
+  declareBlock(statements) {
+    for (const statement of statements) {
+      if (ts.isVariableStatement(statement)) {
+        for (const declaration of statement.declarationList.declarations) {
+          if (!ts.isIdentifier(declaration.name)) this.refuse(declaration, "destructuring declarations are not supported");
+          const symbol = this.symbolOf(declaration.name);
+          if (symbol === void 0) this.refuse(declaration, "a declaration without a symbol");
+          const reg = this.declare(symbol);
+          this.fn.b.emit(abc(Op.LOADNIL, reg, 0, 0));
+        }
+      } else if (ts.isFunctionDeclaration(statement) && !this.isDefaultExport(statement)) {
+        if (statement.name === void 0) this.refuse(statement, "a function declaration needs a name");
+        const symbol = this.symbolOf(statement.name);
+        if (symbol === void 0) this.refuse(statement, "a function without a symbol");
+        this.declare(symbol);
+      } else if (ts.isClassDeclaration(statement)) {
+        if (statement.name === void 0) this.refuse(statement, "a class declaration needs a name");
+        const symbol = this.symbolOf(statement.name);
+        if (symbol === void 0) this.refuse(statement, "a class without a symbol");
+        const reg = this.declare(symbol);
+        this.fn.b.emit(abc(Op.LOADNIL, reg, 0, 0));
+      }
+    }
+    for (const statement of statements) {
+      if (ts.isFunctionDeclaration(statement) && !this.isDefaultExport(statement) && statement.body !== void 0) {
+        const reg = this.lookupLocal(this.symbolOf(statement.name));
+        this.at(statement);
+        this.closureTo(statement, reg, statement.name.text);
+      }
+    }
+  }
+  lookupLocal(key) {
+    for (let i = this.fn.scopes.length - 1; i >= 0; i--) {
+      const reg = this.fn.scopes[i].vars.get(key);
+      if (reg !== void 0) return reg;
+    }
+    return void 0;
+  }
+  resolveIn(fn, key) {
+    for (let i = fn.scopes.length - 1; i >= 0; i--) {
+      const reg = fn.scopes[i].vars.get(key);
+      if (reg !== void 0) return { kind: "local", reg };
+    }
+    if (fn.parent === null) return null;
+    const outer = this.resolveIn(fn.parent, key);
+    if (outer === null || outer.kind === "global") return outer;
+    const index = fn.b.upvalue(
+      outer.kind === "local" ? { kind: CAPTURE_REF, index: outer.reg } : { kind: CAPTURE_UPVAL, index: outer.index }
+    );
+    return { kind: "upval", index };
+  }
+  place(node) {
+    if (node.text === "undefined") return { kind: "global", name: "nil" };
+    const symbol = this.symbolOf(node);
+    if (symbol === void 0) this.refuse(node, `unknown name '${node.text}'`);
+    if (this.isAmbient(symbol)) return { kind: "global", name: GLOBAL_RENAMES.get(node.text) ?? node.text };
+    const found = this.resolveIn(this.fn, symbol);
+    if (found === null) this.refuse(node, `'${node.text}' is used before it is declared in an enclosing block`);
+    return found;
+  }
+  selfPlace(node) {
+    const key = this.selfKeyOf(this.thisScope(node));
+    const found = this.resolveIn(this.fn, key);
+    if (found === null) this.refuse(node, "'this' is only supported inside class methods and constructors");
+    return found;
+  }
+  typeOf(node) {
+    return this.checker.getTypeAtLocation(node);
+  }
+  parts(type) {
+    return type.isUnion() ? type.types : [type];
+  }
+  isString(type) {
+    return this.parts(type).every((t) => (t.flags & ts.TypeFlags.StringLike) !== 0);
+  }
+  isNumber(type) {
+    return this.parts(type).every((t) => (t.flags & ts.TypeFlags.NumberLike) !== 0);
+  }
+  isBoolean(type) {
+    return this.parts(type).every((t) => (t.flags & ts.TypeFlags.BooleanLike) !== 0);
+  }
+  mayBe(type, flags) {
+    return this.parts(type).some((t) => (t.flags & (flags | ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0);
+  }
+  isArray(type) {
+    const nonNull = this.checker.getNonNullableType(type);
+    return this.checker.isArrayType(nonNull) || this.checker.isTupleType(nonNull);
+  }
+  statement(node) {
+    this.at(node);
+    const b = this.fn.b;
+    const mark = b.top;
+    if (ts.isVariableStatement(node)) {
+      for (const declaration of node.declarationList.declarations) {
+        if (declaration.initializer === void 0) continue;
+        const reg = this.lookupLocal(this.symbolOf(declaration.name));
+        this.exprTo(declaration.initializer, reg);
+      }
+    } else if (ts.isExpressionStatement(node)) {
+      this.effect(node.expression);
+    } else if (ts.isReturnStatement(node)) {
+      if (node.expression === void 0) {
+        this.emitReturn(0, 1);
+      } else {
+        const reg = this.exprAny(node.expression);
+        this.emitReturn(reg, 2);
+      }
+    } else if (ts.isIfStatement(node)) {
+      const otherwise = b.label();
+      this.jumpIfFalse(node.expression, otherwise);
+      b.release(mark);
+      this.block(node.thenStatement);
+      if (node.elseStatement !== void 0) {
+        const end = b.label();
+        b.jump(end);
+        b.here(otherwise);
+        this.block(node.elseStatement);
+        b.here(end);
+      } else {
+        b.here(otherwise);
+      }
+    } else if (ts.isWhileStatement(node)) {
+      const top = b.label();
+      const exit = b.label();
+      b.here(top);
+      this.jumpIfFalse(node.expression, exit);
+      b.release(mark);
+      this.loopBody(node.statement, exit, top);
+      b.jump(top);
+      b.here(exit);
+    } else if (ts.isDoStatement(node)) {
+      const top = b.label();
+      const exit = b.label();
+      const next = b.label();
+      b.here(top);
+      this.loopBody(node.statement, exit, next);
+      b.here(next);
+      this.jumpIfFalse(node.expression, exit);
+      b.release(mark);
+      b.jump(top);
+      b.here(exit);
+    } else if (ts.isForStatement(node)) {
+      this.forStatement(node);
+    } else if (ts.isForOfStatement(node)) {
+      this.forOfStatement(node);
+    } else if (ts.isBreakStatement(node) || ts.isContinueStatement(node)) {
+      if (node.label !== void 0) this.refuse(node, "labelled break and continue are not supported");
+      const contexts = this.fn.loops.filter((l) => ts.isBreakStatement(node) || l.loop);
+      const loop = contexts[contexts.length - 1];
+      if (loop === void 0) this.refuse(node, "break or continue outside a loop");
+      const lowest = this.lowestCaptured(this.fn.scopes.slice(loop.scopeDepth));
+      if (lowest >= 0) b.emit(abc(Op.CLOSEUPVALS, lowest, 0, 0));
+      b.jump(ts.isBreakStatement(node) ? loop.breakLabel : loop.continueLabel);
+    } else if (ts.isBlock(node)) {
+      this.block(node);
+    } else if (ts.isSwitchStatement(node)) {
+      this.switchStatement(node);
+    } else if (ts.isThrowStatement(node)) {
+      const base = b.reserve(2);
+      b.emit(abc(Op.GETGLOBAL, base, 0, 0), b.string("error"));
+      this.exprTo(node.expression, base + ARGS_OFFSET);
+      b.emit(abc(Op.CALL, base, 2, RESULTS_NONE));
+    } else if (ts.isFunctionDeclaration(node)) {
+      if (node.body === void 0) this.refuse(node, "a function declaration needs a body");
+    } else if (ts.isClassDeclaration(node)) {
+      this.classDeclaration(node);
+    } else if (ts.isEmptyStatement(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) {
+      return;
+    } else if (ts.isTryStatement(node)) {
+      this.refuse(node, "try and catch are not supported in Rive scripts yet");
+    } else {
+      this.refuse(node, `${this.quoted(node)} is not supported in Rive scripts`);
+    }
+    b.release(mark);
+  }
+  block(node) {
+    const scope = this.openScope();
+    const statements = ts.isBlock(node) ? node.statements : ts.factory.createNodeArray([node]);
+    this.declareBlock(statements);
+    for (const statement of statements) this.statement(statement);
+    this.closeScope(scope, true);
+  }
+  loopBody(body, exit, next) {
+    this.fn.loops.push({ breakLabel: exit, continueLabel: next, scopeDepth: this.fn.scopes.length, loop: true });
+    this.block(body);
+    this.fn.loops.pop();
+  }
+  forStatement(node) {
+    const b = this.fn.b;
+    const scope = this.openScope();
+    if (node.initializer !== void 0) {
+      if (ts.isVariableDeclarationList(node.initializer)) {
+        for (const declaration of node.initializer.declarations) {
+          if (!ts.isIdentifier(declaration.name)) this.refuse(declaration, "destructuring declarations are not supported");
+          const symbol = this.symbolOf(declaration.name);
+          if (this.captured.has(symbol)) {
+            this.refuse(declaration, "a closure cannot capture a for loop's counter; copy it into a const inside the body");
+          }
+          const reg = this.declare(symbol);
+          if (declaration.initializer === void 0) b.emit(abc(Op.LOADNIL, reg, 0, 0));
+          else this.exprTo(declaration.initializer, reg);
+        }
+      } else {
+        this.effect(node.initializer);
+      }
+    }
+    const top = b.label();
+    const exit = b.label();
+    const next = b.label();
+    b.here(top);
+    if (node.condition !== void 0) {
+      const mark = b.top;
+      this.jumpIfFalse(node.condition, exit);
+      b.release(mark);
+    }
+    this.loopBody(node.statement, exit, next);
+    b.here(next);
+    if (node.incrementor !== void 0) {
+      const mark = b.top;
+      this.effect(node.incrementor);
+      b.release(mark);
+    }
+    b.jump(top);
+    b.here(exit);
+    this.closeScope(scope, true);
+  }
+  forOfStatement(node) {
+    const b = this.fn.b;
+    if (node.awaitModifier !== void 0) this.refuse(node, "for await is not supported");
+    if (!this.isArray(this.typeOf(node.expression))) this.refuse(node.expression, "for...of iterates arrays only");
+    if (!ts.isVariableDeclarationList(node.initializer) || node.initializer.declarations.length !== 1) {
+      this.refuse(node.initializer, "for...of needs one const or let declaration");
+    }
+    const declaration = node.initializer.declarations[0];
+    if (!ts.isIdentifier(declaration.name)) this.refuse(declaration, "destructuring declarations are not supported");
+    const outer = this.openScope();
+    const table = b.reserve(1);
+    this.exprTo(node.expression, table);
+    const index = b.reserve(1);
+    b.loadNumber(index, ARRAY_BASE);
+    const length = b.reserve(1);
+    const top = b.label();
+    const exit = b.label();
+    const next = b.label();
+    b.here(top);
+    b.emit(abc(Op.LENGTH, length, table, 0));
+    b.jumpTo(Op.JUMPIFNOTLE, index, exit, length);
+    const iteration = this.openScope();
+    const item = this.declare(this.symbolOf(declaration.name));
+    b.emit(abc(Op.GETTABLE, item, table, index));
+    this.fn.loops.push({ breakLabel: exit, continueLabel: next, scopeDepth: this.fn.scopes.length - 1, loop: true });
+    this.block(node.statement);
+    this.fn.loops.pop();
+    this.closeScope(iteration, true);
+    b.here(next);
+    b.emit(abc(Op.ADDK, index, index, b.number(ARRAY_BASE)));
+    b.jump(top);
+    b.here(exit);
+    this.closeScope(outer, true);
+  }
+  switchStatement(node) {
+    const b = this.fn.b;
+    const scope = this.openScope();
+    const value = b.reserve(1);
+    this.exprTo(node.expression, value);
+    const exit = b.label();
+    const labels = node.caseBlock.clauses.map(() => b.label());
+    let fallback = exit;
+    node.caseBlock.clauses.forEach((clause, i) => {
+      if (ts.isDefaultClause(clause)) {
+        fallback = labels[i];
+        return;
+      }
+      const mark = b.top;
+      const candidate = this.exprAny(clause.expression);
+      b.jumpTo(Op.JUMPIFEQ, value, labels[i], candidate);
+      b.release(mark);
+    });
+    b.jump(fallback);
+    this.fn.loops.push({ breakLabel: exit, continueLabel: exit, scopeDepth: this.fn.scopes.length, loop: false });
+    const body = this.openScope();
+    const statements = node.caseBlock.clauses.flatMap((clause) => [...clause.statements]);
+    this.declareBlock(ts.factory.createNodeArray(statements));
+    node.caseBlock.clauses.forEach((clause, i) => {
+      b.here(labels[i]);
+      for (const statement of clause.statements) this.statement(statement);
+    });
+    this.closeScope(body, true);
+    this.fn.loops.pop();
+    b.here(exit);
+    this.closeScope(scope, true);
+  }
+  classDeclaration(node) {
+    const b = this.fn.b;
+    if (node.heritageClauses !== void 0 && node.heritageClauses.length > 0) {
+      this.refuse(node, "classes cannot extend or implement in Rive scripts yet");
+    }
+    const reg = this.lookupLocal(this.symbolOf(node.name));
+    b.emit(abc(Op.NEWTABLE, reg, 0, 0), 0);
+    b.emit(abc(Op.SETTABLEKS, reg, reg, 0), b.string("__index"));
+    const mark = b.top;
+    let constructor;
+    for (const member of node.members) {
+      if (ts.isConstructorDeclaration(member)) {
+        constructor = member;
+      } else if (ts.isMethodDeclaration(member)) {
+        if (!ts.isIdentifier(member.name)) this.refuse(member, "computed method names are not supported");
+        const isStatic = (ts.getCombinedModifierFlags(member) & ts.ModifierFlags.Static) !== 0;
+        const temp2 = b.reserve(1);
+        this.at(member);
+        this.closureTo(member, temp2, member.name.text, !isStatic);
+        b.emit(abc(Op.SETTABLEKS, temp2, reg, 0), b.string(member.name.text));
+        b.release(mark);
+      } else if (ts.isPropertyDeclaration(member)) {
+        if ((ts.getCombinedModifierFlags(member) & ts.ModifierFlags.Static) !== 0) {
+          this.refuse(member, "static fields are not supported in Rive scripts yet");
+        }
+      } else {
+        this.refuse(member, `${this.quoted(member)} in a class is not supported in Rive scripts yet`);
+      }
+    }
+    const temp = b.reserve(1);
+    this.constructorTo(node, constructor, temp);
+    b.emit(abc(Op.SETTABLEKS, temp, reg, 0), b.string("new"));
+    b.release(mark);
+  }
+  constructorTo(node, constructor, target) {
+    const params = constructor?.parameters ?? ts.factory.createNodeArray([]);
+    const parent = this.fn;
+    const child = new FunctionBuilder(params.length, false, "new", parent.b.line);
+    this.fn = new FnState(child, parent);
+    const scope = this.openScope();
+    params.forEach((param, i) => this.bindParameter(param, i));
+    const selfKey = this.selfKeyOf(node);
+    const self = this.declare(selfKey);
+    const mark = child.top;
+    const base = child.reserve(3);
+    child.emit(abc(Op.GETGLOBAL, base, 0, 0), child.string("setmetatable"));
+    child.emit(abc(Op.NEWTABLE, base + 1, 0, 0), 0);
+    const classPlace = this.resolveIn(this.fn, this.symbolOf(node.name));
+    if (classPlace === null || classPlace.kind !== "upval") throw new CompileLimit("a class must be visible to its constructor");
+    child.emit(abc(Op.GETUPVAL, base + 2, classPlace.index, 0));
+    child.emit(abc(Op.CALL, base, 3, RESULTS_ONE));
+    child.emit(abc(Op.MOVE, self, base, 0));
+    child.release(mark);
+    for (const member of node.members) {
+      if (ts.isPropertyDeclaration(member) && member.initializer !== void 0) {
+        if (!ts.isIdentifier(member.name)) this.refuse(member, "computed field names are not supported");
+        this.at(member);
+        const value = this.exprAny(member.initializer);
+        child.emit(abc(Op.SETTABLEKS, value, self, 0), child.string(member.name.text));
+        child.release(mark);
+      }
+    }
+    if (constructor?.body !== void 0) {
+      this.declareBlock(constructor.body.statements);
+      for (const statement of constructor.body.statements) {
+        if (ts.isReturnStatement(statement)) this.refuse(statement, "a constructor cannot return");
+        this.statement(statement);
+      }
+    }
+    this.emitReturn(self, 2);
+    this.closeScope(scope, false);
+    this.finishClosure(parent, child, target);
+  }
+  bindParameter(param, index) {
+    if (!ts.isIdentifier(param.name)) this.refuse(param, "destructuring parameters are not supported");
+    if (param.dotDotDotToken !== void 0) this.refuse(param, "rest parameters are not supported");
+    const symbol = this.symbolOf(param.name);
+    const scope = this.fn.scopes[this.fn.scopes.length - 1];
+    scope.vars.set(symbol, index);
+    if (this.captured.has(symbol)) scope.captured = true;
+  }
+  closureTo(node, target, name, method = false) {
+    if (node.asteriskToken !== void 0) this.refuse(node, "generators are not supported");
+    if (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) this.refuse(node, "async functions are not supported in Rive scripts yet");
+    const parent = this.fn;
+    const offset = method ? 1 : 0;
+    const child = new FunctionBuilder(node.parameters.length + offset, false, name, parent.b.line);
+    this.fn = new FnState(child, parent);
+    const scope = this.openScope();
+    if (method) {
+      const key = this.selfKeyOf(node);
+      scope.vars.set(key, 0);
+      if (this.captured.has(key)) scope.captured = true;
+    }
+    node.parameters.forEach((param, i) => this.bindParameter(param, i + offset));
+    node.parameters.forEach((param, i) => {
+      if (param.initializer === void 0) return;
+      this.at(param);
+      const reg = i + offset;
+      const skip = child.label();
+      const mark = child.top;
+      const nil = child.reserve(1);
+      child.emit(abc(Op.LOADNIL, nil, 0, 0));
+      child.jumpTo(Op.JUMPIFNOTEQ, reg, skip, nil);
+      child.release(mark);
+      this.exprTo(param.initializer, reg);
+      child.here(skip);
+    });
+    const body = node.body;
+    if (body === void 0) this.refuse(node, "a function needs a body");
+    if (ts.isBlock(body)) {
+      this.declareBlock(body.statements);
+      for (const statement of body.statements) this.statement(statement);
+    } else {
+      this.at(body);
+      const reg = this.exprAny(body);
+      this.emitReturn(reg, 2);
+    }
+    this.closeScope(scope, true);
+    this.finishClosure(parent, child, target);
+  }
+  finishClosure(parent, child, target) {
+    this.fn = parent;
+    this.protos.push(child.finish());
+    parent.b.children.push(this.protos.length - 1);
+    parent.b.emit(ad(Op.NEWCLOSURE, target, parent.b.children.length - 1));
+    for (const upvalue of child.upvalues) {
+      parent.b.emit(abc(Op.CAPTURE, upvalue.kind, upvalue.index, 0));
+    }
+  }
+  effect(node) {
+    const b = this.fn.b;
+    const mark = b.top;
+    if (ts.isParenthesizedExpression(node)) {
+      this.effect(node.expression);
+    } else if (ts.isCallExpression(node)) {
+      this.call(node, null);
+    } else if (ts.isBinaryExpression(node) && this.isAssignment(node.operatorToken.kind)) {
+      this.assignment(node, null);
+    } else if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) && (node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken)) {
+      this.increment(node, null);
+    } else {
+      this.exprAny(node);
+    }
+    b.release(mark);
+  }
+  isAssignment(kind) {
+    return kind === ts.SyntaxKind.EqualsToken || kind === ts.SyntaxKind.PlusEqualsToken || kind === ts.SyntaxKind.MinusEqualsToken || kind === ts.SyntaxKind.AsteriskEqualsToken || kind === ts.SyntaxKind.SlashEqualsToken || kind === ts.SyntaxKind.QuestionQuestionEqualsToken;
+  }
+  exprAny(node) {
+    const inner = this.unwrap(node);
+    if (ts.isIdentifier(inner)) {
+      const place = this.place(inner);
+      if (place.kind === "local") return place.reg;
+    }
+    if (inner.kind === ts.SyntaxKind.ThisKeyword) {
+      const place = this.selfPlace(inner);
+      if (place.kind === "local") return place.reg;
+    }
+    const reg = this.fn.b.reserve(1);
+    this.exprTo(inner, reg);
+    return reg;
+  }
+  unwrap(node) {
+    let current = node;
+    while (ts.isParenthesizedExpression(current) || ts.isAsExpression(current) || ts.isNonNullExpression(current) || ts.isTypeAssertionExpression(current) || ts.isSatisfiesExpression(current)) {
+      current = current.expression;
+    }
+    return current;
+  }
+  loadPlace(place, target) {
+    const b = this.fn.b;
+    switch (place.kind) {
+      case "local":
+        if (place.reg !== target) b.emit(abc(Op.MOVE, target, place.reg, 0));
+        break;
+      case "upval":
+        b.emit(abc(Op.GETUPVAL, target, place.index, 0));
+        break;
+      case "global":
+        if (place.name === "nil") b.emit(abc(Op.LOADNIL, target, 0, 0));
+        else b.emit(abc(Op.GETGLOBAL, target, 0, 0), b.string(place.name));
+        break;
+    }
+  }
+  exprTo(node, target) {
+    const b = this.fn.b;
+    const inner = this.unwrap(node);
+    const mark = b.top;
+    if (ts.isNumericLiteral(inner)) {
+      b.loadNumber(target, numberOf(inner));
+    } else if (ts.isStringLiteral(inner) || ts.isNoSubstitutionTemplateLiteral(inner)) {
+      b.loadString(target, inner.text);
+    } else if (inner.kind === ts.SyntaxKind.TrueKeyword || inner.kind === ts.SyntaxKind.FalseKeyword) {
+      b.emit(abc(Op.LOADB, target, inner.kind === ts.SyntaxKind.TrueKeyword ? TRUE : FALSE, 0));
+    } else if (inner.kind === ts.SyntaxKind.NullKeyword) {
+      b.emit(abc(Op.LOADNIL, target, 0, 0));
+    } else if (ts.isIdentifier(inner)) {
+      this.loadPlace(this.place(inner), target);
+    } else if (inner.kind === ts.SyntaxKind.ThisKeyword) {
+      this.loadPlace(this.selfPlace(inner), target);
+    } else if (ts.isTemplateExpression(inner)) {
+      this.template(inner, target);
+    } else if (ts.isArrayLiteralExpression(inner)) {
+      this.arrayLiteral(inner, target);
+    } else if (ts.isObjectLiteralExpression(inner)) {
+      this.objectLiteral(inner, target);
+    } else if (ts.isPropertyAccessExpression(inner)) {
+      this.propertyGet(inner, target);
+    } else if (ts.isElementAccessExpression(inner)) {
+      this.elementGet(inner, target);
+    } else if (ts.isCallExpression(inner)) {
+      this.call(inner, target);
+    } else if (ts.isNewExpression(inner)) {
+      this.newExpression(inner, target);
+    } else if (ts.isArrowFunction(inner) || ts.isFunctionExpression(inner)) {
+      this.closureTo(inner, target, ts.isFunctionExpression(inner) ? inner.name?.text ?? null : null);
+    } else if (ts.isPrefixUnaryExpression(inner)) {
+      this.prefix(inner, target);
+    } else if (ts.isPostfixUnaryExpression(inner)) {
+      this.increment(inner, target);
+    } else if (ts.isBinaryExpression(inner)) {
+      this.binary(inner, target);
+    } else if (ts.isConditionalExpression(inner)) {
+      const otherwise = b.label();
+      const end = b.label();
+      this.jumpIfFalse(inner.condition, otherwise);
+      b.release(mark);
+      this.exprTo(inner.whenTrue, target);
+      b.jump(end);
+      b.here(otherwise);
+      this.exprTo(inner.whenFalse, target);
+      b.here(end);
+    } else {
+      this.refuse(inner, `${this.quoted(inner)} is not supported in Rive scripts`);
+    }
+    b.release(mark);
+  }
+  template(node, target) {
+    const parts = [];
+    if (node.head.text.length > 0) parts.push(node.head.text);
+    for (const span of node.templateSpans) {
+      parts.push(span.expression);
+      if (span.literal.text.length > 0) parts.push(span.literal.text);
+    }
+    this.concat(parts, target);
+  }
+  concat(parts, target) {
+    const b = this.fn.b;
+    if (parts.length === 1 && typeof parts[0] !== "string") {
+      this.stringify(parts[0], target);
+      return;
+    }
+    const base = b.reserve(parts.length);
+    parts.forEach((part, i) => {
+      if (typeof part === "string") b.loadString(base + i, part);
+      else this.concatOperand(part, base + i);
+    });
+    b.emit(abc(Op.CONCAT, target, base, base + parts.length - 1));
+  }
+  concatOperand(node, target) {
+    const type = this.typeOf(node);
+    if (this.isString(type) || this.isNumber(type)) this.exprTo(node, target);
+    else this.stringify(node, target);
+  }
+  stringify(node, target) {
+    const b = this.fn.b;
+    if (this.isString(this.typeOf(node))) {
+      this.exprTo(node, target);
+      return;
+    }
+    const mark = b.top;
+    const base = b.reserve(2);
+    b.emit(abc(Op.GETGLOBAL, base, 0, 0), b.string("tostring"));
+    this.exprTo(node, base + ARGS_OFFSET);
+    b.emit(abc(Op.CALL, base, 2, RESULTS_ONE));
+    if (base !== target) b.emit(abc(Op.MOVE, target, base, 0));
+    b.release(mark);
+  }
+  flattenConcat(node, out) {
+    const inner = this.unwrap(node);
+    if (ts.isBinaryExpression(inner) && inner.operatorToken.kind === ts.SyntaxKind.PlusToken && this.isString(this.typeOf(inner))) {
+      this.flattenConcat(inner.left, out);
+      this.flattenConcat(inner.right, out);
+      return;
+    }
+    if (ts.isStringLiteral(inner) || ts.isNoSubstitutionTemplateLiteral(inner)) {
+      out.push(inner.text);
+      return;
+    }
+    out.push(inner);
+  }
+  arrayLiteral(node, target) {
+    const b = this.fn.b;
+    const count = node.elements.length;
+    const table = b.reserve(1);
+    b.emit(abc(Op.NEWTABLE, table, 0, 0), count);
+    for (let start = 0; start < count; start += LIST_BATCH) {
+      const batch = node.elements.slice(start, start + LIST_BATCH);
+      const mark = b.top;
+      const base = b.reserve(batch.length);
+      batch.forEach((element, i) => {
+        if (ts.isSpreadElement(element)) this.refuse(element, "spread is not supported");
+        if (ts.isOmittedExpression(element)) this.refuse(element, "array holes are not supported");
+        this.exprTo(element, base + i);
+      });
+      b.emit(abc(Op.SETLIST, table, base, batch.length + 1), start + ARRAY_BASE);
+      b.release(mark);
+    }
+    if (table !== target) b.emit(abc(Op.MOVE, target, table, 0));
+  }
+  propertyName(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name)) return name.text;
+    if (ts.isNumericLiteral(name)) return name.text;
+    return this.refuse(name, "computed property names are not supported");
+  }
+  objectLiteral(node, target) {
+    const b = this.fn.b;
+    const table = b.reserve(1);
+    b.emit(abc(Op.NEWTABLE, table, 0, 0), 0);
+    for (const property of node.properties) {
+      const mark = b.top;
+      this.at(property);
+      if (ts.isPropertyAssignment(property)) {
+        const value = this.exprAny(property.initializer);
+        b.emit(abc(Op.SETTABLEKS, value, table, 0), b.string(this.propertyName(property.name)));
+      } else if (ts.isShorthandPropertyAssignment(property)) {
+        const value = this.exprAny(property.name);
+        b.emit(abc(Op.SETTABLEKS, value, table, 0), b.string(property.name.text));
+      } else if (ts.isMethodDeclaration(property)) {
+        const value = b.reserve(1);
+        const name = this.propertyName(property.name);
+        this.closureTo(property, value, name);
+        b.emit(abc(Op.SETTABLEKS, value, table, 0), b.string(name));
+      } else {
+        this.refuse(property, `${this.quoted(property)} in an object literal is not supported in Rive scripts`);
+      }
+      b.release(mark);
+    }
+    if (table !== target) b.emit(abc(Op.MOVE, target, table, 0));
+  }
+  isMathObject(node) {
+    const inner = this.unwrap(node);
+    if (!ts.isIdentifier(inner) || inner.text !== "Math") return false;
+    const symbol = this.symbolOf(inner);
+    return symbol !== void 0 && this.isAmbient(symbol);
+  }
+  propertyGet(node, target) {
+    const b = this.fn.b;
+    if (node.questionDotToken !== void 0) this.refuse(node, "optional chaining is not supported in Rive scripts yet");
+    const name = node.name.text;
+    const objectType = this.typeOf(node.expression);
+    if (name === "length" && (this.isArray(objectType) || this.isString(objectType))) {
+      const object2 = this.exprAny(node.expression);
+      b.emit(abc(Op.LENGTH, target, object2, 0));
+      return;
+    }
+    const key = this.isMathObject(node.expression) ? MATH_RENAMES.get(name) ?? name : name;
+    const object = this.exprAny(node.expression);
+    b.emit(abc(Op.GETTABLEKS, target, object, 0), b.string(key));
+  }
+  arrayIndex(node) {
+    const b = this.fn.b;
+    const inner = this.unwrap(node);
+    if (!this.isNumber(this.typeOf(inner))) this.refuse(inner, "arrays are indexed by numbers");
+    const index = b.reserve(1);
+    if (ts.isNumericLiteral(inner)) {
+      b.loadNumber(index, numberOf(inner) + ARRAY_BASE);
+    } else {
+      const value = this.exprAny(inner);
+      b.emit(abc(Op.ADDK, index, value, b.number(ARRAY_BASE)));
+    }
+    return index;
+  }
+  elementKey(node) {
+    if (this.isArray(this.typeOf(node.expression))) return this.arrayIndex(node.argumentExpression);
+    if (!this.isString(this.typeOf(node.argumentExpression))) {
+      this.refuse(node.argumentExpression, "only arrays and string-keyed records can be indexed");
+    }
+    return this.exprAny(node.argumentExpression);
+  }
+  elementGet(node, target) {
+    const b = this.fn.b;
+    if (node.questionDotToken !== void 0) this.refuse(node, "optional chaining is not supported in Rive scripts yet");
+    const object = this.exprAny(node.expression);
+    const key = this.elementKey(node);
+    b.emit(abc(Op.GETTABLE, target, object, key));
+  }
+  isSelfMethod(node) {
+    const symbol = this.checker.getSymbolAtLocation(node.name);
+    const declaration = symbol?.declarations?.[0];
+    if (declaration === void 0) return false;
+    if (!ts.isMethodDeclaration(declaration) && !ts.isMethodSignature(declaration)) return false;
+    if ((ts.getCombinedModifierFlags(declaration) & ts.ModifierFlags.Static) !== 0) return false;
+    if (declaration.getSourceFile().fileName === LIB_FILE) return true;
+    return ts.isClassDeclaration(declaration.parent);
+  }
+  call(node, target) {
+    const b = this.fn.b;
+    if (node.questionDotToken !== void 0) this.refuse(node, "optional calls are not supported in Rive scripts yet");
+    for (const arg of node.arguments) if (ts.isSpreadElement(arg)) this.refuse(arg, "spread arguments are not supported");
+    const callee = this.unwrap(node.expression);
+    if (callee.kind === ts.SyntaxKind.SuperKeyword) this.refuse(callee, "super is not supported");
+    const mark = b.top;
+    if (ts.isPropertyAccessExpression(callee)) {
+      const objectType = this.typeOf(callee.expression);
+      const name = callee.name.text;
+      if (this.isArray(objectType) && (name === "push" || name === "pop")) {
+        this.arrayMethod(callee, name, node.arguments, target);
+        b.release(mark);
+        return;
+      }
+      if (this.isString(objectType)) {
+        this.stringMethod(callee, name, node.arguments, target);
+        b.release(mark);
+        return;
+      }
+      if (!this.isMathObject(callee.expression) && this.isSelfMethod(callee)) {
+        const object = this.exprAny(callee.expression);
+        const base2 = b.reserve(NAMECALL_ARGS_OFFSET + node.arguments.length);
+        node.arguments.forEach((arg, i) => this.exprTo(arg, base2 + NAMECALL_ARGS_OFFSET + i));
+        b.emit(abc(Op.NAMECALL, base2, object, 0), b.string(name));
+        this.finishCall(base2, node.arguments.length + NAMECALL_ARGS_OFFSET, target);
+        b.release(mark);
+        return;
+      }
+    }
+    const base = b.reserve(ARGS_OFFSET + node.arguments.length);
+    this.exprTo(callee, base);
+    node.arguments.forEach((arg, i) => this.exprTo(arg, base + ARGS_OFFSET + i));
+    this.finishCall(base, node.arguments.length + ARGS_OFFSET, target);
+    b.release(mark);
+  }
+  finishCall(base, argsPlusOne, target) {
+    const b = this.fn.b;
+    b.emit(abc(Op.CALL, base, argsPlusOne, target === null ? RESULTS_NONE : RESULTS_ONE));
+    if (target !== null && target !== base) b.emit(abc(Op.MOVE, target, base, 0));
+  }
+  arrayMethod(callee, name, args, target) {
+    const b = this.fn.b;
+    const table = this.exprAny(callee.expression);
+    const index = b.reserve(1);
+    b.emit(abc(Op.LENGTH, index, table, 0));
+    if (name === "push") {
+      if (args.length !== 1) this.refuse(callee, "push takes one item in Rive scripts");
+      b.emit(abc(Op.ADDK, index, index, b.number(ARRAY_BASE)));
+      const value2 = this.exprAny(args[0]);
+      b.emit(abc(Op.SETTABLE, value2, table, index));
+      if (target !== null) b.emit(abc(Op.MOVE, target, index, 0));
+      return;
+    }
+    const value = b.reserve(1);
+    b.emit(abc(Op.GETTABLE, value, table, index));
+    const nil = b.reserve(1);
+    b.emit(abc(Op.LOADNIL, nil, 0, 0));
+    b.emit(abc(Op.SETTABLE, nil, table, index));
+    if (target !== null) b.emit(abc(Op.MOVE, target, value, 0));
+  }
+  stringMethod(callee, name, args, target) {
+    const b = this.fn.b;
+    const renames = { toUpperCase: "upper", toLowerCase: "lower", substring: "sub" };
+    const method = renames[name];
+    if (method === void 0) this.refuse(callee, `string method ${name} is not supported`);
+    const object = this.exprAny(callee.expression);
+    const base = b.reserve(NAMECALL_ARGS_OFFSET + args.length);
+    if (name === "substring") {
+      const start = args[0];
+      if (start === void 0) this.refuse(callee, "substring needs a start");
+      const first = this.exprAny(start);
+      b.emit(abc(Op.ADDK, base + NAMECALL_ARGS_OFFSET, first, b.number(ARRAY_BASE)));
+      if (args[1] !== void 0) this.exprTo(args[1], base + NAMECALL_ARGS_OFFSET + 1);
+    }
+    b.emit(abc(Op.NAMECALL, base, object, 0), b.string(method));
+    this.finishCall(base, NAMECALL_ARGS_OFFSET + args.length, target);
+  }
+  newExpression(node, target) {
+    const b = this.fn.b;
+    const args = node.arguments ?? ts.factory.createNodeArray([]);
+    for (const arg of args) if (ts.isSpreadElement(arg)) this.refuse(arg, "spread arguments are not supported");
+    const constructor = this.exprAny(node.expression);
+    const base = b.reserve(ARGS_OFFSET + args.length);
+    b.emit(abc(Op.GETTABLEKS, base, constructor, 0), b.string("new"));
+    args.forEach((arg, i) => this.exprTo(arg, base + ARGS_OFFSET + i));
+    this.finishCall(base, args.length + ARGS_OFFSET, target);
+  }
+  prefix(node, target) {
+    const b = this.fn.b;
+    switch (node.operator) {
+      case ts.SyntaxKind.MinusToken: {
+        const operand = this.unwrap(node.operand);
+        if (ts.isNumericLiteral(operand)) {
+          b.loadNumber(target, -numberOf(operand));
+          return;
+        }
+        const value = this.exprAny(operand);
+        b.emit(abc(Op.MINUS, target, value, 0));
+        return;
+      }
+      case ts.SyntaxKind.PlusToken:
+        if (!this.isNumber(this.typeOf(node.operand))) this.refuse(node, "unary plus applies to numbers only");
+        this.exprTo(node.operand, target);
+        return;
+      case ts.SyntaxKind.ExclamationToken:
+        this.booleanTo(node, target);
+        return;
+      case ts.SyntaxKind.PlusPlusToken:
+      case ts.SyntaxKind.MinusMinusToken:
+        this.increment(node, target);
+        return;
+      default:
+        this.refuse(node, "bitwise operators are not supported in Rive scripts yet");
+    }
+  }
+  booleanTo(node, target) {
+    const b = this.fn.b;
+    const otherwise = b.label();
+    const mark = b.top;
+    this.jumpIfFalse(node, otherwise);
+    b.release(mark);
+    b.emit(abc(Op.LOADB, target, TRUE, SKIP_ONE));
+    b.here(otherwise);
+    b.emit(abc(Op.LOADB, target, FALSE, 0));
+  }
+  binary(node, target) {
+    const b = this.fn.b;
+    const kind = node.operatorToken.kind;
+    if (this.isAssignment(kind)) {
+      this.assignment(node, target);
+      return;
+    }
+    switch (kind) {
+      case ts.SyntaxKind.PlusToken:
+        if (this.isString(this.typeOf(node))) {
+          const parts = [];
+          this.flattenConcat(node, parts);
+          this.concat(parts, target);
+          return;
+        }
+        this.arithmetic(Op.ADD, node.left, node.right, target);
+        return;
+      case ts.SyntaxKind.MinusToken:
+        this.arithmetic(Op.SUB, node.left, node.right, target);
+        return;
+      case ts.SyntaxKind.AsteriskToken:
+        this.arithmetic(Op.MUL, node.left, node.right, target);
+        return;
+      case ts.SyntaxKind.SlashToken:
+        this.arithmetic(Op.DIV, node.left, node.right, target);
+        return;
+      case ts.SyntaxKind.AsteriskAsteriskToken:
+        this.arithmetic(Op.POW, node.left, node.right, target);
+        return;
+      case ts.SyntaxKind.PercentToken: {
+        const base = b.reserve(3);
+        b.emit(abc(Op.GETGLOBAL, base, 0, 0), b.string("math"));
+        b.emit(abc(Op.GETTABLEKS, base, base, 0), b.string("fmod"));
+        this.exprTo(node.left, base + 1);
+        this.exprTo(node.right, base + 2);
+        b.emit(abc(Op.CALL, base, 3, RESULTS_ONE));
+        if (base !== target) b.emit(abc(Op.MOVE, target, base, 0));
+        return;
+      }
+      case ts.SyntaxKind.AmpersandAmpersandToken:
+      case ts.SyntaxKind.BarBarToken: {
+        const end = b.label();
+        const leftType = this.typeOf(node.left);
+        const scratch = b.reserve(1);
+        this.exprTo(node.left, scratch);
+        if (kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+          b.emit(abc(Op.MOVE, target, scratch, 0));
+          this.falsyJumps(scratch, leftType, end);
+        } else {
+          const falsy = b.label();
+          b.emit(abc(Op.MOVE, target, scratch, 0));
+          this.falsyJumps(scratch, leftType, falsy);
+          b.jump(end);
+          b.here(falsy);
+        }
+        this.exprTo(node.right, target);
+        b.here(end);
+        return;
+      }
+      case ts.SyntaxKind.QuestionQuestionToken: {
+        const end = b.label();
+        const scratch = b.reserve(1);
+        this.exprTo(node.left, scratch);
+        b.emit(abc(Op.MOVE, target, scratch, 0));
+        const nil = b.reserve(1);
+        b.emit(abc(Op.LOADNIL, nil, 0, 0));
+        b.jumpTo(Op.JUMPIFNOTEQ, scratch, end, nil);
+        this.exprTo(node.right, target);
+        b.here(end);
+        return;
+      }
+      case ts.SyntaxKind.EqualsEqualsEqualsToken:
+      case ts.SyntaxKind.ExclamationEqualsEqualsToken:
+      case ts.SyntaxKind.EqualsEqualsToken:
+      case ts.SyntaxKind.ExclamationEqualsToken:
+      case ts.SyntaxKind.LessThanToken:
+      case ts.SyntaxKind.LessThanEqualsToken:
+      case ts.SyntaxKind.GreaterThanToken:
+      case ts.SyntaxKind.GreaterThanEqualsToken:
+        this.booleanTo(node, target);
+        return;
+      case ts.SyntaxKind.CommaToken:
+        this.effect(node.left);
+        this.exprTo(node.right, target);
+        return;
+      default:
+        this.refuse(node, `the ${ts.tokenToString(kind) ?? "operator"} operator is not supported in Rive scripts yet`);
+    }
+  }
+  arithmetic(op, left, right, target) {
+    const b = this.fn.b;
+    for (const side of [left, right]) {
+      if (!this.isNumber(this.typeOf(side))) this.refuse(side, "arithmetic applies to numbers only");
+    }
+    const rightInner = this.unwrap(right);
+    if ((op === Op.ADD || op === Op.SUB) && ts.isNumericLiteral(rightInner)) {
+      const a2 = this.exprAny(left);
+      b.emit(abc(op === Op.ADD ? Op.ADDK : Op.SUBK, target, a2, b.number(numberOf(rightInner))));
+      return;
+    }
+    const a = this.exprAny(left);
+    const c = this.exprAny(right);
+    b.emit(abc(op, target, a, c));
+  }
+  falsyJumps(reg, type, falsy) {
+    const b = this.fn.b;
+    b.jumpTo(Op.JUMPIFNOT, reg, falsy);
+    const mark = b.top;
+    if (this.mayBe(type, ts.TypeFlags.NumberLike)) {
+      const zero = b.reserve(1);
+      b.loadNumber(zero, 0);
+      b.jumpTo(Op.JUMPIFEQ, reg, falsy, zero);
+      b.jumpTo(Op.JUMPIFNOTEQ, reg, falsy, reg);
+    }
+    if (this.mayBe(type, ts.TypeFlags.StringLike)) {
+      const empty = b.reserve(1);
+      b.loadString(empty, "");
+      b.jumpTo(Op.JUMPIFEQ, reg, falsy, empty);
+    }
+    b.release(mark);
+  }
+  jumpIfFalse(node, falsy) {
+    const b = this.fn.b;
+    const inner = this.unwrap(node);
+    if (ts.isPrefixUnaryExpression(inner) && inner.operator === ts.SyntaxKind.ExclamationToken) {
+      this.jumpIfTrue(inner.operand, falsy);
+      return;
+    }
+    if (ts.isBinaryExpression(inner)) {
+      const kind = inner.operatorToken.kind;
+      if (kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+        this.jumpIfFalse(inner.left, falsy);
+        this.jumpIfFalse(inner.right, falsy);
+        return;
+      }
+      if (kind === ts.SyntaxKind.BarBarToken) {
+        const truthy = b.label();
+        this.jumpIfTrue(inner.left, truthy);
+        this.jumpIfFalse(inner.right, falsy);
+        b.here(truthy);
+        return;
+      }
+      if (this.compare(inner, falsy, false)) return;
+    }
+    if (inner.kind === ts.SyntaxKind.TrueKeyword) return;
+    const mark = b.top;
+    const reg = this.exprAny(inner);
+    this.falsyJumps(reg, this.typeOf(inner), falsy);
+    b.release(mark);
+  }
+  jumpIfTrue(node, truthy) {
+    const b = this.fn.b;
+    const falsy = b.label();
+    this.jumpIfFalse(node, falsy);
+    b.jump(truthy);
+    b.here(falsy);
+  }
+  compare(node, label, whenTrue) {
+    const b = this.fn.b;
+    const kind = node.operatorToken.kind;
+    let op;
+    let swap = false;
+    switch (kind) {
+      case ts.SyntaxKind.EqualsEqualsEqualsToken:
+      case ts.SyntaxKind.EqualsEqualsToken:
+        op = whenTrue ? Op.JUMPIFEQ : Op.JUMPIFNOTEQ;
+        break;
+      case ts.SyntaxKind.ExclamationEqualsEqualsToken:
+      case ts.SyntaxKind.ExclamationEqualsToken:
+        op = whenTrue ? Op.JUMPIFNOTEQ : Op.JUMPIFEQ;
+        break;
+      case ts.SyntaxKind.LessThanToken:
+        op = whenTrue ? Op.JUMPIFLT : Op.JUMPIFNOTLT;
+        break;
+      case ts.SyntaxKind.LessThanEqualsToken:
+        op = whenTrue ? Op.JUMPIFLE : Op.JUMPIFNOTLE;
+        break;
+      case ts.SyntaxKind.GreaterThanToken:
+        op = whenTrue ? Op.JUMPIFLT : Op.JUMPIFNOTLT;
+        swap = true;
+        break;
+      case ts.SyntaxKind.GreaterThanEqualsToken:
+        op = whenTrue ? Op.JUMPIFLE : Op.JUMPIFNOTLE;
+        swap = true;
+        break;
+      default:
+        return false;
+    }
+    const ordered = op !== Op.JUMPIFEQ && op !== Op.JUMPIFNOTEQ;
+    if (ordered) {
+      for (const side of [node.left, node.right]) {
+        const type = this.typeOf(side);
+        if (!this.isNumber(type) && !this.isString(type)) this.refuse(side, "ordered comparisons apply to numbers or strings");
+      }
+    }
+    const mark = b.top;
+    const left = this.exprAny(node.left);
+    const right = this.exprAny(node.right);
+    const [a, c] = swap ? [right, left] : [left, right];
+    b.jumpTo(op, a, label, c);
+    b.release(mark);
+    return true;
+  }
+  assignment(node, target) {
+    const b = this.fn.b;
+    const kind = node.operatorToken.kind;
+    const left = this.unwrap(node.left);
+    const compute = (into) => {
+      if (kind === ts.SyntaxKind.EqualsToken) {
+        this.exprTo(node.right, into);
+        return;
+      }
+      const synthetic = this.compoundValue(node, left);
+      synthetic(into);
+    };
+    if (ts.isIdentifier(left)) {
+      const place = this.place(left);
+      if (place.kind === "global") this.refuse(left, "globals cannot be assigned");
+      const value = b.reserve(1);
+      compute(value);
+      if (place.kind === "local") b.emit(abc(Op.MOVE, place.reg, value, 0));
+      else b.emit(abc(Op.SETUPVAL, value, place.index, 0));
+      if (target !== null) b.emit(abc(Op.MOVE, target, value, 0));
+      return;
+    }
+    if (ts.isPropertyAccessExpression(left)) {
+      const object = this.exprAny(left.expression);
+      const value = b.reserve(1);
+      compute(value);
+      b.emit(abc(Op.SETTABLEKS, value, object, 0), b.string(left.name.text));
+      if (target !== null) b.emit(abc(Op.MOVE, target, value, 0));
+      return;
+    }
+    if (ts.isElementAccessExpression(left)) {
+      const object = this.exprAny(left.expression);
+      const key = this.elementKey(left);
+      const value = b.reserve(1);
+      compute(value);
+      b.emit(abc(Op.SETTABLE, value, object, key));
+      if (target !== null) b.emit(abc(Op.MOVE, target, value, 0));
+      return;
+    }
+    if (left.kind === ts.SyntaxKind.ThisKeyword) this.refuse(left, "this cannot be assigned");
+    this.refuse(left, "this assignment target is not supported");
+  }
+  compoundValue(node, left) {
+    const b = this.fn.b;
+    const kind = node.operatorToken.kind;
+    return (into) => {
+      if (kind === ts.SyntaxKind.QuestionQuestionEqualsToken) {
+        const end = b.label();
+        this.exprTo(left, into);
+        const mark = b.top;
+        const nil = b.reserve(1);
+        b.emit(abc(Op.LOADNIL, nil, 0, 0));
+        b.jumpTo(Op.JUMPIFNOTEQ, into, end, nil);
+        b.release(mark);
+        this.exprTo(node.right, into);
+        b.here(end);
+        return;
+      }
+      if (kind === ts.SyntaxKind.PlusEqualsToken && this.isString(this.typeOf(left))) {
+        const mark = b.top;
+        const base = b.reserve(2);
+        this.exprTo(left, base);
+        this.concatOperand(node.right, base + 1);
+        b.emit(abc(Op.CONCAT, into, base, base + 1));
+        b.release(mark);
+        return;
+      }
+      const ops = {
+        [ts.SyntaxKind.PlusEqualsToken]: Op.ADD,
+        [ts.SyntaxKind.MinusEqualsToken]: Op.SUB,
+        [ts.SyntaxKind.AsteriskEqualsToken]: Op.MUL,
+        [ts.SyntaxKind.SlashEqualsToken]: Op.DIV
+      };
+      const op = ops[kind];
+      if (op === void 0) this.refuse(node, "this compound assignment is not supported");
+      this.arithmetic(op, left, node.right, into);
+    };
+  }
+  increment(node, target) {
+    const b = this.fn.b;
+    const step = node.operator === ts.SyntaxKind.PlusPlusToken ? Op.ADDK : Op.SUBK;
+    const operand = this.unwrap(node.operand);
+    if (!this.isNumber(this.typeOf(operand))) this.refuse(operand, "++ and -- apply to numbers only");
+    const old = b.reserve(1);
+    const value = b.reserve(1);
+    const store = () => {
+      if (ts.isIdentifier(operand)) {
+        const place = this.place(operand);
+        if (place.kind === "local") b.emit(abc(Op.MOVE, place.reg, value, 0));
+        else if (place.kind === "upval") b.emit(abc(Op.SETUPVAL, value, place.index, 0));
+        else this.refuse(operand, "globals cannot be assigned");
+      }
+    };
+    if (ts.isIdentifier(operand)) {
+      this.exprTo(operand, old);
+      b.emit(abc(step, value, old, b.number(1)));
+      store();
+    } else if (ts.isPropertyAccessExpression(operand)) {
+      const object = this.exprAny(operand.expression);
+      b.emit(abc(Op.GETTABLEKS, old, object, 0), b.string(operand.name.text));
+      b.emit(abc(step, value, old, b.number(1)));
+      b.emit(abc(Op.SETTABLEKS, value, object, 0), b.string(operand.name.text));
+    } else if (ts.isElementAccessExpression(operand)) {
+      const object = this.exprAny(operand.expression);
+      const key = this.elementKey(operand);
+      b.emit(abc(Op.GETTABLE, old, object, key));
+      b.emit(abc(step, value, old, b.number(1)));
+      b.emit(abc(Op.SETTABLE, value, object, key));
+    } else {
+      this.refuse(operand, "this increment target is not supported");
+    }
+    if (target !== null) {
+      const prefix = ts.isPrefixUnaryExpression(node);
+      b.emit(abc(Op.MOVE, target, prefix ? value : old, 0));
+    }
+  }
+};
+function lowerError(error, source) {
+  if (error instanceof Refusal) {
+    const { line, character } = source.getLineAndCharacterOfPosition(error.node.getStart(source));
+    return { message: error.message, line: line + 1, column: character + 1 };
+  }
+  if (error instanceof CompileLimit) return { message: TOO_LARGE, line: 0, column: 0 };
+  return null;
+}
+
+// src/interactives/scripting/ts/compile.ts
+var OPTIONS = {
+  noLib: true,
+  strict: true,
+  target: ts.ScriptTarget.ES2020,
+  module: ts.ModuleKind.ESNext,
+  types: [],
+  noEmit: true,
+  allowUnreachableCode: false
+};
+var LIB_TEXT = {
+  rive: LIB_SOURCE,
+  tool: `${LIB_SOURCE}${TOOL_LIB_SOURCE}`
+};
+var libraries = /* @__PURE__ */ new Map();
+function library(kind) {
+  let file = libraries.get(kind);
+  if (file === void 0) {
+    file = ts.createSourceFile(LIB_FILE, LIB_TEXT[kind], ts.ScriptTarget.ES2020, true);
+    libraries.set(kind, file);
+  }
+  return file;
+}
+function host(fileName, source, kind) {
+  const files = /* @__PURE__ */ new Map([
+    [fileName, ts.createSourceFile(fileName, source, ts.ScriptTarget.ES2020, true)],
+    [LIB_FILE, library(kind)]
+  ]);
+  return {
+    getSourceFile: (name) => files.get(name),
+    getDefaultLibFileName: () => LIB_FILE,
+    writeFile: () => void 0,
+    getCurrentDirectory: () => "",
+    getCanonicalFileName: (name) => name,
+    useCaseSensitiveFileNames: () => true,
+    getNewLine: () => "\n",
+    fileExists: (name) => files.has(name),
+    readFile: (name) => files.get(name)?.text,
+    getDirectories: () => []
+  };
+}
+function diagnostic2(d) {
+  const message = ts.flattenDiagnosticMessageText(d.messageText, "\n");
+  if (d.file === void 0 || d.start === void 0) return { message, line: 0, column: 0 };
+  const { line, character } = d.file.getLineAndCharacterOfPosition(d.start);
+  return { message, line: line + 1, column: character + 1 };
+}
+function compileScript(fileName, source, kind = "rive") {
+  const program = ts.createProgram({ rootNames: [fileName, LIB_FILE], options: OPTIONS, host: host(fileName, source, kind) });
+  const diagnostics = ts.getPreEmitDiagnostics(program).map(diagnostic2);
+  if (diagnostics.length > 0) return { ok: false, diagnostics };
+  const file = program.getSourceFile(fileName);
+  if (file === void 0) return { ok: false, diagnostics: [{ message: "the script did not parse", line: 0, column: 0 }] };
+  const lowering = new Lowering(program.getTypeChecker(), file);
+  try {
+    const main = lowering.compileModule();
+    return { ok: true, bytecode: writeBytecode(lowering.protos, main) };
+  } catch (error) {
+    const found = lowerError(error, file);
+    if (found === null) throw error;
+    return { ok: false, diagnostics: [found] };
+  }
+}
+
+export { PASSTHROUGH_CONVERTER, assetKind, checkRefusals, compileGroups, compileScript, extensionOf, groupOf, isCodePath };