@cj-tech-master/excelts 9.2.1 → 9.3.0

package/dist/cjs/modules/formula/runtime/function-registry.js

@@ -0,0 +1,846 @@
+"use strict";
+/**
+ * Function Registry — Declarative function descriptors and native implementations.
+ *
+ * Each function is described by a `FunctionDescriptor` that carries metadata
+ * about arity and the implementation itself. The evaluator uses this metadata
+ * to validate arguments and invoke functions.
+ *
+ * Special forms (IF, LET, LAMBDA, etc.) are NOT registered here — they
+ * are handled directly by the evaluator's special-form dispatch.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFunction = registerFunction;
+exports.lookupFunction = lookupFunction;
+exports.defineEager = defineEager;
+exports.ensureRegistryInitialized = ensureRegistryInitialized;
+const token_types_1 = require("../syntax/token-types");
+const values_1 = require("./values");
+// ============================================================================
+// Registry
+// ============================================================================
+/**
+ * The function registry.
+ *
+ * Maps uppercase canonical function names to their descriptors.
+ * Also handles _XLFN. and _XLFN._XLWS. prefix variants.
+ */
+const registryMap = new Map();
+/**
+ * Register a function descriptor. The descriptor is stored under its
+ * canonical (unprefixed) name only — `_XLFN.` / `_XLFN._XLWS.` prefix
+ * variants are resolved dynamically in `lookupFunction`. This keeps the
+ * registry small and avoids triple-entry bookkeeping for 200+ functions.
+ */
+function registerFunction(desc) {
+    registryMap.set(desc.name, desc);
+}
+/**
+ * Look up a function by uppercase name. Accepts `_XLFN.` and
+ * `_XLFN._XLWS.` prefixed variants by stripping the prefix before lookup
+ * (a no-op for plain names, so plain lookups also go through a single
+ * Map.get call — avoiding the double-lookup pattern used previously).
+ */
+function lookupFunction(name) {
+    return registryMap.get((0, token_types_1.stripFunctionPrefix)(name));
+}
+/**
+ * Convenience: define and register an eager function.
+ */
+function defineEager(name, minArity, maxArity, invoke) {
+    const desc = {
+        name,
+        minArity,
+        maxArity,
+        invoke
+    };
+    registerFunction(desc);
+    return desc;
+}
+// ============================================================================
+// Registry Initialization
+// ============================================================================
+/**
+ * Initialize the registry with all native function implementations.
+ */
+let initialized = false;
+function ensureRegistryInitialized() {
+    if (initialized) {
+        return;
+    }
+    initialized = true;
+    // Register native functions first — metadata + implementation co-located.
+    registerNativeInformationAndLogical();
+    registerNativeTextFunctions();
+    registerNativeDateFunctions();
+    registerNativeEngineeringFunctions();
+    registerNativeFinancialFunctions();
+    registerNativeStatisticalFunctions();
+    registerNativeMathFunctions();
+    registerNativeConditionalFunctions();
+    registerNativeLookupFunctions();
+    registerNativeDynamicArrayFunctions();
+    registerNativeDatabaseFunctions();
+}
+// ============================================================================
+// Native Function Implementations
+// ============================================================================
+/**
+ * Register native implementations for information and logical functions.
+ * Metadata and implementation are co-located as the single source of truth.
+ */
+function registerNativeInformationAndLogical() {
+    const scalar = (args) => (0, values_1.topLeft)(args[0] ?? values_1.BLANK);
+    // ── Information ──
+    defineEager("ISNUMBER", 1, 1, args => (0, values_1.rvBoolean)(scalar(args).kind === 1 /* RVKind.Number */));
+    defineEager("ISTEXT", 1, 1, args => (0, values_1.rvBoolean)(scalar(args).kind === 2 /* RVKind.String */));
+    defineEager("ISBLANK", 1, 1, args => (0, values_1.rvBoolean)(scalar(args).kind === 0 /* RVKind.Blank */));
+    defineEager("ISLOGICAL", 1, 1, args => (0, values_1.rvBoolean)(scalar(args).kind === 3 /* RVKind.Boolean */));
+    defineEager("ISERROR", 1, 1, args => (0, values_1.rvBoolean)(scalar(args).kind === 4 /* RVKind.Error */));
+    defineEager("ISERR", 1, 1, args => {
+        const v = scalar(args);
+        return (0, values_1.rvBoolean)(v.kind === 4 /* RVKind.Error */ && v.code !== "#N/A");
+    });
+    defineEager("ISNA", 1, 1, args => {
+        const v = scalar(args);
+        return (0, values_1.rvBoolean)(v.kind === 4 /* RVKind.Error */ && v.code === "#N/A");
+    });
+    defineEager("ISNONTEXT", 1, 1, args => (0, values_1.rvBoolean)(scalar(args).kind !== 2 /* RVKind.String */));
+    defineEager("ISEVEN", 1, 1, args => {
+        const v = scalar(args);
+        if (v.kind === 4 /* RVKind.Error */) {
+            return v;
+        }
+        if (v.kind !== 1 /* RVKind.Number */) {
+            return values_1.ERRORS.VALUE;
+        }
+        return (0, values_1.rvBoolean)(Math.floor(Math.abs(v.value)) % 2 === 0);
+    });
+    defineEager("ISODD", 1, 1, args => {
+        const v = scalar(args);
+        if (v.kind === 4 /* RVKind.Error */) {
+            return v;
+        }
+        if (v.kind !== 1 /* RVKind.Number */) {
+            return values_1.ERRORS.VALUE;
+        }
+        return (0, values_1.rvBoolean)(Math.floor(Math.abs(v.value)) % 2 === 1);
+    });
+    defineEager("N", 1, 1, args => {
+        const v = scalar(args);
+        if (v.kind === 1 /* RVKind.Number */) {
+            return v;
+        }
+        if (v.kind === 3 /* RVKind.Boolean */) {
+            return (0, values_1.rvNumber)(v.value ? 1 : 0);
+        }
+        if (v.kind === 4 /* RVKind.Error */) {
+            return v;
+        }
+        return (0, values_1.rvNumber)(0);
+    });
+    defineEager("TYPE", 1, 1, args => {
+        // Check for array BEFORE topLeft extraction
+        if (args[0]?.kind === 5 /* RVKind.Array */) {
+            return (0, values_1.rvNumber)(64);
+        }
+        const v = scalar(args);
+        switch (v.kind) {
+            case 1 /* RVKind.Number */:
+                return (0, values_1.rvNumber)(1);
+            case 2 /* RVKind.String */:
+                return (0, values_1.rvNumber)(2);
+            case 3 /* RVKind.Boolean */:
+                return (0, values_1.rvNumber)(4);
+            case 4 /* RVKind.Error */:
+                return (0, values_1.rvNumber)(16);
+            default:
+                return (0, values_1.rvNumber)(1);
+        }
+    });
+    defineEager("ERROR.TYPE", 1, 1, args => {
+        const v = scalar(args);
+        if (v.kind !== 4 /* RVKind.Error */) {
+            return values_1.ERRORS.NA;
+        }
+        const map = {
+            "#NULL!": 1,
+            "#DIV/0!": 2,
+            "#VALUE!": 3,
+            "#REF!": 4,
+            "#NAME?": 5,
+            "#NUM!": 6,
+            "#N/A": 7
+        };
+        return map[v.code] !== undefined ? (0, values_1.rvNumber)(map[v.code]) : values_1.ERRORS.NA;
+    });
+    defineEager("NA", 0, 0, () => values_1.ERRORS.NA);
+    // ── Stubs — limited implementations for functions that need runtime context ──
+    // INFO returns a handful of environment-describing strings. We implement
+    // the subset that's meaningful in a headless engine: `"release"` (engine
+    // version — we use "16.0" to pretend to be a modern Excel), `"system"`
+    // (the host OS string — the platform that loaded the workbook), and
+    // `"numfile"` / `"origin"` (which require UI context and are always
+    // `#N/A`).
+    defineEager("INFO", 1, 1, args => {
+        if (args.length === 0) {
+            return values_1.ERRORS.NA;
+        }
+        const t = args[0];
+        if (t.kind === 4 /* RVKind.Error */) {
+            return t;
+        }
+        const info = (t.kind === 2 /* RVKind.String */ ? t.value : "").toLowerCase();
+        switch (info) {
+            case "release":
+                return (0, values_1.rvString)("16.0");
+            case "osversion":
+                return (0, values_1.rvString)(`${typeof process !== "undefined" && process.platform ? process.platform : "browser"}`);
+            case "system":
+                // Excel reports "pcdos" or "mac"; we map Node's platform string so
+                // tests that grep for these values behave consistently.
+                if (typeof process !== "undefined" && process.platform) {
+                    return (0, values_1.rvString)(process.platform === "darwin" ? "mac" : "pcdos");
+                }
+                return (0, values_1.rvString)("pcdos");
+            case "recalc":
+                return (0, values_1.rvString)("Automatic");
+            case "directory":
+            case "numfile":
+            case "origin":
+                return values_1.ERRORS.NA;
+            default:
+                return values_1.ERRORS.VALUE;
+        }
+    });
+    // CELL: the evaluator intercepts CELL before this point and handles the
+    // supported info-type subset (address, row, col, contents, type, width,
+    // filename). This fallback only fires if an argument arrangement bypasses
+    // the interception — in which case #N/A matches Excel for unsupported info.
+    defineEager("CELL", 1, 2, () => values_1.ERRORS.NA);
+    // ISREF: the evaluator intercepts ISREF before this point and decides
+    // based on the raw BoundExpr / runtime ReferenceValue. This fallback only
+    // fires if an argument arrangement bypasses the interception — after
+    // dereferencing the answer is always false.
+    defineEager("ISREF", 1, 1, () => (0, values_1.rvBoolean)(false));
+    // SHEET/SHEETS: would need full workbook context — returns 1 as default
+    defineEager("SHEET", 0, 1, () => (0, values_1.rvNumber)(1));
+    defineEager("SHEETS", 0, 1, () => (0, values_1.rvNumber)(1));
+    // ISFORMULA / FORMULATEXT: need evaluator-level reference inspection.
+    // The evaluator intercepts these when the argument is a CellRef/AreaRef;
+    // these stubs only run when the argument has been dereferenced to a value,
+    // in which case the answer is false / #N/A respectively.
+    defineEager("ISFORMULA", 1, 1, () => (0, values_1.rvBoolean)(false));
+    defineEager("FORMULATEXT", 1, 1, () => values_1.ERRORS.NA);
+    // HYPERLINK: simplified semantics — return the friendly name if provided,
+    // otherwise the URL. The link behavior is outside the calculation engine.
+    defineEager("HYPERLINK", 1, 2, args => {
+        const display = args.length > 1 ? (0, values_1.topLeft)(args[1]) : (0, values_1.topLeft)(args[0]);
+        if (display.kind === 4 /* RVKind.Error */) {
+            return display;
+        }
+        if (display.kind === 0 /* RVKind.Blank */) {
+            // If friendly_name was an empty/blank cell, fall back to URL.
+            const url = (0, values_1.topLeft)(args[0]);
+            if (url.kind === 4 /* RVKind.Error */) {
+                return url;
+            }
+            return (0, values_1.rvString)(url.kind === 2 /* RVKind.String */ ? url.value : String(url));
+        }
+        if (display.kind === 2 /* RVKind.String */) {
+            return display;
+        }
+        if (display.kind === 1 /* RVKind.Number */) {
+            return (0, values_1.rvString)(String(display.value));
+        }
+        if (display.kind === 3 /* RVKind.Boolean */) {
+            return (0, values_1.rvString)(display.value ? "TRUE" : "FALSE");
+        }
+        return (0, values_1.rvString)("");
+    });
+    // ── Logical ──
+    defineEager("NOT", 1, 1, args => {
+        const v = scalar(args);
+        if (v.kind === 4 /* RVKind.Error */) {
+            return v;
+        }
+        if (v.kind === 3 /* RVKind.Boolean */) {
+            return (0, values_1.rvBoolean)(!v.value);
+        }
+        if (v.kind === 1 /* RVKind.Number */) {
+            return (0, values_1.rvBoolean)(v.value === 0);
+        }
+        return values_1.ERRORS.VALUE;
+    });
+    defineEager("AND", 1, 255, args => boolAggregate(args, true, (cur, val) => cur && val));
+    defineEager("OR", 1, 255, args => boolAggregate(args, false, (cur, val) => cur || val));
+    defineEager("XOR", 1, 255, args => {
+        let count = 0;
+        let found = false;
+        for (const arg of args) {
+            const r = walkBoolArg(arg, v => {
+                // `found` must only flip when `walkBoolArg` actually visits a
+                // boolean-like cell. The previous code set it after every
+                // argument (even BLANK/empty ranges), so `XOR(A1, B1)` on two
+                // empty cells returned FALSE; Excel returns #VALUE!.
+                found = true;
+                if (v) {
+                    count++;
+                }
+            });
+            if (r) {
+                return r;
+            }
+        }
+        return found ? (0, values_1.rvBoolean)(count % 2 === 1) : values_1.ERRORS.VALUE;
+    });
+}
+/**
+ * Helper: aggregate boolean args (for AND/OR).
+ */
+function boolAggregate(args, init, combine) {
+    let result = init;
+    let found = false;
+    for (const arg of args) {
+        const err = walkBoolArg(arg, v => {
+            found = true;
+            result = combine(result, v);
+        });
+        if (err) {
+            return err;
+        }
+    }
+    return found ? (0, values_1.rvBoolean)(result) : values_1.ERRORS.VALUE;
+}
+/**
+ * Helper: walk a single argument for boolean aggregation.
+ * Returns an error value if one is encountered, otherwise undefined.
+ */
+function walkBoolArg(arg, cb) {
+    if (arg.kind === 4 /* RVKind.Error */) {
+        return arg;
+    }
+    if (arg.kind === 5 /* RVKind.Array */) {
+        for (const row of arg.rows) {
+            for (const cell of row) {
+                if (cell.kind === 4 /* RVKind.Error */) {
+                    return cell;
+                }
+                if (cell.kind === 3 /* RVKind.Boolean */) {
+                    cb(cell.value);
+                }
+                else if (cell.kind === 1 /* RVKind.Number */) {
+                    cb(cell.value !== 0);
+                }
+            }
+        }
+        return undefined;
+    }
+    const v = (0, values_1.topLeft)(arg);
+    if (v.kind === 4 /* RVKind.Error */) {
+        return v;
+    }
+    if (v.kind === 3 /* RVKind.Boolean */) {
+        cb(v.value);
+    }
+    else if (v.kind === 1 /* RVKind.Number */) {
+        cb(v.value !== 0);
+    }
+    else if (v.kind === 2 /* RVKind.String */) {
+        const upper = v.value.toUpperCase();
+        if (upper === "TRUE") {
+            cb(true);
+        }
+        else if (upper === "FALSE") {
+            cb(false);
+        }
+        else {
+            return values_1.ERRORS.VALUE;
+        }
+    }
+    else if (v.kind !== 0 /* RVKind.Blank */) {
+        return values_1.ERRORS.VALUE;
+    }
+    return undefined;
+}
+// ============================================================================
+// Native Text Functions
+// ============================================================================
+const text_1 = require("../functions/text");
+function registerNativeTextFunctions() {
+    defineEager("CONCATENATE", 1, 255, text_1.fnCONCATENATE);
+    defineEager("CONCAT", 1, 255, text_1.fnCONCAT);
+    defineEager("TEXTJOIN", 3, 255, text_1.fnTEXTJOIN);
+    defineEager("LEFT", 1, 2, text_1.fnLEFT);
+    defineEager("LEFTB", 1, 2, text_1.fnLEFT);
+    defineEager("RIGHT", 1, 2, text_1.fnRIGHT);
+    defineEager("RIGHTB", 1, 2, text_1.fnRIGHT);
+    defineEager("MID", 3, 3, text_1.fnMID);
+    defineEager("MIDB", 3, 3, text_1.fnMID);
+    defineEager("LEN", 1, 1, text_1.fnLEN);
+    defineEager("LENB", 1, 1, text_1.fnLEN);
+    defineEager("TRIM", 1, 1, text_1.fnTRIM);
+    defineEager("LOWER", 1, 1, text_1.fnLOWER);
+    defineEager("UPPER", 1, 1, text_1.fnUPPER);
+    defineEager("PROPER", 1, 1, text_1.fnPROPER);
+    defineEager("SUBSTITUTE", 3, 4, text_1.fnSUBSTITUTE);
+    defineEager("REPLACE", 4, 4, text_1.fnREPLACE);
+    defineEager("FIND", 2, 3, text_1.fnFIND);
+    defineEager("FINDB", 2, 3, text_1.fnFIND);
+    defineEager("SEARCH", 2, 3, text_1.fnSEARCH);
+    defineEager("SEARCHB", 2, 3, text_1.fnSEARCH);
+    defineEager("REPT", 2, 2, text_1.fnREPT);
+    defineEager("TEXT", 2, 2, text_1.fnTEXT);
+    defineEager("VALUE", 1, 1, text_1.fnVALUE);
+    defineEager("EXACT", 2, 2, text_1.fnEXACT);
+    defineEager("CODE", 1, 1, text_1.fnCODE);
+    defineEager("CHAR", 1, 1, text_1.fnCHAR);
+    defineEager("CLEAN", 1, 1, text_1.fnCLEAN);
+    defineEager("T", 1, 1, text_1.fnT);
+    defineEager("UNICHAR", 1, 1, text_1.fnUNICHAR);
+    defineEager("UNICODE", 1, 1, text_1.fnUNICODE);
+    defineEager("BAHTTEXT", 1, 1, text_1.fnBAHTTEXT);
+    defineEager("DOLLAR", 1, 2, text_1.fnDOLLAR);
+    defineEager("FIXED", 1, 3, text_1.fnFIXED);
+    defineEager("ASC", 1, 1, text_1.fnASC);
+    defineEager("DBCS", 1, 1, text_1.fnDBCS);
+    defineEager("JIS", 1, 1, text_1.fnJIS);
+    defineEager("PHONETIC", 1, 1, text_1.fnPHONETIC);
+    defineEager("NUMBERVALUE", 1, 3, text_1.fnNUMBERVALUE);
+    defineEager("TEXTBEFORE", 2, 6, text_1.fnTEXTBEFORE);
+    defineEager("TEXTAFTER", 2, 6, text_1.fnTEXTAFTER);
+    defineEager("TEXTSPLIT", 2, 6, text_1.fnTEXTSPLIT);
+    defineEager("REGEXTEST", 2, 3, text_1.fnREGEXTEST);
+    defineEager("REGEXEXTRACT", 2, 4, text_1.fnREGEXEXTRACT);
+    defineEager("REGEXREPLACE", 3, 5, text_1.fnREGEXREPLACE);
+    defineEager("VALUETOTEXT", 1, 2, text_1.fnVALUETOTEXT);
+    defineEager("ARRAYTOTEXT", 1, 2, text_1.fnARRAYTOTEXT);
+    defineEager("ENCODEURL", 1, 1, text_1.fnENCODEURL);
+}
+// ============================================================================
+// Native Date Functions
+// ============================================================================
+const date_1 = require("../functions/date");
+function registerNativeDateFunctions() {
+    defineEager("TODAY", 0, 0, date_1.fnTODAY);
+    defineEager("NOW", 0, 0, date_1.fnNOW);
+    defineEager("YEAR", 1, 1, date_1.fnYEAR);
+    defineEager("MONTH", 1, 1, date_1.fnMONTH);
+    defineEager("DAY", 1, 1, date_1.fnDAY);
+    defineEager("DATE", 3, 3, date_1.fnDATE);
+    defineEager("TIME", 3, 3, date_1.fnTIME);
+    defineEager("HOUR", 1, 1, date_1.fnHOUR);
+    defineEager("MINUTE", 1, 1, date_1.fnMINUTE);
+    defineEager("SECOND", 1, 1, date_1.fnSECOND);
+    defineEager("WEEKDAY", 1, 2, date_1.fnWEEKDAY);
+    defineEager("EOMONTH", 2, 2, date_1.fnEOMONTH);
+    defineEager("EDATE", 2, 2, date_1.fnEDATE);
+    defineEager("DATEDIF", 3, 3, date_1.fnDATEDIF);
+    defineEager("DAYS", 2, 2, date_1.fnDAYS);
+    defineEager("DAYS360", 2, 3, date_1.fnDAYS360);
+    defineEager("ISOWEEKNUM", 1, 1, date_1.fnISOWEEKNUM);
+    defineEager("WEEKNUM", 1, 2, date_1.fnWEEKNUM);
+    defineEager("NETWORKDAYS", 2, 3, date_1.fnNETWORKDAYS);
+    defineEager("NETWORKDAYS.INTL", 2, 4, date_1.fnNETWORKDAYS_INTL);
+    defineEager("WORKDAY", 2, 3, date_1.fnWORKDAY);
+    defineEager("WORKDAY.INTL", 2, 4, date_1.fnWORKDAY_INTL);
+    defineEager("YEARFRAC", 2, 3, date_1.fnYEARFRAC);
+    defineEager("DATEVALUE", 1, 1, date_1.fnDATEVALUE);
+    defineEager("TIMEVALUE", 1, 1, date_1.fnTIMEVALUE);
+}
+// ============================================================================
+// Native Engineering Functions
+// ============================================================================
+const engineering_1 = require("../functions/engineering");
+function registerNativeEngineeringFunctions() {
+    defineEager("BIN2DEC", 1, 1, engineering_1.fnBIN2DEC);
+    defineEager("DEC2BIN", 1, 2, engineering_1.fnDEC2BIN);
+    defineEager("HEX2DEC", 1, 1, engineering_1.fnHEX2DEC);
+    defineEager("DEC2HEX", 1, 2, engineering_1.fnDEC2HEX);
+    defineEager("OCT2DEC", 1, 1, engineering_1.fnOCT2DEC);
+    defineEager("DEC2OCT", 1, 2, engineering_1.fnDEC2OCT);
+    defineEager("DELTA", 1, 2, engineering_1.fnDELTA);
+    defineEager("GESTEP", 1, 2, engineering_1.fnGESTEP);
+    defineEager("COMPLEX", 2, 3, engineering_1.fnCOMPLEX);
+    defineEager("IMREAL", 1, 1, engineering_1.fnIMREAL);
+    defineEager("IMAGINARY", 1, 1, engineering_1.fnIMAGINARY);
+    defineEager("IMABS", 1, 1, engineering_1.fnIMABS);
+    defineEager("IMARGUMENT", 1, 1, engineering_1.fnIMARGUMENT);
+    defineEager("IMCONJUGATE", 1, 1, engineering_1.fnIMCONJUGATE);
+    defineEager("IMSUM", 1, 255, engineering_1.fnIMSUM);
+    defineEager("IMSUB", 2, 2, engineering_1.fnIMSUB);
+    defineEager("IMPRODUCT", 1, 255, engineering_1.fnIMPRODUCT);
+    defineEager("IMDIV", 2, 2, engineering_1.fnIMDIV);
+    defineEager("IMPOWER", 2, 2, engineering_1.fnIMPOWER);
+    defineEager("IMSQRT", 1, 1, engineering_1.fnIMSQRT);
+    defineEager("IMLN", 1, 1, engineering_1.fnIMLN);
+    defineEager("IMLOG2", 1, 1, engineering_1.fnIMLOG2);
+    defineEager("IMLOG10", 1, 1, engineering_1.fnIMLOG10);
+    defineEager("IMEXP", 1, 1, engineering_1.fnIMEXP);
+    defineEager("IMSIN", 1, 1, engineering_1.fnIMSIN);
+    defineEager("IMCOS", 1, 1, engineering_1.fnIMCOS);
+    defineEager("IMTAN", 1, 1, engineering_1.fnIMTAN);
+    defineEager("IMCSC", 1, 1, engineering_1.fnIMCSC);
+    defineEager("IMSEC", 1, 1, engineering_1.fnIMSEC);
+    defineEager("IMCOT", 1, 1, engineering_1.fnIMCOT);
+    defineEager("IMSINH", 1, 1, engineering_1.fnIMSINH);
+    defineEager("IMCOSH", 1, 1, engineering_1.fnIMCOSH);
+    defineEager("IMTANH", 1, 1, engineering_1.fnIMTANH);
+    defineEager("IMCSCH", 1, 1, engineering_1.fnIMCSCH);
+    defineEager("IMSECH", 1, 1, engineering_1.fnIMSECH);
+    defineEager("IMCOTH", 1, 1, engineering_1.fnIMCOTH);
+    defineEager("BIN2HEX", 1, 2, engineering_1.fnBIN2HEX);
+    defineEager("BIN2OCT", 1, 2, engineering_1.fnBIN2OCT);
+    defineEager("HEX2BIN", 1, 2, engineering_1.fnHEX2BIN);
+    defineEager("HEX2OCT", 1, 2, engineering_1.fnHEX2OCT);
+    defineEager("OCT2BIN", 1, 2, engineering_1.fnOCT2BIN);
+    defineEager("OCT2HEX", 1, 2, engineering_1.fnOCT2HEX);
+    defineEager("BESSELJ", 2, 2, engineering_1.fnBESSELJ);
+    defineEager("BESSELI", 2, 2, engineering_1.fnBESSELI);
+    defineEager("BESSELK", 2, 2, engineering_1.fnBESSELK);
+    defineEager("BESSELY", 2, 2, engineering_1.fnBESSELY);
+    defineEager("BITAND", 2, 2, engineering_1.fnBITAND);
+    defineEager("BITOR", 2, 2, engineering_1.fnBITOR);
+    defineEager("BITXOR", 2, 2, engineering_1.fnBITXOR);
+    defineEager("BITLSHIFT", 2, 2, engineering_1.fnBITLSHIFT);
+    defineEager("BITRSHIFT", 2, 2, engineering_1.fnBITRSHIFT);
+}
+// ============================================================================
+// Native Financial Functions
+// ============================================================================
+const financial_1 = require("../functions/financial");
+function registerNativeFinancialFunctions() {
+    defineEager("PMT", 3, 5, financial_1.fnPMT);
+    defineEager("FV", 3, 5, financial_1.fnFV);
+    defineEager("PV", 3, 5, financial_1.fnPV);
+    defineEager("NPV", 2, 255, financial_1.fnNPV);
+    defineEager("IRR", 1, 2, financial_1.fnIRR);
+    defineEager("NPER", 3, 5, financial_1.fnNPER);
+    defineEager("RATE", 3, 6, financial_1.fnRATE);
+    defineEager("SLN", 3, 3, financial_1.fnSLN);
+    defineEager("SYD", 4, 4, financial_1.fnSYD);
+    defineEager("VDB", 5, 7, financial_1.fnVDB);
+    defineEager("FVSCHEDULE", 2, 2, financial_1.fnFVSCHEDULE);
+    defineEager("PDURATION", 3, 3, financial_1.fnPDURATION);
+    defineEager("RRI", 3, 3, financial_1.fnRRI);
+    defineEager("DB", 4, 5, financial_1.fnDB);
+    defineEager("DDB", 4, 5, financial_1.fnDDB);
+    defineEager("IPMT", 4, 6, financial_1.fnIPMT);
+    defineEager("PPMT", 4, 6, financial_1.fnPPMT);
+    defineEager("EFFECT", 2, 2, financial_1.fnEFFECT);
+    defineEager("NOMINAL", 2, 2, financial_1.fnNOMINAL);
+    defineEager("XNPV", 3, 3, financial_1.fnXNPV);
+    defineEager("XIRR", 2, 3, financial_1.fnXIRR);
+    defineEager("MIRR", 3, 3, financial_1.fnMIRR);
+    defineEager("ISPMT", 4, 4, financial_1.fnISPMT);
+    defineEager("CUMPRINC", 6, 6, financial_1.fnCUMPRINC);
+    defineEager("CUMIPMT", 6, 6, financial_1.fnCUMIPMT);
+    defineEager("DOLLARDE", 2, 2, financial_1.fnDOLLARDE);
+    defineEager("DOLLARFR", 2, 2, financial_1.fnDOLLARFR);
+    defineEager("DISC", 4, 5, financial_1.fnDISC);
+    defineEager("PRICEDISC", 4, 5, financial_1.fnPRICEDISC);
+    defineEager("YIELDDISC", 4, 5, financial_1.fnYIELDDISC);
+    defineEager("RECEIVED", 4, 5, financial_1.fnRECEIVED);
+    defineEager("INTRATE", 4, 5, financial_1.fnINTRATE);
+    defineEager("PRICE", 6, 7, financial_1.fnPRICE);
+    defineEager("YIELD", 6, 7, financial_1.fnYIELD);
+    defineEager("DURATION", 5, 6, financial_1.fnDURATION);
+    defineEager("MDURATION", 5, 6, financial_1.fnMDURATION);
+    defineEager("ACCRINT", 6, 8, financial_1.fnACCRINT);
+    defineEager("ACCRINTM", 4, 5, financial_1.fnACCRINTM);
+    defineEager("TBILLPRICE", 3, 3, financial_1.fnTBILLPRICE);
+    defineEager("TBILLYIELD", 3, 3, financial_1.fnTBILLYIELD);
+    defineEager("TBILLEQ", 3, 3, financial_1.fnTBILLEQ);
+    defineEager("PRICEMAT", 5, 6, financial_1.fnPRICEMAT);
+    defineEager("YIELDMAT", 5, 6, financial_1.fnYIELDMAT);
+    defineEager("COUPNCD", 3, 4, financial_1.fnCOUPNCD);
+    defineEager("COUPPCD", 3, 4, financial_1.fnCOUPPCD);
+    defineEager("COUPNUM", 3, 4, financial_1.fnCOUPNUM);
+    defineEager("COUPDAYSNC", 3, 4, financial_1.fnCOUPDAYSNC);
+    defineEager("COUPDAYBS", 3, 4, financial_1.fnCOUPDAYBS);
+    defineEager("COUPDAYS", 3, 4, financial_1.fnCOUPDAYS);
+}
+// ============================================================================
+// Native Statistical Functions
+// ============================================================================
+const statistical_1 = require("../functions/statistical");
+function registerNativeStatisticalFunctions() {
+    defineEager("MEDIAN", 1, 255, statistical_1.fnMEDIAN);
+    defineEager("LARGE", 2, 2, statistical_1.fnLARGE);
+    defineEager("SMALL", 2, 2, statistical_1.fnSMALL);
+    defineEager("RANK", 2, 3, statistical_1.fnRANK);
+    defineEager("RANK.EQ", 2, 3, statistical_1.fnRANK);
+    defineEager("STDEV", 1, 255, statistical_1.fnSTDEV);
+    defineEager("STDEV.S", 1, 255, statistical_1.fnSTDEV);
+    defineEager("STDEVP", 1, 255, statistical_1.fnSTDEVP);
+    defineEager("STDEV.P", 1, 255, statistical_1.fnSTDEVP);
+    defineEager("VAR", 1, 255, statistical_1.fnVAR);
+    defineEager("VAR.S", 1, 255, statistical_1.fnVAR);
+    defineEager("VARP", 1, 255, statistical_1.fnVARP);
+    defineEager("VAR.P", 1, 255, statistical_1.fnVARP);
+    defineEager("NORM.S.DIST", 2, 2, statistical_1.fnNORMSDIST);
+    defineEager("NORMSDIST", 1, 2, statistical_1.fnNORMSDIST);
+    defineEager("NORM.DIST", 4, 4, statistical_1.fnNORMDIST);
+    defineEager("NORMDIST", 4, 4, statistical_1.fnNORMDIST);
+    defineEager("NORM.S.INV", 1, 1, statistical_1.fnNORMSINV);
+    defineEager("NORMSINV", 1, 1, statistical_1.fnNORMSINV);
+    defineEager("NORM.INV", 3, 3, statistical_1.fnNORMINV);
+    defineEager("NORMINV", 3, 3, statistical_1.fnNORMINV);
+    defineEager("PERCENTILE", 2, 2, statistical_1.fnPERCENTILE);
+    defineEager("PERCENTILE.INC", 2, 2, statistical_1.fnPERCENTILE);
+    defineEager("PERCENTILE.EXC", 2, 2, statistical_1.fnPERCENTILEEXC);
+    defineEager("QUARTILE", 2, 2, statistical_1.fnQUARTILE);
+    defineEager("QUARTILE.INC", 2, 2, statistical_1.fnQUARTILE);
+    defineEager("QUARTILE.EXC", 2, 2, statistical_1.fnQUARTILEEXC);
+    defineEager("PERCENTRANK", 2, 3, statistical_1.fnPERCENTRANK_INC);
+    defineEager("PERCENTRANK.INC", 2, 3, statistical_1.fnPERCENTRANK_INC);
+    defineEager("PERCENTRANK.EXC", 2, 3, statistical_1.fnPERCENTRANK_EXC);
+    defineEager("PROB", 3, 4, statistical_1.fnPROB);
+    defineEager("MODE", 1, 255, statistical_1.fnMODE);
+    defineEager("MODE.SNGL", 1, 255, statistical_1.fnMODE);
+    defineEager("CORREL", 2, 2, statistical_1.fnCORREL);
+    defineEager("SLOPE", 2, 2, statistical_1.fnSLOPE);
+    defineEager("INTERCEPT", 2, 2, statistical_1.fnINTERCEPT);
+    defineEager("RSQ", 2, 2, statistical_1.fnRSQ);
+    defineEager("STEYX", 2, 2, statistical_1.fnSTEYX);
+    defineEager("FORECAST", 3, 3, statistical_1.fnFORECAST);
+    defineEager("FORECAST.LINEAR", 3, 3, statistical_1.fnFORECAST);
+    defineEager("GEOMEAN", 1, 255, statistical_1.fnGEOMEAN);
+    defineEager("HARMEAN", 1, 255, statistical_1.fnHARMEAN);
+    defineEager("TRIMMEAN", 2, 2, statistical_1.fnTRIMMEAN);
+    defineEager("DEVSQ", 1, 255, statistical_1.fnDEVSQ);
+    defineEager("AVEDEV", 1, 255, statistical_1.fnAVEDEV);
+    defineEager("CONFIDENCE.NORM", 3, 3, statistical_1.fnCONFIDENCENORM);
+    defineEager("CONFIDENCE.T", 3, 3, statistical_1.fnCONFIDENCE_T);
+    defineEager("COVARIANCE.P", 2, 2, statistical_1.fnCOVARIANCE_P);
+    defineEager("COVARIANCE.S", 2, 2, statistical_1.fnCOVARIANCE_S);
+    defineEager("RANK.AVG", 2, 3, statistical_1.fnRANK_AVG);
+    defineEager("MODE.MULT", 1, 255, statistical_1.fnMODE_MULT);
+    defineEager("CONFIDENCE", 3, 3, statistical_1.fnCONFIDENCENORM);
+    defineEager("FISHER", 1, 1, statistical_1.fnFISHER);
+    defineEager("FISHERINV", 1, 1, statistical_1.fnFISHERINV);
+    defineEager("AVERAGEA", 1, 255, statistical_1.fnAVERAGEA);
+    defineEager("MAXA", 1, 255, statistical_1.fnMAXA);
+    defineEager("MINA", 1, 255, statistical_1.fnMINA);
+    defineEager("POISSON.DIST", 3, 3, statistical_1.fnPOISSON_DIST);
+    defineEager("BINOM.DIST", 4, 4, statistical_1.fnBINOM_DIST);
+    defineEager("BINOMDIST", 4, 4, statistical_1.fnBINOM_DIST);
+    defineEager("BINOM.DIST.RANGE", 3, 4, statistical_1.fnBINOM_DIST_RANGE);
+    defineEager("BINOM.INV", 3, 3, statistical_1.fnBINOM_INV);
+    defineEager("HYPGEOM.DIST", 5, 5, statistical_1.fnHYPGEOM_DIST);
+    defineEager("NEGBINOM.DIST", 4, 4, statistical_1.fnNEGBINOM_DIST);
+    defineEager("CHISQ.DIST", 3, 3, statistical_1.fnCHISQ_DIST);
+    defineEager("CHISQ.INV", 2, 2, statistical_1.fnCHISQ_INV);
+    defineEager("CHISQ.INV.RT", 2, 2, statistical_1.fnCHISQ_INV_RT);
+    defineEager("Z.TEST", 2, 3, statistical_1.fnZ_TEST);
+    defineEager("ZTEST", 2, 3, statistical_1.fnZ_TEST);
+    defineEager("T.TEST", 4, 4, statistical_1.fnT_TEST);
+    defineEager("TTEST", 4, 4, statistical_1.fnT_TEST);
+    defineEager("F.TEST", 2, 2, statistical_1.fnF_TEST);
+    defineEager("FTEST", 2, 2, statistical_1.fnF_TEST);
+    defineEager("CHISQ.TEST", 2, 2, statistical_1.fnCHISQ_TEST);
+    defineEager("CHITEST", 2, 2, statistical_1.fnCHISQ_TEST);
+    defineEager("CHISQ.DIST.RT", 2, 2, statistical_1.fnCHISQ_DIST_RT);
+    defineEager("F.DIST", 4, 4, statistical_1.fnF_DIST);
+    defineEager("F.INV", 3, 3, statistical_1.fnF_INV);
+    defineEager("F.DIST.RT", 3, 3, statistical_1.fnF_DIST_RT);
+    defineEager("F.INV.RT", 3, 3, statistical_1.fnF_INV_RT);
+    defineEager("SKEW", 1, 255, statistical_1.fnSKEW);
+    defineEager("SKEW.P", 1, 255, statistical_1.fnSKEW_P);
+    defineEager("KURT", 1, 255, statistical_1.fnKURT);
+    defineEager("T.DIST", 3, 3, statistical_1.fnT_DIST);
+    defineEager("T.INV", 2, 2, statistical_1.fnT_INV);
+    defineEager("T.DIST.2T", 2, 2, statistical_1.fnT_DIST_2T);
+    defineEager("T.DIST.RT", 2, 2, statistical_1.fnT_DIST_RT);
+    defineEager("T.INV.2T", 2, 2, statistical_1.fnT_INV_2T);
+    defineEager("BETA.DIST", 4, 6, statistical_1.fnBETA_DIST);
+    defineEager("BETA.INV", 3, 5, statistical_1.fnBETA_INV);
+    defineEager("GAMMA", 1, 1, statistical_1.fnGAMMA);
+    defineEager("GAMMALN", 1, 1, statistical_1.fnGAMMALN);
+    defineEager("GAMMALN.PRECISE", 1, 1, statistical_1.fnGAMMALN);
+    defineEager("GAMMA.DIST", 4, 4, statistical_1.fnGAMMA_DIST);
+    defineEager("GAMMA.INV", 3, 3, statistical_1.fnGAMMA_INV);
+    defineEager("EXPON.DIST", 3, 3, statistical_1.fnEXPON_DIST);
+    defineEager("WEIBULL.DIST", 4, 4, statistical_1.fnWEIBULL_DIST);
+    defineEager("LOGNORM.DIST", 4, 4, statistical_1.fnLOGNORM_DIST);
+    defineEager("LOGNORM.INV", 3, 3, statistical_1.fnLOGNORM_INV);
+    defineEager("PHI", 1, 1, statistical_1.fnPHI);
+    defineEager("GAUSS", 1, 1, statistical_1.fnGAUSS);
+    defineEager("ERF", 1, 2, statistical_1.fnERF);
+    defineEager("ERF.PRECISE", 1, 2, statistical_1.fnERF);
+    defineEager("ERFC", 1, 1, statistical_1.fnERFC);
+    defineEager("ERFC.PRECISE", 1, 1, statistical_1.fnERFC);
+    defineEager("STANDARDIZE", 3, 3, statistical_1.fnSTANDARDIZE);
+    defineEager("FREQUENCY", 2, 2, statistical_1.fnFREQUENCY);
+    defineEager("GROWTH", 1, 4, statistical_1.fnGROWTH);
+    defineEager("TREND", 1, 4, statistical_1.fnTREND);
+    defineEager("LINEST", 1, 4, statistical_1.fnLINEST);
+    defineEager("LOGEST", 1, 4, statistical_1.fnLOGEST);
+}
+// ============================================================================
+// Native Math Functions
+// ============================================================================
+const math_1 = require("../functions/math");
+function registerNativeMathFunctions() {
+    defineEager("SUM", 1, 255, math_1.fnSUM);
+    defineEager("AVERAGE", 1, 255, math_1.fnAVERAGE);
+    defineEager("MIN", 1, 255, math_1.fnMIN);
+    defineEager("MAX", 1, 255, math_1.fnMAX);
+    defineEager("COUNT", 1, 255, math_1.fnCOUNT);
+    defineEager("COUNTA", 1, 255, math_1.fnCOUNTA);
+    defineEager("COUNTBLANK", 1, 1, math_1.fnCOUNTBLANK);
+    defineEager("PRODUCT", 1, 255, math_1.fnPRODUCT);
+    defineEager("SUMPRODUCT", 1, 255, math_1.fnSUMPRODUCT);
+    defineEager("MMULT", 2, 2, math_1.fnMMULT);
+    defineEager("MDETERM", 1, 1, math_1.fnMDETERM);
+    defineEager("MINVERSE", 1, 1, math_1.fnMINVERSE);
+    defineEager("MUNIT", 1, 1, math_1.fnMUNIT);
+    defineEager("SERIESSUM", 4, 4, math_1.fnSERIESSUM);
+    defineEager("ABS", 1, 1, math_1.fnABS);
+    defineEager("CEILING", 2, 2, math_1.fnCEILING);
+    defineEager("CEILING.MATH", 1, 3, math_1.fnCEILING);
+    defineEager("CEILING.PRECISE", 1, 2, math_1.fnCEILING);
+    defineEager("ISO.CEILING", 1, 2, math_1.fnCEILING);
+    defineEager("FLOOR", 2, 2, math_1.fnFLOOR);
+    defineEager("FLOOR.MATH", 1, 3, math_1.fnFLOOR);
+    defineEager("FLOOR.PRECISE", 1, 2, math_1.fnFLOOR);
+    defineEager("INT", 1, 1, math_1.fnINT);
+    defineEager("MOD", 2, 2, math_1.fnMOD);
+    defineEager("POWER", 2, 2, math_1.fnPOWER);
+    defineEager("ROUND", 2, 2, math_1.fnROUND);
+    defineEager("ROUNDDOWN", 2, 2, math_1.fnROUNDDOWN);
+    defineEager("ROUNDUP", 2, 2, math_1.fnROUNDUP);
+    defineEager("SQRT", 1, 1, math_1.fnSQRT);
+    defineEager("SQRTPI", 1, 1, math_1.fnSQRTPI);
+    defineEager("LN", 1, 1, math_1.fnLN);
+    defineEager("LOG", 1, 2, math_1.fnLOG);
+    defineEager("LOG10", 1, 1, math_1.fnLOG10);
+    defineEager("EXP", 1, 1, math_1.fnEXP);
+    defineEager("PI", 0, 0, math_1.fnPI);
+    defineEager("RAND", 0, 0, math_1.fnRAND);
+    defineEager("RANDBETWEEN", 2, 2, math_1.fnRANDBETWEEN);
+    defineEager("SIGN", 1, 1, math_1.fnSIGN);
+    defineEager("TRUNC", 1, 2, math_1.fnTRUNC);
+    defineEager("SUMSQ", 1, 255, math_1.fnSUMSQ);
+    defineEager("GCD", 1, 255, math_1.fnGCD);
+    defineEager("LCM", 1, 255, math_1.fnLCM);
+    defineEager("EVEN", 1, 1, math_1.fnEVEN);
+    defineEager("ODD", 1, 1, math_1.fnODD);
+    defineEager("MROUND", 2, 2, math_1.fnMROUND);
+    defineEager("QUOTIENT", 2, 2, math_1.fnQUOTIENT);
+    defineEager("BASE", 2, 3, math_1.fnBASE);
+    defineEager("DECIMAL", 2, 2, math_1.fnDECIMAL);
+    defineEager("ROMAN", 1, 2, math_1.fnROMAN);
+    defineEager("ARABIC", 1, 1, math_1.fnARABIC);
+    defineEager("DEGREES", 1, 1, math_1.fnDEGREES);
+    defineEager("RADIANS", 1, 1, math_1.fnRADIANS);
+    defineEager("SUMX2MY2", 2, 2, math_1.fnSUMX2MY2);
+    defineEager("SUMX2PY2", 2, 2, math_1.fnSUMX2PY2);
+    defineEager("SUMXMY2", 2, 2, math_1.fnSUMXMY2);
+    defineEager("MULTINOMIAL", 1, 255, math_1.fnMULTINOMIAL);
+    defineEager("FACT", 1, 1, math_1.fnFACT);
+    defineEager("FACTDOUBLE", 1, 1, math_1.fnFACTDOUBLE);
+    defineEager("COMBIN", 2, 2, math_1.fnCOMBIN);
+    defineEager("COMBINA", 2, 2, math_1.fnCOMBINA);
+    defineEager("PERMUT", 2, 2, math_1.fnPERMUT);
+    defineEager("SIN", 1, 1, math_1.fnSIN);
+    defineEager("COS", 1, 1, math_1.fnCOS);
+    defineEager("TAN", 1, 1, math_1.fnTAN);
+    defineEager("ASIN", 1, 1, math_1.fnASIN);
+    defineEager("ACOS", 1, 1, math_1.fnACOS);
+    defineEager("ATAN", 1, 1, math_1.fnATAN);
+    defineEager("ATAN2", 2, 2, math_1.fnATAN2);
+    defineEager("SINH", 1, 1, math_1.fnSINH);
+    defineEager("COSH", 1, 1, math_1.fnCOSH);
+    defineEager("TANH", 1, 1, math_1.fnTANH);
+    defineEager("ASINH", 1, 1, math_1.fnASINH);
+    defineEager("ACOSH", 1, 1, math_1.fnACOSH);
+    defineEager("ATANH", 1, 1, math_1.fnATANH);
+    defineEager("SEC", 1, 1, math_1.fnSEC);
+    defineEager("CSC", 1, 1, math_1.fnCSC);
+    defineEager("COT", 1, 1, math_1.fnCOT);
+    defineEager("SECH", 1, 1, math_1.fnSECH);
+    defineEager("CSCH", 1, 1, math_1.fnCSCH);
+    defineEager("COTH", 1, 1, math_1.fnCOTH);
+    defineEager("ACOT", 1, 1, math_1.fnACOT);
+    defineEager("ACOTH", 1, 1, math_1.fnACOTH);
+}
+// ============================================================================
+// Native Conditional Functions
+// ============================================================================
+const conditional_1 = require("../functions/conditional");
+function registerNativeConditionalFunctions() {
+    defineEager("SUMIF", 2, 3, conditional_1.fnSUMIF);
+    defineEager("SUMIFS", 3, 255, conditional_1.fnSUMIFS);
+    defineEager("COUNTIF", 2, 2, conditional_1.fnCOUNTIF);
+    defineEager("COUNTIFS", 2, 255, conditional_1.fnCOUNTIFS);
+    defineEager("AVERAGEIF", 2, 3, conditional_1.fnAVERAGEIF);
+    defineEager("AVERAGEIFS", 3, 255, conditional_1.fnAVERAGEIFS);
+    defineEager("MAXIFS", 3, 255, conditional_1.fnMAXIFS);
+    defineEager("MINIFS", 3, 255, conditional_1.fnMINIFS);
+}
+// ============================================================================
+// Native Lookup Functions
+// ============================================================================
+const lookup_1 = require("../functions/lookup");
+function registerNativeLookupFunctions() {
+    defineEager("ROW", 0, 1, lookup_1.fnROW);
+    defineEager("COLUMN", 0, 1, lookup_1.fnCOLUMN);
+    defineEager("ROWS", 1, 1, lookup_1.fnROWS);
+    defineEager("COLUMNS", 1, 1, lookup_1.fnCOLUMNS);
+    defineEager("INDEX", 2, 4, lookup_1.fnINDEX);
+    defineEager("MATCH", 2, 3, lookup_1.fnMATCH);
+    defineEager("VLOOKUP", 3, 4, lookup_1.fnVLOOKUP);
+    defineEager("HLOOKUP", 3, 4, lookup_1.fnHLOOKUP);
+    defineEager("XLOOKUP", 3, 6, lookup_1.fnXLOOKUP);
+    defineEager("XMATCH", 2, 4, lookup_1.fnXMATCH);
+    defineEager("ADDRESS", 2, 5, lookup_1.fnADDRESS);
+    defineEager("LOOKUP", 2, 3, lookup_1.fnLOOKUP);
+    defineEager("TRANSPOSE", 1, 1, lookup_1.fnTRANSPOSE);
+    defineEager("AREAS", 1, 1, lookup_1.fnAREAS);
+}
+// ============================================================================
+// Native Dynamic Array Functions
+// ============================================================================
+const dynamic_array_1 = require("../functions/dynamic-array");
+function registerNativeDynamicArrayFunctions() {
+    defineEager("FILTER", 2, 3, dynamic_array_1.fnFILTER);
+    defineEager("SORT", 1, 4, dynamic_array_1.fnSORT);
+    defineEager("UNIQUE", 1, 3, dynamic_array_1.fnUNIQUE);
+    defineEager("SORTBY", 2, 255, dynamic_array_1.fnSORTBY);
+    defineEager("SEQUENCE", 1, 4, dynamic_array_1.fnSEQUENCE);
+    defineEager("RANDARRAY", 0, 5, dynamic_array_1.fnRANDARRAY);
+    defineEager("TOCOL", 1, 3, dynamic_array_1.fnTOCOL);
+    defineEager("TOROW", 1, 3, dynamic_array_1.fnTOROW);
+    defineEager("CHOOSEROWS", 2, 255, dynamic_array_1.fnCHOOSEROWS);
+    defineEager("CHOOSECOLS", 2, 255, dynamic_array_1.fnCHOOSECOLS);
+    defineEager("VSTACK", 1, 255, dynamic_array_1.fnVSTACK);
+    defineEager("HSTACK", 1, 255, dynamic_array_1.fnHSTACK);
+    defineEager("WRAPROWS", 2, 3, dynamic_array_1.fnWRAPROWS);
+    defineEager("WRAPCOLS", 2, 3, dynamic_array_1.fnWRAPCOLS);
+    defineEager("EXPAND", 2, 4, dynamic_array_1.fnEXPAND);
+    defineEager("TAKE", 2, 3, dynamic_array_1.fnTAKE);
+    defineEager("DROP", 2, 3, dynamic_array_1.fnDROP);
+    defineEager("SUBTOTAL", 2, 255, dynamic_array_1.fnSUBTOTAL);
+    defineEager("AGGREGATE", 3, 255, dynamic_array_1.fnAGGREGATE);
+}
+// ============================================================================
+// Native Database Functions
+// ============================================================================
+const database_1 = require("../functions/database");
+function registerNativeDatabaseFunctions() {
+    defineEager("DSUM", 3, 3, database_1.fnDSUM);
+    defineEager("DAVERAGE", 3, 3, database_1.fnDAVERAGE);
+    defineEager("DCOUNT", 3, 3, database_1.fnDCOUNT);
+    defineEager("DCOUNTA", 3, 3, database_1.fnDCOUNTA);
+    defineEager("DMAX", 3, 3, database_1.fnDMAX);
+    defineEager("DMIN", 3, 3, database_1.fnDMIN);
+    defineEager("DPRODUCT", 3, 3, database_1.fnDPRODUCT);
+    defineEager("DGET", 3, 3, database_1.fnDGET);
+    defineEager("DSTDEV", 3, 3, database_1.fnDSTDEV);
+    defineEager("DSTDEVP", 3, 3, database_1.fnDSTDEVP);
+    defineEager("DVAR", 3, 3, database_1.fnDVAR);
+    defineEager("DVARP", 3, 3, database_1.fnDVARP);
+}
+// Auto-initialize on import
+ensureRegistryInitialized();