df-script 1.8.0 → 2.0.0

package/dist/columnExpressions/mixins/WindowExpr.d.ts

@@ -7,17 +7,26 @@ import { ExprBase } from "../ExprBase";
  */
 export declare class WindowExpr extends ExprBase {
     _partitionBy: (string | IExpr)[] | null;
-    _window(evaluateWindow: (this: IExpr, groupPreValues: any[], partitionIndices: number[], currentIndex: number) => any): this;
-    _rolling(windowSize: number, aggFn: (vals: any[]) => any): this;
     _cum(reverse: boolean, initialVal: any, stepFn: (acc: any, val: any) => any, postFn?: (acc: any, hasValid: boolean) => any): this;
     get _isWindow(): boolean;
+    _rolling(windowSize: number, aggFn: (vals: any[]) => any): this;
+    _window(evaluateWindow: (this: IExpr, groupPreValues: any[], partitionIndices: number[], currentIndex: number) => any): this;
     /**
      * Window: Computes cumulative count.
      * @param reverse Flag indicating whether to compute from reverse direction.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [10, 20, 30] })
-     * >>> df.with_columns($df.col("val").cum_count().alias("c_count"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").cumCount().alias("c_count"))
      * shape: (3, 2)
      * ┌─────┬─────────┐
      * │ val │ c_count │
@@ -27,66 +36,102 @@ export declare class WindowExpr extends ExprBase {
      * │ 30  │ 3       │
      * └─────┴─────────┘
      */
-    cum_count(reverse?: boolean): this;
+    cumCount(reverse?: boolean): this;
     /**
      * Window: Computes cumulative maximum value.
      * @param reverse Flag indicating whether to compute in reverse direction.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [1, 3, 2] })
-     * >>> df.with_columns($df.col("val").cum_max().alias("c_max"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").cumMax().alias("c_max"))
      * shape: (3, 2)
      * ┌─────┬───────┐
      * │ val │ c_max │
      * ├─────┼───────┤
-     * │ 1   │ 1     │
-     * │ 3   │ 3     │
-     * │ 2   │ 3     │
+     * │ 10  │ 10    │
+     * │ 20  │ 20    │
+     * │ 30  │ 30    │
      * └─────┴───────┘
      */
-    cum_max(reverse?: boolean): this;
+    cumMax(reverse?: boolean): this;
     /**
      * Window: Computes cumulative minimum value.
      * @param reverse Flag indicating whether to compute in reverse direction.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [3, 1, 2] })
-     * >>> df.with_columns($df.col("val").cum_min().alias("c_min"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").cumMin().alias("c_min"))
      * shape: (3, 2)
      * ┌─────┬───────┐
      * │ val │ c_min │
      * ├─────┼───────┤
-     * │ 3   │ 3     │
-     * │ 1   │ 1     │
-     * │ 2   │ 1     │
+     * │ 10  │ 10    │
+     * │ 20  │ 10    │
+     * │ 30  │ 10    │
      * └─────┴───────┘
      */
-    cum_min(reverse?: boolean): this;
+    cumMin(reverse?: boolean): this;
     /**
      * Window: Computes cumulative product of values.
      * @param reverse Flag indicating whether to compute in reverse direction.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [1, 2, 3, 4] })
-     * >>> df.with_columns($df.col("val").cum_prod().alias("c_prod"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").cumProd().alias("c_prod"))
      * shape: (4, 2)
-     * ┌─────┬────────┐
-     * │ val │ c_prod │
-     * ├─────┼────────┤
-     * │ 1   │ 1      │
-     * │ 2   │ 2      │
-     * │ 3   │ 6      │
-     * │ 4   │ 24     │
-     * └─────┴────────┘
+     * ┌───┬────────┐
+     * │ a │ c_prod │
+     * ├───┼────────┤
+     * │ 1 │ 1      │
+     * │ 2 │ 2      │
+     * │ 3 │ 6      │
+     * │ 4 │ 24     │
+     * └───┴────────┘
      */
-    cum_prod(reverse?: boolean): this;
+    cumProd(reverse?: boolean): this;
     /**
      * Window: Computes cumulative sum of values.
      * @param reverse Flag indicating whether to compute in reverse direction.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [10, 20, 30] })
-     * >>> df.with_columns($df.col("val").cum_sum().alias("c_sum"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").cumSum().alias("c_sum"))
      * shape: (3, 2)
      * ┌─────┬───────┐
      * │ val │ c_sum │
@@ -96,31 +141,48 @@ export declare class WindowExpr extends ExprBase {
      * │ 30  │ 60    │
      * └─────┴───────┘
      */
-    cum_sum(reverse?: boolean): this;
+    cumSum(reverse?: boolean): this;
     /**
      * Window: Computes dense rank (ranks without gaps) within group partition.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ score: [100, 100, 90] })
-     * >>> df.with_columns($df.col("score").dense_rank().alias("dr"))
-     * shape: (3, 2)
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("score").denseRank().alias("dr"))
+     * shape: (2, 2)
      * ┌───────┬────┐
      * │ score │ dr │
      * ├───────┼────┤
-     * │ 100   │ 2  │
-     * │ 100   │ 2  │
-     * │ 90    │ 1  │
+     * │ 75    │ 1  │
+     * │ 95    │ 2  │
      * └───────┴────┘
      */
-    dense_rank(): this;
+    denseRank(): this;
     /**
      * Window: Shifts values down by offset, filling missing slots with default value.
      * @param offset Number of rows to shift down (default 1).
      * @param defaultVal Fallback fill value for empty slots (default null).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [10, 20, 30] })
-     * >>> df.with_columns($df.col("val").lag(1, 0).alias("prev"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").lag(1, 0).alias("prev"))
      * shape: (3, 2)
      * ┌─────┬──────┐
      * │ val │ prev │
@@ -137,8 +199,17 @@ export declare class WindowExpr extends ExprBase {
      * @param defaultVal Fallback fill value for empty slots (default null).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [10, 20, 30] })
-     * >>> df.with_columns($df.col("val").lead(1, 0).alias("next"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").lead(1, 0).alias("next"))
      * shape: (3, 2)
      * ┌─────┬──────┐
      * │ val │ next │
@@ -154,31 +225,48 @@ export declare class WindowExpr extends ExprBase {
      * @param columns Column expression or array of columns to partition by.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ cat: ["A", "A", "B"], val: [10, 20, 30] })
-     * >>> df.with_columns($df.col("val").sum().over("cat").alias("cat_sum"))
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───────┬─────┐
+ * │ group │ val │
+ * ├───────┼─────┤
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
+ * └───────┴─────┘
+     * >>> df.withColumns($df.col("val").sum().over("group").alias("cat_sum"))
      * shape: (3, 3)
-     * ┌─────┬─────┬─────────┐
-     * │ cat │ val │ cat_sum │
-     * ├─────┼─────┼─────────┤
-     * │ A   │ 10  │ 30      │
-     * │ A   │ 20  │ 30      │
-     * │ B   │ 30  │ 30      │
-     * └─────┴─────┴─────────┘
+     * ┌───────┬─────┬─────────┐
+     * │ group │ val │ cat_sum │
+     * ├───────┼─────┼─────────┤
+     * │ A     │ 10  │ 30      │
+     * │ A     │ 20  │ 30      │
+     * │ B     │ 30  │ 30      │
+     * └───────┴─────┴─────────┘
      */
     over(columns: string | IExpr | (string | IExpr)[]): this;
     /**
      * Window: Computes rank within group partition.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ score: [100, 80, 90] })
-     * >>> df.with_columns($df.col("score").rank().alias("rank"))
-     * shape: (3, 2)
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("score").rank().alias("rank"))
+     * shape: (2, 2)
      * ┌───────┬──────┐
      * │ score │ rank │
      * ├───────┼──────┤
-     * │ 100   │ 3    │
-     * │ 80    │ 1    │
-     * │ 90    │ 2    │
+     * │ 75    │ 1    │
+     * │ 95    │ 2    │
      * └───────┴──────┘
      */
     rank(): this;
@@ -187,26 +275,43 @@ export declare class WindowExpr extends ExprBase {
      * @param windowSize Size of rolling window.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [1, 5, 2, 8] })
