@creationix/rex 0.3.1 → 0.6.0

package/rex.js

@@ -10,31 +10,31 @@ function byteLength(value) {
   return Buffer.byteLength(value, "utf8");
 }
 var OPCODE_IDS = {
-  do: 0,
-  add: 1,
-  sub: 2,
-  mul: 3,
-  div: 4,
-  eq: 5,
-  neq: 6,
-  lt: 7,
-  lte: 8,
-  gt: 9,
-  gte: 10,
-  and: 11,
-  or: 12,
-  xor: 13,
-  not: 14,
-  boolean: 15,
-  number: 16,
-  string: 17,
-  array: 18,
-  object: 19,
-  mod: 20,
-  neg: 21
+  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"
 };
-var FIRST_NON_RESERVED_REF = 8;
-var DOMAIN_DIGIT_INDEX = new Map(Array.from(DIGITS).map((char, index) => [char, index]));
+var KEYWORD_OPCODES = new Set(["boolean", "number", "string", "array", "object"]);
 var BINARY_TO_OPCODE = {
   add: "add",
   sub: "sub",
@@ -163,11 +163,11 @@ function encodeDecimal(significand, power) {
 function encodeNumberNode(node) {
   const numberValue = node.value;
   if (Number.isNaN(numberValue))
-    return "5'";
+    return "nan'";
   if (numberValue === Infinity)
-    return "6'";
+    return "inf'";
   if (numberValue === -Infinity)
-    return "7'";
+    return "nif'";
   if (Number.isInteger(numberValue)) {
     const { base, exp } = splitDecimal(numberValue);
     if (exp >= 0 && exp <= 4)
@@ -199,7 +199,7 @@ function encodeNumberNode(node) {
   return encodeDecimal(significand, power);
 }
 function encodeOpcode(opcode) {
-  return `${encodeUint(OPCODE_IDS[opcode])}%`;
+  return `${OPCODE_IDS[opcode]}%`;
 }
 function encodeCallParts(parts) {
   return `(${parts.join("")})`;
@@ -216,7 +216,7 @@ function addOptionalPrefix(encoded) {
   let payload = encoded;
   if (encoded.startsWith("?(") || encoded.startsWith("!(") || encoded.startsWith("|(") || encoded.startsWith("&(") || encoded.startsWith(">(") || encoded.startsWith("<(") || encoded.startsWith("#(")) {
     payload = encoded.slice(2, -1);
-  } else if (encoded.startsWith(">[") || encoded.startsWith(">{")) {
+  } else if (encoded.startsWith(">[") || encoded.startsWith(">{") || encoded.startsWith("<[") || encoded.startsWith("<{") || encoded.startsWith("#[") || encoded.startsWith("#{")) {
     payload = encoded.slice(2, -1);
   } else if (encoded.startsWith("[") || encoded.startsWith("{") || encoded.startsWith("(")) {
     payload = encoded.slice(1, -1);
@@ -227,7 +227,7 @@ function addOptionalPrefix(encoded) {
 }
 function encodeBlockExpression(block) {
   if (block.length === 0)
-    return "4'";
+    return "un'";
   if (block.length === 1)
     return encodeNode(block[0]);
   return encodeCallParts([encodeOpcode("do"), ...block.map((node) => encodeNode(node))]);
@@ -244,9 +244,13 @@ function encodeConditionalElse(elseBranch) {
   };
   return encodeNode(nested);
 }
+function encodeDomainLookup(shortCode, tag) {
+  return `${shortCode}${tag}`;
+}
 function encodeNavigation(node) {
   const domainRefs = activeEncodeOptions?.domainRefs;
-  if (domainRefs && node.target.type === "identifier") {
+  const domainOpcodes = activeEncodeOptions?.domainOpcodes;
+  if ((domainRefs || domainOpcodes) && node.target.type === "identifier") {
     const staticPath = [node.target.name];
     for (const segment of node.segments) {
       if (segment.type !== "static")
@@ -255,14 +259,17 @@ function encodeNavigation(node) {
     }
     for (let pathLength = staticPath.length;pathLength >= 1; pathLength -= 1) {
       const dottedName = staticPath.slice(0, pathLength).join(".");
-      const domainRef = domainRefs[dottedName];
-      if (domainRef === undefined)
+      const refCode = domainRefs?.[dottedName];
+      const opcodeCode = domainOpcodes?.[dottedName];
+      const shortCode = refCode ?? opcodeCode;
+      if (shortCode === undefined)
         continue;
+      const tag = refCode !== undefined ? "'" : "%";
       const consumedStaticSegments = pathLength - 1;
       if (consumedStaticSegments === node.segments.length) {
-        return `${encodeUint(domainRef)}'`;
+        return encodeDomainLookup(shortCode, tag);
       }
-      const parts2 = [`${encodeUint(domainRef)}'`];
+      const parts2 = [encodeDomainLookup(shortCode, tag)];
       for (const segment of node.segments.slice(consumedStaticSegments)) {
         if (segment.type === "static")
           parts2.push(encodeBareOrLengthString(segment.key));
@@ -288,9 +295,12 @@ function encodeWhile(node) {
 }
 function encodeFor(node) {
   const body = addOptionalPrefix(encodeBlockExpression(node.body));
-  if (node.binding.type === "binding:expr") {
+  if (node.binding.type === "binding:bareIn") {
     return `>(${encodeNode(node.binding.source)}${body})`;
   }
+  if (node.binding.type === "binding:bareOf") {
+    return `<(${encodeNode(node.binding.source)}${body})`;
+  }
   if (node.binding.type === "binding:valueIn") {
     return `>(${encodeNode(node.binding.source)}${node.binding.value}$${body})`;
   }
@@ -301,30 +311,47 @@ function encodeFor(node) {
 }
 function encodeArrayComprehension(node) {
   const body = addOptionalPrefix(encodeNode(node.body));
-  if (node.binding.type === "binding:expr") {
+  if (node.binding.type === "binding:bareIn") {
     return `>[${encodeNode(node.binding.source)}${body}]`;
   }
+  if (node.binding.type === "binding:bareOf") {
+    return `<[${encodeNode(node.binding.source)}${body}]`;
+  }
   if (node.binding.type === "binding:valueIn") {
     return `>[${encodeNode(node.binding.source)}${node.binding.value}$${body}]`;
   }
   if (node.binding.type === "binding:keyValueIn") {
     return `>[${encodeNode(node.binding.source)}${node.binding.key}$${node.binding.value}$${body}]`;
   }
-  return `>[${encodeNode(node.binding.source)}${node.binding.key}$${body}]`;
+  return `<[${encodeNode(node.binding.source)}${node.binding.key}$${body}]`;
 }
 function encodeObjectComprehension(node) {
   const key = addOptionalPrefix(encodeNode(node.key));
   const value = addOptionalPrefix(encodeNode(node.value));
-  if (node.binding.type === "binding:expr") {
+  if (node.binding.type === "binding:bareIn") {
     return `>{${encodeNode(node.binding.source)}${key}${value}}`;
   }
+  if (node.binding.type === "binding:bareOf") {
+    return `<{${encodeNode(node.binding.source)}${key}${value}}`;
+  }
   if (node.binding.type === "binding:valueIn") {
     return `>{${encodeNode(node.binding.source)}${node.binding.value}$${key}${value}}`;
   }
   if (node.binding.type === "binding:keyValueIn") {
     return `>{${encodeNode(node.binding.source)}${node.binding.key}$${node.binding.value}$${key}${value}}`;
   }
-  return `>{${encodeNode(node.binding.source)}${node.binding.key}$${key}${value}}`;
+  return `<{${encodeNode(node.binding.source)}${node.binding.key}$${key}${value}}`;
+}
+function encodeWhileArrayComprehension(node) {
+  const cond = encodeNode(node.condition);
+  const body = addOptionalPrefix(encodeNode(node.body));
+  return `#[${cond}${body}]`;
+}
+function encodeWhileObjectComprehension(node) {
+  const cond = encodeNode(node.condition);
+  const key = addOptionalPrefix(encodeNode(node.key));
+  const value = addOptionalPrefix(encodeNode(node.value));
+  return `#{${cond}${key}${value}}`;
 }
 var activeEncodeOptions;
 function encodeNode(node) {
@@ -334,7 +361,10 @@ function encodeNode(node) {
     case "identifier": {
       const domainRef = activeEncodeOptions?.domainRefs?.[node.name];
       if (domainRef !== undefined)
-        return `${encodeUint(domainRef)}'`;
+        return `${domainRef}'`;
+      const domainOpcode = activeEncodeOptions?.domainOpcodes?.[node.name];
+      if (domainOpcode !== undefined)
+        return `${domainOpcode}%`;
       return `${node.name}$`;
     }
     case "self":
@@ -347,11 +377,11 @@ function encodeNode(node) {
       return `${encodeUint(node.depth - 1)}@`;
     }
     case "boolean":
-      return node.value ? "1'" : "2'";
+      return node.value ? "tr'" : "fl'";
     case "null":
-      return "3'";
+      return "nl'";
     case "undefined":
-      return "4'";
+      return "un'";
     case "number":
       return encodeNumberNode(node);
     case "string":
@@ -362,12 +392,16 @@ function encodeNode(node) {
     }
     case "arrayComprehension":
       return encodeArrayComprehension(node);
+    case "whileArrayComprehension":
+      return encodeWhileArrayComprehension(node);
     case "object": {
       const body = node.entries.map(({ key, value }) => `${encodeNode(key)}${addOptionalPrefix(encodeNode(value))}`).join("");
       return `{${body}}`;
     }
     case "objectComprehension":
       return encodeObjectComprehension(node);
+    case "whileObjectComprehension":
+      return encodeWhileObjectComprehension(node);
     case "key":
       return encodeBareOrLengthString(node.name);
     case "group":
@@ -377,6 +411,10 @@ function encodeNode(node) {
         return `~${encodeNode(node.value)}`;
       if (node.op === "neg")
         return encodeCallParts([encodeOpcode("neg"), encodeNode(node.value)]);
+      if (node.op === "logicalNot") {
+        const val = encodeNode(node.value);
+        return `!(${val}tr')`;
+      }
       return encodeCallParts([encodeOpcode("not"), encodeNode(node.value)]);
     case "binary":
       if (node.op === "and") {
@@ -395,12 +433,19 @@ function encodeNode(node) {
         }).join("");
         return `|(${body})`;
       }
+      if (node.op === "nor") {
+        const left = encodeNode(node.left);
+        const right = addOptionalPrefix(encodeNode(node.right));
+        return `!(${left}${right})`;
+      }
       return encodeCallParts([
         encodeOpcode(BINARY_TO_OPCODE[node.op]),
         encodeNode(node.left),
         encodeNode(node.right)
       ]);
     case "assign": {
+      if (node.op === ":=")
+        return `/${encodeNode(node.place)}${addOptionalPrefix(encodeNode(node.value))}`;
       if (node.op === "=")
         return `=${encodeNode(node.place)}${addOptionalPrefix(encodeNode(node.value))}`;
       const opcode = ASSIGN_COMPOUND_TO_OPCODE[node.op];
@@ -411,8 +456,12 @@ function encodeNode(node) {
     }
     case "navigation":
       return encodeNavigation(node);
-    case "call":
+    case "call": {
+      if (node.callee.type === "identifier" && KEYWORD_OPCODES.has(node.callee.name)) {
+        return encodeCallParts([encodeOpcode(node.callee.name), ...node.args.map((arg) => encodeNode(arg))]);
+      }
       return encodeCallParts([encodeNode(node.callee), ...node.args.map((arg) => encodeNode(arg))]);
+    }
     case "conditional": {
       const opener = node.head === "when" ? "?(" : "!(";
       const cond = encodeNode(node.condition);
@@ -420,6 +469,8 @@ function encodeNode(node) {
       const elseExpr = node.elseBranch ? addOptionalPrefix(encodeConditionalElse(node.elseBranch)) : "";
       return `${opener}${cond}${thenExpr}${elseExpr})`;
     }
+    case "range":
+      return encodeCallParts([encodeOpcode("range"), encodeNode(node.from), encodeNode(node.to)]);
     case "for":
       return encodeFor(node);
     case "while":
@@ -439,11 +490,30 @@ function collectLogicalChain(node, op) {
     return [node];
   return [...collectLogicalChain(node.left, op), ...collectLogicalChain(node.right, op)];
 }
+function formatParseError(source, match) {
+  const message = match.message ?? "Parse failed";
+  const pos = match.getRightmostFailurePosition?.();
+  if (typeof pos !== "number" || !Number.isFinite(pos))
+    return message;
+  const safePos = Math.max(0, Math.min(source.length, pos));
+  const lineStart = source.lastIndexOf(`
+`, safePos - 1) + 1;
+  const lineEndIndex = source.indexOf(`
+`, safePos);
+  const lineEnd = lineEndIndex === -1 ? source.length : lineEndIndex;
+  const lineText = source.slice(lineStart, lineEnd);
+  const lineNumber = source.slice(0, lineStart).split(`
+`).length;
+  const columnNumber = safePos - lineStart + 1;
+  const caret = `${" ".repeat(Math.max(0, columnNumber - 1))}^`;
+  return `${message}
+  ${lineText}
+  ${caret}`;
+}
 function parseToIR(source) {
   const match = grammar.match(source);
   if (!match.succeeded()) {
-    const failure = match;
-    throw new Error(failure.message ?? "Parse failed");
+    throw new Error(formatParseError(source, match));
   }
   return semantics(match).toIR();
 }
@@ -595,78 +665,55 @@ function domainRefsFromConfig(config) {
   if (!config || typeof config !== "object" || Array.isArray(config)) {
     throw new Error("Domain config must be an object");
   }
-  const refs = {};
-  for (const section of Object.values(config)) {
-    if (!section || typeof section !== "object" || Array.isArray(section))
-      continue;
-    mapConfigEntries(section, refs);
-  }
-  return refs;
-}
-function decodeDomainRefKey(refText) {
-  if (!refText)
-    throw new Error("Domain ref key cannot be empty");
-  if (!/^[0-9A-Za-z_-]+$/.test(refText)) {
-    throw new Error(`Invalid domain ref key '${refText}' (must use base64 alphabet 0-9a-zA-Z-_)`);
-  }
-  if (refText.length > 1 && refText[0] === "0") {
-    throw new Error(`Invalid domain ref key '${refText}' (leading zeroes are not allowed)`);
+  const configObj = config;
+  const domainRefs = {};
+  const domainOpcodes = {};
+  const dataSection = configObj.data;
+  if (dataSection && typeof dataSection === "object" && !Array.isArray(dataSection)) {
+    mapConfigEntries(dataSection, domainRefs);
   }
-  if (/^[1-9]$/.test(refText)) {
-    throw new Error(`Invalid domain ref key '${refText}' (reserved by core language)`);
+  const functionsSection = configObj.functions;
+  if (functionsSection && typeof functionsSection === "object" && !Array.isArray(functionsSection)) {
+    mapConfigEntries(functionsSection, domainOpcodes);
   }
-  let value = 0;
-  for (const char of refText) {
-    const digit = DOMAIN_DIGIT_INDEX.get(char);
-    if (digit === undefined)
-      throw new Error(`Invalid domain ref key '${refText}'`);
-    value = value * 64 + digit;
-    if (value > Number.MAX_SAFE_INTEGER) {
-      throw new Error(`Invalid domain ref key '${refText}' (must fit in 53 bits)`);
-    }
-  }
-  if (value < FIRST_NON_RESERVED_REF) {
-    throw new Error(`Invalid domain ref key '${refText}' (maps to reserved id ${value})`);
-  }
-  return value;
+  return { domainRefs, domainOpcodes };
 }
 function mapConfigEntries(entries, refs) {
   const sourceKindByRoot = new Map;
   for (const root of Object.keys(refs)) {
     sourceKindByRoot.set(root, "explicit");
   }
-  for (const [refText, rawEntry] of Object.entries(entries)) {
+  for (const [shortCode, rawEntry] of Object.entries(entries)) {
     const entry = rawEntry;
     if (!entry || typeof entry !== "object")
       continue;
     if (!Array.isArray(entry.names))
       continue;
-    const refId = decodeDomainRefKey(refText);
     for (const rawName of entry.names) {
       if (typeof rawName !== "string")
         continue;
-      const existingNameRef = refs[rawName];
-      if (existingNameRef !== undefined && existingNameRef !== refId) {
-        throw new Error(`Conflicting refs for '${rawName}': ${existingNameRef} vs ${refId}`);
+      const existingRef = refs[rawName];
+      if (existingRef !== undefined && existingRef !== shortCode) {
+        throw new Error(`Conflicting refs for '${rawName}': ${existingRef} vs ${shortCode}`);
       }
-      refs[rawName] = refId;
+      refs[rawName] = shortCode;
       const root = rawName.split(".")[0];
       if (!root)
         continue;
       const currentKind = rawName.includes(".") ? "implicit" : "explicit";
       const existing = refs[root];
       if (existing !== undefined) {
-        if (existing === refId)
+        if (existing === shortCode)
           continue;
         const existingKind = sourceKindByRoot.get(root) ?? "explicit";
         if (currentKind === "explicit") {
-          throw new Error(`Conflicting refs for '${root}': ${existing} vs ${refId}`);
+          throw new Error(`Conflicting refs for '${root}': ${existing} vs ${shortCode}`);
         }
         if (existingKind === "explicit")
           continue;
         continue;
       }
-      refs[root] = refId;
+      refs[root] = shortCode;
       sourceKindByRoot.set(root, currentKind);
     }
   }
@@ -812,20 +859,11 @@ function gatherEncodedValueSpans(text) {
   }
   return spans;
 }
-function buildPointerToken(pointerStart, targetStart) {
-  let offset = targetStart - (pointerStart + 1);
+function buildPointerToken(pointerStart, targetStart, occurrenceSize) {
+  const offset = targetStart - pointerStart - occurrenceSize;
   if (offset < 0)
     return;
-  for (let guard = 0;guard < 8; guard += 1) {
-    const prefix = encodeUint(offset);
-    const recalculated = targetStart - (pointerStart + prefix.length + 1);
-    if (recalculated === offset)
-      return `${prefix}^`;
-    offset = recalculated;
-    if (offset < 0)
-      return;
-  }
-  return;
+  return `${encodeUint(offset)}^`;
 }
 function buildDedupeCandidateTable(encoded, minBytes) {
   const spans = gatherEncodedValueSpans(encoded);
@@ -867,7 +905,7 @@ function dedupeLargeEncodedValues(encoded, minBytes = 4) {
         if (current.slice(occurrence.span.start, occurrence.span.end) !== value)
           continue;
         const canonicalCurrentStart = current.length - canonical.offsetFromEnd - canonical.sizeBytes;
-        const pointerToken = buildPointerToken(occurrence.span.start, canonicalCurrentStart);
+        const pointerToken = buildPointerToken(occurrence.span.start, canonicalCurrentStart, occurrence.sizeBytes);
         if (!pointerToken)
           continue;
         if (pointerToken.length >= occurrence.sizeBytes)
@@ -896,819 +934,8 @@ function encodeIR(node, options) {
     activeEncodeOptions = previous;
   }
 }
-function cloneNode(node) {
-  return structuredClone(node);
-}
-function emptyOptimizeEnv() {
-  return { constants: {}, selfCaptures: {} };
-}
-function cloneOptimizeEnv(env) {
-  return {
-    constants: { ...env.constants },
-    selfCaptures: { ...env.selfCaptures }
-  };
-}
-function clearOptimizeEnv(env) {
-  for (const key of Object.keys(env.constants))
-    delete env.constants[key];
-  for (const key of Object.keys(env.selfCaptures))
-    delete env.selfCaptures[key];
-}
-function clearBinding(env, name) {
-  delete env.constants[name];
-  delete env.selfCaptures[name];
-}
-function selfTargetFromNode(node, currentDepth) {
-  if (node.type === "self")
-    return currentDepth;
-  if (node.type === "selfDepth") {
-    const target = currentDepth - (node.depth - 1);
-    if (target >= 1)
-      return target;
-  }
-  return;
-}
-function selfNodeFromTarget(targetDepth, currentDepth) {
-  const relDepth = currentDepth - targetDepth + 1;
-  if (!Number.isInteger(relDepth) || relDepth < 1)
-    return;
-  if (relDepth === 1)
-    return { type: "self" };
-  return { type: "selfDepth", depth: relDepth };
-}
-function dropBindingNames(env, binding) {
-  if (binding.type === "binding:valueIn") {
-    clearBinding(env, binding.value);
-    return;
-  }
-  if (binding.type === "binding:keyValueIn") {
-    clearBinding(env, binding.key);
-    clearBinding(env, binding.value);
-    return;
-  }
-  if (binding.type === "binding:keyOf") {
-    clearBinding(env, binding.key);
-  }
-}
-function collectReads(node, out) {
-  switch (node.type) {
-    case "identifier":
-      out.add(node.name);
-      return;
-    case "group":
-      collectReads(node.expression, out);
-      return;
-    case "array":
-      for (const item of node.items)
-        collectReads(item, out);
-      return;
-    case "object":
-      for (const entry of node.entries) {
-        collectReads(entry.key, out);
-        collectReads(entry.value, out);
-      }
-      return;
-    case "arrayComprehension":
-      collectReads(node.binding.source, out);
-      collectReads(node.body, out);
-      return;
-    case "objectComprehension":
-      collectReads(node.binding.source, out);
-      collectReads(node.key, out);
-      collectReads(node.value, out);
-      return;
-    case "unary":
-      collectReads(node.value, out);
-      return;
-    case "binary":
-      collectReads(node.left, out);
-      collectReads(node.right, out);
-      return;
-    case "assign":
-      if (!(node.op === "=" && node.place.type === "identifier"))
-        collectReads(node.place, out);
-      collectReads(node.value, out);
-      return;
-    case "navigation":
-      collectReads(node.target, out);
-      for (const segment of node.segments) {
-        if (segment.type === "dynamic")
-          collectReads(segment.key, out);
-      }
-      return;
-    case "call":
-      collectReads(node.callee, out);
-      for (const arg of node.args)
-        collectReads(arg, out);
-      return;
-    case "conditional":
-      collectReads(node.condition, out);
-      for (const part of node.thenBlock)
-        collectReads(part, out);
-      if (node.elseBranch)
-        collectReadsElse(node.elseBranch, out);
-      return;
-    case "for":
-      collectReads(node.binding.source, out);
-      for (const part of node.body)
-        collectReads(part, out);
-      return;
-    case "program":
-      for (const part of node.body)
-        collectReads(part, out);
-      return;
-    default:
-      return;
-  }
-}
-function collectReadsElse(elseBranch, out) {
-  if (elseBranch.type === "else") {
-    for (const part of elseBranch.block)
-      collectReads(part, out);
-    return;
-  }
-  collectReads(elseBranch.condition, out);
-  for (const part of elseBranch.thenBlock)
-    collectReads(part, out);
-  if (elseBranch.elseBranch)
-    collectReadsElse(elseBranch.elseBranch, out);
-}
-function isPureNode(node) {
-  switch (node.type) {
-    case "identifier":
-    case "self":
-    case "selfDepth":
-    case "boolean":
-    case "null":
-    case "undefined":
-    case "number":
-    case "string":
-    case "key":
-      return true;
-    case "group":
-      return isPureNode(node.expression);
-    case "array":
-      return node.items.every((item) => isPureNode(item));
-    case "object":
-      return node.entries.every((entry) => isPureNode(entry.key) && isPureNode(entry.value));
-    case "navigation":
-      return isPureNode(node.target) && node.segments.every((segment) => segment.type === "static" || isPureNode(segment.key));
-    case "unary":
-      return node.op !== "delete" && isPureNode(node.value);
-    case "binary":
-      return isPureNode(node.left) && isPureNode(node.right);
-    default:
-      return false;
-  }
-}
-function eliminateDeadAssignments(block) {
-  const needed = new Set;
-  const out = [];
-  for (let index = block.length - 1;index >= 0; index -= 1) {
-    const node = block[index];
-    if (node.type === "conditional") {
-      let rewritten = node;
-      if (node.condition.type === "assign" && node.condition.op === "=" && node.condition.place.type === "identifier") {
-        const name = node.condition.place.name;
-        const branchReads = new Set;
-        for (const part of node.thenBlock)
-          collectReads(part, branchReads);
-        if (node.elseBranch)
-          collectReadsElse(node.elseBranch, branchReads);
-        if (!needed.has(name) && !branchReads.has(name)) {
-          rewritten = {
-            type: "conditional",
-            head: node.head,
-            condition: node.condition.value,
-            thenBlock: node.thenBlock,
-            elseBranch: node.elseBranch
-          };
-        }
-      }
-      collectReads(rewritten, needed);
-      out.push(rewritten);
-      continue;
-    }
-    if (node.type === "assign" && node.op === "=" && node.place.type === "identifier") {
-      collectReads(node.value, needed);
-      const name = node.place.name;
-      const canDrop = !needed.has(name) && isPureNode(node.value);
-      needed.delete(name);
-      if (canDrop)
-        continue;
-      out.push(node);
-      continue;
-    }
-    collectReads(node, needed);
-    out.push(node);
-  }
-  out.reverse();
-  return out;
-}
-function hasIdentifierRead(node, name, asPlace = false) {
-  if (node.type === "identifier")
-    return !asPlace && node.name === name;
-  switch (node.type) {
-    case "group":
-      return hasIdentifierRead(node.expression, name);
-    case "array":
-      return node.items.some((item) => hasIdentifierRead(item, name));
-    case "object":
-      return node.entries.some((entry) => hasIdentifierRead(entry.key, name) || hasIdentifierRead(entry.value, name));
-    case "navigation":
-      return hasIdentifierRead(node.target, name) || node.segments.some((segment) => segment.type === "dynamic" && hasIdentifierRead(segment.key, name));
-    case "unary":
-      return hasIdentifierRead(node.value, name, node.op === "delete");
-    case "binary":
-      return hasIdentifierRead(node.left, name) || hasIdentifierRead(node.right, name);
-    case "assign":
-      return hasIdentifierRead(node.place, name, true) || hasIdentifierRead(node.value, name);
-    default:
-      return false;
-  }
-}
-function countIdentifierReads(node, name, asPlace = false) {
-  if (node.type === "identifier")
-    return !asPlace && node.name === name ? 1 : 0;
-  switch (node.type) {
-    case "group":
-      return countIdentifierReads(node.expression, name);
-    case "array":
-      return node.items.reduce((sum, item) => sum + countIdentifierReads(item, name), 0);
-    case "object":
-      return node.entries.reduce((sum, entry) => sum + countIdentifierReads(entry.key, name) + countIdentifierReads(entry.value, name), 0);
-    case "navigation":
-      return countIdentifierReads(node.target, name) + node.segments.reduce((sum, segment) => sum + (segment.type === "dynamic" ? countIdentifierReads(segment.key, name) : 0), 0);
-    case "unary":
-      return countIdentifierReads(node.value, name, node.op === "delete");
-    case "binary":
-      return countIdentifierReads(node.left, name) + countIdentifierReads(node.right, name);
-    case "assign":
-      return countIdentifierReads(node.place, name, true) + countIdentifierReads(node.value, name);
-    default:
-      return 0;
-  }
-}
-function replaceIdentifier(node, name, replacement, asPlace = false) {
-  if (node.type === "identifier") {
-    if (!asPlace && node.name === name)
-      return cloneNode(replacement);
-    return node;
-  }
-  switch (node.type) {
-    case "group":
-      return {
-        type: "group",
-        expression: replaceIdentifier(node.expression, name, replacement)
-      };
-    case "array":
-      return { type: "array", items: node.items.map((item) => replaceIdentifier(item, name, replacement)) };
-    case "object":
-      return {
-        type: "object",
-        entries: node.entries.map((entry) => ({
-          key: replaceIdentifier(entry.key, name, replacement),
-          value: replaceIdentifier(entry.value, name, replacement)
-        }))
-      };
-    case "navigation":
-      return {
-        type: "navigation",
-        target: replaceIdentifier(node.target, name, replacement),
-        segments: node.segments.map((segment) => segment.type === "static" ? segment : { type: "dynamic", key: replaceIdentifier(segment.key, name, replacement) })
-      };
-    case "unary":
-      return {
-        type: "unary",
-        op: node.op,
-        value: replaceIdentifier(node.value, name, replacement, node.op === "delete")
-      };
-    case "binary":
-      return {
-        type: "binary",
-        op: node.op,
-        left: replaceIdentifier(node.left, name, replacement),
-        right: replaceIdentifier(node.right, name, replacement)
-      };
-    case "assign":
-      return {
-        type: "assign",
-        op: node.op,
-        place: replaceIdentifier(node.place, name, replacement, true),
-        value: replaceIdentifier(node.value, name, replacement)
-      };
-    default:
-      return node;
-  }
-}
-function isSafeInlineTargetNode(node) {
-  if (isPureNode(node))
-    return true;
-  if (node.type === "assign" && node.op === "=") {
-    return isPureNode(node.place) && isPureNode(node.value);
-  }
-  return false;
-}
-function inlineAdjacentPureAssignments(block) {
-  const out = [...block];
-  let changed = true;
-  while (changed) {
-    changed = false;
-    for (let index = 0;index < out.length - 1; index += 1) {
-      const current = out[index];
-      if (current.type !== "assign" || current.op !== "=" || current.place.type !== "identifier")
-        continue;
-      if (!isPureNode(current.value))
-        continue;
-      const name = current.place.name;
-      if (hasIdentifierRead(current.value, name))
-        continue;
-      const next = out[index + 1];
-      if (!isSafeInlineTargetNode(next))
-        continue;
-      if (countIdentifierReads(next, name) !== 1)
-        continue;
-      out[index + 1] = replaceIdentifier(next, name, current.value);
-      out.splice(index, 1);
-      changed = true;
-      break;
-    }
-  }
-  return out;
-}
-function toNumberNode(value) {
-  let raw;
-  if (Number.isNaN(value))
-    raw = "nan";
-  else if (value === Infinity)
-    raw = "inf";
-  else if (value === -Infinity)
-    raw = "-inf";
-  else
-    raw = String(value);
-  return { type: "number", raw, value };
-}
-function toStringNode(value) {
-  return { type: "string", raw: JSON.stringify(value) };
-}
-function toLiteralNode(value) {
-  if (value === undefined)
-    return { type: "undefined" };
-  if (value === null)
-    return { type: "null" };
-  if (typeof value === "boolean")
-    return { type: "boolean", value };
-  if (typeof value === "number")
-    return toNumberNode(value);
-  if (typeof value === "string")
-    return toStringNode(value);
-  if (Array.isArray(value)) {
-    const items = [];
-    for (const item of value) {
-      const lowered = toLiteralNode(item);
-      if (!lowered)
-        return;
-      items.push(lowered);
-    }
-    return { type: "array", items };
-  }
-  if (value && typeof value === "object") {
-    const entries = [];
-    for (const [key, entryValue] of Object.entries(value)) {
-      const loweredValue = toLiteralNode(entryValue);
-      if (!loweredValue)
-        return;
-      entries.push({ key: { type: "key", name: key }, value: loweredValue });
-    }
-    return { type: "object", entries };
-  }
-  return;
-}
-function constValue(node) {
-  switch (node.type) {
-    case "undefined":
-      return;
-    case "null":
-      return null;
-    case "boolean":
-      return node.value;
-    case "number":
-      return node.value;
-    case "string":
-      return decodeStringLiteral(node.raw);
-    case "key":
-      return node.name;
-    case "array": {
-      const out = [];
-      for (const item of node.items) {
-        const value = constValue(item);
-        if (value === undefined && item.type !== "undefined")
-          return;
-        out.push(value);
-      }
-      return out;
-    }
-    case "object": {
-      const out = {};
-      for (const entry of node.entries) {
-        const key = constValue(entry.key);
-        if (key === undefined && entry.key.type !== "undefined")
-          return;
-        const value = constValue(entry.value);
-        if (value === undefined && entry.value.type !== "undefined")
-          return;
-        out[String(key)] = value;
-      }
-      return out;
-    }
-    default:
-      return;
-  }
-}
-function isDefinedValue(value) {
-  return value !== undefined;
-}
-function foldUnary(op, value) {
-  if (op === "neg") {
-    if (typeof value !== "number")
-      return;
-    return -value;
-  }
-  if (op === "not") {
-    if (typeof value === "boolean")
-      return !value;
-    if (typeof value === "number")
-      return ~value;
-    return;
-  }
-  return;
-}
-function foldBinary(op, left, right) {
-  if (op === "add" || op === "sub" || op === "mul" || op === "div" || op === "mod") {
-    if (typeof left !== "number" || typeof right !== "number")
-      return;
-    if (op === "add")
-      return left + right;
-    if (op === "sub")
-      return left - right;
-    if (op === "mul")
-      return left * right;
-    if (op === "div")
-      return left / right;
-    return left % right;
-  }
-  if (op === "bitAnd" || op === "bitOr" || op === "bitXor") {
-    if (typeof left !== "number" || typeof right !== "number")
-      return;
-    if (op === "bitAnd")
-      return left & right;
-    if (op === "bitOr")
-      return left | right;
-    return left ^ right;
-  }
-  if (op === "eq")
-    return left === right ? left : undefined;
-  if (op === "neq")
-    return left !== right ? left : undefined;
-  if (op === "gt" || op === "gte" || op === "lt" || op === "lte") {
-    if (typeof left !== "number" || typeof right !== "number")
-      return;
-    if (op === "gt")
-      return left > right ? left : undefined;
-    if (op === "gte")
-      return left >= right ? left : undefined;
-    if (op === "lt")
-      return left < right ? left : undefined;
-    return left <= right ? left : undefined;
-  }
-  if (op === "and")
-    return isDefinedValue(left) ? right : undefined;
-  if (op === "or")
-    return isDefinedValue(left) ? left : right;
-  return;
-}
-function optimizeElse(elseBranch, env, currentDepth) {
-  if (!elseBranch)
-    return;
-  if (elseBranch.type === "else") {
-    return { type: "else", block: optimizeBlock(elseBranch.block, cloneOptimizeEnv(env), currentDepth) };
-  }
-  const optimizedCondition = optimizeNode(elseBranch.condition, env, currentDepth);
-  const foldedCondition = constValue(optimizedCondition);
-  if (foldedCondition !== undefined || optimizedCondition.type === "undefined") {
-    const passes = elseBranch.head === "when" ? isDefinedValue(foldedCondition) : !isDefinedValue(foldedCondition);
-    if (passes) {
-      return {
-        type: "else",
-        block: optimizeBlock(elseBranch.thenBlock, cloneOptimizeEnv(env), currentDepth)
-      };
-    }
-    return optimizeElse(elseBranch.elseBranch, env, currentDepth);
-  }
-  return {
-    type: "elseChain",
-    head: elseBranch.head,
-    condition: optimizedCondition,
-    thenBlock: optimizeBlock(elseBranch.thenBlock, cloneOptimizeEnv(env), currentDepth),
-    elseBranch: optimizeElse(elseBranch.elseBranch, cloneOptimizeEnv(env), currentDepth)
-  };
-}
-function optimizeBlock(block, env, currentDepth) {
-  const out = [];
-  for (const node of block) {
-    const optimized = optimizeNode(node, env, currentDepth);
-    out.push(optimized);
-    if (optimized.type === "break" || optimized.type === "continue")
-      break;
-    if (optimized.type === "assign" && optimized.op === "=" && optimized.place.type === "identifier") {
-      const selfTarget = selfTargetFromNode(optimized.value, currentDepth);
-      if (selfTarget !== undefined) {
-        env.selfCaptures[optimized.place.name] = selfTarget;
-        delete env.constants[optimized.place.name];
-        continue;
-      }
-      const folded = constValue(optimized.value);
-      if (folded !== undefined || optimized.value.type === "undefined") {
-        env.constants[optimized.place.name] = cloneNode(optimized.value);
-        delete env.selfCaptures[optimized.place.name];
-      } else {
-        clearBinding(env, optimized.place.name);
-      }
-      continue;
-    }
-    if (optimized.type === "unary" && optimized.op === "delete" && optimized.value.type === "identifier") {
-      clearBinding(env, optimized.value.name);
-      continue;
-    }
-    if (optimized.type === "assign" && optimized.place.type === "identifier") {
-      clearBinding(env, optimized.place.name);
-      continue;
-    }
-    if (optimized.type === "assign" || optimized.type === "for" || optimized.type === "call") {
-      clearOptimizeEnv(env);
-    }
-  }
-  return inlineAdjacentPureAssignments(eliminateDeadAssignments(out));
-}
-function optimizeNode(node, env, currentDepth, asPlace = false) {
-  switch (node.type) {
-    case "program": {
-      const body = optimizeBlock(node.body, cloneOptimizeEnv(env), currentDepth);
-      if (body.length === 0)
-        return { type: "undefined" };
-      if (body.length === 1)
-        return body[0];
-      return { type: "program", body };
-    }
-    case "identifier": {
-      if (asPlace)
-        return node;
-      const selfTarget = env.selfCaptures[node.name];
-      if (selfTarget !== undefined) {
-        const rewritten = selfNodeFromTarget(selfTarget, currentDepth);
-        if (rewritten)
-          return rewritten;
-      }
-      const replacement = env.constants[node.name];
-      return replacement ? cloneNode(replacement) : node;
-    }
-    case "group": {
-      return optimizeNode(node.expression, env, currentDepth);
-    }
-    case "array": {
-      return { type: "array", items: node.items.map((item) => optimizeNode(item, env, currentDepth)) };
-    }
-    case "object": {
-      return {
-        type: "object",
-        entries: node.entries.map((entry) => ({
-          key: optimizeNode(entry.key, env, currentDepth),
-          value: optimizeNode(entry.value, env, currentDepth)
-        }))
-      };
-    }
-    case "unary": {
-      const value = optimizeNode(node.value, env, currentDepth, node.op === "delete");
-      const foldedValue = constValue(value);
-      if (foldedValue !== undefined || value.type === "undefined") {
-        const folded = foldUnary(node.op, foldedValue);
-        const literal = folded === undefined ? undefined : toLiteralNode(folded);
-        if (literal)
-          return literal;
-      }
-      return { type: "unary", op: node.op, value };
-    }
-    case "binary": {
-      const left = optimizeNode(node.left, env, currentDepth);
-      const right = optimizeNode(node.right, env, currentDepth);
-      const leftValue = constValue(left);
-      const rightValue = constValue(right);
-      if ((leftValue !== undefined || left.type === "undefined") && (rightValue !== undefined || right.type === "undefined")) {
-        const folded = foldBinary(node.op, leftValue, rightValue);
-        const literal = folded === undefined ? undefined : toLiteralNode(folded);
-        if (literal)
-          return literal;
-      }
-      return { type: "binary", op: node.op, left, right };
-    }
-    case "navigation": {
-      const target = optimizeNode(node.target, env, currentDepth);
-      const segments = node.segments.map((segment) => segment.type === "static" ? segment : { type: "dynamic", key: optimizeNode(segment.key, env, currentDepth) });
-      const targetValue = constValue(target);
-      if (targetValue !== undefined || target.type === "undefined") {
-        let current = targetValue;
-        let foldable = true;
-        for (const segment of segments) {
-          if (!foldable)
-            break;
-          const key = segment.type === "static" ? segment.key : constValue(segment.key);
-          if (segment.type === "dynamic" && key === undefined && segment.key.type !== "undefined") {
-            foldable = false;
-            break;
-          }
-          if (current === null || current === undefined) {
-            current = undefined;
-            continue;
-          }
-          current = current[String(key)];
-        }
-        if (foldable) {
-          const literal = toLiteralNode(current);
-          if (literal)
-            return literal;
-        }
-      }
-      return {
-        type: "navigation",
-        target,
-        segments
-      };
-    }
-    case "call": {
-      return {
-        type: "call",
-        callee: optimizeNode(node.callee, env, currentDepth),
-        args: node.args.map((arg) => optimizeNode(arg, env, currentDepth))
-      };
-    }
-    case "assign": {
-      return {
-        type: "assign",
-        op: node.op,
-        place: optimizeNode(node.place, env, currentDepth, true),
-        value: optimizeNode(node.value, env, currentDepth)
-      };
-    }
-    case "conditional": {
-      const condition = optimizeNode(node.condition, env, currentDepth);
-      const thenEnv = cloneOptimizeEnv(env);
-      if (condition.type === "assign" && condition.op === "=" && condition.place.type === "identifier") {
-        thenEnv.selfCaptures[condition.place.name] = currentDepth;
-        delete thenEnv.constants[condition.place.name];
-      }
-      const conditionValue = constValue(condition);
-      if (conditionValue !== undefined || condition.type === "undefined") {
-        const passes = node.head === "when" ? isDefinedValue(conditionValue) : !isDefinedValue(conditionValue);
-        if (passes) {
-          const thenBlock2 = optimizeBlock(node.thenBlock, thenEnv, currentDepth);
-          if (thenBlock2.length === 0)
-            return { type: "undefined" };
-          if (thenBlock2.length === 1)
-            return thenBlock2[0];
-          return { type: "program", body: thenBlock2 };
-        }
-        if (!node.elseBranch)
-          return { type: "undefined" };
-        const loweredElse = optimizeElse(node.elseBranch, cloneOptimizeEnv(env), currentDepth);
-        if (!loweredElse)
-          return { type: "undefined" };
-        if (loweredElse.type === "else") {
-          if (loweredElse.block.length === 0)
-            return { type: "undefined" };
-          if (loweredElse.block.length === 1)
-            return loweredElse.block[0];
-          return { type: "program", body: loweredElse.block };
-        }
-        return {
-          type: "conditional",
-          head: loweredElse.head,
-          condition: loweredElse.condition,
-          thenBlock: loweredElse.thenBlock,
-          elseBranch: loweredElse.elseBranch
-        };
-      }
-      const thenBlock = optimizeBlock(node.thenBlock, thenEnv, currentDepth);
-      const elseBranch = optimizeElse(node.elseBranch, cloneOptimizeEnv(env), currentDepth);
-      let finalCondition = condition;
-      if (condition.type === "assign" && condition.op === "=" && condition.place.type === "identifier") {
-        const name = condition.place.name;
-        const reads = new Set;
-        for (const part of thenBlock)
-          collectReads(part, reads);
-        if (elseBranch)
-          collectReadsElse(elseBranch, reads);
-        if (!reads.has(name)) {
-          finalCondition = condition.value;
-        }
-      }
-      return {
-        type: "conditional",
-        head: node.head,
-        condition: finalCondition,
-        thenBlock,
-        elseBranch
-      };
-    }
-    case "for": {
-      const sourceEnv = cloneOptimizeEnv(env);
-      const binding = (() => {
-        if (node.binding.type === "binding:expr") {
-          return { type: "binding:expr", source: optimizeNode(node.binding.source, sourceEnv, currentDepth) };
-        }
-        if (node.binding.type === "binding:valueIn") {
-          return {
-            type: "binding:valueIn",
-            value: node.binding.value,
-            source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-          };
-        }
-        if (node.binding.type === "binding:keyValueIn") {
-          return {
-            type: "binding:keyValueIn",
-            key: node.binding.key,
-            value: node.binding.value,
-            source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-          };
-        }
-        return {
-          type: "binding:keyOf",
-          key: node.binding.key,
-          source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-        };
-      })();
-      const bodyEnv = cloneOptimizeEnv(env);
-      dropBindingNames(bodyEnv, binding);
-      return {
-        type: "for",
-        binding,
-        body: optimizeBlock(node.body, bodyEnv, currentDepth + 1)
-      };
-    }
-    case "arrayComprehension": {
-      const sourceEnv = cloneOptimizeEnv(env);
-      const binding = node.binding.type === "binding:expr" ? { type: "binding:expr", source: optimizeNode(node.binding.source, sourceEnv, currentDepth) } : node.binding.type === "binding:valueIn" ? {
-        type: "binding:valueIn",
-        value: node.binding.value,
-        source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-      } : node.binding.type === "binding:keyValueIn" ? {
-        type: "binding:keyValueIn",
-        key: node.binding.key,
-        value: node.binding.value,
-        source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-      } : {
-        type: "binding:keyOf",
-        key: node.binding.key,
-        source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-      };
-      const bodyEnv = cloneOptimizeEnv(env);
-      dropBindingNames(bodyEnv, binding);
-      return {
-        type: "arrayComprehension",
-        binding,
-        body: optimizeNode(node.body, bodyEnv, currentDepth + 1)
-      };
-    }
-    case "objectComprehension": {
-      const sourceEnv = cloneOptimizeEnv(env);
-      const binding = node.binding.type === "binding:expr" ? { type: "binding:expr", source: optimizeNode(node.binding.source, sourceEnv, currentDepth) } : node.binding.type === "binding:valueIn" ? {
-        type: "binding:valueIn",
-        value: node.binding.value,
-        source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-      } : node.binding.type === "binding:keyValueIn" ? {
-        type: "binding:keyValueIn",
-        key: node.binding.key,
-        value: node.binding.value,
-        source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-      } : {
-        type: "binding:keyOf",
-        key: node.binding.key,
-        source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-      };
-      const bodyEnv = cloneOptimizeEnv(env);
-      dropBindingNames(bodyEnv, binding);
-      return {
-        type: "objectComprehension",
-        binding,
-        key: optimizeNode(node.key, bodyEnv, currentDepth + 1),
-        value: optimizeNode(node.value, bodyEnv, currentDepth + 1)
-      };
-    }
-    default:
-      return node;
-  }
-}
 function optimizeIR(node) {
-  return optimizeNode(node, emptyOptimizeEnv(), 1);
+  return node;
 }
 function collectLocalBindings(node, locals) {
   switch (node.type) {
@@ -1754,6 +981,10 @@ function collectLocalBindings(node, locals) {
       collectLocalBindings(node.left, locals);
       collectLocalBindings(node.right, locals);
       return;
+    case "range":
+      collectLocalBindings(node.from, locals);
+      collectLocalBindings(node.to, locals);
+      return;
     case "conditional":
       collectLocalBindings(node.condition, locals);
       for (const part of node.thenBlock)
@@ -1770,11 +1001,20 @@ function collectLocalBindings(node, locals) {
       collectLocalBindingFromBinding(node.binding, locals);
       collectLocalBindings(node.body, locals);
       return;
+    case "whileArrayComprehension":
+      collectLocalBindings(node.condition, locals);
+      collectLocalBindings(node.body, locals);
+      return;
     case "objectComprehension":
       collectLocalBindingFromBinding(node.binding, locals);
       collectLocalBindings(node.key, locals);
       collectLocalBindings(node.value, locals);
       return;
+    case "whileObjectComprehension":
+      collectLocalBindings(node.condition, locals);
+      collectLocalBindings(node.key, locals);
+      collectLocalBindings(node.value, locals);
+      return;
     default:
       return;
   }
@@ -1866,6 +1106,10 @@ function collectNameFrequencies(node, locals, frequencies, order, nextOrder) {
       collectNameFrequencies(node.left, locals, frequencies, order, nextOrder);
       collectNameFrequencies(node.right, locals, frequencies, order, nextOrder);
       return;
+    case "range":
+      collectNameFrequencies(node.from, locals, frequencies, order, nextOrder);
+      collectNameFrequencies(node.to, locals, frequencies, order, nextOrder);
+      return;
     case "conditional":
       collectNameFrequencies(node.condition, locals, frequencies, order, nextOrder);
       for (const part of node.thenBlock)
@@ -1882,11 +1126,20 @@ function collectNameFrequencies(node, locals, frequencies, order, nextOrder) {
       collectNameFrequenciesBinding(node.binding, locals, frequencies, order, nextOrder);
       collectNameFrequencies(node.body, locals, frequencies, order, nextOrder);
       return;
+    case "whileArrayComprehension":
+      collectNameFrequencies(node.condition, locals, frequencies, order, nextOrder);
+      collectNameFrequencies(node.body, locals, frequencies, order, nextOrder);
+      return;
     case "objectComprehension":
       collectNameFrequenciesBinding(node.binding, locals, frequencies, order, nextOrder);
       collectNameFrequencies(node.key, locals, frequencies, order, nextOrder);
       collectNameFrequencies(node.value, locals, frequencies, order, nextOrder);
       return;
+    case "whileObjectComprehension":
+      collectNameFrequencies(node.condition, locals, frequencies, order, nextOrder);
+      collectNameFrequencies(node.key, locals, frequencies, order, nextOrder);
+      collectNameFrequencies(node.value, locals, frequencies, order, nextOrder);
+      return;
     default:
       return;
   }
@@ -1961,6 +1214,12 @@ function renameLocalNames(node, map) {
         left: renameLocalNames(node.left, map),
         right: renameLocalNames(node.right, map)
       };
+    case "range":
+      return {
+        type: "range",
+        from: renameLocalNames(node.from, map),
+        to: renameLocalNames(node.to, map)
+      };
     case "assign": {
       const place = node.place.type === "identifier" && map.has(node.place.name) ? { type: "identifier", name: map.get(node.place.name) } : renameLocalNames(node.place, map);
       return {
@@ -1990,6 +1249,12 @@ function renameLocalNames(node, map) {
         binding: renameLocalNamesBinding(node.binding, map),
         body: renameLocalNames(node.body, map)
       };
+    case "whileArrayComprehension":
+      return {
+        type: "whileArrayComprehension",
+        condition: renameLocalNames(node.condition, map),
+        body: renameLocalNames(node.body, map)
+      };
     case "objectComprehension":
       return {
         type: "objectComprehension",
@@ -1997,34 +1262,31 @@ function renameLocalNames(node, map) {
         key: renameLocalNames(node.key, map),
         value: renameLocalNames(node.value, map)
       };
+    case "whileObjectComprehension":
+      return {
+        type: "whileObjectComprehension",
+        condition: renameLocalNames(node.condition, map),
+        key: renameLocalNames(node.key, map),
+        value: renameLocalNames(node.value, map)
+      };
     default:
       return node;
   }
 }
 function renameLocalNamesBinding(binding, map) {
-  if (binding.type === "binding:expr") {
-    return { type: "binding:expr", source: renameLocalNames(binding.source, map) };
-  }
-  if (binding.type === "binding:valueIn") {
-    return {
-      type: "binding:valueIn",
-      value: map.get(binding.value) ?? binding.value,
-      source: renameLocalNames(binding.source, map)
-    };
+  const source = renameLocalNames(binding.source, map);
+  switch (binding.type) {
+    case "binding:bareIn":
+      return { type: "binding:bareIn", source };
+    case "binding:bareOf":
+      return { type: "binding:bareOf", source };
+    case "binding:valueIn":
+      return { type: "binding:valueIn", value: map.get(binding.value) ?? binding.value, source };
+    case "binding:keyValueIn":
+      return { type: "binding:keyValueIn", key: map.get(binding.key) ?? binding.key, value: map.get(binding.value) ?? binding.value, source };
+    case "binding:keyOf":
+      return { type: "binding:keyOf", key: map.get(binding.key) ?? binding.key, source };
   }
-  if (binding.type === "binding:keyValueIn") {
-    return {
-      type: "binding:keyValueIn",
-      key: map.get(binding.key) ?? binding.key,
-      value: map.get(binding.value) ?? binding.value,
-      source: renameLocalNames(binding.source, map)
-    };
-  }
-  return {
-    type: "binding:keyOf",
-    key: map.get(binding.key) ?? binding.key,
-    source: renameLocalNames(binding.source, map)
-  };
 }
 function renameLocalNamesElse(elseBranch, map) {
   if (elseBranch.type === "else") {
@@ -2071,9 +1333,9 @@ function compile(source, options) {
   let lowered = options?.optimize ? optimizeIR(ir) : ir;
   if (options?.minifyNames)
     lowered = minifyLocalNamesIR(lowered);
-  const domainRefs = options?.domainConfig ? domainRefsFromConfig(options.domainConfig) : undefined;
+  const domainMaps = options?.domainConfig ? domainRefsFromConfig(options.domainConfig) : undefined;
   return encodeIR(lowered, {
-    domainRefs,
+    ...domainMaps,
     dedupeValues: options?.dedupeValues,
     dedupeMinBytes: options?.dedupeMinBytes
   });
@@ -2199,6 +1461,9 @@ semantics.addOperation("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() };
   },
@@ -2208,6 +1473,9 @@ semantics.addOperation("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",
@@ -2248,6 +1516,9 @@ semantics.addOperation("toIR", {
   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() };
   },
@@ -2301,14 +1572,6 @@ semantics.addOperation("toIR", {
   ConditionalElse_else(_else, block) {
     return { type: "else", block: block.toIR() };
   },
-  DoExpr(_do, block, _end) {
-    const body = block.toIR();
-    if (body.length === 0)
-      return { type: "undefined" };
-    if (body.length === 1)
-      return body[0];
-    return { type: "program", body };
-  },
   WhileExpr(_while, condition, _do, block, _end) {
     return {
       type: "while",
@@ -2323,30 +1586,44 @@ semantics.addOperation("toIR", {
       body: block.toIR()
     };
   },
-  BindingExpr(iterOrExpr) {
-    const node = iterOrExpr.toIR();
-    if (typeof node === "object" && node && "type" in node && String(node.type).startsWith("binding:")) {
-      return node;
-    }
-    return { type: "binding:expr", source: node };
-  },
   Array_empty(_open, _close) {
     return { type: "array", items: [] };
   },
-  Array_comprehension(_open, binding, _semi, body, _close) {
+  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_comprehension(_open, binding, _semi, key, _colon, value, _close) {
+  Object_forComprehension(_open, key, _colon, value, _for, binding, _close) {
     return {
       type: "objectComprehension",
       binding: binding.toIR(),
@@ -2354,6 +1631,30 @@ semantics.addOperation("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",
@@ -2382,6 +1683,40 @@ semantics.addOperation("toIR", {
       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() };
   },
@@ -2467,6 +1802,7 @@ export {
   optimizeIR,
   minifyLocalNamesIR,
   grammar,
+  formatParseError,
   encodeIR,
   domainRefsFromConfig,
   rex_default as default,