solve-engine 1.1.0 → 1.2.0

package/dist/{chunk-RRLHC37V.js → chunk-TPOK3UNI.js}

@@ -1,21 +1,21 @@
-import { BindingPower, BytecodeBuilder, bigIntLiteralDigits } from './chunk-ENKKJYD3.js';
-import { createFusedToken, isInsideRangeContext } from './chunk-JJIXHXFQ.js';
+import { BindingPower, BytecodeBuilder, bigIntLiteralDigits } from './chunk-IQJGDZOP.js';
+import { createFusedToken, isInsideRangeContext } from './chunk-L5YHV6BQ.js';
 import { stripQuotes } from './chunk-3BOK2LDK.js';
-import { CurrencyAsyncResolver, nextInstruction } from './chunk-7KYSUDQO.js';
+import { CurrencyAsyncResolver, nextInstruction } from './chunk-F4UB4XIL.js';
 import { getActiveQueryClient } from './chunk-NLNDMWZC.js';
-import { allocatePluginFunctionIndex, sharedGlobalVariableStore, adjustForInflation, solveForVariable, CPI_MIN_YEAR, CPI_MAX_YEAR } from './chunk-NKW7LKYU.js';
-import { sharedCurrencyExchange } from './chunk-Z7XGGLI2.js';
+import { allocatePluginFunctionIndex, sharedGlobalVariableStore, adjustForInflation, solveForVariable, CPI_MIN_YEAR, CPI_MAX_YEAR } from './chunk-WMQRJTAO.js';
+import { sharedCurrencyExchange } from './chunk-BSPXMGIS.js';
 import { createTimeoutSignal } from './chunk-Z4X2RWOF.js';
 import { parseColour, clamp255, clamp01, hslToRgb, rotateHue, complement, grayscale, invert, mix, withAlpha, contrastRatio, relativeLuminance, hsvToRgb, hwbToRgb, isDark, readableColour, wcagLevel, WCAG_THRESHOLDS, lighten, darken, saturate, desaturate, rgbToHsl, tint, shade, tone } from './chunk-5HRB36DK.js';
-import { resolveCurrencyAlias, varNode, constNode, rationalFromNumber, simplifySymbolic, rationalToNumber } from './chunk-NNQ2TYDF.js';
-import { errorValue, colourValue, numberValue, boolValue, stringValue, faultedOperand, uomValue, datetimeValue, timecodeUnit, symbolicValue, ValueType } from './chunk-267JPOTF.js';
+import { resolveCurrencyAlias, varNode, constNode, rationalFromNumber, simplifySymbolic, rationalToNumber } from './chunk-ZNFFTYWH.js';
+import { errorValue, colourValue, numberValue, boolValue, stringValue, faultedOperand, uomValue, datetimeValue, timecodeUnit, symbolicValue, ValueType } from './chunk-5EFKSKMA.js';
 import { getMeasure, convertUnit } from './chunk-MVTOCRV2.js';
-import { LexerToken } from './chunk-GQMUHVE3.js';
-import { tokenTypeId } from './chunk-4D6NIHE2.js';
+import { LexerToken } from './chunk-ORM7CHYZ.js';
+import { tokenTypeId } from './chunk-NAWZATKT.js';
 import { getLocale } from './chunk-XBTEO4OB.js';
 import { isKnownUnit } from './chunk-SBUFNJVE.js';
 import { UNIT_TABLE } from './chunk-V4XG5QF6.js';
-import { ErrorFactory } from './chunk-ERCOHGXD.js';
+import { ErrorFactory } from './chunk-N7OA4WPJ.js';
 
 // src/packages/arithmetic/parselets/NumberParselet.ts
 var CHAINED_DOT_THOUSANDS_GROUPS = /^\d{1,3}(\.\d{3}){2,}$/;
@@ -5635,6 +5635,105 @@ var LoanRepaymentParselet = class {
   }
 };
 
