df-script 1.4.0 → 1.5.0

package/dist/columnExpressions/ExprBase.js

@@ -1,45 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExprBase = exports.derive = exports.kleeneBinary = exports.kleeneUnary = void 0;
-const utils_1 = require("../utils");
+exports.ExprBase = exports.derive = void 0;
 const constants_1 = require("./constants");
-const kleeneUnary = (fn) => {
-    return (vArray) => {
-        const height = vArray.length;
-        const result = new Array(height);
-        for (let i = 0; i < height; i++) {
-            const v = vArray[i];
-            result[i] = v == null ? null : fn(v);
-        }
-        return result;
-    };
-};
-exports.kleeneUnary = kleeneUnary;
-const kleeneBinary = (expr, other, fn) => {
-    return (vArray, columns) => {
-        const height = vArray.length;
-        const rResolved = expr._resolve(other, columns, height);
-        const result = new Array(height);
-        if ((0, utils_1.isArrayOrTypedArray)(rResolved)) {
-            for (let i = 0; i < height; i++) {
-                const v = vArray[i];
-                const r = rResolved[i];
-                result[i] = (v == null || r == null) ? null : fn(v, r);
-            }
-        }
-        else {
-            for (let i = 0; i < height; i++) {
-                const v = vArray[i];
-                result[i] = (v == null || rResolved == null) ? null : fn(v, rResolved);
-            }
-        }
-        return result;
-    };
-};
-exports.kleeneBinary = kleeneBinary;
+const exceptions_1 = require("../exceptions");
 const derive = (instance, nextOp) => {
     const Constructor = instance.constructor;
-    const newInst = new Constructor(instance.colName || "");
+    const colNameVal = instance.colNames || instance.colName || "";
+    const newInst = new Constructor(colNameVal);
     Object.assign(newInst, instance);
     newInst.ops = nextOp ? [...instance.ops, nextOp] : [...instance.ops];
     return newInst;
@@ -48,12 +15,15 @@ exports.derive = derive;
 class ExprBase {
     ops = [];
     outputName = "";
+    isLiteral;
+    literalValue;
     aggFn = null;
     groupingOpsIndex;
     partitionOpsIndex;
     partitionBy = null;
+    evaluateWindow;
     _resolve(val, columns, height) {
-        if (val && typeof val === "object" && "evaluate" in val) {
+        if (val instanceof ExprBase) {
             if (val.isLiteral && val.ops.length === 1) {
                 return val.literalValue;
             }
@@ -62,9 +32,7 @@ class ExprBase {
         return val;
     }
     alias(name) {
-        const Constructor = this.constructor;
-        const newInst = new Constructor(this.colName || "");
-        Object.assign(newInst, this);
+        const newInst = (0, exports.derive)(this);
         newInst.outputName = name;
         return newInst;
     }
@@ -84,11 +52,17 @@ class ExprBase {
             return vArray;
         });
     }
-    evaluate(columns, height) {
+    _getInitialValue(columns, height) {
         const name = this.colName;
-        let value = name && name !== constants_1.ALL_COLUMNS_MARKER
+        if (name && name !== constants_1.ALL_COLUMNS_MARKER && !name.startsWith("*") && !(name in columns)) {
+            throw new exceptions_1.ColumnNotFoundError(name);
+        }
+        return name && name !== constants_1.ALL_COLUMNS_MARKER
             ? (columns[name] || new Array(height).fill(null))
             : new Array(height).fill(null);
+    }
+    evaluate(columns, height) {
+        let value = this._getInitialValue(columns, height);
         const ops = this.ops;
         const len = ops.length;
         for (let i = 0; i < len; i++) {
@@ -96,11 +70,8 @@ class ExprBase {
         }
         return value;
     }
-    _evaluatePre(opsIndex, columns, height) {
-        const name = this.colName;
-        let value = name && name !== constants_1.ALL_COLUMNS_MARKER
-            ? (columns[name] || new Array(height).fill(null))
-            : new Array(height).fill(null);
+    evaluatePre(opsIndex, columns, height) {
+        let value = this._getInitialValue(columns, height);
         const ops = this.ops;
         const idx = opsIndex !== undefined ? opsIndex : ops.length;
         for (let i = 0; i < idx; i++) {
@@ -108,7 +79,7 @@ class ExprBase {
         }
         return value;
     }
-    _evaluatePost(opsIndex, aggregatedArray, columns) {
+    evaluatePost(opsIndex, aggregatedArray, columns) {
         const ops = this.ops;
         const idx = opsIndex !== undefined ? opsIndex : ops.length;
         let value = aggregatedArray;
@@ -117,17 +88,5 @@ class ExprBase {
         }
         return value;
     }
-    evaluatePrePartition(columns, height) {
-        return this._evaluatePre(this.partitionOpsIndex, columns, height);
-    }
-    evaluatePostPartition(aggregatedArray, columns) {
-        return this._evaluatePost(this.partitionOpsIndex, aggregatedArray, columns);
-    }
-    evaluatePreGrouping(columns, height) {
-        return this._evaluatePre(this.groupingOpsIndex, columns, height);
-    }
-    evaluatePostGrouping(aggregatedArray, columns) {
-        return this._evaluatePost(this.groupingOpsIndex, aggregatedArray, columns);
-    }
 }
 exports.ExprBase = ExprBase;

package/dist/columnExpressions/constants.d.ts

@@ -1,2 +1,4 @@
 export declare const ALL_COLUMNS_MARKER = "*";
 export declare const LITERAL_MARKER = "*literal*";
+export declare const COALESCE_MARKER = "*coalesce*";
+export declare const ELEMENT_MARKER = "*element*";

package/dist/columnExpressions/constants.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LITERAL_MARKER = exports.ALL_COLUMNS_MARKER = void 0;
+exports.ELEMENT_MARKER = exports.COALESCE_MARKER = exports.LITERAL_MARKER = exports.ALL_COLUMNS_MARKER = void 0;
 exports.ALL_COLUMNS_MARKER = "*";
 exports.LITERAL_MARKER = "*literal*";
+exports.COALESCE_MARKER = "*coalesce*";
+exports.ELEMENT_MARKER = "*element*";

package/dist/columnExpressions/functions/coalesce.js

@@ -3,15 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.coalesce = coalesce;
 const ColumnExpr_1 = require("../ColumnExpr");
 const utils_1 = require("../../utils");
+const constants_1 = require("../constants");
 function coalesce(...exprs) {
     const rawArgs = (exprs.length === 1 && Array.isArray(exprs[0]))
         ? exprs[0]
         : exprs;
-    const expr = new ColumnExpr_1.ColumnExpr("*coalesce*");
+    const expr = new ColumnExpr_1.ColumnExpr(constants_1.COALESCE_MARKER);
     expr.ops.push((_, columns) => {
         const height = _.length;
         const evaluateArg = (arg) => {
-            if (arg && typeof arg === "object" && "evaluate" in arg) {
+            if (ColumnExpr_1.ColumnExpr.isColExpr(arg)) {
                 return arg.evaluate(columns, height);
             }
             if (typeof arg === "string") {
@@ -19,9 +20,12 @@ function coalesce(...exprs) {
             }
             return arg;
         };
-        const evaluatedArrays = rawArgs.map(evaluateArg);
+        const exprCount = rawArgs.length;
+        const evaluatedArrays = new Array(exprCount);
+        for (let j = 0; j < exprCount; j++) {
+            evaluatedArrays[j] = evaluateArg(rawArgs[j]);
+        }
         const result = new Array(height);
-        const exprCount = evaluatedArrays.length;
         for (let i = 0; i < height; i++) {
             let foundVal = null;
             for (let j = 0; j < exprCount; j++) {

package/dist/columnExpressions/functions/element.d.ts

@@ -0,0 +1,5 @@
+import { ColumnExpr } from "../ColumnExpr";
+/**
+ * Creates an expression referencing the current element(s) of a list during evaluation.
+ */
+export declare function element<T = any>(): ColumnExpr<T>;

package/dist/columnExpressions/functions/element.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.element = element;
+const ColumnExpr_1 = require("../ColumnExpr");
+const constants_1 = require("../constants");
+/**
+ * Creates an expression referencing the current element(s) of a list during evaluation.
+ */
+function element() {
+    return new ColumnExpr_1.ColumnExpr(constants_1.ELEMENT_MARKER);
+}

package/dist/columnExpressions/functions/implode.d.ts

@@ -0,0 +1,3 @@
+import { ColumnExpr } from "../ColumnExpr";
+import type { IntoExpr } from "../../types";
+export declare function implode(column: IntoExpr | IntoExpr[]): ColumnExpr<any>;

package/dist/columnExpressions/functions/implode.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.implode = implode;
+const ColumnExpr_1 = require("../ColumnExpr");
+function implode(column) {
+    return ColumnExpr_1.ColumnExpr.toColExpr(column).implode();
+}

package/dist/columnExpressions/functions/lit.d.ts

@@ -1,5 +1,7 @@
 import { ColumnExpr } from "../ColumnExpr";
+import type { SeqRangeOptions } from "./seq_range";
+export type LitOptions = Pick<SeqRangeOptions, "dtype" | "name">;
 /**
  * Creates a literal column expression that repeats the given value for all rows.
  */
-export declare function lit(value: any): ColumnExpr<any>;
+export declare function lit(value: any, options?: LitOptions): ColumnExpr<any>;

package/dist/columnExpressions/functions/lit.js

@@ -1,22 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lit = lit;
-const ColumnExpr_1 = require("../ColumnExpr");
-const constants_1 = require("../constants");
+const seq_range_1 = require("./seq_range");
 /**
  * Creates a literal column expression that repeats the given value for all rows.
  */
-function lit(value) {
-    const expr = new ColumnExpr_1.ColumnExpr(constants_1.LITERAL_MARKER);
-    expr.isLiteral = true;
-    expr.literalValue = value;
-    expr.ops.push((vArray) => {
-        const height = vArray.length;
-        const result = new Array(height);
-        for (let i = 0; i < height; i++) {
-            result[i] = value;
-        }
-        return result;
+function lit(value, options) {
+    const expr = (0, seq_range_1.seq_range)(value, {
+        strict: true,
+        mode: "constant",
+        dtype: options?.dtype,
+        name: options?.name,
     });
+    expr.isLiteral = true;
     return expr;
 }

package/dist/columnExpressions/functions/repeat.d.ts

@@ -0,0 +1,47 @@
+import { ColumnExpr } from "../ColumnExpr";
+import type { RegisteredDataType } from "../../types";
+export type RepeatOptions = {
+    n?: number;
+    dtype?: RegisteredDataType;
+    name?: string;
+} & ({
+    mode?: "constant";
+} | {
+    mode: "cumulative" | "independent";
+    step?: number | ((prevOrIndex: any, index: number) => any);
+}) & ({
+    strict?: true;
+} | {
+    strict: false;
+    pad?: boolean;
+    truncate?: boolean;
+    padValue?: any;
+    startIndex?: number;
+    endIndex?: number;
+});
+export type SeqRangeOptions = {
+    n?: number;
+    dtype?: RegisteredDataType;
+    name?: string;
+    step?: number | ((prevOrIndex: any, index: number) => any);
+    mode?: "cumulative" | "independent";
+} & ({
+    strict?: true;
+} | {
+    strict: false;
+    pad?: boolean;
+    truncate?: boolean;
+    padValue?: any;
+    startIndex?: number;
+    endIndex?: number;
+});
+/**
+ * Creates a literal column expression that repeats the given value.
+ * If n is specified, it repeats the value n times.
+ * If strict is true (default), a height mismatch with the DataFrame will throw a ShapeError.
+ */
+export declare function repeat(value: any, options?: RepeatOptions): ColumnExpr<any>;
+/**
+ * Creates a column expression that generates a sequence of values starting from the given start value.
+ */
+export declare function seq_range(start: any, options?: SeqRangeOptions): ColumnExpr<any>;

package/dist/columnExpressions/functions/repeat.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repeat = repeat;
+exports.seq_range = seq_range;
+const ColumnExpr_1 = require("../ColumnExpr");
+const constants_1 = require("../constants");
+const exceptions_1 = require("../../exceptions");
+const utils_1 = require("../../utils");
+/**
+ * Creates a literal column expression that repeats the given value.
+ * If n is specified, it repeats the value n times.
+ * If strict is true (default), a height mismatch with the DataFrame will throw a ShapeError.
+ */
+function repeat(value, options = { strict: true }) {
+    const expr = new ColumnExpr_1.ColumnExpr(constants_1.LITERAL_MARKER);
+    expr.isLiteral = true;
+    expr.literalValue = value;
+    const opts = options;
+    if (opts.name) {
+        expr.outputName = opts.name;
+    }
+    expr.ops.push((vArray) => {
+        const targetHeight = vArray.length;
+        let start = opts.startIndex !== undefined ? opts.startIndex : 0;
+        if (start < 0) {
+            start = targetHeight + start;
+        }
+        const safeStart = (0, utils_1.clamp)(start, 0, targetHeight);
+        let end = opts.endIndex !== undefined ? opts.endIndex : targetHeight;
+        if (end < 0) {
+            end = targetHeight + end;
+        }
+        const safeEnd = (0, utils_1.clamp)(end, 0, targetHeight);
+        const sliceWidth = Math.max(0, safeEnd - safeStart);
+        const specifiedHeight = opts.n !== undefined ? opts.n : sliceWidth;
+        const strict = opts.strict !== false;
+        if (strict) {
+            if (specifiedHeight !== targetHeight) {
+                throw new exceptions_1.ShapeError(`Column height mismatch: repeat length ${specifiedHeight} does not match DataFrame height ${targetHeight}`);
+            }
+        }
+        else {
+            const pad = opts.pad ?? false;
+            const truncate = opts.truncate ?? false;
+            if (pad && !truncate) {
+                if (specifiedHeight > sliceWidth) {
+                    throw new exceptions_1.ShapeError(`Cannot pad repeat output: specified length ${specifiedHeight} starting at index ${safeStart} exceeds slice width ${sliceWidth} (requires truncation).`);
+                }
+            }
+            else if (truncate && !pad) {
+                if (specifiedHeight < sliceWidth) {
+                    throw new exceptions_1.ShapeError(`Cannot truncate repeat output: specified length ${specifiedHeight} starting at index ${safeStart} is less than slice width ${sliceWidth} (requires padding).`);
+                }
+            }
+        }
+        const finalHeight = targetHeight;
+        const result = new Array(finalHeight);
+        const repeatEnd = Math.min(safeStart + specifiedHeight, safeEnd);
+        const rawFill = opts.padValue !== undefined ? opts.padValue : null;
+        const coercedFill = opts.dtype ? opts.dtype.coerce(rawFill) : rawFill;
+        const hasDtype = !!opts.dtype;
+        const mode = opts.mode || "constant";
+        const step = opts.step !== undefined ? opts.step : 1;
+        // Fast-path optimization for simple constant lit/repeat operations
+        if (mode === "constant" && safeStart === 0 && repeatEnd === finalHeight && !opts.dtype) {
+            for (let i = 0; i < finalHeight; i++) {
+                result[i] = value;
+            }
+            return result;
+        }
+        const seqVals = new Array(specifiedHeight);
+        if (specifiedHeight > 0) {
+            if (mode === "constant") {
+                const finalVal = opts.dtype ? opts.dtype.coerce(value) : value;
+                for (let idx = 0; idx < specifiedHeight; idx++) {
+                    seqVals[idx] = finalVal;
+                }
+            }
+            else if (mode === "independent") {
+                if (typeof step === "function") {
+                    for (let idx = 0; idx < specifiedHeight; idx++) {
+                        const val = step(idx, value);
+                        seqVals[idx] = hasDtype ? opts.dtype.coerce(val) : val;
+                    }
+                }
+                else {
+                    for (let idx = 0; idx < specifiedHeight; idx++) {
+                        const val = value + idx * step;
+                        seqVals[idx] = hasDtype ? opts.dtype.coerce(val) : val;
+                    }
+                }
+            }
+            else {
+                // cumulative mode
+                let current = value;
+                seqVals[0] = hasDtype ? opts.dtype.coerce(current) : current;
+                if (typeof step === "function") {
+                    for (let idx = 1; idx < specifiedHeight; idx++) {
+                        current = step(current, idx);
+                        seqVals[idx] = hasDtype ? opts.dtype.coerce(current) : current;
+                    }
+                }
+                else {
+                    for (let idx = 1; idx < specifiedHeight; idx++) {
+                        current = current + step;
+                        seqVals[idx] = hasDtype ? opts.dtype.coerce(current) : current;
+                    }
+                }
+            }
+        }
+        for (let i = 0; i < finalHeight; i++) {
+            if (i >= safeStart && i < repeatEnd) {
+                result[i] = seqVals[i - safeStart];
+            }
+            else {
+                result[i] = coercedFill;
+            }
+        }
+        return result;
+    });
+    return expr;
+}
+/**
+ * Creates a column expression that generates a sequence of values starting from the given start value.
+ */
+function seq_range(start, options = { strict: true }) {
+    return repeat(start, {
+        ...options,
+        mode: options.mode || "cumulative"
+    });
+}

package/dist/columnExpressions/functions/seq_range.d.ts

@@ -0,0 +1,31 @@
+import { ColumnExpr } from "../ColumnExpr";
+import type { RegisteredDataType } from "../../types";
+import { CumulativeStepContext, IndependentStepContext } from "../../utils";
+export type SeqRangeOptions = {
+    n?: number;
+    dtype?: RegisteredDataType;
+    name?: string;
+} & ({
+    mode: "constant";
+} | {
+    mode?: "cumulative";
+    step?: number | ((context: CumulativeStepContext) => any);
+} | {
+    mode: "independent";
+    step?: number | ((context: IndependentStepContext) => any);
+}) & ({
+    strict?: true;
+} | {
+    strict: false;
+    pad?: boolean;
+    truncate?: boolean;
+    padValue?: any;
+    startIndex?: number;
+    endIndex?: number;
+});
+/**
+ * Creates a column expression that generates a range of values.
+ * If mode is "cumulative" (default) or "independent", it generates a sequence.
+ * If mode is "constant", it repeats the given value.
+ */
+export declare function seq_range(value: any, options?: SeqRangeOptions): ColumnExpr<any>;

package/dist/columnExpressions/functions/seq_range.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seq_range = seq_range;
+const ColumnExpr_1 = require("../ColumnExpr");
+const constants_1 = require("../constants");
+const exceptions_1 = require("../../exceptions");
+const utils_1 = require("../../utils");
+/**
+ * Creates a column expression that generates a range of values.
+ * If mode is "cumulative" (default) or "independent", it generates a sequence.
+ * If mode is "constant", it repeats the given value.
+ */
+function seq_range(value, options = { strict: true }) {
+    const opts = options;
+    const expr = new ColumnExpr_1.ColumnExpr(constants_1.LITERAL_MARKER);
+    expr.literalValue = value;
+    if (opts.name) {
+        expr.outputName = opts.name;
+    }
+    expr.ops.push((vArray) => {
+        const targetHeight = vArray.length;
+        const getIdx = (val, def) => {
+            if (val === undefined)
+                return def;
+            return (0, utils_1.clamp)(val < 0 ? targetHeight + val : val, { min: 0, max: targetHeight });
+        };
+        const safeStart = getIdx(opts.startIndex, 0);
+        const safeEnd = getIdx(opts.endIndex, targetHeight);
+        const sliceWidth = Math.max(0, safeEnd - safeStart);
+        const specifiedHeight = opts.n !== undefined ? opts.n : sliceWidth;
+        const strict = opts.strict !== false;
+        if (strict) {
+            if (specifiedHeight !== targetHeight) {
+                throw new exceptions_1.ShapeError(`Column height mismatch: seq_range length ${specifiedHeight} does not match DataFrame height ${targetHeight}`);
+            }
+        }
+        else {
+            const pad = opts.pad ?? false;
+            const truncate = opts.truncate ?? false;
+            if (pad && !truncate && specifiedHeight > sliceWidth) {
+                throw new exceptions_1.ShapeError(`Cannot pad seq_range output: specified length ${specifiedHeight} starting at index ${safeStart} exceeds slice width ${sliceWidth} (requires truncation).`);
+            }
+            if (truncate && !pad && specifiedHeight < sliceWidth) {
+                throw new exceptions_1.ShapeError(`Cannot truncate seq_range output: specified length ${specifiedHeight} starting at index ${safeStart} is less than slice width ${sliceWidth} (requires padding).`);
+            }
+        }
+        const finalHeight = targetHeight;
+        const hasDtype = !!opts.dtype;
+        const mode = opts.mode || "cumulative";
+        const step = opts.step !== undefined ? opts.step : 1;
+        const coerceVal = hasDtype
+            ? (val) => opts.dtype.coerce(val)
+            : (val) => val;
+        if (strict) {
+            const result = opts.dtype?.allocate
+                ? opts.dtype.allocate(finalHeight)
+                : new Array(finalHeight);
+            (0, utils_1.fillSequence)(result, value, {
+                mode,
+                step,
+                coerce: coerceVal,
+                startIndex: 0,
+                endIndex: finalHeight
+            });
+            return result;
+        }
+        // Non-strict mode path:
+        const repeatEnd = Math.min(safeStart + specifiedHeight, safeEnd);
+        const rawFill = opts.padValue !== undefined ? opts.padValue : null;
+        const coercedFill = coerceVal(rawFill);
+        // Fast-path optimization for simple constant lit/repeat operations
+        if (mode === "constant" && safeStart === 0 && repeatEnd === finalHeight && !opts.dtype) {
+            const result = new Array(finalHeight);
+            for (let i = 0; i < finalHeight; i++) {
+                result[i] = value;
+            }
+            return result;
+        }
+        const result = new Array(finalHeight);
+        result.fill(coercedFill);
+        (0, utils_1.fillSequence)(result, value, {
+            mode,
+            step,
+            coerce: coerceVal,
+            startIndex: safeStart,
+            endIndex: repeatEnd
+        });
+        return result;
+    });
+    return expr;
+}

package/dist/columnExpressions/functions/when.js

@@ -38,7 +38,7 @@ class WhenThen extends ColumnExpr_1.ColumnExpr {
         this.ops.push((_, columns) => {
             const height = _.length;
             const evaluateArg = (arg) => {
-                if (arg && typeof arg === "object" && "evaluate" in arg) {
+                if (ColumnExpr_1.ColumnExpr.isColExpr(arg)) {
                     return arg.evaluate(columns, height);
                 }
                 if (typeof arg === "string" && (arg in columns)) {
@@ -46,11 +46,15 @@ class WhenThen extends ColumnExpr_1.ColumnExpr {
                 }
                 return arg;
             };
-            const evaluatedPreds = this.predicates.map(evaluateArg);
-            const evaluatedVals = this.values.map(evaluateArg);
+            const numConditions = this.predicates.length;
+            const evaluatedPreds = new Array(numConditions);
+            const evaluatedVals = new Array(numConditions);
+            for (let j = 0; j < numConditions; j++) {
+                evaluatedPreds[j] = evaluateArg(this.predicates[j]);
+                evaluatedVals[j] = evaluateArg(this.values[j]);
+            }
             const evaluatedOtherwise = evaluateArg(this.otherwiseValue);
             const result = new Array(height);
-            const numConditions = evaluatedPreds.length;
             for (let i = 0; i < height; i++) {
                 let matched = false;
                 for (let j = 0; j < numConditions; j++) {

package/dist/columnExpressions/index.d.ts

@@ -1,4 +1,3 @@
-import type { IExpr } from "../types";
 export * from "./constants";
 export * from "./types";
 export * from "./ExprBase";
@@ -10,10 +9,14 @@ export * from "./mixins/AggregationExpr";
 export * from "./mixins/WindowExpr";
 export * from "./mixins/TemporalExpr";
 export * from "./mixins/ListExpr";
+export * from "./mixins/StructExpr";
 export * from "./ColumnExpr";
 export * from "./functions/lit";
 export * from "./functions/all";
 export * from "./functions/exclude";
 export * from "./functions/coalesce";
 export * from "./functions/when";
-export declare function resolveColumnSelectors(exprs: any[], allKeys: string[], keysToExcludeFromAll?: string[]): IExpr[];
+export * from "./functions/implode";
+export * from "./functions/seq_range";
+export * from "./functions/element";
+export * from "./utils";