df-script 1.8.0 → 2.0.0

package/dist/types.d.ts

@@ -28,6 +28,10 @@ export interface IExpr {
     _literalValue?: any;
     _aggFn?: AggFn<any> | null;
     _castType?: RegisteredDataType;
+    _binaryMeta?: {
+        left: any;
+        right: any;
+    };
     _groupingOpsIndex?: number;
     _partitionOpsIndex?: number;
     _partitionBy?: (string | IExpr)[] | null;
@@ -36,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;
@@ -47,9 +55,30 @@ export interface IExpr {
 }
 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";
+export type DurationUnit = "ns" | "us" | "ms" | "s" | "m" | "h" | "d" | "w" | "mo" | "q" | "y" | "i";
+export interface DurationInterval {
+    months: number;
+    days: number;
+    ms: number;
+    indexUnits: number;
+    isCalendar: boolean;
+    isIndex: boolean;
+}
+export interface DurationOptions {
+    weeks?: IntoExpr | number;
+    days?: IntoExpr | number;
+    hours?: IntoExpr | number;
+    minutes?: IntoExpr | number;
+    seconds?: IntoExpr | number;
+    milliseconds?: IntoExpr | number;
+    microseconds?: IntoExpr | number;
+    nanoseconds?: IntoExpr | number;
+}
+export interface ParseDurationStringOptions {
+    to?: DurationUnit;
+}
+export interface ToDurationOptions extends ParseDurationStringOptions {
+    fallback?: number;
 }
 export interface StrptimeOptions {
     format: string;
@@ -61,6 +90,95 @@ 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" | "nonAlphanumericAscii";
+export interface EscapeRegexOptions {
+    /**
+     * Escaping mode:
+     * - "tc39" (default): TC39 ECMAScript standard specification (syntax metacharacters + set operators).
+     * - "nonAlphanumericAscii": 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>;
@@ -96,6 +214,19 @@ export interface DateTimeParts {
     timeZone?: string | null;
 }
 export type ReplaceDateOptions = Partial<Omit<DateTimeParts, "dayOfWeek">>;
+/** Rolling Window Configuration */
+export interface RollingOptions {
+    windowSize: number;
+}
+/** Sorting Configuration */
+export interface SortArrayOptions<T = any> {
+    descending?: boolean | boolean[];
+    nullsLast?: boolean;
+    customComp?: ((a: any, b: any) => number) | Partial<Record<keyof T, (a: any, b: any) => number>> | null;
+}
+export interface SortOptions<T = any> extends SortArrayOptions<T> {
+    by: keyof T | (keyof T)[] | IExpr | IExpr[];
+}
 /** Concatenation Configuration */
 export type ConcatHow = "vertical" | "horizontal" | "diagonal";
 export interface HorizontalConcatOptions {
@@ -106,10 +237,9 @@ export interface ConcatOptions {
     horizontal?: HorizontalConcatOptions;
 }
 export type ConcatItem = DataFrame<any> | ColumnDict | RowRecord[];
-export type { UniqueArrayStatsOptions, JoinArrayOptions } from "./utils/array";
 export interface ExplodeOptions {
-    empty_as_null?: boolean;
-    keep_nulls?: boolean;
+    emptyAsNull?: boolean;
+    keepNulls?: boolean;
 }
 import type { DataType } from "./datatypes/DataType";
 export type InferDataType<T> = T extends DataType<infer U> ? U : any;
@@ -127,5 +257,16 @@ export interface FillNullOptions {
 }
 export interface ToStructOptions {
     fields?: string[] | ((idx: number) => string);
-    upper_bound?: number;
+    upperBound?: 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,33 +1,41 @@
-import type { AnyTypedArray, ColumnData } from "../types";
+import type { AnyTypedArray, ColumnData, SkewOptions, KurtosisOptions, EntropyOptions, SortArrayOptions } 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, nullOnOob: 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;
-export interface SortArrayOptions {
-    descending?: boolean;
-    nullsLast?: boolean;
-}
-export declare function sortArray(arr: unknown, { descending, nullsLast }?: SortArrayOptions): any[];
+/**
+ * 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 declare function compareScalarValues(a: any, b: any, { descending, nullsLast, customComp }?: SortArrayOptions): number;
+export declare function sortArray(arr: unknown, { descending, nullsLast, customComp }?: 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;
@@ -85,9 +93,9 @@ export interface StepSliceArrayOptions {
      * If false, throws an error when the starting offset is out of bounds.
      * @default true
      */
-    null_on_oob?: boolean;
+    nullOnOob?: boolean;
 }
-export declare function stepSliceArray<T>(arr: ArrayLike<T>, { step, offsetStart, offsetEnd, maxItemsGathered, null_on_oob }?: StepSliceArrayOptions): T[] | null;
+export declare function stepSliceArray<T>(arr: ArrayLike<T>, { step, offsetStart, offsetEnd, maxItemsGathered, nullOnOob }?: StepSliceArrayOptions): T[] | null;
 /**
  * Options configuration for the `joinArray` utility.
  */
@@ -203,11 +211,6 @@ export type FillSeqOptions = FillSeqBaseOptions & ({
     step?: number | ((context: IndependentStepContext) => any);
 });
 export declare function fillSequence(targetArray: any, initialValue: any, options?: FillSeqOptions): void;
-/**
- * Computes the median of a numeric array, filtering out non-numeric and NaN values.
- * Returns null if no valid numbers remain.
- */
-export declare function computeMedian(values: ArrayLike<any>): number | null;
 /**
  * Computes the quantile of a numeric array using linear interpolation, filtering out non-numeric and NaN values.
  * q must be in [0, 1]. Returns null if no valid numbers remain or q is out of bounds.
@@ -269,3 +272,36 @@ export interface BinarySearchOptions<T = any> {
  * @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;
+export interface FilterByMaskOptions {
+    nullify?: boolean;
+}
+/**
+ * Filters an array or ArrayLike structure where the mask evaluates to truthy.
+ * @param arr The source array or ArrayLike structure to filter.
+ * @param mask A boolean mask array or truthy/falsy scalar.
+ * @param options Configuration options ({ nullify?: boolean }). If nullify is true, non-matching items become null while preserving length.
+ * @returns Filtered array containing matching elements (or nullified elements).
+ */
+export declare function filterByMask<T = any>(arr: ArrayLike<T> | null | undefined, mask: any, options?: FilterByMaskOptions): (T | null)[];

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/csv.d.ts

@@ -67,7 +67,10 @@ export interface WriteCSVOptions extends FormatCSVValueOptions {
      */
     includeBom?: boolean;
 }
-export declare function formatCsvValue(options?: FormatCSVValueOptions): (val: any) => string;
+export declare function formatCsvValue(options?: FormatCSVValueOptions): (val: any) => {
+    str: string;
+    isNumeric: boolean;
+};
 export declare function stringifyCSV(columns: ColumnDict, height: number, options?: WriteCSVOptions & {
     onRow?: (rowStr: string) => void;
 }): string;

package/dist/utils/date.d.ts

@@ -1,30 +1,14 @@
-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;
+import type { TimeUnit, StrptimeOptions, StrftimeOptions, IsBusinessDayOptions, DayOffsetOptions, UtcOffsetOptions, ReplaceDateOptions, DateTimeParts } from "../types";
+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;
 export declare function toValidTime(val: unknown): string | null;
 export declare function toEpoch(d: Date, unit?: TimeUnit): number | bigint;
-export declare function normalizeEpochToMs(n: number | bigint): number;
-export declare function getCentury(d: Date): number | null;
-export declare function getISO(d: Date, options?: {
-    field: "week" | "year";
-}): number | null;
-export declare function getMillennium(d: Date): number | null;
-export declare function getMonthOffset(d: Date, monthOffset: number, day?: number): Date | null;
-export declare function dateDiff(d1: Date, d2: Date, unit: DateDiffUnit, { roundMode }?: DateDiffOptions): number | null;
-export declare function getOrdinalDay(d: Date): number | null;
-export declare function getQuarter(d: Date): number | null;
-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 }?: 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 getTimeZoneOffset(d: Date, timeZone?: string, options?: UtcOffsetOptions): number | string;
 export declare function replaceDateComponents(d: Date, opts?: ReplaceDateOptions): Date;

package/dist/utils/duration.d.ts

@@ -1,5 +1,7 @@
-/** @internalfile */
-/**
- * Scale total milliseconds into the target time unit precision.
- */
-export declare function scaleDurationMs(ms: number, timeUnit: "ms" | "us" | "ns"): number;
+import type { DurationInterval, ParseDurationStringOptions, ToDurationOptions } from "../types";
+export declare const FIXED_DURATION_UNITS: Readonly<Record<string, number>>;
+export declare function scaleDurationMs(ms: number, timeUnit: "ms" | "us" | "ns" | string): number;
+export declare function parseDurationInterval(str: string): DurationInterval;
+export declare function addCalendarDuration(d: unknown, interval: DurationInterval | string, step?: number): Date;
+export declare function parseDurationString(str: string, options?: ParseDurationStringOptions): number;
+export declare function toDuration(v?: unknown, options?: ToDurationOptions): number;

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<T = unknown>(input: unknown, options?: SafeJsonParseOptions<T>): 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,9 @@ 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, Opts extends SafeJsonParseOptions<T, F> = SafeJsonParseOptions<T, F>>(input: I, options?: Opts): Opts extends {
+    format: "ndjson";
+} ? (T[] | I | F) : (T | I | F);
 export interface SafeJsonReplacerOptions {
     /** Custom formatter function for Date objects. Ignored if onDate is specified. */
     formatDate?: (v: Date) => string;
@@ -119,3 +121,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

@@ -1,15 +1,4 @@
-/** @internalfile */
-export declare const TAG_DATE = "[object Date]";
-export declare const TAG_REGEXP = "[object RegExp]";
-export declare const TAG_SET = "[object Set]";
-export declare const TAG_MAP = "[object Map]";
-export declare const TAG_ERROR = "[object Error]";
-export declare const TAG_URL_PARAMS = "[object URLSearchParams]";
-export declare const TAG_STRING = "[object String]";
-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 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 +13,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 = {
     /**
@@ -48,13 +48,14 @@ export type StripCharsOptions = {
         caseInsensitive?: boolean;
     };
 };
+export declare function _trimByMode(str: string, mode?: StripMode): string;
 export declare function stripChars(str: string | null | undefined, characters?: string | RegExp | null, options?: StripCharsOptions): string | null;
 export declare function toCanonicalString(val: any, { depth, maxDepth }?: {
     depth?: number;
     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 +66,83 @@ 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 type UnicodeSurrogateType = "all" | "high" | "low";
+export type IsUnicodeSurrogateOptions = {
+    type?: UnicodeSurrogateType;
+};
+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;