Socket
Socket
Sign inDemoInstall

@mathigon/hilbert

Package Overview
Dependencies
Maintainers
1
Versions
56
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@mathigon/hilbert - npm Package Compare versions

Comparing version 1.0.1 to 1.0.2

794

dist/index.cjs.js

@@ -0,2 +1,7 @@

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });

@@ -8,2 +13,13 @@ var __export = (target, all) => {

};
var __reExport = (target, module2, desc) => {
if (module2 && typeof module2 === "object" || typeof module2 === "function") {
for (let key of __getOwnPropNames(module2))
if (!__hasOwnProp.call(target, key) && key !== "default")
__defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
}
return target;
};
var __toModule = (module2) => {
return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
};

@@ -60,699 +76,6 @@ // src/index.ts

// node_modules/@mathigon/core/dist/index.esm.js
function isOneOf(x, ...values) {
return values.includes(x);
}
var CacheError = class extends Error {
constructor(data) {
super("[Cache Error]");
this.data = data;
}
};
function cache(fn) {
const cached = new Map();
return function(...args) {
const argString = args.join("--");
if (!cached.has(argString)) {
try {
cached.set(argString, fn(...args));
} catch (e) {
cached.set(argString, new CacheError(e));
}
}
const value = cached.get(argString);
if (value instanceof CacheError)
throw value.data;
return value;
};
}
function repeat(value, n) {
return new Array(n).fill(value);
}
function last(array, i = 0) {
return array[array.length - 1 - i];
}
function total(array) {
return array.reduce((t, v) => t + v, 0);
}
function unique(array) {
return array.filter((a, i) => array.indexOf(a) === i);
}
function flatten(array) {
return array.reduce((a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []);
}
function join(...arrays) {
return arrays.reduce((a, x) => a.concat(x), []);
}
function words(str, divider = /\s+/) {
if (!str)
return [];
return str.trim().split(divider);
}
var Itarray = class {
constructor(...values) {
this.values = values;
}
map(fn) {
const values = this.values;
return new Itarray(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
yield fn(v, i);
i += 1;
}
}
}());
}
every(fn) {
let i = 0;
for (const row of this.values) {
for (const v of row) {
if (!fn(v, i))
return false;
i += 1;
}
}
return true;
}
some(fn) {
let i = 0;
for (const row of this.values) {
for (const v of row) {
if (fn(v, i))
return true;
i += 1;
}
}
return false;
}
slice(from, to) {
const values = this.values;
return new Itarray(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
if (i < from || to !== void 0 && i > from + to)
continue;
yield v;
i += 1;
}
}
}());
}
filter(fn) {
const values = this.values;
return new Itarray(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
if (fn(v, i))
yield v;
i += 1;
}
}
}());
}
concat(newValues) {
this.values.push(newValues);
}
[Symbol.iterator]() {
const values = this.values;
return function* () {
for (const row of values) {
for (const v of row) {
yield v;
}
}
}();
}
static make(fn, max) {
return new Itarray(function* () {
let i = 0;
while (max === void 0 || i < max) {
yield fn(i);
i += 1;
}
}());
}
};
// src/expression.ts
var import_core4 = __toModule(require("@mathigon/core"));
var import_fermat2 = __toModule(require("@mathigon/fermat"));
// node_modules/@mathigon/fermat/node_modules/@mathigon/core/dist/index.esm.js
function uid(n = 10) {
return Math.random().toString(36).substr(2, n);
}
function repeat2(value, n) {
return new Array(n).fill(value);
}
function repeat2D(value, x, y) {
const result = [];
for (let i = 0; i < x; ++i) {
result.push(repeat2(value, y));
}
return result;
}
function tabulate2D(fn, x, y) {
const result = [];
for (let i = 0; i < x; ++i) {
const row = [];
for (let j = 0; j < y; ++j) {
row.push(fn(i, j));
}
result.push(row);
}
return result;
}
function list(a, b, step = 1) {
const arr = [];
if (b === void 0 && a >= 0) {
for (let i = 0; i < a; i += step)
arr.push(i);
} else if (b === void 0) {
for (let i = 0; i > a; i -= step)
arr.push(i);
} else if (a <= b) {
for (let i = a; i <= b; i += step)
arr.push(i);
} else {
for (let i = a; i >= b; i -= step)
arr.push(i);
}
return arr;
}
function total2(array) {
return array.reduce((t, v) => t + v, 0);
}
var Itarray2 = class {
constructor(...values) {
this.values = values;
}
map(fn) {
const values = this.values;
return new Itarray2(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
yield fn(v, i);
i += 1;
}
}
}());
}
every(fn) {
let i = 0;
for (const row of this.values) {
for (const v of row) {
if (!fn(v, i))
return false;
i += 1;
}
}
return true;
}
some(fn) {
let i = 0;
for (const row of this.values) {
for (const v of row) {
if (fn(v, i))
return true;
i += 1;
}
}
return false;
}
slice(from, to) {
const values = this.values;
return new Itarray2(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
if (i < from || to !== void 0 && i > from + to)
continue;
yield v;
i += 1;
}
}
}());
}
filter(fn) {
const values = this.values;
return new Itarray2(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
if (fn(v, i))
yield v;
i += 1;
}
}
}());
}
concat(newValues) {
this.values.push(newValues);
}
[Symbol.iterator]() {
const values = this.values;
return function* () {
for (const row of values) {
for (const v of row) {
yield v;
}
}
}();
}
static make(fn, max) {
return new Itarray2(function* () {
let i = 0;
while (max === void 0 || i < max) {
yield fn(i);
i += 1;
}
}());
}
};
// node_modules/@mathigon/fermat/dist/index.esm.js
var __defProp2 = Object.defineProperty;
var __markAsModule2 = (target) => __defProp2(target, "__esModule", { value: true });
var __export2 = (target, all) => {
__markAsModule2(target);
for (var name in all)
__defProp2(target, name, { get: all[name], enumerable: true });
};
var PRECISION = 1e-6;
function nearlyEquals(a, b, t = PRECISION) {
if (isNaN(a) || isNaN(b))
return false;
return Math.abs(a - b) < t;
}
function isBetween(value, a, b, t = PRECISION) {
if (a > b)
[a, b] = [b, a];
return value > a + t && value < b - t;
}
function gcd(...numbers) {
const [first, ...rest] = numbers;
if (rest.length > 1)
return gcd(first, gcd(...rest));
let a = Math.abs(first);
let b = Math.abs(rest[0]);
while (b)
[a, b] = [b, a % b];
return a;
}
function lcm(...numbers) {
const [first, ...rest] = numbers;
if (rest.length > 1)
return lcm(first, lcm(...rest));
return Math.abs(first * rest[0]) / gcd(first, rest[0]);
}
var matrix_exports = {};
__export2(matrix_exports, {
determinant: () => determinant,
fill: () => fill,
identity: () => identity,
inverse: () => inverse,
product: () => product,
reflection: () => reflection,
rotation: () => rotation,
scalarProduct: () => scalarProduct,
shear: () => shear,
sum: () => sum,
transpose: () => transpose
});
function fill(value, x, y) {
return repeat2D(value, x, y);
}
function identity(n = 2) {
const x = fill(0, n, n);
for (let i = 0; i < n; ++i)
x[i][i] = 1;
return x;
}
function rotation(angle) {
const sin = Math.sin(angle);
const cos = Math.cos(angle);
return [[cos, -sin], [sin, cos]];
}
function shear(lambda) {
return [[1, lambda], [0, 1]];
}
function reflection(angle) {
const sin = Math.sin(2 * angle);
const cos = Math.cos(2 * angle);
return [[cos, sin], [sin, -cos]];
}
function sum(...matrices) {
const [M1, ...rest] = matrices;
const M2 = rest.length > 1 ? sum(...rest) : rest[0];
if (M1.length !== M2.length || M1[0].length !== M2[0].length) {
throw new Error("Matrix sizes don\u2019t match");
}
const S = [];
for (let i = 0; i < M1.length; ++i) {
const row = [];
for (let j = 0; j < M1[i].length; ++j) {
row.push(M1[i][j] + M2[i][j]);
}
S.push(row);
}
return S;
}
function scalarProduct(M, v) {
return M.map((row) => row.map((x) => x * v));
}
function product(...matrices) {
const [M1, ...rest] = matrices;
const M2 = rest.length > 1 ? product(...rest) : rest[0];
if (M1[0].length !== M2.length) {
throw new Error("Matrix sizes don\u2019t match.");
}
const P2 = [];
for (let i = 0; i < M1.length; ++i) {
const row = [];
for (let j = 0; j < M2[0].length; ++j) {
let value = 0;
for (let k = 0; k < M2.length; ++k) {
value += M1[i][k] * M2[k][j];
}
row.push(value);
}
P2.push(row);
}
return P2;
}
function transpose(M) {
const T = [];
for (let j = 0; j < M[0].length; ++j) {
const row = [];
for (let i = 0; i < M.length; ++i) {
row.push(M[i][j]);
}
T.push(row);
}
return T;
}
function determinant(M) {
if (M.length !== M[0].length)
throw new Error("Not a square matrix.");
const n = M.length;
if (n === 1)
return M[0][0];
if (n === 2)
return M[0][0] * M[1][1] - M[0][1] * M[1][0];
let det = 0;
for (let j = 0; j < n; ++j) {
let diagLeft = M[0][j];
let diagRight = M[0][j];
for (let i = 1; i < n; ++i) {
diagRight *= M[i][j + i % n];
diagLeft *= M[i][j - i % n];
}
det += diagRight - diagLeft;
}
return det;
}
function inverse(M) {
const n = M.length;
if (n !== M[0].length)
throw new Error("Not a square matrix.");
const I = identity(n);
const C = tabulate2D((x, y) => M[x][y], n, n);
for (let i = 0; i < n; ++i) {
let e = C[i][i];
if (!e) {
for (let ii = i + 1; ii < n; ++ii) {
if (C[ii][i] !== 0) {
for (let j = 0; j < n; ++j) {
[C[ii][j], C[i][j]] = [C[i][j], C[ii][j]];
[I[ii][j], I[i][j]] = [I[i][j], I[ii][j]];
}
break;
}
}
e = C[i][i];
if (!e)
throw new Error("Matrix not invertible.");
}
for (let j = 0; j < n; ++j) {
C[i][j] = C[i][j] / e;
I[i][j] = I[i][j] / e;
}
for (let ii = 0; ii < n; ++ii) {
if (ii === i)
continue;
const f = C[ii][i];
for (let j = 0; j < n; ++j) {
C[ii][j] -= f * C[i][j];
I[ii][j] -= f * I[i][j];
}
}
}
return I;
}
var random_exports = {};
__export2(random_exports, {
bernoulli: () => bernoulli,
binomial: () => binomial2,
cauchy: () => cauchy,
chiCDF: () => chiCDF,
exponential: () => exponential,
find: () => find,
geometric: () => geometric,
integer: () => integer,
integrate: () => integrate,
normal: () => normal,
normalPDF: () => normalPDF,
poisson: () => poisson,
shuffle: () => shuffle,
smart: () => smart,
uniform: () => uniform,
weighted: () => weighted
});
function shuffle(a) {
a = a.slice(0);
for (let i = a.length - 1; i > 0; --i) {
const j = Math.floor(Math.random() * (i + 1));
[a[i], a[j]] = [a[j], a[i]];
}
return a;
}
function integer(a, b) {
const start = b === void 0 ? 0 : a;
const length = b === void 0 ? a : b - a + 1;
return start + Math.floor(length * Math.random());
}
function weighted(weights) {
const x = Math.random() * total2(weights);
let cum = 0;
return weights.findIndex((w) => (cum += w) >= x);
}
function find(items) {
return items[Math.floor(items.length * Math.random())];
}
var SMART_RANDOM_CACHE = new Map();
function smart(n, id) {
if (!id)
id = uid();
if (!SMART_RANDOM_CACHE.has(id))
SMART_RANDOM_CACHE.set(id, repeat2(1, n));
const cache2 = SMART_RANDOM_CACHE.get(id);
const x = weighted(cache2.map((x2) => x2 * x2));
cache2[x] -= 1;
if (cache2[x] <= 0)
SMART_RANDOM_CACHE.set(id, cache2.map((x2) => x2 + 1));
return x;
}
function bernoulli(p = 0.5) {
return Math.random() < p ? 1 : 0;
}
function binomial2(n = 1, p = 0.5) {
let t = 0;
for (let i = 0; i < n; ++i)
t += bernoulli(p);
return t;
}
function poisson(l = 1) {
if (l <= 0)
return 0;
const L = Math.exp(-l);
let p = 1;
let k = 0;
for (; p > L; ++k)
p *= Math.random();
return k - 1;
}
function uniform(a = 0, b = 1) {
return a + (b - a) * Math.random();
}
function normal(m = 0, v = 1) {
const u1 = Math.random();
const u2 = Math.random();
const rand = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
return rand * Math.sqrt(v) + m;
}
function exponential(l = 1) {
return l <= 0 ? 0 : -Math.log(Math.random()) / l;
}
function geometric(p = 0.5) {
if (p <= 0 || p > 1)
return void 0;
return Math.floor(Math.log(Math.random()) / Math.log(1 - p));
}
function cauchy() {
let rr;
let v1;
let v2;
do {
v1 = 2 * Math.random() - 1;
v2 = 2 * Math.random() - 1;
rr = v1 * v1 + v2 * v2;
} while (rr >= 1);
return v1 / v2;
}
function normalPDF(x, m = 1, v = 0) {
return Math.exp(-((x - m) ** 2) / (2 * v)) / Math.sqrt(2 * Math.PI * v);
}
var G = 7;
var P = [
0.9999999999998099,
676.5203681218851,
-1259.1392167224028,
771.3234287776531,
-176.6150291621406,
12.507343278686905,
-0.13857109526572012,
9984369578019572e-21,
15056327351493116e-23
];
function gamma(z) {
if (z < 0.5)
return Math.PI / (Math.sin(Math.PI * z) * gamma(1 - z));
z -= 1;
let x = P[0];
for (let i = 1; i < G + 2; i++)
x += P[i] / (z + i);
const t = z + G + 0.5;
return Math.sqrt(2 * Math.PI) * Math.pow(t, z + 0.5) * Math.exp(-t) * x;
}
function integrate(fn, xMin, xMax, dx = 1) {
let result = 0;
for (let x = xMin; x < xMax; x += dx) {
result += fn(x) * dx || 0;
}
return result;
}
function chiCDF(chi, deg) {
const int2 = integrate((t) => Math.pow(t, (deg - 2) / 2) * Math.exp(-t / 2), 0, chi);
return 1 - int2 / Math.pow(2, deg / 2) / gamma(deg / 2);
}
var regression_exports = {};
__export2(regression_exports, {
bestPolynomial: () => bestPolynomial,
coefficient: () => coefficient,
exponential: () => exponential2,
linear: () => linear,
logarithmic: () => logarithmic,
polynomial: () => polynomial2,
power: () => power
});
function evaluatePolynomial(regression, x) {
let xs = 1;
let t = regression[0];
for (let i = 1; i < regression.length; ++i) {
xs *= x;
t += xs * regression[i];
}
return t;
}
function linear(data, throughOrigin = false) {
let sX = 0;
let sY = 0;
let sXX = 0;
let sXY = 0;
const len = data.length;
for (let n = 0; n < len; n++) {
sX += data[n][0];
sY += data[n][1];
sXX += data[n][0] * data[n][0];
sXY += data[n][0] * data[n][1];
}
if (throughOrigin) {
const gradient2 = sXY / sXX;
return [0, gradient2];
}
const gradient = (len * sXY - sX * sY) / (len * sXX - sX * sX);
const intercept = sY / len - gradient * sX / len;
return [intercept, gradient];
}
function exponential2(data) {
const sum2 = [0, 0, 0, 0, 0, 0];
for (const d of data) {
sum2[0] += d[0];
sum2[1] += d[1];
sum2[2] += d[0] * d[0] * d[1];
sum2[3] += d[1] * Math.log(d[1]);
sum2[4] += d[0] * d[1] * Math.log(d[1]);
sum2[5] += d[0] * d[1];
}
const denominator = sum2[1] * sum2[2] - sum2[5] * sum2[5];
const a = Math.exp((sum2[2] * sum2[3] - sum2[5] * sum2[4]) / denominator);
const b = (sum2[1] * sum2[4] - sum2[5] * sum2[3]) / denominator;
return [a, b];
}
function logarithmic(data) {
const sum2 = [0, 0, 0, 0];
const len = data.length;
for (const d of data) {
sum2[0] += Math.log(d[0]);
sum2[1] += d[1] * Math.log(d[0]);
sum2[2] += d[1];
sum2[3] += Math.pow(Math.log(d[0]), 2);
}
const b = (len * sum2[1] - sum2[2] * sum2[0]) / (len * sum2[3] - sum2[0] * sum2[0]);
const a = (sum2[2] - b * sum2[0]) / len;
return [a, b];
}
function power(data) {
const sum2 = [0, 0, 0, 0];
const len = data.length;
for (const d of data) {
sum2[0] += Math.log(d[0]);
sum2[1] += Math.log(d[1]) * Math.log(d[0]);
sum2[2] += Math.log(d[1]);
sum2[3] += Math.pow(Math.log(d[0]), 2);
}
const b = (len * sum2[1] - sum2[2] * sum2[0]) / (len * sum2[3] - sum2[0] * sum2[0]);
const a = Math.exp((sum2[2] - b * sum2[0]) / len);
return [a, b];
}
function polynomial2(data, order = 2) {
const X = data.map((d) => list(order + 1).map((p) => Math.pow(d[0], p)));
const XT = transpose(X);
const y = data.map((d) => [d[1]]);
const XTX = product(XT, X);
const inv = inverse(XTX);
const r = product(inv, XT, y);
return r.map((x) => x[0]);
}
function coefficient(data, fn) {
const total4 = data.reduce((sum2, d) => sum2 + d[1], 0);
const mean2 = total4 / data.length;
const ssyy = data.reduce((sum2, d) => sum2 + (d[1] - mean2) ** 2, 0);
const sse = data.reduce((sum2, d) => sum2 + (d[1] - fn(d[0])) ** 2, 0);
return 1 - sse / ssyy;
}
function bestPolynomial(data, threshold = 0.85, maxOrder = 8) {
if (data.length <= 1)
return void 0;
for (let i = 1; i < maxOrder; ++i) {
const reg = polynomial2(data, i);
const fn = (x) => evaluatePolynomial(reg, x);
const coeff = coefficient(data, fn);
if (coeff >= threshold)
return { order: i, coefficients: reg, fn };
}
return void 0;
}
// src/symbols.ts

