@creationix/rex 0.3.1 → 0.4.1

package/rex-repl.js

@@ -14,31 +14,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 = 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", "size"]);
 var BINARY_TO_OPCODE = {
   add: "add",
   sub: "sub",
@@ -167,11 +168,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)
@@ -203,7 +204,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("")})`;
@@ -220,7 +221,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);
@@ -231,7 +232,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))]);
@@ -248,9 +249,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")
@@ -259,14 +264,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));
@@ -292,9 +300,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})`;
   }
@@ -305,30 +316,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) {
@@ -338,7 +366,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":
@@ -351,11 +382,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":
@@ -366,12 +397,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":
@@ -381,6 +416,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") {
@@ -399,12 +438,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];
@@ -415,8 +461,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);
@@ -424,6 +474,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":
@@ -554,78 +606,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);
+  const configObj = config;
+  const domainRefs = {};
+  const domainOpcodes = {};
+  const dataSection = configObj.data;
+  if (dataSection && typeof dataSection === "object" && !Array.isArray(dataSection)) {
+    mapConfigEntries(dataSection, domainRefs);
   }
-  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 functionsSection = configObj.functions;
+  if (functionsSection && typeof functionsSection === "object" && !Array.isArray(functionsSection)) {
+    mapConfigEntries(functionsSection, domainOpcodes);
   }
