df-script 1.5.0 → 1.6.0

package/dist/utils/array.d.ts

@@ -0,0 +1,217 @@
+import type { AnyTypedArray } from "../types";
+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 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 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[];
+export declare function getArrayStats(arr: unknown): {
+    sum: number | null;
+    count: number;
+    min: any;
+    max: any;
+    mean: number | null;
+    variance: number;
+    std: number;
+    nullCount: number;
+    len: number;
+    hasNulls: boolean;
+    isNumeric: boolean;
+};
+/**
+ * Options configuration for the `getUniqueArrayStats` utility.
+ */
+export interface UniqueArrayStatsOptions {
+    /**
+     * If true, uses strict serialization comparison (via keySelector or toCanonicalString)
+     * to group complex nested types (like Arrays, Sets, Maps, and Dates) by value instead of reference.
+     * @default false
+     */
+    strict?: boolean;
+    /**
+     * Custom function to extract a unique comparison key from each element.
+     * If strict is true and no selector is provided, falls back to `toCanonicalString`.
+     */
+    keySelector?: (val: any) => any;
+}
+export declare function getUniqueArrayStats(arr: ArrayLike<any>, { strict, keySelector }?: UniqueArrayStatsOptions): {
+    values: any[];
+    count: number;
+    frequencies: Map<any, number>;
+};
+/**
+ * Options configuration for the `stepSliceArray` utility.
+ */
+export interface StepSliceArrayOptions {
+    /**
+     * The step size to slice the array by. Cannot be zero.
+     * Positive values slice forward (left-to-right), negative values slice backward (right-to-left).
+     * @default 1
+     */
+    step?: number;
+    /**
+     * The index to start slicing from (inclusive).
+     * Supports negative values to start relative to the end of the array.
+     * @default 0
+     */
+    offsetStart?: number;
+    /**
+     * The index to end slicing at (exclusive).
+     * Supports negative values to end relative to the end of the array.
+     * Defaults to the end of the array (if step > 0) or -1 (if step < 0).
+     */
+    offsetEnd?: number;
+    /**
+     * Caps the maximum number of items gathered in the sliced result array.
+     * If specified, the slicing process stops once this limit is reached.
+     */
+    maxItemsGathered?: number;
+    /**
+     * If true, returns null when the starting offset is out of bounds.
+     * If false, throws an error when the starting offset is out of bounds.
+     * @default true
+     */
+    null_on_oob?: boolean;
+}
+export declare function stepSliceArray<T>(arr: ArrayLike<T>, { step, offsetStart, offsetEnd, maxItemsGathered, null_on_oob }?: StepSliceArrayOptions): T[] | null;
+/**
+ * Options configuration for the `joinArray` utility.
+ */
+export interface JoinArrayOptions {
+    /**
+     * If true, nullish elements (null and undefined) are completely ignored during joining.
+     * If false (default), nullish elements are serialized as empty strings or custom `nullValue`.
+     * @default false
+     */
+    ignoreNulls?: boolean;
+    /**
+     * Custom string representation for nullish values.
+     * Only applied if `ignoreNulls` is false.
+     * @default ""
+     */
+    nullValue?: string;
+    /**
+     * Optional prefix string prepended to the final joined result.
+     * @default ""
+     */
+    prefix?: string;
+    /**
+     * Optional suffix string appended to the final joined result.
+     * @default ""
+     */
+    suffix?: string;
+    /**
+     * Maximum number of array elements to join.
+     * If specified, elements beyond this limit are omitted and `truncationMarker` is appended.
+     */
+    limit?: number;
+    /**
+     * Custom placeholder string appended to the joined string when limit truncation occurs.
+     * Only applied if `limit` is specified and the array length exceeds it.
+     * @default "..."
+     */
+    truncationMarker?: string;
+    /**
+     * Callback function used to format each individual non-null element to a custom string representation.
+     */
+    valueFormatter?: (val: any, index: number) => string;
+}
+/**
+ * Joins the elements of an array-like structure into a string using a separator.
+ * Excludes nullish checks and formats nested arrays cleanly.
+ */
+export declare function joinArray(arr: ArrayLike<any>, separator?: string, { ignoreNulls, nullValue, prefix, suffix, limit, truncationMarker, valueFormatter }?: JoinArrayOptions): string;
+export interface FillSeqBaseOptions {
+    /**
+     * Type coercion helper applied to each generated value before writing.
+     *
+     * @param v The newly generated candidate value.
+     * @returns The coerced value to write to the array.
+     */
+    coerce?: (v: any) => any;
+    /**
+     * Conditional predicate determining if a value should be replaced at a given index.
+     *
+     * @param v The original/current value at the target index.
+     * @param index The absolute index of the current element.
+     * @param array The entire target array.
+     * @returns True if the candidate value should overwrite the original value, false otherwise.
+     */
+    condition?: (v: any, index: number, array: any[]) => boolean;
+    /**
+     * If true, iterates and populates in reverse (from startIndex down to endIndex).
+     * @default false
+     */
+    reverse?: boolean;
+    /**
+     * The index at which array iteration and writing begins.
+     * @default reverse ? length - 1 : 0
+     */
+    startIndex?: number;
+    /**
+     * The exclusive boundary index at which iteration and writing stops.
+     * @default reverse ? -1 : length
+     */
+    endIndex?: number;
+}
+export interface CumulativeStepContext {
+    /** The accumulated value returned by the step function from the previous stepped index. */
+    prev: any;
+    /** The relative iteration counter of the stepping process (starts at 1). */
+    index: number;
+    /** The original value at the current index in the target array. */
+    originalValue: any;
+    /** The absolute index of the current element in the parent array. */
+    absoluteIndex: number;
+    /** The entire target array being populated/modified. */
+    targetArray: any;
+}
+export interface IndependentStepContext {
+    /** The relative iteration counter of the generation process (starts at 0). */
+    index: number;
+    /** The static starting value passed to the sequence generator. */
+    initialValue: any;
+    /** The original value at the current index in the target array. */
+    originalValue: any;
+    /** The absolute index of the current element in the parent array. */
+    absoluteIndex: number;
+    /** The entire target array being populated/modified. */
+    targetArray: any;
+}
+export type FillSeqOptions = FillSeqBaseOptions & ({
+    mode: "constant";
+    step?: never;
+} | {
+    mode?: "cumulative";
+    step?: number | ((context: CumulativeStepContext) => any);
+} | {
+    mode: "independent";
+    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.
+ */
+export declare function computeQuantile(values: ArrayLike<any>, q: number): number | null;
+/**
+ * Computes the mode(s) of an array, filtering out null/undefined values.
+ * Returns an array of the most frequent values, sorted, or null if empty/no mode.
+ */
+export declare function computeMode(values: ArrayLike<any>): any[] | null;

package/dist/utils/binary.d.ts

@@ -0,0 +1,3 @@
+import type { AnyTypedArray } from "../types";
+export declare function isValidBinary(v: unknown): v is string | any[] | AnyTypedArray;
+export declare function toValidBinary(v: unknown): Uint8Array | null;

package/dist/utils/date.d.ts

@@ -5,7 +5,7 @@ import type { TimeUnit } from "../types";
  * - "12:34" (matches "12:34")
  * - "10:37:16.123" (matches "10:37")
  * - "2026-05-25" (does not match)
- */
+ * */
 export declare const TIME_PREFIX_REGEX: RegExp;
 /**
  * Matches timezone offset indicators at the end of a string.
@@ -18,40 +18,26 @@ export declare const TIME_PREFIX_REGEX: RegExp;
  */
 export declare const ZONE_OFFSET_REGEX: RegExp;
 /**
- * Matches only UTC offset indicators at the end of a string.
+ * Matches strict ISO 8601 date-only format (YYYY-MM-DD).
  * Examples:
- * - "12:34:56Z" (matches "Z")
- * - "12:34:56+00:00" (matches "+00:00")
- * - "12:34:56-0000" (matches "-0000")
- * - "12:34:56+02:00" (does not match)
+ * - "2026-05-25" (matches)
+ * - "2026-05-25T10:37:16Z" (does not match)
  */
-export declare const UTC_INDICATOR_REGEX: RegExp;
-export declare const MS_PER_SECOND = 1000;
-export declare const MS_PER_MINUTE = 60000;
-export declare const MS_PER_HOUR = 3600000;
-export declare const MS_PER_DAY = 86400000;
-export declare const US_PER_MS = 1000;
-export declare const NS_PER_MS = 1000000;
-export interface UtcOffsetResult {
-    timeZoneTime: Date;
-    utcTime: Date;
-    offset: number;
-    formatted: string;
-}
-export declare function toEpoch(d: Date, unit?: TimeUnit): number;
-export declare function getCentury(d: Date): number;
-export declare function getISOWeek(d: Date): number;
-export declare function getMillennium(d: Date): number;
-export declare function getMonthOffset(d: Date, monthOffset: number, day?: number): Date;
-export declare function getOrdinalDay(d: Date): number;
-export declare function getQuarter(d: Date): number;
-export declare function getUtcOffset(timeZone: string): UtcOffsetResult;
+export declare const ISO_DATE_ONLY_REGEX: RegExp;
+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 getISOWeek(d: Date): 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 getOrdinalDay(d: Date): number | null;
+export declare function getQuarter(d: Date): number | null;
 export declare function isLeapYear(yOrDate: number | Date): boolean;
-export declare function isUtcString(timestamp: string | null | undefined): boolean;
-export declare function isValidDate(v: unknown): v is string | number | bigint | Date;
-export declare function isValidDateObj(d: unknown): d is Date;
-export declare function normalizeEpochToMs(n: number): number;
-export declare const STRFTIME_DIRECTIVES: readonly ["%ms", "%f", "%Y", "%y", "%m", "%d", "%e", "%H", "%I", "%p", "%M", "%S", "%A", "%a", "%B", "%b", "%h", "%j", "%u", "%w", "%Z", "%z"];
-export declare function strftime(d: Date, format: string, locale?: string): string;
-export declare function strptime(str: string, format: string, strict?: boolean): Date | null;
-export declare function toValidDate(input: unknown): Date | null;
+export declare const FORMAT_REGEX: RegExp;
+export declare function expandFormatShorthands(format: string): string;
+export declare function strftime(d: Date, format: string, locale?: string, timeZone?: string): string;
+export declare function strptime(str: string, format: string, strict?: boolean, defaultTimeZone?: string): Date | null;

package/dist/utils/guards.d.ts

@@ -1,12 +1,13 @@
-export declare function isTypedArray(v: unknown): v is ArrayBufferView;
-export declare function isArrayOrTypedArray(v: unknown): v is ArrayLike<any> & Iterable<any>;
-export declare function isNonEmptyArray<T = unknown>(arr: unknown): arr is ArrayLike<T>;
-export declare function isNonEmptyArrayObjs<T extends object>(arr: unknown): arr is T[];
-export declare function isNonEmptyObj(v: unknown): v is Record<string, unknown>;
-export declare function isObj(v: unknown): v is Record<string, unknown>;
-export declare function isPlainObj(v: unknown): v is Record<string, unknown>;
+import type { ValidScalarTypes } from "../types";
+/** Array Guards **/
+export type AnyTypedArray = ArrayBufferView & ArrayLike<number | bigint> & Iterable<number | bigint>;
+export declare function isTypedArray(v: unknown): v is AnyTypedArray;
+export declare function isArrayOrTypedArray(v: unknown): v is any[] | AnyTypedArray;
+export declare function isObj(v: unknown): v is Record<PropertyKey, unknown>;
+export declare function isPlainObj(v: unknown): v is Record<PropertyKey, unknown>;
+/** Class Guards **/
 export declare function isClass(v: unknown): v is new (...args: any[]) => any;
-export declare function isScalar(v: unknown): v is string | number | boolean | bigint | Date | Uint8Array;
-export declare function isValidBinary(v: unknown): v is Uint8Array | string | ArrayLike<any>;
+/** Scalar & Conversion Guards **/
+export declare function isScalar<V>(v: V): v is Extract<V, Exclude<ValidScalarTypes, null | undefined>>;
+export declare function isValidBinary(v: unknown): v is string | any[] | AnyTypedArray;
 export declare function toValidBinary(v: unknown): Uint8Array | null;
-export declare function tryParseBoolean(v: unknown): boolean | undefined;

package/dist/utils/index.d.ts

@@ -1,7 +1,8 @@
-export * from "./guards";
+export * from "./object";
 export * from "./number";
 export * from "./date";
-export * from "./list";
+export * from "./array";
 export * from "./string";
 export * from "./json";
 export * from "./csv";
+export * from "./binary";

package/dist/utils/list.d.ts

@@ -8,7 +8,14 @@ export type IsArrayOfTypeOptionsParams = {
 export declare function toValidArray<T>(val: T | T[] | null | undefined): T[];
 export declare function toValidStringArray(val: unknown): string[];
 export declare function isArrayOfType(arr: unknown, type: ArrayItemType, { mode, allowNulls, allowEmpty }?: IsArrayOfTypeOptionsParams): boolean;
-export declare function sortList(arr: unknown, descending?: boolean): any[];
+export interface SortListOptions {
+    descending?: boolean;
+    nullsLast?: boolean;
+    isAllNumbers?: boolean;
+    isAllStrings?: boolean;
+    hasNulls?: boolean;
+}
+export declare function sortList(arr: unknown, options?: SortListOptions): any[];
 export declare function getListStats(arr: unknown): {
     sum: number | null;
     count: number;
@@ -193,3 +200,18 @@ 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.
+ */
+export declare function computeQuantile(values: ArrayLike<any>, q: number): number | null;
+/**
+ * Computes the mode(s) of an array, filtering out null/undefined values.
+ * Returns an array of the most frequent values, sorted, or null if empty/no mode.
+ */
+export declare function computeMode(values: ArrayLike<any>): any[] | null;

package/dist/utils/number.d.ts

@@ -1,8 +1,13 @@
 export interface NumericValidationOptions {
     allowNonFiniteNumbers?: boolean;
+    allowNaN?: boolean;
 }
 export declare function isValidNumber(v: unknown, options?: NumericValidationOptions): v is number;
-export declare function toValidNumber(v: unknown, options?: NumericValidationOptions): number | null;
+export interface ParseNumberOptions extends NumericValidationOptions {
+    strictNumericString?: boolean;
+    floatScientific?: boolean;
+}
+export declare function toValidNumber(v: unknown, { allowNonFiniteNumbers, strictNumericString, floatScientific }?: ParseNumberOptions): number | null;
 export interface NumericFormatOptions extends Intl.NumberFormatOptions {
     /** BCP 47 language tag (e.g., 'en-US' for dot, 'de-DE' for comma). Defaults to 'en-US'. */
     locale?: string;
@@ -10,23 +15,20 @@ export interface NumericFormatOptions extends Intl.NumberFormatOptions {
     accountingNegatives?: boolean;
     /** Fallback string if the value cannot be parsed into a formatable number. */
     fallback?: string;
+    /** If true, returns the fallback string for Infinity and -Infinity values. */
+    formatNonFinite?: boolean;
 }
 /**
  * Formats any numeric value (number, bigint, numeric string, Date, etc.) for output,
  * handling NaN, Infinity, scientific notation, precision, and accounting formats.
  */
-export declare function formatNumber({ locale, accountingNegatives, fallback, ...intlOpts }?: NumericFormatOptions): (value: unknown) => string;
+export declare function formatNumber({ locale, accountingNegatives, fallback, formatNonFinite, ...intlOpts }?: NumericFormatOptions): (value: unknown) => string;
 export type FloatPrecision = "Float32" | "Float64";
-export interface FloatOptions extends NumericValidationOptions {
+export interface FloatOptions extends ParseNumberOptions {
     floatPrecision?: FloatPrecision;
-    /**
-     * When true, explicitly accepts scientific notation strings (e.g. "1.23e+4").
-     * The result is still validated against the precision range.
-     */
-    floatScientific?: boolean;
 }
-export declare function isValidFloat(v: unknown, { floatPrecision, allowNonFiniteNumbers, floatScientific }?: FloatOptions): boolean;
-export declare function toValidFloat(v: unknown, { floatPrecision, allowNonFiniteNumbers, floatScientific }?: FloatOptions): number | null;
+export declare function isValidFloat(v: unknown, { floatPrecision, allowNonFiniteNumbers }?: FloatOptions): v is number;
+export declare function toValidFloat(v: unknown, { floatPrecision, allowNonFiniteNumbers, floatScientific, strictNumericString }?: FloatOptions): number | null;
 export declare const INT_RANGES: {
     readonly Int8: {
         readonly min: -128;
@@ -63,7 +65,6 @@ export interface IntOptions {
     range?: IntRange;
     coerce?: IntCoerceType;
 }
-export declare function isValidInt(v: unknown, range?: IntRange): v is number;
 export declare function toValidInt(v: unknown, { range, coerce }?: IntOptions): number | null;
 export declare const BIGINT_RANGES: {
     readonly Int64: {
@@ -84,15 +85,14 @@ export interface BigIntOptions {
     range?: BigIntRange;
     truncate?: boolean;
 }
-export declare function isValidBigInt(v: unknown, range?: BigIntRange): v is bigint;
 export declare function toValidBigInt(v: unknown, { range, truncate }?: BigIntOptions): bigint | null;
 export interface DecimalOptions {
     precision?: number;
     scale?: number;
 }
-export declare function isValidDecimal(v: unknown, { precision, scale }?: DecimalOptions): boolean;
+export declare function roundToScale(v: number, scale: number): number;
 export declare function toValidDecimal(v: unknown, { precision, scale }?: DecimalOptions): number | null;
-export declare function clamp<T extends number | bigint>(val: T, { min, max, safe }?: {
+export declare function clamp<T extends number | bigint>(val: T, options?: {
     min?: T | null;
     max?: T | null;
     safe?: boolean;
@@ -102,18 +102,3 @@ export declare function clamp<T extends number | bigint>(val: T, { min, max, saf
  * Returns a function that generates a pseudo-random float in the range [0, 1).
  */
 export declare function mulberry32(seed: number): () => number;
-/**
- * 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.
- */
-export declare function computeQuantile(values: ArrayLike<any>, q: number): number | null;
-/**
- * Computes the mode(s) of an array, filtering out null/undefined values.
- * Returns an array of the most frequent values, sorted, or null if empty/no mode.
- */
-export declare function computeMode(values: ArrayLike<any>): any[] | null;

package/dist/utils/object.d.ts

@@ -0,0 +1,26 @@
+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 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;
+export declare function isValidDateObj(v: unknown): v is Date;
+export declare function isRegExp(v: unknown): v is RegExp;
+export declare function isSet(v: unknown): v is Set<unknown>;
+export declare function isMap(v: unknown): v is Map<unknown, unknown>;
+export declare function isURLSearchParams(v: unknown): v is URLSearchParams;
+export declare function isError(v: unknown): v is Error;
+export declare function isStringObj(v: unknown): v is String;
+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 unboxPrimitiveObj(v: unknown): unknown;

package/dist/utils/string.d.ts

@@ -1,3 +1,5 @@
+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 = {
     /**
@@ -46,11 +48,7 @@ export type StripCharsOptions = {
         caseInsensitive?: boolean;
     };
 };
-/**
- * Strips characters from the start, end, or both ends of a string.
- */
-export declare function stripChars(str: string | null | undefined, characters?: string | RegExp | null, { mode, returnStringOnNull, maxScanStart, maxScanEnd, maxMatchesStart, maxMatchesEnd, trimFirst, stringOptions: { literal, caseInsensitive } }?: StripCharsOptions): string | null;
-export declare function isBlankString(v: unknown): v is 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "df-script",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "A zero-dependency, high-performance, expression-based DataFrame library for TypeScript/JavaScript.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,7 +10,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc && esbuild src/index.ts --bundle --minify --outfile=dist/index.js --platform=node",
+    "build": "tsc --emitDeclarationOnly && esbuild src/index.ts --bundle --minify --outfile=dist/index.js --platform=node",
     "test": "tsx _tests/run_all_project_tests.ts",
     "prepublishOnly": "npm run build"
   },

package/dist/api.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.$df = void 0;
-const dataframe_1 = require("./dataframe");
-const columnExpressions_1 = require("./columnExpressions");
-const datatypes_1 = require("./datatypes");
-const functions_1 = require("./functions");
-function data(data, schema) {
-    return new dataframe_1.DataFrame(data, schema);
-}
-exports.$df = {
-    data,
-    col: (name) => new columnExpressions_1.ColumnExpr(name),
-    all: columnExpressions_1.all,
-    exclude: columnExpressions_1.exclude,
-    coalesce: columnExpressions_1.coalesce,
-    concat: functions_1.concat,
-    read_json: functions_1.read_json,
-    read_csv: functions_1.read_csv,
-    lit: columnExpressions_1.lit,
-    when: columnExpressions_1.when,
-    implode: columnExpressions_1.implode,
-    seq_range: columnExpressions_1.seq_range,
-    element: columnExpressions_1.element,
-    DataType: datatypes_1.DataTypeRegistry
-};