numpy-ts 0.12.0 → 0.13.0

package/dist/types/index.d.ts

@@ -1,49 +1,163 @@
 /**
  * numpy-ts - Complete NumPy implementation for TypeScript and JavaScript
  *
+ * This is the main entry point with full method chaining support.
+ * Functions return NDArray which has methods like .add(), .reshape(), etc.
+ *
+ * @example
+ * ```typescript
+ * import { array, zeros } from 'numpy-ts';
+ *
+ * const a = array([1, 2, 3, 4]);
+ * const b = a.add(10).reshape([2, 2]).T;  // Method chaining works!
+ * ```
+ *
+ * For tree-shakeable imports (smaller bundles, no method chaining), use:
+ * ```typescript
+ * import { array, add, reshape } from 'numpy-ts/core';
+ * ```
+ *
  * @module numpy-ts
  */
-export { Complex, type ComplexInput } from './core/complex';
-export { NDArray, zeros, ones, array, arange, linspace, logspace, geomspace, eye, empty, full, identity, asarray, copy, zeros_like, ones_like, empty_like, full_like, asanyarray, asarray_chkfinite, ascontiguousarray, asfortranarray, require, diag, diagflat, frombuffer, fromfile, fromfunction, fromiter, fromstring, meshgrid, tri, tril, triu, vander, sqrt, power, pow, // alias for power
-exp, exp2, expm1, log, log2, log10, log1p, logaddexp, logaddexp2, absolute, abs, // alias for absolute
-negative, sign, mod, divide, true_divide, // alias for divide
-floor_divide, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, float_power, fmod, frexp, gcd, lcm, ldexp, modf, clip, maximum, minimum, fmax, fmin, nan_to_num, interp, unwrap, sinc, i0, dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, vdot, vecdot, matrix_transpose, permute_dims, matvec, vecmat, linalg, sin, cos, tan, arcsin, asin, // alias for arcsin
-arccos, acos, // alias for arccos
-arctan, atan, // alias for arctan
-arctan2, atan2, // alias for arctan2
-hypot, degrees, radians, deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, asinh, // alias for arcsinh
-arccosh, acosh, // alias for arccosh
-arctanh, atanh, // alias for arctanh
-swapaxes, moveaxis, concatenate, stack, vstack, hstack, dstack, concat, unstack, block, split, array_split, vsplit, hsplit, tile, repeat, ravel, flatten, fill, item, tolist, tobytes, byteswap, view, tofile, reshape, squeeze, expand_dims, flip, fliplr, flipud, rot90, roll, rollaxis, atleast_1d, atleast_2d, atleast_3d, dsplit, column_stack, row_stack, resize, append, delete_ as delete, insert, pad, broadcast_to, broadcast_arrays, broadcast_shapes, take, put, iindex, bindex, copyto, choose, array_equal, array_equiv, take_along_axis, put_along_axis, putmask, compress, select, place, fill_diagonal, diag_indices, diag_indices_from, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, indices, ix_, ravel_multi_index, unravel_index, cumsum, cumulative_sum, // alias for cumsum
-cumprod, cumulative_prod, // alias for cumprod
-max, amax, // alias for max
-min, amin, // alias for min
-ptp, median, percentile, quantile, average, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, nanquantile, nanpercentile, bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert, left_shift, right_shift, packbits, unpackbits, bitwise_count, bitwise_invert, bitwise_left_shift, bitwise_right_shift, logical_and, logical_or, logical_not, logical_xor, isfinite, isinf, isnan, isnat, iscomplex, iscomplexobj, isreal, isrealobj, real, imag, conj, conjugate, angle, isneginf, isposinf, isfortran, real_if_close, isscalar, iterable, isdtype, promote_types, copysign, signbit, nextafter, spacing, sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, argwhere, flatnonzero, where, searchsorted, extract, count_nonzero, around, round_, // alias for around
-ceil, fix, floor, rint, round, trunc, unique, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, trim_zeros, unique_all, unique_counts, unique_inverse, unique_values, diff, ediff1d, gradient, cross, bincount, digitize, histogram, histogram2d, histogramdd, correlate, convolve, cov, corrcoef, histogram_bin_edges, trapezoid, apply_along_axis, apply_over_axes, may_share_memory, shares_memory, ndim, shape, size, geterr, seterr, can_cast, common_type, result_type, min_scalar_type, issubdtype, typename, mintypecode, poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub, polyval, roots, } from './core/ndarray';
-export { parseNpy, serializeNpy, parseNpyHeader, parseNpyData, UnsupportedDTypeError, InvalidNpyError, SUPPORTED_DTYPES, DTYPE_TO_DESCR, type NpyHeader, type NpyMetadata, type NpyVersion, parseNpz, parseNpzSync, loadNpz, loadNpzSync, serializeNpz, serializeNpzSync, type NpzParseOptions, type NpzParseResult, type NpzSerializeOptions, } from './io';
-import * as randomOps from './ops/random';
-import { ArrayStorage } from './core/storage';
-import { NDArray as NDArrayClass } from './core/ndarray';
-import { DType } from './core/dtype';
+export { Complex, type ComplexInput } from './common/complex';
+export { NDArray } from './full';
+export { NDArrayCore } from './common/ndarray-core';
+export { zeros, ones, empty, full, array, arange, linspace, logspace, geomspace, eye, identity, asarray, zeros_like, ones_like, empty_like, full_like, copy, asanyarray, asarray_chkfinite, ascontiguousarray, asfortranarray, require, diag, diagflat, frombuffer, fromfile, fromfunction, fromiter, fromstring, meshgrid, tri, tril, triu, vander, } from './full';
+export { add, subtract, multiply, divide, true_divide, floor_divide, mod, sqrt, power, exp, exp2, expm1, log, log2, log10, log1p, logaddexp, logaddexp2, absolute, negative, sign, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, float_power, fmod, frexp, gcd, lcm, ldexp, modf, clip, maximum, minimum, fmax, fmin, nan_to_num, interp, unwrap, sinc, i0, } from './full';
+export { power as pow, absolute as abs } from './full';
+export { sin, cos, tan, arcsin, arccos, arctan, arctan2, hypot, degrees, radians, deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, arccosh, arctanh, } from './full';
+export { arcsin as asin, arccos as acos, arctan as atan, arctan2 as atan2, arcsinh as asinh, arccosh as acosh, arctanh as atanh, } from './full';
+export { dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, einsum_path, vdot, vecdot, matrix_transpose, permute_dims, matvec, vecmat, cross, matmul, linalg, } from './full';
+export { reshape, flatten, ravel, squeeze, expand_dims, swapaxes, moveaxis, rollaxis, concatenate, stack, vstack, hstack, dstack, column_stack, row_stack, block, split, array_split, vsplit, hsplit, dsplit, unstack, tile, repeat, flip, fliplr, flipud, rot90, roll, resize, atleast_1d, atleast_2d, atleast_3d, append, delete_, delete_ as delete, insert, pad, } from './full';
+export { concatenate as concat } from './full';
+export { sum, mean, prod, amax, amin, ptp, argmin, argmax, std, variance, var_ as var, median, percentile, quantile, average, all, any, cumsum, cumprod, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, nanquantile, nanpercentile, } from './full';
+export { amax as max, amin as min, cumsum as cumulative_sum, cumprod as cumulative_prod, } from './full';
+export { logical_and, logical_or, logical_not, logical_xor, isfinite, isinf, isnan, isnat, isneginf, isposinf, iscomplex, iscomplexobj, isreal, isrealobj, real_if_close, isfortran, isscalar, iterable, isdtype, promote_types, copysign, signbit, nextafter, spacing, greater, greater_equal, less, less_equal, equal, not_equal, isclose, allclose, } from './full';
+export { sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, argwhere, flatnonzero, where, searchsorted, extract, count_nonzero, } from './full';
+export { bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert, left_shift, right_shift, packbits, unpackbits, bitwise_count, } from './full';
+export { bitwise_not as bitwise_invert, left_shift as bitwise_left_shift, right_shift as bitwise_right_shift, } from './full';
+export { around, round_, ceil, fix, floor, rint, trunc } from './full';
+export { around as round } from './full';
+export { unique, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, trim_zeros, unique_all, unique_counts, unique_inverse, unique_values, } from './full';
+export { bincount, digitize, histogram, histogram2d, histogramdd, correlate, convolve, cov, corrcoef, histogram_bin_edges, trapezoid, } from './full';
+export { diff, ediff1d, gradient } from './full';
+export { real, imag, conj, angle } from './full';
+export { conj as conjugate } from './full';
+export { broadcast_to, broadcast_arrays, broadcast_shapes, take, put, iindex, bindex, copyto, choose, array_equal, array_equiv, take_along_axis, put_along_axis, putmask, compress, select, place, fill_diagonal, diag_indices, diag_indices_from, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, indices, ix_, ravel_multi_index, unravel_index, fill, item, tolist, tobytes, byteswap, view, tofile, } from './full';
+export { apply_along_axis, apply_over_axes, may_share_memory, shares_memory, ndim, shape, size, geterr, seterr, } from './full';
+export { array2string, array_repr, array_str, base_repr, binary_repr, format_float_positional, format_float_scientific, get_printoptions, set_printoptions, printoptions, } from './full';
+export { can_cast, common_type, result_type, min_scalar_type, issubdtype, typename, mintypecode, } from './full';
+export { poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub, polyval, roots, } from './full';
+export { UnsupportedDTypeError, InvalidNpyError, SUPPORTED_DTYPES, DTYPE_TO_DESCR, type NpyHeader, type NpyMetadata, type NpyVersion, } from './io/npy/format';
+export type { NpzParseOptions } from './io/npz/parser';
+export type { NpzSerializeOptions } from './io/npz/serializer';
+export type { ParseTxtOptions } from './io/txt/parser';
+export type { SerializeTxtOptions } from './io/txt/serializer';
+export { serializeNpy } from './io/npy/serializer';
+export { serializeNpz, serializeNpzSync } from './io/npz/serializer';
+export { serializeTxt } from './io/txt/serializer';
+import { parseNpyHeader as parseNpyHeaderCore } from './io/npy/parser';
+import type { NpyMetadata as NpyMetadataType } from './io/npy/format';
+import type { NpzParseOptions as NpzParseOptionsType } from './io/npz/parser';
+import type { ParseTxtOptions as ParseTxtOptionsType } from './io/txt/parser';
+import type { DType as DTypeIO } from './common/dtype';
+export type NpzArraysInput = NDArrayClass[] | Map<string, NDArrayClass> | Record<string, NDArrayClass>;
+export interface NpzParseResult {
+    arrays: Map<string, NDArrayClass>;
+    skipped: string[];
+    errors: Map<string, string>;
+}
+export declare function parseNpy(buffer: ArrayBuffer | Uint8Array): NDArrayClass;
+export declare const parseNpyHeader: typeof parseNpyHeaderCore;
+export declare function parseNpyData(bytes: Uint8Array, metadata: NpyMetadataType): NDArrayClass;
+export declare function parseNpz(buffer: ArrayBuffer | Uint8Array, options?: NpzParseOptionsType): Promise<NpzParseResult>;
+export declare function parseNpzSync(buffer: ArrayBuffer | Uint8Array, options?: NpzParseOptionsType): NpzParseResult;
+export declare function loadNpz(buffer: ArrayBuffer | Uint8Array, options?: NpzParseOptionsType): Promise<Record<string, NDArrayClass>>;
+export declare function loadNpzSync(buffer: ArrayBuffer | Uint8Array, options?: NpzParseOptionsType): Record<string, NDArrayClass>;
+export declare function parseTxt(text: string, options?: ParseTxtOptionsType): NDArrayClass;
+export declare function genfromtxt(text: string, options?: ParseTxtOptionsType): NDArrayClass;
+export declare function fromregex(text: string, regexp: RegExp | string, dtype?: DTypeIO): NDArrayClass;
+import * as randomOps from './common/ops/random';
+import { ArrayStorage } from './common/storage';
+import { NDArray as NDArrayClass } from './full';
+import { DType } from './common/dtype';
 export declare const random: {
     seed: typeof randomOps.seed;
+    get_state: typeof randomOps.get_state;
+    set_state: typeof randomOps.set_state;
+    get_bit_generator: typeof randomOps.get_bit_generator;
+    set_bit_generator: typeof randomOps.set_bit_generator;
+    default_rng: typeof randomOps.default_rng;
+    Generator: typeof randomOps.Generator;
     random: (size?: number | number[]) => number | ArrayStorage | NDArrayClass;
     rand: (...shape: number[]) => number | ArrayStorage | NDArrayClass;
     randn: (...shape: number[]) => number | ArrayStorage | NDArrayClass;
     randint: (low: number, high?: number | null, size?: number | number[], dtype?: DType) => number | ArrayStorage | NDArrayClass;
+    random_sample: (size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    ranf: (size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    sample: (size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    random_integers: (low: number, high?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    bytes: typeof randomOps.bytes;
     uniform: (low?: number, high?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
     normal: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
     standard_normal: (size?: number | number[]) => number | ArrayStorage | NDArrayClass;
     exponential: (scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    standard_exponential: (size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    gamma: (shape: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    standard_gamma: (shape: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    beta: (a: number, b: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    chisquare: (df: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    noncentral_chisquare: (df: number, nonc: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    f: (dfnum: number, dfden: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    noncentral_f: (dfnum: number, dfden: number, nonc: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    standard_cauchy: (size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    standard_t: (df: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    laplace: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    logistic: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    lognormal: (mean?: number, sigma?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    gumbel: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    pareto: (a: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    power: (a: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    rayleigh: (scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    triangular: (left: number, mode: number, right: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    wald: (mean: number, scale: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    weibull: (a: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
     poisson: (lam?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
     binomial: (n: number, p: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    geometric: (p: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    hypergeometric: (ngood: number, nbad: number, nsample: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    logseries: (p: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    negative_binomial: (n: number, p: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    zipf: (a: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    multinomial: (n: number, pvals: number[] | ArrayStorage, size?: number | number[]) => ArrayStorage | NDArrayClass;
+    multivariate_normal: (mean: number[] | ArrayStorage, cov: number[][] | ArrayStorage, size?: number | number[], check_valid?: "warn" | "raise" | "ignore", tol?: number) => ArrayStorage | NDArrayClass;
+    dirichlet: (alpha: number[] | ArrayStorage, size?: number | number[]) => ArrayStorage | NDArrayClass;
+    vonmises: (mu: number, kappa: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
     choice: (a: number | ArrayStorage, size?: number | number[], replace?: boolean, p?: ArrayStorage | number[]) => number | ArrayStorage | NDArrayClass;
     permutation: (x: number | ArrayStorage) => ArrayStorage | NDArrayClass;
     shuffle: typeof randomOps.shuffle;
-    get_state: typeof randomOps.get_state;
-    set_state: typeof randomOps.set_state;
-    default_rng: typeof randomOps.default_rng;
-    Generator: typeof randomOps.Generator;
+};
+import { NDArrayCore } from './common/ndarray-core';
+type ArrayInput = NDArrayClass | NDArrayCore | ArrayStorage;
+export declare const fft: {
+    fft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayClass;
+    ifft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayClass;
+    fft2: (a: ArrayInput, s?: [number, number], axes?: [number, number], norm?: "backward" | "ortho" | "forward") => NDArrayClass;
+    ifft2: (a: ArrayInput, s?: [number, number], axes?: [number, number], norm?: "backward" | "ortho" | "forward") => NDArrayClass;
+    fftn: (a: ArrayInput, s?: number[], axes?: number[], norm?: "backward" | "ortho" | "forward") => NDArrayClass;
+    ifftn: (a: ArrayInput, s?: number[], axes?: number[], norm?: "backward" | "ortho" | "forward") => NDArrayClass;
+    rfft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayClass;
+    irfft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayClass;
+    rfft2: (a: ArrayInput, s?: [number, number], axes?: [number, number], norm?: "backward" | "ortho" | "forward") => NDArrayClass;
+    irfft2: (a: ArrayInput, s?: [number, number], axes?: [number, number], norm?: "backward" | "ortho" | "forward") => NDArrayClass;
+    rfftn: (a: ArrayInput, s?: number[], axes?: number[], norm?: "backward" | "ortho" | "forward") => NDArrayClass;
+    irfftn: (a: ArrayInput, s?: number[], axes?: number[], norm?: "backward" | "ortho" | "forward") => NDArrayClass;
+    hfft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayClass;
+    ihfft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayClass;
+    fftfreq: (n: number, d?: number) => NDArrayClass;
+    rfftfreq: (n: number, d?: number) => NDArrayClass;
+    fftshift: (a: ArrayInput, axes?: number | number[]) => NDArrayClass;
+    ifftshift: (a: ArrayInput, axes?: number | number[]) => NDArrayClass;
 };
 export declare const __version__: string;
 //# sourceMappingURL=index.d.ts.map

package/dist/types/io/npy/format.d.ts

@@ -4,7 +4,7 @@
  * NPY is NumPy's native binary format for storing arrays.
  * Spec: https://numpy.org/doc/stable/reference/generated/numpy.lib.format.html
  */
-import type { DType } from '../../core/dtype';
+import type { DType } from '../../common/dtype';
 /**
  * NPY magic number: \x93NUMPY (6 bytes)
  */

package/dist/types/io/npy/parser.d.ts

@@ -3,7 +3,7 @@
  *
  * Parses NumPy .npy files (both v1 and v2/v3 formats) into NDArray objects.
  */
-import { NDArray } from '../../core/ndarray';
+import { NDArrayCore } from '../../common/ndarray-core';
 import { type NpyMetadata } from './format';
 /**
  * Parse an NPY file from a Uint8Array or ArrayBuffer
@@ -13,7 +13,7 @@ import { type NpyMetadata } from './format';
  * @throws InvalidNpyError if the file format is invalid
  * @throws UnsupportedDTypeError if the dtype is not supported
  */
-export declare function parseNpy(buffer: ArrayBuffer | Uint8Array): NDArray;
+export declare function parseNpy(buffer: ArrayBuffer | Uint8Array): NDArrayCore;
 /**
  * Parse just the NPY header without reading the data
  *
@@ -24,5 +24,5 @@ export declare function parseNpyHeader(bytes: Uint8Array): NpyMetadata;
 /**
  * Parse the data section of an NPY file given parsed metadata
  */
-export declare function parseNpyData(bytes: Uint8Array, metadata: NpyMetadata): NDArray;
+export declare function parseNpyData(bytes: Uint8Array, metadata: NpyMetadata): NDArrayCore;
 //# sourceMappingURL=parser.d.ts.map

package/dist/types/io/npy/serializer.d.ts

@@ -6,12 +6,12 @@
  *
  * v3.0 is identical to v2.0 but allows UTF-8 in dtype descriptions.
  */
-import { NDArray } from '../../core/ndarray';
+import { NDArrayCore } from '../../common/ndarray-core';
 /**
  * Serialize an NDArray to NPY format (v3.0)
  *
  * @param arr - The NDArray to serialize
  * @returns A Uint8Array containing the NPY file data
  */
-export declare function serializeNpy(arr: NDArray): Uint8Array;
+export declare function serializeNpy(arr: NDArrayCore): Uint8Array;
 //# sourceMappingURL=serializer.d.ts.map

package/dist/types/io/npz/parser.d.ts

@@ -3,7 +3,7 @@
  *
  * NPZ is a ZIP archive containing multiple .npy files.
  */
-import { NDArray } from '../../core/ndarray';
+import { NDArrayCore } from '../../common/ndarray-core';
 /**
  * Options for parsing NPZ files
  */
@@ -20,7 +20,7 @@ export interface NpzParseOptions {
  */
 export interface NpzParseResult {
     /** Successfully parsed arrays */
-    arrays: Map<string, NDArray>;
+    arrays: Map<string, NDArrayCore>;
     /** Names of arrays that were skipped due to unsupported dtypes (only when force=true) */
     skipped: string[];
     /** Error messages for skipped arrays */
@@ -49,9 +49,9 @@ export declare function parseNpzSync(buffer: ArrayBuffer | Uint8Array, options?:
  * @param options - Parse options
  * @returns Promise resolving to object with array names as keys
  */
-export declare function loadNpz(buffer: ArrayBuffer | Uint8Array, options?: NpzParseOptions): Promise<Record<string, NDArray>>;
+export declare function loadNpz(buffer: ArrayBuffer | Uint8Array, options?: NpzParseOptions): Promise<Record<string, NDArrayCore>>;
 /**
  * Synchronous version of loadNpz
  */
-export declare function loadNpzSync(buffer: ArrayBuffer | Uint8Array, options?: NpzParseOptions): Record<string, NDArray>;
+export declare function loadNpzSync(buffer: ArrayBuffer | Uint8Array, options?: NpzParseOptions): Record<string, NDArrayCore>;
 //# sourceMappingURL=parser.d.ts.map

package/dist/types/io/npz/serializer.d.ts

@@ -3,14 +3,14 @@
  *
  * Serializes multiple NDArrays to NPZ format (ZIP archive of .npy files).
  */
-import { NDArray } from '../../core/ndarray';
+import { NDArrayCore } from '../../common/ndarray-core';
 /**
  * Input type for arrays - supports:
- * - Array of NDArrays (positional, named arr_0, arr_1, etc.)
- * - Map of names to NDArrays
+ * - Array of NDArrayCores (positional, named arr_0, arr_1, etc.)
+ * - Map of names to NDArrayCores
  * - Object with names as keys
  */
-export type NpzArraysInput = NDArray[] | Map<string, NDArray> | Record<string, NDArray>;
+export type NpzArraysInput = NDArrayCore[] | Map<string, NDArrayCore> | Record<string, NDArrayCore>;
 /**
  * Options for serializing NPZ files
  */
@@ -25,8 +25,8 @@ export interface NpzSerializeOptions {
  * Serialize multiple arrays to NPZ format
  *
  * @param arrays - Arrays to save. Can be:
- *   - An array of NDArrays (named arr_0, arr_1, etc. like np.savez positional args)
- *   - A Map of names to NDArrays
+ *   - An array of NDArrayCores (named arr_0, arr_1, etc. like np.savez positional args)
+ *   - A Map of names to NDArrayCores
  *   - An object with names as keys (like np.savez keyword args)
  * @param options - Serialization options
  * @returns Promise resolving to NPZ file as Uint8Array

package/dist/types/io/txt/parser.d.ts

@@ -4,8 +4,8 @@
  * Provides NumPy-compatible loadtxt/genfromtxt functionality.
  * These functions work with strings and are environment-agnostic.
  */
-import { NDArray } from '../../core/ndarray';
-import type { DType } from '../../core/dtype';
+import { NDArrayCore } from '../../common/ndarray-core';
+import type { DType } from '../../common/dtype';
 /**
  * Options for parsing text data
  */
@@ -76,7 +76,7 @@ export interface ParseTxtOptions {
  * // arr.shape = [3, 3]
  * ```
  */
-export declare function parseTxt(text: string, options?: ParseTxtOptions): NDArray;
+export declare function parseTxt(text: string, options?: ParseTxtOptions): NDArrayCore;
 /**
  * Parse text data into an NDArray with more flexible handling.
  *
@@ -87,7 +87,7 @@ export declare function parseTxt(text: string, options?: ParseTxtOptions): NDArr
  * @param options - Parsing options
  * @returns NDArray with the parsed data
  */
-export declare function genfromtxt(text: string, options?: ParseTxtOptions): NDArray;
+export declare function genfromtxt(text: string, options?: ParseTxtOptions): NDArrayCore;
 /**
  * Parse text data using a regular expression.
  *
@@ -105,5 +105,5 @@ export declare function genfromtxt(text: string, options?: ParseTxtOptions): NDA
  * // arr = [[1.0, 2.0], [3.0, 4.0]]
  * ```
  */
-export declare function fromregex(text: string, regexp: RegExp | string, dtype?: DType): NDArray;
+export declare function fromregex(text: string, regexp: RegExp | string, dtype?: DType): NDArrayCore;
 //# sourceMappingURL=parser.d.ts.map

package/dist/types/io/txt/serializer.d.ts

@@ -4,7 +4,7 @@
  * Provides NumPy-compatible savetxt functionality.
  * These functions work with strings and are environment-agnostic.
  */
-import { NDArray } from '../../core/ndarray';
+import { NDArrayCore } from '../../common/ndarray-core';
 /**
  * Options for serializing array to text
  */
@@ -63,5 +63,5 @@ export interface SerializeTxtOptions {
  * // "1.000000000000000000e+00,2.000000000000000000e+00,3.000000000000000000e+00\n4.000000000000000000e+00,5.000000000000000000e+00,6.000000000000000000e+00\n"
  * ```
  */
-export declare function serializeTxt(arr: NDArray, options?: SerializeTxtOptions): string;
+export declare function serializeTxt(arr: NDArrayCore, options?: SerializeTxtOptions): string;
 //# sourceMappingURL=serializer.d.ts.map

package/dist/types/node.d.ts

@@ -12,13 +12,17 @@
  *
  * For browser usage, use the main entry point (no file I/O).
  */
-import { NDArray } from './core/ndarray';
-import { type NpzParseOptions, type NpzParseResult } from './io/npz/parser';
+import { NDArray } from './full/ndarray';
+import type { NpzParseOptions } from './io/npz/parser';
 import { type NpzSerializeOptions, type NpzArraysInput } from './io/npz/serializer';
 import { type ParseTxtOptions, type SerializeTxtOptions } from './io/txt';
-import type { DType } from './core/dtype';
+import type { DType } from './common/dtype';
+interface NpzParseResultNDArray {
+    arrays: Map<string, NDArray>;
+    skipped: string[];
+    errors: Map<string, string>;
+}
 export * from './index';
-export * from './io';
 /**
  * Options for loading NPY/NPZ files
  */
@@ -69,7 +73,7 @@ export declare function saveNpySync(path: string, arr: NDArray): void;
  * @param options - Load options
  * @returns Object with array names as keys
  */
-export declare function loadNpzFile(path: string, options?: NpzParseOptions): Promise<NpzParseResult>;
+export declare function loadNpzFile(path: string, options?: NpzParseOptions): Promise<NpzParseResultNDArray>;
 /**
  * Synchronously load arrays from a .npz file
  *
@@ -79,7 +83,7 @@ export declare function loadNpzFile(path: string, options?: NpzParseOptions): Pr
  * @param options - Load options
  * @returns Object with array names as keys
  */
-export declare function loadNpzFileSync(path: string, options?: NpzParseOptions): NpzParseResult;
+export declare function loadNpzFileSync(path: string, options?: NpzParseOptions): NpzParseResultNDArray;
 /**
  * Save arrays to a .npz file
  *
@@ -107,7 +111,7 @@ export declare function saveNpzSync(path: string, arrays: NpzArraysInput): void;
  * @param options - Load options
  * @returns NDArray for .npy files, or NpzParseResult for .npz files
  */
-export declare function load(path: string, options?: LoadOptions): Promise<NDArray | NpzParseResult>;
+export declare function load(path: string, options?: LoadOptions): Promise<NDArray | NpzParseResultNDArray>;
 /**
  * Synchronously load an array or arrays from a .npy or .npz file
  *
@@ -115,7 +119,7 @@ export declare function load(path: string, options?: LoadOptions): Promise<NDArr
  * @param options - Load options
  * @returns NDArray for .npy files, or NpzParseResult for .npz files
  */
-export declare function loadSync(path: string, options?: LoadOptions): NDArray | NpzParseResult;
+export declare function loadSync(path: string, options?: LoadOptions): NDArray | NpzParseResultNDArray;
 /**
  * Save an array to a .npy file
  *

package/package.json

@@ -1,18 +1,20 @@
 {
   "name": "numpy-ts",
-  "version": "0.12.0",
-  "description": "Complete NumPy implementation for TypeScript and JavaScript (81% API coverage)",
+  "version": "0.13.0",
+  "description": "Complete NumPy implementation for TypeScript and JavaScript (94% API coverage)",
   "main": "dist/numpy-ts.node.cjs",
   "browser": "dist/numpy-ts.browser.js",
-  "module": "dist/numpy-ts.esm.js",
+  "module": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",
   "type": "module",
+  "sideEffects": false,
   "files": [
     "dist/**/*.js",
     "dist/**/*.cjs",
     "dist/**/*.mjs",
     "dist/**/*.cjs.map",
     "dist/**/*.mjs.map",
+    "dist/esm/**/*.js",
     "dist/types/**/*.d.ts",
     "README.md",
     "LICENSE"
@@ -22,7 +24,8 @@
       "types": "./dist/types/index.d.ts",
       "node": "./dist/numpy-ts.node.cjs",
       "browser": "./dist/numpy-ts.browser.js",
-      "default": "./dist/numpy-ts.esm.js"
+      "import": "./dist/esm/index.js",
+      "default": "./dist/esm/index.js"
     },
     "./node": {
       "types": "./dist/types/node.d.ts",
@@ -30,37 +33,27 @@
       "require": "./dist/numpy-ts.node-io.cjs",
       "default": "./dist/numpy-ts.node-io.cjs"
     },
-    "./io": {
-      "types": "./dist/types/io/index.d.ts",
-      "node": "./dist/numpy-ts.node.cjs",
-      "browser": "./dist/numpy-ts.browser.js",
-      "default": "./dist/numpy-ts.esm.js"
-    },
-    "./browser": {
-      "types": "./dist/types/index.d.ts",
-      "default": "./dist/numpy-ts.browser.js"
+    "./core": {
+      "types": "./dist/types/core.d.ts",
+      "import": "./dist/esm/core.js",
+      "default": "./dist/esm/core.js"
     }
   },
   "scripts": {
-    "dev": "esbuild src/index.ts --bundle --sourcemap --watch --outfile=dist/numpy-ts.dev.js",
-    "build": "npm run build:clean && tsx build.ts && npm run build:types",
+    "generate": "tsx scripts/generate-full.ts && prettier --write src/full/index.ts src/full/ndarray.ts",
+    "build": "npm run build:clean && npm run generate && tsx build.ts && npm run build:types",
     "build:clean": "rm -rf dist",
     "build:types": "tsc --emitDeclarationOnly --outDir dist/types",
-    "test": "vitest run --project=unit --project=validation",
-    "test:quick": "vitest run --project=quick",
+    "test": "npm run build && vitest run",
     "test:unit": "vitest run --project=unit",
     "test:validation": "vitest run --project=validation",
     "test:bundles": "npm run build && vitest run --project=bundle-node --project=bundle-esm --project=bundle-browser",
-    "test:ci": "npm run lint && npm run typecheck && npm test && npm run test:bundles",
-    "test:summary": "vitest run --reporter=tap | grep -E 'not ok|# tests'",
-    "test:watch": "vitest watch",
-    "test:coverage": "vitest run --project=unit --coverage",
-    "test:coverage:view": "vitest run --project=unit --coverage && open coverage/index.html",
-    "test:coverage:validation": "vitest run --project=validation-quick --coverage",
-    "test:coverage:validation:view": "vitest run --project=validation-quick --coverage && open coverage/index.html",
-    "test:coverage:all": "vitest run --coverage",
-    "lint": "eslint src tests --ext .ts",
-    "lint:fix": "eslint src tests --ext .ts --fix",
+    "test:tree-shaking": "vitest run --project=tree-shaking",
+    "test:ci": "npm run lint && npm run typecheck && npm test",
+    "test:coverage": "vitest run --project=unit --project=validation --coverage",
+    "test:coverage:view": "open coverage/index.html || xdg-open coverage/index.html",
+    "lint": "eslint --cache src tests",
+    "lint:fix": "eslint --cache src tests --fix",
     "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
     "format:check": "prettier --check \"src/**/*.ts\" \"tests/**/*.ts\"",
     "typecheck": "tsc --noEmit",
@@ -97,7 +90,11 @@
   },
   "homepage": "https://github.com/dupontcyborg/numpy-ts",
   "devDependencies": {
-    "@types/node": "^24.9.1",
+    "@rollup/plugin-alias": "^6.0.0",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/node": "^25.0.3",
     "@typescript-eslint/eslint-plugin": "^8.46.2",
     "@typescript-eslint/parser": "^8.46.2",
     "@vitest/browser": "^4.0.3",
@@ -113,9 +110,13 @@
     "lint-staged": "^16.2.6",
     "playwright": "^1.56.1",
     "prettier": "^3.1.1",
+    "rollup": "^4.40.0",
+    "ts-loader": "^9.5.2",
+    "ts-morph": "^27.0.2",
     "tsx": "^4.20.6",
     "typescript": "^5.3.3",
-    "vitest": "^4.0.3"
+    "vitest": "^4.0.3",
+    "webpack": "^5.99.9"
   },
   "engines": {
     "node": ">=20.1.0"