solve-engine 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/errors.cjs

@@ -0,0 +1,81 @@
+'use strict';
+
+var chunkM4N5GA5Z_cjs = require('./chunk-M4N5GA5Z.cjs');
+require('./chunk-B7LXJ6LC.cjs');
+
+
+
+Object.defineProperty(exports, "CoreErrorCodes", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.CoreErrorCodes; }
+});
+Object.defineProperty(exports, "EngineError", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.EngineError; }
+});
+Object.defineProperty(exports, "ErrorCategory", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.ErrorCategory; }
+});
+Object.defineProperty(exports, "ErrorFactory", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.ErrorFactory; }
+});
+Object.defineProperty(exports, "andThen", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.andThen; }
+});
+Object.defineProperty(exports, "combine", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.combine; }
+});
+Object.defineProperty(exports, "err", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.err; }
+});
+Object.defineProperty(exports, "isErr", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.isErr; }
+});
+Object.defineProperty(exports, "isOk", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.isOk; }
+});
+Object.defineProperty(exports, "map", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.map; }
+});
+Object.defineProperty(exports, "mapErr", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.mapErr; }
+});
+Object.defineProperty(exports, "match", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.match; }
+});
+Object.defineProperty(exports, "normalizeUnknownError", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.normalizeUnknownError; }
+});
+Object.defineProperty(exports, "ok", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.ok; }
+});
+Object.defineProperty(exports, "throwIfErr", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.throwIfErr; }
+});
+Object.defineProperty(exports, "tryCatch", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.tryCatch; }
+});
+Object.defineProperty(exports, "tryCatchAsync", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.tryCatchAsync; }
+});
+Object.defineProperty(exports, "unwrapOr", {
+  enumerable: true,
+  get: function () { return chunkM4N5GA5Z_cjs.unwrapOr; }
+});
+//# sourceMappingURL=errors.cjs.map
+//# sourceMappingURL=errors.cjs.map

package/dist/errors.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"errors.cjs"}

package/dist/errors.d.cts

