@danielsimonjr/mathts-expression 0.7.1 → 0.8.1

package/dist/utils/latex.d.ts

@@ -0,0 +1,452 @@
+import type { MathNode } from '../node/Node.js';
+export declare const latexSymbols: {
+    Alpha: string;
+    alpha: string;
+    Beta: string;
+    beta: string;
+    Gamma: string;
+    gamma: string;
+    Delta: string;
+    delta: string;
+    Epsilon: string;
+    epsilon: string;
+    varepsilon: string;
+    Zeta: string;
+    zeta: string;
+    Eta: string;
+    eta: string;
+    Theta: string;
+    theta: string;
+    vartheta: string;
+    Iota: string;
+    iota: string;
+    Kappa: string;
+    kappa: string;
+    varkappa: string;
+    Lambda: string;
+    lambda: string;
+    Mu: string;
+    mu: string;
+    Nu: string;
+    nu: string;
+    Xi: string;
+    xi: string;
+    Omicron: string;
+    omicron: string;
+    Pi: string;
+    pi: string;
+    varpi: string;
+    Rho: string;
+    rho: string;
+    varrho: string;
+    Sigma: string;
+    sigma: string;
+    varsigma: string;
+    Tau: string;
+    tau: string;
+    Upsilon: string;
+    upsilon: string;
+    Phi: string;
+    phi: string;
+    varphi: string;
+    Chi: string;
+    chi: string;
+    Psi: string;
+    psi: string;
+    Omega: string;
+    omega: string;
+    true: string;
+    false: string;
+    i: string;
+    inf: string;
+    Inf: string;
+    infinity: string;
+    Infinity: string;
+    oo: string;
+    lim: string;
+    undefined: string;
+};
+export declare const latexOperators: {
+    transpose: string;
+    ctranspose: string;
+    factorial: string;
+    pow: string;
+    dotPow: string;
+    unaryPlus: string;
+    unaryMinus: string;
+    bitNot: string;
+    not: string;
+    multiply: string;
+    divide: string;
+    dotMultiply: string;
+    dotDivide: string;
+    mod: string;
+    add: string;
+    subtract: string;
+    to: string;
+    leftShift: string;
+    rightArithShift: string;
+    rightLogShift: string;
+    equal: string;
+    unequal: string;
+    smaller: string;
+    larger: string;
+    smallerEq: string;
+    largerEq: string;
+    bitAnd: string;
+    bitXor: string;
+    bitOr: string;
+    and: string;
+    xor: string;
+    or: string;
+};
+export declare const latexFunctions: {
+    abs: {
+        1: string;
+    };
+    add: {
+        2: string;
+    };
+    cbrt: {
+        1: string;
+    };
+    ceil: {
+        1: string;
+    };
+    cube: {
+        1: string;
+    };
+    divide: {
+        2: string;
+    };
+    dotDivide: {
+        2: string;
+    };
+    dotMultiply: {
+        2: string;
+    };
+    dotPow: {
+        2: string;
+    };
+    exp: {
+        1: string;
+    };
+    expm1: string;
+    fix: {
+        1: string;
+    };
+    floor: {
+        1: string;
+    };
+    fraction: {
+        2: string;
+    };
+    gcd: string;
+    hypot: string;
+    log: {
+        1: string;
+        2: string;
+    };
+    log10: {
+        1: string;
+    };
+    log1p: {
+        1: string;
+        2: string;
+    };
+    log2: string;
+    mod: {
+        2: string;
+    };
+    multiply: {
+        2: string;
+    };
+    norm: {
+        1: string;
+        2: string | undefined;
+    };
+    nthRoot: {
+        2: string;
+    };
+    nthRoots: {
+        2: string;
+    };
+    pow: {
+        2: string;
+    };
+    round: {
+        1: string;
+        2: string | undefined;
+    };
+    sign: {
+        1: string;
+    };
+    sqrt: {
+        1: string;
+    };
+    square: {
+        1: string;
+    };
+    subtract: {
+        2: string;
+    };
+    unaryMinus: {
+        1: string;
+    };
+    unaryPlus: {
+        1: string;
+    };
+    bitAnd: {
+        2: string;
+    };
+    bitNot: {
+        1: string;
+    };
+    bitOr: {
+        2: string;
+    };
+    bitXor: {
+        2: string;
+    };
+    leftShift: {
+        2: string;
+    };
+    rightArithShift: {
+        2: string;
+    };
+    rightLogShift: {
+        2: string;
+    };
+    bellNumbers: {
+        1: string;
+    };
+    catalan: {
+        1: string;
+    };
+    stirlingS2: {
+        2: string;
+    };
+    arg: {
+        1: string;
+    };
+    conj: {
+        1: string;
+    };
+    im: {
+        1: string;
+    };
+    re: {
+        1: string;
+    };
+    and: {
+        2: string;
+    };
+    not: {
+        1: string;
+    };
+    or: {
+        2: string;
+    };
+    xor: {
+        2: string;
+    };
+    cross: {
+        2: string;
+    };
+    ctranspose: {
+        1: string;
+    };
+    det: {
+        1: string;
+    };
+    dot: {
+        2: string;
+    };
+    expm: {
+        1: string;
+    };
+    inv: {
+        1: string;
+    };
+    pinv: {
+        1: string;
+    };
+    sqrtm: {
+        1: string;
+    };
+    trace: {
+        1: string;
+    };
+    transpose: {
+        1: string;
+    };
+    combinations: {
+        2: string;
+    };
+    combinationsWithRep: {
+        2: string;
+    };
+    factorial: {
+        1: string;
+    };
+    gamma: {
+        1: string;
+    };
+    lgamma: {
+        1: string;
+    };
+    equal: {
+        2: string;
+    };
+    larger: {
+        2: string;
+    };
+    largerEq: {
+        2: string;
+    };
+    smaller: {
+        2: string;
+    };
+    smallerEq: {
+        2: string;
+    };
+    unequal: {
+        2: string;
+    };
+    erf: {
+        1: string;
+    };
+    max: string;
+    min: string;
+    variance: string;
+    acos: {
+        1: string;
+    };
+    acosh: {
+        1: string;
+    };
+    acot: {
+        1: string;
+    };
+    acoth: {
+        1: string;
+    };
+    acsc: {
+        1: string;
+    };
+    acsch: {
+        1: string;
+    };
+    asec: {
+        1: string;
+    };
+    asech: {
+        1: string;
+    };
+    asin: {
+        1: string;
+    };
+    asinh: {
+        1: string;
+    };
+    atan: {
+        1: string;
+    };
+    atan2: {
+        2: string;
+    };
+    atanh: {
+        1: string;
+    };
+    cos: {
+        1: string;
+    };
+    cosh: {
+        1: string;
+    };
+    cot: {
+        1: string;
+    };
+    coth: {
+        1: string;
+    };
+    csc: {
+        1: string;
+    };
+    csch: {
+        1: string;
+    };
+    sec: {
+        1: string;
+    };
+    sech: {
+        1: string;
+    };
+    sin: {
+        1: string;
+    };
+    sinh: {
+        1: string;
+    };
+    tan: {
+        1: string;
+    };
+    tanh: {
+        1: string;
+    };
+    to: {
+        2: string;
+    };
+    numeric: (node: MathNode, _options?: unknown) => string;
+    number: {
+        0: string;
+        1: string;
+        2: string;
+    };
+    string: {
+        0: string;
+        1: string;
+    };
+    bignumber: {
+        0: string;
+        1: string;
+    };
+    bigint: {
+        0: string;
+        1: string;
+    };
+    complex: {
+        0: string;
+        1: string;
+        2: string;
+    };
+    matrix: {
+        0: string;
+        1: string;
+        2: string;
+    };
+    sparse: {
+        0: string;
+        1: string;
+    };
+    unit: {
+        1: string;
+        2: string;
+    };
+};
+export declare const defaultTemplate = "\\mathrm{${name}}\\left(${args}\\right)";
+/**
+ * Escape the LaTeX special characters in a string.
+ * This function calls the `escape-latex` package with `preserveFormatting: true`.
+ * @param string - The text to escape.
+ */
+export declare function escapeLatex(string: string): any;
+/**
+ * Convert a name to its LaTeX form.
+ * If `isUnit` is truthy, a known unit (only `deg`) gets its symbol, and other names get `\mathrm{...}`.
+ * If not, a known symbol name gets its LaTeX symbol, and other names are escaped.
+ * @param name - The symbol or unit name.
+ * @param isUnit - Optional. Set to a truthy value for a unit name. Default is `false`.
+ */
+export declare function toSymbol(name: string, isUnit?: unknown): any;
+//# sourceMappingURL=latex.d.ts.map