-  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)`);
-    }
-  }
-  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);
     }
   }
@@ -909,6 +938,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":
@@ -931,11 +975,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;
@@ -972,6 +1025,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);
@@ -1016,6 +1073,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;
   }
@@ -1080,6 +1139,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:
@@ -1102,6 +1163,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:
@@ -1156,6 +1219,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;
   }
@@ -1300,6 +1369,9 @@ function foldUnary(op, value) {
       return ~value;
     return;
   }
+  if (op === "logicalNot") {
+    return value === undefined ? true : undefined;
+  }
   return;
 }
 function foldBinary(op, left, right) {
@@ -1470,6 +1542,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) });
@@ -1580,31 +1658,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 {
@@ -1615,20 +1669,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 {
@@ -1637,22 +1678,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 {
@@ -1662,6 +1696,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;
   }
@@ -1713,6 +1754,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)
@@ -1729,11 +1774,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;
   }
@@ -1825,6 +1879,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)
@@ -1841,11 +1899,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;
   }
@@ -1920,6 +1987,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 {
@@ -1949,6 +2022,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",
@@ -1956,34 +2035,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") {
@@ -2030,9 +2106,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
   });
@@ -2158,6 +2234,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() };
   },
@@ -2167,6 +2246,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",
@@ -2207,6 +2289,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() };
   },
@@ -2260,14 +2345,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",
@@ -2282,30 +2359,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(),
@@ -2313,6 +2404,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",
@@ -2341,6 +2456,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() };
   },
@@ -2404,6 +2531,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 };
   },
@@ -2422,28 +2552,30 @@ semantics.addOperation("toIR", {
 var DIGITS2 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_";
 var digitMap = new Map(Array.from(DIGITS2).map((char, index) => [char, index]));
 var OPCODES = {
-  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"
 };
 function decodePrefix(text, start, end) {
   let value = 0;
@@ -2467,7 +2599,6 @@ class CursorInterpreter {
   pos = 0;
   state;
   selfStack;
-  opcodeMarkers;
   pointerCache = new Map;
   gasLimit;
   gas = 0;
@@ -2482,28 +2613,22 @@ class CursorInterpreter {
     this.state = {
       vars: ctx.vars ?? {},
       refs: {
-        0: ctx.refs?.[0],
-        1: ctx.refs?.[1] ?? true,
-        2: ctx.refs?.[2] ?? false,
-        3: ctx.refs?.[3] ?? null,
-        4: ctx.refs?.[4] ?? undefined,
-        5: ctx.refs?.[5] ?? NaN,
-        6: ctx.refs?.[6] ?? Infinity,
-        7: ctx.refs?.[7] ?? -Infinity
+        tr: true,
+        fl: false,
+        nl: null,
+        un: undefined,
+        nan: NaN,
+        inf: Infinity,
+        nif: -Infinity,
+        ...ctx.refs
       }
     };
     this.selfStack = ctx.selfStack && ctx.selfStack.length > 0 ? [...ctx.selfStack] : [initialSelf];
     this.gasLimit = ctx.gasLimit ?? 0;
-    this.opcodeMarkers = Array.from({ length: 256 }, (_, id) => ({ __opcode: id }));
-    for (const [idText, value] of Object.entries(ctx.refs ?? {})) {
-      const id = Number(idText);
-      if (Number.isInteger(id))
-        this.state.refs[id] = value;
-    }
     if (ctx.opcodes) {
-      for (const [idText, op] of Object.entries(ctx.opcodes)) {
+      for (const [key, op] of Object.entries(ctx.opcodes)) {
         if (op)
-          this.customOpcodes.set(Number(idText), op);
+          this.customOpcodes.set(key, op);
       }
     }
   }
@@ -2564,6 +2689,22 @@ class CursorInterpreter {
     const end = this.pos;
     return { start, end, value: decodePrefix(this.text, start, end), raw: this.text.slice(start, end) };
   }
+  advanceByBytes(start, byteCount) {
+    if (byteCount <= 0)
+      return start;
+    let bytes = 0;
+    let index = start;
+    for (const char of this.text.slice(start)) {
+      const charBytes = Buffer.byteLength(char);
+      if (bytes + charBytes > byteCount)
+        break;
+      bytes += charBytes;
+      index += char.length;
+      if (bytes === byteCount)
+        return index;
+    }
+    throw new Error("String container overflows input");
+  }
   ensure(char) {
     if (this.text[this.pos] !== char)
       throw new Error(`Expected '${char}' at ${this.pos}`);
@@ -2604,36 +2745,34 @@ class CursorInterpreter {
         const significand = this.evalValue();
         if (typeof significand !== "number")
           throw new Error("Decimal significand must be numeric");
-        return significand * 10 ** power;
+        return parseFloat(`${significand}e${power}`);
       }
       case ":":
         this.pos += 1;
         return prefix.raw;
       case "%":
         this.pos += 1;
-        return this.opcodeMarkers[prefix.value] ?? { __opcode: prefix.value };
+        return { __opcode: prefix.raw };
       case "@":
         this.pos += 1;
         return this.readSelf(prefix.value);
       case "'":
         this.pos += 1;
-        return this.state.refs[prefix.value];
+        return this.state.refs[prefix.raw];
       case "$":
         this.pos += 1;
         return this.state.vars[prefix.raw];
       case ",": {
         this.pos += 1;
         const start = this.pos;
-        const end = start + prefix.value;
-        if (end > this.text.length)
-          throw new Error("String container overflows input");
+        const end = this.advanceByBytes(start, prefix.value);
         const value = this.text.slice(start, end);
         this.pos = end;
         return value;
       }
       case "^": {
         this.pos += 1;
-        const target = this.pos + prefix.value;
+        const target = this.advanceByBytes(this.pos, prefix.value);
         if (this.pointerCache.has(target))
           return this.pointerCache.get(target);
         const save = this.pos;
@@ -2650,6 +2789,14 @@ class CursorInterpreter {
         this.writePlace(place, value);
         return value;
       }
+      case "/": {
+        this.pos += 1;
+        const place = this.readPlace();
+        const oldValue = this.readPlaceValue(place);
+        const newValue = this.evalValue();
+        this.writePlace(place, newValue);
+        return oldValue;
+      }
       case "~": {
         this.pos += 1;
         const place = this.readPlace();
@@ -2677,7 +2824,7 @@ class CursorInterpreter {
       case "<":
         return this.evalLoopLike(tag);
       case "#":
-        return this.evalWhileLoop();
+        return this.evalWhileLike();
       default:
         throw new Error(`Unexpected tag '${tag}' at ${this.pos}`);
     }
@@ -2890,15 +3037,11 @@ class CursorInterpreter {
         return entries.map(([key]) => ({ key, value: key }));
       return entries.map(([key, value]) => ({ key, value }));
     }
-    if (typeof iterable === "number" && Number.isFinite(iterable) && iterable > 0) {
-      const out = [];
-      for (let index = 0;index < Math.floor(iterable); index += 1) {
-        if (keysOnly)
-          out.push({ key: index, value: index });
-        else
-          out.push({ key: index, value: index + 1 });
-      }
-      return out;
+    if (typeof iterable === "string") {
+      const entries = Array.from(iterable);
+      if (keysOnly)
+        return entries.map((_value, index) => ({ key: index, value: index }));
+      return entries.map((value, index) => ({ key: index, value }));
     }
     return [];
   }
@@ -2943,21 +3086,32 @@ class CursorInterpreter {
     }
     return last;
   }
-  evalWhileLoop() {
+  evalWhileLike() {
+    this.pos += 1;
+    const open = this.text[this.pos];
+    if (!open || !"([{".includes(open))
+      throw new Error(`Expected opener after '#' at ${this.pos}`);
+    const close = open === "(" ? ")" : open === "[" ? "]" : "}";
     this.pos += 1;
-    this.ensure("(");
     const condStart = this.pos;
     const condValue = this.evalValue();
     const bodyStart = this.pos;
-    const bodyValueCount = 1;
+    const bodyValueCount = open === "{" ? 2 : 1;
     let cursor = bodyStart;
     for (let index = 0;index < bodyValueCount; index += 1) {
       cursor = this.skipValueFrom(cursor);
     }
     const bodyEnd = cursor;
     this.pos = bodyEnd;
-    this.ensure(")");
+    this.ensure(close);
     const afterClose = this.pos;
+    if (open === "[")
+      return this.evalWhileArrayComprehension(condStart, bodyStart, bodyEnd, afterClose, condValue);
+    if (open === "{")
+      return this.evalWhileObjectComprehension(condStart, bodyStart, bodyEnd, afterClose, condValue);
+    return this.evalWhileLoop(condStart, bodyStart, bodyEnd, afterClose, condValue);
+  }
+  evalWhileLoop(condStart, bodyStart, bodyEnd, afterClose, condValue) {
     let last = undefined;
     let currentCond = condValue;
     while (isDefined(currentCond)) {
@@ -2978,6 +3132,58 @@ class CursorInterpreter {
     this.pos = afterClose;
     return last;
   }
+  evalWhileArrayComprehension(condStart, bodyStart, bodyEnd, afterClose, condValue) {
+    const out = [];
+    let currentCond = condValue;
+    while (isDefined(currentCond)) {
+      this.tick();
+      this.selfStack.push(currentCond);
+      const value = this.evalBodySlice(bodyStart, bodyEnd);
+      this.selfStack.pop();
+      const control = this.handleLoopControl(value);
+      if (control) {
+        if (control.depth > 1)
+          return { kind: control.kind, depth: control.depth - 1 };
+        if (control.kind === "break")
+          break;
+        currentCond = this.evalBodySlice(condStart, bodyStart);
+        continue;
+      }
+      if (isDefined(value))
+        out.push(value);
+      currentCond = this.evalBodySlice(condStart, bodyStart);
+    }
+    this.pos = afterClose;
+    return out;
+  }
+  evalWhileObjectComprehension(condStart, bodyStart, bodyEnd, afterClose, condValue) {
+    const result = {};
+    let currentCond = condValue;
+    while (isDefined(currentCond)) {
+      this.tick();
+      this.selfStack.push(currentCond);
+      const save = this.pos;
+      this.pos = bodyStart;
+      const key = this.evalValue();
+      const value = this.evalValue();
+      this.pos = save;
+      this.selfStack.pop();
+      const control = this.handleLoopControl(value);
+      if (control) {
+        if (control.depth > 1)
+          return { kind: control.kind, depth: control.depth - 1 };
+        if (control.kind === "break")
+          break;
+        currentCond = this.evalBodySlice(condStart, bodyStart);
+        continue;
+      }
+      if (isDefined(value))
+        result[String(key)] = value;
+      currentCond = this.evalBodySlice(condStart, bodyStart);
+    }
+    this.pos = afterClose;
+    return result;
+  }
   evalArrayComprehension(iterable, varA, varB, bodyStart, bodyEnd, keysOnly) {
     const items = this.iterate(iterable, keysOnly);
     const out = [];
@@ -3120,6 +3326,25 @@ class CursorInterpreter {
         return Array.isArray(args[0]) ? args[0] : undefined;
       case OPCODES.object:
         return args[0] && typeof args[0] === "object" && !Array.isArray(args[0]) ? args[0] : undefined;
+      case OPCODES.range: {
+        const from = Number(args[0]);
+        const to = Number(args[1]);
+        const step = to >= from ? 1 : -1;
+        const out = [];
+        for (let v = from;step > 0 ? v <= to : v >= to; v += step)
+          out.push(v);
+        return out;
+      }
+      case OPCODES.size: {
+        const target = args[0];
+        if (Array.isArray(target))
+          return target.length;
+        if (typeof target === "string")
+          return Array.from(target).length;
+        if (target && typeof target === "object")
+          return Object.keys(target).length;
+        return;
+      }
       default:
         throw new Error(`Unknown opcode ${id}`);
     }
@@ -3129,10 +3354,59 @@ class CursorInterpreter {
     for (const key of keys) {
       if (current === undefined || current === null)
         return;
-      current = current[String(key)];
+      current = this.readProperty(current, key);
+      if (current === undefined)
+        return;
     }
     return current;
   }
+  readProperty(target, key) {
+    const index = this.parseIndexKey(key);
+    if (Array.isArray(target)) {
+      if (index === undefined)
+        return;
+      return target[index];
+    }
+    if (typeof target === "string") {
+      if (index === undefined)
+        return;
+      return Array.from(target)[index];
+    }
+    if (this.isPlainObject(target)) {
+      const prop = String(key);
+      if (!Object.prototype.hasOwnProperty.call(target, prop))
+        return;
+      return target[prop];
+    }
+    return;
+  }
+  canWriteProperty(target, key) {
+    const index = this.parseIndexKey(key);
+    if (Array.isArray(target)) {
+      if (index === undefined)
+        return;
+      return { kind: "array", index };
+    }
+    if (this.isPlainObject(target))
+      return { kind: "object" };
+    return;
+  }
+  parseIndexKey(key) {
+    if (typeof key === "number" && Number.isInteger(key) && key >= 0)
+      return key;
+    if (typeof key !== "string" || key.length === 0)
+      return;
+    if (!/^(0|[1-9]\d*)$/.test(key))
+      return;
+    const index = Number(key);
+    return Number.isSafeInteger(index) ? index : undefined;
+  }
+  isPlainObject(value) {
+    if (!value || typeof value !== "object")
+      return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+  }
   readPlace() {
     this.skipNonCode();
     const direct = this.readRootVarOrRefIfPresent();
@@ -3187,13 +3461,13 @@ class CursorInterpreter {
     }
     this.pos += 1;
     return {
-      root: tag === "$" ? prefix.raw : prefix.value,
+      root: prefix.raw,
       isRef: tag === "'"
     };
   }
   writePlace(place, value) {
     const rootTable = place.isRef ? this.state.refs : this.state.vars;
-    const rootKey = String(place.root);
+    const rootKey = place.root;
     if (place.keys.length === 0) {
       rootTable[rootKey] = value;
       return;
@@ -3204,17 +3478,48 @@ class CursorInterpreter {
       rootTable[rootKey] = target;
     }
     for (let index = 0;index < place.keys.length - 1; index += 1) {
-      const key = String(place.keys[index]);
-      const next = target[key];
+      const key = place.keys[index];
+      const access2 = this.canWriteProperty(target, key);
+      if (!access2)
+        return;
+      if (access2.kind === "array") {
+        const next2 = target[access2.index];
+        if (!next2 || typeof next2 !== "object")
+          target[access2.index] = {};
+        target = target[access2.index];
+        continue;
+      }
+      const prop = String(key);
+      const next = target[prop];
       if (!next || typeof next !== "object")
-        target[key] = {};
-      target = target[key];
+        target[prop] = {};
+      target = target[prop];
     }
-    target[String(place.keys[place.keys.length - 1])] = value;
+    const lastKey = place.keys[place.keys.length - 1];
+    const access = this.canWriteProperty(target, lastKey);
+    if (!access)
+      return;
+    if (access.kind === "array") {
+      target[access.index] = value;
+      return;
+    }
+    target[String(lastKey)] = value;
+  }
+  readPlaceValue(place) {
+    const rootTable = place.isRef ? this.state.refs : this.state.vars;
+    let current = rootTable[place.root];
+    for (const key of place.keys) {
+      if (current === undefined || current === null)
+        return;
+      current = this.readProperty(current, key);
+      if (current === undefined)
+        return;
+    }
+    return current;
   }
   deletePlace(place) {
     const rootTable = place.isRef ? this.state.refs : this.state.vars;
-    const rootKey = String(place.root);
+    const rootKey = place.root;
     if (place.keys.length === 0) {
       delete rootTable[rootKey];
       return;
@@ -3223,11 +3528,29 @@ class CursorInterpreter {
     if (!target || typeof target !== "object")
       return;
     for (let index = 0;index < place.keys.length - 1; index += 1) {
-      target = target[String(place.keys[index])];
+      const key = place.keys[index];
+      const access2 = this.canWriteProperty(target, key);
+      if (!access2)
+        return;
+      if (access2.kind === "array") {
+        target = target[access2.index];
+        if (!target || typeof target !== "object")
+          return;
+        continue;
+      }
+      target = target[String(key)];
       if (!target || typeof target !== "object")
         return;
     }
-    delete target[String(place.keys[place.keys.length - 1])];
+    const lastKey = place.keys[place.keys.length - 1];
+    const access = this.canWriteProperty(target, lastKey);
+    if (!access)
+      return;
+    if (access.kind === "array") {
+      delete target[access.index];
+      return;
+    }
+    delete target[String(lastKey)];
   }
   skipValue() {
     this.pos = this.skipValueFrom(this.pos);
@@ -3243,12 +3566,12 @@ class CursorInterpreter {
       return startPos;
     }
     if (tag === ",") {
-      this.pos += 1 + prefix.value;
+      this.pos = this.advanceByBytes(this.pos + 1, prefix.value);
       const end2 = this.pos;
       this.pos = save;
       return end2;
     }
-    if (tag === "=") {
+    if (tag === "=" || tag === "/") {
       this.pos += 1;
       this.skipValue();
       this.skipValue();
@@ -3283,7 +3606,8 @@ class CursorInterpreter {
     if (opener && "([{".includes(opener)) {
       const close = opener === "(" ? ")" : opener === "[" ? "]" : "}";
       if (prefix.value > 0) {
-        this.pos += 1 + prefix.value + 1;
+        const bodyEnd = this.advanceByBytes(this.pos + 1, prefix.value);
+        this.pos = bodyEnd + 1;
         const end3 = this.pos;
         this.pos = save;
         return end3;
@@ -3327,7 +3651,7 @@ var C = {
   gray: "\x1B[90m",
   boldBlue: "\x1B[1;34m"
 };
-var TOKEN_RE = /(?<blockComment>\/\*[\s\S]*?(?:\*\/|$))|(?<lineComment>\/\/[^\n]*)|(?<dstring>"(?:[^"\\]|\\.)*"?)|(?<sstring>'(?:[^'\\]|\\.)*'?)|(?<keyword>\b(?:when|unless|while|for|do|end|in|of|and|or|else|break|continue|delete|self)(?![a-zA-Z0-9_-]))|(?<literal>\b(?:true|false|null|undefined|nan)(?![a-zA-Z0-9_-])|-?\binf\b)|(?<typePred>\b(?:string|number|object|array|boolean)(?![a-zA-Z0-9_-]))|(?<num>\b(?:0x[0-9a-fA-F]+|0b[01]+|(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)\b)/g;
+var TOKEN_RE = /(?<blockComment>\/\*[\s\S]*?(?:\*\/|$))|(?<lineComment>\/\/[^\n]*)|(?<dstring>"(?:[^"\\]|\\.)*"?)|(?<sstring>'(?:[^'\\]|\\.)*'?)|(?<keyword>\b(?:when|unless|while|for|do|end|in|of|and|or|nor|else|break|continue|delete|self)(?![a-zA-Z0-9_-]))|(?<literal>\b(?:true|false|null|undefined|nan)(?![a-zA-Z0-9_-])|-?\binf\b)|(?<typePred>\b(?:string|number|object|array|boolean)(?![a-zA-Z0-9_-]))|(?<num>\b(?:0x[0-9a-fA-F]+|0b[01]+|(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)\b)/g;
 function highlightLine(line) {
   let result = "";
   let lastIndex = 0;
@@ -3436,6 +3760,7 @@ function highlightRexc(text) {
         break;
       }
       case "=":
+      case "/":
       case "~":
         out += C.red + prefix + tag + C.reset;
         i++;
@@ -3539,7 +3864,7 @@ function isIncomplete(buffer) {
   const trimmed = buffer.trimEnd();
   if (/[+\-*/%&|^=<>]$/.test(trimmed))
     return true;
-  if (/\b(?:and|or|do|in|of)\s*$/.test(trimmed))
+  if (/\b(?:and|or|nor|do|in|of)\s*$/.test(trimmed))
     return true;
   return false;
 }
@@ -3591,6 +3916,7 @@ var KEYWORDS = [
   "of",
   "and",
   "or",
+  "nor",
   "else",
   "break",
   "continue",