@creationix/rex 0.3.0 → 0.4.1

package/rex.js

@@ -10,31 +10,32 @@ 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",
+  size: "sz"
 };
-var FIRST_NON_RESERVED_REF = 5;
-var DOMAIN_DIGIT_INDEX = new Map(Array.from(DIGITS).map((char, index) => [char, index]));
+var KEYWORD_OPCODES = new Set(["boolean", "number", "string", "array", "object", "size"]);
 var BINARY_TO_OPCODE = {
   add: "add",
   sub: "sub",
@@ -147,12 +148,33 @@ function encodeBareOrLengthString(value) {
     return `${value}:`;
   return `${encodeUint(byteLength(value))},${value}`;
 }
+var DEC_PARTS = /^(-?\d)(?:\.(\d+))?e([+-]\d+)$/;
+function splitDecimal(num) {
+  const match = num.toExponential().match(DEC_PARTS);
+  if (!match)
+    throw new Error(`Failed to split decimal for ${num}`);
+  const [, b1, b2 = "", e1] = match;
+  const base = Number.parseInt(b1 + b2, 10);
+  const exp = Number.parseInt(e1, 10) - b2.length;
+  return { base, exp };
+}
+function encodeDecimal(significand, power) {
+  return `${encodeZigzag(power)}*${encodeInt(significand)}`;
+}
 function encodeNumberNode(node) {
   const numberValue = node.value;
-  if (!Number.isFinite(numberValue))
-    throw new Error(`Cannot encode non-finite number: ${node.raw}`);
-  if (Number.isInteger(numberValue))
-    return encodeInt(numberValue);
+  if (Number.isNaN(numberValue))
+    return "nan'";
+  if (numberValue === Infinity)
+    return "inf'";
+  if (numberValue === -Infinity)
+    return "nif'";
+  if (Number.isInteger(numberValue)) {
+    const { base, exp } = splitDecimal(numberValue);
+    if (exp >= 0 && exp <= 4)
+      return encodeInt(numberValue);
+    return encodeDecimal(base, exp);
+  }
   const raw = node.raw.toLowerCase();
   const sign = raw.startsWith("-") ? -1 : 1;
   const unsigned = sign < 0 ? raw.slice(1) : raw;
@@ -175,10 +197,10 @@ function encodeNumberNode(node) {
     significand /= 10;
     power += 1;
   }
-  return `${encodeZigzag(power)}*${encodeInt(significand)}`;
+  return encodeDecimal(significand, power);
 }
 function encodeOpcode(opcode) {
-  return `${encodeUint(OPCODE_IDS[opcode])}%`;
+  return `${OPCODE_IDS[opcode]}%`;
 }
 function encodeCallParts(parts) {
   return `(${parts.join("")})`;
@@ -195,7 +217,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);
@@ -206,7 +228,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))]);
@@ -223,9 +245,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")
@@ -234,14 +260,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));
@@ -267,9 +296,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})`;
   }
@@ -280,30 +312,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) {
@@ -313,7 +362,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":
@@ -326,11 +378,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":
@@ -341,12 +393,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":
@@ -356,6 +412,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") {
@@ -374,12 +434,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];
@@ -390,8 +457,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);
@@ -399,6 +470,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":
@@ -477,6 +550,18 @@ function isPlainObject(value) {
 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);
 }
@@ -488,8 +573,12 @@ function stringifyInline(value) {
   if (typeof value === "boolean")
     return value ? "true" : "false";
   if (typeof value === "number") {
-    if (!Number.isFinite(value))
-      throw new Error("Rex stringify() cannot encode non-finite numbers");
+    if (Number.isNaN(value))
+      return "nan";
+    if (value === Infinity)
+      return "inf";
+    if (value === -Infinity)
+      return "-inf";
     return String(value);
   }
   if (typeof value === "string")
@@ -503,7 +592,7 @@ function stringifyInline(value) {
     const entries = Object.entries(value);
     if (entries.length === 0)
       return "{}";
-    const body = entries.map(([key, item]) => `${isBareKeyName(key) ? key : stringifyString(key)}: ${stringifyInline(item)}`).join(" ");
+    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}`);
@@ -540,7 +629,7 @@ ${indent}]`;
     if (entries.length === 0)
       return "{}";
     const lines = entries.map(([key, item]) => {
-      const keyText = isBareKeyName(key) ? key : stringifyString(key);
+      const keyText = stringifyKey(key);
       const rendered = stringifyPretty(item, depth + 1, indentSize, maxWidth);
       return `${childIndent}${keyText}: ${rendered}`;
     });
@@ -558,78 +647,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)`);
-  }
-  if (/^[1-9]$/.test(refText)) {
-    throw new Error(`Invalid domain ref key '${refText}' (reserved by core language)`);
-  }
-  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)`);
-    }
+  const configObj = config;
+  const domainRefs = {};
+  const domainOpcodes = {};
+  const dataSection = configObj.data;
+  if (dataSection && typeof dataSection === "object" && !Array.isArray(dataSection)) {
+    mapConfigEntries(dataSection, domainRefs);
   }
-  if (value < FIRST_NON_RESERVED_REF) {
-    throw new Error(`Invalid domain ref key '${refText}' (maps to reserved id ${value})`);
+  const functionsSection = configObj.functions;
+  if (functionsSection && typeof functionsSection === "object" && !Array.isArray(functionsSection)) {
+    mapConfigEntries(functionsSection, domainOpcodes);
   }
-  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);
     }
   }
@@ -913,6 +979,21 @@ function dropBindingNames(env, binding) {
     clearBinding(env, binding.key);
   }
 }
+function optimizeBinding(binding, sourceEnv, currentDepth) {
+  const source = optimizeNode(binding.source, sourceEnv, currentDepth);
+  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: binding.value, source };
+    case "binding:keyValueIn":
+      return { type: "binding:keyValueIn", key: binding.key, value: binding.value, source };
+    case "binding:keyOf":
+      return { type: "binding:keyOf", key: binding.key, source };
+  }
+}
 function collectReads(node, out) {
   switch (node.type) {
     case "identifier":
@@ -935,11 +1016,20 @@ function collectReads(node, out) {
       collectReads(node.binding.source, out);
       collectReads(node.body, out);
       return;
+    case "whileArrayComprehension":
+      collectReads(node.condition, out);
+      collectReads(node.body, out);
+      return;
     case "objectComprehension":
       collectReads(node.binding.source, out);
       collectReads(node.key, out);
       collectReads(node.value, out);
       return;
+    case "whileObjectComprehension":
+      collectReads(node.condition, out);
+      collectReads(node.key, out);
+      collectReads(node.value, out);
+      return;
     case "unary":
       collectReads(node.value, out);
       return;
@@ -976,6 +1066,10 @@ function collectReads(node, out) {
       for (const part of node.body)
         collectReads(part, out);
       return;
+    case "range":
+      collectReads(node.from, out);
+      collectReads(node.to, out);
+      return;
     case "program":
       for (const part of node.body)
         collectReads(part, out);
@@ -1020,6 +1114,8 @@ function isPureNode(node) {
       return node.op !== "delete" && isPureNode(node.value);
     case "binary":
       return isPureNode(node.left) && isPureNode(node.right);
+    case "range":
+      return isPureNode(node.from) && isPureNode(node.to);
     default:
       return false;
   }
@@ -1084,6 +1180,8 @@ function hasIdentifierRead(node, name, asPlace = false) {
       return hasIdentifierRead(node.value, name, node.op === "delete");
     case "binary":
       return hasIdentifierRead(node.left, name) || hasIdentifierRead(node.right, name);
+    case "range":
+      return hasIdentifierRead(node.from, name) || hasIdentifierRead(node.to, name);
     case "assign":
       return hasIdentifierRead(node.place, name, true) || hasIdentifierRead(node.value, name);
     default:
@@ -1106,6 +1204,8 @@ function countIdentifierReads(node, name, asPlace = false) {
       return countIdentifierReads(node.value, name, node.op === "delete");
     case "binary":
       return countIdentifierReads(node.left, name) + countIdentifierReads(node.right, name);
+    case "range":
+      return countIdentifierReads(node.from, name) + countIdentifierReads(node.to, name);
     case "assign":
       return countIdentifierReads(node.place, name, true) + countIdentifierReads(node.value, name);
     default:
@@ -1160,6 +1260,12 @@ function replaceIdentifier(node, name, replacement, asPlace = false) {
         place: replaceIdentifier(node.place, name, replacement, true),
         value: replaceIdentifier(node.value, name, replacement)
       };
+    case "range":
+      return {
+        type: "range",
+        from: replaceIdentifier(node.from, name, replacement),
+        to: replaceIdentifier(node.to, name, replacement)
+      };
     default:
       return node;
   }
@@ -1200,7 +1306,16 @@ function inlineAdjacentPureAssignments(block) {
   return out;
 }
 function toNumberNode(value) {
-  return { type: "number", raw: String(value), 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) };
@@ -1212,7 +1327,7 @@ function toLiteralNode(value) {
     return { type: "null" };
   if (typeof value === "boolean")
     return { type: "boolean", value };
-  if (typeof value === "number" && Number.isFinite(value))
+  if (typeof value === "number")
     return toNumberNode(value);
   if (typeof value === "string")
     return toStringNode(value);
@@ -1295,6 +1410,9 @@ function foldUnary(op, value) {
       return ~value;
     return;
   }
+  if (op === "logicalNot") {
+    return value === undefined ? true : undefined;
+  }
   return;
 }
 function foldBinary(op, left, right) {
@@ -1465,6 +1583,12 @@ function optimizeNode(node, env, currentDepth, asPlace = false) {
       }
       return { type: "binary", op: node.op, left, right };
     }
+    case "range":
+      return {
+        type: "range",
+        from: optimizeNode(node.from, env, currentDepth),
+        to: optimizeNode(node.to, env, currentDepth)
+      };
     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) });
@@ -1575,31 +1699,7 @@ function optimizeNode(node, env, currentDepth, asPlace = false) {
     }
     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 binding = optimizeBinding(node.binding, sourceEnv, currentDepth);
       const bodyEnv = cloneOptimizeEnv(env);
       dropBindingNames(bodyEnv, binding);
       return {
@@ -1610,20 +1710,7 @@ function optimizeNode(node, env, currentDepth, asPlace = false) {
     }
     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 binding = optimizeBinding(node.binding, sourceEnv, currentDepth);
       const bodyEnv = cloneOptimizeEnv(env);
       dropBindingNames(bodyEnv, binding);
       return {
@@ -1632,22 +1719,15 @@ function optimizeNode(node, env, currentDepth, asPlace = false) {
         body: optimizeNode(node.body, bodyEnv, currentDepth + 1)
       };
     }
+    case "whileArrayComprehension":
+      return {
+        type: "whileArrayComprehension",
+        condition: optimizeNode(node.condition, env, currentDepth),
+        body: optimizeNode(node.body, env, 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 binding = optimizeBinding(node.binding, sourceEnv, currentDepth);
       const bodyEnv = cloneOptimizeEnv(env);
       dropBindingNames(bodyEnv, binding);
       return {
@@ -1657,6 +1737,13 @@ function optimizeNode(node, env, currentDepth, asPlace = false) {
         value: optimizeNode(node.value, bodyEnv, currentDepth + 1)
       };
     }
+    case "whileObjectComprehension":
+      return {
+        type: "whileObjectComprehension",
+        condition: optimizeNode(node.condition, env, currentDepth),
+        key: optimizeNode(node.key, env, currentDepth + 1),
+        value: optimizeNode(node.value, env, currentDepth + 1)
+      };
     default:
       return node;
   }
@@ -1708,6 +1795,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)
@@ -1724,11 +1815,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;
   }
@@ -1820,6 +1920,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)
@@ -1836,11 +1940,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;
   }
@@ -1915,6 +2028,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 {
@@ -1944,6 +2063,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",
@@ -1951,34 +2076,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") {
@@ -2025,14 +2147,20 @@ 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
   });
 }
 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)) {
@@ -2147,6 +2275,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() };
   },
@@ -2156,6 +2287,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",
@@ -2196,6 +2330,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() };
   },
@@ -2249,14 +2386,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",
@@ -2271,30 +2400,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(),
@@ -2302,6 +2445,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",
@@ -2330,6 +2497,18 @@ 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()
+    };
+  },
   Pair(key, _colon, value) {
     return { key: key.toIR(), value: value.toIR() };
   },
@@ -2393,6 +2572,9 @@ semantics.addOperation("toIR", {
   BooleanKw(_kw) {
     return { type: "identifier", name: "boolean" };
   },
+  SizeKw(_kw) {
+    return { type: "identifier", name: "size" };
+  },
   identifier(_a, _b) {
     return { type: "identifier", name: this.sourceString };
   },