package/dist/utils/latex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"latex.d.ts","sourceRoot":"","sources":["../../src/utils/latex.ts"],"names":[],"mappings":"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"}

package/dist/utils/map.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A `Map`-facade over a bare object (`ObjectWrappingMap`), a two-partition
+ * `Map` (`PartitionedMap`), and small `Map`/object interop helpers
+ * (`createMap`/`createEmptyMap`/`toObject`/`assign`).
+ *
+ * Consolidated onto core: the implementation lives once in
+ * `@danielsimonjr/mathts-core/internal` (see `core/src/map.ts` and the
+ * `project-all-libraries-build-on-core` principle). Thin re-export so existing
+ * `../utils/map.js` imports keep working while the single source of truth lives
+ * in core. Proven equivalent to the prior local copy (and to `functions`'s copy)
+ * via a fast-check property harness before the redirect — see
+ * `functions/tests/dedup-bucketB-equivalence.test.ts`.
+ *
+ * TWO divergences were found and reconciled onto core (see `core/src/map.ts`'s
+ * header for the full writeup):
+ *  1. `[Symbol.iterator]` — THIS package's prior copy assigned it dynamically via
+ *     a type-erasing cast, which type-checked but was a latent `implements Map<K,
+ *     V>` lie (TS2420 downstream under `skipLibCheck: false`). core's canonical
+ *     uses `functions`'s already-fixed, correctly-typed version — a genuine
+ *     bug fix, not a style change, and this redirect FIXES the latent bug here.
+ *  2. `createEmptyMap`/`createMap`'s generic default (`K = string` here vs.
+ *     `K = unknown` in `functions`) — a compile-time-only inference default with
+ *     no behavioral difference; reconciled to `K = string` (this package's
+ *     original default, matching `ObjectWrappingMap`/`PartitionedMap`'s own
+ *     `K = string` default already shared by both packages).
+ *
+ * `toObject` is consumed by `expression/src/Parser.ts` and re-exported here;
+ * `functions` never had it and doesn't get it in its own shim.
+ */
+export { ObjectWrappingMap, PartitionedMap, createEmptyMap, createMap, toObject, assignMap as assign, isObjectWrappingMap, } from '@danielsimonjr/mathts-core/internal';
+//# sourceMappingURL=map.d.ts.map

