@creationix/rex 0.1.4 → 0.3.1

package/rex.js

@@ -33,38 +33,8 @@ var OPCODE_IDS = {
   mod: 20,
   neg: 21
 };
-var registeredDomainRefs = {};
-function registerDomainExtensionRef(name, refId = 0) {
-  if (!name)
-    throw new Error("Domain extension name cannot be empty");
-  if (!Number.isInteger(refId) || refId < 0)
-    throw new Error(`Invalid domain extension ref id for '${name}': ${refId}`);
-  registeredDomainRefs[name] = refId;
-}
-function registerDomainExtensionRefs(refs) {
-  for (const [name, refId] of Object.entries(refs)) {
-    registerDomainExtensionRef(name, refId);
-  }
-}
-function clearDomainExtensionRefs() {
-  for (const name of Object.keys(registeredDomainRefs))
-    delete registeredDomainRefs[name];
-}
-function getRegisteredDomainExtensionRefs() {
-  return { ...registeredDomainRefs };
-}
-function resolveDomainRefMap(overrides) {
-  if (!overrides || Object.keys(overrides).length === 0) {
-    return Object.keys(registeredDomainRefs).length > 0 ? { ...registeredDomainRefs } : undefined;
-  }
-  const merged = { ...registeredDomainRefs };
-  for (const [name, refId] of Object.entries(overrides)) {
-    if (!Number.isInteger(refId) || refId < 0)
-      throw new Error(`Invalid domain extension ref id for '${name}': ${refId}`);
-    merged[name] = refId;
-  }
-  return merged;
-}
+var FIRST_NON_RESERVED_REF = 8;
+var DOMAIN_DIGIT_INDEX = new Map(Array.from(DIGITS).map((char, index) => [char, index]));
 var BINARY_TO_OPCODE = {
   add: "add",
   sub: "sub",
@@ -177,12 +147,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 "5'";
+  if (numberValue === Infinity)
+    return "6'";
+  if (numberValue === -Infinity)
+    return "7'";
+  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;
@@ -205,7 +196,7 @@ function encodeNumberNode(node) {
     significand /= 10;
     power += 1;
   }
-  return `${encodeZigzag(power)}*${encodeInt(significand)}`;
+  return encodeDecimal(significand, power);
 }
 function encodeOpcode(opcode) {
   return `${encodeUint(OPCODE_IDS[opcode])}%`;
@@ -217,13 +208,13 @@ function needsOptionalPrefix(encoded) {
   const first = encoded[0];
   if (!first)
     return false;
-  return first === "[" || first === "{" || first === "(" || first === "=" || first === "~" || first === "?" || first === "!" || first === "|" || first === "&" || first === ">" || first === "<";
+  return first === "[" || first === "{" || first === "(" || first === "=" || first === "~" || first === "?" || first === "!" || first === "|" || first === "&" || first === ">" || first === "<" || first === "#";
 }
 function addOptionalPrefix(encoded) {
   if (!needsOptionalPrefix(encoded))
     return encoded;
   let payload = encoded;
-  if (encoded.startsWith("?(") || encoded.startsWith("!(") || encoded.startsWith("|(") || encoded.startsWith("&(") || encoded.startsWith(">(") || encoded.startsWith("<(")) {
+  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(">{")) {
     payload = encoded.slice(2, -1);
@@ -254,6 +245,33 @@ function encodeConditionalElse(elseBranch) {
   return encodeNode(nested);
 }
 function encodeNavigation(node) {
+  const domainRefs = activeEncodeOptions?.domainRefs;
+  if (domainRefs && node.target.type === "identifier") {
+    const staticPath = [node.target.name];
+    for (const segment of node.segments) {
+      if (segment.type !== "static")
+        break;
+      staticPath.push(segment.key);
+    }
+    for (let pathLength = staticPath.length;pathLength >= 1; pathLength -= 1) {
+      const dottedName = staticPath.slice(0, pathLength).join(".");
+      const domainRef = domainRefs[dottedName];
+      if (domainRef === undefined)
+        continue;
+      const consumedStaticSegments = pathLength - 1;
+      if (consumedStaticSegments === node.segments.length) {
+        return `${encodeUint(domainRef)}'`;
+      }
+      const parts2 = [`${encodeUint(domainRef)}'`];
+      for (const segment of node.segments.slice(consumedStaticSegments)) {
+        if (segment.type === "static")
+          parts2.push(encodeBareOrLengthString(segment.key));
+        else
+          parts2.push(encodeNode(segment.key));
+      }
+      return encodeCallParts(parts2);
+    }
+  }
   const parts = [encodeNode(node.target)];
   for (const segment of node.segments) {
     if (segment.type === "static")
@@ -263,6 +281,11 @@ function encodeNavigation(node) {
   }
   return encodeCallParts(parts);
 }
+function encodeWhile(node) {
+  const cond = encodeNode(node.condition);
+  const body = addOptionalPrefix(encodeBlockExpression(node.body));
+  return `#(${cond}${body})`;
+}
 function encodeFor(node) {
   const body = addOptionalPrefix(encodeBlockExpression(node.body));
   if (node.binding.type === "binding:expr") {
@@ -399,6 +422,8 @@ function encodeNode(node) {
     }
     case "for":
       return encodeFor(node);
+    case "while":
+      return encodeWhile(node);
     case "break":
       return ";";
     case "continue":
@@ -473,6 +498,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);
 }
@@ -484,8 +521,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")
@@ -499,7 +540,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}`);
@@ -536,7 +577,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}`;
     });
@@ -550,6 +591,86 @@ ${indent}}`;
 function parse(source) {
   return parseDataNode(parseToIR(source));
 }
+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)`);
+    }
+  }
+  if (value < FIRST_NON_RESERVED_REF) {
+    throw new Error(`Invalid domain ref key '${refText}' (maps to reserved id ${value})`);
+  }
+  return value;
+}
+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)) {
+    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}`);
+      }
+      refs[rawName] = refId;
+      const root = rawName.split(".")[0];
+      if (!root)
+        continue;
+      const currentKind = rawName.includes(".") ? "implicit" : "explicit";
+      const existing = refs[root];
+      if (existing !== undefined) {
+        if (existing === refId)
+          continue;
+        const existingKind = sourceKindByRoot.get(root) ?? "explicit";
+        if (currentKind === "explicit") {
+          throw new Error(`Conflicting refs for '${root}': ${existing} vs ${refId}`);
+        }
+        if (existingKind === "explicit")
+          continue;
+        continue;
+      }
+      refs[root] = refId;
+      sourceKindByRoot.set(root, currentKind);
+    }
+  }
+}
 function stringify(value, options) {
   const indent = options?.indent ?? 2;
   const maxWidth = options?.maxWidth ?? 80;
@@ -1116,7 +1237,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) };
@@ -1128,7 +1258,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);
@@ -1440,12 +1570,12 @@ function optimizeNode(node, env, currentDepth, asPlace = false) {
       if (conditionValue !== undefined || condition.type === "undefined") {
         const passes = node.head === "when" ? isDefinedValue(conditionValue) : !isDefinedValue(conditionValue);
         if (passes) {
-          const thenBlock = optimizeBlock(node.thenBlock, thenEnv, currentDepth);
-          if (thenBlock.length === 0)
+          const thenBlock2 = optimizeBlock(node.thenBlock, thenEnv, currentDepth);
+          if (thenBlock2.length === 0)
             return { type: "undefined" };
-          if (thenBlock.length === 1)
-            return thenBlock[0];
-          return { type: "program", body: thenBlock };
+          if (thenBlock2.length === 1)
+            return thenBlock2[0];
+          return { type: "program", body: thenBlock2 };
         }
         if (!node.elseBranch)
           return { type: "undefined" };
@@ -1467,12 +1597,26 @@ function optimizeNode(node, env, currentDepth, asPlace = false) {
           elseBranch: loweredElse.elseBranch
         };
       }
+      const thenBlock = optimizeBlock(node.thenBlock, thenEnv, currentDepth);
+      const elseBranch = optimizeElse(node.elseBranch, cloneOptimizeEnv(env), currentDepth);
+      let finalCondition = condition;
+      if (condition.type === "assign" && condition.op === "=" && condition.place.type === "identifier") {
+        const name = condition.place.name;
+        const reads = new Set;
+        for (const part of thenBlock)
+          collectReads(part, reads);
+        if (elseBranch)
+          collectReadsElse(elseBranch, reads);
+        if (!reads.has(name)) {
+          finalCondition = condition.value;
+        }
+      }
       return {
         type: "conditional",
         head: node.head,
-        condition,
-        thenBlock: optimizeBlock(node.thenBlock, thenEnv, currentDepth),
-        elseBranch: optimizeElse(node.elseBranch, cloneOptimizeEnv(env), currentDepth)
+        condition: finalCondition,
+        thenBlock,
+        elseBranch
       };
     }
     case "for": {
@@ -1927,13 +2071,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;
   return encodeIR(lowered, {
-    domainRefs: resolveDomainRefMap(options?.domainRefs),
+    domainRefs,
     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)) {
@@ -2158,6 +2309,13 @@ semantics.addOperation("toIR", {
       return body[0];
     return { type: "program", body };
   },
+  WhileExpr(_while, condition, _do, block, _end) {
+    return {
+      type: "while",
+      condition: condition.toIR(),
+      body: block.toIR()
+    };
+  },
   ForExpr(_for, binding, _do, block, _end) {
     return {
       type: "for",
@@ -2304,16 +2462,13 @@ var rex_default = semantics;
 export {
   stringify,
   semantics,
-  registerDomainExtensionRefs,
-  registerDomainExtensionRef,
   parseToIR,
   parse,
   optimizeIR,
   minifyLocalNamesIR,
   grammar,
-  getRegisteredDomainExtensionRefs,
   encodeIR,
+  domainRefsFromConfig,
   rex_default as default,
-  compile,
-  clearDomainExtensionRefs
+  compile
 };

package/rex.ohm

@@ -38,7 +38,7 @@ Rex {
     | UnaryExpr                      -- value
 
   UnaryExpr
-    = "-" ~digit UnaryExpr           -- neg
+    = "-" ~digit ~infTok UnaryExpr    -- neg
     | "~" UnaryExpr                  -- not
     | DeleteKw Place                 -- delete
     | PostfixExpr                    -- value
@@ -47,7 +47,7 @@ Rex {
     = PrimaryExpr PostfixTail*       -- chain
 
   PostfixTail
-    = "." keyName                    -- navStatic
+    = "." navKey                     -- navStatic
     | ".(" Expr ")"                 -- navDynamic
     | "(" ")"                      -- callEmpty
     | "(" Elements<Expr> ")"        -- call
@@ -56,6 +56,7 @@ Rex {
     = ConditionalExpr
     | DoExpr
     | ForExpr
+    | WhileExpr
     | BreakKw                        -- break
     | ContinueKw                     -- continue
     | Array
@@ -87,7 +88,7 @@ Rex {
     | SelfKw
 
   PlaceTail
-    = "." keyName                    -- navStatic
+    = "." navKey                     -- navStatic
     | ".(" Expr ")"                 -- navDynamic
 
   ConditionalExpr
@@ -104,6 +105,9 @@ Rex {
   ForExpr
     = ForKw BindingExpr DoKw Block EndKw
 
+  WhileExpr
+    = WhileKw Expr DoKw Block EndKw
+
   DoExpr
     = DoKw Block EndKw
 
@@ -138,6 +142,10 @@ Rex {
     | String                         -- string
     | "(" Expr ")"                  -- computed
 
+  navKey
+    = keyName
+    | digit+
+
   keyName
     = nameHead nameTail*
 
@@ -181,10 +189,13 @@ Rex {
     | falseTok
     | nullTok
     | undefinedTok
+    | nanTok
+    | infTok
     | selfTok
     | whenTok
     | unlessTok
     | forTok
+    | whileTok
     | inTok
     | ofTok
     | doTok
@@ -222,6 +233,9 @@ Rex {
   UnlessKw
     = unlessTok
 
+  WhileKw
+    = whileTok
+
   ForKw
     = forTok
 
@@ -276,6 +290,12 @@ Rex {
   undefinedTok
     = "undefined" ~nameTail
 
+  nanTok
+    = "nan" ~nameTail
+
+  infTok
+    = "inf" ~nameTail
+
   selfTok
     = "self" ~nameTail
 
@@ -285,6 +305,9 @@ Rex {
   unlessTok
     = "unless" ~nameTail
 
+  whileTok
+    = "while" ~nameTail
+
   forTok
     = "for" ~nameTail
 
@@ -371,8 +394,16 @@ Rex {
   Number
     = hexNumber
     | binaryNumber
+    | infLiteral
+    | nanLiteral
     | decimalNumber
 
+  infLiteral
+    = "-"? infTok
+
+  nanLiteral
+    = nanTok
+
   hexNumber
     = "-"? "0x" hex+