solve-engine 1.0.0-beta.7 → 1.0.1

package/dist/{chunk-GVWHCL2N.js → chunk-HMOISHXR.js}

@@ -1,19 +1,19 @@
-import { BindingPower, BytecodeBuilder } from './chunk-6GCKCWLB.js';
-import { createFusedToken, isInsideRangeContext } from './chunk-OFXOTECC.js';
-import { stripQuotes } from './chunk-PFSDGGYL.js';
-import { CurrencyAsyncResolver, nextInstruction } from './chunk-YU2CUNFO.js';
+import { BindingPower, BytecodeBuilder, bigIntLiteralDigits } from './chunk-526PMQOA.js';
+import { createFusedToken, isInsideRangeContext } from './chunk-YPPPYLSR.js';
+import { stripQuotes } from './chunk-3BOK2LDK.js';
+import { CurrencyAsyncResolver, nextInstruction } from './chunk-KV7UW6T6.js';
 import { getActiveQueryClient } from './chunk-NLNDMWZC.js';
-import { allocatePluginFunctionIndex, sharedGlobalVariableStore, adjustForInflation, CPI_MIN_YEAR, CPI_MAX_YEAR } from './chunk-MVBEL57Q.js';
+import { allocatePluginFunctionIndex, sharedGlobalVariableStore, adjustForInflation, CPI_MIN_YEAR, CPI_MAX_YEAR } from './chunk-Y7FT4IQT.js';
 import { createTimeoutSignal } from './chunk-Z4X2RWOF.js';
-import { resolveCurrencyAlias } from './chunk-CYFK5SY2.js';
-import { errorValue, numberValue, stringValue, boolValue, uomValue, datetimeValue, timecodeUnit, ValueType } from './chunk-BVAR5J2F.js';
-import { getMeasure, convertUnit } from './chunk-WC5FFSHB.js';
-import { LexerToken } from './chunk-SFQWJMKT.js';
-import { tokenTypeId } from './chunk-GPPLSM2Z.js';
+import { resolveCurrencyAlias } from './chunk-O3ANBHSA.js';
+import { errorValue, numberValue, stringValue, boolValue, uomValue, datetimeValue, timecodeUnit, ValueType } from './chunk-GQCOSXMG.js';
+import { getMeasure, convertUnit } from './chunk-R3PY4G7J.js';
+import { LexerToken } from './chunk-QY25VWBF.js';
+import { tokenTypeId } from './chunk-VB37OC6I.js';
 import { getLocale } from './chunk-XBTEO4OB.js';
-import { isKnownUnit } from './chunk-M5E34VG5.js';
-import { UNIT_TABLE } from './chunk-PCPX42KL.js';
-import { ErrorFactory } from './chunk-6RDSQURE.js';
+import { isKnownUnit } from './chunk-SBUFNJVE.js';
+import { UNIT_TABLE } from './chunk-V4XG5QF6.js';
+import { ErrorFactory } from './chunk-3D7V24DG.js';
 
 // src/packages/arithmetic/parselets/NumberParselet.ts
 var CHAINED_DOT_THOUSANDS_GROUPS = /^\d{1,3}(\.\d{3}){2,}$/;