@@ -934,2 +257,5 @@ var CONSTANTS = {

// src/parser.ts
var import_core3 = __toModule(require("@mathigon/core"));
// src/elements.ts

@@ -1090,3 +416,8 @@ var toNumber = (x) => typeof x === "number" ? x : x[0];

// src/functions.ts
var import_core2 = __toModule(require("@mathigon/core"));
// src/eval.ts
var import_core = __toModule(require("@mathigon/core"));
var import_fermat = __toModule(require("@mathigon/fermat"));
var WHOLE = [-Infinity, Infinity];

@@ -1101,3 +432,3 @@ var EMPTY = [NaN, NaN];

var isInfinite = (a) => !isFinite(a[0]) && a[0] === a[1];
var contains = (a, v) => isBetween(v, a[0] - Number.EPSILON, a[1] + Number.EPSILON);
var contains = (a, v) => (0, import_fermat.isBetween)(v, a[0] - Number.EPSILON, a[1] + Number.EPSILON);
var hasZero = (a) => contains(a, 0);

@@ -1116,5 +447,5 @@ var evaluate = {

mod: (a, b) => a % b,
lcm: (...args) => lcm(...args),
gcd: (...args) => gcd(...args),
gcf: (...args) => gcd(...args),
lcm: (...args) => (0, import_fermat.lcm)(...args),
gcd: (...args) => (0, import_fermat.gcd)(...args),
gcf: (...args) => (0, import_fermat.gcd)(...args),
sup: (a, b) => Math.pow(a, b),

@@ -1168,3 +499,3 @@ log: (a, b) => Math.log(a) / (b === void 0 ? 1 : Math.log(b)),

var interval = {
add: (...args) => int(total(args.map((a) => a[0])), total(args.map((a) => a[1]))),
add: (...args) => int((0, import_core.total)(args.map((a) => a[0])), (0, import_core.total)(args.map((a) => a[1]))),
sub: (a, b) => b !== void 0 ? int(a[0] - b[1], a[1] - b[0]) : int(-a[1], -a[0]),

@@ -1194,4 +525,4 @@ mul: (a, ...b) => {

},
lcm: (...args) => range(lcm(...args.map((a) => a[0]))),
gcd: (...args) => range(gcd(...args.map((a) => a[0]))),
lcm: (...args) => range((0, import_fermat.lcm)(...args.map((a) => a[0]))),
gcd: (...args) => range((0, import_fermat.gcd)(...args.map((a) => a[0]))),
gcf: (...args) => interval.gcd(...args),

@@ -1265,4 +596,4 @@ sup: (a, b) => pow(a, b),

// src/functions.ts
var PRECEDENCE = words("+ \u2212 * \xD7 \xB7 / \xF7 // sup sub subsup");
var SUBSUP = words("sub sup subsup");
var PRECEDENCE = (0, import_core2.words)("+ \u2212 * \xD7 \xB7 / \xF7 // sup sub subsup");
var SUBSUP = (0, import_core2.words)("sub sup subsup");
var COMMA = '<mo value="," lspace="0">,</mo>';

@@ -1320,3 +651,3 @@ function needsBrackets(expr, parentFn) {

if (this.fn in vars)
return repeat(this.evaluate(vars), 2);
return (0, import_core2.repeat)(this.evaluate(vars), 2);
const args = this.args.map((a) => a.interval(vars));

@@ -1351,6 +682,6 @@ if (this.fn === "+")

get variables() {
return unique(flatten(this.args.map((a) => a.variables)));
return (0, import_core2.unique)((0, import_core2.flatten)(this.args.map((a) => a.variables)));
}
get functions() {
return unique([this.fn, ...flatten(this.args.map((a) => a.functions))]);
return (0, import_core2.unique)([this.fn, ...(0, import_core2.flatten)(this.args.map((a) => a.functions))]);
}

@@ -1368,9 +699,9 @@ toString() {

return `${args[0]}_${args[1]}^${args[2]}`;
if (words("+ * \xD7 \xB7 / = < > \u2264 \u2265 \u2248").includes(this.fn)) {
if ((0, import_core2.words)("+ * \xD7 \xB7 / = < > \u2264 \u2265 \u2248").includes(this.fn)) {
return args.join(` ${this.fn} `);
}
if (isOneOf(this.fn, "(", "[", "{")) {
if ((0, import_core2.isOneOf)(this.fn, "(", "[", "{")) {
return this.fn + this.args.join(", ") + BRACKETS[this.fn];
}
if (isOneOf(this.fn, "!", "%"))
if ((0, import_core2.isOneOf)(this.fn, "!", "%"))
return args[0] + this.fn;

@@ -1392,7 +723,7 @@ return `${this.fn}(${args.join(", ")})`;

}
if (isOneOf(this.fn, "+", "=", "<", ">", "\u2264", "\u2265", "\u2248")) {
if ((0, import_core2.isOneOf)(this.fn, "+", "=", "<", ">", "\u2264", "\u2265", "\u2248")) {
const fn = escape(this.fn);
return argsF.join(`<mo value="${fn}">${fn}</mo>`);
}
if (isOneOf(this.fn, "*", "\xD7", "\xB7")) {
if ((0, import_core2.isOneOf)(this.fn, "*", "\xD7", "\xB7")) {
let str = argsF[0];

@@ -1409,3 +740,3 @@ for (let i = 1; i < argsF.length - 1; ++i) {

return `<msqrt>${argsF[0]}</msqrt>`;
if (isOneOf(this.fn, "/", "root")) {
if ((0, import_core2.isOneOf)(this.fn, "/", "root")) {
const el = this.fn === "/" ? "mfrac" : "mroot";

@@ -1415,3 +746,3 @@ const args1 = this.args.map((a, i) => addMRow(a, args[i]));

}
if (isOneOf(this.fn, "sup", "sub")) {
if ((0, import_core2.isOneOf)(this.fn, "sup", "sub")) {
const args1 = [

@@ -1431,6 +762,6 @@ addMRow(this.args[0], argsF[0]),

}
if (isOneOf(this.fn, "(", "[", "{")) {
if ((0, import_core2.isOneOf)(this.fn, "(", "[", "{")) {
return `<mfenced open="${this.fn}" close="${BRACKETS[this.fn]}">${argsF.join(COMMA)}</mfenced>`;
}
if (isOneOf(this.fn, "!", "%")) {
if ((0, import_core2.isOneOf)(this.fn, "!", "%")) {
return `${argsF[0]}<mo value="${this.fn}" lspace="0">${this.fn}</mo>`;

@@ -1460,3 +791,3 @@ }

}
if (isOneOf(this.fn, "(", "[", "{"))
if ((0, import_core2.isOneOf)(this.fn, "(", "[", "{"))
return joined;

@@ -1504,3 +835,3 @@ if (this.fn === "sqrt")

get variables() {
return unique(join(...this.items.map((i) => i.variables)));
return (0, import_core2.unique)((0, import_core2.join)(...this.items.map((i) => i.variables)));
}

@@ -1562,3 +893,2 @@ get functions() {

}
return;
}

@@ -1612,3 +942,3 @@ function tokenize(str) {

} else {
last(result).push(i);
(0, import_core3.last)(result).push(i);
}

@@ -1619,3 +949,3 @@ }

function isOperator(expr, fns) {
return expr instanceof ExprOperator && words(fns).includes(expr.o);
return expr instanceof ExprOperator && (0, import_core3.words)(fns).includes(expr.o);
}

@@ -1628,4 +958,4 @@ function removeBrackets(expr) {

throw ExprError.startOperator(tokens[0]);
if (isOperator(last(tokens), fn))
throw ExprError.endOperator(last(tokens));
if (isOperator((0, import_core3.last)(tokens), fn))
throw ExprError.endOperator((0, import_core3.last)(tokens));
for (let i = 1; i < tokens.length - 1; ++i) {

@@ -1670,3 +1000,3 @@ if (!isOperator(tokens[i], fn))

for (const t of tokens) {
const lastOpen = last(stack).length ? last(stack)[0].o : void 0;
const lastOpen = (0, import_core3.last)(stack).length ? (0, import_core3.last)(stack)[0].o : void 0;
if (isOperator(t, ") ] }")) {

@@ -1677,4 +1007,4 @@ if (!isOperator(t, BRACKETS[lastOpen])) {

const closed = stack.pop();
const term = last(stack);
const lastTerm = last(term);
const term = (0, import_core3.last)(stack);
const lastTerm = (0, import_core3.last)(term);
const isFn = isOperator(t, ")") && lastTerm instanceof ExprIdentifier && !safeVariables.includes(lastTerm.i);

@@ -1687,7 +1017,7 @@ const fnName = isFn ? term.pop().i : closed[0].o;

} else {
last(stack).push(t);
(0, import_core3.last)(stack).push(t);
}
}
if (stack.length > 1) {
throw ExprError.unclosedBracket(last(stack)[0].o);
throw ExprError.unclosedBracket((0, import_core3.last)(stack)[0].o);
}

@@ -1771,3 +1101,3 @@ return prepareTerm(stack[0]);

try {
const vars = unique([...expr1.variables, ...expr2.variables]);
const vars = (0, import_core4.unique)([...expr1.variables, ...expr2.variables]);
const fn1 = expr1.collapse();

@@ -1784,3 +1114,3 @@ const fn2 = expr2.collapse();

continue;
if (!nearlyEquals(a, b))
if (!(0, import_fermat2.nearlyEquals)(a, b))
return false;

@@ -1796,4 +1126,4 @@ matches += 1;

numEquals,
parse: cache(parse)
parse: (0, import_core4.cache)(parse)
};
//# sourceMappingURL=index.cjs.js.map

712

dist/index.esm.js

@@ -39,699 +39,6 @@ // src/errors.ts

// node_modules/@mathigon/core/dist/index.esm.js
function isOneOf(x, ...values) {
return values.includes(x);
}
var CacheError = class extends Error {
constructor(data) {
super("[Cache Error]");
this.data = data;
}
};
function cache(fn) {
const cached = new Map();
return function(...args) {
const argString = args.join("--");
if (!cached.has(argString)) {
try {
cached.set(argString, fn(...args));
} catch (e) {
cached.set(argString, new CacheError(e));
}
}
const value = cached.get(argString);
if (value instanceof CacheError)
throw value.data;
return value;
};
}
function repeat(value, n) {
return new Array(n).fill(value);
}
function last(array, i = 0) {
return array[array.length - 1 - i];
}
function total(array) {
return array.reduce((t, v) => t + v, 0);
}
function unique(array) {
return array.filter((a, i) => array.indexOf(a) === i);
}
function flatten(array) {
return array.reduce((a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []);
}
function join(...arrays) {
return arrays.reduce((a, x) => a.concat(x), []);
}
function words(str, divider = /\s+/) {
if (!str)
return [];
return str.trim().split(divider);
}
var Itarray = class {
constructor(...values) {
this.values = values;
}
map(fn) {
const values = this.values;
return new Itarray(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
yield fn(v, i);
i += 1;
}
}
}());
}
every(fn) {
let i = 0;
for (const row of this.values) {
for (const v of row) {
if (!fn(v, i))
return false;
i += 1;
}
}
return true;
}
some(fn) {
let i = 0;
for (const row of this.values) {
for (const v of row) {
if (fn(v, i))
return true;
i += 1;
}
}
return false;
}
slice(from, to) {
const values = this.values;
return new Itarray(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
if (i < from || to !== void 0 && i > from + to)
continue;
yield v;
i += 1;
}
}
}());
}
filter(fn) {
const values = this.values;
return new Itarray(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
if (fn(v, i))
yield v;
i += 1;
}
}
}());
}
concat(newValues) {
this.values.push(newValues);
}
[Symbol.iterator]() {
const values = this.values;
return function* () {
for (const row of values) {
for (const v of row) {
yield v;
}
}
}();
}
static make(fn, max) {
return new Itarray(function* () {
let i = 0;
while (max === void 0 || i < max) {
yield fn(i);
i += 1;
}
}());
}
};
// src/expression.ts
import { cache, unique as unique2 } from "@mathigon/core";
import { nearlyEquals } from "@mathigon/fermat";
// node_modules/@mathigon/fermat/node_modules/@mathigon/core/dist/index.esm.js
function uid(n = 10) {
return Math.random().toString(36).substr(2, n);
}
function repeat2(value, n) {
return new Array(n).fill(value);
}
function repeat2D(value, x, y) {
const result = [];
for (let i = 0; i < x; ++i) {
result.push(repeat2(value, y));
}
return result;
}
function tabulate2D(fn, x, y) {
const result = [];
for (let i = 0; i < x; ++i) {
const row = [];
for (let j = 0; j < y; ++j) {
row.push(fn(i, j));
}
result.push(row);
}
return result;
}
function list(a, b, step = 1) {
const arr = [];
if (b === void 0 && a >= 0) {
for (let i = 0; i < a; i += step)
arr.push(i);
} else if (b === void 0) {
for (let i = 0; i > a; i -= step)
arr.push(i);
} else if (a <= b) {
for (let i = a; i <= b; i += step)
arr.push(i);
} else {
for (let i = a; i >= b; i -= step)
arr.push(i);
}
return arr;
}
function total2(array) {
return array.reduce((t, v) => t + v, 0);
}
var Itarray2 = class {
constructor(...values) {
this.values = values;
}
map(fn) {
const values = this.values;
return new Itarray2(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
yield fn(v, i);
i += 1;
}
}
}());
}
every(fn) {
let i = 0;
for (const row of this.values) {
for (const v of row) {
if (!fn(v, i))
return false;
i += 1;
}
}
return true;
}
some(fn) {
let i = 0;
for (const row of this.values) {
for (const v of row) {
if (fn(v, i))
return true;
i += 1;
}
}
return false;
}
slice(from, to) {
const values = this.values;
return new Itarray2(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
if (i < from || to !== void 0 && i > from + to)
continue;
yield v;
i += 1;
}
}
}());
}
filter(fn) {
const values = this.values;
return new Itarray2(function* () {
let i = 0;
for (const row of values) {
for (const v of row) {
if (fn(v, i))
yield v;
i += 1;
}
}
}());
}
concat(newValues) {
this.values.push(newValues);
}
[Symbol.iterator]() {
const values = this.values;
return function* () {
for (const row of values) {
for (const v of row) {
yield v;
}
}
}();
}
static make(fn, max) {
return new Itarray2(function* () {
let i = 0;
while (max === void 0 || i < max) {
yield fn(i);
i += 1;
}
}());
}
};
// node_modules/@mathigon/fermat/dist/index.esm.js
var __defProp = Object.defineProperty;
var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
var __export = (target, all) => {
__markAsModule(target);
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var PRECISION = 1e-6;
function nearlyEquals(a, b, t = PRECISION) {
if (isNaN(a) || isNaN(b))
return false;
return Math.abs(a - b) < t;
}
function isBetween(value, a, b, t = PRECISION) {
if (a > b)
[a, b] = [b, a];
return value > a + t && value < b - t;
}
function gcd(...numbers) {
const [first, ...rest] = numbers;
if (rest.length > 1)
return gcd(first, gcd(...rest));
let a = Math.abs(first);
let b = Math.abs(rest[0]);
while (b)
[a, b] = [b, a % b];
return a;
}
function lcm(...numbers) {
const [first, ...rest] = numbers;
if (rest.length > 1)
return lcm(first, lcm(...rest));
return Math.abs(first * rest[0]) / gcd(first, rest[0]);
}
var matrix_exports = {};
__export(matrix_exports, {
determinant: () => determinant,
fill: () => fill,
identity: () => identity,
inverse: () => inverse,
product: () => product,
reflection: () => reflection,
rotation: () => rotation,
scalarProduct: () => scalarProduct,
shear: () => shear,
sum: () => sum,
transpose: () => transpose
});
function fill(value, x, y) {
return repeat2D(value, x, y);
}
function identity(n = 2) {
const x = fill(0, n, n);
for (let i = 0; i < n; ++i)
x[i][i] = 1;
return x;
}
function rotation(angle) {
const sin = Math.sin(angle);
const cos = Math.cos(angle);
return [[cos, -sin], [sin, cos]];
}
function shear(lambda) {
return [[1, lambda], [0, 1]];
}
function reflection(angle) {
const sin = Math.sin(2 * angle);
const cos = Math.cos(2 * angle);
return [[cos, sin], [sin, -cos]];
}
function sum(...matrices) {
const [M1, ...rest] = matrices;
const M2 = rest.length > 1 ? sum(...rest) : rest[0];
if (M1.length !== M2.length || M1[0].length !== M2[0].length) {
throw new Error("Matrix sizes don\u2019t match");
}
const S = [];
for (let i = 0; i < M1.length; ++i) {
const row = [];
for (let j = 0; j < M1[i].length; ++j) {
row.push(M1[i][j] + M2[i][j]);
}
S.push(row);
}
return S;
}
function scalarProduct(M, v) {
return M.map((row) => row.map((x) => x * v));
}
function product(...matrices) {
const [M1, ...rest] = matrices;
const M2 = rest.length > 1 ? product(...rest) : rest[0];
if (M1[0].length !== M2.length) {
throw new Error("Matrix sizes don\u2019t match.");
}
const P2 = [];
for (let i = 0; i < M1.length; ++i) {
const row = [];
for (let j = 0; j < M2[0].length; ++j) {
let value = 0;
for (let k = 0; k < M2.length; ++k) {
value += M1[i][k] * M2[k][j];
}
row.push(value);
}
P2.push(row);
}
return P2;
}
function transpose(M) {
const T = [];
for (let j = 0; j < M[0].length; ++j) {
const row = [];
for (let i = 0; i < M.length; ++i) {
row.push(M[i][j]);
}
T.push(row);
}
return T;
}
function determinant(M) {
if (M.length !== M[0].length)
throw new Error("Not a square matrix.");
const n = M.length;
if (n === 1)
return M[0][0];
if (n === 2)
return M[0][0] * M[1][1] - M[0][1] * M[1][0];
let det = 0;
for (let j = 0; j < n; ++j) {
let diagLeft = M[0][j];
let diagRight = M[0][j];
for (let i = 1; i < n; ++i) {
diagRight *= M[i][j + i % n];
diagLeft *= M[i][j - i % n];
}
det += diagRight - diagLeft;
}
return det;
}
function inverse(M) {
const n = M.length;
if (n !== M[0].length)
throw new Error("Not a square matrix.");
const I = identity(n);
const C = tabulate2D((x, y) => M[x][y], n, n);
for (let i = 0; i < n; ++i) {
let e = C[i][i];
if (!e) {
for (let ii = i + 1; ii < n; ++ii) {
if (C[ii][i] !== 0) {
for (let j = 0; j < n; ++j) {
[C[ii][j], C[i][j]] = [C[i][j], C[ii][j]];
[I[ii][j], I[i][j]] = [I[i][j], I[ii][j]];
}
break;
}
}
e = C[i][i];
if (!e)
throw new Error("Matrix not invertible.");
}
for (let j = 0; j < n; ++j) {
C[i][j] = C[i][j] / e;
I[i][j] = I[i][j] / e;
}
for (let ii = 0; ii < n; ++ii) {
if (ii === i)
continue;
const f = C[ii][i];
for (let j = 0; j < n; ++j) {
C[ii][j] -= f * C[i][j];
I[ii][j] -= f * I[i][j];
}
}
}
return I;
}
var random_exports = {};
__export(random_exports, {
bernoulli: () => bernoulli,
binomial: () => binomial2,
cauchy: () => cauchy,
chiCDF: () => chiCDF,
exponential: () => exponential,
find: () => find,
geometric: () => geometric,
integer: () => integer,
integrate: () => integrate,
normal: () => normal,
normalPDF: () => normalPDF,
poisson: () => poisson,
shuffle: () => shuffle,
smart: () => smart,
uniform: () => uniform,
weighted: () => weighted
});
function shuffle(a) {
a = a.slice(0);
for (let i = a.length - 1; i > 0; --i) {
const j = Math.floor(Math.random() * (i + 1));
[a[i], a[j]] = [a[j], a[i]];
}
return a;
}
function integer(a, b) {
const start = b === void 0 ? 0 : a;
const length = b === void 0 ? a : b - a + 1;
return start + Math.floor(length * Math.random());
}
function weighted(weights) {
const x = Math.random() * total2(weights);
let cum = 0;
return weights.findIndex((w) => (cum += w) >= x);
}
function find(items) {
return items[Math.floor(items.length * Math.random())];
}
var SMART_RANDOM_CACHE = new Map();
function smart(n, id) {
if (!id)
id = uid();
if (!SMART_RANDOM_CACHE.has(id))
SMART_RANDOM_CACHE.set(id, repeat2(1, n));
const cache2 = SMART_RANDOM_CACHE.get(id);
const x = weighted(cache2.map((x2) => x2 * x2));
cache2[x] -= 1;
if (cache2[x] <= 0)
SMART_RANDOM_CACHE.set(id, cache2.map((x2) => x2 + 1));
return x;
}
function bernoulli(p = 0.5) {
return Math.random() < p ? 1 : 0;
}
function binomial2(n = 1, p = 0.5) {
let t = 0;
for (let i = 0; i < n; ++i)
t += bernoulli(p);
return t;
}
function poisson(l = 1) {
if (l <= 0)
return 0;
const L = Math.exp(-l);
let p = 1;
let k = 0;
for (; p > L; ++k)
p *= Math.random();
return k - 1;
}
function uniform(a = 0, b = 1) {
return a + (b - a) * Math.random();
}
function normal(m = 0, v = 1) {
const u1 = Math.random();
const u2 = Math.random();
const rand = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
return rand * Math.sqrt(v) + m;
}
function exponential(l = 1) {
return l <= 0 ? 0 : -Math.log(Math.random()) / l;
}
function geometric(p = 0.5) {
if (p <= 0 || p > 1)
return void 0;
return Math.floor(Math.log(Math.random()) / Math.log(1 - p));
}
function cauchy() {
let rr;
let v1;
let v2;
do {
v1 = 2 * Math.random() - 1;
v2 = 2 * Math.random() - 1;
rr = v1 * v1 + v2 * v2;
} while (rr >= 1);
return v1 / v2;
}
function normalPDF(x, m = 1, v = 0) {
return Math.exp(-((x - m) ** 2) / (2 * v)) / Math.sqrt(2 * Math.PI * v);
}
var G = 7;
var P = [
0.9999999999998099,
676.5203681218851,
-1259.1392167224028,
771.3234287776531,
-176.6150291621406,
12.507343278686905,
-0.13857109526572012,
9984369578019572e-21,
15056327351493116e-23
];
function gamma(z) {
if (z < 0.5)
return Math.PI / (Math.sin(Math.PI * z) * gamma(1 - z));
z -= 1;
let x = P[0];
for (let i = 1; i < G + 2; i++)
x += P[i] / (z + i);
const t = z + G + 0.5;
return Math.sqrt(2 * Math.PI) * Math.pow(t, z + 0.5) * Math.exp(-t) * x;
}
function integrate(fn, xMin, xMax, dx = 1) {
let result = 0;
for (let x = xMin; x < xMax; x += dx) {
result += fn(x) * dx || 0;
}
return result;
}
function chiCDF(chi, deg) {
const int2 = integrate((t) => Math.pow(t, (deg - 2) / 2) * Math.exp(-t / 2), 0, chi);
return 1 - int2 / Math.pow(2, deg / 2) / gamma(deg / 2);
}
var regression_exports = {};
__export(regression_exports, {
bestPolynomial: () => bestPolynomial,
coefficient: () => coefficient,
exponential: () => exponential2,
linear: () => linear,
logarithmic: () => logarithmic,
polynomial: () => polynomial2,
power: () => power
});
function evaluatePolynomial(regression, x) {
let xs = 1;
let t = regression[0];
for (let i = 1; i < regression.length; ++i) {
xs *= x;
t += xs * regression[i];
}
return t;
}
function linear(data, throughOrigin = false) {
let sX = 0;
let sY = 0;
let sXX = 0;
let sXY = 0;
const len = data.length;
for (let n = 0; n < len; n++) {
sX += data[n][0];
sY += data[n][1];
sXX += data[n][0] * data[n][0];
sXY += data[n][0] * data[n][1];
}
if (throughOrigin) {
const gradient2 = sXY / sXX;
return [0, gradient2];
}
const gradient = (len * sXY - sX * sY) / (len * sXX - sX * sX);
const intercept = sY / len - gradient * sX / len;
return [intercept, gradient];
}
function exponential2(data) {
const sum2 = [0, 0, 0, 0, 0, 0];
for (const d of data) {
sum2[0] += d[0];
sum2[1] += d[1];
sum2[2] += d[0] * d[0] * d[1];
sum2[3] += d[1] * Math.log(d[1]);
sum2[4] += d[0] * d[1] * Math.log(d[1]);
sum2[5] += d[0] * d[1];
}
const denominator = sum2[1] * sum2[2] - sum2[5] * sum2[5];
const a = Math.exp((sum2[2] * sum2[3] - sum2[5] * sum2[4]) / denominator);
const b = (sum2[1] * sum2[4] - sum2[5] * sum2[3]) / denominator;
return [a, b];
}
function logarithmic(data) {
const sum2 = [0, 0, 0, 0];
const len = data.length;
for (const d of data) {
sum2[0] += Math.log(d[0]);
sum2[1] += d[1] * Math.log(d[0]);
sum2[2] += d[1];
sum2[3] += Math.pow(Math.log(d[0]), 2);
}
const b = (len * sum2[1] - sum2[2] * sum2[0]) / (len * sum2[3] - sum2[0] * sum2[0]);
const a = (sum2[2] - b * sum2[0]) / len;
return [a, b];
}
function power(data) {
const sum2 = [0, 0, 0, 0];
const len = data.length;
for (const d of data) {
sum2[0] += Math.log(d[0]);
sum2[1] += Math.log(d[1]) * Math.log(d[0]);
sum2[2] += Math.log(d[1]);
sum2[3] += Math.pow(Math.log(d[0]), 2);
}
const b = (len * sum2[1] - sum2[2] * sum2[0]) / (len * sum2[3] - sum2[0] * sum2[0]);
const a = Math.exp((sum2[2] - b * sum2[0]) / len);
return [a, b];
}
function polynomial2(data, order = 2) {
const X = data.map((d) => list(order + 1).map((p) => Math.pow(d[0], p)));
const XT = transpose(X);
const y = data.map((d) => [d[1]]);
const XTX = product(XT, X);
const inv = inverse(XTX);
const r = product(inv, XT, y);
return r.map((x) => x[0]);
}
function coefficient(data, fn) {
const total4 = data.reduce((sum2, d) => sum2 + d[1], 0);
const mean2 = total4 / data.length;
const ssyy = data.reduce((sum2, d) => sum2 + (d[1] - mean2) ** 2, 0);
const sse = data.reduce((sum2, d) => sum2 + (d[1] - fn(d[0])) ** 2, 0);
return 1 - sse / ssyy;
}
function bestPolynomial(data, threshold = 0.85, maxOrder = 8) {
if (data.length <= 1)
return void 0;
for (let i = 1; i < maxOrder; ++i) {
const reg = polynomial2(data, i);
const fn = (x) => evaluatePolynomial(reg, x);
const coeff = coefficient(data, fn);
if (coeff >= threshold)
return { order: i, coefficients: reg, fn };
}
return void 0;
}
// src/symbols.ts

@@ -913,2 +220,5 @@ var CONSTANTS = {

// src/parser.ts
import { last, words as words2 } from "@mathigon/core";
// src/elements.ts

@@ -1069,3 +379,8 @@ var toNumber = (x) => typeof x === "number" ? x : x[0];

// src/functions.ts
import { flatten, isOneOf, join, repeat, unique, words } from "@mathigon/core";
// src/eval.ts
import { total } from "@mathigon/core";
import { gcd, isBetween, lcm } from "@mathigon/fermat";
var WHOLE = [-Infinity, Infinity];

@@ -1527,3 +842,2 @@ var EMPTY = [NaN, NaN];

}
return;
}

@@ -1583,3 +897,3 @@ function tokenize(str) {

function isOperator(expr, fns) {
return expr instanceof ExprOperator && words(fns).includes(expr.o);
return expr instanceof ExprOperator && words2(fns).includes(expr.o);
}

@@ -1731,3 +1045,3 @@ function removeBrackets(expr) {

try {
const vars = unique([...expr1.variables, ...expr2.variables]);
const vars = unique2([...expr1.variables, ...expr2.variables]);
const fn1 = expr1.collapse();

@@ -1734,0 +1048,0 @@ const fn2 = expr2.collapse();

10

package.json
{
"name": "@mathigon/hilbert",
"version": "1.0.1",
"version": "1.0.2",
"license": "MIT",

@@ -24,4 +24,4 @@ "homepage": "https://mathigon.io/hilbert",

"prepare": "npm run build",
"cjs": "esbuild src/index.ts --outfile=dist/index.cjs.js --format=cjs --bundle --target=es2016 --sourcemap --external:@mathigon/core,@mathigon/fermat",
"esm": "esbuild src/index.ts --outfile=dist/index.esm.js --format=esm --bundle --target=es2016 --sourcemap --external:@mathigon/core,@mathigon/fermat",
"cjs": "esbuild src/index.ts --outfile=dist/index.cjs.js --format=cjs --bundle --target=es2016 --sourcemap --external:@mathigon/core --external:@mathigon/fermat",
"esm": "esbuild src/index.ts --outfile=dist/index.esm.js --format=esm --bundle --target=es2016 --sourcemap --external:@mathigon/core --external:@mathigon/fermat",
"types": "tsc --project tsconfig-types.json",

@@ -32,4 +32,4 @@ "build": "npm run cjs && npm run esm && npm run types",

"dependencies": {
"@mathigon/core": "1.0.1",
"@mathigon/fermat": "1.0.1"
"@mathigon/core": "1.0.2",
"@mathigon/fermat": "1.0.2"
},

@@ -36,0 +36,0 @@ "devDependencies": {

2

src/parser.ts

@@ -51,4 +51,2 @@ // =============================================================================

}
return;
}

@@ -55,0 +53,0 @@

3

tsconfig.json
{
"compilerOptions": {
"lib": ["esnext", "dom"],
"lib": ["esnext"],
"target": "es2016",

@@ -10,3 +10,2 @@ "moduleResolution": "node",

"noImplicitThis": true,
"noImplicitReturns": true,
"noFallthroughCasesInSwitch": true,

@@ -13,0 +12,0 @@ "strictFunctionTypes": true,

dist/index.cjs.js.map

Sorry, the diff of this file is not supported yet

dist/index.esm.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc