@bilig/formula 0.1.0

package/dist/builtins/lookup.js

@@ -0,0 +1,867 @@
+import { ErrorCode, ValueTag } from "@bilig/protocol";
+import { getExternalLookupFunction } from "../external-function-adapter.js";
+import { createLookupArrayShapeBuiltins } from "./lookup-array-shape-builtins.js";
+import { createLookupCriteriaBuiltins } from "./lookup-criteria-builtins.js";
+import { createLookupDatabaseBuiltins } from "./lookup-database-builtins.js";
+import { createLookupFinancialBuiltins } from "./lookup-financial-builtins.js";
+import { createLookupHypothesisBuiltins } from "./lookup-hypothesis-builtins.js";
+import { createLookupMatrixBuiltins } from "./lookup-matrix-builtins.js";
+import { createLookupOrderStatisticsBuiltins } from "./lookup-order-statistics-builtins.js";
+import { createLookupReferenceBuiltins } from "./lookup-reference-builtins.js";
+import { createLookupRegressionBuiltins } from "./lookup-regression-builtins.js";
+import { createLookupSortFilterBuiltins } from "./lookup-sort-filter-builtins.js";
+function errorValue(code) {
+    return { tag: ValueTag.Error, code };
+}
+function numberResult(value) {
+    return { tag: ValueTag.Number, value };
+}
+function isError(value) {
+    return value !== undefined && !isRangeArg(value) && value.tag === ValueTag.Error;
+}
+function isRangeArg(value) {
+    return typeof value === "object" && value !== null && "kind" in value && value.kind === "range";
+}
+function isCriteriaOperator(value) {
+    return (value === "=" ||
+        value === "<>" ||
+        value === ">" ||
+        value === ">=" ||
+        value === "<" ||
+        value === "<=");
+}
+function findFirstNonRange(values) {
+    for (const value of values) {
+        if (!isRangeArg(value)) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function areRangeArgs(values) {
+    return values.every((value) => isRangeArg(value));
+}
+function toNumber(value) {
+    switch (value.tag) {
+        case ValueTag.Number:
+            return value.value;
+        case ValueTag.Boolean:
+            return value.value ? 1 : 0;
+        case ValueTag.Empty:
+            return 0;
+        case ValueTag.String:
+        case ValueTag.Error:
+            return undefined;
+        default:
+            return undefined;
+    }
+}
+function toInteger(value) {
+    const numeric = toNumber(value);
+    if (numeric === undefined || !Number.isFinite(numeric)) {
+        return undefined;
+    }
+    return Math.trunc(numeric);
+}
+function toBoolean(value) {
+    switch (value.tag) {
+        case ValueTag.Boolean:
+            return value.value;
+        case ValueTag.Number:
+            return value.value !== 0;
+        case ValueTag.Empty:
+            return false;
+        case ValueTag.String:
+        case ValueTag.Error:
+            return undefined;
+        default:
+            return undefined;
+    }
+}
+function toStringValue(value) {
+    switch (value.tag) {
+        case ValueTag.Empty:
+            return "";
+        case ValueTag.Number:
+            return String(value.value);
+        case ValueTag.Boolean:
+            return value.value ? "TRUE" : "FALSE";
+        case ValueTag.String:
+            return value.value;
+        case ValueTag.Error:
+            return "";
+    }
+}
+function compareScalars(left, right) {
+    if ((left.tag === ValueTag.String || left.tag === ValueTag.Empty) &&
+        (right.tag === ValueTag.String || right.tag === ValueTag.Empty)) {
+        const normalizedLeft = toStringValue(left).toUpperCase();
+        const normalizedRight = toStringValue(right).toUpperCase();
+        if (normalizedLeft === normalizedRight) {
+            return 0;
+        }
+        return normalizedLeft < normalizedRight ? -1 : 1;
+    }
+    const leftNum = toNumber(left);
+    const rightNum = toNumber(right);
+    if (leftNum === undefined || rightNum === undefined) {
+        return undefined;
+    }
+    if (leftNum === rightNum) {
+        return 0;
+    }
+    return leftNum < rightNum ? -1 : 1;
+}
+function requireCellVector(arg) {
+    if (!isRangeArg(arg)) {
+        return errorValue(ErrorCode.Value);
+    }
+    if (arg.refKind !== "cells") {
+        return errorValue(ErrorCode.Value);
+    }
+    if (arg.rows !== 1 && arg.cols !== 1) {
+        return errorValue(ErrorCode.NA);
+    }
+    return arg;
+}
+function requireCellRange(arg) {
+    if (!isRangeArg(arg) || arg.refKind !== "cells") {
+        return errorValue(ErrorCode.Value);
+    }
+    return arg;
+}
+function getRangeValue(range, row, col) {
+    const index = row * range.cols + col;
+    return range.values[index] ?? { tag: ValueTag.Empty };
+}
+function arrayResult(values, rows, cols) {
+    return { kind: "array", values, rows, cols };
+}
+function collectNumericSeries(arg, mode) {
+    const values = [];
+    const cells = isRangeArg(arg) ? arg.values : [arg];
+    if (isRangeArg(arg) && arg.refKind !== "cells") {
+        return errorValue(ErrorCode.Value);
+    }
+    for (const cell of cells) {
+        if (cell.tag === ValueTag.Error) {
+            return cell;
+        }
+        if (cell.tag === ValueTag.Number) {
+            values.push(cell.value);
+            continue;
+        }
+        if (mode === "strict") {
+            return errorValue(ErrorCode.Value);
+        }
+    }
+    return values;
+}
+function numericAggregateCandidate(value) {
+    return value.tag === ValueTag.Number ? value.value : undefined;
+}
+function toCellRange(arg) {
+    if (!isRangeArg(arg)) {
+        return { kind: "range", values: [arg], refKind: "cells", rows: 1, cols: 1 };
+    }
+    if (arg.refKind !== "cells") {
+        return errorValue(ErrorCode.Value);
+    }
+    return arg;
+}
+function toNumericMatrix(arg) {
+    const range = toCellRange(arg);
+    if (!isRangeArg(range)) {
+        return range;
+    }
+    const matrix = [];
+    for (let row = 0; row < range.rows; row += 1) {
+        const rowValues = [];
+        for (let col = 0; col < range.cols; col += 1) {
+            const numeric = toNumber(getRangeValue(range, row, col));
+            if (numeric === undefined) {
+                return errorValue(ErrorCode.Value);
+            }
+            rowValues.push(numeric);
+        }
+        matrix.push(rowValues);
+    }
+    return matrix;
+}
+const LANCZOS_G = 7;
+const LANCZOS_COEFFICIENTS = [
+    676.5203681218851, -1259.1392167224028, 771.3234287776531, -176.6150291621406, 12.507343278686905,
+    -0.13857109526572012, 9.984369578019572e-6, 1.5056327351493116e-7,
+];
+function logGamma(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+        return Number.NaN;
+    }
+    let sum = 0.9999999999998099;
+    const shifted = value - 1;
+    LANCZOS_COEFFICIENTS.forEach((coefficient, index) => {
+        sum += coefficient / (shifted + index + 1);
+    });
+    const t = shifted + LANCZOS_G + 0.5;
+    return 0.5 * Math.log(2 * Math.PI) + (shifted + 0.5) * Math.log(t) - t + Math.log(sum);
+}
+function regularizedLowerGamma(shape, x) {
+    if (!Number.isFinite(shape) || !Number.isFinite(x) || shape <= 0 || x < 0) {
+        return Number.NaN;
+    }
+    if (x === 0) {
+        return 0;
+    }
+    const logGammaShape = logGamma(shape);
+    if (!Number.isFinite(logGammaShape)) {
+        return Number.NaN;
+    }
+    if (x < shape + 1) {
+        let term = 1 / shape;
+        let sum = term;
+        for (let iteration = 1; iteration < 1000; iteration += 1) {
+            term *= x / (shape + iteration);
+            sum += term;
+            if (Math.abs(term) <= Math.abs(sum) * 1e-14) {
+                break;
+            }
+        }
+        return sum * Math.exp(-x + shape * Math.log(x) - logGammaShape);
+    }
+    let b = x + 1 - shape;
+    let c = 1 / 1e-300;
+    let d = 1 / b;
+    let h = d;
+    for (let iteration = 1; iteration < 1000; iteration += 1) {
+        const factor = -iteration * (iteration - shape);
+        b += 2;
+        d = factor * d + b;
+        if (Math.abs(d) < 1e-300) {
+            d = 1e-300;
+        }
+        c = b + factor / c;
+        if (Math.abs(c) < 1e-300) {
+            c = 1e-300;
+        }
+        d = 1 / d;
+        const delta = d * c;
+        h *= delta;
+        if (Math.abs(delta - 1) <= 1e-14) {
+            break;
+        }
+    }
+    return 1 - Math.exp(-x + shape * Math.log(x) - logGammaShape) * h;
+}
+function regularizedUpperGamma(shape, x) {
+    const lower = regularizedLowerGamma(shape, x);
+    return Number.isFinite(lower) ? 1 - lower : Number.NaN;
+}
+function erfApprox(value) {
+    const sign = value < 0 ? -1 : 1;
+    const absolute = Math.abs(value);
+    const t = 1 / (1 + 0.3275911 * absolute);
+    const y = 1 -
+        ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) *
+            t *
+            Math.exp(-absolute * absolute);
+    return sign * y;
+}
+function standardNormalCdf(value) {
+    return 0.5 * (1 + erfApprox(value / Math.sqrt(2)));
+}
+function logBeta(alpha, beta) {
+    return logGamma(alpha) + logGamma(beta) - logGamma(alpha + beta);
+}
+function betaContinuedFraction(x, alpha, beta) {
+    const maxIterations = 200;
+    const epsilon = 1e-14;
+    const tiny = 1e-300;
+    const qab = alpha + beta;
+    const qap = alpha + 1;
+    const qam = alpha - 1;
+    let c = 1;
+    let d = 1 - (qab * x) / qap;
+    if (Math.abs(d) < tiny) {
+        d = tiny;
+    }
+    d = 1 / d;
+    let h = d;
+    for (let iteration = 1; iteration <= maxIterations; iteration += 1) {
+        const step = iteration * 2;
+        let factor = (iteration * (beta - iteration) * x) / ((qam + step) * (alpha + step));
+        d = 1 + factor * d;
+        if (Math.abs(d) < tiny) {
+            d = tiny;
+        }
+        c = 1 + factor / c;
+        if (Math.abs(c) < tiny) {
+            c = tiny;
+        }
+        d = 1 / d;
+        h *= d * c;
+        factor = (-(alpha + iteration) * (qab + iteration) * x) / ((alpha + step) * (qap + step));
+        d = 1 + factor * d;
+        if (Math.abs(d) < tiny) {
+            d = tiny;
+        }
+        c = 1 + factor / c;
+        if (Math.abs(c) < tiny) {
+            c = tiny;
+        }
+        d = 1 / d;
+        const delta = d * c;
+        h *= delta;
+        if (Math.abs(delta - 1) <= epsilon) {
+            break;
+        }
+    }
+    return h;
+}
+function regularizedBeta(x, alpha, beta) {
+    if (!Number.isFinite(x) ||
+        !Number.isFinite(alpha) ||
+        !Number.isFinite(beta) ||
+        x < 0 ||
+        x > 1 ||
+        alpha <= 0 ||
+        beta <= 0) {
+        return Number.NaN;
+    }
+    if (x === 0) {
+        return 0;
+    }
+    if (x === 1) {
+        return 1;
+    }
+    const logTerm = alpha * Math.log(x) + beta * Math.log(1 - x) - logBeta(alpha, beta);
+    if (!Number.isFinite(logTerm)) {
+        return Number.NaN;
+    }
+    const front = Math.exp(logTerm);
+    if (x < (alpha + 1) / (alpha + beta + 2)) {
+        return (front * betaContinuedFraction(x, alpha, beta)) / alpha;
+    }
+    return 1 - (front * betaContinuedFraction(1 - x, beta, alpha)) / beta;
+}
+function fDistributionCdf(x, degreesFreedom1, degreesFreedom2) {
+    if (!Number.isFinite(x) ||
+        !Number.isFinite(degreesFreedom1) ||
+        !Number.isFinite(degreesFreedom2) ||
+        x < 0 ||
+        degreesFreedom1 < 1 ||
+        degreesFreedom2 < 1) {
+        return Number.NaN;
+    }
+    const alpha = degreesFreedom1 / 2;
+    const beta = degreesFreedom2 / 2;
+    const transformed = (degreesFreedom1 * x) / (degreesFreedom1 * x + degreesFreedom2);
+    return regularizedBeta(transformed, alpha, beta);
+}
+function studentTCdf(x, degreesFreedom) {
+    if (!Number.isFinite(x) || !Number.isFinite(degreesFreedom) || degreesFreedom < 1) {
+        return Number.NaN;
+    }
+    if (x === 0) {
+        return 0.5;
+    }
+    const transformed = degreesFreedom / (degreesFreedom + x * x);
+    const tail = regularizedBeta(transformed, degreesFreedom / 2, 0.5);
+    if (!Number.isFinite(tail)) {
+        return Number.NaN;
+    }
+    return x > 0 ? 1 - tail / 2 : tail / 2;
+}
+function collectSampleNumbers(arg) {
+    if (!isRangeArg(arg)) {
+        if (isError(arg)) {
+            return arg;
+        }
+        return arg.tag === ValueTag.Number ? [arg.value] : errorValue(ErrorCode.Value);
+    }
+    const values = [];
+    for (const value of arg.values) {
+        if (value.tag === ValueTag.Error) {
+            return value;
+        }
+        if (value.tag === ValueTag.Number) {
+            values.push(value.value);
+        }
+    }
+    return values;
+}
+function chiSquareTestResult(actualArg, expectedArg) {
+    const actual = toNumericMatrix(actualArg);
+    if (!Array.isArray(actual)) {
+        return actual;
+    }
+    const expected = toNumericMatrix(expectedArg);
+    if (!Array.isArray(expected)) {
+        return expected;
+    }
+    const rows = actual.length;
+    const cols = actual[0]?.length ?? 0;
+    if (rows !== expected.length || cols !== (expected[0]?.length ?? 0)) {
+        return errorValue(ErrorCode.NA);
+    }
+    if ((rows === 1 && cols === 1) || rows === 0 || cols === 0) {
+        return errorValue(ErrorCode.NA);
+    }
+    let statistic = 0;
+    for (let row = 0; row < rows; row += 1) {
+        const actualRow = actual[row];
+        const expectedRow = expected[row];
+        if (actualRow.length !== cols || expectedRow.length !== cols) {
+            return errorValue(ErrorCode.NA);
+        }
+        for (let col = 0; col < cols; col += 1) {
+            const actualValue = actualRow[col];
+            const expectedValue = expectedRow[col];
+            if (actualValue < 0 || expectedValue < 0) {
+                return errorValue(ErrorCode.Value);
+            }
+            if (expectedValue === 0) {
+                return errorValue(ErrorCode.Div0);
+            }
+            const delta = actualValue - expectedValue;
+            statistic += (delta * delta) / expectedValue;
+        }
+    }
+    const degrees = rows > 1 && cols > 1 ? (rows - 1) * (cols - 1) : rows > 1 ? rows - 1 : cols - 1;
+    if (degrees <= 0) {
+        return errorValue(ErrorCode.NA);
+    }
+    const probability = regularizedUpperGamma(degrees / 2, statistic / 2);
+    return Number.isFinite(probability)
+        ? { tag: ValueTag.Number, value: probability }
+        : errorValue(ErrorCode.Value);
+}
+function fTestResult(firstArg, secondArg) {
+    const first = collectSampleNumbers(firstArg);
+    if (!Array.isArray(first)) {
+        return first;
+    }
+    const second = collectSampleNumbers(secondArg);
+    if (!Array.isArray(second)) {
+        return second;
+    }
+    if (first.length < 2 || second.length < 2) {
+        return errorValue(ErrorCode.Div0);
+    }
+    const firstMean = first.reduce((sum, value) => sum + value, 0) / first.length;
+    const secondMean = second.reduce((sum, value) => sum + value, 0) / second.length;
+    const firstVariance = first.reduce((sum, value) => sum + (value - firstMean) ** 2, 0) / (first.length - 1);
+    const secondVariance = second.reduce((sum, value) => sum + (value - secondMean) ** 2, 0) / (second.length - 1);
+    if (!(firstVariance > 0) || !(secondVariance > 0)) {
+        return errorValue(ErrorCode.Div0);
+    }
+    const firstLeads = firstVariance >= secondVariance;
+    const numeratorVariance = firstLeads ? firstVariance : secondVariance;
+    const denominatorVariance = firstLeads ? secondVariance : firstVariance;
+    const numeratorDf = firstLeads ? first.length - 1 : second.length - 1;
+    const denominatorDf = firstLeads ? second.length - 1 : first.length - 1;
+    const upperTail = 1 - fDistributionCdf(numeratorVariance / denominatorVariance, numeratorDf, denominatorDf);
+    const probability = Math.min(1, upperTail * 2);
+    return Number.isFinite(probability)
+        ? { tag: ValueTag.Number, value: probability }
+        : errorValue(ErrorCode.Value);
+}
+function zTestResult(arrayArg, xArg, sigmaArg) {
+    const sample = collectSampleNumbers(arrayArg);
+    if (!Array.isArray(sample)) {
+        return sample;
+    }
+    const x = !isRangeArg(xArg) ? toNumber(xArg) : undefined;
+    if (x === undefined || sample.length === 0) {
+        return errorValue(ErrorCode.Value);
+    }
+    let sigma;
+    if (sigmaArg !== undefined) {
+        sigma = !isRangeArg(sigmaArg) ? toNumber(sigmaArg) : undefined;
+    }
+    else if (sample.length >= 2) {
+        const mean = sample.reduce((sum, value) => sum + value, 0) / sample.length;
+        const variance = sample.reduce((sum, value) => sum + (value - mean) ** 2, 0) / (sample.length - 1);
+        sigma = variance > 0 ? Math.sqrt(variance) : undefined;
+    }
+    if (sigma === undefined || !(sigma > 0)) {
+        return errorValue(ErrorCode.Div0);
+    }
+    const mean = sample.reduce((sum, value) => sum + value, 0) / sample.length;
+    const zScore = (mean - x) / (sigma / Math.sqrt(sample.length));
+    const probability = 1 - standardNormalCdf(zScore);
+    return Number.isFinite(probability)
+        ? { tag: ValueTag.Number, value: probability }
+        : errorValue(ErrorCode.Value);
+}
+function tTestResult(firstArg, secondArg, tailsArg, typeArg) {
+    const first = collectSampleNumbers(firstArg);
+    if (!Array.isArray(first)) {
+        return first;
+    }
+    const second = collectSampleNumbers(secondArg);
+    if (!Array.isArray(second)) {
+        return second;
+    }
+    const tails = !isRangeArg(tailsArg) ? toNumber(tailsArg) : undefined;
+    const type = !isRangeArg(typeArg) ? toNumber(typeArg) : undefined;
+    if (tails === undefined ||
+        type === undefined ||
+        !Number.isInteger(tails) ||
+        !Number.isInteger(type) ||
+        ![1, 2].includes(tails) ||
+        ![1, 2, 3].includes(type)) {
+        return errorValue(ErrorCode.Value);
+    }
+    let statistic;
+    let degreesFreedom;
+    if (type === 1) {
+        if (first.length !== second.length) {
+            return errorValue(ErrorCode.NA);
+        }
+        if (first.length < 2) {
+            return errorValue(ErrorCode.Div0);
+        }
+        const deltas = first.map((value, index) => value - second[index]);
+        const mean = deltas.reduce((sum, value) => sum + value, 0) / deltas.length;
+        const variance = deltas.reduce((sum, value) => sum + (value - mean) ** 2, 0) / (deltas.length - 1);
+        if (!(variance > 0)) {
+            return errorValue(ErrorCode.Div0);
+        }
+        statistic = mean / Math.sqrt(variance / deltas.length);
+        degreesFreedom = deltas.length - 1;
+    }
+    else {
+        if (first.length < 2 || second.length < 2) {
+            return errorValue(ErrorCode.Div0);
+        }
+        const firstMean = first.reduce((sum, value) => sum + value, 0) / first.length;
+        const secondMean = second.reduce((sum, value) => sum + value, 0) / second.length;
+        const firstVariance = first.reduce((sum, value) => sum + (value - firstMean) ** 2, 0) / (first.length - 1);
+        const secondVariance = second.reduce((sum, value) => sum + (value - secondMean) ** 2, 0) / (second.length - 1);
+        if (!(firstVariance > 0) || !(secondVariance > 0)) {
+            return errorValue(ErrorCode.Div0);
+        }
+        if (type === 2) {
+            const pooledVariance = ((first.length - 1) * firstVariance + (second.length - 1) * secondVariance) /
+                (first.length + second.length - 2);
+            if (!(pooledVariance > 0)) {
+                return errorValue(ErrorCode.Div0);
+            }
+            statistic =
+                (firstMean - secondMean) /
+                    Math.sqrt(pooledVariance * (1 / first.length + 1 / second.length));
+            degreesFreedom = first.length + second.length - 2;
+        }
+        else {
+            const firstTerm = firstVariance / first.length;
+            const secondTerm = secondVariance / second.length;
+            const denominator = Math.sqrt(firstTerm + secondTerm);
+            const welchDenominator = (firstTerm * firstTerm) / (first.length - 1) +
+                (secondTerm * secondTerm) / (second.length - 1);
+            if (!(denominator > 0) || !(welchDenominator > 0)) {
+                return errorValue(ErrorCode.Div0);
+            }
+            statistic = (firstMean - secondMean) / denominator;
+            degreesFreedom = (firstTerm + secondTerm) ** 2 / welchDenominator;
+        }
+    }
+    const upperTail = 1 - studentTCdf(Math.abs(statistic), degreesFreedom);
+    const probability = tails === 1 ? upperTail : Math.min(1, upperTail * 2);
+    return Number.isFinite(probability)
+        ? { tag: ValueTag.Number, value: probability }
+        : errorValue(ErrorCode.Value);
+}
+function flattenNumbers(arg) {
+    if (!isRangeArg(arg)) {
+        const numeric = toNumber(arg);
+        return numeric === undefined ? errorValue(ErrorCode.Value) : [numeric];
+    }
+    const values = [];
+    for (const value of arg.values) {
+        const numeric = toNumber(value);
+        if (numeric === undefined) {
+            return errorValue(ErrorCode.Value);
+        }
+        values.push(numeric);
+    }
+    return values;
+}
+function pickRangeRow(range, row) {
+    const values = [];
+    for (let col = 0; col < range.cols; col += 1) {
+        values.push(getRangeValue(range, row, col));
+    }
+    return values;
+}
+function hasWildcardPattern(pattern) {
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        if (char === "~") {
+            index += 1;
+            continue;
+        }
+        if (char === "*" || char === "?") {
+            return true;
+        }
+    }
+    return false;
+}
+function wildcardPatternToRegExp(pattern) {
+    let source = "^";
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        if (char === undefined) {
+            continue;
+        }
+        if (char === "~") {
+            const escaped = pattern[index + 1];
+            if (escaped !== undefined) {
+                source += escapeRegexFragment(escaped);
+                index += 1;
+                continue;
+            }
+            source += escapeRegexFragment(char);
+            continue;
+        }
+        if (char === "*") {
+            source += ".*";
+            continue;
+        }
+        if (char === "?") {
+            source += ".";
+            continue;
+        }
+        source += escapeRegexFragment(char);
+    }
+    source += "$";
+    return new RegExp(source, "i");
+}
+function escapeRegexFragment(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function unescapeCriteriaPattern(pattern) {
+    let unescaped = "";
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        if (char === undefined) {
+            continue;
+        }
+        if (char === "~") {
+            const escaped = pattern[index + 1];
+            if (escaped !== undefined) {
+                unescaped += escaped;
+                index += 1;
+                continue;
+            }
+        }
+        unescaped += char;
+    }
+    return unescaped;
+}
+function firstLookupError(args) {
+    return args.find((arg) => isError(arg));
+}
+const externalLookupBuiltinNames = ["FILTERXML", "STOCKHISTORY"];
+function createExternalLookupBuiltin(name) {
+    return (...args) => {
+        const existingError = firstLookupError(args);
+        if (existingError) {
+            return existingError;
+        }
+        const external = getExternalLookupFunction(name);
+        return external ? external(...args) : errorValue(ErrorCode.Blocked);
+    };
+}
+const externalLookupBuiltins = Object.fromEntries(externalLookupBuiltinNames.map((name) => [name, createExternalLookupBuiltin(name)]));
+const lookupRegressionBuiltins = createLookupRegressionBuiltins({
+    errorValue,
+    numberResult,
+    isRangeArg,
+    toNumber,
+    toBoolean,
+    flattenNumbers,
+});
+const lookupOrderStatisticsBuiltins = createLookupOrderStatisticsBuiltins({
+    errorValue,
+    numberResult,
+    arrayResult,
+    requireCellRange,
+    isError,
+    isRangeArg,
+    toNumber,
+    toInteger,
+    flattenNumbers,
+});
+const lookupFinancialBuiltins = createLookupFinancialBuiltins({
+    errorValue,
+    numberResult,
+    isRangeArg,
+    toNumber,
+    collectNumericSeries,
+});
+const lookupHypothesisBuiltins = createLookupHypothesisBuiltins({
+    errorValue,
+    chiSquareTestResult,
+    fTestResult,
+    zTestResult,
+    tTestResult,
+});
+const lookupMatrixBuiltins = createLookupMatrixBuiltins({
+    errorValue,
+    numberResult,
+    arrayResult,
+    isRangeArg,
+    requireCellRange,
+    findFirstNonRange,
+    areRangeArgs,
+    toNumber,
+    toNumericMatrix,
+    flattenNumbers,
+});
+const lookupSortFilterBuiltins = createLookupSortFilterBuiltins({
+    errorValue,
+    arrayResult,
+    isError,
+    isRangeArg,
+    toBoolean,
+    toInteger,
+    requireCellRange,
+    toCellRange,
+    compareScalars,
+    getRangeValue,
+    pickRangeRow,
+});
+const lookupDatabaseBuiltins = createLookupDatabaseBuiltins({
+    errorValue,
+    numberResult,
+    isError,
+    isRangeArg,
+    toNumber,
+    toStringValue,
+    requireCellRange,
+    getRangeValue,
+    matchesCriteria,
+});
+const lookupCriteriaBuiltins = createLookupCriteriaBuiltins({
+    errorValue,
+    numberResult,
+    isError,
+    isRangeArg,
+    toNumber,
+    requireCellRange,
+    matchesCriteria,
+    numericAggregateCandidate,
+});
+const lookupReferenceBuiltins = createLookupReferenceBuiltins({
+    errorValue,
+    numberResult,
+    isError,
+    isRangeArg,
+    toBoolean,
+    toInteger,
+    requireCellVector,
+    toCellRange,
+    compareScalars,
+    getRangeValue,
+});
+const lookupArrayShapeBuiltins = createLookupArrayShapeBuiltins({
+    errorValue,
+    arrayResult,
+    isError,
+    isRangeArg,
+    toBoolean,
+    toInteger,
+    requireCellRange,
+    toCellRange,
+    getRangeValue,
+    findFirstNonRange,
+    areRangeArgs,
+    pickRangeRow,
+});
+export const lookupBuiltins = {
+    ...lookupArrayShapeBuiltins,
+    ...lookupReferenceBuiltins,
+    ...lookupCriteriaBuiltins,
+    ...lookupDatabaseBuiltins,
+    ...lookupFinancialBuiltins,
+    ...lookupHypothesisBuiltins,
+    ...lookupRegressionBuiltins,
+    ...lookupOrderStatisticsBuiltins,
+    ...lookupMatrixBuiltins,
+    ...lookupSortFilterBuiltins,
+    ...externalLookupBuiltins,
+};
+function matchesCriteria(value, criteria) {
+    if (isError(value)) {
+        return false;
+    }
+    let { operator, operand } = parseCriteria(criteria);
+    if (operand.tag === ValueTag.String &&
+        (operator === "=" || operator === "<>") &&
+        hasWildcardPattern(operand.value)) {
+        const matches = wildcardPatternToRegExp(operand.value).test(toStringValue(value));
+        return operator === "=" ? matches : !matches;
+    }
+    if (operand.tag === ValueTag.String && operand.value.includes("~")) {
+        operand = {
+            tag: ValueTag.String,
+            value: unescapeCriteriaPattern(operand.value),
+            stringId: operand.stringId,
+        };
+    }
+    const comparison = compareScalars(value, operand);
+    if (comparison === undefined) {
+        return false;
+    }
+    switch (operator) {
+        case "=":
+            return comparison === 0;
+        case "<>":
+            return comparison !== 0;
+        case ">":
+            return comparison > 0;
+        case ">=":
+            return comparison >= 0;
+        case "<":
+            return comparison < 0;
+        case "<=":
+            return comparison <= 0;
+    }
+}
+function parseCriteria(criteria) {
+    if (criteria.tag !== ValueTag.String) {
+        return { operator: "=", operand: criteria };
+    }
+    const match = /^(<=|>=|<>|=|<|>)(.*)$/.exec(criteria.value);
+    if (!match) {
+        return { operator: "=", operand: criteria };
+    }
+    const operator = match[1] ?? "=";
+    return {
+        operator: isCriteriaOperator(operator) ? operator : "=",
+        operand: parseCriteriaOperand(match[2] ?? ""),
+    };
+}
+function parseCriteriaOperand(raw) {
+    const trimmed = raw.trim();
+    if (trimmed === "") {
+        return { tag: ValueTag.String, value: "", stringId: 0 };
+    }
+    const upper = trimmed.toUpperCase();
+    if (upper === "TRUE" || upper === "FALSE") {
+        return { tag: ValueTag.Boolean, value: upper === "TRUE" };
+    }
+    const numeric = Number(trimmed);
+    if (Number.isFinite(numeric)) {
+        return { tag: ValueTag.Number, value: numeric };
+    }
+    return { tag: ValueTag.String, value: trimmed, stringId: 0 };
+}
+export function getLookupBuiltin(name) {
+    const upper = name.toUpperCase();
+    if (upper === "USE.THE.COUNTIF") {
+        return lookupBuiltins["COUNTIF"];
+    }
+    return lookupBuiltins[upper] ?? getExternalLookupFunction(name);
+}
+//# sourceMappingURL=lookup.js.map