@@ -73,13 +73,14 @@ var PrefixOpParselet = class {
 
 // src/packages/arithmetic/parselets/BinaryOpParselet.ts
 var BinaryOpParselet = class {
-  constructor(bp, opcode) {
+  constructor(bp, opcode, rightAssociative = false) {
     this.opcode = opcode;
     this.category = "Arithmetic";
     this.bindingPower = bp;
+    this.rightBindingPower = rightAssociative ? bp - 1 : bp;
   }
   parse(parser, left, token, builder) {
-    parser.parseExpression(this.bindingPower, builder);
+    parser.parseExpression(this.rightBindingPower, builder);
     builder.emitOpcode(this.opcode);
   }
 };
@@ -162,7 +163,8 @@ function largeNumberSuffixNormalizerRule(priority = 65) {
       if (!suffixToken) return null;
       if (suffixToken.type !== "IDENT" && suffixToken.type !== "UNIT") return null;
       const adjacent = numberToken.offset + numberToken.text.length === suffixToken.offset;
-      const magnitude = adjacent ? SUFFIX_MAGNITUDE[suffixToken.value] ?? WORD_MAGNITUDE[suffixToken.value.toLowerCase()] : WORD_MAGNITUDE[suffixToken.value.toLowerCase()];
+      const wordMagnitude = suffixToken.type === "UNIT" ? void 0 : WORD_MAGNITUDE[suffixToken.value.toLowerCase()];
+      const magnitude = adjacent ? SUFFIX_MAGNITUDE[suffixToken.value] ?? wordMagnitude : wordMagnitude;
       if (magnitude === void 0) return null;
       const scaled = scaleDecimalString(numberToken.text, magnitude);
       return {
@@ -199,15 +201,25 @@ var ARITHMETIC_PACKAGE = {
     { tokenType: "STAR", parselet: new BinaryOpParselet(BindingPower.Product, 22 /* MUL */) },
     { tokenType: "SLASH", parselet: new BinaryOpParselet(BindingPower.Product, 23 /* DIV */) },
     { tokenType: "MOD", parselet: new BinaryOpParselet(BindingPower.Product, 24 /* MOD */) },
-    { tokenType: "CARET", parselet: new BinaryOpParselet(BindingPower.Exponent, 25 /* EXP */) },
+    // `^` is right-associative, so "2 ^ 3 ^ 2" is 2^(3^2) = 512. The Tier 1
+    // fast path in PrecedenceParser is what actually runs for `^`; this
+    // registration has to agree with it or the two tiers describe different
+    // languages.
+    { tokenType: "CARET", parselet: new BinaryOpParselet(BindingPower.Exponent, 25 /* EXP */, true) },
     { tokenType: "TIMES_BY", parselet: new BinaryOpParselet(BindingPower.Product, 22 /* MUL */) },
     { tokenType: "MULTIPLY_BY", parselet: new BinaryOpParselet(BindingPower.Product, 22 /* MUL */) },
     { tokenType: "DIVIDE_BY", parselet: new BinaryOpParselet(BindingPower.Product, 23 /* DIV */) },
-    { tokenType: "LSHIFT", parselet: new BinaryOpParselet(BindingPower.Sum, 30 /* LSHIFT */) },
-    { tokenType: "RSHIFT", parselet: new BinaryOpParselet(BindingPower.Sum, 31 /* RSHIFT */) },
-    { tokenType: "URSHIFT", parselet: new BinaryOpParselet(BindingPower.Sum, 32 /* URSHIFT */) },
-    { tokenType: "BIT_AND", parselet: new BinaryOpParselet(BindingPower.Product, 33 /* BIT_AND */) },
-    { tokenType: "BIT_OR", parselet: new BinaryOpParselet(BindingPower.Sum, 34 /* BIT_OR */) },
+    // The shifts and the bitwise trio, at the levels BindingPower gives them
+    // and therefore at C and JavaScript precedence. These six are declared
+    // twice, here and in BUILTIN_INFIX_BP, and only the Tier 1 numbers are
+    // ever read, so the levels must be the SAME names in both places. When
+    // they were not, the four that had a fast-path entry ran at one level
+    // while `>>>`, which had none, ran at another.
+    { tokenType: "LSHIFT", parselet: new BinaryOpParselet(BindingPower.Shift, 30 /* LSHIFT */) },
+    { tokenType: "RSHIFT", parselet: new BinaryOpParselet(BindingPower.Shift, 31 /* RSHIFT */) },
+    { tokenType: "URSHIFT", parselet: new BinaryOpParselet(BindingPower.Shift, 32 /* URSHIFT */) },
+    { tokenType: "BIT_AND", parselet: new BinaryOpParselet(BindingPower.BitwiseAnd, 33 /* BIT_AND */) },
+    { tokenType: "BIT_OR", parselet: new BinaryOpParselet(BindingPower.BitwiseOr, 34 /* BIT_OR */) },
     { tokenType: "BIT_XOR", parselet: new BinaryOpParselet(BindingPower.BitwiseXor, 35 /* BIT_XOR */) }
   ],
   normalizerRules: [largeNumberSuffixNormalizerRule()]
@@ -677,13 +689,16 @@ var FUNCTION_PACKAGE = {
 var NowParselet = class {
   constructor(dayOffset = 0) {
     this.category = "Date/Time";
-    this.msOffset = dayOffset * 24 * 60 * 60 * 1e3;
+    this.dayOffset = dayOffset;
   }
   parse(parser, token, builder) {
     builder.emitOpcode(90 /* DATE_NOW */);
-    if (this.msOffset !== 0) {
+    if (this.dayOffset !== 0) {
       builder.emitOpcode(10 /* PUSH_NUMBER */);
-      builder.emitNumber(this.msOffset);
+      builder.emitNumber(this.dayOffset);
+      builder.emitOpcode(13 /* PUSH_STRING */);
+      builder.emitString("days");
+      builder.emitOpcode(80 /* UOM_CONVERT */);
       builder.emitOpcode(20 /* ADD */);
     }
   }
@@ -801,9 +816,11 @@ function workdaysInDurationHandler(args) {
   } else {
     totalDays = v.toNumber();
   }
-  const fullWeeks = Math.floor(totalDays / 7);
-  const remainderDays = totalDays - fullWeeks * 7;
-  const workdays = fullWeeks * 5 + Math.min(remainderDays, 5);
+  const sign = totalDays < 0 ? -1 : 1;
+  const magnitudeDays = Math.abs(totalDays);
+  const fullWeeks = Math.floor(magnitudeDays / 7);
+  const remainderDays = magnitudeDays - fullWeeks * 7;
+  const workdays = sign * (fullWeeks * 5 + Math.min(remainderDays, 5));
   return numberValue(workdays);
 }
 var WEEKDAY_NAMES = [
@@ -1125,6 +1142,15 @@ var DATETIME_LITERAL_TYPE_ID = tokenTypeId(DATETIME_LITERAL_TYPE);
 var PLAIN_INTEGER = /^\d+$/;
 var DOT_DAY_MONTH = /^\d{1,2}\.\d{1,2}$/;
 var DOT_LEADING_YEAR = /^\.(\d{2}|\d{4})$/;
+var DAY_OR_MONTH = /^\d{1,2}$/;
+function writtenAsOneRun(tokens) {
+  for (let i = 0; i < tokens.length - 1; i++) {
+    const token = tokens[i];
+    const end = token.sourceEnd ?? token.offset + token.text.length;
+    if (end !== tokens[i + 1].offset) return false;
+  }
+  return true;
+}
 function resolveYear(digits) {
   if (digits.length === 4) return Number(digits);
   if (digits.length === 2) {
@@ -1153,6 +1179,48 @@ function buildDateToken(day, month, year, sourceTokens, ruleName) {
   );
   return { consumed: sourceTokens.length, replacement: [fusedToken], ruleName };
 }
+var ISO_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?/;
+var ISO_TOKEN_TYPES = /* @__PURE__ */ new Set(["NUMBER", "MINUS", "PLUS", "COLON", "IDENT"]);
+var ISO_MAX_TOKENS = 16;
+function fuseIsoTimestamp(tokens, pos, ruleName) {
+  const first = tokens[pos];
+  if (first.sourceEnd !== void 0) return null;
+  let text = first.text;
+  let runEnd = first.offset + first.text.length;
+  const window = [first];
+  for (let i = pos + 1; i < tokens.length && window.length < ISO_MAX_TOKENS; i++) {
+    const next = tokens[i];
+    if (next.sourceEnd !== void 0) break;
+    if (next.offset !== runEnd || !ISO_TOKEN_TYPES.has(next.type)) break;
+    text += next.text;
+    runEnd = next.offset + next.text.length;
+    window.push(next);
+  }
+  const matched = ISO_TIMESTAMP.exec(text);
+  if (matched === null) return null;
+  let consumed = 0;
+  let covered = 0;
+  for (const token of window) {
+    covered += token.text.length;
+    consumed++;
+    if (covered >= matched[0].length) break;
+  }
+  if (covered !== matched[0].length) return null;
+  const epochMs = parseIso8601(matched[0]);
+  if (epochMs === null) return null;
+  const fusedToken = new LexerToken(
+    DATETIME_LITERAL_TYPE,
+    DATETIME_LITERAL_TYPE_ID,
+    String(epochMs),
+    matched[0],
+    first.offset,
+    0,
+    first.line,
+    first.col,
+    first.offset + matched[0].length
+  );
+  return { consumed, replacement: [fusedToken], ruleName };
+}
 function dateLiteralNormalizerRule() {
   return {
     name: "datetime:date-literal",
@@ -1178,6 +1246,10 @@ function dateLiteralNormalizerRule() {
         }
         return null;
       }
+      if (t0.value.length === 4 && PLAIN_INTEGER.test(t0.value)) {
+        const timestamp = fuseIsoTimestamp(tokens, pos, "datetime:date-literal:iso-timestamp");
+        if (timestamp) return timestamp;
+      }
       if (!PLAIN_INTEGER.test(t0.value)) return null;
       const sep1 = tokens[pos + 1];
       if (!sep1 || sep1.type !== "SLASH" && sep1.type !== "MINUS") return null;
@@ -1188,14 +1260,18 @@ function dateLiteralNormalizerRule() {
       if (!sep2 || sep2.type !== sep1.type) return null;
       if (!t2 || t2.type !== "NUMBER" || !PLAIN_INTEGER.test(t2.value)) return null;
       const sourceTokens = [t0, sep1, t1, sep2, t2];
+      if (!writtenAsOneRun(sourceTokens)) return null;
       if (sep1.type === "SLASH") {
+        if (!DAY_OR_MONTH.test(t0.value) || !DAY_OR_MONTH.test(t1.value)) return null;
         const year2 = resolveYear(t2.value);
         if (year2 === null) return null;
         return buildDateToken(Number(t0.value), Number(t1.value), year2, sourceTokens, "datetime:date-literal:european");
       }
       if (t0.value.length === 4) {
+        if (!DAY_OR_MONTH.test(t1.value) || !DAY_OR_MONTH.test(t2.value)) return null;
         return buildDateToken(Number(t2.value), Number(t1.value), Number(t0.value), sourceTokens, "datetime:date-literal:iso");
       }
+      if (!DAY_OR_MONTH.test(t0.value) || !DAY_OR_MONTH.test(t1.value)) return null;
       const year = resolveYear(t2.value);
       if (year === null) return null;
       return buildDateToken(Number(t1.value), Number(t0.value), year, sourceTokens, "datetime:date-literal:us");
@@ -2054,14 +2130,14 @@ var VideoTimecodeParselet = class {
     }
     parser.consume();
     const fps = parseFloat(fpsToken.value);
-    const fpsWhole = Math.floor(fps);
+    const fpsWhole = Math.round(fps);
     if (frames >= fpsWhole) {
       throw ErrorFactory.parsing(
         "TIMECODE_FRAME_OUT_OF_RANGE",
         `Frame number ${frames} is out of range for ${fps} fps (must be 0-${fpsWhole - 1})`
       );
     }
-    const totalFrames = Math.round((hours * 3600 + minutes * 60 + seconds) * fps) + frames;
+    const totalFrames = (hours * 3600 + minutes * 60 + seconds) * fpsWhole + frames;
     let unit = timecodeUnit(fps);
     if (parser.peek()?.type === "IN") {
       parser.consume();
@@ -3309,6 +3385,27 @@ function ingredientNameNormalizerRule(priority = 68) {
   };
 }
 
+// src/packages/uom/normalizer/MultiWordUnitNormalizerRule.ts
+function multiWordUnitNormalizerRule(priority = 78) {
+  return {
+    name: "uom:multi-word-unit",
+    priority,
+    match(tokens, pos) {
+      const first = tokens[pos];
+      const second = tokens[pos + 1];
+      if (first?.type !== "UNIT" || second?.type !== "UNIT") return null;
+      if (first.offset + first.text.length + 1 !== second.offset) return null;
+      const spelling = `${first.value} ${second.value}`;
+      if (UNIT_TABLE[spelling] === void 0) return null;
+      return {
+        consumed: 2,
+        replacement: [createFusedToken("UNIT", spelling, tokens.slice(pos, pos + 2))],
+        ruleName: "uom:multi-word-unit"
+      };
+    }
+  };
+}
+
 // src/packages/uom/UomPackage.ts
 var UOM_PACKAGE = {
   name: "solve-uom",
@@ -3324,6 +3421,9 @@ var UOM_PACKAGE = {
     { tokenType: "INGREDIENT_NAME", parselet: new CookingConversionParselet() }
   ],
   normalizerRules: [
+    // Highest priority of the unit rules: a two-word spelling has to become one
+    // token before anything else reads the first word as a unit on its own.
+    multiWordUnitNormalizerRule(),
     uomPossibilitiesNormalizerRule(),
     compoundQuantityNormalizerRule(),
     twoUnitConversionNormalizerRule(),
@@ -3710,7 +3810,9 @@ var SumParselet = class {
     parser.consume("COMMA");
     parseCollectionExpr(parser, builder);
     parser.consume("RPAREN");
-    emitInvoke(builder, 158 /* REDUCE_INVOKE */, { kind: 0, program: bodyProgram }, ["acc", "x"], 0);
+    builder.emitOpcode(10 /* PUSH_NUMBER */);
+    builder.emitNumber(0);
+    emitInvoke(builder, 158 /* REDUCE_INVOKE */, { kind: 0, program: bodyProgram }, ["acc", "x"], 1);
   }
 };
 
@@ -3737,7 +3839,9 @@ var ProdParselet = class {
     parser.consume("COMMA");
     parseCollectionExpr(parser, builder);
     parser.consume("RPAREN");
-    emitInvoke(builder, 158 /* REDUCE_INVOKE */, { kind: 0, program: bodyProgram }, ["acc", "x"], 0);
+    builder.emitOpcode(10 /* PUSH_NUMBER */);
+    builder.emitNumber(1);
+    emitInvoke(builder, 158 /* REDUCE_INVOKE */, { kind: 0, program: bodyProgram }, ["acc", "x"], 1);
   }
 };
 
@@ -3837,6 +3941,42 @@ var FactorParselet = class {
   }
 };
 
+// src/packages/symbolic/parselets/VariableArgument.ts
+function readVariableName(parser, verb) {
+  const token = parser.peek();
+  if (!token || token.type !== "IDENT" && token.type !== "UNIT") {
+    throw ErrorFactory.parsing(
+      "SYMBOLIC_REQUIRES_VARIABLE_NAME",
+      `${verb} needs the name of an unknown here, as in ${verb}(x^2, x).`,
+      { found: token?.type ?? "end of input" }
+    );
+  }
+  parser.consume();
+  return token.value;
+}
+function emitVariableName(builder, name) {
+  builder.emitOpcode(13 /* PUSH_STRING */);
+  builder.emitString(name);
+}
+function parseBoundExpression(parser, builder, verb) {
+  const inner = new BytecodeBuilder();
+  parser.parseExpression(BindingPower.Lowest, inner);
+  parser.setBuilder(builder);
+  const program = inner.build();
+  if (program.hasAsync) {
+    throw ErrorFactory.parsing(
+      "SYMBOLIC_ARGUMENT_MUST_BE_SYNCHRONOUS",
+      `${verb}'s expression must be synchronous (no weather/stocks/currency calls).`
+    );
+  }
+  return program;
+}
+function emitBoundExpression(builder, program, name) {
+  const index = builder.emitAnonymousBody([name], program);
+  builder.emitOpcode(159 /* BIND_UNKNOWN */);
+  builder.emitIndex(index);
+}
+
 // src/packages/symbolic/parselets/SolveParselet.ts
 var SolveParselet = class {
   constructor() {
@@ -3844,13 +3984,8 @@ var SolveParselet = class {
   }
   parse(parser, _token, builder) {
     parser.consume("LPAREN");
-    parser.parseExpression(BindingPower.Lowest, builder);
-    if (parser.match("EQUALS")) {
-      parser.parseExpression(BindingPower.Lowest, builder);
-    } else {
-      builder.emitOpcode(10 /* PUSH_NUMBER */);
-      builder.emitNumber(0);
-    }
+    const left = parseBoundExpression(parser, builder, "solve");
+    const right = parser.match("EQUALS") ? parseBoundExpression(parser, builder, "solve") : null;
     parser.consume("COMMA");
     const variable = parser.peek();
     if (!variable || variable.type !== "IDENT" && variable.type !== "UNIT") {
@@ -3861,8 +3996,14 @@ var SolveParselet = class {
       );
     }
     parser.consume();
-    builder.emitOpcode(13 /* PUSH_STRING */);
-    builder.emitString(variable.value);
+    emitBoundExpression(builder, left, variable.value);
+    if (right) {
+      emitBoundExpression(builder, right, variable.value);
+    } else {
+      builder.emitOpcode(10 /* PUSH_NUMBER */);
+      builder.emitNumber(0);
+    }
+    emitVariableName(builder, variable.value);
     parser.consume("RPAREN");
     builder.emitOpcode(51 /* CALL_BUILTIN */);
     builder.emitIndex(SYMBOLIC_BUILTIN_SOLVE);
@@ -3870,21 +4011,6 @@ var SolveParselet = class {
   }
 };
 
-// src/packages/symbolic/parselets/VariableArgument.ts
-function consumeVariableName(parser, builder, verb) {
-  const token = parser.peek();
-  if (!token || token.type !== "IDENT" && token.type !== "UNIT") {
-    throw ErrorFactory.parsing(
-      "SYMBOLIC_REQUIRES_VARIABLE_NAME",
-      `${verb} needs the name of an unknown here, as in ${verb}(x^2, x).`,
-      { found: token?.type ?? "end of input" }
-    );
-  }
-  parser.consume();
-  builder.emitOpcode(13 /* PUSH_STRING */);
-  builder.emitString(token.value);
-}
-
 // src/packages/symbolic/parselets/DerParselet.ts
 var DerParselet = class {
   constructor() {
@@ -3892,9 +4018,11 @@ var DerParselet = class {
   }
   parse(parser, _token, builder) {
     parser.consume("LPAREN");
-    parser.parseExpression(BindingPower.Lowest, builder);
+    const expression = parseBoundExpression(parser, builder, "der");
     parser.consume("COMMA");
-    consumeVariableName(parser, builder, "der");
+    const variable = readVariableName(parser, "der");
+    emitBoundExpression(builder, expression, variable);
+    emitVariableName(builder, variable);
     if (parser.match("COMMA")) {
       parser.parseExpression(BindingPower.Lowest, builder);
     } else {
@@ -3915,9 +4043,11 @@ var IntegralParselet = class {
   }
   parse(parser, _token, builder) {
     parser.consume("LPAREN");
-    parser.parseExpression(BindingPower.Lowest, builder);
+    const expression = parseBoundExpression(parser, builder, "integral");
     parser.consume("COMMA");
-    consumeVariableName(parser, builder, "integral");
+    const variable = readVariableName(parser, "integral");
+    emitBoundExpression(builder, expression, variable);
+    emitVariableName(builder, variable);
     parser.consume("RPAREN");
     builder.emitOpcode(51 /* CALL_BUILTIN */);
     builder.emitIndex(SYMBOLIC_BUILTIN_INTEGRAL);
@@ -3932,9 +4062,11 @@ var TaylorParselet = class {
   }
   parse(parser, _token, builder) {
     parser.consume("LPAREN");
-    parser.parseExpression(BindingPower.Lowest, builder);
+    const expression = parseBoundExpression(parser, builder, "taylor");
     parser.consume("COMMA");
-    consumeVariableName(parser, builder, "taylor");
+    const variable = readVariableName(parser, "taylor");
+    emitBoundExpression(builder, expression, variable);
+    emitVariableName(builder, variable);
     parser.consume("EQUALS");
     parser.parseExpression(BindingPower.Lowest, builder);
     parser.consume("COMMA");
@@ -4267,10 +4399,8 @@ var BigIntNumberParselet = class {
     this.category = "BigInt";
   }
   parse(parser, token, builder) {
-    let raw = token.value;
-    if (raw.endsWith("n")) raw = raw.slice(0, -1);
     builder.emitOpcode(11 /* PUSH_BIGINT */);
-    builder.emitString(raw);
+    builder.emitString(bigIntLiteralDigits(token.value, parser.getLocaleCode()));
   }
 };
 
@@ -4456,6 +4586,7 @@ function emitRoundDirection(builder, direction) {
 var ROUND_BUILTIN = 8;
 var CEIL_BUILTIN = 6;
 var FLOOR_BUILTIN = 7;
+var ROUND_TO_PLACES_BUILTIN = 97;
 function readDirection(parser) {
   const next = parser.peek();
   const word = (next?.text ?? "").toLowerCase();
@@ -4523,14 +4654,11 @@ var DecimalPlacesParselet = class {
         `"to ${token.value} dp": expected a place count between 0 and 100`
       );
     }
-    const scale = Math.pow(10, places);
     builder.emitOpcode(10 /* PUSH_NUMBER */);
-    builder.emitNumber(scale);
-    builder.emitOpcode(22 /* MUL */);
-    emitRoundDirection(builder, "nearest");
-    builder.emitOpcode(10 /* PUSH_NUMBER */);
-    builder.emitNumber(scale);
-    builder.emitOpcode(23 /* DIV */);
+    builder.emitNumber(places);
+    builder.emitOpcode(51 /* CALL_BUILTIN */);
+    builder.emitIndex(ROUND_TO_PLACES_BUILTIN);
+    builder.emitIndex(2);
   }
 };
 
@@ -4569,6 +4697,7 @@ function decimalPlacesNormalizerRule(priority = 66) {
 }
 
 // src/packages/converters/normalizer/ConverterPrepositionNormalizerRule.ts
+var FUNC_TYPED_CONVERTERS = /* @__PURE__ */ new Set(["hex", "bin"]);
 function converterPrepositionNormalizerRule(priority = 67) {
   return {
     name: "converters:preposition",
@@ -4576,7 +4705,9 @@ function converterPrepositionNormalizerRule(priority = 67) {
     match(tokens, pos) {
       const preposition = tokens[pos];
       if (preposition?.type !== "IN" && preposition?.type !== "TO") return null;
-      if (tokens[pos + 1]?.type !== "CONVERTER_NAME") return null;
+      const target = tokens[pos + 1];
+      const isConverterTarget = target?.type === "CONVERTER_NAME" || target?.type === "FUNC" && FUNC_TYPED_CONVERTERS.has(target.value.toLowerCase());
+      if (!isConverterTarget) return null;
       return {
         consumed: 1,
         replacement: [createFusedToken("AS", "as", [preposition])],
@@ -5144,12 +5275,23 @@ function inflationFutureValueHandler(args) {
 
 // src/packages/finance/parselets/InflationQueryParselet.ts
 var INFLATION_ADJUST_BUILTIN_IDX = 60;
+function hasInflationKeyword(parser) {
+  for (let offset = 0; ; offset++) {
+    const token = parser.peekAt(offset);
+    if (!token) return false;
+    if (token.type === "FROM" || token.type === "WORTH_IN") return true;
+  }
+}
 var InflationQueryParselet = class {
   constructor(variant) {
     this.variant = variant;
     this.category = "Finance";
   }
   parse(parser, _token, builder) {
+    if (!hasInflationKeyword(parser)) {
+      parser.parseExpression(BindingPower.Lowest, builder);
+      return;
+    }
     parser.parseExpression(BindingPower.Product, builder);
     if (this.variant === "what-was") {
       parser.consume("WORTH_IN");
@@ -6366,5 +6508,5 @@ var BUILTIN_PACKAGES = [
 ];
 
 export { ARITHMETIC_PACKAGE, BIGINT_PACKAGE, BUILTIN_PACKAGES, CONDITIONALS_PACKAGE, CONVERTERS_PACKAGE, CURRENCY_PACKAGE, DATETIME_PACKAGE, DICE_PACKAGE, FINANCE_PACKAGE, FUNCTION_PACKAGE, LINES_PACKAGE, MAPREDUCE_PACKAGE, MATHPHRASES_PACKAGE, MATRIX_PACKAGE, PERCENTAGE_PACKAGE, SYMBOLIC_PACKAGE, TIME_PACKAGE, UOM_PACKAGE, VARIABLES_PACKAGE, VECTOR_PACKAGE, WEATHER_PACKAGE, containsSymbolicCall, createKnowledgePackage, createStocksPackage };
-//# sourceMappingURL=chunk-GVWHCL2N.js.map
-//# sourceMappingURL=chunk-GVWHCL2N.js.map
+//# sourceMappingURL=chunk-HMOISHXR.js.map
+//# sourceMappingURL=chunk-HMOISHXR.js.map