package/dist/utils/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/utils/map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,SAAS,EACT,QAAQ,EACR,SAAS,IAAI,MAAM,EACnB,mBAAmB,GACpB,MAAM,qCAAqC,CAAC"}

package/dist/utils/mathml.d.ts

@@ -0,0 +1,26 @@
+/**
+ * MathML rendering helpers — the MathML analog of `utils/latex.ts`. Shared by
+ * the per-node `_toMathML()` methods (mirroring how `utils/latex.ts` serves the
+ * per-node `_toTex()` methods). Browsers typeset MathML natively, so the output
+ * is self-contained (no fonts/JS/CDN).
+ */
+/** Escape text for a MathML/HTML text node. */
+export declare function escapeMathML(s: string): string;
+/** A symbol name → `<mi>` (Greek-mapped), or `name_sub` → `<msub>` (MathML analog of toSymbol). */
+export declare function toMathMLSymbol(name: string): string;
+/** A finite number → `<mn>`, with `8.85e-12` → mantissa × 10⁻¹². */
+export declare function numberToMathML(value: number): string;
+/** A ConstantNode value → MathML (number/bigint/boolean/string/other). */
+export declare function constantToMathML(value: unknown): string;
+/** The inline `<mo>` glyph for a binary operator fn (falls back to its `op`). */
+export declare function inlineOperator(fn: string, op: string): string;
+/** Wrap an already-rendered child fragment in parens when it is a lower-precedence
+ * operator under `parentFn` (so `(a+b)*c` reads correctly inline). */
+export declare function parenthesizeLower(childFragment: string, childFn: string | undefined, parentFn: string): string;
+/** Wrap a MathML fragment (e.g. from `node.toMathML()`) in a `<math>` element. */
+export declare function mathMLDocument(node: {
+    toMathML(): string;
+}): string;
+/** A `<math>` element reporting a parse/render failure (escaped source). */
+export declare function mathMLError(src: string): string;
+//# sourceMappingURL=mathml.d.ts.map