-     * >>> df.with_columns($df.col("val").rolling_max(2).alias("r_max"))
-     * shape: (4, 2)
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").rollingMax(2).alias("r_max"))
+     * shape: (3, 2)
      * ┌─────┬───────┐
      * │ val │ r_max │
      * ├─────┼───────┤
-     * │ 1   │ 1     │
-     * │ 5   │ 5     │
-     * │ 2   │ 5     │
-     * │ 8   │ 8     │
+     * │ 10  │ 10    │
+     * │ 20  │ 20    │
+     * │ 30  │ 30    │
      * └─────┴───────┘
      */
-    rolling_max(windowSize: number): this;
+    rollingMax(windowSize: number): this;
     /**
      * Window: Computes rolling window mean average.
      * @param windowSize Size of rolling window.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [10, 20, 30] })
-     * >>> df.with_columns($df.col("val").rolling_mean(2).alias("r_mean"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").rollingMean(2).alias("r_mean"))
      * shape: (3, 2)
      * ┌─────┬────────┐
      * │ val │ r_mean │
@@ -216,49 +321,76 @@ export declare class WindowExpr extends ExprBase {
      * │ 30  │ 25     │
      * └─────┴────────┘
      */
-    rolling_mean(windowSize: number): this;
+    rollingMean(windowSize: number): this;
     /**
      * Window: Computes rolling window median value.
      * @param windowSize Size of rolling window.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [10, 30, 20] })
-     * >>> df.with_columns($df.col("val").rolling_median(2).alias("r_med"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").rollingMedian(2).alias("r_med"))
      * shape: (3, 2)
      * ┌─────┬───────┐
      * │ val │ r_med │
      * ├─────┼───────┤
      * │ 10  │ 10    │
-     * │ 30  │ 20    │
-     * │ 20  │ 25    │
+     * │ 20  │ 15    │
+     * │ 30  │ 25    │
      * └─────┴───────┘
      */