@@ -0,0 +1,95 @@
+import { E as EngineError } from './EngineError-DvPSnhZi.cjs';
+export { C as CoreErrorCode, a as CoreErrorCodes, b as EngineErrorInit, c as ErrorCategory, d as ErrorCode, e as ErrorFactory, S as SourceSpan, n as normalizeUnknownError } from './EngineError-DvPSnhZi.cjs';
+
+/**
+ * A Rust-style `Result<T, E>`, the value half of this engine's error-handling
+ * redesign. `E` defaults to `EngineError` (this engine's structured error
+ * type) but every combinator here is generic over `E`, so `Result` works
+ * equally well for a domain that isn't `EngineError`-shaped.
+ *
+ * This exact shape used to live in `errors/UnifiedErrorFramework.ts` (kept
+ * there as a barrel re-export for backward compatibility), moved here as
+ * its own module because it's genuinely generic (no dependency on
+ * `EngineError` beyond the default type parameter) and because the engine
+ * is migrating callers to it incrementally: parsing/VM/package code that
+ * expects "a failure is a possibility, not an exception" returns
+ * `Result<T, EngineError>` instead of throwing; two explicit adapters
+ * {@link throwIfErr} and {@link tryCatch}, are the sanctioned way to cross
+ * the boundary between Result-based code and still-throw-based code during
+ * the migration (and permanently, at the public API boundary. See
+ * `ExpressionEngine.evaluateExpression()`'s documented throw contract).
+ */
+type Result<T, E = EngineError> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+/** Wrap a successful value. */
+declare function ok<T>(value: T): Result<T, never>;
+/** Wrap a failure. */
+declare function err<E>(error: E): Result<never, E>;
+/**
+ * Narrow a {@link Result} to its success arm.
+ *
+ * @param r - The result to test.
+ * @returns True when it succeeded, narrowing `r` so `r.value` is reachable.
+ */
+declare function isOk<T, E>(r: Result<T, E>): r is {
+    ok: true;
+    value: T;
+};
+/**
+ * Narrow a {@link Result} to its failure arm.
+ *
+ * @param r - The result to test.
+ * @returns True when it failed, narrowing `r` so `r.error` is reachable.
+ */
+declare function isErr<T, E>(r: Result<T, E>): r is {
+    ok: false;
+    error: E;
+};
+/** Transform the success value; a failure passes through untouched. */
+declare function map<T, U, E>(r: Result<T, E>, fn: (value: T) => U): Result<U, E>;
+/** Transform the error; a success passes through untouched. */
+declare function mapErr<T, E, F>(r: Result<T, E>, fn: (error: E) => F): Result<T, F>;
+/** Chain a Result-returning operation onto a success (a.k.a. flatMap/bind). */
+declare function andThen<T, U, E>(r: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;
+/** Unwrap a success, or return `fallback` for a failure. Never throws. */
+declare function unwrapOr<T, E>(r: Result<T, E>, fallback: T): T;
+/** Exhaustive pattern-match, the `match`/`switch` a Rust enum gets for free. */
+declare function match<T, E, R>(r: Result<T, E>, arms: {
+    ok: (value: T) => R;
+    err: (error: E) => R;
+}): R;
+/**
+ * Combine several Results into one, succeeds with a tuple of all values
+ * iff every input succeeded; otherwise fails with the FIRST error
+ * encountered (left-to-right), matching this codebase's existing
+ * fail-fast convention elsewhere (e.g. `BytecodeBuilder`'s constant-pool
+ * limit checks).
+ */
+declare function combine<T extends readonly unknown[], E>(results: {
+    [K in keyof T]: Result<T[K], E>;
+}): Result<T, E>;
+/**
+ * Cross from Result-space back to throw-space, the sanctioned boundary
+ * adapter for callers (public API surface, older not-yet-migrated code,
+ * tests) that still want exception-based control flow. Throws `r.error`
+ * as-is (an `EngineError` is already a real `Error` subclass, so this
+ * needs no wrapping).
+ */
+declare function throwIfErr<T, E>(r: Result<T, E>): T;
+/**
+ * Cross from throw-space into Result-space, runs `fn`, converting any
+ * thrown value into a Result via `normalize` (defaults to
+ * {@link normalizeUnknownError}). The inverse of {@link throwIfErr}; the
+ * pairing that lets Result-based and throw-based code interoperate during
+ * an incremental migration instead of requiring a single flag-day rewrite.
+ */
+declare function tryCatch<T>(fn: () => T, normalize?: (e: unknown) => EngineError): Result<T, EngineError>;
+/** Async sibling of {@link tryCatch}. */
+declare function tryCatchAsync<T>(fn: () => Promise<T>, normalize?: (e: unknown) => EngineError): Promise<Result<T, EngineError>>;
+
+export { EngineError, type Result, andThen, combine, err, isErr, isOk, map, mapErr, match, ok, throwIfErr, tryCatch, tryCatchAsync, unwrapOr };

package/dist/errors.d.ts

@@ -0,0 +1,95 @@
+import { E as EngineError } from './EngineError-DvPSnhZi.js';
+export { C as CoreErrorCode, a as CoreErrorCodes, b as EngineErrorInit, c as ErrorCategory, d as ErrorCode, e as ErrorFactory, S as SourceSpan, n as normalizeUnknownError } from './EngineError-DvPSnhZi.js';
+
+/**
+ * A Rust-style `Result<T, E>`, the value half of this engine's error-handling
+ * redesign. `E` defaults to `EngineError` (this engine's structured error
+ * type) but every combinator here is generic over `E`, so `Result` works
+ * equally well for a domain that isn't `EngineError`-shaped.
+ *
+ * This exact shape used to live in `errors/UnifiedErrorFramework.ts` (kept
+ * there as a barrel re-export for backward compatibility), moved here as
+ * its own module because it's genuinely generic (no dependency on
+ * `EngineError` beyond the default type parameter) and because the engine
+ * is migrating callers to it incrementally: parsing/VM/package code that
+ * expects "a failure is a possibility, not an exception" returns
+ * `Result<T, EngineError>` instead of throwing; two explicit adapters
+ * {@link throwIfErr} and {@link tryCatch}, are the sanctioned way to cross
+ * the boundary between Result-based code and still-throw-based code during
+ * the migration (and permanently, at the public API boundary. See
+ * `ExpressionEngine.evaluateExpression()`'s documented throw contract).
+ */
+type Result<T, E = EngineError> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+/** Wrap a successful value. */
+declare function ok<T>(value: T): Result<T, never>;
+/** Wrap a failure. */
+declare function err<E>(error: E): Result<never, E>;
+/**
+ * Narrow a {@link Result} to its success arm.
+ *
+ * @param r - The result to test.
+ * @returns True when it succeeded, narrowing `r` so `r.value` is reachable.
+ */
+declare function isOk<T, E>(r: Result<T, E>): r is {
+    ok: true;
+    value: T;
+};
+/**
+ * Narrow a {@link Result} to its failure arm.
+ *
+ * @param r - The result to test.
+ * @returns True when it failed, narrowing `r` so `r.error` is reachable.
+ */
+declare function isErr<T, E>(r: Result<T, E>): r is {
+    ok: false;
+    error: E;
+};
+/** Transform the success value; a failure passes through untouched. */
+declare function map<T, U, E>(r: Result<T, E>, fn: (value: T) => U): Result<U, E>;
+/** Transform the error; a success passes through untouched. */
+declare function mapErr<T, E, F>(r: Result<T, E>, fn: (error: E) => F): Result<T, F>;
+/** Chain a Result-returning operation onto a success (a.k.a. flatMap/bind). */
+declare function andThen<T, U, E>(r: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;
+/** Unwrap a success, or return `fallback` for a failure. Never throws. */
+declare function unwrapOr<T, E>(r: Result<T, E>, fallback: T): T;
+/** Exhaustive pattern-match, the `match`/`switch` a Rust enum gets for free. */
+declare function match<T, E, R>(r: Result<T, E>, arms: {
+    ok: (value: T) => R;
+    err: (error: E) => R;
+}): R;
+/**
+ * Combine several Results into one, succeeds with a tuple of all values
+ * iff every input succeeded; otherwise fails with the FIRST error
+ * encountered (left-to-right), matching this codebase's existing
+ * fail-fast convention elsewhere (e.g. `BytecodeBuilder`'s constant-pool
+ * limit checks).
+ */
+declare function combine<T extends readonly unknown[], E>(results: {
+    [K in keyof T]: Result<T[K], E>;
+}): Result<T, E>;
+/**
+ * Cross from Result-space back to throw-space, the sanctioned boundary
+ * adapter for callers (public API surface, older not-yet-migrated code,
+ * tests) that still want exception-based control flow. Throws `r.error`
+ * as-is (an `EngineError` is already a real `Error` subclass, so this
+ * needs no wrapping).
+ */
+declare function throwIfErr<T, E>(r: Result<T, E>): T;
+/**
+ * Cross from throw-space into Result-space, runs `fn`, converting any
+ * thrown value into a Result via `normalize` (defaults to
+ * {@link normalizeUnknownError}). The inverse of {@link throwIfErr}; the
+ * pairing that lets Result-based and throw-based code interoperate during
+ * an incremental migration instead of requiring a single flag-day rewrite.
+ */
+declare function tryCatch<T>(fn: () => T, normalize?: (e: unknown) => EngineError): Result<T, EngineError>;
+/** Async sibling of {@link tryCatch}. */
+declare function tryCatchAsync<T>(fn: () => Promise<T>, normalize?: (e: unknown) => EngineError): Promise<Result<T, EngineError>>;
+
+export { EngineError, type Result, andThen, combine, err, isErr, isOk, map, mapErr, match, ok, throwIfErr, tryCatch, tryCatchAsync, unwrapOr };

package/dist/errors.js

@@ -0,0 +1,4 @@
+export { CoreErrorCodes, EngineError, ErrorCategory, ErrorFactory, andThen, combine, err, isErr, isOk, map, mapErr, match, normalizeUnknownError, ok, throwIfErr, tryCatch, tryCatchAsync, unwrapOr } from './chunk-6RDSQURE.js';
+import './chunk-YLJ4XMA6.js';
+//# sourceMappingURL=errors.js.map
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"errors.js"}

package/dist/format.cjs

@@ -0,0 +1,171 @@
+'use strict';
+
+var chunkCCJPSHGI_cjs = require('./chunk-CCJPSHGI.cjs');
+var chunkOT6OJY7C_cjs = require('./chunk-OT6OJY7C.cjs');
+var chunkHTXVVJRA_cjs = require('./chunk-HTXVVJRA.cjs');
+require('./chunk-OC6LTXYS.cjs');
+var chunk3YNVWKR2_cjs = require('./chunk-3YNVWKR2.cjs');
+require('./chunk-M4N5GA5Z.cjs');
+require('./chunk-B7LXJ6LC.cjs');
+
+// src/format/FormattingSettings.ts
+var DEFAULT_FORMATTING_SETTINGS = {
+  floatResult: {
+    decimalPlaces: 2,
+    enableSeperator: true
+  },
+  numberResult: {
+    decimalSeparatorLocale: "en-US"
+  },
+  hexResult: {
+    enablePadding: false,
+    paddingZeros: 0
+  },
+  unitOfMeasurementResult: {
+    decimalPlaces: 2,
+    unitNames: true
+  },
+  percentageResult: {
+    decimalPlaces: 2
+  }
+};
+
+// src/format/FormatEngine.ts
+function formatNumber(value, locale, settings) {
+  const dp = settings.floatResult.decimalPlaces;
+  const sep = settings.floatResult.enableSeperator;
+  const loc = settings.numberResult.decimalSeparatorLocale;
+  const formatted = chunkCCJPSHGI_cjs.autoFormatIntegerOrFloat(value, dp, sep, loc);
+  return `${locale.display.resultPrefix}${formatted}`;
+}
+function formatHex(value, settings, base) {
+  const truncated = Math.trunc(value);
+  const sign = truncated < 0 ? "-" : "";
+  const magnitude = Math.abs(truncated);
+  if (base === "bin") return `= ${sign}0b${magnitude.toString(2)}`;
+  if (base === "oct") return `= ${sign}0o${magnitude.toString(8)}`;
+  const padding = settings.hexResult.enablePadding ? settings.hexResult.paddingZeros : 0;
+  const hex = magnitude.toString(16).toUpperCase().padStart(padding, "0");
+  return `= ${sign}0x${hex}`;
+}
+function formatBigInt(value) {
+  return `= ${value}`;
+}
+function formatString(value) {
+  return `= ${value}`;
+}
+function formatBoolean(value) {
+  return `= ${value}`;
+}
+function formatDatetime(value, locale) {
+  const d = new Date(value);
+  const dateStr = d.toLocaleDateString(locale.code, { weekday: "long", year: "numeric", month: "long", day: "numeric" });
+  const isMidnight = d.getHours() === 0 && d.getMinutes() === 0 && d.getSeconds() === 0 && d.getMilliseconds() === 0;
+  if (isMidnight) return `= ${dateStr}`;
+  return `= ${dateStr}, ${d.toLocaleTimeString(locale.code)}`;
+}
+function formatMsDuration(ms) {
+  const sign = ms < 0 ? "-" : "";
+  const totalSeconds = Math.round(Math.abs(ms) / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  const mm = String(minutes).padStart(2, "0");
+  if (seconds === 0) return `${sign}${hours}:${mm}`;
+  const ss = String(seconds).padStart(2, "0");
+  return `${sign}${hours}:${mm}:${ss}`;
+}
+function formatUom(value, unit, locale, settings) {
+  if (unit === "ms") return `= ${formatMsDuration(value)}`;
+  const dp = settings.unitOfMeasurementResult.decimalPlaces;
+  const useUnitNames = settings.unitOfMeasurementResult.unitNames;
+  const timeSpanUnits = ["days", "weeks", "hours", "minutes", "seconds", "day", "week", "hour", "minute", "second"];
+  const isTimeSpan = unit && timeSpanUnits.includes(unit);
+  let formatted;
+  if (isTimeSpan && value === Math.floor(value)) {
+    formatted = value.toString();
+  } else {
+    formatted = value.toFixed(dp);
+  }
+  const currencyDisplay = unit ? chunkOT6OJY7C_cjs.CURRENCY_DISPLAY[unit.toUpperCase()] : void 0;
+  if (currencyDisplay) {
+    const sep = currencyDisplay.spaced ? " " : "";
+    const withSymbol = currencyDisplay.position === "prefix" ? `${currencyDisplay.symbol}${sep}${formatted}` : `${formatted}${sep}${currencyDisplay.symbol}`;
+    return `= ${withSymbol}`;
+  }
+  const unitLabel = useUnitNames ? unit || "" : unit || "";
+  return `= ${formatted} ${unitLabel}`.trim();
+}
+function formatMatrixEntry(entry, settings) {
+  if (typeof entry === "boolean") return entry ? "true" : "false";
+  if (typeof entry === "object" && entry !== null) return chunkHTXVVJRA_cjs.formatSymbolic(entry);
+  const dp = settings.floatResult.decimalPlaces;
+  const sep = settings.floatResult.enableSeperator;
+  const loc = settings.numberResult.decimalSeparatorLocale;
+  return chunkCCJPSHGI_cjs.autoFormatIntegerOrFloat(entry, dp, sep, loc);
+}
+function formatMatrix(m, locale, settings) {
+  const rowMajor = chunkHTXVVJRA_cjs.columnMajorToRowMajor(m);
+  const rows = [];
+  for (let r = 0; r < m.rows; r++) {
+    const cells = [];
+    for (let c = 0; c < m.cols; c++) {
+      cells.push(formatMatrixEntry(rowMajor[r * m.cols + c], settings));
+    }
+    rows.push(cells.join(", "));
+  }
+  return `${locale.display.resultPrefix}[${rows.join("; ")}]`;
+}
+function formatRange(min, max, locale) {
+  return `${locale.display.resultPrefix}${min}:${max}`;
+}
+function formatPercentage(value, locale, settings) {
+  const dp = settings.percentageResult.decimalPlaces;
+  const formatted = (value * 100).toFixed(dp);
+  return `= ${formatted}${locale.display.percentageSuffix}`;
+}
+function formatUnit(value, unit) {
+  return `= ${value} ${unit || ""}`.trim();
+}
+function formatValue(value, settings) {
+  const us = settings || DEFAULT_FORMATTING_SETTINGS;
+  const localeCode = us.numberResult.decimalSeparatorLocale || "en";
+  const locale = chunk3YNVWKR2_cjs.getLocale(localeCode);
+  switch (value.type) {
+    case 0 /* Number */:
+      return formatNumber(value.value, locale, us);
+    case 1 /* Hex */:
+      return formatHex(value.value, us, value.unit);
+    case 2 /* BigInt */:
+      return formatBigInt(value.value);
+    case 3 /* String */:
+      return formatString(value.value);
+    case 10 /* Boolean */:
+      return formatBoolean(value.value);
+    case 4 /* Datetime */:
+      return formatDatetime(value.value, locale);
+    case 6 /* Uom */:
+      return formatUom(value.value, value.unit, locale, us);
+    case 7 /* Matrix */:
+      return formatMatrix(value.value, locale, us);
+    case 8 /* Range */: {
+      const r = value.value;
+      return formatRange(r.min, r.max, locale);
+    }
+    case 9 /* Symbolic */:
+      return chunkHTXVVJRA_cjs.formatSymbolic(value.value);
+    case 5 /* Percentage */:
+      return formatPercentage(value.value, locale, us);
+    case 11 /* Unit */:
+      return formatUnit(value.value, value.unit);
+    case 13 /* Error */:
+      return value.unit ?? String(value.value);
+    default:
+      return `= ${String(value.value)}`;
+  }
+}
+
+exports.DEFAULT_FORMATTING_SETTINGS = DEFAULT_FORMATTING_SETTINGS;
+exports.formatValue = formatValue;
+//# sourceMappingURL=format.cjs.map
+//# sourceMappingURL=format.cjs.map

package/dist/format.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/format/FormattingSettings.ts","../src/format/FormatEngine.ts"],"names":["autoFormatIntegerOrFloat","CURRENCY_DISPLAY","formatSymbolic","columnMajorToRowMajor","getLocale"],"mappings":";;;;;;;;;;;AA0BO,IAAM,2BAAA,GAAkD;AAAA,EAC7D,WAAA,EAAa;AAAA,IACX,aAAA,EAAe,CAAA;AAAA,IACf,eAAA,EAAiB;AAAA,GACnB;AAAA,EACA,YAAA,EAAc;AAAA,IACZ,sBAAA,EAAwB;AAAA,GAC1B;AAAA,EACA,SAAA,EAAW;AAAA,IACT,aAAA,EAAe,KAAA;AAAA,IACf,YAAA,EAAc;AAAA,GAChB;AAAA,EACA,uBAAA,EAAyB;AAAA,IACvB,aAAA,EAAe,CAAA;AAAA,IACf,SAAA,EAAW;AAAA,GACb;AAAA,EACA,gBAAA,EAAkB;AAAA,IAChB,aAAA,EAAe;AAAA;AAEnB;;;ACrCA,SAAS,YAAA,CAAa,KAAA,EAAe,MAAA,EAAiB,QAAA,EAAsC;AAC1F,EAAA,MAAM,EAAA,GAAK,SAAS,WAAA,CAAY,aAAA;AAChC,EAAA,MAAM,GAAA,GAAM,SAAS,WAAA,CAAY,eAAA;AACjC,EAAA,MAAM,GAAA,GAAM,SAAS,YAAA,CAAa,sBAAA;AAClC,EAAA,MAAM,SAAA,GAAYA,0CAAA,CAAyB,KAAA,EAAO,EAAA,EAAI,KAAK,GAAG,CAAA;AAC9D,EAAA,OAAO,CAAA,EAAG,MAAA,CAAO,OAAA,CAAQ,YAAY,GAAG,SAAS,CAAA,CAAA;AACnD;AAUA,SAAS,SAAA,CAAU,KAAA,EAAe,QAAA,EAA8B,IAAA,EAAuB;AAMrF,EAAA,MAAM,SAAA,GAAY,IAAA,CAAK,KAAA,CAAM,KAAK,CAAA;AAClC,EAAA,MAAM,IAAA,GAAO,SAAA,GAAY,CAAA,GAAI,GAAA,GAAM,EAAA;AACnC,EAAA,MAAM,SAAA,GAAY,IAAA,CAAK,GAAA,CAAI,SAAS,CAAA;AAEpC,EAAA,IAAI,IAAA,KAAS,OAAO,OAAO,CAAA,EAAA,EAAK,IAAI,CAAA,EAAA,EAAK,SAAA,CAAU,QAAA,CAAS,CAAC,CAAC,CAAA,CAAA;AAC9D,EAAA,IAAI,IAAA,KAAS,OAAO,OAAO,CAAA,EAAA,EAAK,IAAI,CAAA,EAAA,EAAK,SAAA,CAAU,QAAA,CAAS,CAAC,CAAC,CAAA,CAAA;AAC9D,EAAA,MAAM,UAAU,QAAA,CAAS,SAAA,CAAU,aAAA,GAAgB,QAAA,CAAS,UAAU,YAAA,GAAe,CAAA;AACrF,EAAA,MAAM,GAAA,GAAM,UAAU,QAAA,CAAS,EAAE,EAAE,WAAA,EAAY,CAAE,QAAA,CAAS,OAAA,EAAS,GAAG,CAAA;AACtE,EAAA,OAAO,CAAA,EAAA,EAAK,IAAI,CAAA,EAAA,EAAK,GAAG,CAAA,CAAA;AAC1B;AAEA,SAAS,aAAa,KAAA,EAAuB;AAC3C,EAAA,OAAO,KAAK,KAAK,CAAA,CAAA;AACnB;AAEA,SAAS,aAAa,KAAA,EAAuB;AAC3C,EAAA,OAAO,KAAK,KAAK,CAAA,CAAA;AACnB;AAEA,SAAS,cAAc,KAAA,EAAwB;AAC7C,EAAA,OAAO,KAAK,KAAK,CAAA,CAAA;AACnB;AAqBA,SAAS,cAAA,CAAe,OAAe,MAAA,EAAyB;AAC9D,EAAA,MAAM,CAAA,GAAI,IAAI,IAAA,CAAK,KAAK,CAAA;AACxB,EAAA,MAAM,OAAA,GAAU,CAAA,CAAE,kBAAA,CAAmB,MAAA,CAAO,MAAM,EAAE,OAAA,EAAS,MAAA,EAAQ,IAAA,EAAM,SAAA,EAAW,KAAA,EAAO,MAAA,EAAQ,GAAA,EAAK,WAAW,CAAA;AACrH,EAAA,MAAM,UAAA,GAAa,CAAA,CAAE,QAAA,EAAS,KAAM,KAAK,CAAA,CAAE,UAAA,EAAW,KAAM,CAAA,IAAK,EAAE,UAAA,EAAW,KAAM,CAAA,IAAK,CAAA,CAAE,iBAAgB,KAAM,CAAA;AACjH,EAAA,IAAI,UAAA,EAAY,OAAO,CAAA,EAAA,EAAK,OAAO,CAAA,CAAA;AACnC,EAAA,OAAO,KAAK,OAAO,CAAA,EAAA,EAAK,EAAE,kBAAA,CAAmB,MAAA,CAAO,IAAI,CAAC,CAAA,CAAA;AAC3D;AAUA,SAAS,iBAAiB,EAAA,EAAoB;AAC5C,EAAA,MAAM,IAAA,GAAO,EAAA,GAAK,CAAA,GAAI,GAAA,GAAM,EAAA;AAC5B,EAAA,MAAM,eAAe,IAAA,CAAK,KAAA,CAAM,KAAK,GAAA,CAAI,EAAE,IAAI,GAAI,CAAA;AACnD,EAAA,MAAM,KAAA,GAAQ,IAAA,CAAK,KAAA,CAAM,YAAA,GAAe,IAAI,CAAA;AAC5C,EAAA,MAAM,OAAA,GAAU,IAAA,CAAK,KAAA,CAAO,YAAA,GAAe,OAAQ,EAAE,CAAA;AACrD,EAAA,MAAM,UAAU,YAAA,GAAe,EAAA;AAC/B,EAAA,MAAM,KAAK,MAAA,CAAO,OAAO,CAAA,CAAE,QAAA,CAAS,GAAG,GAAG,CAAA;AAC1C,EAAA,IAAI,OAAA,KAAY,GAAG,OAAO,CAAA,EAAG,IAAI,CAAA,EAAG,KAAK,IAAI,EAAE,CAAA,CAAA;AAC/C,EAAA,MAAM,KAAK,MAAA,CAAO,OAAO,CAAA,CAAE,QAAA,CAAS,GAAG,GAAG,CAAA;AAC1C,EAAA,OAAO,GAAG,IAAI,CAAA,EAAG,KAAK,CAAA,CAAA,EAAI,EAAE,IAAI,EAAE,CAAA,CAAA;AACpC;AAEA,SAAS,SAAA,CAAU,KAAA,EAAe,IAAA,EAA0B,MAAA,EAAiB,QAAA,EAAsC;AACjH,EAAA,IAAI,SAAS,IAAA,EAAM,OAAO,CAAA,EAAA,EAAK,gBAAA,CAAiB,KAAK,CAAC,CAAA,CAAA;AAEtD,EAAA,MAAM,EAAA,GAAK,SAAS,uBAAA,CAAwB,aAAA;AAC5C,EAAA,MAAM,YAAA,GAAe,SAAS,uBAAA,CAAwB,SAAA;AAGtD,EAAA,MAAM,aAAA,GAAgB,CAAC,MAAA,EAAQ,OAAA,EAAS,OAAA,EAAS,SAAA,EAAW,SAAA,EAAW,KAAA,EAAO,MAAA,EAAQ,MAAA,EAAQ,QAAA,EAAU,QAAQ,CAAA;AAChH,EAAA,MAAM,UAAA,GAAa,IAAA,IAAQ,aAAA,CAAc,QAAA,CAAS,IAAI,CAAA;AAEtD,EAAA,IAAI,SAAA;AACJ,EAAA,IAAI,UAAA,IAAc,KAAA,KAAU,IAAA,CAAK,KAAA,CAAM,KAAK,CAAA,EAAG;AAE7C,IAAA,SAAA,GAAY,MAAM,QAAA,EAAS;AAAA,EAC7B,CAAA,MAAO;AAEL,IAAA,SAAA,GAAY,KAAA,CAAM,QAAQ,EAAE,CAAA;AAAA,EAC9B;AASA,EAAA,MAAM,kBAAkB,IAAA,GAAOC,kCAAA,CAAiB,IAAA,CAAK,WAAA,EAAa,CAAA,GAAI,MAAA;AACtE,EAAA,IAAI,eAAA,EAAiB;AACnB,IAAA,MAAM,GAAA,GAAM,eAAA,CAAgB,MAAA,GAAS,GAAA,GAAM,EAAA;AAC3C,IAAA,MAAM,aAAa,eAAA,CAAgB,QAAA,KAAa,WAC5C,CAAA,EAAG,eAAA,CAAgB,MAAM,CAAA,EAAG,GAAG,CAAA,EAAG,SAAS,KAC3C,CAAA,EAAG,SAAS,GAAG,GAAG,CAAA,EAAG,gBAAgB,MAAM,CAAA,CAAA;AAC/C,IAAA,OAAO,KAAK,UAAU,CAAA,CAAA;AAAA,EACxB;AAEA,EAAA,MAAM,SAAA,GAAY,YAAA,GAAgB,IAAA,IAAQ,EAAA,GAAO,IAAA,IAAQ,EAAA;AACzD,EAAA,OAAO,CAAA,EAAA,EAAK,SAAS,CAAA,CAAA,EAAI,SAAS,GAAG,IAAA,EAAK;AAC5C;AAEA,SAAS,iBAAA,CAAkB,OAAoB,QAAA,EAAsC;AACnF,EAAA,IAAI,OAAO,KAAA,KAAU,SAAA,EAAW,OAAO,QAAQ,MAAA,GAAS,OAAA;AACxD,EAAA,IAAI,OAAO,KAAA,KAAU,QAAA,IAAY,UAAU,IAAA,EAAM,OAAOC,iCAAe,KAAK,CAAA;AAC5E,EAAA,MAAM,EAAA,GAAK,SAAS,WAAA,CAAY,aAAA;AAChC,EAAA,MAAM,GAAA,GAAM,SAAS,WAAA,CAAY,eAAA;AACjC,EAAA,MAAM,GAAA,GAAM,SAAS,YAAA,CAAa,sBAAA;AAClC,EAAA,OAAOF,0CAAA,CAAyB,KAAA,EAAO,EAAA,EAAI,GAAA,EAAK,GAAG,CAAA;AACrD;AASA,SAAS,YAAA,CAAa,CAAA,EAAe,MAAA,EAAiB,QAAA,EAAsC;AAC1F,EAAA,MAAM,QAAA,GAAWG,wCAAsB,CAAC,CAAA;AACxC,EAAA,MAAM,OAAiB,EAAC;AACxB,EAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,CAAA,CAAE,MAAM,CAAA,EAAA,EAAK;AAC/B,IAAA,MAAM,QAAkB,EAAC;AACzB,IAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,CAAA,CAAE,MAAM,CAAA,EAAA,EAAK;AAC/B,MAAA,KAAA,CAAM,IAAA,CAAK,kBAAkB,QAAA,CAAS,CAAA,GAAI,EAAE,IAAA,GAAO,CAAC,CAAA,EAAG,QAAQ,CAAC,CAAA;AAAA,IAClE;AACA,IAAA,IAAA,CAAK,IAAA,CAAK,KAAA,CAAM,IAAA,CAAK,IAAI,CAAC,CAAA;AAAA,EAC5B;AACA,EAAA,OAAO,CAAA,EAAG,OAAO,OAAA,CAAQ,YAAY,IAAI,IAAA,CAAK,IAAA,CAAK,IAAI,CAAC,CAAA,CAAA,CAAA;AAC1D;AAEA,SAAS,WAAA,CAAY,GAAA,EAAa,GAAA,EAAa,MAAA,EAAyB;AACtE,EAAA,OAAO,GAAG,MAAA,CAAO,OAAA,CAAQ,YAAY,CAAA,EAAG,GAAG,IAAI,GAAG,CAAA,CAAA;AACpD;AAEA,SAAS,gBAAA,CAAiB,KAAA,EAAe,MAAA,EAAiB,QAAA,EAAsC;AAM9F,EAAA,MAAM,EAAA,GAAK,SAAS,gBAAA,CAAiB,aAAA;AACrC,EAAA,MAAM,SAAA,GAAA,CAAa,KAAA,GAAQ,GAAA,EAAK,OAAA,CAAQ,EAAE,CAAA;AAC1C,EAAA,OAAO,CAAA,EAAA,EAAK,SAAS,CAAA,EAAG,MAAA,CAAO,QAAQ,gBAAgB,CAAA,CAAA;AACzD;AAEA,SAAS,UAAA,CAAW,OAAe,IAAA,EAAkC;AACnE,EAAA,OAAO,KAAK,KAAK,CAAA,CAAA,EAAI,IAAA,IAAQ,EAAE,GAAG,IAAA,EAAK;AACzC;AAqBO,SAAS,WAAA,CAAY,OAAc,QAAA,EAAuC;AAC/E,EAAA,MAAM,KAAK,QAAA,IAAY,2BAAA;AACvB,EAAA,MAAM,UAAA,GAAa,EAAA,CAAG,YAAA,CAAa,sBAAA,IAA0B,IAAA;AAC7D,EAAA,MAAM,MAAA,GAASC,4BAAU,UAAU,CAAA;AAEnC,EAAA,QAAQ,MAAM,IAAA;AAAM,IAClB,KAAA,CAAA;AACE,MAAA,OAAO,YAAA,CAAa,KAAA,CAAM,KAAA,EAAiB,MAAA,EAAQ,EAAE,CAAA;AAAA,IACvD,KAAA,CAAA;AACE,MAAA,OAAO,SAAA,CAAU,KAAA,CAAM,KAAA,EAAiB,EAAA,EAAI,MAAM,IAAI,CAAA;AAAA,IACxD,KAAA,CAAA;AACE,MAAA,OAAO,YAAA,CAAa,MAAM,KAAe,CAAA;AAAA,IAC3C,KAAA,CAAA;AACE,MAAA,OAAO,YAAA,CAAa,MAAM,KAAe,CAAA;AAAA,IAC3C,KAAA,EAAA;AACE,MAAA,OAAO,aAAA,CAAc,MAAM,KAAgB,CAAA;AAAA,IAC7C,KAAA,CAAA;AACE,MAAA,OAAO,cAAA,CAAe,KAAA,CAAM,KAAA,EAAiB,MAAM,CAAA;AAAA,IACrD,KAAA,CAAA;AACE,MAAA,OAAO,UAAU,KAAA,CAAM,KAAA,EAAiB,KAAA,CAAM,IAAA,EAAM,QAAQ,EAAE,CAAA;AAAA,IAChE,KAAA,CAAA;AACE,MAAA,OAAO,YAAA,CAAa,KAAA,CAAM,KAAA,EAAqB,MAAA,EAAQ,EAAE,CAAA;AAAA,IAC3D,KAAA,CAAA,cAAsB;AACpB,MAAA,MAAM,IAAI,KAAA,CAAM,KAAA;AAChB,MAAA,OAAO,WAAA,CAAY,CAAA,CAAE,GAAA,EAAK,CAAA,CAAE,KAAK,MAAM,CAAA;AAAA,IACzC;AAAA,IACA,KAAA,CAAA;AACE,MAAA,OAAOF,gCAAA,CAAe,MAAM,KAAqB,CAAA;AAAA,IACnD,KAAA,CAAA;AACE,MAAA,OAAO,gBAAA,CAAiB,KAAA,CAAM,KAAA,EAAiB,MAAA,EAAQ,EAAE,CAAA;AAAA,IAC3D,KAAA,EAAA;AACE,MAAA,OAAO,UAAA,CAAW,KAAA,CAAM,KAAA,EAAiB,KAAA,CAAM,IAAI,CAAA;AAAA,IACrD,KAAA,EAAA;AAKE,MAAA,OAAO,KAAA,CAAM,IAAA,IAAQ,MAAA,CAAO,KAAA,CAAM,KAAK,CAAA;AAAA,IACzC;AACE,MAAA,OAAO,CAAA,EAAA,EAAK,MAAA,CAAO,KAAA,CAAM,KAAK,CAAC,CAAA,CAAA;AAAA;AAErC","file":"format.cjs","sourcesContent":["/**\n * Minimal formatting settings interface for the engine\n * This allows the engine to format values without depending on app-specific settings\n */\nexport interface FormattingSettings {\n  floatResult: {\n    decimalPlaces: number;\n    enableSeperator: boolean;\n  };\n  numberResult: {\n    decimalSeparatorLocale: string;\n  };\n  hexResult: {\n    enablePadding: boolean;\n    paddingZeros: number;\n  };\n  unitOfMeasurementResult: {\n    decimalPlaces: number;\n    unitNames: boolean;\n  };\n  percentageResult: {\n    decimalPlaces: number;\n  };\n}\n\n/** Formatting used when a host supplies none. */\nexport const DEFAULT_FORMATTING_SETTINGS: FormattingSettings = {\n  floatResult: {\n    decimalPlaces: 2,\n    enableSeperator: true,\n  },\n  numberResult: {\n    decimalSeparatorLocale: \"en-US\",\n  },\n  hexResult: {\n    enablePadding: false,\n    paddingZeros: 0,\n  },\n  unitOfMeasurementResult: {\n    decimalPlaces: 2,\n    unitNames: true,\n  },\n  percentageResult: {\n    decimalPlaces: 2,\n  },\n};\n","import { Value, ValueType, type MatrixData, type MatrixEntry, type RangeData } from \"@solve-js/vm/Value\";\nimport { getLocale, type ILocale } from \"@solve-js/constants/locales\";\nimport { autoFormatIntegerOrFloat } from \"@solve-js/utilities/Number\";\nimport { FormattingSettings, DEFAULT_FORMATTING_SETTINGS } from \"./FormattingSettings\";\nimport { CURRENCY_DISPLAY } from \"@solve-js/uom/CurrencyAliases\";\nimport { columnMajorToRowMajor } from \"@solve-js/vm/MatrixOps\";\nimport { formatSymbolic, type SymbolicNode } from \"@solve-js/symbolic\";\n\nfunction formatNumber(value: number, locale: ILocale, settings: FormattingSettings): string {\n  const dp = settings.floatResult.decimalPlaces;\n  const sep = settings.floatResult.enableSeperator;\n  const loc = settings.numberResult.decimalSeparatorLocale;\n  const formatted = autoFormatIntegerOrFloat(value, dp, sep, loc);\n  return `${locale.display.resultPrefix}${formatted}`;\n}\n\n/**\n * Renders a number in whichever base it is tagged with.\n *\n * The zero padding is a hexadecimal setting and stays one. Applying it to a\n * binary rendering would pad `0b101` out to the same digit count as a hex\n * value, which is a different quantity of zeros and not what the setting asks\n * for.\n */\nfunction formatHex(value: number, settings: FormattingSettings, base?: string): string {\n  // Truncate and take the sign off before converting. `Number.toString(radix)`\n  // does neither: it renders -255 as \"-ff\", which lands the minus inside the\n  // literal as `0x-FF`, and it renders 255.7 as \"ff.b3333333333\", inventing\n  // fractional hex digits for a notation that has no use for them. Both were\n  // visible on `as hex` until the builtins started sharing this path.\n  const truncated = Math.trunc(value);\n  const sign = truncated < 0 ? \"-\" : \"\";\n  const magnitude = Math.abs(truncated);\n\n  if (base === \"bin\") return `= ${sign}0b${magnitude.toString(2)}`;\n  if (base === \"oct\") return `= ${sign}0o${magnitude.toString(8)}`;\n  const padding = settings.hexResult.enablePadding ? settings.hexResult.paddingZeros : 0;\n  const hex = magnitude.toString(16).toUpperCase().padStart(padding, \"0\");\n  return `= ${sign}0x${hex}`;\n}\n\nfunction formatBigInt(value: bigint): string {\n  return `= ${value}`;\n}\n\nfunction formatString(value: string): string {\n  return `= ${value}`;\n}\n\nfunction formatBoolean(value: boolean): string {\n  return `= ${value}`;\n}\n\n/**\n * Renders a Datetime value locale-aware, the previous implementation\n * called `d.toLocaleString()` with no arguments, which always uses the JS\n * runtime's own default locale and never actually consulted `locale.code`\n * despite receiving it as a parameter (both branches of its old\n * `dateFormat === \"default\"` check were byte-for-byte identical, dead\n * groundwork for a distinction that was never implemented). Concretely,\n * this meant every configured locale (including the shipped German one)\n * always displayed weekday/month names in English. See GitHub issue #77.\n *\n * Uses `weekday`/`month`: \"long\" for a spelled-out date (\"Monday,\n * November 17, 2025\" / \"lundi 17 novembre 2025\") since that's what a\n * literal weekday name is for; a bare numeric date doesn't need\n * localizing beyond the decimal/thousands separators `formatNumber()`\n * already handles. The time-of-day portion is only appended when it's\n * not exactly local midnight, bare date literals (\"today\", \"17/11/2025\")\n * always anchor to local midnight, and showing \"00:00:00\" on every one of\n * those would be noise, not information.\n */\nfunction formatDatetime(value: number, locale: ILocale): string {\n  const d = new Date(value);\n  const dateStr = d.toLocaleDateString(locale.code, { weekday: \"long\", year: \"numeric\", month: \"long\", day: \"numeric\" });\n  const isMidnight = d.getHours() === 0 && d.getMinutes() === 0 && d.getSeconds() === 0 && d.getMilliseconds() === 0;\n  if (isMidnight) return `= ${dateStr}`;\n  return `= ${dateStr}, ${d.toLocaleTimeString(locale.code)}`;\n}\n\n/**\n * Renders a millisecond duration as clock-style `H:MM` (or `H:MM:SS` when\n * there's a non-zero seconds component). `ms` is never a user-typeable\n * unit (confirmed: it appears nowhere in `lexer/units.ts`), it's only\n * ever produced by subtracting two clock times/datetimes (`9:30 - 8:30`,\n * `VM.ts`'s Datetime SUB case), so this is a safe, narrow special case,\n * not a general change to how durations display.\n */\nfunction formatMsDuration(ms: number): string {\n  const sign = ms < 0 ? \"-\" : \"\";\n  const totalSeconds = Math.round(Math.abs(ms) / 1000);\n  const hours = Math.floor(totalSeconds / 3600);\n  const minutes = Math.floor((totalSeconds % 3600) / 60);\n  const seconds = totalSeconds % 60;\n  const mm = String(minutes).padStart(2, \"0\");\n  if (seconds === 0) return `${sign}${hours}:${mm}`;\n  const ss = String(seconds).padStart(2, \"0\");\n  return `${sign}${hours}:${mm}:${ss}`;\n}\n\nfunction formatUom(value: number, unit: string | undefined, locale: ILocale, settings: FormattingSettings): string {\n  if (unit === \"ms\") return `= ${formatMsDuration(value)}`;\n\n  const dp = settings.unitOfMeasurementResult.decimalPlaces;\n  const useUnitNames = settings.unitOfMeasurementResult.unitNames;\n\n  // For TimeSpan values (days, weeks, hours, etc.), format as integer if the value is a whole number\n  const timeSpanUnits = [\"days\", \"weeks\", \"hours\", \"minutes\", \"seconds\", \"day\", \"week\", \"hour\", \"minute\", \"second\"];\n  const isTimeSpan = unit && timeSpanUnits.includes(unit);\n\n  let formatted: string;\n  if (isTimeSpan && value === Math.floor(value)) {\n    // For whole number TimeSpan values, format as integer\n    formatted = value.toString();\n  } else {\n    // For other values, use the configured decimal places\n    formatted = value.toFixed(dp);\n  }\n\n  // Currency display: symbol + culturally-conventional placement (e.g.\n  // \"$100.00\" prefix vs \"100.00 kr\" suffix) instead of the generic\n  // \"amount CODE\" fallback below. See uom/CurrencyAliases.ts's\n  // CURRENCY_DISPLAY table for the exact set covered and the reasoning\n  // behind each placement choice. Any currency code NOT in that table\n  // (most of the ~150 `CurrencyExchange.isCurrency()` recognizes) falls\n  // through to the unchanged \"amount CODE\" format below.\n  const currencyDisplay = unit ? CURRENCY_DISPLAY[unit.toUpperCase()] : undefined;\n  if (currencyDisplay) {\n    const sep = currencyDisplay.spaced ? \" \" : \"\";\n    const withSymbol = currencyDisplay.position === \"prefix\"\n      ? `${currencyDisplay.symbol}${sep}${formatted}`\n      : `${formatted}${sep}${currencyDisplay.symbol}`;\n    return `= ${withSymbol}`;\n  }\n\n  const unitLabel = useUnitNames ? (unit || \"\") : (unit || \"\");\n  return `= ${formatted} ${unitLabel}`.trim();\n}\n\nfunction formatMatrixEntry(entry: MatrixEntry, settings: FormattingSettings): string {\n  if (typeof entry === \"boolean\") return entry ? \"true\" : \"false\";\n  if (typeof entry === \"object\" && entry !== null) return formatSymbolic(entry);\n  const dp = settings.floatResult.decimalPlaces;\n  const sep = settings.floatResult.enableSeperator;\n  const loc = settings.numberResult.decimalSeparatorLocale;\n  return autoFormatIntegerOrFloat(entry, dp, sep, loc);\n}\n\n/**\n * Renders a Matrix matching its own literal syntax: a single row (1xN,\n * including plain vectors) as `[a, b, c]`, a single column (Nx1) as\n * `[a; b; c]`, and a general shape as `[r0c0, r0c1; r1c0, r1c1]`, row-major\n * textual output read back out of the column-major storage\n * (`columnMajorToRowMajor()`), matching how `[1,2;3,4]` is written.\n */\nfunction formatMatrix(m: MatrixData, locale: ILocale, settings: FormattingSettings): string {\n  const rowMajor = columnMajorToRowMajor(m);\n  const rows: string[] = [];\n  for (let r = 0; r < m.rows; r++) {\n    const cells: string[] = [];\n    for (let c = 0; c < m.cols; c++) {\n      cells.push(formatMatrixEntry(rowMajor[r * m.cols + c], settings));\n    }\n    rows.push(cells.join(\", \"));\n  }\n  return `${locale.display.resultPrefix}[${rows.join(\"; \")}]`;\n}\n\nfunction formatRange(min: number, max: number, locale: ILocale): string {\n  return `${locale.display.resultPrefix}${min}:${max}`;\n}\n\nfunction formatPercentage(value: number, locale: ILocale, settings: FormattingSettings): string {\n  // ValueType.Percentage stores a fraction (0.25 for 25%). See Value.ts's\n  // documented contract and the sole producer, VM.ts's TO_PERCENTAGE opcode\n  // (`right/left - 1`, e.g. 0.25 for \"800 to 1000\"). Multiply by 100 before\n  // formatting; without this every percentage-change result displayed as\n  // e.g. \"0.25%\" instead of \"25.00%\".\n  const dp = settings.percentageResult.decimalPlaces;\n  const formatted = (value * 100).toFixed(dp);\n  return `= ${formatted}${locale.display.percentageSuffix}`;\n}\n\nfunction formatUnit(value: number, unit: string | undefined): string {\n  return `= ${value} ${unit || \"\"}`.trim();\n}\n\n/**\n * Render an evaluated {@link Value} as a display string, dispatching on\n * `value.type` to the type-specific formatter (number, hex, datetime, unit\n * of measurement, matrix, range, percentage, ...).\n *\n * Most branches produce a `\"= \"`-prefixed result string (matching the\n * plugin's inline-result convention); `ValueType.Error` is the one\n * exception, it returns the human-readable error message directly\n * (stored in `value.unit`), not an `\"= \"`-prefixed string.\n *\n * @param value - The evaluated value to format.\n * @param settings - Locale/precision/separator options; defaults to\n *   {@link DEFAULT_FORMATTING_SETTINGS} when omitted.\n * @example\n * ```typescript\n * const [value] = engine.evaluateExpression(\"10 USD to GBP\");\n * formatValue(value); // \"= £7.85\" (exact output depends on live exchange rates)\n * ```\n */\nexport function formatValue(value: Value, settings?: FormattingSettings): string {\n  const us = settings || DEFAULT_FORMATTING_SETTINGS;\n  const localeCode = us.numberResult.decimalSeparatorLocale || \"en\";\n  const locale = getLocale(localeCode);\n\n  switch (value.type) {\n    case ValueType.Number:\n      return formatNumber(value.value as number, locale, us);\n    case ValueType.Hex:\n      return formatHex(value.value as number, us, value.unit);\n    case ValueType.BigInt:\n      return formatBigInt(value.value as bigint);\n    case ValueType.String:\n      return formatString(value.value as string);\n    case ValueType.Boolean:\n      return formatBoolean(value.value as boolean);\n    case ValueType.Datetime:\n      return formatDatetime(value.value as number, locale);\n    case ValueType.Uom:\n      return formatUom(value.value as number, value.unit, locale, us);\n    case ValueType.Matrix:\n      return formatMatrix(value.value as MatrixData, locale, us);\n    case ValueType.Range: {\n      const r = value.value as RangeData;\n      return formatRange(r.min, r.max, locale);\n    }\n    case ValueType.Symbolic:\n      return formatSymbolic(value.value as SymbolicNode);\n    case ValueType.Percentage:\n      return formatPercentage(value.value as number, locale, us);\n    case ValueType.Unit:\n      return formatUnit(value.value as number, value.unit);\n    case ValueType.Error:\n      // errorValue(code, message) stores the human-readable message in\n      // `.unit` (code goes in `.value`), falling through to the default\n      // case here previously displayed the raw code (e.g.\n      // \"CURRENCY_RATE_UNAVAILABLE\") instead of the actual message.\n      return value.unit ?? String(value.value);\n    default:\n      return `= ${String(value.value)}`;\n  }\n}\n"]}

package/dist/format.d.cts

@@ -0,0 +1,51 @@
+import { V as Value } from './Value-KtAQNHur.cjs';
+
+/**
+ * Minimal formatting settings interface for the engine
+ * This allows the engine to format values without depending on app-specific settings
+ */
+interface FormattingSettings {
+    floatResult: {
+        decimalPlaces: number;
+        enableSeperator: boolean;
+    };
+    numberResult: {
+        decimalSeparatorLocale: string;
+    };
+    hexResult: {
+        enablePadding: boolean;
+        paddingZeros: number;
+    };
+    unitOfMeasurementResult: {
+        decimalPlaces: number;
+        unitNames: boolean;
+    };
+    percentageResult: {
+        decimalPlaces: number;
+    };
+}
+/** Formatting used when a host supplies none. */
+declare const DEFAULT_FORMATTING_SETTINGS: FormattingSettings;
+
+/**
+ * Render an evaluated {@link Value} as a display string, dispatching on
+ * `value.type` to the type-specific formatter (number, hex, datetime, unit
+ * of measurement, matrix, range, percentage, ...).
+ *
+ * Most branches produce a `"= "`-prefixed result string (matching the
+ * plugin's inline-result convention); `ValueType.Error` is the one
+ * exception, it returns the human-readable error message directly
+ * (stored in `value.unit`), not an `"= "`-prefixed string.
+ *
+ * @param value - The evaluated value to format.
+ * @param settings - Locale/precision/separator options; defaults to
+ *   {@link DEFAULT_FORMATTING_SETTINGS} when omitted.
+ * @example
+ * ```typescript
+ * const [value] = engine.evaluateExpression("10 USD to GBP");
+ * formatValue(value); // "= £7.85" (exact output depends on live exchange rates)
+ * ```
+ */
+declare function formatValue(value: Value, settings?: FormattingSettings): string;
+
+export { DEFAULT_FORMATTING_SETTINGS, type FormattingSettings, formatValue };

package/dist/format.d.ts

@@ -0,0 +1,51 @@
+import { V as Value } from './Value-KtAQNHur.js';
+
+/**
+ * Minimal formatting settings interface for the engine
+ * This allows the engine to format values without depending on app-specific settings
+ */
+interface FormattingSettings {
+    floatResult: {
+        decimalPlaces: number;
+        enableSeperator: boolean;
+    };
+    numberResult: {
+        decimalSeparatorLocale: string;
+    };
+    hexResult: {
+        enablePadding: boolean;
+        paddingZeros: number;
+    };
+    unitOfMeasurementResult: {
+        decimalPlaces: number;
+        unitNames: boolean;
+    };
+    percentageResult: {
+        decimalPlaces: number;
+    };
+}
+/** Formatting used when a host supplies none. */
+declare const DEFAULT_FORMATTING_SETTINGS: FormattingSettings;
+
+/**
+ * Render an evaluated {@link Value} as a display string, dispatching on
+ * `value.type` to the type-specific formatter (number, hex, datetime, unit
+ * of measurement, matrix, range, percentage, ...).
+ *
+ * Most branches produce a `"= "`-prefixed result string (matching the
+ * plugin's inline-result convention); `ValueType.Error` is the one
+ * exception, it returns the human-readable error message directly
+ * (stored in `value.unit`), not an `"= "`-prefixed string.
+ *
+ * @param value - The evaluated value to format.
+ * @param settings - Locale/precision/separator options; defaults to
+ *   {@link DEFAULT_FORMATTING_SETTINGS} when omitted.
+ * @example
+ * ```typescript
+ * const [value] = engine.evaluateExpression("10 USD to GBP");
+ * formatValue(value); // "= £7.85" (exact output depends on live exchange rates)
+ * ```
+ */
+declare function formatValue(value: Value, settings?: FormattingSettings): string;
+
+export { DEFAULT_FORMATTING_SETTINGS, type FormattingSettings, formatValue };