package/dist/utils/mathml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mathml.d.ts","sourceRoot":"","sources":["../../src/utils/mathml.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA0EH,+CAA+C;AAC/C,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE9C;AAMD,mGAAmG;AACnG,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CASnD;AAED,oEAAoE;AACpE,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAWpD;AAED,0EAA0E;AAC1E,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAOvD;AAED,iFAAiF;AACjF,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED;sEACsE;AACtE,wBAAgB,iBAAiB,CAC/B,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,QAAQ,EAAE,MAAM,GACf,MAAM,CAOR;AAID,kFAAkF;AAClF,wBAAgB,cAAc,CAAC,IAAI,EAAE;IAAE,QAAQ,IAAI,MAAM,CAAA;CAAE,GAAG,MAAM,CAEnE;AAED,4EAA4E;AAC5E,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C"}

package/dist/utils/number.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Number formatting, parsing, and Math polyfills.
+ *
+ * Consolidated onto core: the implementations live once in
+ * `@danielsimonjr/mathts-core/internal` (see the `project-all-libraries-build-on-core`
+ * principle). Thin re-export so existing `../utils/number.js` imports keep working
+ * while the single source of truth lives in core.
+ */
+export { acosh, asinh, atanh, cbrt, copysign, cosh, digits, expm1, format, isInteger, log10, log1p, log2, nearlyEqual, normalizeFormatOptions, roundDigits, safeNumberType, sign, sinh, splitNumber, tanh, toEngineering, toExponential, toFixed, toPrecision, } from '@danielsimonjr/mathts-core/internal';
+export type { FormatOptions, NormalizedFormatOptions, NumberTypeConfig, SplitValue, } from '@danielsimonjr/mathts-core/internal';
+//# sourceMappingURL=number.d.ts.map

package/dist/utils/number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../src/utils/number.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,IAAI,EACJ,MAAM,EACN,KAAK,EACL,MAAM,EACN,SAAS,EACT,KAAK,EACL,KAAK,EACL,IAAI,EACJ,WAAW,EACX,sBAAsB,EACtB,WAAW,EACX,cAAc,EACd,IAAI,EACJ,IAAI,EACJ,WAAW,EACX,IAAI,EACJ,aAAa,EACb,aAAa,EACb,OAAO,EACP,WAAW,GACZ,MAAM,qCAAqC,CAAC;AAC7C,YAAY,EACV,aAAa,EACb,uBAAuB,EACvB,gBAAgB,EAChB,UAAU,GACX,MAAM,qCAAqC,CAAC"}