-    rolling_median(windowSize: number): this;
+    rollingMedian(windowSize: number): this;
     /**
      * Window: Computes rolling window minimum value.
      * @param windowSize Size of rolling window.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [10, 5, 20] })
-     * >>> df.with_columns($df.col("val").rolling_min(2).alias("r_min"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").rollingMin(2).alias("r_min"))
      * shape: (3, 2)
      * ┌─────┬───────┐
      * │ val │ r_min │
      * ├─────┼───────┤
      * │ 10  │ 10    │
-     * │ 5   │ 5     │
-     * │ 20  │ 5     │
+     * │ 20  │ 10    │
+     * │ 30  │ 20    │
      * └─────┴───────┘
      */
-    rolling_min(windowSize: number): this;
+    rollingMin(windowSize: number): this;
     /**
      * Window: Computes rolling window quantile value.
      * @param quantile Quantile boundary between 0.0 and 1.0.
      * @param windowSize Size of rolling window.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [10, 20, 30] })
-     * >>> df.with_columns($df.col("val").rolling_quantile(0.5, 2).alias("r_quant"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").rollingQuantile(0.5, 2).alias("r_quant"))
      * shape: (3, 2)
      * ┌─────┬─────────┐
      * │ val │ r_quant │
@@ -268,31 +400,49 @@ export declare class WindowExpr extends ExprBase {
      * │ 30  │ 25      │
      * └─────┴─────────┘
      */
-    rolling_quantile(quantile: number, windowSize: number): this;
+    rollingQuantile(quantile: number, windowSize: number): this;
     /**
      * Window: Computes rolling window rank.
      * @param windowSize Size of rolling window.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [10, 20, 15] })
-     * >>> df.with_columns($df.col("val").rolling_rank(2).alias("r_rank"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").rollingRank(2).alias("r_rank"))
      * shape: (3, 2)
      * ┌─────┬────────┐
      * │ val │ r_rank │
      * ├─────┼────────┤
      * │ 10  │ 1      │
      * │ 20  │ 2      │
-     * │ 15  │ 1      │
+     * │ 30  │ 2      │
      * └─────┴────────┘
      */
-    rolling_rank(windowSize: number): this;
+    rollingRank(windowSize: number): this;
     /**
      * Window: Computes rolling window standard deviation.
      * @param windowSize Size of rolling window.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [10, 20, 30] })
-     * >>> df.with_columns($df.col("val").rolling_std(2).alias("r_std"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").rollingStd(2).alias("r_std"))
      * shape: (3, 2)
      * ┌─────┬────────┐
      * │ val │ r_std  │
@@ -302,14 +452,23 @@ export declare class WindowExpr extends ExprBase {
      * │ 30  │ 7.071  │
      * └─────┴────────┘
      */
