df-script 1.7.0 → 1.9.0

package/dist/types.d.ts

@@ -27,6 +27,11 @@ export interface IExpr {
     _isLiteral?: boolean;
     _literalValue?: any;
     _aggFn?: AggFn<any> | null;
+    _castType?: RegisteredDataType;
+    _binaryMeta?: {
+        left: any;
+        right: any;
+    };
     _groupingOpsIndex?: number;
     _partitionOpsIndex?: number;
     _partitionBy?: (string | IExpr)[] | null;
@@ -35,6 +40,10 @@ export interface IExpr {
         [key: string]: any;
     } | null;
     _isWindow?: boolean;
+    _baseExpr?: IExpr;
+    _fieldName?: string;
+    _isUnnest?: boolean;
+    _branchOperands?: any[];
     alias(name: string): this;
     cast(dataType: RegisteredDataType): this;
     _resolve(val: any, columns: ColumnDict, height: number): ColumnData | any;
@@ -45,6 +54,7 @@ export interface IExpr {
     debug(label?: string): this;
 }
 export type TimeUnit = "s" | "ms" | "us" | "ns";
+export type DatetimeTimeUnit = "ms" | "us" | "ns";
 export type DateDiffUnit = "ms" | "milliseconds" | "s" | "seconds" | "m" | "minutes" | "h" | "hours" | "d" | "days" | "w" | "weeks" | "mo" | "months" | "q" | "quarters" | "y" | "years";
 export interface DateDiffOptions {
     roundMode?: "exact" | "floor" | "ceil" | "round" | "trunc";
@@ -59,12 +69,101 @@ export interface StrftimeOptions {
     locale?: string;
     timeZone?: string;
 }
+export type StringEncoding = "hex" | "base64";
+export interface StringEncodeOptions {
+    encoding: StringEncoding;
+}
+export interface StringDecodeOptions extends StringEncodeOptions {
+    strict?: boolean;
+}
+export type EscapeRegexMode = "tc39" | "non_alphanumeric_ascii";
+export interface EscapeRegexOptions {
+    /**
+     * Escaping mode:
+     * - "tc39" (default): TC39 ECMAScript standard specification (syntax metacharacters + set operators).
+     * - "non_alphanumeric_ascii": Escapes all non-alphanumeric ASCII characters ([^A-Za-z0-9]) matching Polars / Rust regex::escape.
+     */
+    mode?: EscapeRegexMode;
+}
+export interface ExtractRegexEngineOptions {
+    /**
+     * Index or name of the capture group to extract.
+     */
+    groupIndex?: number | string;
+    /**
+     * Whether matching should be case-insensitive for ASCII characters.
+     */
+    asciiCaseInsensitive?: boolean;
+    /**
+     * Whether to return all matches (global flag). Defaults to false.
+     */
+    global?: boolean;
+}
+export type RegexEngineOptions = Omit<ExtractRegexEngineOptions, "groupIndex">;
+export interface ExtractManyOptions extends ExtractRegexEngineOptions {
+    /**
+     * Whether overlapping matches are allowed.
+     */
+    overlapping?: boolean;
+    /**
+     * Guarantees in case there are overlapping matches that the leftmost match is used.
+     * In case there are multiple candidates for the leftmost match, the pattern which comes
+     * first in patterns is used. May not be used together with overlapping = true.
+     */
+    leftmost?: boolean;
+}
+export interface FindOptions extends ExtractRegexEngineOptions, EscapeRegexOptions {
+    /**
+     * Treat pattern as literal string instead of regex.
+     */
+    literal?: boolean;
+}
+export interface FindManyOptions extends ExtractManyOptions, EscapeRegexOptions {
+    /**
+     * Treat patterns as literal strings instead of regex.
+     */
+    literal?: boolean;
+}
+export interface ReplaceOptions extends RegexEngineOptions, EscapeRegexOptions {
+    /**
+     * Treat pattern as a literal string instead of regex.
+     */
+    literal?: boolean;
+    /**
+     * Number of occurrences to replace. Use -1 or Infinity to replace all. Defaults to 1.
+     */
+    n?: number;
+}
+export interface ReplaceManyOptions extends FindManyOptions {
+}
+export interface SplitOptions extends RegexEngineOptions, EscapeRegexOptions {
+    /**
+     * Treat delimiter as literal string (default: true). Set to false for regex matching.
+     */
+    literal?: boolean;
+    /**
+     * Include delimiter in the split results.
+     */
+    inclusive?: boolean;
+    /**
+     * Maximum number of splits to perform.
+     */
+    limit?: number;
+    /**
+     * If true, pads missing splits with null to guarantee exact limit + 1 parts.
+     */
+    exact?: boolean;
+    /**
+     * If true, throws an InvalidArgumentError if the split does not yield at least limit + 1 parts.
+     */
+    strict?: boolean;
+}
 export type BusinessDayRollType = "raise" | "forward" | "backward";
 export interface IsBusinessDayOptions {
     holidays?: (Date | string | number)[] | Set<number>;
     excludeWeekdays?: number[];
 }
-export interface BusinessDayOffsetOptions extends IsBusinessDayOptions {
+export interface DayOffsetOptions extends IsBusinessDayOptions {
     roll?: BusinessDayRollType;
 }
 export type UtcOffsetType = "base" | "total" | "daylightSavingTime";
@@ -73,6 +172,27 @@ export interface UtcOffsetOptions {
     type?: UtcOffsetType;
     format?: UtcOffsetFormat;
 }
+export interface DateTimeParts {
+    /** Calendar year (e.g. 2026). */
+    year: number;
+    /** 1-indexed calendar month from 1 to 12 (1 = January, 12 = December). */
+    month: number;
+    /** 1-indexed day of the month from 1 to 31. */
+    day: number;
+    /** 0-indexed hour of day from 0 to 23 (0 = Midnight). */
+    hour: number;
+    /** 0-indexed minute of hour from 0 to 59. */
+    minute: number;
+    /** 0-indexed second of minute from 0 to 59. */
+    second: number;
+    /** 0-indexed millisecond from 0 to 999. */
+    ms: number;
+    /** 0-indexed day of week (0 = Sunday, 6 = Saturday). */
+    dayOfWeek?: number;
+    /** Optional target timezone identifier (e.g. "UTC", "America/New_York"). */
+    timeZone?: string | null;
+}
+export type ReplaceDateOptions = Partial<Omit<DateTimeParts, "dayOfWeek">>;
 /** Concatenation Configuration */
 export type ConcatHow = "vertical" | "horizontal" | "diagonal";
 export interface HorizontalConcatOptions {
@@ -106,3 +226,14 @@ export interface ToStructOptions {
     fields?: string[] | ((idx: number) => string);
     upper_bound?: number;
 }
+export interface SkewOptions {
+    bias?: boolean;
+}
+export interface KurtosisOptions {
+    fisher?: boolean;
+    bias?: boolean;
+}
+export interface EntropyOptions {
+    base?: number;
+    normalize?: boolean;
+}

package/dist/utils/array.d.ts

@@ -1,17 +1,24 @@
-import type { AnyTypedArray, ColumnData } from "../types";
+import type { AnyTypedArray, ColumnData, SkewOptions, KurtosisOptions, EntropyOptions } from "../types";
+/** Array Guards **/
 export declare function isTypedArray(v: unknown): v is AnyTypedArray;
 export declare function isArrayOrTypedArray(v: unknown): v is any[] | AnyTypedArray;
-export type ArrayItemType = "string" | "number" | "boolean" | "bigint" | "object" | "plainObject" | "date" | "any" | "null" | "undefined" | "nullish" | (new (...args: any[]) => any) | ((v: unknown) => boolean);
+export declare function toValidArray<T>(val: T | T[] | null | undefined): T[];
+export declare function getArrayElement(arr: any[] | AnyTypedArray, index: number, null_on_oob: boolean): any;
+export type ArrayItemType = "string" | "number" | "boolean" | "bigint" | "object" | "plainObject" | "date" | "any" | "null" | "undefined" | "nullish" | (new (...args: any[]) => any) | ((v: unknown) => any);
 export type ArrayCheckMode = "every" | "some";
 export type IsArrayOfTypeOptionsParams = {
     mode?: ArrayCheckMode;
     allowNulls?: boolean;
     allowEmpty?: boolean;
 };
-export declare function toValidArray<T>(val: T | T[] | null | undefined): T[];
-export declare function toValidStringArray(val: unknown): string[];
-export declare function getArrayElement(arr: any[] | AnyTypedArray, index: number, null_on_oob: boolean): any;
-export declare function isArrayOfType(arr: unknown, type: ArrayItemType, { mode, allowNulls, allowEmpty }?: IsArrayOfTypeOptionsParams): boolean;
+/**
+ * Checks if an array matches a specific item type contract.
+ */
+export declare function isArrayOfType(arr: unknown, type: ArrayItemType, { mode, allowNulls, allowEmpty, }?: IsArrayOfTypeOptionsParams): boolean;
+/**
+ * Coerces array items to a target type contract in a single optimized pass.
+ */
+export declare function toArrayOfType<T = any>(val: unknown, type?: ArrayItemType, { mode, allowNulls, allowEmpty, }?: IsArrayOfTypeOptionsParams): T[];
 export interface SortArrayOptions {
     descending?: boolean;
     nullsLast?: boolean;
@@ -19,15 +26,19 @@ export interface SortArrayOptions {
 export declare function sortArray(arr: unknown, { descending, nullsLast }?: SortArrayOptions): any[];
 export declare function getArrayStats(arr: unknown): {
     sum: number | null;
+    product: number | null;
     count: number;
     min: any;
     max: any;
+    nanMin: any;
+    nanMax: any;
     minIdx: number | null;
     maxIdx: number | null;
     mean: number | null;
     variance: number;
     std: number;
     nullCount: number;
+    nanCount: number;
     len: number;
     hasNulls: boolean;
     isNumeric: boolean;
@@ -246,3 +257,48 @@ export declare function computeDotProduct(pairs: ColumnData<[any, any]>): number
  * Defensive against absolute sum-zero weight errors.
  */
 export declare function computeWeightedAverage(pairs: ColumnData<[any, any]>): number | null;
+/**
+ * Generates Cartesian product pair index arrays for two lengths lenA and lenB.
+ */
+export declare function computeCartesianProduct(lenA: number, lenB: number): {
+    leftIndices: number[];
+    rightIndices: number[];
+};
+export type BinarySearchSide = "left" | "right";
+export interface BinarySearchOptions<T = any> {
+    side?: BinarySearchSide;
+    getValue?: (index: number, item: T) => number;
+}
+/**
+ * Performs a binary search on a sorted numeric array or ArrayLike structure.
+ * Supports an optional `getValue` accessor for indirect index searching without array allocations.
+ * @param arr Sorted array or ArrayLike structure to search within.
+ * @param target Target numeric value to search for.
+ * @param options Binary search options.
+ * @param options.side Search side: `"left"` (bisect_left, first index >= target) or `"right"` (bisect_right, first index > target). Default `"left"`.
+ * @param options.getValue Optional accessor function `(index, item) => number` for indirect searching.
+ * @returns Index insertion point.
+ */
+export declare function binarySearch<T = any>(arr: ArrayLike<T>, target: number, options?: BinarySearchOptions<T>): number;
+/**
+ * Computes the sample skewness of a numeric dataset as the Fisher-Pearson coefficient of skewness.
+ * @param arr ArrayLike dataset
+ * @param options Skewness calculation options ({ bias?: boolean }, default bias=true)
+ */
+export declare function computeSkewness(arr: ArrayLike<any>, options?: SkewOptions): number | null;
+/**
+ * Computes the kurtosis of a numeric dataset.
+ * @param arr ArrayLike dataset
+ * @param options Kurtosis calculation options ({ fisher?: boolean, bias?: boolean }, default fisher=true, bias=true)
+ */
+export declare function computeKurtosis(arr: ArrayLike<any>, options?: KurtosisOptions): number | null;
+/**
+ * Computes the Shannon entropy of a dataset.
+ * @param arr ArrayLike dataset
+ * @param options Entropy options ({ base?: number, normalize?: boolean }, default base=Math.E, normalize=true)
+ */
+export declare function computeEntropy(arr: ArrayLike<any>, options?: EntropyOptions): number | null;
+/** Reduces elements in an array using a bitwise binary operation across valid BigInts/numbers. */
+export declare function reduceBitwise(arr: ArrayLike<any>, op: (acc: bigint, val: bigint) => bigint): number | bigint | null;
+/** Finds the value in target column corresponding to the minimum or maximum value in `by` column. */
+export declare function computeBy(pairs: Array<[any, any]> | null | undefined, statKey: "minIdx" | "maxIdx"): any;

package/dist/utils/binary.d.ts

@@ -1,3 +1,7 @@
 import type { AnyTypedArray } from "../types";
-export declare function isValidBinary(v: unknown): v is string | any[] | AnyTypedArray;
-export declare function toValidBinary(v: unknown): Uint8Array | null;
+export interface BinaryValidationOptions {
+    strict?: boolean;
+}
+export declare function isBinaryObj(v: unknown): v is Uint8Array | Uint8ClampedArray | ArrayBuffer | SharedArrayBuffer | DataView;
+export declare function isValidBinary(v: unknown, options?: BinaryValidationOptions): v is Uint8Array | Uint8ClampedArray | ArrayBuffer | SharedArrayBuffer | DataView | string | number[] | AnyTypedArray;
+export declare function toValidBinary(v: unknown, options?: BinaryValidationOptions): Uint8Array | null;

package/dist/utils/date.d.ts

@@ -1,7 +1,10 @@
-import type { TimeUnit, StrptimeOptions, StrftimeOptions, IsBusinessDayOptions, BusinessDayOffsetOptions, DateDiffUnit, DateDiffOptions, UtcOffsetOptions } from "../types";
+import type { TimeUnit, StrptimeOptions, StrftimeOptions, IsBusinessDayOptions, DayOffsetOptions, DateDiffUnit, DateDiffOptions, UtcOffsetOptions, ReplaceDateOptions, DateTimeParts } from "../types";
 export declare const TIME_PREFIX_REGEX: RegExp;
 export declare const ZONE_OFFSET_REGEX: RegExp;
 export declare const ISO_DATE_ONLY_REGEX: RegExp;
+export declare function _createUTCDate(year: number, monthZeroIndexed?: number, day?: number, hour?: number, minute?: number, second?: number, ms?: number): Date;
+export declare function _getDateTimeParts(d: Date, timeZone?: string): DateTimeParts;
+export declare function _getTimeZoneOffsetMinutes(d: Date, tz: string): number;
 export declare function toValidDate(input: unknown, options?: {
     dateOnly?: boolean;
 }): Date | null;
@@ -21,6 +24,7 @@ export declare function isLeapYear(yOrDate: number | Date): boolean;
 export declare const FORMAT_REGEX: RegExp;
 export declare function strftime(d: Date, { format, locale, timeZone }: StrftimeOptions): string;
 export declare function strptime(str: string, { format, strict, defaultTimeZone }: StrptimeOptions): Date | null;
-export declare function offsetDay(d: Date, n: number | any, { excludeWeekdays, holidays, roll }?: BusinessDayOffsetOptions): Date;
+export declare function offsetDay(d: Date, n: number | any, { excludeWeekdays, holidays, roll }?: DayOffsetOptions): number;
 export declare function getTimeZoneOffset(d: Date, timeZone?: string, options?: UtcOffsetOptions): number | string;
 export declare function isBusinessDay(d: Date, options?: IsBusinessDayOptions): boolean | null;
+export declare function replaceDateComponents(d: Date, opts?: ReplaceDateOptions): Date;

package/dist/utils/duration.d.ts

@@ -0,0 +1,5 @@
+/** @internalfile */
+/**
+ * Scale total milliseconds into the target time unit precision.
+ */
+export declare function scaleDurationMs(ms: number, timeUnit: "ms" | "us" | "ns"): number;

package/dist/utils/index.d.ts

@@ -6,3 +6,4 @@ export * from "./string";
 export * from "./json";
 export * from "./csv";
 export * from "./binary";
+export * from "./duration";

package/dist/utils/json.d.ts

@@ -65,7 +65,7 @@ export type SafeJsonParseOptions<T = unknown, F = T> = JSONParseOptions & {
  * @param options - Configuration options for validation.
  * @returns `true` if the input is a valid JSON or NDJSON string; `false` otherwise.
  */
-export declare function isJsonString(input: unknown, options?: JSONParseOptions): input is string;
+export declare function isJsonString(input: unknown, options?: SafeJsonParseOptions): input is string;
 /**
  * Safely parses a string containing JSON or NDJSON content in a single pass, returning the parsed value if successful
  * and passing the guard validation. If parsing or validation fails, returns the fallback value (if provided)
@@ -75,7 +75,7 @@ export declare function isJsonString(input: unknown, options?: JSONParseOptions)
  * @param options - Configuration options for parsing and validation.
  * @returns The parsed value, the fallback, or the original input.
  */
-export declare function safeJsonParse<T = unknown, I = unknown, F = T>(input: I, { format, allowPrimitives, trimBeforeParse, reviver, ndjson: { skipInvalidLines, maxLines, skipLines }, guard, onError, fallback }?: SafeJsonParseOptions<T, F>): T | I | F;
+export declare function safeJsonParse<T = unknown, I = unknown, F = T>(input: I, options?: SafeJsonParseOptions<T, F>): T | I | F;
 export interface SafeJsonReplacerOptions {
     /** Custom formatter function for Date objects. Ignored if onDate is specified. */
     formatDate?: (v: Date) => string;
@@ -119,3 +119,55 @@ export interface SafeJsonReplacerOptions {
     replacer?: ((this: any, k: string, v: any) => any) | (string | number)[] | null;
 }
 export declare function createSafeJsonReplacer(options?: SafeJsonReplacerOptions): (this: any, k: string, v: any) => any;
+/**
+ * Represents the type of operation a JSONPath token performs.
+ */
+export type JsonTokenType = 
+/**
+ * Selects an object property by name (e.g., .foo or ['foo'])
+ */
+"prop"
+/**
+ * Selects a zero-based or negative array index (e.g., [0] or [-1])
+ */
+ | "idx"
+/**
+ * Selects a range or stepped slice of an array (e.g., [1:5:2])
+ */
+ | "slice"
+/**
+ * Selects all immediate properties of an object or elements of an array (e.g., .* or [*])
+ */
+ | "wildcard"
+/**
+ * Recursively searches and collects matching keys down the hierarchy (e.g., ..foo)
+ * */
+ | "rec";
+/**
+ * Parsed AST token representing a single evaluation step in a JSONPath expression.
+ */
+export interface JsonToken {
+    /** The evaluation operation type. */
+    type: JsonTokenType;
+    /** Property name or recursive search key. Used by "prop" and "rec" tokens. */
+    key?: string;
+    /** Target index position. Used by "idx" tokens. Supports negative indices. */
+    idx?: number;
+    /** Starting array index (inclusive). Used by "slice" tokens. Defaults to 0 or end of array depending on step. */
+    start?: number;
+    /** Ending array index (exclusive). Used by "slice" tokens. Defaults to array bound depending on step. */
+    end?: number;
+    /** Increment step value. Used by "slice" tokens. Defaults to 1. Cannot be 0. */
+    step?: number;
+}
+/**
+ * Tokenizes a JSONPath query string (e.g. "$.user.items[0]") into an array
+ * of executable query tokens without polluting global regex state.
+ * Returns null if path contains unparsed/invalid syntax fragments.
+ */
+export declare function tokenizeJsonPath(path: string): JsonToken[] | null;
+export declare function evaluateJsonToken(item: any, tok: JsonToken, next: any[]): void;
+/**
+ * Extracts the first match from a JSON string or object using the provided JSONPath expression.
+ */
+export declare function jsonPathMatch(jsonInput: unknown, path: string): string | null;

package/dist/utils/number.d.ts

@@ -82,11 +82,14 @@ export type BigIntRange = {
     min: bigint;
     max: bigint;
 } | BigIntRangeType;
-export interface BigIntOptions {
+export interface IsValidBigIntOptions {
     range?: BigIntRange;
+}
+export interface toValidBigIntOptions extends IsValidBigIntOptions {
     truncate?: boolean;
 }
-export declare function toValidBigInt(v: unknown, { range, truncate }?: BigIntOptions): bigint | null;
+export declare function isValidBigInt(v: unknown, { range }?: IsValidBigIntOptions): v is bigint;
+export declare function toValidBigInt(v: unknown, { range, truncate }?: toValidBigIntOptions): bigint | null;
 export interface DecimalOptions {
     precision?: number;
     scale?: number;

package/dist/utils/object.d.ts

@@ -10,6 +10,13 @@ export declare const TAG_NUMBER = "[object Number]";
 export declare const TAG_BOOLEAN = "[object Boolean]";
 export declare const TAG_BIGINT = "[object BigInt]";
 export declare const TAG_SYMBOL = "[object Symbol]";
+export declare const TAG_UINT8ARRAY = "[object Uint8Array]";
+export declare const TAG_UINT8CLAMPEDARRAY = "[object Uint8ClampedArray]";
+export declare const TAG_ARRAYBUFFER = "[object ArrayBuffer]";
+export declare const TAG_SHAREDARRAYBUFFER = "[object SharedArrayBuffer]";
+export declare const TAG_DATAVIEW = "[object DataView]";
+export declare const TAG_OBJECT = "[object Object]";
+export declare const typedArrayTagGetter: (() => any) | undefined;
 export declare function isObj(v: unknown): v is Record<PropertyKey, unknown>;
 export declare function isPlainObj(v: unknown): v is Record<PropertyKey, unknown>;
 export declare function isClass(v: unknown): v is new (...args: any[]) => any;
@@ -24,4 +31,10 @@ export declare function isNumberObj(v: unknown): v is Number;
 export declare function isBooleanObj(v: unknown): v is Boolean;
 export declare function isBigIntObj(v: unknown): v is Object;
 export declare function isSymbolObj(v: unknown): v is Object;
+export declare function isDetachedBuffer(v: unknown): boolean;
+export declare function isArrayBuffer(v: unknown): v is ArrayBuffer;
+export declare function isSharedArrayBuffer(v: unknown): v is SharedArrayBuffer;
+export declare function isDataView(v: unknown): v is DataView;
+export declare function isUint8Array(v: unknown): v is Uint8Array;
+export declare function isUint8ClampedArray(v: unknown): v is Uint8ClampedArray;
 export declare function unboxPrimitiveObj(v: unknown): unknown;

package/dist/utils/string.d.ts

@@ -1,5 +1,5 @@
+import type { StringEncoding, EscapeRegexOptions, ExtractManyOptions, ExtractRegexEngineOptions, RegexEngineOptions, FindOptions, FindManyOptions, SplitOptions, ReplaceOptions, ReplaceManyOptions } from "../types";
 export declare function isBlankString(v: unknown): v is string;
-export declare function escapeRegExp(val: unknown): string;
 export type StripMode = "both" | "start" | "end";
 export type StripCharsOptions = {
     /**
@@ -54,7 +54,7 @@ export declare function toCanonicalString(val: any, { depth, maxDepth }?: {
     maxDepth?: number;
 }): string;
 export interface ChangeCaseOptions {
-    format: "camel" | "kebab" | "pascal" | "snake";
+    format: "camel" | "kebab" | "pascal" | "snake" | "title";
 }
 /**
  * Fully robust, Unicode-aware string tokenization engine.
@@ -65,3 +65,79 @@ export declare function toWords(str: any): string[];
  * High-performance, predictable case converter
  */
 export declare function changeCase(str: any, options: ChangeCaseOptions): string;
+/**
+ * Serializes a value to a JSON string with BigInt support using createSafeJsonReplacer.
+ */
+export declare function encodeObjectToJson(value: unknown): string;
+/**
+ * Encodes a JSON string into a UTF-8 Uint8Array byte array.
+ */
+export declare function encodeJsonToBytes(json: string): Uint8Array;
+/**
+ * Encodes a byte array or binary-coercible input into a standard Base64 string representation.
+ * Uses 8192-byte chunking or native methods to prevent stack overflow errors.
+ */
+export declare function encodeBytesToBase64(bytes: unknown): string;
+/**
+ * Converts a standard Base64 string into a URL-safe Base64URL string.
+ * Replaces '+' with '-', '/' with '_', and strips trailing '=' padding in a single pass.
+ */
+export declare function encodeBase64ToBase64URL(b64: string): string;
+/**
+ * Encodes a string into a hexadecimal string representation.
+ */
+export declare function encodeHex(str: string): string;
+/**
+ * Encodes a string into a Base64 string representation.
+ */
+export declare function encodeBase64(str: string): string;
+/**
+ * Encodes string to hex or base64 based on specified encoding option.
+ */
+export declare function encodeString(str: string | null | undefined, encoding: StringEncoding): string | null;
+/**
+ * Converts a Base64URL string back into standard Base64 format.
+ * Restores URL-safe characters ('-' to '+', '_' to '/') in a single pass and appends '=' padding.
+ */
+export declare function decodeBase64URLToBase64(b64Url: string): string;
+/**
+ * Decodes a standard Base64 string directly into a Uint8Array byte array.
+ */
+export declare function decodeBase64ToBytes(b64: string, strict?: boolean): Uint8Array;
+/**
+ * Decodes a Uint8Array byte array back into a parsed JSON object.
+ */
+export declare function decodeBytesToJson(bytes: Uint8Array): unknown;
+/**
+ * Decodes a Hex-encoded string directly into a Uint8Array byte array.
+ */
+export declare function decodeHexToBytes(hex: string): Uint8Array;
+/**
+ * Decodes a Hex-encoded string into a standard UTF-8 string.
+ */
+export declare function decodeHex(str: string, strict?: boolean): string | null;
+/**
+ * Decodes a Base64 or Base64URL-encoded string into a standard UTF-8 string.
+ */
+export declare function decodeBase64(str: string, strict?: boolean): string | null;
+/**
+ * Decodes hex or base64 encoded string back to standard UTF-8 string.
+ */
+export declare function decodeString(str: string | null | undefined, encoding: StringEncoding, options?: {
+    strict?: boolean;
+} | boolean): string | null;
+export declare function escapeRegExp(val: unknown, options?: EscapeRegexOptions): string;
+export declare function toCleanRegExp(str: string | null | undefined, pattern: string | RegExp, options?: RegexEngineOptions): {
+    reg: RegExp;
+    input: string;
+} | null;
+export declare function extractRegexEngine(str: string | null | undefined, pattern: string | RegExp, options?: ExtractRegexEngineOptions): Record<string, string | null>[] | null;
+export declare function extractRegex(str: string | null | undefined, pattern: string | RegExp, options?: ExtractRegexEngineOptions): string | null;
+export declare function extractRegexAll(str: string | null | undefined, pattern: string | RegExp, options?: ExtractRegexEngineOptions): (string | null)[] | null;
+export declare function extractRegexGroups(str: string | null | undefined, pattern: string | RegExp, options?: ExtractManyOptions): Record<string, string | null> | null;
+export declare function extractRegexMany(str: string | null | undefined, patterns: (string | RegExp)[] | (string | RegExp), options?: ExtractManyOptions): (string | null)[] | null;
+export declare function findRegex(str: string | null | undefined, pattern: string | RegExp, options?: FindOptions): number | null;
+export declare function findManyRegex(str: string | null | undefined, patterns: (string | RegExp)[] | (string | RegExp), options?: FindManyOptions): (number | null)[] | null;
+export declare function splitString(str: string | null | undefined, delimiter: string, options?: SplitOptions): (string | null)[] | null;
+export declare function replaceString(str: string | null | undefined, pattern: string | RegExp, replacement: string | ((match: string, ...args: any[]) => string), options?: ReplaceOptions): string | null;
+export declare function replaceManyString(str: string | null | undefined, patterns: (string | RegExp)[] | Record<string, string>, replaceWith?: (string | ((match: string, ...args: any[]) => string))[] | string | ((match: string, ...args: any[]) => string), options?: ReplaceManyOptions): string | null;

package/dist/utils/table.d.ts

@@ -0,0 +1,76 @@
+/** @file Table Formatting and HTML / Markdown Generation Utilities */
+import type { ColumnDict } from "../types";
+export type ColumnAlignment = "left" | "center" | "right";
+export interface MarkdownOptions {
+    /**
+     * Whether to include the row index column in output.
+     * @default false
+     */
+    index?: boolean;
+    /**
+     * Name of the index column if `index: true`.
+     * @default "(index)"
+     */
+    indexName?: string;
+    /**
+     * Text alignment for table columns. Can be a single alignment for all columns
+     * or a map from column name to alignment.
+     * @default "left"
+     */
+    align?: ColumnAlignment | Record<string, ColumnAlignment>;
+    /**
+     * String representation for null or undefined values.
+     * @default "null"
+     */
+    nullValue?: string;
+}
+export interface HtmlOptions {
+    /**
+     * Whether to include the row index column in output.
+     * @default false
+     */
+    index?: boolean;
+    /**
+     * Name of the index column if `index: true`.
+     * @default ""
+     */
+    indexName?: string;
+    /**
+     * CSS class name(s) to add to the `<table>` element.
+     */
+    classes?: string | string[];
+    /**
+     * HTML `id` attribute to set on the `<table>` element.
+     */
+    tableId?: string;
+    /**
+     * HTML `border` attribute value.
+     */
+    border?: number | string;
+    /**
+     * Whether to escape HTML entities in cell values (`&`, `<`, `>`, `"`, `'`).
+     * @default true
+     */
+    escape?: boolean;
+    /**
+     * String representation for null or undefined values.
+     * @default "null"
+     */
+    nullValue?: string;
+}
+/**
+ * Escapes HTML characters in a string to prevent XSS and broken layouts.
+ */
+export declare function escapeHtml(str: string): string;
+/**
+ * Formats a generic JavaScript value as a safe string for display in tables.
+ */
+export declare function formatCellValue(val: any, nullValue?: string): string;
+/**
+ * Formats DataFrame columnar data into a GitHub-Flavored Markdown (GFM) table string.
+ */
+export declare function stringifyMarkdownTable(columns: ColumnDict, height: number, options?: MarkdownOptions): string;
+/**
+ * Formats DataFrame columnar data into an HTML table string.
+ */
+export declare function stringifyHtmlTable(columns: ColumnDict, height: number, options?: HtmlOptions): string;

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "df-script",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "description": "A zero-dependency, high-performance, expression-based DataFrame library for TypeScript/JavaScript.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
+  "typings": "dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -19,10 +20,11 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc --emitDeclarationOnly && esbuild src/index.ts --bundle --minify --outfile=dist/index.js --platform=node --mangle-props=^_ && esbuild src/index.ts --bundle --minify --outfile=dist/index.mjs --platform=neutral --format=esm --external:fs --mangle-props=^_",
+    "build": "tsc --emitDeclarationOnly && esbuild src/index.ts --bundle --minify --outfile=dist/index.js --platform=node --mangle-props=\\\"^_\\\" && esbuild src/index.ts --bundle --minify --outfile=dist/index.mjs --platform=neutral --format=esm --external:fs --mangle-props=\\\"^_\\\"",
     "test": "tsx _tests/run_all_project_tests.ts",
     "prepublishOnly": "npm run build",
-    "extract-docs": "node scripts/extract-docs.mjs"
+    "extract-docs": "node scripts/extract-docs.mjs",
+    "release": "node scripts/publish.mjs"
   },
   "keywords": [
     "dataframe",
@@ -39,6 +41,14 @@
     "expression-engine"
   ],
   "author": "Trent Morris",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/trentamorris/df-script.git"
+  },
+  "bugs": {
+    "url": "https://github.com/trentamorris/df-script/issues"
+  },
+  "homepage": "https://github.com/trentamorris/df-script#readme",
   "license": "MIT",
   "funding": {
     "type": "custom",