@danielsimonjr/mathts-core 0.4.0 → 0.5.0

package/dist/{chunk-JB4VPWK4.js → chunk-BDNTTHO4.js}

@@ -2318,12 +2318,6 @@ function isIndex(x) {
 function isBoolean(x) {
   return typeof x === "boolean";
 }
-function isResultSet(x) {
-  return hasPrototypeFlag(x, "isResultSet");
-}
-function isHelp(x) {
-  return hasPrototypeFlag(x, "isHelp");
-}
 function isFunction(x) {
   return typeof x === "function";
 }
@@ -2343,75 +2337,12 @@ function isMap(object) {
   const o = object;
   return object instanceof Map || typeof o.set === "function" && typeof o.get === "function" && typeof o.keys === "function" && typeof o.has === "function";
 }
-function isPartitionedMap(object) {
-  const pm = object;
-  return isMap(object) && isMap(pm.a) && isMap(pm.b);
-}
-function isObjectWrappingMap(object) {
-  if (!isMap(object)) return false;
-  const wrapper = object;
-  return wrapper[Symbol.toStringTag] === "ObjectWrappingMap" && isObject(wrapper.wrappedObject);
-}
 function isNull(x) {
   return x === null;
 }
 function isUndefined(x) {
   return x === void 0;
 }
-function isAccessorNode(x) {
-  return hasOwnAndPrototypeFlag(x, "isAccessorNode", "isNode");
-}
-function isArrayNode(x) {
-  return hasOwnAndPrototypeFlag(x, "isArrayNode", "isNode");
-}
-function isAssignmentNode(x) {
-  return hasOwnAndPrototypeFlag(x, "isAssignmentNode", "isNode");
-}
-function isBlockNode(x) {
-  return hasOwnAndPrototypeFlag(x, "isBlockNode", "isNode");
-}
-function isConditionalNode(x) {
-  return hasOwnAndPrototypeFlag(x, "isConditionalNode", "isNode");
-}
-function isConstantNode(x) {
-  return hasOwnAndPrototypeFlag(x, "isConstantNode", "isNode");
-}
-function rule2Node(node) {
-  return isConstantNode(node) || isOperatorNode(node) && node.args.length === 1 && isConstantNode(node.args[0]) && "-+~".includes(node.op);
-}
-function isFunctionAssignmentNode(x) {
-  return hasOwnAndPrototypeFlag(x, "isFunctionAssignmentNode", "isNode");
-}
-function isFunctionNode(x) {
-  return hasOwnAndPrototypeFlag(x, "isFunctionNode", "isNode");
-}
-function isIndexNode(x) {
-  return hasOwnAndPrototypeFlag(x, "isIndexNode", "isNode");
-}
-function isNode(x) {
-  return hasOwnAndPrototypeFlag(x, "isNode", "isNode");
-}
-function isObjectNode(x) {
-  return hasOwnAndPrototypeFlag(x, "isObjectNode", "isNode");
-}
-function isOperatorNode(x) {
-  return hasOwnAndPrototypeFlag(x, "isOperatorNode", "isNode");
-}
-function isParenthesisNode(x) {
-  return hasOwnAndPrototypeFlag(x, "isParenthesisNode", "isNode");
-}
-function isRangeNode(x) {
-  return hasOwnAndPrototypeFlag(x, "isRangeNode", "isNode");
-}
-function isRelationalNode(x) {
-  return hasOwnAndPrototypeFlag(x, "isRelationalNode", "isNode");
-}
-function isSymbolNode(x) {
-  return hasOwnAndPrototypeFlag(x, "isSymbolNode", "isNode");
-}
-function isChain(x) {
-  return hasPrototypeFlag(x, "isChain");
-}
 function typeOf(x) {
   const t = typeof x;
   if (t === "object") {
@@ -4421,6 +4352,19 @@ var createUnitClass = /* @__PURE__ */ factory(
     PREFIXES.SHORTLONG = Object.assign({}, PREFIXES.SHORT, PREFIXES.LONG);
     PREFIXES.BINARY_SHORT = Object.assign({}, PREFIXES.BINARY_SHORT_SI, PREFIXES.BINARY_SHORT_IEC);
     PREFIXES.BINARY_LONG = Object.assign({}, PREFIXES.BINARY_LONG_SI, PREFIXES.BINARY_LONG_IEC);
+    PREFIXES.SHORT_UP_ONLY = {
+      "": { name: "", value: 1, scientific: true },
+      k: { name: "k", value: 1e3, scientific: true },
+      M: { name: "M", value: 1e6, scientific: true },
+      G: { name: "G", value: 1e9, scientific: true },
+      T: { name: "T", value: 1e12, scientific: true },
+      P: { name: "P", value: 1e15, scientific: true },
+      E: { name: "E", value: 1e18, scientific: true },
+      Z: { name: "Z", value: 1e21, scientific: true },
+      Y: { name: "Y", value: 1e24, scientific: true },
+      R: { name: "R", value: 1e27, scientific: true },
+      Q: { name: "Q", value: 1e30, scientific: true }
+    };
     const BASE_DIMENSIONS = [
       "MASS",
       "LENGTH",
@@ -4587,6 +4531,89 @@ var createUnitClass = /* @__PURE__ */ factory(
         value: 1e-10,
         offset: 0
       },
+      // Astronomical / nautical / typography length units (ported from
+      // upstream mathjs ece1aab0f + 5f360326b — B-5). `ly` and `pc` are
+      // first-class UNITS with SHORT_UP_ONLY prefixes so kpc/Mpc/Mly/Gly
+      // resolve through the prefix system while sub-multiples throw.
+      astronomicalUnit: {
+        name: "astronomicalUnit",
+        base: BASE_UNITS.LENGTH,
+        prefixes: PREFIXES.NONE,
+        value: 149597870700,
+        // IAU 2012 exact definition
+        offset: 0
+      },
+      lightyear: {
+        name: "lightyear",
+        base: BASE_UNITS.LENGTH,
+        prefixes: PREFIXES.NONE,
+        value: 9460730472580800,
+        // Julian year × c (exact)
+        offset: 0
+      },
+      ly: {
+        name: "ly",
+        base: BASE_UNITS.LENGTH,
+        prefixes: PREFIXES.SHORT_UP_ONLY,
+        value: 9460730472580800,
+        offset: 0
+      },
+      parsec: {
+        name: "parsec",
+        base: BASE_UNITS.LENGTH,
+        prefixes: PREFIXES.LONG,
+        // kiloparsec, megaparsec, gigaparsec
+        value: 30856775814913700,
+        // IAU 2015 exact definition
+        offset: 0
+      },
+      pc: {
+        name: "pc",
+        base: BASE_UNITS.LENGTH,
+        prefixes: PREFIXES.SHORT_UP_ONLY,
+        value: 30856775814913700,
+        offset: 0
+      },
+      nauticalMile: {
+        name: "nauticalMile",
+        base: BASE_UNITS.LENGTH,
+        prefixes: PREFIXES.NONE,
+        value: 1852,
+        // exact
+        offset: 0
+      },
+      fathom: {
+        name: "fathom",
+        base: BASE_UNITS.LENGTH,
+        prefixes: PREFIXES.NONE,
+        value: 1.8288,
+        // 6 ft exactly
+        offset: 0
+      },
+      furlong: {
+        name: "furlong",
+        base: BASE_UNITS.LENGTH,
+        prefixes: PREFIXES.NONE,
+        value: 201.168,
+        // 1/8 mile exactly
+        offset: 0
+      },
+      point: {
+        name: "point",
+        base: BASE_UNITS.LENGTH,
+        prefixes: PREFIXES.NONE,
+        value: 0.0254 / 72,
+        // 1/72 inch (PostScript), exact
+        offset: 0
+      },
+      pica: {
+        name: "pica",
+        base: BASE_UNITS.LENGTH,
+        prefixes: PREFIXES.NONE,
+        value: 0.0254 / 6,
+        // 1/6 inch (12 points), exact
+        offset: 0
+      },
       m: {
         name: "m",
         base: BASE_UNITS.LENGTH,
@@ -5699,6 +5726,19 @@ var createUnitClass = /* @__PURE__ */ factory(
     };
     const ALIASES = {
       meters: "meter",
+      // Astronomical / nautical / typography aliases (B-5 port). Lowercase
+      // 'au' is deliberately ABSENT: it collides with the atomic unit of
+      // length (Bohr radius, ~5.29e-11 m), 21 orders of magnitude smaller.
+      AU: "astronomicalUnit",
+      astronomicalUnits: "astronomicalUnit",
+      lightyears: "lightyear",
+      parsecs: "parsec",
+      nmi: "nauticalMile",
+      nauticalMiles: "nauticalMile",
+      fathoms: "fathom",
+      furlongs: "furlong",
+      points: "point",
+      picas: "pica",
       inches: "inch",
       feet: "foot",
       yards: "yard",
@@ -6256,35 +6296,13 @@ export {
   isRange,
   isIndex,
   isBoolean,
-  isResultSet,
-  isHelp,
   isFunction,
   isDate,
   isRegExp,
   isObject,
   isMap,
-  isPartitionedMap,
-  isObjectWrappingMap,
   isNull,
   isUndefined,
-  isAccessorNode,
-  isArrayNode,
-  isAssignmentNode,
-  isBlockNode,
-  isConditionalNode,
-  isConstantNode,
-  rule2Node,
-  isFunctionAssignmentNode,
-  isFunctionNode,
-  isIndexNode,
-  isNode,
-  isObjectNode,
-  isOperatorNode,
-  isParenthesisNode,
-  isRangeNode,
-  isRelationalNode,
-  isSymbolNode,
-  isChain,
   typeOf,
   isInteger,
   safeNumberType,

package/dist/{index-qMNYDTSO.d.ts → index-DpOizJsa.d.ts}

@@ -63,87 +63,6 @@ interface Index {
         };
     };
 }
-interface ResultSet {
-    entries: unknown[];
-    constructor: {
-        prototype: {
-            isResultSet: boolean;
-        };
-    };
-}
-interface Help {
-    constructor: {
-        prototype: {
-            isHelp: boolean;
-        };
-    };
-}
-interface Chain {
-    constructor: {
-        prototype: {
-            isChain: boolean;
-        };
-    };
-}
-interface Node {
-    isNode: boolean;
-    constructor: {
-        prototype: {
-            isNode: boolean;
-        };
-    };
-}
-interface AccessorNode extends Node {
-    isAccessorNode: boolean;
-}
-interface ArrayNode extends Node {
-    isArrayNode: boolean;
-}
-interface AssignmentNode extends Node {
-    isAssignmentNode: boolean;
-}
-interface BlockNode extends Node {
-    isBlockNode: boolean;
-}
-interface ConditionalNode extends Node {
-    isConditionalNode: boolean;
-}
-interface ConstantNode extends Node {
-    isConstantNode: boolean;
-}
-interface FunctionAssignmentNode extends Node {
-    isFunctionAssignmentNode: boolean;
-}
-interface FunctionNode extends Node {
-    isFunctionNode: boolean;
-}
-interface IndexNode extends Node {
-    isIndexNode: boolean;
-}
-interface ObjectNode extends Node {
-    isObjectNode: boolean;
-}
-interface OperatorNode extends Node {
-    isOperatorNode: boolean;
-    op: string;
-    args: Node[];
-}
-interface ParenthesisNode extends Node {
-    isParenthesisNode: boolean;
-}
-interface RangeNode extends Node {
-    isRangeNode: boolean;
-}
-interface RelationalNode extends Node {
-    isRelationalNode: boolean;
-}
-interface SymbolNode extends Node {
-    isSymbolNode: boolean;
-}
-interface PartitionedMap {
-    a: Map<unknown, unknown>;
-    b: Map<unknown, unknown>;
-}
 declare function isNumber(x: unknown): x is number;
 declare function isBigNumber(x: unknown): x is BigNumber;
 declare function isBigInt(x: unknown): x is bigint;
@@ -164,8 +83,6 @@ declare function isSparseMatrix(x: unknown): x is SparseMatrix;
 declare function isRange(x: unknown): x is Range;
 declare function isIndex(x: unknown): x is Index;
 declare function isBoolean(x: unknown): x is boolean;
-declare function isResultSet(x: unknown): x is ResultSet;
-declare function isHelp(x: unknown): x is Help;
 declare function isFunction(x: unknown): x is (...args: unknown[]) => unknown;
 declare function isDate(x: unknown): x is Date;
 declare function isRegExp(x: unknown): x is RegExp;
@@ -179,28 +96,8 @@ declare function isObject(x: unknown): x is Record<string, unknown>;
  * @returns
  */
 declare function isMap(object: unknown): object is Map<unknown, unknown>;
-declare function isPartitionedMap(object: unknown): object is PartitionedMap;
-declare function isObjectWrappingMap(object: unknown): boolean;
 declare function isNull(x: unknown): x is null;
 declare function isUndefined(x: unknown): x is undefined;
-declare function isAccessorNode(x: unknown): x is AccessorNode;
-declare function isArrayNode(x: unknown): x is ArrayNode;
-declare function isAssignmentNode(x: unknown): x is AssignmentNode;
-declare function isBlockNode(x: unknown): x is BlockNode;
-declare function isConditionalNode(x: unknown): x is ConditionalNode;
-declare function isConstantNode(x: unknown): x is ConstantNode;
-declare function rule2Node(node: Node): boolean;
-declare function isFunctionAssignmentNode(x: unknown): x is FunctionAssignmentNode;
-declare function isFunctionNode(x: unknown): x is FunctionNode;
-declare function isIndexNode(x: unknown): x is IndexNode;
-declare function isNode(x: unknown): x is Node;
-declare function isObjectNode(x: unknown): x is ObjectNode;
-declare function isOperatorNode(x: unknown): x is OperatorNode;
-declare function isParenthesisNode(x: unknown): x is ParenthesisNode;
-declare function isRangeNode(x: unknown): x is RangeNode;
-declare function isRelationalNode(x: unknown): x is RelationalNode;
-declare function isSymbolNode(x: unknown): x is SymbolNode;
-declare function isChain(x: unknown): x is Chain;
 declare function typeOf(x: unknown): string;
 
 /**
@@ -437,4 +334,4 @@ interface UnitConstructor {
 /** The core `Unit` class, pre-wired to core's numeric primitives. */
 declare const Unit: UnitConstructor;
 
-export { type UnitComponent as $, type AccessorNode as A, type BaseUnitDef as B, type Chain as C, type DenseMatrix as D, type ParseOptions as E, type Fraction as F, type PartitionedMap as G, type Help as H, type Index as I, type PrefixDef as J, type PrefixTable as K, type RangeNode as L, type Matrix as M, type Node as N, type ObjectNode as O, type ParenthesisNode as P, type RelationalNode as Q, type Range as R, type ResultSet as S, type ScalarBinaryOp as T, Unit as U, type ScalarUnaryOp as V, type SparseMatrix as W, type SubtractScalar as X, type SymbolNode as Y, type TypeConverters as Z, type Unit$1 as _, type UnitInstance as a, type UnitConfig as a0, type UnitDef as a1, type UnitFormatOptions as a2, type UnitJSON as a3, type UnitSystem as a4, type UnitSystemEntry as a5, isAccessorNode as a6, isArray as a7, isArrayNode as a8, isAssignmentNode as a9, isOperatorNode as aA, isParenthesisNode as aB, isPartitionedMap as aC, isRange as aD, isRangeNode as aE, isRegExp as aF, isRelationalNode as aG, isResultSet as aH, isSparseMatrix as aI, isString as aJ, isSymbolNode as aK, isUndefined as aL, rule2Node as aM, typeOf as aN, isBigInt as aa, isBigNumber as ab, isBlockNode as ac, isBoolean as ad, isChain as ae, isCollection as af, isComplex as ag, isConditionalNode as ah, isConstantNode as ai, isDate as aj, isDenseMatrix as ak, isFraction as al, isFunction as am, isFunctionAssignmentNode as an, isFunctionNode as ao, isHelp as ap, isIndex as aq, isIndexNode as ar, isMap as as, isMatrix as at, isNode as au, isNull as av, isNumber as aw, isObject as ax, isObjectNode as ay, isObjectWrappingMap as az, type UnitConstructor as b, type UnitDependencies as c, type ArrayNode as d, type AssignmentNode as e, type BigNumber as f, type BigNumberConstructor as g, type BigNumberValue as h, isUnit as i, type BlockNode as j, type Complex as k, type ComplexConstructor as l, type ComplexValue as m, type ConditionalNode as n, type ConstantNode as o, type ConverterFn as p, type CreateUnitDefObject as q, type CreateUnitOptions as r, type FractionConstructor as s, type FractionValue as t, type FunctionAssignmentNode as u, type FunctionNode as v, type IndexDimension as w, type IndexNode as x, type Numeric as y, type OperatorNode as z };
+export { isNull as $, type UnitSystem as A, type BaseUnitDef as B, type Complex as C, type DenseMatrix as D, type UnitSystemEntry as E, type Fraction as F, isArray as G, isBigInt as H, type Index as I, isBigNumber as J, isBoolean as K, isCollection as L, type Matrix as M, type Numeric as N, isComplex as O, type ParseOptions as P, isDate as Q, type Range as R, type ScalarBinaryOp as S, type TypeConverters as T, Unit as U, isDenseMatrix as V, isFraction as W, isFunction as X, isIndex as Y, isMap as Z, isMatrix as _, type UnitInstance as a, isNumber as a0, isObject as a1, isRange as a2, isRegExp as a3, isSparseMatrix as a4, isString as a5, isUndefined as a6, typeOf as a7, type UnitConstructor as b, type UnitDependencies as c, type BigNumber as d, type BigNumberConstructor as e, type BigNumberValue as f, type ComplexConstructor as g, type ComplexValue as h, isUnit as i, type ConverterFn as j, type CreateUnitDefObject as k, type CreateUnitOptions as l, type FractionConstructor as m, type FractionValue as n, type IndexDimension as o, type PrefixDef as p, type PrefixTable as q, type ScalarUnaryOp as r, type SparseMatrix as s, type SubtractScalar as t, type Unit$1 as u, type UnitComponent as v, type UnitConfig as w, type UnitDef as x, type UnitFormatOptions as y, type UnitJSON as z };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { U as Unit, a as UnitInstance, i as isUnitValue } from './index-qMNYDTSO.js';
+export { U as Unit, a as UnitInstance, i as isUnitValue } from './index-DpOizJsa.js';
 import { TypedInstance, ReferTo, ReferToSelf, TypedFunction, SignatureFunction } from 'typed-function';
 export { ReferTo, ReferToSelf, SignatureFunction, TypedFunction, TypedInstance, create, default as typed } from 'typed-function';
 

package/dist/index.js

@@ -38,7 +38,7 @@ import {
   pow,
   round,
   subtractScalar
-} from "./chunk-JB4VPWK4.js";
+} from "./chunk-BDNTTHO4.js";
 
 // src/types/dual-rules.ts
 var DUAL_UNARY_RULES = {
@@ -376,9 +376,6 @@ var SI_PREFIXES = {
   y: 1e-24
   // yocto
 };
-var SI_PREFIX_KEYS = Object.keys(SI_PREFIXES).sort(
-  (a, b) => b.length - a.length
-);
 var BEST_PREFIXES = [
   "Y",
   "Z",

package/dist/internal.d.ts

@@ -1,5 +1,5 @@
-import { b as UnitConstructor, c as UnitDependencies } from './index-qMNYDTSO.js';
-export { A as AccessorNode, d as ArrayNode, e as AssignmentNode, B as BaseUnitDef, f as BigNumber, g as BigNumberConstructor, h as BigNumberValue, j as BlockNode, C as Chain, k as Complex, l as ComplexConstructor, m as ComplexValue, n as ConditionalNode, o as ConstantNode, p as ConverterFn, U as CoreUnit, q as CreateUnitDefObject, r as CreateUnitOptions, D as DenseMatrix, F as Fraction, s as FractionConstructor, t as FractionValue, u as FunctionAssignmentNode, v as FunctionNode, H as Help, I as Index, w as IndexDimension, x as IndexNode, M as Matrix, N as Node, y as Numeric, O as ObjectNode, z as OperatorNode, P as ParenthesisNode, E as ParseOptions, G as PartitionedMap, J as PrefixDef, K as PrefixTable, R as Range, L as RangeNode, Q as RelationalNode, S as ResultSet, T as ScalarBinaryOp, V as ScalarUnaryOp, W as SparseMatrix, X as SubtractScalar, Y as SymbolNode, Z as TypeConverters, _ as Unit, $ as UnitComponent, a0 as UnitConfig, a1 as UnitDef, a2 as UnitFormatOptions, a as UnitInstance, a3 as UnitJSON, a4 as UnitSystem, a5 as UnitSystemEntry, a6 as isAccessorNode, a7 as isArray, a8 as isArrayNode, a9 as isAssignmentNode, aa as isBigInt, ab as isBigNumber, ac as isBlockNode, ad as isBoolean, ae as isChain, af as isCollection, ag as isComplex, ah as isConditionalNode, ai as isConstantNode, aj as isDate, ak as isDenseMatrix, al as isFraction, am as isFunction, an as isFunctionAssignmentNode, ao as isFunctionNode, ap as isHelp, aq as isIndex, ar as isIndexNode, as as isMap, at as isMatrix, au as isNode, av as isNull, aw as isNumber, ax as isObject, ay as isObjectNode, az as isObjectWrappingMap, aA as isOperatorNode, aB as isParenthesisNode, aC as isPartitionedMap, aD as isRange, aE as isRangeNode, aF as isRegExp, aG as isRelationalNode, aH as isResultSet, aI as isSparseMatrix, aJ as isString, aK as isSymbolNode, aL as isUndefined, i as isUnit, aM as rule2Node, aN as typeOf } from './index-qMNYDTSO.js';
+import { b as UnitConstructor, c as UnitDependencies } from './index-DpOizJsa.js';
+export { B as BaseUnitDef, d as BigNumber, e as BigNumberConstructor, f as BigNumberValue, C as Complex, g as ComplexConstructor, h as ComplexValue, j as ConverterFn, U as CoreUnit, k as CreateUnitDefObject, l as CreateUnitOptions, D as DenseMatrix, F as Fraction, m as FractionConstructor, n as FractionValue, I as Index, o as IndexDimension, M as Matrix, N as Numeric, P as ParseOptions, p as PrefixDef, q as PrefixTable, R as Range, S as ScalarBinaryOp, r as ScalarUnaryOp, s as SparseMatrix, t as SubtractScalar, T as TypeConverters, u as Unit, v as UnitComponent, w as UnitConfig, x as UnitDef, y as UnitFormatOptions, a as UnitInstance, z as UnitJSON, A as UnitSystem, E as UnitSystemEntry, G as isArray, H as isBigInt, J as isBigNumber, K as isBoolean, L as isCollection, O as isComplex, Q as isDate, V as isDenseMatrix, W as isFraction, X as isFunction, Y as isIndex, Z as isMap, _ as isMatrix, $ as isNull, a0 as isNumber, a1 as isObject, a2 as isRange, a3 as isRegExp, a4 as isSparseMatrix, a5 as isString, a6 as isUndefined, i as isUnit, a7 as typeOf } from './index-DpOizJsa.js';
 
 /**
  * Type for a factory function that creates instances

package/dist/internal.js

@@ -19,50 +19,29 @@ import {
   format,
   get,
   hasOwnProperty,
-  isAccessorNode,
   isArray,
-  isArrayNode,
-  isAssignmentNode,
   isBigInt,
   isBigNumber2 as isBigNumber,
-  isBlockNode,
   isBoolean,
-  isChain,
   isCollection,
   isComplex2 as isComplex,
-  isConditionalNode,
-  isConstantNode,
   isDate,
   isDenseMatrix,
   isFraction2 as isFraction,
   isFunction,
-  isFunctionAssignmentNode,
-  isFunctionNode,
-  isHelp,
   isIndex,
-  isIndexNode,
   isInteger,
   isLegacyFactory,
   isMap,
   isMatrix,
-  isNode,
   isNull,
   isNumber,
   isObject,
-  isObjectNode,
-  isObjectWrappingMap,
-  isOperatorNode,
-  isParenthesisNode,
-  isPartitionedMap,
   isPowZeroAtInfinity,
   isRange,
-  isRangeNode,
   isRegExp,
-  isRelationalNode,
-  isResultSet,
   isSparseMatrix,
   isString,
-  isSymbolNode,
   isUndefined,
   isUnit,
   lazy,
@@ -76,7 +55,6 @@ import {
   pick,
   pickShallow,
   roundDigits,
-  rule2Node,
   safeNumberType,
   set,
   sign,
@@ -91,7 +69,7 @@ import {
   typeOf,
   unitDependencies,
   warnOnce
-} from "./chunk-JB4VPWK4.js";
+} from "./chunk-BDNTTHO4.js";
 export {
   Unit as CoreUnit,
   acosh,
@@ -113,50 +91,29 @@ export {
   format,
   get,
   hasOwnProperty,
-  isAccessorNode,
   isArray,
-  isArrayNode,
-  isAssignmentNode,
   isBigInt,
   isBigNumber,
-  isBlockNode,
   isBoolean,
-  isChain,
   isCollection,
   isComplex,
-  isConditionalNode,
-  isConstantNode,
   isDate,
   isDenseMatrix,
   isFraction,
   isFunction,
-  isFunctionAssignmentNode,
-  isFunctionNode,
-  isHelp,
   isIndex,
-  isIndexNode,
   isInteger,
   isLegacyFactory,
   isMap,
   isMatrix,
-  isNode,
   isNull,
   isNumber,
   isObject,
-  isObjectNode,
-  isObjectWrappingMap,
-  isOperatorNode,
-  isParenthesisNode,
-  isPartitionedMap,
   isPowZeroAtInfinity,
   isRange,
-  isRangeNode,
   isRegExp,
-  isRelationalNode,
-  isResultSet,
   isSparseMatrix,
   isString,
-  isSymbolNode,
   isUndefined,
   isUnit,
   lazy,
@@ -170,7 +127,6 @@ export {
   pick,
   pickShallow,
   roundDigits,
-  rule2Node,
   safeNumberType,
   set,
   sign,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-core",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Core types, utilities, and configuration for MathTS",
   "author": "Daniel Simon Jr.",
   "license": "MIT",