-    rolling_std(windowSize: number): this;
+    rollingStd(windowSize: number): this;
     /**
      * Window: Computes rolling window sum.
      * @param windowSize Size of rolling window.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [10, 20, 30] })
-     * >>> df.with_columns($df.col("val").rolling_sum(2).alias("r_sum"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").rollingSum(2).alias("r_sum"))
      * shape: (3, 2)
      * ┌─────┬───────┐
      * │ val │ r_sum │
@@ -319,21 +478,30 @@ export declare class WindowExpr extends ExprBase {
      * │ 30  │ 50    │
      * └─────┴───────┘
      */
-    rolling_sum(windowSize: number): this;
+    rollingSum(windowSize: number): this;
     /**
      * Window: Computes 1-indexed row number count within group partitions.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ cat: ["A", "A", "B"] })
-     * >>> df.with_columns($df.col("cat").row_number().over("cat").alias("rn"))
-     * shape: (3, 2)
-     * ┌─────┬────┐
-     * │ cat │ rn │
-     * ├─────┼────┤
-     * │ A   │ 1  │
-     * │ A   │ 2  │
-     * │ B   │ 1  │
-     * └─────┴────┘
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───────┬─────┐
+ * │ group │ val │
+ * ├───────┼─────┤
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
+ * └───────┴─────┘
+     * >>> df.withColumns($df.col("val").rowNumber().over("group").alias("rn"))
+     * shape: (3, 3)
+     * ┌───────┬─────┬────┐
+     * │ group │ val │ rn │
+     * ├───────┼─────┼────┤
+     * │ A     │ 10  │ 1  │
+     * │ A     │ 20  │ 2  │
+     * │ B     │ 30  │ 1  │
+     * └───────┴─────┴────┘
      */
-    row_number(): this;
+    rowNumber(): this;
 }

package/dist/columnExpressions/typeInference.d.ts

@@ -0,0 +1,13 @@
+import type { IExpr, DataFrameSchema, RegisteredDataType, ColumnData } from "../types";
+/**
+ * Resolves the DataType for an expression operand, whether it is an IExpr, a DataType, a literal value, or a column name.
+ */
+export declare function resolveOperandType(operand: unknown, schema: DataFrameSchema): RegisteredDataType | undefined;
+/**
+ * Deduces the output DataType of a binary arithmetic operation between two DataTypes.
+ */
+export declare function deduceBinaryType(leftType: RegisteredDataType | undefined, rightType: RegisteredDataType | undefined, colSample?: ColumnData | any[]): RegisteredDataType | undefined;
+/**
+ * Resolves the output DataType of an expression given the input DataFrame schema and evaluated column.
+ */
+export declare function resolveExprOutputType(expr: IExpr, schema: DataFrameSchema, colSample?: ColumnData | any[]): RegisteredDataType | undefined;

package/dist/columnExpressions/types.d.ts

@@ -6,4 +6,9 @@ export interface RandomOptions {
     max?: number;
     integer?: boolean;
 }
-export type NumericArg = number | IExpr | null;
+export type NumericArg = number | bigint | IExpr | null;
+export interface IsCloseOptions {
+    absTol?: number;
+    relTol?: number;
+    nansEqual?: boolean;
+}

package/dist/columnExpressions/utils.d.ts

