@danielsimonjr/mathts-expression 0.6.7 → 0.7.1

package/dist/index.js

@@ -5,11 +5,7 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function __require() {
-  try {
-    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  } catch (e) {
-    throw mod = 0, e;
-  }
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -164,6 +160,11 @@ function isRange(x) {
   const obj = x;
   return obj.constructor?.prototype?.isRange === true;
 }
+function isIndex(x) {
+  if (!x || typeof x !== "object") return false;
+  const obj = x;
+  return obj.constructor?.prototype?.isIndex === true;
+}
 function isHelp(x) {
   if (!x || typeof x !== "object") return false;
   const obj = x;
@@ -650,6 +651,75 @@ import {
   toPrecision
 } from "@danielsimonjr/mathts-core/internal";
 
+// src/utils/customs.ts
+function getSafeProperty(object, prop) {
+  if (isSafeProperty(object, prop)) {
+    return object[prop];
+  }
+  if (typeof object[prop] === "function" && isSafeMethod(object, prop)) {
+    throw new Error('Cannot access method "' + String(prop) + '" as a property');
+  }
+  throw new Error('No access to property "' + String(prop) + '"');
+}
+function setSafeProperty(object, prop, value) {
+  if (isSafeProperty(object, prop)) {
+    object[prop] = value;
+    return value;
+  }
+  throw new Error('No access to property "' + String(prop) + '"');
+}
+function isSafeProperty(object, prop) {
+  if (!isPlainObject(object) && !Array.isArray(object)) {
+    return false;
+  }
+  if (hasOwnProperty(safeNativeProperties, prop)) {
+    return true;
+  }
+  if (prop in Object.prototype) {
+    return false;
+  }
+  if (prop in Function.prototype) {
+    return false;
+  }
+  return true;
+}
+function getSafeMethod(object, method) {
+  if (!isSafeMethod(object, method)) {
+    throw new Error('No access to method "' + String(method) + '"');
+  }
+  return object[method];
+}
+function isSafeMethod(object, method) {
+  if (object === null || object === void 0 || typeof object[method] !== "function") {
+    return false;
+  }
+  if (hasOwnProperty(object, method) && Object.getPrototypeOf && method in Object.getPrototypeOf(object)) {
+    return false;
+  }
+  if (hasOwnProperty(safeNativeMethods, method)) {
+    return true;
+  }
+  if (method in Object.prototype) {
+    return false;
+  }
+  if (method in Function.prototype) {
+    return false;
+  }
+  return true;
+}
+function isPlainObject(object) {
+  return typeof object === "object" && !!object && object.constructor === Object;
+}
+var safeNativeProperties = {
+  length: true,
+  name: true
+};
+var safeNativeMethods = {
+  toString: true,
+  valueOf: true,
+  toLocaleString: true
+};
+
 // src/parse.ts
 var name = "parse";
 var dependencies = [
@@ -756,7 +826,8 @@ var createParse = /* @__PURE__ */ factory(
       ">=": true,
       "<<": true,
       ">>": true,
-      ">>>": true
+      ">>>": true,
+      ".": true
     };
     const NAMED_DELIMITERS = {
       mod: true,
@@ -851,25 +922,28 @@ var createParse = /* @__PURE__ */ factory(
       const c1 = currentCharacter(state);
       const c2 = currentString(state, 2);
       const c3 = currentString(state, 3);
+      let delim = "";
       if (c3.length === 3 && DELIMITERS[c3]) {
-        state.tokenType = 1 /* DELIMITER */;
-        state.token = c3;
-        next(state);
-        next(state);
-        next(state);
-        return;
-      }
-      if (c2.length === 2 && DELIMITERS[c2] && (c2 !== "?." || !parse.isDigit(state.expression.charAt(state.index + 2)))) {
-        state.tokenType = 1 /* DELIMITER */;
-        state.token = c2;
-        next(state);
-        next(state);
-        return;
+        delim = c3;
+      } else if (c2.length === 2 && DELIMITERS[c2]) {
+        delim = c2;
+      } else if (DELIMITERS[c1]) {
+        delim = c1;
+      }
+      if (delim) {
+        if (delim.endsWith(".") && parse.isDigit(state.expression.charAt(state.index + delim.length))) {
+          delim = delim.slice(0, -1);
+          if (delim.length > 0 && !DELIMITERS[delim]) {
+            delim = "";
+          }
+        }
       }
-      if (DELIMITERS[c1]) {
+      if (delim) {
         state.tokenType = 1 /* DELIMITER */;
-        state.token = c1;
-        next(state);
+        state.token = delim;
+        for (let i = 0; i < delim.length; i++) {
+          next(state);
+        }
         return;
       }
       if (parse.isDigitDot(c1)) {
@@ -904,10 +978,6 @@ var createParse = /* @__PURE__ */ factory(
         if (currentCharacter(state) === ".") {
           state.token += currentCharacter(state);
           next(state);
-          if (!parse.isDigit(currentCharacter(state))) {
-            state.tokenType = 1 /* DELIMITER */;
-            return;
-          }
         } else {
           while (parse.isDigit(currentCharacter(state))) {
             state.token += currentCharacter(state);
@@ -1023,26 +1093,29 @@ var createParse = /* @__PURE__ */ factory(
     function parseBlock(state) {
       let node;
       const blocks = [];
-      let visible;
-      if (state.token !== "" && state.token !== "\n" && state.token !== ";") {
-        node = parseAssignment(state);
-        if (state.comment) {
-          node.comment = state.comment;
-        }
-      }
-      while (state.token === "\n" || state.token === ";") {
-        if (blocks.length === 0 && node) {
-          visible = state.token !== ";";
-          blocks.push({ node, visible });
-        }
-        getToken(state);
-        if (state.token !== "\n" && state.token !== ";" && state.token !== "") {
+      let hasSeparators = false;
+      let nodePushed = true;
+      while (state.token !== "") {
+        if (state.token !== "\n" && state.token !== ";") {
           node = parseAssignment(state);
+          nodePushed = false;
           if (state.comment) {
             node.comment = state.comment;
           }
-          visible = state.token !== ";";
-          blocks.push({ node, visible });
+        }
+        if (state.token === "\n" || state.token === ";") {
+          hasSeparators = true;
+          if (node && !nodePushed) {
+            blocks.push({ node, visible: state.token !== ";" });
+            nodePushed = true;
+          }
+          getToken(state);
+        } else {
+          if (node && hasSeparators && !nodePushed) {
+            blocks.push({ node, visible: state.token !== ";" });
+            nodePushed = true;
+          }
+          break;
         }
       }
       if (blocks.length > 0) {
@@ -1688,7 +1761,7 @@ var createParse = /* @__PURE__ */ factory(
               throw createSyntaxError(state, "Colon : expected after object key");
             }
             getToken(state);
-            properties2[key] = parseAssignment(state);
+            setSafeProperty(properties2, key, parseAssignment(state));
           }
         } while (state.token === ",");
         if (state.token !== "}") {
@@ -1787,9 +1860,15 @@ var createParserClass = /* @__PURE__ */ factory(
     Parser.prototype.type = "Parser";
     Parser.prototype.isParser = true;
     Parser.prototype.evaluate = function(expr) {
+      if (typeof expr !== "string" && !Array.isArray(expr)) {
+        throw new TypeError('String or string array expected for parameter "expr"');
+      }
       return evaluate(expr, this.scope);
     };
     Parser.prototype.get = function(name47) {
+      if (typeof name47 !== "string") {
+        throw new TypeError('String expected for parameter "name"');
+      }
       return this.scope.has(name47) ? this.scope.get(name47) : void 0;
     };
     Parser.prototype.getAll = function() {
@@ -1973,6 +2052,516 @@ var createHelpClass = /* @__PURE__ */ factory(
   { isClass: true }
 );
 
+// src/embeddedDocs/physicalConstants/speedOfLight.ts
+var speedOfLightDocs = {
+  name: "speedOfLight",
+  category: "Physical Constants",
+  syntax: ["speedOfLight"],
+  description: "Speed of light in vacuum",
+  examples: ["speedOfLight"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/gravitationConstant.ts
+var gravitationConstantDocs = {
+  name: "gravitationConstant",
+  category: "Physical Constants",
+  syntax: ["gravitationConstant"],
+  description: "Newtonian constant of gravitation",
+  examples: ["gravitationConstant"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/planckConstant.ts
+var planckConstantDocs = {
+  name: "planckConstant",
+  category: "Physical Constants",
+  syntax: ["planckConstant"],
+  description: "Planck constant",
+  examples: ["planckConstant"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/reducedPlanckConstant.ts
+var reducedPlanckConstantDocs = {
+  name: "reducedPlanckConstant",
+  category: "Physical Constants",
+  syntax: ["reducedPlanckConstant"],
+  description: "Reduced Planck constant",
+  examples: ["reducedPlanckConstant"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/magneticConstant.ts
+var magneticConstantDocs = {
+  name: "magneticConstant",
+  category: "Physical Constants",
+  syntax: ["magneticConstant"],
+  description: "Magnetic constant (vacuum permeability)",
+  examples: ["magneticConstant"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/electricConstant.ts
+var electricConstantDocs = {
+  name: "electricConstant",
+  category: "Physical Constants",
+  syntax: ["electricConstant"],
+  description: "Electric constant (vacuum permeability)",
+  examples: ["electricConstant"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/vacuumImpedance.ts
+var vacuumImpedanceDocs = {
+  name: "vacuumImpedance",
+  category: "Physical Constants",
+  syntax: ["vacuumImpedance"],
+  description: "Characteristic impedance of vacuum",
+  examples: ["vacuumImpedance"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/coulomb.ts
+var coulombDocs = {
+  name: "coulomb",
+  category: "Physical Constants",
+  syntax: ["coulomb"],
+  description: "Coulomb's constant. Deprecated in favor of coulombConstant",
+  examples: ["coulomb"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/coulombConstant.ts
+var coulombConstantDocs = {
+  name: "coulombConstant",
+  category: "Physical Constants",
+  syntax: ["coulombConstant"],
+  description: "Coulomb's constant",
+  examples: ["coulombConstant"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/elementaryCharge.ts
+var elementaryChargeDocs = {
+  name: "elementaryCharge",
+  category: "Physical Constants",
+  syntax: ["elementaryCharge"],
+  description: "Elementary charge",
+  examples: ["elementaryCharge"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/bohrMagneton.ts
+var bohrMagnetonDocs = {
+  name: "bohrMagneton",
+  category: "Physical Constants",
+  syntax: ["bohrMagneton"],
+  description: "Bohr magneton",
+  examples: ["bohrMagneton"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/conductanceQuantum.ts
+var conductanceQuantumDocs = {
+  name: "conductanceQuantum",
+  category: "Physical Constants",
+  syntax: ["conductanceQuantum"],
+  description: "Conductance quantum",
+  examples: ["conductanceQuantum"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/inverseConductanceQuantum.ts
+var inverseConductanceQuantumDocs = {
+  name: "inverseConductanceQuantum",
+  category: "Physical Constants",
+  syntax: ["inverseConductanceQuantum"],
+  description: "Inverse conductance quantum",
+  examples: ["inverseConductanceQuantum"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/magneticFluxQuantum.ts
+var magneticFluxQuantumDocs = {
+  name: "magneticFluxQuantum",
+  category: "Physical Constants",
+  syntax: ["magneticFluxQuantum"],
+  description: "Magnetic flux quantum",
+  examples: ["magneticFluxQuantum"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/nuclearMagneton.ts
+var nuclearMagnetonDocs = {
+  name: "nuclearMagneton",
+  category: "Physical Constants",
+  syntax: ["nuclearMagneton"],
+  description: "Nuclear magneton",
+  examples: ["nuclearMagneton"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/klitzing.ts
+var klitzingDocs = {
+  name: "klitzing",
+  category: "Physical Constants",
+  syntax: ["klitzing"],
+  description: "Von Klitzing constant",
+  examples: ["klitzing"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/bohrRadius.ts
+var bohrRadiusDocs = {
+  name: "bohrRadius",
+  category: "Physical Constants",
+  syntax: ["bohrRadius"],
+  description: "Bohr radius",
+  examples: ["bohrRadius"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/classicalElectronRadius.ts
+var classicalElectronRadiusDocs = {
+  name: "classicalElectronRadius",
+  category: "Physical Constants",
+  syntax: ["classicalElectronRadius"],
+  description: "Classical electron radius",
+  examples: ["classicalElectronRadius"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/electronMass.ts
+var electronMassDocs = {
+  name: "electronMass",
+  category: "Physical Constants",
+  syntax: ["electronMass"],
+  description: "Electron mass",
+  examples: ["electronMass"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/fermiCoupling.ts
+var fermiCouplingDocs = {
+  name: "fermiCoupling",
+  category: "Physical Constants",
+  syntax: ["fermiCoupling"],
+  description: "Fermi coupling constant",
+  examples: ["fermiCoupling"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/fineStructure.ts
+var fineStructureDocs = {
+  name: "fineStructure",
+  category: "Physical Constants",
+  syntax: ["fineStructure"],
+  description: "Fine-structure constant",
+  examples: ["fineStructure"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/hartreeEnergy.ts
+var hartreeEnergyDocs = {
+  name: "hartreeEnergy",
+  category: "Physical Constants",
+  syntax: ["hartreeEnergy"],
+  description: "Hartree energy",
+  examples: ["hartreeEnergy"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/protonMass.ts
+var protonMassDocs = {
+  name: "protonMass",
+  category: "Physical Constants",
+  syntax: ["protonMass"],
+  description: "Proton mass",
+  examples: ["protonMass"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/deuteronMass.ts
+var deuteronMassDocs = {
+  name: "deuteronMass",
+  category: "Physical Constants",
+  syntax: ["deuteronMass"],
+  description: "Deuteron Mass",
+  examples: ["deuteronMass"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/neutronMass.ts
+var neutronMassDocs = {
+  name: "neutronMass",
+  category: "Physical Constants",
+  syntax: ["neutronMass"],
+  description: "Neutron mass",
+  examples: ["neutronMass"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/quantumOfCirculation.ts
+var quantumOfCirculationDocs = {
+  name: "quantumOfCirculation",
+  category: "Physical Constants",
+  syntax: ["quantumOfCirculation"],
+  description: "Quantum of circulation",
+  examples: ["quantumOfCirculation"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/rydberg.ts
+var rydbergDocs = {
+  name: "rydberg",
+  category: "Physical Constants",
+  syntax: ["rydberg"],
+  description: "Rydberg constant",
+  examples: ["rydberg"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/thomsonCrossSection.ts
+var thomsonCrossSectionDocs = {
+  name: "thomsonCrossSection",
+  category: "Physical Constants",
+  syntax: ["thomsonCrossSection"],
+  description: "Thomson cross section",
+  examples: ["thomsonCrossSection"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/weakMixingAngle.ts
+var weakMixingAngleDocs = {
+  name: "weakMixingAngle",
+  category: "Physical Constants",
+  syntax: ["weakMixingAngle"],
+  description: "Weak mixing angle",
+  examples: ["weakMixingAngle"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/efimovFactor.ts
+var efimovFactorDocs = {
+  name: "efimovFactor",
+  category: "Physical Constants",
+  syntax: ["efimovFactor"],
+  description: "Efimov factor",
+  examples: ["efimovFactor"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/atomicMass.ts
+var atomicMassDocs = {
+  name: "atomicMass",
+  category: "Physical Constants",
+  syntax: ["atomicMass"],
+  description: "Atomic mass constant",
+  examples: ["atomicMass"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/avogadro.ts
+var avogadroDocs = {
+  name: "avogadro",
+  category: "Physical Constants",
+  syntax: ["avogadro"],
+  description: "Avogadro's number",
+  examples: ["avogadro"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/boltzmann.ts
+var boltzmannDocs = {
+  name: "boltzmann",
+  category: "Physical Constants",
+  syntax: ["boltzmann"],
+  description: "Boltzmann constant",
+  examples: ["boltzmann"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/faraday.ts
+var faradayDocs = {
+  name: "faraday",
+  category: "Physical Constants",
+  syntax: ["faraday"],
+  description: "Faraday constant",
+  examples: ["faraday"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/firstRadiation.ts
+var firstRadiationDocs = {
+  name: "firstRadiation",
+  category: "Physical Constants",
+  syntax: ["firstRadiation"],
+  description: "First radiation constant",
+  examples: ["firstRadiation"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/loschmidt.ts
+var loschmidtDocs = {
+  name: "loschmidt",
+  category: "Physical Constants",
+  syntax: ["loschmidt"],
+  description: "Loschmidt constant at T=273.15 K and p=101.325 kPa",
+  examples: ["loschmidt"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/gasConstant.ts
+var gasConstantDocs = {
+  name: "gasConstant",
+  category: "Physical Constants",
+  syntax: ["gasConstant"],
+  description: "Gas constant",
+  examples: ["gasConstant"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/molarPlanckConstant.ts
+var molarPlanckConstantDocs = {
+  name: "molarPlanckConstant",
+  category: "Physical Constants",
+  syntax: ["molarPlanckConstant"],
+  description: "Molar Planck constant",
+  examples: ["molarPlanckConstant"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/molarVolume.ts
+var molarVolumeDocs = {
+  name: "molarVolume",
+  category: "Physical Constants",
+  syntax: ["molarVolume"],
+  description: "Molar volume of an ideal gas at T=273.15 K and p=101.325 kPa",
+  examples: ["molarVolume"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/sackurTetrode.ts
+var sackurTetrodeDocs = {
+  name: "sackurTetrode",
+  category: "Physical Constants",
+  syntax: ["sackurTetrode"],
+  description: "Sackur-Tetrode constant at T=1 K and p=101.325 kPa",
+  examples: ["sackurTetrode"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/secondRadiation.ts
+var secondRadiationDocs = {
+  name: "secondRadiation",
+  category: "Physical Constants",
+  syntax: ["secondRadiation"],
+  description: "Second radiation constant",
+  examples: ["secondRadiation"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/stefanBoltzmann.ts
+var stefanBoltzmannDocs = {
+  name: "stefanBoltzmann",
+  category: "Physical Constants",
+  syntax: ["stefanBoltzmann"],
+  description: "Stefan-Boltzmann constant",
+  examples: ["stefanBoltzmann"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/wienDisplacement.ts
+var wienDisplacementDocs = {
+  name: "wienDisplacement",
+  category: "Physical Constants",
+  syntax: ["wienDisplacement"],
+  description: "Wien displacement law constant",
+  examples: ["wienDisplacement"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/molarMass.ts
+var molarMassDocs = {
+  name: "molarMass",
+  category: "Physical Constants",
+  syntax: ["molarMass"],
+  description: "Molar mass constant",
+  examples: ["molarMass"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/molarMassC12.ts
+var molarMassC12Docs = {
+  name: "molarMassC12",
+  category: "Physical Constants",
+  syntax: ["molarMassC12"],
+  description: "Molar mass constant of carbon-12",
+  examples: ["molarMassC12"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/gravity.ts
+var gravityDocs = {
+  name: "gravity",
+  category: "Physical Constants",
+  syntax: ["gravity"],
+  description: "Standard acceleration of gravity (standard acceleration of free-fall on Earth)",
+  examples: ["gravity"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/planckLength.ts
+var planckLengthDocs = {
+  name: "planckLength",
+  category: "Physical Constants",
+  syntax: ["planckLength"],
+  description: "Planck length",
+  examples: ["planckLength"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/planckMass.ts
+var planckMassDocs = {
+  name: "planckMass",
+  category: "Physical Constants",
+  syntax: ["planckMass"],
+  description: "Planck mass",
+  examples: ["planckMass"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/planckTime.ts
+var planckTimeDocs = {
+  name: "planckTime",
+  category: "Physical Constants",
+  syntax: ["planckTime"],
+  description: "Planck time",
+  examples: ["planckTime"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/planckCharge.ts
+var planckChargeDocs = {
+  name: "planckCharge",
+  category: "Physical Constants",
+  syntax: ["planckCharge"],
+  description: "Planck charge",
+  examples: ["planckCharge"],
+  seealso: []
+};
+
+// src/embeddedDocs/physicalConstants/planckTemperature.ts
+var planckTemperatureDocs = {
+  name: "planckTemperature",
+  category: "Physical Constants",
+  syntax: ["planckTemperature"],
+  description: "Planck temperature",
+  examples: ["planckTemperature"],
+  seealso: []
+};
+
 // src/embeddedDocs/constants/e.ts
 var eDocs = {
   name: "e",
@@ -6275,102 +6864,59 @@ var embeddedDocs = {
   true: trueDocs,
   version: versionDocs,
   // physical constants
-  // TODO: more detailed docs for physical constants
-  speedOfLight: { description: "Speed of light in vacuum", examples: ["speedOfLight"] },
-  gravitationConstant: {
-    description: "Newtonian constant of gravitation",
-    examples: ["gravitationConstant"]
-  },
-  planckConstant: { description: "Planck constant", examples: ["planckConstant"] },
-  reducedPlanckConstant: {
-    description: "Reduced Planck constant",
-    examples: ["reducedPlanckConstant"]
-  },
-  magneticConstant: {
-    description: "Magnetic constant (vacuum permeability)",
-    examples: ["magneticConstant"]
-  },
-  electricConstant: {
-    description: "Electric constant (vacuum permeability)",
-    examples: ["electricConstant"]
-  },
-  vacuumImpedance: {
-    description: "Characteristic impedance of vacuum",
-    examples: ["vacuumImpedance"]
-  },
-  coulomb: {
-    description: "Coulomb's constant. Deprecated in favor of coulombConstant",
-    examples: ["coulombConstant"]
-  },
-  coulombConstant: { description: "Coulomb's constant", examples: ["coulombConstant"] },
-  elementaryCharge: { description: "Elementary charge", examples: ["elementaryCharge"] },
-  bohrMagneton: { description: "Bohr magneton", examples: ["bohrMagneton"] },
-  conductanceQuantum: { description: "Conductance quantum", examples: ["conductanceQuantum"] },
-  inverseConductanceQuantum: {
-    description: "Inverse conductance quantum",
-    examples: ["inverseConductanceQuantum"]
-  },
+  speedOfLight: speedOfLightDocs,
+  gravitationConstant: gravitationConstantDocs,
+  planckConstant: planckConstantDocs,
+  reducedPlanckConstant: reducedPlanckConstantDocs,
+  magneticConstant: magneticConstantDocs,
+  electricConstant: electricConstantDocs,
+  vacuumImpedance: vacuumImpedanceDocs,
+  coulomb: coulombDocs,
+  coulombConstant: coulombConstantDocs,
+  elementaryCharge: elementaryChargeDocs,
+  bohrMagneton: bohrMagnetonDocs,
+  conductanceQuantum: conductanceQuantumDocs,
+  inverseConductanceQuantum: inverseConductanceQuantumDocs,
   // josephson: {description: 'Josephson constant', examples: ['josephson']},
-  magneticFluxQuantum: { description: "Magnetic flux quantum", examples: ["magneticFluxQuantum"] },
-  nuclearMagneton: { description: "Nuclear magneton", examples: ["nuclearMagneton"] },
-  klitzing: { description: "Von Klitzing constant", examples: ["klitzing"] },
-  bohrRadius: { description: "Bohr radius", examples: ["bohrRadius"] },
-  classicalElectronRadius: {
-    description: "Classical electron radius",
-    examples: ["classicalElectronRadius"]
-  },
-  electronMass: { description: "Electron mass", examples: ["electronMass"] },
-  fermiCoupling: { description: "Fermi coupling constant", examples: ["fermiCoupling"] },
-  fineStructure: { description: "Fine-structure constant", examples: ["fineStructure"] },
-  hartreeEnergy: { description: "Hartree energy", examples: ["hartreeEnergy"] },
-  protonMass: { description: "Proton mass", examples: ["protonMass"] },
-  deuteronMass: { description: "Deuteron Mass", examples: ["deuteronMass"] },
-  neutronMass: { description: "Neutron mass", examples: ["neutronMass"] },
-  quantumOfCirculation: {
-    description: "Quantum of circulation",
-    examples: ["quantumOfCirculation"]
-  },
-  rydberg: { description: "Rydberg constant", examples: ["rydberg"] },
-  thomsonCrossSection: { description: "Thomson cross section", examples: ["thomsonCrossSection"] },
-  weakMixingAngle: { description: "Weak mixing angle", examples: ["weakMixingAngle"] },
-  efimovFactor: { description: "Efimov factor", examples: ["efimovFactor"] },
-  atomicMass: { description: "Atomic mass constant", examples: ["atomicMass"] },
-  avogadro: { description: "Avogadro's number", examples: ["avogadro"] },
-  boltzmann: { description: "Boltzmann constant", examples: ["boltzmann"] },
-  faraday: { description: "Faraday constant", examples: ["faraday"] },
-  firstRadiation: { description: "First radiation constant", examples: ["firstRadiation"] },
-  loschmidt: {
-    description: "Loschmidt constant at T=273.15 K and p=101.325 kPa",
-    examples: ["loschmidt"]
-  },
-  gasConstant: { description: "Gas constant", examples: ["gasConstant"] },
-  molarPlanckConstant: { description: "Molar Planck constant", examples: ["molarPlanckConstant"] },
-  molarVolume: {
-    description: "Molar volume of an ideal gas at T=273.15 K and p=101.325 kPa",
-    examples: ["molarVolume"]
-  },
-  sackurTetrode: {
-    description: "Sackur-Tetrode constant at T=1 K and p=101.325 kPa",
-    examples: ["sackurTetrode"]
-  },
-  secondRadiation: { description: "Second radiation constant", examples: ["secondRadiation"] },
-  stefanBoltzmann: { description: "Stefan-Boltzmann constant", examples: ["stefanBoltzmann"] },
-  wienDisplacement: {
-    description: "Wien displacement law constant",
-    examples: ["wienDisplacement"]
-  },
+  magneticFluxQuantum: magneticFluxQuantumDocs,
+  nuclearMagneton: nuclearMagnetonDocs,
+  klitzing: klitzingDocs,
+  bohrRadius: bohrRadiusDocs,
+  classicalElectronRadius: classicalElectronRadiusDocs,
+  electronMass: electronMassDocs,
+  fermiCoupling: fermiCouplingDocs,
+  fineStructure: fineStructureDocs,
+  hartreeEnergy: hartreeEnergyDocs,
+  protonMass: protonMassDocs,
+  deuteronMass: deuteronMassDocs,
+  neutronMass: neutronMassDocs,
+  quantumOfCirculation: quantumOfCirculationDocs,
+  rydberg: rydbergDocs,
+  thomsonCrossSection: thomsonCrossSectionDocs,
+  weakMixingAngle: weakMixingAngleDocs,
+  efimovFactor: efimovFactorDocs,
+  atomicMass: atomicMassDocs,
+  avogadro: avogadroDocs,
+  boltzmann: boltzmannDocs,
+  faraday: faradayDocs,
+  firstRadiation: firstRadiationDocs,
+  loschmidt: loschmidtDocs,
+  gasConstant: gasConstantDocs,
+  molarPlanckConstant: molarPlanckConstantDocs,
+  molarVolume: molarVolumeDocs,
+  sackurTetrode: sackurTetrodeDocs,
+  secondRadiation: secondRadiationDocs,
+  stefanBoltzmann: stefanBoltzmannDocs,
+  wienDisplacement: wienDisplacementDocs,
   // spectralRadiance: {description: 'First radiation constant for spectral radiance', examples: ['spectralRadiance']},
-  molarMass: { description: "Molar mass constant", examples: ["molarMass"] },
-  molarMassC12: { description: "Molar mass constant of carbon-12", examples: ["molarMassC12"] },
-  gravity: {
-    description: "Standard acceleration of gravity (standard acceleration of free-fall on Earth)",
-    examples: ["gravity"]
-  },
-  planckLength: { description: "Planck length", examples: ["planckLength"] },
-  planckMass: { description: "Planck mass", examples: ["planckMass"] },
-  planckTime: { description: "Planck time", examples: ["planckTime"] },
-  planckCharge: { description: "Planck charge", examples: ["planckCharge"] },
-  planckTemperature: { description: "Planck temperature", examples: ["planckTemperature"] },
+  molarMass: molarMassDocs,
+  molarMassC12: molarMassC12Docs,
+  gravity: gravityDocs,
+  planckLength: planckLengthDocs,
+  planckMass: planckMassDocs,
+  planckTime: planckTimeDocs,
+  planckCharge: planckChargeDocs,
+  planckTemperature: planckTemperatureDocs,
   // functions - algebra
   derivative: derivativeDocs,
   lsolve: lsolveDocs,
@@ -6710,75 +7256,6 @@ var embeddedDocs = {
   gammainc: gammaincDocs
 };
 
-// src/utils/customs.ts
-function getSafeProperty(object, prop) {
-  if (isSafeProperty(object, prop)) {
-    return object[prop];
-  }
-  if (typeof object[prop] === "function" && isSafeMethod(object, prop)) {
-    throw new Error('Cannot access method "' + String(prop) + '" as a property');
-  }
-  throw new Error('No access to property "' + String(prop) + '"');
-}
-function setSafeProperty(object, prop, value) {
-  if (isSafeProperty(object, prop)) {
-    object[prop] = value;
-    return value;
-  }
-  throw new Error('No access to property "' + String(prop) + '"');
-}
-function isSafeProperty(object, prop) {
-  if (!isPlainObject(object) && !Array.isArray(object)) {
-    return false;
-  }
-  if (hasOwnProperty(safeNativeProperties, prop)) {
-    return true;
-  }
-  if (prop in Object.prototype) {
-    return false;
-  }
-  if (prop in Function.prototype) {
-    return false;
-  }
-  return true;
-}
-function getSafeMethod(object, method) {
-  if (!isSafeMethod(object, method)) {
-    throw new Error('No access to method "' + String(method) + '"');
-  }
-  return object[method];
-}
-function isSafeMethod(object, method) {
-  if (object === null || object === void 0 || typeof object[method] !== "function") {
-    return false;
-  }
-  if (hasOwnProperty(object, method) && Object.getPrototypeOf && method in Object.getPrototypeOf(object)) {
-    return false;
-  }
-  if (hasOwnProperty(safeNativeMethods, method)) {
-    return true;
-  }
-  if (method in Object.prototype) {
-    return false;
-  }
-  if (method in Function.prototype) {
-    return false;
-  }
-  return true;
-}
-function isPlainObject(object) {
-  return typeof object === "object" && !!object && object.constructor === Object;
-}
-var safeNativeProperties = {
-  length: true,
-  name: true
-};
-var safeNativeMethods = {
-  toString: true,
-  valueOf: true,
-  toLocaleString: true
-};
-
 // src/compiler/compile.ts
 function compile(node, mathScope) {
   const evalFn = compileNode(node, mathScope, {});
@@ -7860,6 +8337,72 @@ function errorTransform(err) {
   return err;
 }
 
+// src/utils/array.ts
+import {
+  arraySize,
+  validate,
+  validateIndexSourceSize,
+  validateIndex,
+  isEmptyIndex,
+  resize,
+  reshape,
+  processSizesWildcard,
+  squeeze,
+  unsqueeze,
+  flatten,
+  map,
+  forEach,
+  filter,
+  filterRegExp,
+  join,
+  identify,
+  generalize,
+  getArrayDataType,
+  last,
+  initial,
+  concat,
+  broadcastSizes,
+  checkBroadcastingRules,
+  broadcastTo,
+  broadcastArrays,
+  stretch,
+  getArrayElement,
+  deepMapArray,
+  deepForEachArray,
+  cloneArray
+} from "@danielsimonjr/mathts-core/internal";
+
+// src/error/DimensionError.ts
+import { DimensionError } from "@danielsimonjr/mathts-core/internal";
+
+// src/node/utils/stringSubset.ts
+function getStringSubset(str, index) {
+  if (!isIndex(index)) {
+    throw new TypeError("Index expected");
+  }
+  if (isEmptyIndex(index)) {
+    return "";
+  }
+  validateIndexSourceSize(Array.from(str), index);
+  if (index.size().length !== 1) {
+    throw new DimensionError(index.size().length, 1);
+  }
+  const strLen = str.length;
+  validateIndex(index.min()[0], strLen);
+  validateIndex(index.max()[0], strLen);
+  const range = index.dimension(0);
+  let substr = "";
+  function callback(v) {
+    substr += str.charAt(v);
+  }
+  if (Number.isInteger(range)) {
+    callback(range);
+  } else {
+    range.forEach(callback);
+  }
+  return substr;
+}
+
 // src/node/utils/access.ts
 function accessFactory({ subset }) {
   return function access(object, index) {
@@ -7869,7 +8412,7 @@ function accessFactory({ subset }) {
       } else if (object && typeof object.subset === "function") {
         return object.subset(index);
       } else if (typeof object === "string") {
-        return subset(object, index);
+        return getStringSubset(object, index);
       } else if (typeof object === "object") {
         if (!index.isObjectProperty()) {
           throw new TypeError("Cannot apply a numeric index as object property");
@@ -8085,41 +8628,6 @@ var createAccessorNode = /* @__PURE__ */ factory(
   { isClass: true, isNode: true }
 );
 
-// src/utils/array.ts
-import {
-  arraySize,
-  validate,
-  validateIndexSourceSize,
-  validateIndex,
-  isEmptyIndex,
-  resize,
-  reshape,
-  processSizesWildcard,
-  squeeze,
-  unsqueeze,
-  flatten,
-  map,
-  forEach,
-  filter,
-  filterRegExp,
-  join,
-  identify,
-  generalize,
-  getArrayDataType,
-  last,
-  initial,
-  concat,
-  broadcastSizes,
-  checkBroadcastingRules,
-  broadcastTo,
-  broadcastArrays,
-  stretch,
-  getArrayElement,
-  deepMapArray,
-  deepForEachArray,
-  cloneArray
-} from "@danielsimonjr/mathts-core/internal";
-
 // src/node/ArrayNode.ts
 var name7 = "ArrayNode";
 var dependencies7 = ["Node"];
@@ -10432,14 +10940,14 @@ var createObjectNode = /* @__PURE__ */ factory(
             const stringifiedKey = stringify(key);
             const parsedKey = JSON.parse(stringifiedKey);
             const prop = getSafeProperty(this.properties, key);
-            evalEntries[parsedKey] = prop._compile(math, argNames);
+            setSafeProperty(evalEntries, parsedKey, prop._compile(math, argNames));
           }
         }
         return function evalObjectNode(scope, args, context) {
           const obj = {};
           for (const key in evalEntries) {
             if (hasOwnProperty(evalEntries, key)) {
-              obj[key] = evalEntries[key](scope, args, context);
+              setSafeProperty(obj, key, evalEntries[key](scope, args, context));
             }
           }
           return obj;