+// src/packages/finance/parselets/BillSplitParselets.ts
+var SplitBetweenParselet = class {
+  constructor(builtinIndex) {
+    this.builtinIndex = builtinIndex;
+    this.category = "Finance";
+  }
+  parse(parser, _token, builder) {
+    parser.parseExpression(BindingPower.Lowest, builder);
+    parser.consume("BETWEEN");
+    parser.parseExpression(BindingPower.Lowest, builder);
+    parser.match("PEOPLE");
+    builder.emitOpcode(51 /* CALL_BUILTIN */);
+    builder.emitIndex(this.builtinIndex);
+    builder.emitIndex(2);
+  }
+};
+var SplitWaysParselet = class {
+  constructor(builtinIndex) {
+    this.builtinIndex = builtinIndex;
+    this.category = "Finance";
+    this.bindingPower = BindingPower.Conditional;
+  }
+  parse(parser, _left, _token, builder) {
+    parser.parseExpression(BindingPower.Conditional, builder);
+    parser.consume("WAYS");
+    builder.emitOpcode(51 /* CALL_BUILTIN */);
+    builder.emitIndex(this.builtinIndex);
+    builder.emitIndex(2);
+  }
+};
+
+// src/packages/finance/parselets/SavingsGoalParselets.ts
+var SAVINGS_PERIODS = {
+  daily: { perYear: 365, unit: "days" },
+  weekly: { perYear: 52, unit: "weeks" },
+  monthly: { perYear: 12, unit: "months" },
+  yearly: { perYear: 1, unit: "years" },
+  annually: { perYear: 1, unit: "years" }
+};
+function readSavingsPeriod(parser) {
+  const token = parser.peek();
+  const word = (token?.text ?? token?.value ?? "").toLowerCase();
+  const period = SAVINGS_PERIODS[word];
+  if (period === void 0) {
+    throw ErrorFactory.parsing(
+      "UNKNOWN_SAVINGS_PERIOD",
+      `savings goal: expected a contribution period, one of ${Object.keys(SAVINGS_PERIODS).join(", ")}, not "${word || "?"}".`
+    );
+  }
+  parser.consume();
+  return period;
+}
+var SavingsDurationParselet = class {
+  constructor(builtinIndex) {
+    this.builtinIndex = builtinIndex;
+    this.category = "Finance";
+  }
+  parse(parser, _token, builder) {
+    parser.parseExpression(BindingPower.Conditional, builder);
+    if (!parser.match("RATE_AT")) parser.consume("AT");
+    parser.parseExpression(BindingPower.Product, builder);
+    parser.match("STAR");
+    const period = readSavingsPeriod(parser);
+    builder.emitOpcode(10 /* PUSH_NUMBER */);
+    builder.emitNumber(period.perYear);
+    if (parser.match("RATE_AT") || parser.match("AT")) {
+      parser.parseExpression(BindingPower.Conditional, builder);
+    } else {
+      builder.emitOpcode(10 /* PUSH_NUMBER */);
+      builder.emitNumber(0);
+    }
+    builder.emitOpcode(13 /* PUSH_STRING */);
+    builder.emitString(period.unit);
+    builder.emitOpcode(51 /* CALL_BUILTIN */);
+    builder.emitIndex(this.builtinIndex);
+    builder.emitIndex(5);
+  }
+};
+var SavingsContributionParselet = class {
+  constructor(builtinIndex) {
+    this.builtinIndex = builtinIndex;
+    this.category = "Finance";
+  }
+  parse(parser, _token, builder) {
+    parser.parseExpression(BindingPower.Product, builder);
+    parser.consume("IN");
+    parser.parseExpression(BindingPower.Conditional, builder);
+    if (parser.match("RATE_AT") || parser.match("AT")) {
+      parser.parseExpression(BindingPower.Conditional, builder);
+    } else {
+      builder.emitOpcode(10 /* PUSH_NUMBER */);
+      builder.emitNumber(0);
+    }
+    builder.emitOpcode(51 /* CALL_BUILTIN */);
+    builder.emitIndex(this.builtinIndex);
+    builder.emitIndex(3);
+  }
+};
+
 // src/packages/finance/parselets/SalesTaxParselet.ts
 var SalesTaxParselet = class {
   constructor(builtinIndex) {
@@ -5936,6 +6035,77 @@ function recurringScheduleNormalizerRule(priority = 78) {
   };
 }
 
+// src/packages/finance/normalizer/BillSplitNormalizerRule.ts
+function wordOf2(token) {
+  if (token === void 0) return "";
+  return (token.text ?? token.value ?? "").toLowerCase();
+}
+var VALUE_ENDERS2 = /* @__PURE__ */ new Set([
+  "NUMBER",
+  "FLOAT",
+  "HEX",
+  "BIGINT",
+  "RPAREN",
+  "RBRACKET",
+  "IDENT",
+  "PERCENT",
+  "STRING"
+]);
+var NUMERIC = /* @__PURE__ */ new Set(["NUMBER", "FLOAT"]);
+function billSplitNormalizerRule(priority = 77) {
+  return {
+    name: "finance:bill-split",
+    priority,
+    match(tokens, pos) {
+      const head = tokens[pos];
+      if (head === void 0) return null;
+      if (VALUE_ENDERS2.has(head.type)) {
+        const split = tokens[pos + 1];
+        const count2 = tokens[pos + 2];
+        const ways = tokens[pos + 3];
+        if (split?.type === "IDENT" && wordOf2(split) === "split" && count2 !== void 0 && NUMERIC.has(count2.type) && ways?.type === "IDENT" && wordOf2(ways) === "ways") {
+          return {
+            consumed: 4,
+            replacement: [
+              head,
+              createFusedToken("SPLIT_WAYS", "split", [split]),
+              count2,
+              createFusedToken("WAYS", "ways", [ways])
+            ],
+            ruleName: "finance:bill-split"
+          };
+        }
+      }
+      if (head.type !== "IDENT" || wordOf2(head) !== "split") return null;
+      const before = tokens[pos - 1];
+      if (before !== void 0 && VALUE_ENDERS2.has(before.type)) return null;
+      let betweenIndex = -1;
+      for (let i = pos + 1; i < tokens.length; i++) {
+        if (tokens[i].type === "BETWEEN") {
+          betweenIndex = i;
+          break;
+        }
+      }
+      if (betweenIndex === -1) return null;
+      const count = tokens[betweenIndex + 1];
+      if (count === void 0 || !NUMERIC.has(count.type)) return null;
+      const peopleIndex = betweenIndex + 2;
+      const hasPeople = tokens[peopleIndex]?.type === "IDENT" && wordOf2(tokens[peopleIndex]) === "people";
+      const lastIndex = hasPeople ? peopleIndex : betweenIndex + 1;
+      const replacement = [
+        createFusedToken("SPLIT", "split", [head]),
+        ...tokens.slice(pos + 1, betweenIndex + 2)
+      ];
+      if (hasPeople) replacement.push(createFusedToken("PEOPLE", "people", [tokens[peopleIndex]]));
+      return {
+        consumed: lastIndex - pos + 1,
+        replacement,
+        ruleName: "finance:bill-split"
+      };
+    }
+  };
+}
+
 // src/packages/finance/FinancePackage.ts
 var COMPOUND_FV = 51;
 var COMPOUND_INTEREST = 52;
@@ -5949,6 +6119,9 @@ var ANNUAL_RETURN = 84;
 var TAX_REMOVE = 59;
 var TAX_IN = 85;
 var TAX_ON = 86;
+var SPLIT_EACH = 98;
+var SAVINGS_PAYMENT = 99;
+var SAVINGS_PERIODS2 = 100;
 var FINANCE_PACKAGE = {
   name: "solve-finance",
   phrases: {
@@ -5980,6 +6153,9 @@ var FINANCE_PACKAGE = {
     "annual return on": "ANNUAL_RETURN_ON",
     "value of": "VALUE_OF",
     "worth in": "WORTH_IN",
+    "how long to save": "SAVINGS_HOW_LONG",
+    "how much per month to save": "SAVINGS_HOW_MUCH",
+    "how much per month to reach": "SAVINGS_HOW_MUCH",
     "assuming": "ASSUMING"
   },
   prefixParselets: [
@@ -5998,9 +6174,12 @@ var FINANCE_PACKAGE = {
     { tokenType: "TAX_ON", parselet: new SalesTaxParselet(TAX_ON) },
     { tokenType: "TAX_OFF", parselet: new SalesTaxParselet(TAX_REMOVE) },
     { tokenType: "TAX_IN_PHRASE", parselet: new SalesTaxParselet(TAX_IN) },
+    { tokenType: "SPLIT", parselet: new SplitBetweenParselet(SPLIT_EACH) },
     { tokenType: "WHAT_IS", parselet: new InflationQueryParselet("what-is") },
     { tokenType: "WHAT_WAS", parselet: new InflationQueryParselet("what-was") },
-    { tokenType: "VALUE_OF", parselet: new InflationFutureValueParselet() }
+    { tokenType: "VALUE_OF", parselet: new InflationFutureValueParselet() },
+    { tokenType: "SAVINGS_HOW_LONG", parselet: new SavingsDurationParselet(SAVINGS_PERIODS2) },
+    { tokenType: "SAVINGS_HOW_MUCH", parselet: new SavingsContributionParselet(SAVINGS_PAYMENT) }
   ],
   infixParselets: [
     // The documented bare forms: "$1,000 after 3 years at 7%" and the "for
@@ -6009,14 +6188,22 @@ var FINANCE_PACKAGE = {
     { tokenType: "AFTER", parselet: new InvestmentGrowthParselet(COMPOUND_FV, COMPOUND_FV_EVERY) },
     { tokenType: "FOR_DURATION", parselet: new InvestmentGrowthParselet(COMPOUND_FV, COMPOUND_FV_EVERY) },
     { tokenType: "INVESTED", parselet: new ReturnOnInvestmentParselet(ROI) },
-    { tokenType: "IN_YEAR_DOLLARS", parselet: new InYearDollarsParselet() }
+    { tokenType: "IN_YEAR_DOLLARS", parselet: new InYearDollarsParselet() },
+    // The amount-first split spelling, `<amount> split N ways`. Infix so the
+    // amount (which may be `$120 + 18%`) is the left operand. See
+    // BillSplitParselets.ts.
+    { tokenType: "SPLIT_WAYS", parselet: new SplitWaysParselet(SPLIT_EACH) }
   ],
   normalizerRules: [
     inYearDollarsNormalizerRule(),
     // `450 monthly for 18 months` -> `450 * 18`. A recurring schedule totalled
     // as a plain multiplication, so a currency amount stays currency and an
     // exact one stays exact. See RecurringScheduleNormalizerRule.ts.
-    recurringScheduleNormalizerRule()
+    recurringScheduleNormalizerRule(),
+    // `split $180 between 4` / `$120 + 18% split 3 ways`. Retypes split/ways/
+    // people contextually so those words stay ordinary names everywhere else.
+    // See BillSplitNormalizerRule.ts.
+    billSplitNormalizerRule()
   ],
   pluginFunctions: [
     { index: INFLATION_FROM_YEAR_TO_PRESENT_IDX, handler: inflationFromYearToPresentHandler },
@@ -7284,6 +7471,185 @@ var TABLES_PACKAGE = {
   ]
 };
 
+// src/packages/tags/parselets/TagAggregateParselet.ts
+var TagAggregateParselet = class {
+  constructor(pluginFnIndex) {
+    this.pluginFnIndex = pluginFnIndex;
+    this.category = "Tags";
+  }
+  parse(_parser, token, builder) {
+    builder.emitOpcode(13 /* PUSH_STRING */);
+    builder.emitString(token.value);
+    builder.emitOpcode(50 /* CALL_PLUGIN */);
+    builder.emitIndex(this.pluginFnIndex);
+    builder.emitIndex(1);
+  }
+};
+
+// src/packages/tags/normalizer/TagAggregateNormalizerRule.ts
+function wordOf3(token) {
+  if (token === void 0) return "";
+  return (token.text ?? token.value ?? "").toLowerCase();
+}
+var AGGREGATE_TOKEN = {
+  TOTAL_OF: "TAG_SUM",
+  COUNT_OF: "TAG_COUNT",
+  AVERAGE_OF: "TAG_AVERAGE"
+};
+var AGGREGATE_WORDS = /* @__PURE__ */ new Set(["total", "sum", "count", "average"]);
+function tagAggregateNormalizerRule(priority = 80) {
+  return {
+    name: "tags:aggregate",
+    priority,
+    match(tokens, pos) {
+      const head = tokens[pos];
+      if (head === void 0) return null;
+      const fused = AGGREGATE_TOKEN[head.type];
+      if (fused !== void 0) {
+        const tag = tokens[pos + 1];
+        if (tag?.type !== "TAG") return null;
+        return {
+          consumed: 2,
+          replacement: [createFusedToken(fused, tag.value ?? "", [head, tag])],
+          ruleName: "tags:aggregate"
+        };
+      }
+      if (head.type === "IDENT" && wordOf3(head) === "sum") {
+        const of = tokens[pos + 1];
+        const tag = tokens[pos + 2];
+        if (wordOf3(of) !== "of") return null;
+        if (tag?.type !== "TAG") return null;
+        return {
+          consumed: 3,
+          replacement: [createFusedToken("TAG_SUM", tag.value ?? "", [head, of, tag])],
+          ruleName: "tags:aggregate"
+        };
+      }
+      return null;
+    }
+  };
+}
+function tagStripNormalizerRule(priority = 40) {
+  return {
+    name: "tags:strip",
+    priority,
+    match(tokens, pos) {
+      if (tokens[pos]?.type !== "TAG") return null;
+      const before = tokens[pos - 1];
+      if (before !== void 0) {
+        if (AGGREGATE_TOKEN[before.type] !== void 0) return null;
+        if (wordOf3(before) === "of" && AGGREGATE_WORDS.has(wordOf3(tokens[pos - 2]))) return null;
+      }
+      return { consumed: 1, replacement: [], ruleName: "tags:strip" };
+    }
+  };
+}
+
+// src/packages/tags/TagScanner.ts
+function escapeTag(name) {
+  return name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function lineCarriesTag(rawText, tag) {
+  if (tag === "") return false;
+  const re = new RegExp(`(?:^|[^0-9A-Za-z_])#${escapeTag(tag)}(?![0-9A-Za-z_-])`, "i");
+  const m = re.exec(rawText);
+  if (m === null) return false;
+  const hashIndex = m.index + m[0].indexOf("#");
+  return rawText.slice(0, hashIndex).trim().length > 0;
+}
+
+// src/packages/tags/TagsPluginFunctions.ts
+function checkLineValue2(v, lineNumber) {
+  if (v === void 0) {
+    return errorValue("LINE_NOT_YET_EVALUATED", `Line ${lineNumber} has not been evaluated yet`);
+  }
+  if (v.type === 12 /* Pending */) {
+    return errorValue("LINE_RESULT_PENDING", `Line ${lineNumber}'s result is still resolving`);
+  }
+  if (v.type === 13 /* Error */) {
+    return errorValue("LINE_RESULT_ERROR", `Line ${lineNumber} has an error`);
+  }
+  return null;
+}
+function requireContext2(context) {
+  if (!context?.getLineResult || !context.getLineText) {
+    return errorValue("TAG_NO_DOCUMENT", "Category tag sums require a real document, not available outside one (e.g. evaluateExpression()'s single-expression path)");
+  }
+  return null;
+}
+function aggregateTagged(context, tag, mode) {
+  const getText = context.getLineText;
+  const getResult = context.getLineResult;
+  const isBoundary = context.isLineBoundary;
+  const needle = tag.toLowerCase();
+  let total = 0;
+  let count = 0;
+  let commonUnit;
+  let sawUom = false;
+  for (let n = 1; ; n++) {
+    const text = getText(n);
+    if (text === void 0) break;
+    if (n === context.lineIndex) continue;
+    if (isBoundary && isBoundary(n)) continue;
+    if (!lineCarriesTag(text, needle)) continue;
+    const v = getResult(n);
+    const err = checkLineValue2(v, n);
+    if (err) return err;
+    if (mode !== "count") {
+      if (v.type !== 0 /* Number */ && v.type !== 6 /* Uom */) {
+        return errorValue("TAG_NON_NUMERIC", `Line ${n}, tagged #${tag}, is not a plain number or unit value.`);
+      }
+      if (v.type === 6 /* Uom */) {
+        sawUom = true;
+        if (commonUnit === void 0) commonUnit = v.unit;
+        else if (v.unit !== commonUnit) {
+          return errorValue("TAG_MIXED_UNITS", `Line ${n}'s unit (${v.unit}) doesn't match #${tag}'s first unit (${commonUnit}), aggregating mixed units would misrepresent the result.`);
+        }
+      }
+      total += v.toNumber();
+    }
+    count++;
+  }
+  if (mode === "count") return numberValue(count);
+  if (count === 0) return errorValue("TAG_EMPTY", `No lines are tagged #${tag}.`);
+  const result = mode === "average" ? total / count : total;
+  return sawUom ? uomValue(result, commonUnit) : numberValue(result);
+}
+var TAG_SUM_FN_IDX = allocatePluginFunctionIndex();
+function tagSumHandler(args, context) {
+  const ctxError = requireContext2(context);
+  if (ctxError) return ctxError;
+  return aggregateTagged(context, String(args[0].value), "sum");
+}
+var TAG_AVERAGE_FN_IDX = allocatePluginFunctionIndex();
+function tagAverageHandler(args, context) {
+  const ctxError = requireContext2(context);
+  if (ctxError) return ctxError;
+  return aggregateTagged(context, String(args[0].value), "average");
+}
+var TAG_COUNT_FN_IDX = allocatePluginFunctionIndex();
+function tagCountHandler(args, context) {
+  const ctxError = requireContext2(context);
+  if (ctxError) return ctxError;
+  return aggregateTagged(context, String(args[0].value), "count");
+}
+
+// src/packages/tags/TagsPackage.ts
+var TAGS_PACKAGE = {
+  name: "solve-tags",
+  normalizerRules: [tagAggregateNormalizerRule(), tagStripNormalizerRule()],
+  prefixParselets: [
+    { tokenType: "TAG_SUM", parselet: new TagAggregateParselet(TAG_SUM_FN_IDX) },
+    { tokenType: "TAG_AVERAGE", parselet: new TagAggregateParselet(TAG_AVERAGE_FN_IDX) },
+    { tokenType: "TAG_COUNT", parselet: new TagAggregateParselet(TAG_COUNT_FN_IDX) }
+  ],
+  pluginFunctions: [
+    { index: TAG_SUM_FN_IDX, handler: tagSumHandler },
+    { index: TAG_AVERAGE_FN_IDX, handler: tagAverageHandler },
+    { index: TAG_COUNT_FN_IDX, handler: tagCountHandler }
+  ]
+};
+
 // src/packages/uncertainty/parselets/UncertaintyParselet.ts
 var UncertaintyParselet = class {
   constructor() {
@@ -7977,9 +8343,13 @@ var BUILTIN_PACKAGES = [
   // rule mints, and its parselet targets a line reference.
   GOALSEEK_PACKAGE,
   TABLES_PACKAGE,
-  COLOUR_PACKAGE
+  COLOUR_PACKAGE,
+  // After MATHPHRASES_PACKAGE and LINES_PACKAGE: tag aggregates reuse the
+  // `total of`/`count of`/`average of` fusions and walk the document the same
+  // way the lines cross-line reads do.
+  TAGS_PACKAGE
 ];
 
-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, TABLES_PACKAGE, TIME_PACKAGE, UOM_PACKAGE, VARIABLES_PACKAGE, VECTOR_PACKAGE, WEATHER_PACKAGE, containsSymbolicCall, createCurrencyPackage, createKnowledgePackage, createStocksPackage };
-//# sourceMappingURL=chunk-RRLHC37V.js.map
-//# sourceMappingURL=chunk-RRLHC37V.js.map
+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, TABLES_PACKAGE, TAGS_PACKAGE, TIME_PACKAGE, UOM_PACKAGE, VARIABLES_PACKAGE, VECTOR_PACKAGE, WEATHER_PACKAGE, containsSymbolicCall, createCurrencyPackage, createKnowledgePackage, createStocksPackage };
+//# sourceMappingURL=chunk-TPOK3UNI.js.map
+//# sourceMappingURL=chunk-TPOK3UNI.js.map