package/dist/utils/object.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Object cloning, extension, deep-equality, and traversal helpers.
+ *
+ * Consolidated onto core: the implementations live once in
+ * `@danielsimonjr/mathts-core/internal` (see `number.ts` and the
+ * `project-all-libraries-build-on-core` principle). Thin re-export so existing
+ * `../utils/object.js` imports keep working while the single source lives in core.
+ */
+export { canDefineProperty, clone, deepExtend, deepFlatten, deepStrictEqual, extend, get, hasOwnProperty, isLegacyFactory, lazy, mapObject, pick, pickShallow, set, traverse, } from '@danielsimonjr/mathts-core/internal';
+//# sourceMappingURL=object.d.ts.map

package/dist/utils/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../src/utils/object.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EACL,iBAAiB,EACjB,KAAK,EACL,UAAU,EACV,WAAW,EACX,eAAe,EACf,MAAM,EACN,GAAG,EACH,cAAc,EACd,eAAe,EACf,IAAI,EACJ,SAAS,EACT,IAAI,EACJ,WAAW,EACX,GAAG,EACH,QAAQ,GACT,MAAM,qCAAqC,CAAC"}

package/dist/utils/print.d.ts

@@ -0,0 +1,2 @@
+export declare const printTemplate: RegExp;
+//# sourceMappingURL=print.d.ts.map

package/dist/utils/print.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print.d.ts","sourceRoot":"","sources":["../../src/utils/print.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,QAAgB,CAAC"}

package/dist/utils/scope.d.ts

@@ -0,0 +1,16 @@
+import { PartitionedMap } from './map.js';
+/**
+ * Create a new scope which can access the parent scope,
+ * but does not affect it when written. This is suitable for variable definitions
+ * within a block node, or function definition.
+ *
+ * If parent scope has a createSubScope method, it delegates to that. Otherwise,
+ * creates an empty map, and copies the parent scope to it, adding in
+ * the remaining `args`.
+ *
+ * @param parentScope - Parent scope
+ * @param args - Arguments to add to the new scope
+ * @returns PartitionedMap with parent and args
+ */
+export declare function createSubScope<K = unknown, V = unknown>(parentScope: Map<K, V>, args: Record<string, V>): PartitionedMap<K, V>;
+//# sourceMappingURL=scope.d.ts.map

package/dist/utils/scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../../src/utils/scope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,cAAc,EAAE,MAAM,UAAU,CAAC;AAE7D;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EACrD,WAAW,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EACtB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GACtB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAMtB"}

package/dist/utils/string.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Generic-value string formatting (`format`, `stringify`, `compareText`, `escape`)
+ * and `endsWith`.
+ *
+ * Consolidated onto core: the implementations live once in
+ * `@danielsimonjr/mathts-core/internal` (see `number.ts`/`object.ts` and the
+ * `project-all-libraries-build-on-core` principle). Thin re-export so existing
+ * `../utils/string.js` imports keep working while the single source of truth
+ * lives in core. Proven equivalent to the prior local copy (and to `functions`'s
+ * copy) via a fast-check property harness before the redirect — see
+ * `functions/tests/dedup-bucketB-equivalence.test.ts`. `endsWith` was ALSO
+ * locally defined here pre-redirect, and was already identical to (hence
+ * redundant with) `./shared.ts`'s `endsWith` — already canonical in core.
+ *
+ * NOTE: core exports the generic `format` here as `formatGeneric` (its `number.ts`
+ * already exports a `format` for plain numbers from the same `internal.ts` barrel,
+ * so an unaliased re-export would collide); re-exported here under the original
+ * local name `format`.
+ */
+export { endsWith, formatGeneric as format, stringify, escape, compareText, } from '@danielsimonjr/mathts-core/internal';
+//# sourceMappingURL=string.d.ts.map

package/dist/utils/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/utils/string.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EACL,QAAQ,EACR,aAAa,IAAI,MAAM,EACvB,SAAS,EACT,MAAM,EACN,WAAW,GACZ,MAAM,qCAAqC,CAAC"}