@@ -12,3 +12,19 @@ export declare function evalBinaryOp(v: any, r: any, fn: (a: any, b: any) => any
 export declare const kleeneUnary: (fn: (v: any) => any) => (vArray: ColumnData) => any[];
 export declare const kleeneBinary: (expr: IExpr, other: any, fn: (v: any, r: any) => any) => (vArray: ColumnData, columns: ColumnDict) => any[];
 export declare function evaluateExpression(expr: IExpr, columns: ColumnDict, height: number): ColumnData;
+/**
+ * Evaluates a column expression, column string lookup, or returns a scalar literal value.
+ */
+export declare function evaluateArg(arg: unknown, columns: ColumnDict | null | undefined, height: number): any;
+/**
+ * Determines whether an evaluated argument is an actual DataFrame column array
+ * rather than a scalar or literal array/buffer cell value.
+ */
+export declare function isEvaluatedColumn(arg: unknown, evaluatedVal: unknown, columns: ColumnDict | null | undefined, height: number): boolean;
+export declare function buildCanonicalSet(vals: any): Set<string>;
+export declare function computeIsIn(vArray: ArrayLike<any>, columns: any, values: any): any[];
+export declare function compareMissing(vArray: ArrayLike<any>, rResolved: any): boolean[];
+export declare function computeRank(arr: any[], value: any, options?: {
+    ignoreNulls?: boolean;
+    dense?: boolean;
+}): number | null;

package/dist/constants.d.ts

@@ -1,6 +1,13 @@
 export declare const NEWLINE = "\n";
 export declare const CARRIAGE_RETURN = "\r";
 export declare const UTF8_BOM = "\uFEFF";
+export declare const NEWLINE_PATTERN = "\\r\\n|\\n|\\r";
+export declare const NEWLINE_REGEX: RegExp;
+/** Reusable singleton TextEncoder instance for UTF-8 string encoding across the codebase. */
+export declare const TEXT_ENCODER: TextEncoder;
+/** Reusable singleton TextDecoder instances for non-fatal and fatal UTF-8 decoding. */
+export declare const TEXT_DECODER: TextDecoder;
+export declare const TEXT_DECODER_FATAL: TextDecoder;
 export declare const MS_PER_WEEK = 604800000;
 export declare const MS_PER_DAY = 86400000;
 export declare const MS_PER_HOUR = 3600000;
@@ -13,6 +20,8 @@ export declare const US_PER_MS = 1000;
 export declare const NS_PER_MS = 1000000;
 export declare const US_PER_MS_BI = 1000n;
 export declare const NS_PER_MS_BI = 1000000n;
+/** Day of week string to UTC day index mapping (Sunday = 0, Saturday = 6) */
+export declare const DAY_OF_WEEK_MAP: Readonly<Record<string, number>>;
 /** Separates composite key segments within a single row hash (e.g. multi-column join keys). */
 export declare const KEY_SEPARATOR = "\0";
 /** Separates key-value pairs within a serialized object or map canonical hash. */
@@ -21,3 +30,32 @@ export declare const KEY_PAIR_SEPARATOR = "\u0001";
 export declare const UNMATCHED_ROW_INDEX = -1;
 /** Maximum allowable length for a single JavaScript array (2^32 - 1). */
 export declare const MAX_JS_ARRAY_LENGTH = 4294967295;
+/** 64-bit Integer Boundaries */
+export declare const INT64_MIN = -9223372036854775808n;
+export declare const INT64_MAX = 9223372036854775807n;
+export declare const UINT64_MIN = 0n;
+export declare const UINT64_MAX = 18446744073709551615n;
+/** 32-bit & Standard Integer Boundaries */
+export declare const INT32_MIN = -2147483648;
+export declare const INT32_MAX = 2147483647;
+export declare const UINT32_MIN = 0;
+export declare const UINT32_MAX = 4294967295;
+export declare const INT16_MIN = -32768;
+export declare const INT16_MAX = 32767;
+export declare const UINT16_MIN = 0;
+export declare const UINT16_MAX = 65535;
+export declare const INT8_MIN = -128;
+export declare const INT8_MAX = 127;
+export declare const UINT8_MIN = 0;
+export declare const UINT8_MAX = 255;
+/** Unicode Codepoint Boundaries for Control Characters & Surrogates */
+export declare const MAX_C0_CONTROL_CODE = 31;
+export declare const ASCII_DEL_CODE = 127;
+export declare const SURROGATE_HIGH_MIN_CODE = 55296;
+export declare const SURROGATE_HIGH_MAX_CODE = 56319;
+export declare const SURROGATE_LOW_MIN_CODE = 56320;
+export declare const SURROGATE_LOW_MAX_CODE = 57343;
+/** Named escape mappings for common control characters */
+export declare const NAMED_CONTROL_ESCAPES: Readonly<Record<number, string>>;
+/** Inverse unescape mapping for control character escape sequences */
+export declare const CONTROL_UNESCAPE_MAP: Readonly<Record<string, string>>;