@creationix/rex 0.3.1 → 0.6.0

package/rx-cli.js

@@ -0,0 +1,2836 @@
+#!/usr/bin/env node
+// b64.ts
+var regex = /^[0-9a-zA-Z\-_]*$/;
+var chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_";
+var decodeTable = new Uint8Array(256).fill(255);
+var encodeTable = new Uint8Array(64);
+for (let i = 0;i < 64; i++) {
+  const code = chars.charCodeAt(i);
+  decodeTable[code] = i;
+  encodeTable[i] = code;
+}
+function is(byte) {
+  return decodeTable[byte] !== 255;
+}
+function stringify(num) {
+  if (!Number.isSafeInteger(num) || num < 0) {
+    throw new Error(`Cannot stringify ${num} as base64`);
+  }
+  let result = "";
+  while (num > 0) {
+    result = chars[num % 64] + result;
+    num = Math.floor(num / 64);
+  }
+  return result;
+}
+function read(data, left, right) {
+  let result = 0;
+  for (let i = left;i < right; i++) {
+    const digit = decodeTable[data[i]];
+    if (digit === 255) {
+      throw new Error(`Invalid base64 character code: ${data[i]}`);
+    }
+    result = result * 64 + digit;
+  }
+  return result;
+}
+
+// rexc.ts
+var BUILTIN_REFS = {
+  n: null,
+  t: true,
+  f: false,
+  u: undefined,
+  nan: NaN,
+  inf: Infinity,
+  nif: -Infinity
+};
+var ENCODE_DEFAULTS = {
+  chainSplit: "/",
+  indexes: 32,
+  refs: {}
+};
+var DECODE_DEFAULTS = {
+  lazy: false,
+  refs: {}
+};
+function toZigZag(num) {
+  if (num >= -2147483648 && num <= 2147483647) {
+    return num << 1 ^ num >> 31;
+  }
+  return num < 0 ? num * -2 - 1 : num * 2;
+}
+function writeStringPair(tag, value) {
+  if (!regex.test(value)) {
+    throw new TypeError(`String contains invalid characters for inline encoding: ${value}`);
+  }
+  return tag + value;
+}
+function writeUnsigned(tag, value) {
+  if (value < 0) {
+    throw new RangeError(`Value must be non-negative, got ${value}`);
+  }
+  return `${tag}${stringify(value)}`;
+}
+function writeSigned(tag, value) {
+  return `${tag}${stringify(toZigZag(value))}`;
+}
+function stringify2(value, options) {
+  const { onChunk, ...rest } = options ?? {};
+  if (onChunk) {
+    encode(value, {
+      ...rest,
+      onChunk: (chunk, offset) => onChunk(new TextDecoder().decode(chunk), offset)
+    });
+    return;
+  }
+  return new TextDecoder().decode(encode(value, rest));
+}
+function encode(rootValue, options) {
+  const opts = { ...ENCODE_DEFAULTS, ...options };
+  const parts = [];
+  let byteLength = 0;
+  const onChunk = opts.onChunk ?? ((chunk) => parts.push(chunk));
+  const chainSplit = opts.chainSplit;
+  const refs = Object.fromEntries(Object.entries({ ...opts.refs }).map(([key, val]) => [makeKey(val), key]));
+  const indexThreshold = typeof opts.indexes === "number" ? opts.indexes : Infinity;
+  const seenOffsets = {};
+  const schemaOffsets = {};
+  const seenCosts = {};
+  for (const [key, val] of Object.entries(opts.refs)) {
+    if (typeof val === "object" && val !== null) {
+      if (Array.isArray(val)) {
+        schemaOffsets[makeKey(val)] = key;
+      } else {
+        schemaOffsets[makeKey(Object.keys(val))] = key;
+      }
+    }
+  }
+  const duplicatePrefixes = new Set;
+  const seenPrefixes = new Set;
+  scanPrefixes(rootValue);
+  function scanPrefixes(value) {
+    if (!chainSplit)
+      return;
+    if (typeof value === "string" && value.indexOf(chainSplit) >= 0) {
+      let offset2 = 0;
+      if (!seenPrefixes.has(value)) {
+        while (offset2 < value.length) {
+          const nextDelimiter = value.indexOf(chainSplit, offset2 + 1);
+          if (nextDelimiter === -1)
+            break;
+          const prefix = value.slice(0, nextDelimiter);
+          if (seenPrefixes.has(prefix)) {
+            duplicatePrefixes.add(prefix);
+          } else {
+            seenPrefixes.add(prefix);
+          }
+          offset2 = nextDelimiter;
+        }
+      }
+    } else if (value && typeof value === "object") {
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          scanPrefixes(item);
+        }
+      } else {
+        for (const [key, val] of Object.entries(value)) {
+          scanPrefixes(key);
+          scanPrefixes(val);
+        }
+      }
+    }
+  }
+  writeAny(rootValue);
+  if (opts.onChunk)
+    return;
+  const output = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const chunk of parts) {
+    output.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return output;
+  function pushBytes(bytes) {
+    onChunk(bytes, byteLength);
+    return byteLength += bytes.byteLength;
+  }
+  function pushString(str) {
+    const bytes = new TextEncoder().encode(str);
+    return pushBytes(bytes);
+  }
+  function writeAny(value) {
+    const key = makeKey(value);
+    const refKey = refs[key];
+    if (refKey !== undefined) {
+      return pushString(writeStringPair("'", refKey));
+    }
+    const seenOffset = seenOffsets[key];
+    if (seenOffset !== undefined) {
+      const delta = byteLength - seenOffset;
+      const seenCost = seenCosts[key] ?? 0;
+      const pointerCost = Math.ceil(Math.log(delta + 1) / Math.log(64)) + 1;
+      if (pointerCost < seenCost) {
+        return pushString(writeUnsigned("^", delta));
+      }
+    }
+    const before = byteLength;
+    const ret = writeAnyInner(value);
+    seenOffsets[key] = byteLength;
+    seenCosts[key] = byteLength - before;
+    return ret;
+  }
+  function writeAnyInner(value) {
+    switch (typeof value) {
+      case "string":
+        return writeString(value);
+      case "number":
+        return writeNumber(value);
+      case "boolean":
+        return pushString(writeStringPair("'", value ? "t" : "f"));
+      case "undefined":
+        return pushString(writeStringPair("'", "u"));
+      case "object":
+        if (value === null)
+          return pushString(writeStringPair("'", "n"));
+        if (Array.isArray(value))
+          return writeArray(value);
+        return writeObject(value);
+      default:
+        throw new TypeError(`Unsupported value type: ${typeof value}`);
+    }
+  }
+  function writeString(value) {
+    if (chainSplit && value.indexOf(chainSplit) >= 0) {
+      let offset2 = value.length;
+      let head;
+      let tail;
+      while (offset2 > 0) {
+        offset2 = value.lastIndexOf(chainSplit, offset2 - 1);
+        if (offset2 <= 0)
+          break;
+        const prefix = value.slice(0, offset2);
+        if (duplicatePrefixes.has(prefix)) {
+          head = prefix;
+          tail = value.substring(offset2);
+          break;
+        }
+      }
+      if (head && tail) {
+        const before = byteLength;
+        writeAny(tail);
+        writeAny(head);
+        const size = byteLength - before;
+        return pushString(writeUnsigned(".", size));
+      }
+    }
+    const utf8 = new TextEncoder().encode(value);
+    pushBytes(utf8);
+    return pushString(writeUnsigned(",", utf8.byteLength));
+  }
+  function writeNumber(value) {
+    if (Number.isNaN(value)) {
+      return pushString(writeStringPair("'", "nan"));
+    }
+    if (value === Infinity) {
+      return pushString(writeStringPair("'", "inf"));
+    }
+    if (value === -Infinity) {
+      return pushString(writeStringPair("'", "nif"));
+    }
+    const [base, exp] = splitNumber(value);
+    if (exp >= 0 && exp < 5 && Number.isInteger(base) && Number.isSafeInteger(base)) {
+      return pushString(writeSigned("+", value));
+    }
+    pushString(writeSigned("+", base));
+    return pushString(writeSigned("*", exp));
+  }
+  function writeArray(value) {
+    const start = byteLength;
+    writeValues(value);
+    return pushString(writeUnsigned(";", byteLength - start));
+  }
+  function writeValues(values) {
+    const length = values.length;
+    const offsets = length > indexThreshold ? new Array(length) : undefined;
+    for (let f = length - 1, i = f;i >= 0; i--) {
+      writeAny(values[i]);
+      if (offsets) {
+        offsets[i] = byteLength;
+      }
+    }
+    if (offsets) {
+      const lastOffset = offsets[offsets.length - 1];
+      const width = Math.ceil(Math.log(byteLength - lastOffset + 1) / Math.log(64));
+      const pointers = offsets.map((offset2) => stringify(byteLength - offset2).padStart(width, "0")).join("");
+      pushString(pointers);
+      if (width > 8) {
+        throw new Error(`Index width exceeds maximum of 8 characters: ${width}`);
+      }
+      pushString(writeUnsigned("#", values.length << 3 | width - 1));
+    }
+  }
+  function writeObject(value) {
+    const keys = Object.keys(value);
+    const length = keys.length;
+    if (length === 0) {
+      return pushString(":");
+    }
+    const keysKey = makeKey(keys);
+    const schemaTarget = schemaOffsets[keysKey] ?? seenOffsets[keysKey];
+    if (schemaTarget !== undefined) {
+      return writeSchemaObject(value, schemaTarget);
+    }
+    const before = byteLength;
+    const offsets = length > indexThreshold ? {} : undefined;
+    let lastOffset;
+    const entries = Object.entries(value);
+    for (let f = entries.length - 1, i = f;i >= 0; i--) {
+      const [key, val] = entries[i];
+      writeAny(val);
+      writeAny(key);
+      if (offsets) {
+        offsets[key] = byteLength;
+        lastOffset = lastOffset ?? byteLength;
+      }
+    }
+    if (offsets && lastOffset !== undefined) {
+      const width = Math.ceil(Math.log(byteLength - lastOffset + 1) / Math.log(64));
+      const pointers = Object.entries(offsets).sort(([a], [b]) => utf8Sort(a, b)).map(([, offset2]) => stringify(byteLength - offset2).padStart(width, "0")).join("");
+      pushString(pointers);
+      if (width > 8) {
+        throw new Error(`Index width exceeds maximum of 8 characters: ${width}`);
+      }
+      pushString(writeUnsigned("#", length << 3 | width - 1));
+    }
+    const ret = pushString(writeUnsigned(":", byteLength - before));
+    schemaOffsets[keysKey] = byteLength;
+    return ret;
+  }
+  function writeSchemaObject(value, target) {
+    const before = byteLength;
+    writeValues(Object.values(value));
+    if (typeof target === "string") {
+      pushString(writeStringPair("'", target));
+    } else {
+      pushString(writeUnsigned("^", byteLength - target));
+    }
+    return pushString(writeUnsigned(":", byteLength - before));
+  }
+}
+function zigzagDecode(num) {
+  if (num <= 4294967295) {
+    return num >>> 1 ^ -(num & 1);
+  }
+  return num % 2 === 0 ? num / 2 : (num + 1) / -2;
+}
+function b64Skip(data, offset) {
+  while (is(data[--offset] ?? 0))
+    ;
+  return offset + 1;
+}
+function peek(data, right) {
+  let left = b64Skip(data, right);
+  if (left <= 0) {
+    throw new SyntaxError("Unexpected end of input seeking for non-b64 tag");
+  }
+  const tag = data[--left];
+  return [left, tag];
+}
+function unpackIndex(data, left, right) {
+  const b64 = read(data, left, right);
+  return {
+    width: (b64 & 7) + 1,
+    count: b64 >> 3
+  };
+}
+function get(data, right = data.length) {
+  let [left, tag] = peek(data, right);
+  if (tag === 39) {
+    const ref = new TextDecoder().decode(data.subarray(left + 1, right));
+    if (ref in BUILTIN_REFS) {
+      return {
+        type: "primitive",
+        left,
+        right,
+        value: BUILTIN_REFS[ref]
+      };
+    }
+    return {
+      type: "pointer",
+      left,
+      right,
+      target: ref
+    };
+  }
+  const b64 = read(data, left + 1, right);
+  switch (tag) {
+    case 44:
+      return {
+        type: "primitive",
+        left: left - b64,
+        right,
+        value: new TextDecoder().decode(data.subarray(left - b64, left))
+      };
+    case 59: {
+      let content = left;
+      left -= b64;
+      let index;
+      if (content > left) {
+        const [l, t] = peek(data, content);
+        if (t === 35) {
+          index = unpackIndex(data, l + 1, content);
+          content = l - index.width * index.count;
+        }
+      }
+      return {
+        type: "array",
+        left,
+        right,
+        content,
+        index
+      };
+    }
+    case 58: {
+      let content = left;
+      left -= b64;
+      let index;
+      let schema;
+      while (content > left) {
+        const [l, t] = peek(data, content);
+        if (t === 35 && index === undefined) {
+          index = unpackIndex(data, l + 1, content);
+          content = l - index.width * index.count;
+        } else if ((t === 39 || t === 94) && schema === undefined) {
+          const ptr = get(data, content);
+          if (ptr.type !== "pointer") {
+            break;
+          }
+          if (t === 94) {
+            const target = get(data, ptr.target);
+            if (target.type !== "array" && target.type !== "object") {
+              break;
+            }
+          }
+          schema = ptr.target;
+          content = l;
+        } else {
+          break;
+        }
+      }
+      return {
+        type: "object",
+        left,
+        right,
+        content,
+        schema,
+        index
+      };
+    }
+    case 94:
+      return {
+        type: "pointer",
+        left,
+        right,
+        target: left - b64
+      };
+    case 46: {
+      return {
+        type: "chain",
+        left: left - b64,
+        right,
+        content: left
+      };
+      throw new Error("TODO: implement string chain reading");
+    }
+    case 42: {
+      const int = get(data, left);
+      if (int.type === "primitive" && typeof int.value === "number") {
+        return {
+          type: "primitive",
+          left: int.left,
+          right,
+          value: parseFloat(`${int.value}e${zigzagDecode(b64)}`)
+        };
+      }
+      throw new SyntaxError("Invalid number format in decimal");
+    }
+    case 43:
+      return {
+        type: "primitive",
+        left,
+        right,
+        value: zigzagDecode(b64)
+      };
+    default:
+      throw new SyntaxError(`Unknown tag: ${String.fromCharCode(tag)}`);
+  }
+}
+function* getEntries(context, node) {
+  if (node.type !== "object") {
+    throw new TypeError("Node must be an object");
+  }
+  const { data, refs } = context;
+  const { schema } = node;
+  let right = node.content;
+  if (schema !== undefined) {
+    let keyNodes;
+    if (typeof schema === "string") {
+      if (!(schema in refs)) {
+        throw new ReferenceError(`Unknown schema reference: ${schema}`);
+      }
+      const ref = refs[schema];
+      if (typeof ref !== "object" || ref === null) {
+        throw new TypeError("Schema reference must point to an object or array");
+      }
+      const keyStrings = Array.isArray(ref) ? ref : Object.keys(ref);
+      keyNodes = keyStrings.map((k) => ({
+        type: "primitive",
+        left: -1,
+        right: -1,
+        value: k
+      }));
+    } else if (typeof schema === "number") {
+      let targetNode = get(data, schema);
+      if (targetNode.type === "array") {
+        keyNodes = getEach(context, targetNode);
+      } else if (targetNode.type === "object") {
+        keyNodes = getEntries(context, targetNode).map(([k]) => k);
+      } else {
+        throw new TypeError("Schema reference must point to an object or array");
+      }
+    } else {
+      throw new TypeError("Invalid schema reference type");
+    }
+    const values = getEach(context, node);
+    const keysIter = keyNodes[Symbol.iterator]();
+    for (const value of values) {
+      const key = keysIter.next();
+      if (key.done) {
+        throw new SyntaxError("Not enough keys in schema reference for object entries");
+      }
+      yield [key.value, value];
+    }
+    return;
+  }
+  while (right > node.left) {
+    const key = get(data, right);
+    right = key.left;
+    const value = get(data, right);
+    right = value.left;
+    yield [key, value];
+  }
+}
+function* getEach(context, node) {
+  if (node.type !== "array" && node.type !== "object" && node.type !== "chain") {
+    throw new TypeError("Node must be an array, object, or chain");
+  }
+  const { data } = context;
+  let right = node.content;
+  while (right > node.left) {
+    const value = get(data, right);
+    right = value.left;
+    yield value;
+  }
+}
+function makeContext(input, options) {
+  return {
+    data: input,
+    refs: options?.refs ?? DECODE_DEFAULTS.refs,
+    lazy: options?.lazy ?? DECODE_DEFAULTS.lazy,
+    resolveCache: options?.resolveCache ?? new Map
+  };
+}
+function decode(input, options) {
+  let context = makeContext(input, options);
+  return resolve(context, get(context.data));
+}
+function resolve(context, node, lazy = false) {
+  const { data, refs } = context;
+  if (node.type === "primitive") {
+    return node.value;
+  }
+  if (node.type === "pointer") {
+    const target = node.target;
+    if (typeof target === "string") {
+      if (target in refs) {
+        return refs[target];
+      }
+      throw new ReferenceError(`Unknown reference: ${target}`);
+    } else if (typeof target === "number") {
+      return resolve(context, get(data, target));
+    }
+    throw new TypeError(`Invalid pointer target type: ${typeof target}`);
+  }
+  if (node.type === "object") {
+    const obj = {};
+    for (const [keyNode, value] of getEntries(context, node)) {
+      const key = resolve(context, keyNode);
+      if (typeof key !== "string") {
+        throw new SyntaxError("Expected string key in object");
+      }
+      obj[key] = resolve(context, value);
+    }
+    return obj;
+  }
+  if (node.type === "array") {
+    return Array.from(getEach(context, node)).map((value) => resolve(context, value));
+  }
+  if (node.type === "chain") {
+    let expandChain = function(node2) {
+      for (const part of getEach(context, node2)) {
+        if (part.type === "chain") {
+          expandChain(part);
+        } else {
+          parts.push(resolve(context, part));
+        }
+      }
+    };
+    const parts = [];
+    expandChain(node);
+    if (parts.length === 0) {
+      throw new SyntaxError("Chain must have at least one part");
+    }
+    if (parts.every((part) => typeof part === "string")) {
+      return parts.join("");
+    }
+    if (parts.some((part) => Array.isArray(part))) {
+      return parts.flat();
+    }
+    throw new Error("TODO: implement complex chain resolution");
+  }
+  throw new TypeError(`Unknown node type - ${JSON.stringify(node)}`);
+}
+function parse(input, options) {
+  return decode(new TextEncoder().encode(input), options);
+}
+function trimZeroes(str) {
+  const trimmed = str.replace(/0+$/, "");
+  const zeroCount = str.length - trimmed.length;
+  return [parseInt(trimmed, 10), zeroCount];
+}
+function splitNumber(val) {
+  if (Number.isInteger(val)) {
+    if (Math.abs(val) < 10) {
+      return [val, 0];
+    }
+    if (Math.abs(val) < 999999999999999900000) {
+      return trimZeroes(val.toString());
+    }
+  }
+  const decStr = val.toPrecision(14).match(/^([-+]?\d+)(?:\.(\d+))?$/);
+  if (decStr) {
+    const b1 = parseInt((decStr[1] ?? "") + (decStr[2] ?? ""), 10);
+    const e1 = -(decStr[2]?.length ?? 0);
+    if (e1 === 0) {
+      return [b1, 0];
+    }
+    const [b2, e2] = splitNumber(b1);
+    return [b2, e1 + e2];
+  }
+  const sciStr = val.toExponential(14).match(/^([+-]?\d+)(?:\.(\d+))?(?:e([+-]?\d+))$/);
+  if (sciStr) {
+    const e1 = -(sciStr[2]?.length ?? 0);
+    const e2 = parseInt(sciStr[3] ?? "0", 10);
+    const [b1, e3] = trimZeroes(sciStr[1] + (sciStr[2] ?? ""));
+    return [b1, e1 + e2 + e3];
+  }
+  throw new Error(`Invalid number format: ${val}`);
+}
+var KeyMap = new WeakMap;
+function makeKey(val) {
+  if (val && typeof val === "object") {
+    let key = KeyMap.get(val);
+    if (!key) {
+      key = JSON.stringify(val);
+      KeyMap.set(val, key);
+    }
+    return key;
+  }
+  return JSON.stringify(val);
+}
+function utf8Sort(a, b) {
+  const len = Math.min(a.length, b.length);
+  for (let i = 0;i < len; ) {
+    const cpA = a.codePointAt(i) ?? 0;
+    const cpB = b.codePointAt(i) ?? 0;
+    if (cpA !== cpB)
+      return cpA - cpB;
+    i += cpA > 65535 ? 2 : 1;
+  }
+  return a.length - b.length;
+}
+
+// rex.ts
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+var rexGrammarModule = require2("./rex.ohm-bundle.cjs");
+var rexGrammar = rexGrammarModule?.default ?? rexGrammarModule;
+var semantics = rexGrammar.createSemantics();
+var DIGITS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_";
+var KEYWORD_OPCODES = new Set(["boolean", "number", "string", "array", "object"]);
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function isBareKeyName(key) {
+  return /^[A-Za-z_][A-Za-z0-9_-]*$/.test(key);
+}
+function isNumericKey(key) {
+  if (key === "")
+    return false;
+  return String(Number(key)) === key && Number.isFinite(Number(key));
+}
+function stringifyKey(key) {
+  if (isBareKeyName(key))
+    return key;
+  if (isNumericKey(key))
+    return key;
+  return stringifyString(key);
+}
+function stringifyString(value) {
+  return JSON.stringify(value);
+}
+function stringifyInline(value) {
+  if (value === undefined)
+    return "undefined";
+  if (value === null)
+    return "null";
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  if (typeof value === "number") {
+    if (Number.isNaN(value))
+      return "nan";
+    if (value === Infinity)
+      return "inf";
+    if (value === -Infinity)
+      return "-inf";
+    return String(value);
+  }
+  if (typeof value === "string")
+    return stringifyString(value);
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return "[]";
+    return `[${value.map((item) => stringifyInline(item)).join(" ")}]`;
+  }
+  if (isPlainObject(value)) {
+    const entries = Object.entries(value);
+    if (entries.length === 0)
+      return "{}";
+    const body = entries.map(([key, item]) => `${stringifyKey(key)}: ${stringifyInline(item)}`).join(" ");
+    return `{${body}}`;
+  }
+  throw new Error(`Rex stringify() cannot encode value of type ${typeof value}`);
+}
+function fitsInline(rendered, depth, indentSize, maxWidth) {
+  if (rendered.includes(`
+`))
+    return false;
+  return depth * indentSize + rendered.length <= maxWidth;
+}
+function stringifyPretty(value, depth, indentSize, maxWidth) {
+  const inline = stringifyInline(value);
+  if (fitsInline(inline, depth, indentSize, maxWidth))
+    return inline;
+  const indent = " ".repeat(depth * indentSize);
+  const childIndent = " ".repeat((depth + 1) * indentSize);
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return "[]";
+    const lines = value.map((item) => {
+      const rendered = stringifyPretty(item, depth + 1, indentSize, maxWidth);
+      if (!rendered.includes(`
+`))
+        return `${childIndent}${rendered}`;
+      return `${childIndent}${rendered}`;
+    });
+    return `[
+${lines.join(`
+`)}
+${indent}]`;
+  }
+  if (isPlainObject(value)) {
+    const entries = Object.entries(value);
+    if (entries.length === 0)
+      return "{}";
+    const lines = entries.map(([key, item]) => {
+      const keyText = stringifyKey(key);
+      const rendered = stringifyPretty(item, depth + 1, indentSize, maxWidth);
+      return `${childIndent}${keyText}: ${rendered}`;
+    });
+    return `{
+${lines.join(`
+`)}
+${indent}}`;
+  }
+  return inline;
+}
+function stringify3(value, options) {
+  const indent = options?.indent ?? 2;
+  const maxWidth = options?.maxWidth ?? 80;
+  if (!Number.isInteger(indent) || indent < 0)
+    throw new Error("Rex stringify() indent must be a non-negative integer");
+  if (!Number.isInteger(maxWidth) || maxWidth < 20)
+    throw new Error("Rex stringify() maxWidth must be an integer >= 20");
+  return stringifyPretty(value, 0, indent, maxWidth);
+}
+var DIGIT_SET = new Set(DIGITS.split(""));
+var DIGIT_INDEX = new Map(Array.from(DIGITS).map((char, index) => [char, index]));
+function parseNumber(raw) {
+  if (raw === "nan")
+    return NaN;
+  if (raw === "inf")
+    return Infinity;
+  if (raw === "-inf")
+    return -Infinity;
+  if (/^-?0x/i.test(raw))
+    return parseInt(raw, 16);
+  if (/^-?0b/i.test(raw)) {
+    const isNegative = raw.startsWith("-");
+    const digits = raw.replace(/^-?0b/i, "");
+    const value = parseInt(digits, 2);
+    return isNegative ? -value : value;
+  }
+  return Number(raw);
+}
+function collectStructured(value, out) {
+  if (Array.isArray(value)) {
+    for (const part of value)
+      collectStructured(part, out);
+    return;
+  }
+  if (!value || typeof value !== "object")
+    return;
+  if ("type" in value || "key" in value && "value" in value) {
+    out.push(value);
+  }
+}
+function normalizeList(value) {
+  const out = [];
+  collectStructured(value, out);
+  return out;
+}
+function collectPostfixSteps(value, out) {
+  if (Array.isArray(value)) {
+    for (const part of value)
+      collectPostfixSteps(part, out);
+    return;
+  }
+  if (!value || typeof value !== "object")
+    return;
+  if ("kind" in value)
+    out.push(value);
+}
+function normalizePostfixSteps(value) {
+  const out = [];
+  collectPostfixSteps(value, out);
+  return out;
+}
+function buildPostfix(base, steps) {
+  let current = base;
+  let pendingSegments = [];
+  const flushSegments = () => {
+    if (pendingSegments.length === 0)
+      return;
+    current = {
+      type: "navigation",
+      target: current,
+      segments: pendingSegments
+    };
+    pendingSegments = [];
+  };
+  for (const step of steps) {
+    if (step.kind === "navStatic") {
+      pendingSegments.push({ type: "static", key: step.key });
+      continue;
+    }
+    if (step.kind === "navDynamic") {
+      pendingSegments.push({ type: "dynamic", key: step.key });
+      continue;
+    }
+    flushSegments();
+    current = { type: "call", callee: current, args: step.args };
+  }
+  flushSegments();
+  return current;
+}
+semantics.addOperation("toIR", {
+  _iter(...children) {
+    return children.map((child) => child.toIR());
+  },
+  _terminal() {
+    return this.sourceString;
+  },
+  _nonterminal(...children) {
+    if (children.length === 1 && children[0])
+      return children[0].toIR();
+    return children.map((child) => child.toIR());
+  },
+  Program(expressions) {
+    const body = normalizeList(expressions.toIR());
+    if (body.length === 1)
+      return body[0];
+    return { type: "program", body };
+  },
+  Block(expressions) {
+    return normalizeList(expressions.toIR());
+  },
+  Elements(first, separatorsAndItems, maybeTrailingComma, maybeEmpty) {
+    return normalizeList([
+      first.toIR(),
+      separatorsAndItems.toIR(),
+      maybeTrailingComma.toIR(),
+      maybeEmpty.toIR()
+    ]);
+  },
+  AssignExpr_assign(place, op, value) {
+    return {
+      type: "assign",
+      op: op.sourceString,
+      place: place.toIR(),
+      value: value.toIR()
+    };
+  },
+  ExistenceExpr_and(left, _and, right) {
+    return { type: "binary", op: "and", left: left.toIR(), right: right.toIR() };
+  },
+  ExistenceExpr_or(left, _or, right) {
+    return { type: "binary", op: "or", left: left.toIR(), right: right.toIR() };
+  },
+  ExistenceExpr_nor(left, _nor, right) {
+    return { type: "binary", op: "nor", left: left.toIR(), right: right.toIR() };
+  },
+  BitExpr_and(left, _op, right) {
+    return { type: "binary", op: "bitAnd", left: left.toIR(), right: right.toIR() };
+  },
+  BitExpr_xor(left, _op, right) {
+    return { type: "binary", op: "bitXor", left: left.toIR(), right: right.toIR() };
+  },
+  BitExpr_or(left, _op, right) {
+    return { type: "binary", op: "bitOr", left: left.toIR(), right: right.toIR() };
+  },
+  RangeExpr_range(left, _op, right) {
+    return { type: "range", from: left.toIR(), to: right.toIR() };
+  },
+  CompareExpr_binary(left, op, right) {
+    const map = {
+      "==": "eq",
+      "!=": "neq",
+      ">": "gt",
+      ">=": "gte",
+      "<": "lt",
+      "<=": "lte"
+    };
+    const mapped = map[op.sourceString];
+    if (!mapped)
+      throw new Error(`Unsupported compare op: ${op.sourceString}`);
+    return { type: "binary", op: mapped, left: left.toIR(), right: right.toIR() };
+  },
+  AddExpr_add(left, _op, right) {
+    return { type: "binary", op: "add", left: left.toIR(), right: right.toIR() };
+  },
+  AddExpr_sub(left, _op, right) {
+    return { type: "binary", op: "sub", left: left.toIR(), right: right.toIR() };
+  },
+  MulExpr_mul(left, _op, right) {
+    return { type: "binary", op: "mul", left: left.toIR(), right: right.toIR() };
+  },
+  MulExpr_div(left, _op, right) {
+    return { type: "binary", op: "div", left: left.toIR(), right: right.toIR() };
+  },
+  MulExpr_mod(left, _op, right) {
+    return { type: "binary", op: "mod", left: left.toIR(), right: right.toIR() };
+  },
+  UnaryExpr_neg(_op, value) {
+    const lowered = value.toIR();
+    if (lowered.type === "number") {
+      const raw = lowered.raw.startsWith("-") ? lowered.raw.slice(1) : `-${lowered.raw}`;
+      return { type: "number", raw, value: -lowered.value };
+    }
+    return { type: "unary", op: "neg", value: lowered };
+  },
+  UnaryExpr_not(_op, value) {
+    return { type: "unary", op: "not", value: value.toIR() };
+  },
+  UnaryExpr_logicalNot(_not, value) {
+    return { type: "unary", op: "logicalNot", value: value.toIR() };
+  },
+  UnaryExpr_delete(_del, place) {
+    return { type: "unary", op: "delete", value: place.toIR() };
+  },
+  PostfixExpr_chain(base, tails) {
+    return buildPostfix(base.toIR(), normalizePostfixSteps(tails.toIR()));
+  },
+  Place(base, tails) {
+    return buildPostfix(base.toIR(), normalizePostfixSteps(tails.toIR()));
+  },
+  PlaceTail_navStatic(_dot, key) {
+    return { kind: "navStatic", key: key.sourceString };
+  },
+  PlaceTail_navDynamic(_dotOpen, key, _close) {
+    return { kind: "navDynamic", key: key.toIR() };
+  },
+  PostfixTail_navStatic(_dot, key) {
+    return { kind: "navStatic", key: key.sourceString };
+  },
+  PostfixTail_navDynamic(_dotOpen, key, _close) {
+    return { kind: "navDynamic", key: key.toIR() };
+  },
+  PostfixTail_callEmpty(_open, _close) {
+    return { kind: "call", args: [] };
+  },
+  PostfixTail_call(_open, args, _close) {
+    return { kind: "call", args: normalizeList(args.toIR()) };
+  },
+  ConditionalExpr(head, condition, _do, thenBlock, elseBranch, _end) {
+    const nextElse = elseBranch.children[0];
+    return {
+      type: "conditional",
+      head: head.toIR(),
+      condition: condition.toIR(),
+      thenBlock: thenBlock.toIR(),
+      elseBranch: nextElse ? nextElse.toIR() : undefined
+    };
+  },
+  ConditionalHead(_kw) {
+    return this.sourceString;
+  },
+  ConditionalElse_elseChain(_else, head, condition, _do, thenBlock, elseBranch) {
+    const nextElse = elseBranch.children[0];
+    return {
+      type: "elseChain",
+      head: head.toIR(),
+      condition: condition.toIR(),
+      thenBlock: thenBlock.toIR(),
+      elseBranch: nextElse ? nextElse.toIR() : undefined
+    };
+  },
+  ConditionalElse_else(_else, block) {
+    return { type: "else", block: block.toIR() };
+  },
+  WhileExpr(_while, condition, _do, block, _end) {
+    return {
+      type: "while",
+      condition: condition.toIR(),
+      body: block.toIR()
+    };
+  },
+  ForExpr(_for, binding, _do, block, _end) {
+    return {
+      type: "for",
+      binding: binding.toIR(),
+      body: block.toIR()
+    };
+  },
+  Array_empty(_open, _close) {
+    return { type: "array", items: [] };
+  },
+  Array_forComprehension(_open, body, _for, binding, _close) {
+    return {
+      type: "arrayComprehension",
+      binding: binding.toIR(),
+      body: body.toIR()
+    };
+  },
+  Array_whileComprehension(_open, body, _while, condition, _close) {
+    return {
+      type: "whileArrayComprehension",
+      condition: condition.toIR(),
+      body: body.toIR()
+    };
+  },
+  Array_inComprehension(_open, body, _in, source, _close) {
+    return {
+      type: "arrayComprehension",
+      binding: { type: "binding:bareIn", source: source.toIR() },
+      body: body.toIR()
+    };
+  },
+  Array_ofComprehension(_open, body, _of, source, _close) {
+    return {
+      type: "arrayComprehension",
+      binding: { type: "binding:bareOf", source: source.toIR() },
+      body: body.toIR()
+    };
+  },
+  Array_values(_open, items, _close) {
+    return { type: "array", items: normalizeList(items.toIR()) };
+  },
+  Object_empty(_open, _close) {
+    return { type: "object", entries: [] };
+  },
+  Object_forComprehension(_open, key, _colon, value, _for, binding, _close) {
+    return {
+      type: "objectComprehension",
+      binding: binding.toIR(),
+      key: key.toIR(),
+      value: value.toIR()
+    };
+  },
+  Object_whileComprehension(_open, key, _colon, value, _while, condition, _close) {
+    return {
+      type: "whileObjectComprehension",
+      condition: condition.toIR(),
+      key: key.toIR(),
+      value: value.toIR()
+    };
+  },
+  Object_inComprehension(_open, key, _colon, value, _in, source, _close) {
+    return {
+      type: "objectComprehension",
+      binding: { type: "binding:bareIn", source: source.toIR() },
+      key: key.toIR(),
+      value: value.toIR()
+    };
+  },
+  Object_ofComprehension(_open, key, _colon, value, _of, source, _close) {
+    return {
+      type: "objectComprehension",
+      binding: { type: "binding:bareOf", source: source.toIR() },
+      key: key.toIR(),
+      value: value.toIR()
+    };
+  },
+  Object_pairs(_open, pairs, _close) {
+    return {
+      type: "object",
+      entries: normalizeList(pairs.toIR())
+    };
+  },
+  IterBinding_keyValueIn(key, _comma, value, _in, source) {
+    return {
+      type: "binding:keyValueIn",
+      key: key.sourceString,
+      value: value.sourceString,
+      source: source.toIR()
+    };
+  },
+  IterBinding_valueIn(value, _in, source) {
+    return {
+      type: "binding:valueIn",
+      value: value.sourceString,
+      source: source.toIR()
+    };
+  },
+  IterBinding_keyOf(key, _of, source) {
+    return {
+      type: "binding:keyOf",
+      key: key.sourceString,
+      source: source.toIR()
+    };
+  },
+  IterBinding_bareIn(_in, source) {
+    return {
+      type: "binding:bareIn",
+      source: source.toIR()
+    };
+  },
+  IterBinding_bareOf(_of, source) {
+    return {
+      type: "binding:bareOf",
+      source: source.toIR()
+    };
+  },
+  IterBindingComprehension_keyValueIn(key, _comma, value, _in, source) {
+    return {
+      type: "binding:keyValueIn",
+      key: key.sourceString,
+      value: value.sourceString,
+      source: source.toIR()
+    };
+  },
+  IterBindingComprehension_valueIn(value, _in, source) {
+    return {
+      type: "binding:valueIn",
+      value: value.sourceString,
+      source: source.toIR()
+    };
+  },
+  IterBindingComprehension_keyOf(key, _of, source) {
+    return {
+      type: "binding:keyOf",
+      key: key.sourceString,
+      source: source.toIR()
+    };
+  },
+  Pair(key, _colon, value) {
+    return { key: key.toIR(), value: value.toIR() };
+  },
+  ObjKey_bare(key) {
+    return { type: "key", name: key.sourceString };
+  },
+  ObjKey_number(num) {
+    return num.toIR();
+  },
+  ObjKey_string(str) {
+    return str.toIR();
+  },
+  ObjKey_computed(_open, expr, _close) {
+    return expr.toIR();
+  },
+  BreakKw(_kw) {
+    return { type: "break" };
+  },
+  ContinueKw(_kw) {
+    return { type: "continue" };
+  },
+  SelfExpr_depth(_self, _at, depth) {
+    const value = depth.toIR();
+    if (value.type !== "number" || !Number.isInteger(value.value) || value.value < 1) {
+      throw new Error("self depth must be a positive integer literal");
+    }
+    if (value.value === 1)
+      return { type: "self" };
+    return { type: "selfDepth", depth: value.value };
+  },
+  SelfExpr_plain(selfKw) {
+    return selfKw.toIR();
+  },
+  SelfKw(_kw) {
+    return { type: "self" };
+  },
+  TrueKw(_kw) {
+    return { type: "boolean", value: true };
+  },
+  FalseKw(_kw) {
+    return { type: "boolean", value: false };
+  },
+  NullKw(_kw) {
+    return { type: "null" };
+  },
+  UndefinedKw(_kw) {
+    return { type: "undefined" };
+  },
+  StringKw(_kw) {
+    return { type: "identifier", name: "string" };
+  },
+  NumberKw(_kw) {
+    return { type: "identifier", name: "number" };
+  },
+  ObjectKw(_kw) {
+    return { type: "identifier", name: "object" };
+  },
+  ArrayKw(_kw) {
+    return { type: "identifier", name: "array" };
+  },
+  BooleanKw(_kw) {
+    return { type: "identifier", name: "boolean" };
+  },
+  identifier(_a, _b) {
+    return { type: "identifier", name: this.sourceString };
+  },
+  String(_value) {
+    return { type: "string", raw: this.sourceString };
+  },
+  Number(_value) {
+    return { type: "number", raw: this.sourceString, value: parseNumber(this.sourceString) };
+  },
+  PrimaryExpr_group(_open, expr, _close) {
+    return { type: "group", expression: expr.toIR() };
+  }
+});
+
+// rex-repl.ts
+import { createRequire as createRequire2 } from "node:module";
+import { resolve as resolve2, dirname, basename } from "node:path";
+import { homedir } from "node:os";
+
+// rexc-interpreter.ts
+var DIGITS2 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_";
+var digitMap = new Map(Array.from(DIGITS2).map((char, index) => [char, index]));
+var OPCODES = {
+  do: "",
+  add: "ad",
+  sub: "sb",
+  mul: "ml",
+  div: "dv",
+  eq: "eq",
+  neq: "nq",
+  lt: "lt",
+  lte: "le",
+  gt: "gt",
+  gte: "ge",
+  and: "an",
+  or: "or",
+  xor: "xr",
+  not: "nt",
+  boolean: "bt",
+  number: "nm",
+  string: "st",
+  array: "ar",
+  object: "ob",
+  mod: "md",
+  neg: "ng",
+  range: "rn"
+};
+function decodePrefix(text, start, end) {
+  let value = 0;
+  for (let index = start;index < end; index += 1) {
+    const digit = digitMap.get(text[index] ?? "") ?? -1;
+    if (digit < 0)
+      throw new Error(`Invalid digit '${text[index]}'`);
+    value = value * 64 + digit;
+  }
+  return value;
+}
+function decodeZigzag(value) {
+  return value % 2 === 0 ? value / 2 : -(value + 1) / 2;
+}
+function isDefined(value) {
+  return value !== undefined;
+}
+
+class CursorInterpreter {
+  text;
+  pos = 0;
+  state;
+  selfStack;
+  pointerCache = new Map;
+  gasLimit;
+  gas = 0;
+  tick() {
+    if (this.gasLimit && ++this.gas > this.gasLimit) {
+      throw new Error("Gas limit exceeded (too many loop iterations)");
+    }
+  }
+  constructor(text, ctx = {}) {
+    const initialSelf = ctx.selfStack && ctx.selfStack.length > 0 ? ctx.selfStack[ctx.selfStack.length - 1] : ctx.self;
+    this.text = text;
+    this.state = {
+      vars: ctx.vars ?? {},
+      refs: {
+        tr: true,
+        fl: false,
+        nl: null,
+        un: undefined,
+        nan: NaN,
+        inf: Infinity,
+        nif: -Infinity,
+        ...ctx.refs
+      }
+    };
+    this.selfStack = ctx.selfStack && ctx.selfStack.length > 0 ? [...ctx.selfStack] : [initialSelf];
+    this.gasLimit = ctx.gasLimit ?? 0;
+    if (ctx.opcodes) {
+      for (const [key, op] of Object.entries(ctx.opcodes)) {
+        if (op)
+          this.customOpcodes.set(key, op);
+      }
+    }
+  }
+  customOpcodes = new Map;
+  readSelf(depthPrefix) {
+    const depth = depthPrefix + 1;
+    const index = this.selfStack.length - depth;
+    if (index < 0)
+      return;
+    return this.selfStack[index];
+  }
+  get runtimeState() {
+    return this.state;
+  }
+  evaluateTopLevel() {
+    this.skipNonCode();
+    if (this.pos >= this.text.length)
+      return;
+    const value = this.evalValue();
+    this.skipNonCode();
+    if (this.pos < this.text.length)
+      throw new Error(`Unexpected trailing input at ${this.pos}`);
+    return value;
+  }
+  skipNonCode() {
+    while (this.pos < this.text.length) {
+      const ch = this.text[this.pos];
+      if (ch === " " || ch === "\t" || ch === `
+` || ch === "\r") {
+        this.pos += 1;
+        continue;
+      }
+      if (ch === "/" && this.text[this.pos + 1] === "/") {
+        this.pos += 2;
+        while (this.pos < this.text.length && this.text[this.pos] !== `
+`)
+          this.pos += 1;
+        continue;
+      }
+      if (ch === "/" && this.text[this.pos + 1] === "*") {
+        this.pos += 2;
+        while (this.pos < this.text.length) {
+          if (this.text[this.pos] === "*" && this.text[this.pos + 1] === "/") {
+            this.pos += 2;
+            break;
+          }
+          this.pos += 1;
+        }
+        continue;
+      }
+      break;
+    }
+  }
+  readPrefix() {
+    const start = this.pos;
+    while (this.pos < this.text.length && digitMap.has(this.text[this.pos] ?? ""))
+      this.pos += 1;
+    const end = this.pos;
+    return { start, end, value: decodePrefix(this.text, start, end), raw: this.text.slice(start, end) };
+  }
+  advanceByBytes(start, byteCount) {
+    if (byteCount <= 0)
+      return start;
+    let bytes = 0;
+    let index = start;
+    for (const char of this.text.slice(start)) {
+      const charBytes = Buffer.byteLength(char);
+      if (bytes + charBytes > byteCount)
+        break;
+      bytes += charBytes;
+      index += char.length;
+      if (bytes === byteCount)
+        return index;
+    }
+    throw new Error("String container overflows input");
+  }
+  ensure(char) {
+    if (this.text[this.pos] !== char)
+      throw new Error(`Expected '${char}' at ${this.pos}`);
+    this.pos += 1;
+  }
+  hasMoreBefore(close) {
+    const save = this.pos;
+    this.skipNonCode();
+    const more = this.pos < this.text.length && this.text[this.pos] !== close;
+    this.pos = save;
+    return more;
+  }
+  readBindingVarIfPresent() {
+    const save = this.pos;
+    this.skipNonCode();
+    const prefix = this.readPrefix();
+    const tag = this.text[this.pos];
+    if (tag === "$" && prefix.raw.length > 0) {
+      this.pos += 1;
+      return prefix.raw;
+    }
+    this.pos = save;
+    return;
+  }
+  evalValue() {
+    this.skipNonCode();
+    const prefix = this.readPrefix();
+    const tag = this.text[this.pos];
+    if (!tag)
+      throw new Error("Unexpected end of input");
+    switch (tag) {
+      case "+":
+        this.pos += 1;
+        return decodeZigzag(prefix.value);
+      case "*": {
+        this.pos += 1;
+        const power = decodeZigzag(prefix.value);
+        const significand = this.evalValue();
+        if (typeof significand !== "number")
+          throw new Error("Decimal significand must be numeric");
+        return parseFloat(`${significand}e${power}`);
+      }
+      case ":":
+        this.pos += 1;
+        return prefix.raw;
+      case "%":
+        this.pos += 1;
+        return { __opcode: prefix.raw };
+      case "@":
+        this.pos += 1;
+        return this.readSelf(prefix.value);
+      case "'":
+        this.pos += 1;
+        return this.state.refs[prefix.raw];
+      case "$":
+        this.pos += 1;
+        return this.state.vars[prefix.raw];
+      case ",": {
+        this.pos += 1;
+        const start = this.pos;
+        const end = this.advanceByBytes(start, prefix.value);
+        const value = this.text.slice(start, end);
+        this.pos = end;
+        return value;
+      }
+      case "^": {
+        this.pos += 1;
+        const target = this.advanceByBytes(this.pos, prefix.value);
+        if (this.pointerCache.has(target))
+          return this.pointerCache.get(target);
+        const save = this.pos;
+        this.pos = target;
+        const value = this.evalValue();
+        this.pos = save;
+        this.pointerCache.set(target, value);
+        return value;
+      }
+      case "=": {
+        this.pos += 1;
+        const place = this.readPlace();
+        const value = this.evalValue();
+        this.writePlace(place, value);
+        return value;
+      }
+      case "/": {
+        this.pos += 1;
+        const place = this.readPlace();
+        const oldValue = this.readPlaceValue(place);
+        const newValue = this.evalValue();
+        this.writePlace(place, newValue);
+        return oldValue;
+      }
+      case "~": {
+        this.pos += 1;
+        const place = this.readPlace();
+        this.deletePlace(place);
+        return;
+      }
+      case ";": {
+        this.pos += 1;
+        const kind = prefix.value % 2 === 0 ? "break" : "continue";
+        const depth = Math.floor(prefix.value / 2) + 1;
+        return { kind, depth };
+      }
+      case "(":
+        return this.evalCall(prefix.value);
+      case "[":
+        return this.evalArray(prefix.value);
+      case "{":
+        return this.evalObject(prefix.value);
+      case "?":
+      case "!":
+      case "|":
+      case "&":
+        return this.evalFlowParen(tag);
+      case ">":
+      case "<":
+        return this.evalLoopLike(tag);
+      case "#":
+        return this.evalWhileLike();
+      default:
+        throw new Error(`Unexpected tag '${tag}' at ${this.pos}`);
+    }
+  }
+  evalCall(_prefix) {
+    this.ensure("(");
+    this.skipNonCode();
+    if (this.text[this.pos] === ")") {
+      this.pos += 1;
+      return;
+    }
+    const callee = this.evalValue();
+    const args = [];
+    while (true) {
+      this.skipNonCode();
+      if (this.text[this.pos] === ")")
+        break;
+      args.push(this.evalValue());
+    }
+    this.ensure(")");
+    if (typeof callee === "object" && callee && "__opcode" in callee) {
+      const marker = callee;
+      const opArgs = marker.__receiver !== undefined ? [marker.__receiver, ...args] : args;
+      return this.applyOpcode(marker.__opcode, opArgs);
+    }
+    return this.navigate(callee, args);
+  }
+  evalArray(_prefix) {
+    this.ensure("[");
+    this.skipNonCode();
+    this.skipIndexHeaderIfPresent();
+    const out = [];
+    while (true) {
+      this.skipNonCode();
+      if (this.text[this.pos] === "]")
+        break;
+      out.push(this.evalValue());
+    }
+    this.ensure("]");
+    return out;
+  }
+  evalObject(_prefix) {
+    this.ensure("{");
+    this.skipNonCode();
+    this.skipIndexHeaderIfPresent();
+    const out = {};
+    while (true) {
+      this.skipNonCode();
+      if (this.text[this.pos] === "}")
+        break;
+      const key = this.evalValue();
+      const value = this.evalValue();
+      out[String(key)] = value;
+    }
+    this.ensure("}");
+    return out;
+  }
+  skipIndexHeaderIfPresent() {
+    const save = this.pos;
+    const countPrefix = this.readPrefix();
+    if (this.text[this.pos] !== "#") {
+      this.pos = save;
+      return;
+    }
+    this.pos += 1;
+    const widthChar = this.text[this.pos];
+    const width = widthChar ? digitMap.get(widthChar) ?? 0 : 0;
+    if (widthChar)
+      this.pos += 1;
+    const skipLen = countPrefix.value * width;
+    this.pos += skipLen;
+  }
+  evalFlowParen(tag) {
+    this.pos += 1;
+    this.ensure("(");
+    if (tag === "?") {
+      const cond = this.evalValue();
+      if (isDefined(cond)) {
+        this.selfStack.push(cond);
+        const thenValue = this.evalValue();
+        this.selfStack.pop();
+        if (this.hasMoreBefore(")"))
+          this.skipValue();
+        this.ensure(")");
+        return thenValue;
+      }
+      this.skipValue();
+      let elseValue = undefined;
+      if (this.hasMoreBefore(")"))
+        elseValue = this.evalValue();
+      this.ensure(")");
+      return elseValue;
+    }
+    if (tag === "!") {
+      const cond = this.evalValue();
+      if (!isDefined(cond)) {
+        const thenValue = this.evalValue();
+        if (this.hasMoreBefore(")"))
+          this.skipValue();
+        this.ensure(")");
+        return thenValue;
+      }
+      this.skipValue();
+      let elseValue = undefined;
+      if (this.hasMoreBefore(")")) {
+        this.selfStack.push(cond);
+        elseValue = this.evalValue();
+        this.selfStack.pop();
+      }
+      this.ensure(")");
+      return elseValue;
+    }
+    if (tag === "|") {
+      let result2 = undefined;
+      while (this.hasMoreBefore(")")) {
+        if (isDefined(result2))
+          this.skipValue();
+        else
+          result2 = this.evalValue();
+      }
+      this.ensure(")");
+      return result2;
+    }
+    let result = undefined;
+    while (this.hasMoreBefore(")")) {
+      if (!isDefined(result) && result !== undefined) {
+        this.skipValue();
+        continue;
+      }
+      result = this.evalValue();
+      if (!isDefined(result)) {
+        while (this.hasMoreBefore(")"))
+          this.skipValue();
+        break;
+      }
+    }
+    this.ensure(")");
+    return result;
+  }
+  evalLoopLike(tag) {
+    this.pos += 1;
+    const open = this.text[this.pos];
+    if (!open || !"([{".includes(open))
+      throw new Error(`Expected loop opener after '${tag}'`);
+    const close = open === "(" ? ")" : open === "[" ? "]" : "}";
+    this.pos += 1;
+    const iterable = this.evalValue();
+    const afterIterable = this.pos;
+    const bodyValueCount = open === "{" ? 2 : 1;
+    let varA;
+    let varB;
+    let bodyStart = afterIterable;
+    let bodyEnd = afterIterable;
+    let matched = false;
+    for (const bindingCount of [2, 1, 0]) {
+      this.pos = afterIterable;
+      const vars = [];
+      let bindingsOk = true;
+      for (let index = 0;index < bindingCount; index += 1) {
+        const binding = this.readBindingVarIfPresent();
+        if (!binding) {
+          bindingsOk = false;
+          break;
+        }
+        vars.push(binding);
+      }
+      if (!bindingsOk)
+        continue;
+      const candidateBodyStart = this.pos;
+      let cursor = candidateBodyStart;
+      let bodyOk = true;
+      for (let index = 0;index < bodyValueCount; index += 1) {
+        const next = this.skipValueFrom(cursor);
+        if (next <= cursor) {
+          bodyOk = false;
+          break;
+        }
+        cursor = next;
+      }
+      if (!bodyOk)
+        continue;
+      this.pos = cursor;
+      this.skipNonCode();
+      if (this.text[this.pos] !== close)
+        continue;
+      varA = vars[0];
+      varB = vars[1];
+      bodyStart = candidateBodyStart;
+      bodyEnd = cursor;
+      matched = true;
+      break;
+    }
+    if (!matched)
+      throw new Error(`Invalid loop/comprehension body before '${close}' at ${this.pos}`);
+    this.pos = bodyEnd;
+    this.ensure(close);
+    if (open === "[")
+      return this.evalArrayComprehension(iterable, varA, varB, bodyStart, bodyEnd, tag === "<");
+    if (open === "{")
+      return this.evalObjectComprehension(iterable, varA, varB, bodyStart, bodyEnd, tag === "<");
+    return this.evalForLoop(iterable, varA, varB, bodyStart, bodyEnd, tag === "<");
+  }
+  iterate(iterable, keysOnly) {
+    if (Array.isArray(iterable)) {
+      if (keysOnly)
+        return iterable.map((_value, index) => ({ key: index, value: index }));
+      return iterable.map((value, index) => ({ key: index, value }));
+    }
+    if (iterable && typeof iterable === "object") {
+      const entries = Object.entries(iterable);
+      if (keysOnly)
+        return entries.map(([key]) => ({ key, value: key }));
+      return entries.map(([key, value]) => ({ key, value }));
+    }
+    if (typeof iterable === "string") {
+      const entries = Array.from(iterable);
+      if (keysOnly)
+        return entries.map((_value, index) => ({ key: index, value: index }));
+      return entries.map((value, index) => ({ key: index, value }));
+    }
+    return [];
+  }
+  evalBodySlice(start, end) {
+    const save = this.pos;
+    this.pos = start;
+    const value = this.evalValue();
+    this.pos = end;
+    this.pos = save;
+    return value;
+  }
+  handleLoopControl(value) {
+    if (value && typeof value === "object" && "kind" in value && "depth" in value) {
+      return value;
+    }
+    return;
+  }
+  evalForLoop(iterable, varA, varB, bodyStart, bodyEnd, keysOnly) {
+    const items = this.iterate(iterable, keysOnly);
+    let last = undefined;
+    for (const item of items) {
+      this.tick();
+      const currentSelf = keysOnly ? item.key : item.value;
+      this.selfStack.push(currentSelf);
+      if (varA && varB) {
+        this.state.vars[varA] = item.key;
+        this.state.vars[varB] = keysOnly ? item.key : item.value;
+      } else if (varA) {
+        this.state.vars[varA] = keysOnly ? item.key : item.value;
+      }
+      last = this.evalBodySlice(bodyStart, bodyEnd);
+      this.selfStack.pop();
+      const control = this.handleLoopControl(last);
+      if (!control)
+        continue;
+      if (control.depth > 1)
+        return { kind: control.kind, depth: control.depth - 1 };
+      if (control.kind === "break")
+        return;
+      last = undefined;
+      continue;
+    }
+    return last;
+  }
+  evalWhileLike() {
+    this.pos += 1;
+    const open = this.text[this.pos];
+    if (!open || !"([{".includes(open))
+      throw new Error(`Expected opener after '#' at ${this.pos}`);
+    const close = open === "(" ? ")" : open === "[" ? "]" : "}";
+    this.pos += 1;
+    const condStart = this.pos;
+    const condValue = this.evalValue();
+    const bodyStart = this.pos;
+    const bodyValueCount = open === "{" ? 2 : 1;
+    let cursor = bodyStart;
+    for (let index = 0;index < bodyValueCount; index += 1) {
+      cursor = this.skipValueFrom(cursor);
+    }
+    const bodyEnd = cursor;
+    this.pos = bodyEnd;
+    this.ensure(close);
+    const afterClose = this.pos;
+    if (open === "[")
+      return this.evalWhileArrayComprehension(condStart, bodyStart, bodyEnd, afterClose, condValue);
+    if (open === "{")
+      return this.evalWhileObjectComprehension(condStart, bodyStart, bodyEnd, afterClose, condValue);
+    return this.evalWhileLoop(condStart, bodyStart, bodyEnd, afterClose, condValue);
+  }
+  evalWhileLoop(condStart, bodyStart, bodyEnd, afterClose, condValue) {
+    let last = undefined;
+    let currentCond = condValue;
+    while (isDefined(currentCond)) {
+      this.tick();
+      this.selfStack.push(currentCond);
+      last = this.evalBodySlice(bodyStart, bodyEnd);
+      this.selfStack.pop();
+      const control = this.handleLoopControl(last);
+      if (control) {
+        if (control.depth > 1)
+          return { kind: control.kind, depth: control.depth - 1 };
+        if (control.kind === "break")
+          return;
+        last = undefined;
+      }
+      currentCond = this.evalBodySlice(condStart, bodyStart);
+    }
+    this.pos = afterClose;
+    return last;
+  }
+  evalWhileArrayComprehension(condStart, bodyStart, bodyEnd, afterClose, condValue) {
+    const out = [];
+    let currentCond = condValue;
+    while (isDefined(currentCond)) {
+      this.tick();
+      this.selfStack.push(currentCond);
+      const value = this.evalBodySlice(bodyStart, bodyEnd);
+      this.selfStack.pop();
+      const control = this.handleLoopControl(value);
+      if (control) {
+        if (control.depth > 1)
+          return { kind: control.kind, depth: control.depth - 1 };
+        if (control.kind === "break")
+          break;
+        currentCond = this.evalBodySlice(condStart, bodyStart);
+        continue;
+      }
+      if (isDefined(value))
+        out.push(value);
+      currentCond = this.evalBodySlice(condStart, bodyStart);
+    }
+    this.pos = afterClose;
+    return out;
+  }
+  evalWhileObjectComprehension(condStart, bodyStart, bodyEnd, afterClose, condValue) {
+    const result = {};
+    let currentCond = condValue;
+    while (isDefined(currentCond)) {
+      this.tick();
+      this.selfStack.push(currentCond);
+      const save = this.pos;
+      this.pos = bodyStart;
+      const key = this.evalValue();
+      const value = this.evalValue();
+      this.pos = save;
+      this.selfStack.pop();
+      const control = this.handleLoopControl(value);
+      if (control) {
+        if (control.depth > 1)
+          return { kind: control.kind, depth: control.depth - 1 };
+        if (control.kind === "break")
+          break;
+        currentCond = this.evalBodySlice(condStart, bodyStart);
+        continue;
+      }
+      if (isDefined(value))
+        result[String(key)] = value;
+      currentCond = this.evalBodySlice(condStart, bodyStart);
+    }
+    this.pos = afterClose;
+    return result;
+  }
+  evalArrayComprehension(iterable, varA, varB, bodyStart, bodyEnd, keysOnly) {
+    const items = this.iterate(iterable, keysOnly);
+    const out = [];
+    for (const item of items) {
+      this.tick();
+      const currentSelf = keysOnly ? item.key : item.value;
+      this.selfStack.push(currentSelf);
+      if (varA && varB) {
+        this.state.vars[varA] = item.key;
+        this.state.vars[varB] = keysOnly ? item.key : item.value;
+      } else if (varA) {
+        this.state.vars[varA] = keysOnly ? item.key : item.value;
+      }
+      const value = this.evalBodySlice(bodyStart, bodyEnd);
+      this.selfStack.pop();
+      const control = this.handleLoopControl(value);
+      if (control) {
+        if (control.depth > 1)
+          return { kind: control.kind, depth: control.depth - 1 };
+        if (control.kind === "break")
+          break;
+        continue;
+      }
+      if (isDefined(value))
+        out.push(value);
+    }
+    return out;
+  }
+  evalObjectComprehension(iterable, varA, varB, bodyStart, bodyEnd, keysOnly) {
+    const items = this.iterate(iterable, keysOnly);
+    const out = {};
+    for (const item of items) {
+      this.tick();
+      const currentSelf = keysOnly ? item.key : item.value;
+      this.selfStack.push(currentSelf);
+      if (varA && varB) {
+        this.state.vars[varA] = item.key;
+        this.state.vars[varB] = keysOnly ? item.key : item.value;
+      } else if (varA) {
+        this.state.vars[varA] = keysOnly ? item.key : item.value;
+      }
+      const save = this.pos;
+      this.pos = bodyStart;
+      const key = this.evalValue();
+      const value = this.evalValue();
+      this.pos = save;
+      this.selfStack.pop();
+      const control = this.handleLoopControl(value);
+      if (control) {
+        if (control.depth > 1)
+          return { kind: control.kind, depth: control.depth - 1 };
+        if (control.kind === "break")
+          break;
+        continue;
+      }
+      if (isDefined(value))
+        out[String(key)] = value;
+    }
+    return out;
+  }
+  applyOpcode(id, args) {
+    const custom = this.customOpcodes.get(id);
+    if (custom)
+      return custom(args, this.state);
+    switch (id) {
+      case OPCODES.do:
+        return args.length ? args[args.length - 1] : undefined;
+      case OPCODES.add:
+        if (args[0] === undefined || args[1] === undefined)
+          return;
+        if (Array.isArray(args[0]) && Array.isArray(args[1])) {
+          return [...args[0], ...args[1]];
+        }
+        if (args[0] && args[1] && typeof args[0] === "object" && typeof args[1] === "object" && !Array.isArray(args[0]) && !Array.isArray(args[1])) {
+          return { ...args[0], ...args[1] };
+        }
+        if (typeof args[0] === "string" && typeof args[1] === "string") {
+          return args[0] + args[1];
+        }
+        if (typeof args[0] === "number" && typeof args[1] === "number") {
+          return args[0] + args[1];
+        }
+        return;
+      case OPCODES.sub:
+        if (args[0] === undefined || args[1] === undefined)
+          return;
+        return Number(args[0]) - Number(args[1]);
+      case OPCODES.mul:
+        if (args[0] === undefined || args[1] === undefined)
+          return;
+        return Number(args[0]) * Number(args[1]);
+      case OPCODES.div:
+        if (args[0] === undefined || args[1] === undefined)
+          return;
+        return Number(args[0]) / Number(args[1]);
+      case OPCODES.mod:
+        if (args[0] === undefined || args[1] === undefined)
+          return;
+        return Number(args[0]) % Number(args[1]);
+      case OPCODES.neg:
+        if (args[0] === undefined)
+          return;
+        return -Number(args[0]);
+      case OPCODES.not: {
+        const value = args[0];
+        if (value === undefined)
+          return;
+        if (typeof value === "boolean")
+          return !value;
+        return ~Number(value);
+      }
+      case OPCODES.and: {
+        const [a, b] = args;
+        if (typeof a === "boolean" || typeof b === "boolean")
+          return Boolean(a) && Boolean(b);
+        return Number(a ?? 0) & Number(b ?? 0);
+      }
+      case OPCODES.or: {
+        const [a, b] = args;
+        if (typeof a === "boolean" || typeof b === "boolean")
+          return Boolean(a) || Boolean(b);
+        return Number(a ?? 0) | Number(b ?? 0);
+      }
+      case OPCODES.xor: {
+        const [a, b] = args;
+        if (typeof a === "boolean" || typeof b === "boolean")
+          return Boolean(a) !== Boolean(b);
+        return Number(a ?? 0) ^ Number(b ?? 0);
+      }
+      case OPCODES.eq:
+        return args[0] === args[1] ? args[0] : undefined;
+      case OPCODES.neq:
+        return args[0] !== args[1] ? args[0] : undefined;
+      case OPCODES.gt:
+        return Number(args[0]) > Number(args[1]) ? args[0] : undefined;
+      case OPCODES.gte:
+        return Number(args[0]) >= Number(args[1]) ? args[0] : undefined;
+      case OPCODES.lt:
+        return Number(args[0]) < Number(args[1]) ? args[0] : undefined;
+      case OPCODES.lte:
+        return Number(args[0]) <= Number(args[1]) ? args[0] : undefined;
+      case OPCODES.boolean:
+        return typeof args[0] === "boolean" ? args[0] : undefined;
+      case OPCODES.number:
+        return typeof args[0] === "number" ? args[0] : undefined;
+      case OPCODES.string:
+        return typeof args[0] === "string" ? args[0] : undefined;
+      case OPCODES.array:
+        return Array.isArray(args[0]) ? args[0] : undefined;
+      case OPCODES.object:
+        return args[0] && typeof args[0] === "object" && !Array.isArray(args[0]) ? args[0] : undefined;
+      case OPCODES.range: {
+        const from = Number(args[0]);
+        const to = Number(args[1]);
+        const step = to >= from ? 1 : -1;
+        const out = [];
+        for (let v = from;step > 0 ? v <= to : v >= to; v += step)
+          out.push(v);
+        return out;
+      }
+      case "array:push": {
+        const target = args[0];
+        if (!Array.isArray(target))
+          return;
+        const next = target.slice();
+        for (let i = 1;i < args.length; i += 1)
+          next.push(args[i]);
+        return next;
+      }
+      case "array:pop": {
+        const target = args[0];
+        if (!Array.isArray(target) || target.length === 0)
+          return;
+        return target[target.length - 1];
+      }
+      case "array:unshift": {
+        const target = args[0];
+        if (!Array.isArray(target))
+          return;
+        const next = target.slice();
+        for (let i = args.length - 1;i >= 1; i -= 1)
+          next.unshift(args[i]);
+        return next;
+      }
+      case "array:shift": {
+        const target = args[0];
+        if (!Array.isArray(target) || target.length === 0)
+          return;
+        return target[0];
+      }
+      case "array:slice": {
+        const target = args[0];
+        if (!Array.isArray(target))
+          return;
+        const start = args.length > 1 && args[1] !== undefined ? Number(args[1]) : undefined;
+        const end = args.length > 2 && args[2] !== undefined ? Number(args[2]) : undefined;
+        return target.slice(start, end);
+      }
+      case "array:join": {
+        const target = args[0];
+        if (!Array.isArray(target))
+          return;
+        const sep = args.length > 1 && args[1] !== undefined ? String(args[1]) : ",";
+        return target.map((item) => String(item)).join(sep);
+      }
+      case "string:split": {
+        const target = args[0];
+        if (typeof target !== "string")
+          return;
+        if (args.length < 2 || args[1] === undefined)
+          return [target];
+        return target.split(String(args[1]));
+      }
+      case "string:join": {
+        const target = args[0];
+        if (typeof target !== "string")
+          return;
+        const parts = Array.from(target);
+        const sep = args.length > 1 && args[1] !== undefined ? String(args[1]) : "";
+        return parts.join(sep);
+      }
+      case "string:slice": {
+        const target = args[0];
+        if (typeof target !== "string")
+          return;
+        const start = args.length > 1 && args[1] !== undefined ? Number(args[1]) : undefined;
+        const end = args.length > 2 && args[2] !== undefined ? Number(args[2]) : undefined;
+        return Array.from(target).slice(start, end).join("");
+      }
+      case "string:starts-with": {
+        const target = args[0];
+        if (typeof target !== "string")
+          return;
+        const prefix = args.length > 1 && args[1] !== undefined ? String(args[1]) : "";
+        return target.startsWith(prefix);
+      }
+      case "string:ends-with": {
+        const target = args[0];
+        if (typeof target !== "string")
+          return;
+        const suffix = args.length > 1 && args[1] !== undefined ? String(args[1]) : "";
+        return target.endsWith(suffix);
+      }
+      default:
+        throw new Error(`Unknown opcode ${id}`);
+    }
+  }
+  navigate(base, keys) {
+    let current = base;
+    for (const key of keys) {
+      if (current === undefined || current === null)
+        return;
+      current = this.readProperty(current, key);
+      if (current === undefined)
+        return;
+    }
+    return current;
+  }
+  readProperty(target, key) {
+    if (typeof key === "string" && key === "size") {
+      if (Array.isArray(target))
+        return target.length;
+      if (typeof target === "string")
+        return Array.from(target).length;
+    }
+    const index = this.parseIndexKey(key);
+    if (Array.isArray(target)) {
+      if (index !== undefined)
+        return target[index];
+      if (typeof key === "string")
+        return this.resolveArrayMethod(target, key);
+      return;
+    }
+    if (typeof target === "string") {
+      if (index !== undefined)
+        return Array.from(target)[index];
+      if (typeof key === "string")
+        return this.resolveStringMethod(target, key);
+      return;
+    }
+    if (this.isPlainObject(target)) {
+      const prop = String(key);
+      if (!Object.prototype.hasOwnProperty.call(target, prop))
+        return;
+      return target[prop];
+    }
+    return;
+  }
+  resolveArrayMethod(target, key) {
+    switch (key) {
+      case "push":
+        return { __opcode: "array:push", __receiver: target };
+      case "pop":
+        return { __opcode: "array:pop", __receiver: target };
+      case "unshift":
+        return { __opcode: "array:unshift", __receiver: target };
+      case "shift":
+        return { __opcode: "array:shift", __receiver: target };
+      case "slice":
+        return { __opcode: "array:slice", __receiver: target };
+      case "join":
+        return { __opcode: "array:join", __receiver: target };
+      default:
+        return;
+    }
+  }
+  resolveStringMethod(target, key) {
+    switch (key) {
+      case "split":
+        return { __opcode: "string:split", __receiver: target };
+      case "join":
+        return { __opcode: "string:join", __receiver: target };
+      case "slice":
+        return { __opcode: "string:slice", __receiver: target };
+      case "starts-with":
+        return { __opcode: "string:starts-with", __receiver: target };
+      case "ends-with":
+        return { __opcode: "string:ends-with", __receiver: target };
+      default:
+        return;
+    }
+  }
+  canWriteProperty(target, key) {
+    const index = this.parseIndexKey(key);
+    if (Array.isArray(target)) {
+      if (index === undefined)
+        return;
+      return { kind: "array", index };
+    }
+    if (this.isPlainObject(target))
+      return { kind: "object" };
+    return;
+  }
+  parseIndexKey(key) {
+    if (typeof key === "number" && Number.isInteger(key) && key >= 0)
+      return key;
+    if (typeof key !== "string" || key.length === 0)
+      return;
+    if (!/^(0|[1-9]\d*)$/.test(key))
+      return;
+    const index = Number(key);
+    return Number.isSafeInteger(index) ? index : undefined;
+  }
+  isPlainObject(value) {
+    if (!value || typeof value !== "object")
+      return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+  }
+  readPlace() {
+    this.skipNonCode();
+    const direct = this.readRootVarOrRefIfPresent();
+    if (direct) {
+      const keys = [];
+      this.skipNonCode();
+      if (this.text[this.pos] === "(") {
+        this.pos += 1;
+        while (true) {
+          this.skipNonCode();
+          if (this.text[this.pos] === ")")
+            break;
+          keys.push(this.evalValue());
+        }
+        this.pos += 1;
+      }
+      return {
+        root: direct.root,
+        keys,
+        isRef: direct.isRef
+      };
+    }
+    if (this.text[this.pos] === "(") {
+      this.pos += 1;
+      this.skipNonCode();
+      const rootFromNav = this.readRootVarOrRefIfPresent();
+      if (!rootFromNav)
+        throw new Error(`Invalid place root at ${this.pos}`);
+      const keys = [];
+      while (true) {
+        this.skipNonCode();
+        if (this.text[this.pos] === ")")
+          break;
+        keys.push(this.evalValue());
+      }
+      this.pos += 1;
+      return {
+        root: rootFromNav.root,
+        keys,
+        isRef: rootFromNav.isRef
+      };
+    }
+    throw new Error(`Invalid place at ${this.pos}`);
+  }
+  readRootVarOrRefIfPresent() {
+    const save = this.pos;
+    const prefix = this.readPrefix();
+    const tag = this.text[this.pos];
+    if (tag !== "$" && tag !== "'") {
+      this.pos = save;
+      return;
+    }
+    this.pos += 1;
+    return {
+      root: prefix.raw,
+      isRef: tag === "'"
+    };
+  }
+  writePlace(place, value) {
+    const rootTable = place.isRef ? this.state.refs : this.state.vars;
+    const rootKey = place.root;
+    if (place.keys.length === 0) {
+      rootTable[rootKey] = value;
+      return;
+    }
+    let target = rootTable[rootKey];
+    if (!target || typeof target !== "object") {
+      target = {};
+      rootTable[rootKey] = target;
+    }
+    for (let index = 0;index < place.keys.length - 1; index += 1) {
+      const key = place.keys[index];
+      const access2 = this.canWriteProperty(target, key);
+      if (!access2)
+        return;
+      if (access2.kind === "array") {
+        const next2 = target[access2.index];
+        if (!next2 || typeof next2 !== "object")
+          target[access2.index] = {};
+        target = target[access2.index];
+        continue;
+      }
+      const prop = String(key);
+      const next = target[prop];
+      if (!next || typeof next !== "object")
+        target[prop] = {};
+      target = target[prop];
+    }
+    const lastKey = place.keys[place.keys.length - 1];
+    const access = this.canWriteProperty(target, lastKey);
+    if (!access)
+      return;
+    if (access.kind === "array") {
+      target[access.index] = value;
+      return;
+    }
+    target[String(lastKey)] = value;
+  }
+  readPlaceValue(place) {
+    const rootTable = place.isRef ? this.state.refs : this.state.vars;
+    let current = rootTable[place.root];
+    for (const key of place.keys) {
+      if (current === undefined || current === null)
+        return;
+      current = this.readProperty(current, key);
+      if (current === undefined)
+        return;
+    }
+    return current;
+  }
+  deletePlace(place) {
+    const rootTable = place.isRef ? this.state.refs : this.state.vars;
+    const rootKey = place.root;
+    if (place.keys.length === 0) {
+      delete rootTable[rootKey];
+      return;
+    }
+    let target = rootTable[rootKey];
+    if (!target || typeof target !== "object")
+      return;
+    for (let index = 0;index < place.keys.length - 1; index += 1) {
+      const key = place.keys[index];
+      const access2 = this.canWriteProperty(target, key);
+      if (!access2)
+        return;
+      if (access2.kind === "array") {
+        target = target[access2.index];
+        if (!target || typeof target !== "object")
+          return;
+        continue;
+      }
+      target = target[String(key)];
+      if (!target || typeof target !== "object")
+        return;
+    }
+    const lastKey = place.keys[place.keys.length - 1];
+    const access = this.canWriteProperty(target, lastKey);
+    if (!access)
+      return;
+    if (access.kind === "array") {
+      delete target[access.index];
+      return;
+    }
+    delete target[String(lastKey)];
+  }
+  skipValue() {
+    this.pos = this.skipValueFrom(this.pos);
+  }
+  skipValueFrom(startPos) {
+    const save = this.pos;
+    this.pos = startPos;
+    this.skipNonCode();
+    const prefix = this.readPrefix();
+    const tag = this.text[this.pos];
+    if (!tag) {
+      this.pos = save;
+      return startPos;
+    }
+    if (tag === ",") {
+      this.pos = this.advanceByBytes(this.pos + 1, prefix.value);
+      const end2 = this.pos;
+      this.pos = save;
+      return end2;
+    }
+    if (tag === "=" || tag === "/") {
+      this.pos += 1;
+      this.skipValue();
+      this.skipValue();
+      const end2 = this.pos;
+      this.pos = save;
+      return end2;
+    }
+    if (tag === "~") {
+      this.pos += 1;
+      this.skipValue();
+      const end2 = this.pos;
+      this.pos = save;
+      return end2;
+    }
+    if (tag === "*") {
+      this.pos += 1;
+      this.skipValue();
+      const end2 = this.pos;
+      this.pos = save;
+      return end2;
+    }
+    if ("+:%$@'^;".includes(tag)) {
+      this.pos += 1;
+      const end2 = this.pos;
+      this.pos = save;
+      return end2;
+    }
+    if (tag === "?" || tag === "!" || tag === "|" || tag === "&" || tag === ">" || tag === "<" || tag === "#") {
+      this.pos += 1;
+    }
+    const opener = this.text[this.pos];
+    if (opener && "([{".includes(opener)) {
+      const close = opener === "(" ? ")" : opener === "[" ? "]" : "}";
+      if (prefix.value > 0) {
+        const bodyEnd = this.advanceByBytes(this.pos + 1, prefix.value);
+        this.pos = bodyEnd + 1;
+        const end3 = this.pos;
+        this.pos = save;
+        return end3;
+      }
+      this.pos += 1;
+      while (true) {
+        this.skipNonCode();
+        if (this.text[this.pos] === close)
+          break;
+        this.skipValue();
+      }
+      this.pos += 1;
+      const end2 = this.pos;
+      this.pos = save;
+      return end2;
+    }
+    this.pos += 1;
+    const end = this.pos;
+    this.pos = save;
+    return end;
+  }
+}
+
+// rex-repl.ts
+var req = createRequire2(import.meta.url);
+var { version } = req("./package.json");
+function createColors(enabled) {
+  if (!enabled) {
+    return {
+      reset: "",
+      bold: "",
+      dim: "",
+      red: "",
+      green: "",
+      yellow: "",
+      blue: "",
+      magenta: "",
+      cyan: "",
+      gray: "",
+      keyword: ""
+    };
+  }
+  return {
+    reset: "\x1B[0m",
+    bold: "\x1B[1m",
+    dim: "\x1B[2m",
+    red: "\x1B[38;5;203m",
+    green: "\x1B[38;5;114m",
+    yellow: "\x1B[38;5;179m",
+    blue: "\x1B[38;5;75m",
+    magenta: "\x1B[38;5;141m",
+    cyan: "\x1B[38;5;81m",
+    gray: "\x1B[38;5;245m",
+    keyword: "\x1B[1;38;5;208m"
+  };
+}
+var colorEnabled = process.stdout.isTTY;
+var C = createColors(colorEnabled);
+function setColorEnabled(enabled) {
+  colorEnabled = enabled;
+  C = createColors(enabled);
+}
+var TOKEN_RE = /(?<blockComment>\/\*[\s\S]*?(?:\*\/|$))|(?<lineComment>\/\/[^\n]*)|(?<dstring>"(?:[^"\\]|\\.)*"?)|(?<sstring>'(?:[^'\\]|\\.)*'?)|(?<objKey>\b[A-Za-z_][A-Za-z0-9_-]*\b)(?=\s*:)|(?<keyword>\b(?:when|unless|while|for|do|end|in|of|and|or|nor|else|break|continue|delete|self)(?![a-zA-Z0-9_-]))|(?<literal>\b(?:true|false|null|undefined|nan)(?![a-zA-Z0-9_-])|-?\binf\b)|(?<typePred>\b(?:string|number|object|array|boolean)(?![a-zA-Z0-9_-]))|(?<num>\b(?:0x[0-9a-fA-F]+|0b[01]+|(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)\b)|(?<identifier>\b[A-Za-z_][A-Za-z0-9_.-]*\b)/g;
+function highlightLine(line) {
+  let result = "";
+  let lastIndex = 0;
+  TOKEN_RE.lastIndex = 0;
+  for (const m of line.matchAll(TOKEN_RE)) {
+    result += line.slice(lastIndex, m.index);
+    const text = m[0];
+    const g = m.groups;
+    if (g.blockComment || g.lineComment) {
+      result += C.gray + text + C.reset;
+    } else if (g.dstring || g.sstring) {
+      result += C.green + text + C.reset;
+    } else if (g.objKey) {
+      result += C.magenta + text + C.reset;
+    } else if (g.keyword) {
+      result += C.keyword + text + C.reset;
+    } else if (g.literal) {
+      result += C.yellow + text + C.reset;
+    } else if (g.typePred) {
+      result += C.cyan + text + C.reset;
+    } else if (g.num) {
+      result += C.cyan + text + C.reset;
+    } else if (g.identifier) {
+      result += C.blue + text + C.reset;
+    } else {
+      result += text;
+    }
+    lastIndex = m.index + text.length;
+  }
+  result += line.slice(lastIndex);
+  return result;
+}
+var REXC_DIGITS = new Set("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_");
+var JSON_TOKEN_RE = /(?<key>"(?:[^"\\]|\\.)*")\s*:|(?<string>"(?:[^"\\]|\\.)*")|(?<number>-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)\b|(?<bool>true|false)|(?<null>null)|(?<brace>[{}[\]])|(?<punct>[:,])/g;
+function highlightJSON(json) {
+  let result = "";
+  let lastIndex = 0;
+  JSON_TOKEN_RE.lastIndex = 0;
+  for (const m of json.matchAll(JSON_TOKEN_RE)) {
+    result += json.slice(lastIndex, m.index);
+    const text = m[0];
+    const g = m.groups;
+    if (g.key) {
+      result += C.cyan + g.key + C.reset + ":";
+    } else if (g.string) {
+      result += C.green + text + C.reset;
+    } else if (g.number) {
+      result += C.yellow + text + C.reset;
+    } else if (g.bool) {
+      result += C.yellow + text + C.reset;
+    } else if (g.null) {
+      result += C.dim + text + C.reset;
+    } else {
+      result += text;
+    }
+    lastIndex = m.index + text.length;
+  }
+  result += json.slice(lastIndex);
+  return result;
+}
+var HISTORY_PATH = resolve2(homedir(), ".rex_history");
+
+// rx-cli.ts
+import { readFile, writeFile } from "node:fs/promises";
+function parseArgs(argv) {
+  const opts = {
+    files: [],
+    color: process.stdout.isTTY ?? false,
+    colorExplicit: false,
+    help: false
+  };
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "-h" || arg === "--help") {
+      opts.help = true;
+      continue;
+    }
+    if (arg === "--color") {
+      opts.color = true;
+      opts.colorExplicit = true;
+      continue;
+    }
+    if (arg === "--no-color") {
+      opts.color = false;
+      opts.colorExplicit = true;
+      continue;
+    }
+    if (arg === "-j" || arg === "--json") {
+      opts.toFormat = "json";
+      continue;
+    }
+    if (arg === "-r" || arg === "--rexc") {
+      opts.toFormat = "rexc";
+      continue;
+    }
+    if (arg === "-t" || arg === "--tree") {
+      opts.toFormat = "tree";
+      continue;
+    }
+    if (arg === "--from") {
+      const v = argv[++i];
+      if (v !== "json" && v !== "rexc")
+        throw new Error("--from must be 'json' or 'rexc'");
+      opts.fromFormat = v;
+      continue;
+    }
+    if (arg === "--to") {
+      const v = argv[++i];
+      if (v !== "json" && v !== "rexc" && v !== "tree")
+        throw new Error("--to must be 'json', 'rexc', or 'tree'");
+      opts.toFormat = v;
+      continue;
+    }
+    if (arg === "-s" || arg === "--select") {
+      const v = argv[++i];
+      if (!v)
+        throw new Error("Missing value for --select");
+      opts.select = v;
+      continue;
+    }
+    if (arg === "-o" || arg === "--out") {
+      const v = argv[++i];
+      if (!v)
+        throw new Error("Missing value for --out");
+      opts.out = v;
+      continue;
+    }
+    if (!arg.startsWith("-") || arg === "-") {
+      opts.files.push(arg);
+      continue;
+    }
+    throw new Error(`Unknown option: ${arg}`);
+  }
+  return opts;
+}
+function usage() {
+  return [
+    "rx — inspect, convert, and filter REXC & JSON data.",
+    "",
+    "Usage:",
+    "  rx data.rexc                   Pretty-print rexc as a tree",
+    "  rx data.rexc --to json         Convert rexc to JSON",
+    "  rx data.json --to rexc         Convert JSON to rexc",
+    "  cat data.rexc | rx             Read from stdin (auto-detect)",
+    "  rx -s .routes[0].op data.rexc  Select a sub-value",
+    "",
+    "Input:",
+    "  <file>              Read from file (format auto-detected by extension)",
+    "  -                   Read from stdin explicitly",
+    "  (no args, piped)    Read from stdin automatically",
+    "",
+    "Format control:",
+    "  --from json|rexc    Force input format (default: auto-detect)",
+    "  --to json|rexc|tree Output format",
+    "  -j, --json          Shortcut for --to json",
+    "  -r, --rexc          Shortcut for --to rexc",
+    "  -t, --tree          Shortcut for --to tree",
+    "",
+    "  Default output: tree on TTY, json when piped.",
+    "",
+    "Filtering:",
+    "  -s, --select <path> Dot-path selector (e.g. .foo.bar[0].baz)",
+    "",
+    "Output:",
+    "  -o, --out <path>    Write to file instead of stdout",
+    "  --color             Force ANSI color",
+    "  --no-color          Disable ANSI color",
+    "  -h, --help          Show this message"
+  ].join(`
+`);
+}
+function formatFromExt(path) {
+  if (path.endsWith(".json"))
+    return "json";
+  if (path.endsWith(".rexc"))
+    return "rexc";
+  return;
+}
+function detectFormat(content) {
+  const t = content.trimStart();
+  if (/^[\[{"0-9tfn\-]/.test(t)) {
+    try {
+      JSON.parse(content);
+      return "json";
+    } catch {}
+  }
+  return "rexc";
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function parseRaw(raw, format) {
+  if (format === "json")
+    return JSON.parse(raw);
+  return parse(raw.trim());
+}
+async function readInput(opts) {
+  if (opts.files.length === 0) {
+    if (process.stdin.isTTY)
+      throw new Error("No input. Provide a file or pipe data via stdin.");
+    const raw = await readStdin();
+    if (!raw.trim())
+      throw new Error("Empty stdin.");
+    const format = opts.fromFormat ?? detectFormat(raw);
+    return { value: parseRaw(raw, format) };
+  }
+  if (opts.files.length === 1) {
+    const file = opts.files[0];
+    const raw = file === "-" ? await readStdin() : await readFile(file, "utf8");
+    const format = opts.fromFormat ?? (file === "-" ? detectFormat(raw) : formatFromExt(file) ?? detectFormat(raw));
+    return { value: parseRaw(raw, format) };
+  }
+  const values = [];
+  for (const file of opts.files) {
+    const raw = file === "-" ? await readStdin() : await readFile(file, "utf8");
+    const format = opts.fromFormat ?? (file === "-" ? detectFormat(raw) : formatFromExt(file) ?? detectFormat(raw));
+    values.push(parseRaw(raw, format));
+  }
+  return { value: values };
+}
+function parseSelector(selector) {
+  const segments = [];
+  const re = /\.([a-zA-Z_][\w-]*)|(\[(\d+)\])/g;
+  let s = selector;
+  if (s.startsWith("."))
+    s = s;
+  else if (!s.startsWith("["))
+    s = "." + s;
+  let match;
+  let lastIndex = 0;
+  while ((match = re.exec(s)) !== null) {
+    if (match.index !== lastIndex) {
+      throw new Error(`Invalid selector at position ${lastIndex}: ${selector}`);
+    }
+    if (match[1] !== undefined) {
+      segments.push({ type: "key", name: match[1] });
+    } else if (match[3] !== undefined) {
+      segments.push({ type: "index", value: parseInt(match[3], 10) });
+    }
+    lastIndex = re.lastIndex;
+  }
+  if (lastIndex !== s.length) {
+    throw new Error(`Invalid selector at position ${lastIndex}: ${selector}`);
+  }
+  return segments;
+}
+function applySelector(value, selector) {
+  if (selector === "." || selector === "")
+    return value;
+  const segments = parseSelector(selector);
+  let current = value;
+  let path = "";
+  for (const seg of segments) {
+    if (seg.type === "key") {
+      path += `.${seg.name}`;
+      if (current === null || current === undefined || typeof current !== "object" || Array.isArray(current)) {
+        throw new Error(`Selector ${path}: cannot access property '${seg.name}' on ${typeLabel(current)}`);
+      }
+      const obj = current;
+      if (!(seg.name in obj)) {
+        throw new Error(`Selector ${path}: property '${seg.name}' not found`);
+      }
+      current = obj[seg.name];
+    } else {
+      path += `[${seg.value}]`;
+      if (!Array.isArray(current)) {
+        throw new Error(`Selector ${path}: cannot index into ${typeLabel(current)}`);
+      }
+      if (seg.value < 0 || seg.value >= current.length) {
+        throw new Error(`Selector ${path}: index ${seg.value} out of range (length ${current.length})`);
+      }
+      current = current[seg.value];
+    }
+  }
+  return current;
+}
+function typeLabel(v) {
+  if (v === null)
+    return "null";
+  if (v === undefined)
+    return "undefined";
+  if (Array.isArray(v))
+    return "array";
+  return typeof v;
+}
+function formatTree(value, color) {
+  const text = stringify3(value, { indent: 2, maxWidth: 80 });
+  if (!color)
+    return text;
+  return text.split(`
+`).map((line) => highlightLine(line)).join(`
+`);
+}
+function normalizeForJson(value, inArray) {
+  if (value === undefined)
+    return inArray ? null : undefined;
+  if (value === null || typeof value !== "object")
+    return value;
+  if (Array.isArray(value))
+    return value.map((item) => normalizeForJson(item, true));
+  const out = {};
+  for (const [key, val] of Object.entries(value)) {
+    const n = normalizeForJson(val, false);
+    if (n !== undefined)
+      out[key] = n;
+  }
+  return out;
+}
+function formatOutput(value, format, color) {
+  if (format === "tree")
+    return formatTree(value, color);
+  if (format === "json") {
+    const text = JSON.stringify(normalizeForJson(value, false), null, 2) ?? "null";
+    return color ? highlightJSON(text) : text;
+  }
+  return stringify2(value);
+}
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  if (opts.help) {
+    console.log(usage());
+    return;
+  }
+  setColorEnabled(opts.color);
+  const toFormat = opts.toFormat ?? (process.stdout.isTTY ? "tree" : "json");
+  const { value: parsed } = await readInput(opts);
+  const value = opts.select ? applySelector(parsed, opts.select) : parsed;
+  const output = formatOutput(value, toFormat, opts.color);
+  if (opts.out) {
+    await writeFile(opts.out, output + `
+`, "utf8");
+  } else {
+    process.stdout.write(output + `
+`);
+  }
+}
+await main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`rx: ${message}
+`);
+  process.exit(1);
+});