numpy-ts 1.2.0 → 1.3.0

package/dist/esm/common/wasm/min.js

@@ -1 +1 @@
-import{min_f64 as D,min_f32 as c,min_i64 as w,min_i32 as M,min_i16 as F,min_i8 as R,min_scalar_f64 as h,min_scalar_f32 as p,min_scalar_i64 as k,min_scalar_i32 as I,min_scalar_i16 as N,min_scalar_i8 as L,min_u64 as O,min_u32 as z,min_u16 as U,min_u8 as Y,min_scalar_u64 as v,min_scalar_u32 as x,min_scalar_u16 as H,min_scalar_u8 as K}from"./bins/min.wasm.js";import{ensureMemory as _,resetAllocator as A,copyIn as f,alloc as d,copyOut as T,f16ToF32Input as m,f32ToF16Output as E}from"./runtime.js";import{ArrayStorage as b}from"../storage.js";import{promoteDTypes as j}from"../dtype.js";import{wasmConfig as P}from"./config.js";const S=64,q={float64:D,float32:c,int64:w,uint64:O,int32:M,uint32:z,int16:F,uint16:U,int8:R,uint8:Y,float16:c},G={float64:h,float32:p,int64:k,uint64:v,int32:I,uint32:x,int16:N,uint16:H,int8:L,uint8:K,float16:p},g={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function Z(r,a){if(!r.isCContiguous||!a.isCContiguous)return null;const t=r.size;if(t<S*P.thresholdMultiplier)return null;const n=j(r.dtype,a.dtype),e=q[n],o=g[n];if(!e||!o)return null;const i=o.BYTES_PER_ELEMENT;_(t*i*3),A();const u=n,s=f(m(r.data.subarray(r.offset,r.offset+t),r.dtype)),l=f(m(a.data.subarray(a.offset,a.offset+t),a.dtype)),y=d(t*i);e(s,l,y,t);const B=T(y,t,o),C=E(B,u);return b.fromData(C,Array.from(r.shape),u)}function $(r,a){if(!r.isCContiguous)return null;const t=r.size;if(t<S*P.thresholdMultiplier)return null;const n=r.dtype,e=G[n],o=g[n];if(!e||!o)return null;const i=o.BYTES_PER_ELEMENT;_(t*i*2),A();const u=f(m(r.data.subarray(r.offset,r.offset+t),n)),s=d(t*i);e(u,s,t,a);const l=T(s,t,o),y=E(l,n);return b.fromData(y,Array.from(r.shape),n)}export{Z as wasmMin,$ as wasmMinScalar};
+import{min_f64 as R,min_f32 as d,min_i64 as S,min_i32 as C,min_i16 as h,min_i8 as k,min_scalar_f64 as F,min_scalar_f32 as T,min_scalar_i64 as M,min_scalar_i32 as D,min_scalar_i16 as W,min_scalar_i8 as z,min_u64 as I,min_u32 as N,min_u16 as L,min_u8 as v,min_scalar_u64 as U,min_scalar_u32 as Y,min_scalar_u16 as x,min_scalar_u8 as H}from"./bins/min.wasm.js";import{wasmMalloc as b,resetScratchAllocator as g,resolveInputPtr as p,f16InputToScratchF32 as A,f32OutputToF16Region as E}from"./runtime.js";import{ArrayStorage as f}from"../storage.js";import{effectiveDType as w,promoteDTypes as K}from"../dtype.js";import{wasmConfig as m}from"./config.js";const P=64,O={float64:R,float32:d,int64:S,uint64:I,int32:C,uint32:N,int16:h,uint16:L,int8:k,uint8:v,float16:d},j={float64:F,float32:T,int64:M,uint64:U,int32:D,uint32:Y,int16:W,uint16:x,int8:z,uint8:H,float16:T},B={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function X(r,e){if(!r.isCContiguous||!e.isCContiguous||r.dtype!==e.dtype||r.size!==e.size)return null;const n=r.size;if(n<P*m.thresholdMultiplier)return null;const t=w(K(r.dtype,e.dtype)),s=O[t],o=B[t];if(!s||!o)return null;const i=o.BYTES_PER_ELEMENT,y=n*i,a=b(y);if(!a)return null;m.wasmCallCount++;const u=t;g();let l,c;if(t==="float16"?(l=A(r,n),c=A(e,n)):(l=p(r.data,r.isWasmBacked,r.wasmPtr,r.offset,n,i),c=p(e.data,e.isWasmBacked,e.wasmPtr,e.offset,n,i)),s(l,c,a.ptr,n),u==="float16"){const _=E(a,n);return a.release(),_?f.fromWasmRegion(Array.from(r.shape),u,_,n,Float16Array):null}return f.fromWasmRegion(Array.from(r.shape),t,a,n,o)}function Z(r,e){if(!r.isCContiguous)return null;const n=r.size;if(n<P*m.thresholdMultiplier)return null;const t=w(r.dtype),s=j[t],o=B[t];if(!s||!o)return null;const i=o.BYTES_PER_ELEMENT,y=n*i,a=b(y);if(!a)return null;m.wasmCallCount++,g();let u;if(t==="float16"?u=A(r,n):u=p(r.data,r.isWasmBacked,r.wasmPtr,r.offset,n,i),s(u,a.ptr,n,e),t==="float16"){const l=E(a,n);return a.release(),l?f.fromWasmRegion(Array.from(r.shape),t,l,n,Float16Array):null}return f.fromWasmRegion(Array.from(r.shape),t,a,n,o)}export{X as wasmMin,Z as wasmMinScalar};

package/dist/esm/common/wasm/mul.js

@@ -1 +1 @@
-import{mul_f64 as z,mul_f32 as U,mul_i64 as d,mul_i32 as E,mul_i16 as T,mul_i8 as P,mul_c128 as Y,mul_c64 as v,mul_scalar_f64 as H,mul_scalar_f32 as K,mul_scalar_i64 as B,mul_scalar_i32 as g,mul_scalar_i16 as S,mul_scalar_i8 as D,mul_scalar_c128 as j,mul_scalar_c64 as q}from"./bins/mul.wasm.js";import{ensureMemory as x,resetAllocator as C,copyIn as _,alloc as w,copyOut as M}from"./runtime.js";import{ArrayStorage as h}from"../storage.js";import{promoteDTypes as G}from"../dtype.js";import{wasmConfig as F}from"./config.js";const R=64,J={float64:z,float32:U,int64:d,uint64:d,int32:E,uint32:E,int16:T,uint16:T,int8:P,uint8:P,complex128:Y,complex64:v},Q={float64:H,float32:K,int64:B,uint64:B,int32:g,uint32:g,int16:S,uint16:S,int8:D,uint8:D,complex128:j,complex64:q},O={float64:Float64Array,float32:Float32Array,complex128:Float64Array,complex64:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array},k={complex128:2,complex64:2};function tt(t,e){if(!t.isCContiguous||!e.isCContiguous)return null;const a=t.size;if(a<R*F.thresholdMultiplier)return null;const n=G(t.dtype,e.dtype),l=J[n],o=O[n];if(!l||!o)return null;const s=k[n]??1,u=o.BYTES_PER_ELEMENT,r=a*s,p=r*u,i=r*u,c=r*u;x(p+i+c),C();const y=t.offset*s,m=e.offset*s,f=t.data.subarray(y,y+r),A=e.data.subarray(m,m+r),N=_(f),I=_(A),b=w(c);l(N,I,b,a);const L=M(b,r,o);return h.fromData(L,Array.from(t.shape),n)}function rt(t,e){if(!t.isCContiguous)return null;const a=t.size;if(a<R*F.thresholdMultiplier)return null;const n=t.dtype,l=Q[n],o=O[n];if(!l||!o)return null;const s=k[n]??1,u=o.BYTES_PER_ELEMENT,r=a*s,p=r*u,i=r*u;x(p+i),C();const c=t.offset*s,y=t.data.subarray(c,c+r),m=_(y),f=w(i);l(m,f,a,e);const A=M(f,r,o);return h.fromData(A,Array.from(t.shape),n)}export{tt as wasmMul,rt as wasmMulScalar};
+import{mul_f64 as h,mul_f32 as M,mul_i64 as p,mul_i32 as _,mul_i16 as A,mul_i8 as d,mul_c128 as k,mul_c64 as F,mul_scalar_f64 as D,mul_scalar_f32 as z,mul_scalar_i64 as E,mul_scalar_i32 as T,mul_scalar_i16 as P,mul_scalar_i8 as b,mul_scalar_c128 as N,mul_scalar_c64 as I}from"./bins/mul.wasm.js";import{wasmMalloc as g,resetScratchAllocator as w,resolveInputPtr as f}from"./runtime.js";import{ArrayStorage as B}from"../storage.js";import{promoteDTypes as L}from"../dtype.js";import{wasmConfig as m}from"./config.js";const S=64,W={float64:h,float32:M,int64:p,uint64:p,int32:_,uint32:_,int16:A,uint16:A,int8:d,uint8:d,complex128:k,complex64:F},U={float64:D,float32:z,int64:E,uint64:E,int32:T,uint32:T,int16:P,uint16:P,int8:b,uint8:b,complex128:N,complex64:I},C={float64:Float64Array,float32:Float32Array,complex128:Float64Array,complex64:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array},R={complex128:2,complex64:2};function j(r,t){if(!r.isCContiguous||!t.isCContiguous||r.dtype!==t.dtype||r.size!==t.size)return null;const o=r.size;if(o<S*m.thresholdMultiplier)return null;const n=L(r.dtype,t.dtype),i=W[n],a=C[n];if(!i||!a)return null;const u=R[n]??1,s=a.BYTES_PER_ELEMENT,e=o*u,c=e*s,l=g(c);if(!l)return null;m.wasmCallCount++,w();const y=f(r.data,r.isWasmBacked,r.wasmPtr,r.offset*u,e,s),x=f(t.data,t.isWasmBacked,t.wasmPtr,t.offset*u,e,s);return i(y,x,l.ptr,o),B.fromWasmRegion(Array.from(r.shape),n,l,e,a)}function q(r,t){if(!r.isCContiguous)return null;const o=r.size;if(o<S*m.thresholdMultiplier)return null;const n=r.dtype,i=U[n],a=C[n];if(!i||!a)return null;const u=R[n]??1,s=a.BYTES_PER_ELEMENT,e=o*u,c=e*s,l=g(c);if(!l)return null;m.wasmCallCount++,w();const y=f(r.data,r.isWasmBacked,r.wasmPtr,r.offset*u,e,s);return i(y,l.ptr,o,t),B.fromWasmRegion(Array.from(r.shape),n,l,e,a)}export{j as wasmMul,q as wasmMulScalar};

package/dist/esm/common/wasm/neg.js

@@ -1 +1 @@
-import{neg_f64 as E,neg_f32 as _,neg_i64 as c,neg_i32 as p,neg_i16 as m,neg_i8 as f,neg_c128 as b,neg_c64 as P}from"./bins/neg.wasm.js";import{ensureMemory as x,resetAllocator as B,copyIn as D,alloc as F,copyOut as S}from"./runtime.js";import{ArrayStorage as w}from"../storage.js";import{wasmConfig as C}from"./config.js";const R=64,U={float64:E,float32:_,int64:c,uint64:c,int32:p,uint32:p,int16:m,uint16:m,int8:f,uint8:f,complex128:b,complex64:P},h={float64:Float64Array,float32:Float32Array,complex128:Float64Array,complex64:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array},I={complex128:2,complex64:2};function L(r){if(!r.isCContiguous)return null;const e=r.size;if(e<R*C.thresholdMultiplier)return null;const t=r.dtype,a=U[t],o=h[t];if(!a||!o)return null;const y=I[t]??1,i=o.BYTES_PER_ELEMENT,n=e*y,A=n*i,s=n*i;x(A+s),B();const l=r.offset*y,g=r.data.subarray(l,l+n),d=D(g),u=F(s);a(d,u,e);const T=S(u,n,o);return w.fromData(T,Array.from(r.shape),t)}export{L as wasmNeg};
+import{neg_f64 as g,neg_f32 as d,neg_i64 as s,neg_i32 as u,neg_i16 as p,neg_i8 as c,neg_f16 as T,neg_c128 as _,neg_c64 as E}from"./bins/neg.wasm.js";import{wasmMalloc as b,resetScratchAllocator as w,resolveInputPtr as F}from"./runtime.js";import{ArrayStorage as P}from"../storage.js";import{wasmConfig as m}from"./config.js";const C=64,x={float64:g,float32:d,float16:T,int64:s,uint64:s,int32:u,uint32:u,int16:p,uint16:p,int8:c,uint8:c,complex128:_,complex64:E},B={float64:Float64Array,float32:Float32Array,float16:typeof Float16Array<"u"?Float16Array:Float32Array,complex128:Float64Array,complex64:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array},R={complex128:2,complex64:2};function D(r){if(!r.isCContiguous)return null;const n=r.size;if(n<C*m.thresholdMultiplier)return null;const t=r.dtype,i=x[t],e=B[t];if(!i||!e)return null;const y=R[t]??1,l=e.BYTES_PER_ELEMENT,o=n*y,f=o*l,a=b(f);if(!a)return null;m.wasmCallCount++,w();const A=F(r.data,r.isWasmBacked,r.wasmPtr,r.offset*y,o,l);return i(A,a.ptr,n),P.fromWasmRegion(Array.from(r.shape),t,a,o,e)}export{D as wasmNeg};

package/dist/esm/common/wasm/outer.js

@@ -1 +1 @@
-import{outer_f64 as x,outer_f32 as A,outer_c128 as C,outer_c64 as S,outer_i64 as T,outer_i32 as d,outer_i16 as b,outer_i8 as E}from"./bins/outer.wasm.js";import{ensureMemory as w,resetAllocator as M,copyIn as _,alloc as O,copyOut as I,f16ToF32Input as g,f32ToF16Output as R}from"./runtime.js";import{ArrayStorage as h}from"../storage.js";import{promoteDTypes as N}from"../dtype.js";import{wasmConfig as U}from"./config.js";const k=128,L={float64:x,float32:A,complex128:C,complex64:S,int64:T,uint64:T,int32:d,uint32:d,int16:b,uint16:b,int8:E,uint8:E,float16:A},z={float64:Float64Array,float32:Float32Array,complex128:Float64Array,complex64:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array,float16:Float32Array},H={complex128:2,complex64:2};function q(n,a){if(!n.isCContiguous||!a.isCContiguous)return null;const o=n.size,e=a.size;if(o+e<k*U.thresholdMultiplier)return null;const r=N(n.dtype,a.dtype),l=L[r],u=z[r];if(!l||!u)return null;const t=H[r]??1,y=u.BYTES_PER_ELEMENT,D=o*t*y,F=e*t*y,c=o*e*t*y;w(D+F+c),M();const p=r==="float16";let s=n.data.subarray(n.offset*t,n.offset*t+o*t),i=a.data.subarray(a.offset*t,a.offset*t+e*t);p&&(s=g(s,r),i=g(i,r));const B=_(s),P=_(i),f=O(c);l(B,P,f,o,e);const m=I(f,o*e*t,u);return h.fromData(p?R(m,r):m,[o,e],r)}export{q as wasmOuter};
+import{outer_f64 as C,outer_f32 as m,outer_c128 as S,outer_c64 as x,outer_i64 as f,outer_i32 as p,outer_i16 as A,outer_i8 as T}from"./bins/outer.wasm.js";import{wasmMalloc as D,resetScratchAllocator as M,resolveInputPtr as d,f16InputToScratchF32 as g,f32OutputToF16Region as h}from"./runtime.js";import{ArrayStorage as w}from"../storage.js";import{effectiveDType as k,promoteDTypes as I}from"../dtype.js";import{wasmConfig as E}from"./config.js";const O=128,W={float64:C,float32:m,complex128:S,complex64:x,int64:f,uint64:f,int32:p,uint32:p,int16:A,uint16:A,int8:T,uint8:T,float16:m},N={float64:Float64Array,float32:Float32Array,complex128:Float64Array,complex64:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array,float16:Float32Array},U={complex128:2,complex64:2};function K(r,t){if(!r.isCContiguous||!t.isCContiguous)return null;const e=r.size,o=t.size;if(e+o<O*E.thresholdMultiplier)return null;const n=k(I(r.dtype,t.dtype)),s=W[n],l=N[n];if(!s||!l)return null;const u=U[n]??1,y=l.BYTES_PER_ELEMENT,i=e*o*u,_=i*y,b=n==="float16",a=D(_);if(!a)return null;if(E.wasmCallCount++,M(),b){const R=g(r,e),B=g(t,o);s(R,B,a.ptr,e,o);const c=h(a,i);return a.release(),c?w.fromWasmRegion([e,o],n,c,i,Float16Array):null}const F=d(r.data,r.isWasmBacked,r.wasmPtr,r.offset*u,e*u,y),P=d(t.data,t.isWasmBacked,t.wasmPtr,t.offset*u,o*u,y);return s(F,P,a.ptr,e,o),w.fromWasmRegion([e,o],n,a,i,l)}export{K as wasmOuter};

package/dist/esm/common/wasm/pad.js

@@ -1 +1 @@
-import{pad_2d_f64 as B,pad_2d_f32 as T,pad_2d_i64 as b,pad_2d_i32 as E,pad_2d_i16 as P,pad_2d_i8 as D}from"./bins/pad.wasm.js";import{ensureMemory as F,resetAllocator as S,copyIn as C,alloc as h,copyOut as I,f16ToF32Input as R,f32ToF16Output as M}from"./runtime.js";import{ArrayStorage as k}from"../storage.js";import{wasmConfig as O}from"./config.js";const U=64,z={float64:B,float32:T,int64:b,uint64:b,int32:E,uint32:E,int16:P,uint16:P,int8:D,uint8:D,float16:T},L={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array,float16:Float32Array};function x(t,n){if(!t.isCContiguous||t.shape.length!==2)return null;const o=t.size;if(o<U*O.thresholdMultiplier)return null;const r=t.dtype,s=z[r],a=L[r];if(!s||!a)return null;const u=t.shape[0],i=t.shape[1],y=u+2*n,l=i+2*n,p=y*l,f=a.BYTES_PER_ELEMENT,g=o*f,c=p*f;F(g+c),S();const d=r==="float16",A=t.offset;let e=t.data.subarray(A,A+o);d&&(e=R(e,r));const w=C(e),m=h(c);s(w,m,u,i,n);const _=I(m,p,a);return k.fromData(d?M(_,r):_,[y,l],r)}export{x as wasmPad2D};
+import{pad_2d_f64 as B,pad_2d_f32 as C,pad_2d_i64 as c,pad_2d_i32 as A,pad_2d_i16 as p,pad_2d_i8 as d}from"./bins/pad.wasm.js";import{wasmMalloc as F,resetScratchAllocator as R,resolveInputPtr as b}from"./runtime.js";import{ArrayStorage as _}from"../storage.js";import{effectiveDType as S}from"../dtype.js";import{wasmConfig as w}from"./config.js";const h=64,k={float64:B,float32:C,int64:c,uint64:c,int32:A,uint32:A,int16:p,uint16:p,int8:d,uint8:d,float16:p},D={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array,float16:typeof Float16Array<"u"?Float16Array:Float32Array};function O(r,e){if(!r.isCContiguous||r.shape.length!==2)return null;const o=r.size;if(o<h*w.thresholdMultiplier)return null;const t=S(r.dtype),a=k[t],s=D[t];if(!a||!s)return null;const i=r.shape[0],u=r.shape[1],y=i+2*e,l=u+2*e,f=y*l,m=s.BYTES_PER_ELEMENT,T=f*m,g=t==="float16",n=F(T);if(!n)return null;if(w.wasmCallCount++,R(),g){const E=b(r.data,r.isWasmBacked,r.wasmPtr,r.offset,o,2);return a(E,n.ptr,i,u,e),_.fromWasmRegion([y,l],t,n,f,Float16Array)}const P=b(r.data,r.isWasmBacked,r.wasmPtr,r.offset,o,m);return a(P,n.ptr,i,u,e),_.fromWasmRegion([y,l],t,n,f,s)}export{O as wasmPad2D};

package/dist/esm/common/wasm/partition.js

@@ -1 +1 @@
-import{partition_f64 as R,partition_f32 as F,partition_i64 as C,partition_u64 as I,partition_i32 as N,partition_u32 as Y,partition_i16 as v,partition_u16 as H,partition_i8 as K,partition_u8 as j,partition_slices_f64 as q,partition_slices_f32 as O,partition_slices_i64 as G,partition_slices_u64 as J,partition_slices_i32 as Q,partition_slices_u32 as V,partition_slices_i16 as W,partition_slices_u16 as X,partition_slices_i8 as Z,partition_slices_u8 as $}from"./bins/partition.wasm.js";import{ensureMemory as g,resetAllocator as w,copyIn as h,copyOut as x,getSharedMemory as S,f16ToF32Input as L,f32ToF16Output as P}from"./runtime.js";import{ArrayStorage as z}from"../storage.js";import{wasmConfig as D}from"./config.js";const tt=64,k={float64:R,float32:F,int64:C,uint64:I,int32:N,uint32:Y,int16:v,uint16:H,int8:K,uint8:j,float16:F},nt={float64:q,float32:O,int64:G,uint64:J,int32:Q,uint32:V,int16:W,uint16:X,int8:Z,uint8:$,float16:O},d={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array,float16:Float32Array};function at(t,f,e,i,s,n){if(e<2)return!0;const b=nt[n],o=n==="float16";if(b&&f[0]===0&&i>1&&f[1]===e){const r=d[n];if(!r)return!1;const c=r.BYTES_PER_ELEMENT,m=o?L(t,n):t,M=m.length*c;g(M),w();const T=h(m);b(T,e,i,s);const B=S();if(o){const A=new Float32Array(m.length);new Uint8Array(A.buffer,0,A.byteLength).set(new Uint8Array(B.buffer,T,A.byteLength));const E=P(A,n);new Uint8Array(t.buffer,t.byteOffset,t.byteLength).set(new Uint8Array(E.buffer,E.byteOffset,E.byteLength))}else new Uint8Array(t.buffer,t.byteOffset,t.byteLength).set(new Uint8Array(B.buffer,T,t.byteLength));return!0}const u=k[n],p=d[n];if(!u||!p)return!1;const a=p.BYTES_PER_ELEMENT,y=o?L(t,n):t,l=y.length*a;g(l),w();const _=h(y);for(let r=0;r<i;r++)u(_+f[r]*a,e,s);const U=S();if(o){const r=new Float32Array(y.length);new Uint8Array(r.buffer,0,r.byteLength).set(new Uint8Array(U.buffer,_,r.byteLength));const c=P(r,n);new Uint8Array(t.buffer,t.byteOffset,t.byteLength).set(new Uint8Array(c.buffer,c.byteOffset,c.byteLength))}else new Uint8Array(t.buffer,t.byteOffset,t.byteLength).set(new Uint8Array(U.buffer,_,t.byteLength));return!0}function yt(t,f){if(!t.isCContiguous)return null;const e=t.size;if(e<tt*D.thresholdMultiplier)return null;const i=t.dtype,s=k[i],n=d[i];if(!s||!n)return null;const b=n.BYTES_PER_ELEMENT,o=e*b;g(o),w();const u=i==="float16",p=t.offset;let a=t.data.subarray(p,p+e);u&&(a=L(a,i));const y=h(a);s(y,e,f);const l=x(y,e,n);return z.fromData(u?P(l,i):l,Array.from(t.shape),i)}export{yt as wasmPartition,at as wasmPartitionSlices};
+import{partition_f64 as R,partition_f32 as d,partition_i64 as S,partition_u64 as O,partition_i32 as M,partition_u32 as I,partition_i16 as U,partition_u16 as W,partition_i8 as N,partition_u8 as Y,partition_slices_f64 as v,partition_slices_f32 as E,partition_slices_i64 as x,partition_slices_u64 as V,partition_slices_i32 as j,partition_slices_u32 as H,partition_slices_i16 as K,partition_slices_u16 as q,partition_slices_i8 as G,partition_slices_u8 as J}from"./bins/partition.wasm.js";import{wasmMalloc as P,resetScratchAllocator as h,scratchCopyIn as F,getSharedMemory as _,f16InputToScratchF32 as C}from"./runtime.js";import{ArrayStorage as B}from"../storage.js";import{effectiveDType as Q,hasFloat16 as L}from"../dtype.js";import{wasmConfig as g}from"./config.js";const X=64,k={float64:R,float32:d,int64:S,uint64:O,int32:M,uint32:I,int16:U,uint16:W,int8:N,uint8:Y,float16:d},Z={float64:v,float32:E,int64:x,uint64:V,int32:j,uint32:H,int16:K,uint16:q,int8:G,uint8:J,float16:E},T={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array,float16:Float32Array};function er(r,c,t,a,p,s){if(t<2)return!0;const m=Z[s],y=s==="float16";if(m&&c[0]===0&&a>1&&c[1]===t){if(!T[s])return!1;g.wasmCallCount++,h();const i=y?C({data:r,isWasmBacked:!1,wasmPtr:0,offset:0},r.length):F(r);m(i,t,a,p);const b=_();if(y){const A=new Uint16Array(r.length),n=new Float32Array(b.buffer,i,r.length);new Float16Array(A.buffer,0,r.length).set(n),new Uint8Array(r.buffer,r.byteOffset,r.byteLength).set(new Uint8Array(A.buffer,0,A.byteLength))}else new Uint8Array(r.buffer,r.byteOffset,r.byteLength).set(new Uint8Array(b.buffer,i,r.byteLength));return!0}const w=k[s],f=T[s];if(!w||!f)return!1;const u=f.BYTES_PER_ELEMENT;g.wasmCallCount++,h();const l=y?C({data:r,isWasmBacked:!1,wasmPtr:0,offset:0},r.length):F(r);for(let e=0;e<a;e++)w(l+c[e]*u,t,p);const o=_();if(y){const e=new Float32Array(o.buffer,l,r.length);if(L){const i=new Uint16Array(r.length);new Float16Array(i.buffer,0,r.length).set(e),new Uint8Array(r.buffer,r.byteOffset,r.byteLength).set(new Uint8Array(i.buffer,0,i.byteLength))}else r.set(e)}else new Uint8Array(r.buffer,r.byteOffset,r.byteLength).set(new Uint8Array(o.buffer,l,r.byteLength));return!0}function ir(r,c){if(!r.isCContiguous)return null;const t=r.size;if(t<X*g.thresholdMultiplier)return null;const a=Q(r.dtype),p=k[a],s=T[a];if(!p||!s)return null;const m=s.BYTES_PER_ELEMENT,y=t*m,w=a==="float16",f=P(y);if(!f)return null;g.wasmCallCount++,h();const u=r.offset;if(w){const o=t*2,e=P(o);if(!e)return f.release(),null;const i=_();if(r.isWasmBacked)new Uint8Array(i.buffer,e.ptr,o).set(new Uint8Array(i.buffer,r.wasmPtr+u*2,o));else{const n=r.data.subarray(u,u+t);new Uint8Array(i.buffer,e.ptr,o).set(new Uint8Array(n.buffer,n.byteOffset,n.byteLength))}const b=new Uint16Array(i.buffer,e.ptr,t);for(let n=0;n<t;n++)b[n]&32768&&(b[n]^=32767);U(e.ptr,t,c);for(let n=0;n<t;n++)b[n]&32768&&(b[n]^=32767);f.release();const A=L?Float16Array:Uint16Array;return B.fromWasmRegion(Array.from(r.shape),a,e,t,A)}const l=_();if(r.isWasmBacked)new Uint8Array(l.buffer,f.ptr,y).set(new Uint8Array(l.buffer,r.wasmPtr+u*m,y));else{const o=r.data.subarray(u,u+t);new Uint8Array(l.buffer,f.ptr,y).set(new Uint8Array(o.buffer,o.byteOffset,o.byteLength))}return p(f.ptr,t,c),B.fromWasmRegion(Array.from(r.shape),a,f,t,s)}export{ir as wasmPartition,er as wasmPartitionSlices};

package/dist/esm/common/wasm/power.js

@@ -1 +1 @@
-import{power_f64 as G,power_f32 as C,power_i64 as F,power_i32 as I,power_i16 as k,power_i8 as M,power_scalar_f64 as N,power_scalar_f32 as R,power_scalar_i64 as L,power_scalar_i32 as z,power_scalar_i16 as U,power_scalar_i8 as Y}from"./bins/power.wasm.js";import{ensureMemory as E,resetAllocator as g,copyIn as b,alloc as P,copyOut as B,f16ToF32Input as D,f32ToF16Output as v}from"./runtime.js";import{ArrayStorage as S}from"../storage.js";import{promoteDTypes as J,isBigIntDType as Q}from"../dtype.js";import{wasmConfig as x}from"./config.js";const H=64,V={float64:G,float32:C,int64:F,uint64:F,int32:I,uint32:I,int16:k,uint16:k,int8:M,uint8:M,float16:C},W={float64:N,float32:R,int64:L,uint64:L,int32:z,uint32:z,int16:U,uint16:U,int8:Y,uint8:Y,float16:R},K={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function nr(t,e){if(!t.isCContiguous||!e.isCContiguous)return null;const r=t.size;if(r<H*x.thresholdMultiplier)return null;const n=J(t.dtype,e.dtype),d=V[n],s=K[n];if(!d||!s)return null;const a=s.BYTES_PER_ELEMENT,l=r*a,T=r*a,u=r*a;E(l+T+u),g();const i=n,p=t.offset,c=e.offset,m=D(t.data.subarray(p,p+r),t.dtype),w=D(e.data.subarray(c,c+r),e.dtype),_=b(m),O=b(w),y=P(u);d(_,O,y,r);const A=B(y,r,s),f=v(A,i);return S.fromData(f,Array.from(t.shape),i)}function er(t,e){if(!t.isCContiguous)return null;const r=t.size;if(r<H*x.thresholdMultiplier)return null;const n=t.dtype;if(n!=="float32"&&n!=="float64"&&(e<0||!Number.isInteger(e))){E(r*8*2),g();const y=t.offset,A=t.data,f=new Float64Array(r);if(Q(n))for(let o=0;o<r;o++)f[o]=Number(A[y+o]);else for(let o=0;o<r;o++)f[o]=A[y+o];const j=b(f),h=P(r*8);N(j,h,r,e);const q=B(h,r,Float64Array);return S.fromData(q,Array.from(t.shape),"float64")}const s=W[n],a=K[n];if(!s||!a)return null;const l=a.BYTES_PER_ELEMENT,T=r*l,u=r*l;E(T+u),g();const i=t.offset,p=D(t.data.subarray(i,i+r),n),c=b(p),m=P(u);s(c,m,r,e);const w=B(m,r,a),_=v(w,n);return S.fromData(_,Array.from(t.shape),n)}export{nr as wasmPower,er as wasmPowerScalar};
+import{power_f64 as U,power_f32 as B,power_i64 as R,power_i32 as C,power_i16 as S,power_i8 as h,power_scalar_f64 as k,power_scalar_f32 as F,power_scalar_i64 as I,power_scalar_i32 as D,power_scalar_i16 as M,power_scalar_i8 as N}from"./bins/power.wasm.js";import{wasmMalloc as d,resetScratchAllocator as g,resolveInputPtr as T,scratchCopyIn as Y,f16InputToScratchF32 as _,f32OutputToF16Region as W}from"./runtime.js";import{ArrayStorage as y}from"../storage.js";import{effectiveDType as z,promoteDTypes as x,isBigIntDType as H}from"../dtype.js";import{wasmConfig as p}from"./config.js";const O=64,K={float64:U,float32:B,int64:R,uint64:R,int32:C,uint32:C,int16:S,uint16:S,int8:h,uint8:h,float16:B},j={float64:k,float32:F,int64:I,uint64:I,int32:D,uint32:D,int16:M,uint16:M,int8:N,uint8:N,float16:F},v={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function X(r,n){if(!r.isCContiguous||!n.isCContiguous||r.dtype!==n.dtype||r.size!==n.size)return null;const t=r.size;if(t<O*p.thresholdMultiplier)return null;const e=z(x(r.dtype,n.dtype)),A=K[e],l=v[e];if(!A||!l)return null;const s=l.BYTES_PER_ELEMENT,m=t*s,u=d(m);if(!u)return null;p.wasmCallCount++;const a=e;g();let i,f;if(e==="float16"?(i=_(r,t),f=_(n,t)):(i=T(r.data,r.isWasmBacked,r.wasmPtr,r.offset,t,s),f=T(n.data,n.isWasmBacked,n.wasmPtr,n.offset,t,s)),A(i,f,u.ptr,t),a==="float16"){const c=W(u,t);return u.release(),c?y.fromWasmRegion(Array.from(r.shape),a,c,t,Float16Array):null}return y.fromWasmRegion(Array.from(r.shape),e,u,t,l)}function Z(r,n){if(!r.isCContiguous)return null;const t=r.size;if(t<O*p.thresholdMultiplier)return null;const e=z(r.dtype);if(e!=="float32"&&e!=="float64"&&(n<0||!Number.isInteger(n))){const c=t*8,w=d(c);if(!w)return null;p.wasmCallCount++,g();const E=r.offset,P=r.data,b=new Float64Array(t);if(H(e))for(let o=0;o<t;o++)b[o]=Number(P[E+o]);else for(let o=0;o<t;o++)b[o]=P[E+o];const L=Y(b);return k(L,w.ptr,t,n),y.fromWasmRegion(Array.from(r.shape),"float64",w,t,Float64Array)}const l=j[e],s=v[e];if(!l||!s)return null;const m=s.BYTES_PER_ELEMENT,u=t*m,a=d(u);if(!a)return null;p.wasmCallCount++,g();let i;if(e==="float16"?i=_(r,t):i=T(r.data,r.isWasmBacked,r.wasmPtr,r.offset,t,m),l(i,a.ptr,t,n),e==="float16"){const f=W(a,t);return a.release(),f?y.fromWasmRegion(Array.from(r.shape),e,f,t,Float16Array):null}return y.fromWasmRegion(Array.from(r.shape),e,a,t,s)}export{X as wasmPower,Z as wasmPowerScalar};

package/dist/esm/common/wasm/qr.js

@@ -1 +1 @@
-import{qr_f64 as B}from"./bins/qr.wasm.js";import{ensureMemory as E,resetAllocator as H,copyIn as O,alloc as s,copyOut as y}from"./runtime.js";import{ArrayStorage as h}from"../storage.js";import{wasmConfig as A}from"./config.js";const g=4;function C(a){if(a.ndim!==2)return null;const r=a.shape[0],t=a.shape[1];if(r<g*A.thresholdMultiplier||t<g*A.thresholdMultiplier)return null;const o=Math.min(r,t),i=r*t,c=r*o,l=o*t,m=o,f=o,q=(i+c+l+m+f)*8;E(q),H();const u=new Float64Array(i);for(let n=0;n<r;n++)for(let e=0;e<t;e++)u[n*t+e]=Number(a.get(n,e));const D=O(u),S=s(c*8),p=s(l*8),z=s(m*8),F=s(f*8);B(D,S,p,z,F,r,t);const P=y(S,c,Float64Array),M=y(p,l,Float64Array),d=h.fromData(P,[r,o],"float64"),w=h.fromData(M,[o,t],"float64");return{q:d,r:w}}export{C as wasmQr};
+import{qr_f64 as C}from"./bins/qr.wasm.js";import{wasmMalloc as c,resetScratchAllocator as F,scratchAlloc as g,getSharedMemory as R}from"./runtime.js";import{ArrayStorage as w}from"../storage.js";import{isComplexDType as M}from"../dtype.js";import{wasmConfig as y}from"./config.js";const b=4;function P(r){if(r.ndim!==2||M(r.dtype))return null;const t=r.shape[0],e=r.shape[1];if(t<b*y.thresholdMultiplier||e<b*y.thresholdMultiplier)return null;const o=Math.min(t,e),p=t*o,A=o*e,n=c(p*8);if(!n)return null;const l=c(A*8);if(!l)return n.release(),null;y.wasmCallCount++,F();const a=t*e,s=c(a*8);if(!s)return n.release(),l.release(),null;const m=R();if(r.dtype==="float64"&&r.isCContiguous){const f=new Float64Array(m.buffer,s.ptr,a);r.isWasmBacked?f.set(new Float64Array(m.buffer,r.wasmPtr+r.offset*8,a)):f.set(r.data.subarray(r.offset,r.offset+a))}else{const f=new Float64Array(m.buffer,s.ptr,a);for(let i=0;i<t;i++)for(let u=0;u<e;u++)f[i*e+u]=Number(r.get(i,u))}const h=g(o*8),S=g(o*8);C(s.ptr,n.ptr,l.ptr,h,S,t,e),s.release();const d=w.fromWasmRegion([t,o],"float64",n,p,Float64Array),q=w.fromWasmRegion([o,e],"float64",l,A,Float64Array);return{q:d,r:q}}export{P as wasmQr};

package/dist/esm/common/wasm/reciprocal.js

@@ -1 +1 @@
-import{reciprocal_f64 as S,reciprocal_f32 as g,reciprocal_i64_f64 as f,reciprocal_i32_f64 as l,reciprocal_i16_f64 as c,reciprocal_i8_f64 as p}from"./bins/reciprocal.wasm.js";import{ensureMemory as A,resetAllocator as m,copyIn as E,alloc as T,copyOut as _}from"./runtime.js";import{ArrayStorage as d}from"../storage.js";import{wasmConfig as C}from"./config.js";const M=64,U={float64:S,float32:g},F={int64:f,uint64:f,int32:l,uint32:l,int16:c,uint16:c,int8:p,uint8:p},b={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function k(t){if(!t.isCContiguous)return null;const r=t.size;if(r<M*C.thresholdMultiplier)return null;const n=t.dtype,o=U[n];if(o){const y=b[n],u=y.BYTES_PER_ELEMENT;A(r*u*2),m();const D=E(t.data.subarray(t.offset,t.offset+r)),s=T(r*u);o(D,s,r);const R=_(s,r,y);return d.fromData(R,Array.from(t.shape),n)}const a=F[n],e=b[n];if(!a||!e)return null;const P=e.BYTES_PER_ELEMENT;A(r*P+r*8),m();const B=E(t.data.subarray(t.offset,t.offset+r)),i=T(r*8);a(B,i,r);const w=_(i,r,Float64Array);return d.fromData(w,Array.from(t.shape),"float64")}export{k as wasmReciprocal};
+import{reciprocal_f64 as w,reciprocal_f32 as P,reciprocal_i64 as B,reciprocal_u64 as R,reciprocal_i32 as g,reciprocal_u32 as C,reciprocal_i16 as S,reciprocal_u16 as M,reciprocal_i8 as U,reciprocal_u8 as h}from"./bins/reciprocal.wasm.js";import{wasmMalloc as p,resetScratchAllocator as f,resolveInputPtr as m}from"./runtime.js";import{ArrayStorage as A}from"../storage.js";import{wasmConfig as i}from"./config.js";const k=64,I={float64:w,float32:P},D={int64:B,uint64:R,int32:g,uint32:C,int16:S,uint16:M,int8:U,uint8:h},E={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function W(r){if(!r.isCContiguous)return null;const t=r.size;if(t<k*i.thresholdMultiplier)return null;const n=r.dtype,u=I[n];if(u){const c=E[n],y=c.BYTES_PER_ELEMENT,d=t*y,a=p(d);if(!a)return null;i.wasmCallCount++,f();const b=m(r.data,r.isWasmBacked,r.wasmPtr,r.offset,t,y);return u(b,a.ptr,t),A.fromWasmRegion(Array.from(r.shape),n,a,t,c)}const s=D[n],o=E[n];if(!s||!o)return null;const l=o.BYTES_PER_ELEMENT,T=t*l,e=p(T);if(!e)return null;i.wasmCallCount++,f();const _=m(r.data,r.isWasmBacked,r.wasmPtr,r.offset,t,l);return s(_,e.ptr,t),A.fromWasmRegion(Array.from(r.shape),n,e,t,o)}export{W as wasmReciprocal};

package/dist/esm/common/wasm/reduce_all.js

@@ -1 +1 @@
-import{reduce_all_f64 as d,reduce_all_f32 as i,reduce_all_i64 as l,reduce_all_i32 as u,reduce_all_i16 as y,reduce_all_i8 as c}from"./bins/reduce_all.wasm.js";import{ensureMemory as m,resetAllocator as _,copyIn as T,f16ToF32Input as E}from"./runtime.js";import{wasmConfig as R}from"./config.js";const b=64,g={float64:d,float32:i,float16:i,int64:l,uint64:l,int32:u,uint32:u,int16:y,uint16:y,int8:c,uint8:c},C={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function B(r){if(!r.isCContiguous)return null;const t=r.size;if(t<b*R.thresholdMultiplier)return null;const n=r.dtype,e=g[n],a=C[n];if(!e||!a)return null;const s=a.BYTES_PER_ELEMENT;m(t*s),_();const o=r.offset,p=r.data.subarray(o,o+t),f=E(p,n),A=T(f);return e(A,t)}export{B as wasmReduceAll};
+import{reduce_all_f64 as p,reduce_all_f32 as i,reduce_all_i64 as l,reduce_all_i32 as u,reduce_all_i16 as y,reduce_all_i8 as c}from"./bins/reduce_all.wasm.js";import{resetScratchAllocator as m,resolveInputPtr as A,f16InputToScratchF32 as d}from"./runtime.js";import{effectiveDType as _}from"../dtype.js";import{wasmConfig as s}from"./config.js";const T=64,E={float64:p,float32:i,float16:i,int64:l,uint64:l,int32:u,uint32:u,int16:y,uint16:y,int8:c,uint8:c},b={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function F(r){if(!r.isCContiguous)return null;const t=r.size;if(t<T*s.thresholdMultiplier)return null;const e=_(r.dtype),a=E[e],o=b[e];if(!a||!o)return null;const f=o.BYTES_PER_ELEMENT;s.wasmCallCount++,m();let n;return e==="float16"?n=d(r,t):n=A(r.data,r.isWasmBacked,r.wasmPtr,r.offset,t,f),a(n,t)}export{F as wasmReduceAll};

package/dist/esm/common/wasm/reduce_any.js

@@ -1 +1 @@
-import{reduce_any_f64 as d,reduce_any_f32 as i,reduce_any_i64 as y,reduce_any_i32 as u,reduce_any_i16 as c,reduce_any_i8 as l}from"./bins/reduce_any.wasm.js";import{ensureMemory as m,resetAllocator as _,copyIn as T,f16ToF32Input as E}from"./runtime.js";import{wasmConfig as R}from"./config.js";const b=64,g={float64:d,float32:i,float16:i,int64:y,uint64:y,int32:u,uint32:u,int16:c,uint16:c,int8:l,uint8:l},C={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function B(r){if(!r.isCContiguous)return null;const t=r.size;if(t<b*R.thresholdMultiplier)return null;const n=r.dtype,e=g[n],a=C[n];if(!e||!a)return null;const s=a.BYTES_PER_ELEMENT;m(t*s),_();const o=r.offset,p=r.data.subarray(o,o+t),f=E(p,n),A=T(f);return e(A,t)}export{B as wasmReduceAny};
+import{reduce_any_f64 as p,reduce_any_f32 as i,reduce_any_i64 as u,reduce_any_i32 as y,reduce_any_i16 as l,reduce_any_i8 as c}from"./bins/reduce_any.wasm.js";import{resetScratchAllocator as m,resolveInputPtr as A,f16InputToScratchF32 as d}from"./runtime.js";import{effectiveDType as _}from"../dtype.js";import{wasmConfig as s}from"./config.js";const T=64,E={float64:p,float32:i,float16:i,int64:u,uint64:u,int32:y,uint32:y,int16:l,uint16:l,int8:c,uint8:c},b={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function F(r){if(!r.isCContiguous)return null;const t=r.size;if(t<T*s.thresholdMultiplier)return null;const n=_(r.dtype),a=E[n],o=b[n];if(!a||!o)return null;const f=o.BYTES_PER_ELEMENT;s.wasmCallCount++,m();let e;return n==="float16"?e=d(r,t):e=A(r.data,r.isWasmBacked,r.wasmPtr,r.offset,t,f),a(e,t)}export{F as wasmReduceAny};

package/dist/esm/common/wasm/reduce_argmax.js

@@ -1 +1 @@
-import{reduce_argmax_f32 as u,reduce_argmax_i64 as s,reduce_argmax_i32 as l,reduce_argmax_i16 as p,reduce_argmax_i8 as d,reduce_argmax_u64 as A,reduce_argmax_u32 as _,reduce_argmax_u16 as f,reduce_argmax_u8 as g}from"./bins/reduce_argmax.wasm.js";import{ensureMemory as T,resetAllocator as E,copyIn as x,f16ToF32Input as b}from"./runtime.js";import{wasmConfig as R}from"./config.js";const C=64,F={float32:u,float16:u,int64:s,uint64:A,int32:l,uint32:_,int16:p,uint16:f,int8:d,uint8:g},I={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function M(r){if(!r.isCContiguous)return null;const t=r.size;if(t<C*R.thresholdMultiplier)return null;const e=r.dtype,n=F[e],a=I[e];if(!n||!a)return null;const i=a.BYTES_PER_ELEMENT;T(t*i),E();const o=r.offset,y=r.data.subarray(o,o+t),c=b(y,e),m=x(c);return Number(n(m,t))}export{M as wasmReduceArgmax};
+import{reduce_argmax_f64 as E,reduce_argmax_f32 as c,reduce_argmax_i64 as T,reduce_argmax_i32 as P,reduce_argmax_i16 as R,reduce_argmax_i8 as w,reduce_argmax_u64 as C,reduce_argmax_u32 as S,reduce_argmax_u16 as B,reduce_argmax_u8 as k,reduce_argmax_strided_f64 as F,reduce_argmax_strided_f32 as _,reduce_argmax_strided_i32 as I,reduce_argmax_strided_u32 as M,reduce_argmax_strided_i16 as h,reduce_argmax_strided_u16 as D,reduce_argmax_strided_i8 as N,reduce_argmax_strided_u8 as L}from"./bins/reduce_argmax.wasm.js";import{resetScratchAllocator as f,resolveInputPtr as y,f16InputToScratchF32 as g,wasmMalloc as U}from"./runtime.js";import{ArrayStorage as Y}from"../storage.js";import{effectiveDType as p}from"../dtype.js";import{wasmConfig as o}from"./config.js";const A=64,v={float64:E,float32:c,float16:c,int64:T,uint64:C,int32:P,uint32:S,int16:R,uint16:B,int8:w,uint8:k},b={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function J(r){if(!r.isCContiguous)return null;const t=r.size;if(t<A*o.thresholdMultiplier)return null;const e=p(r.dtype),n=v[e],a=b[e];if(!n||!a)return null;const i=a.BYTES_PER_ELEMENT;o.wasmCallCount++,f();let u;return e==="float16"?u=g(r,t):u=y(r.data,r.isWasmBacked,r.wasmPtr,r.offset,t,i),Number(n(u,t))}const W={float64:F,float32:_,float16:_,int32:I,uint32:M,int16:h,uint16:D,int8:N,uint8:L};function Q(r,t,e,n){if(!r.isCContiguous)return null;const a=t*e*n;if(a<A*o.thresholdMultiplier)return null;const i=p(r.dtype),u=W[i],s=b[i];if(!u||!s)return null;const x=s.BYTES_PER_ELEMENT,d=t*n,m=U(d*4);if(!m)return null;o.wasmCallCount++,f();let l;return i==="float16"?l=g(r,a):l=y(r.data,r.isWasmBacked,r.wasmPtr,r.offset,a,x),u(l,m.ptr,t,e,n),Y.fromWasmRegion([d],"int32",m,d,Int32Array)}export{J as wasmReduceArgmax,Q as wasmReduceArgmaxStrided};

package/dist/esm/common/wasm/reduce_argmin.js

@@ -1 +1 @@
-import{reduce_argmin_f32 as o,reduce_argmin_i64 as s,reduce_argmin_i32 as l,reduce_argmin_i16 as p,reduce_argmin_i8 as d,reduce_argmin_u64 as A,reduce_argmin_u32 as _,reduce_argmin_u16 as f,reduce_argmin_u8 as g}from"./bins/reduce_argmin.wasm.js";import{ensureMemory as T,resetAllocator as E,copyIn as b,f16ToF32Input as R}from"./runtime.js";import{wasmConfig as C}from"./config.js";const F=64,I={float32:o,float16:o,int64:s,uint64:A,int32:l,uint32:_,int16:p,uint16:f,int8:d,uint8:g},P={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function N(r){if(!r.isCContiguous)return null;const t=r.size;if(t<F*C.thresholdMultiplier)return null;const n=r.dtype,e=I[n],a=P[n];if(!e||!a)return null;const u=a.BYTES_PER_ELEMENT;T(t*u),E();const i=r.offset,y=r.data.subarray(i,i+t),c=R(y,n),m=b(c);return Number(e(m,t))}export{N as wasmReduceArgmin};
+import{reduce_argmin_f64 as T,reduce_argmin_f32 as c,reduce_argmin_i64 as P,reduce_argmin_i32 as R,reduce_argmin_i16 as w,reduce_argmin_i8 as C,reduce_argmin_u64 as S,reduce_argmin_u32 as B,reduce_argmin_u16 as k,reduce_argmin_u8 as F,reduce_argmin_strided_f64 as I,reduce_argmin_strided_f32 as _,reduce_argmin_strided_i32 as M,reduce_argmin_strided_u32 as h,reduce_argmin_strided_i16 as D,reduce_argmin_strided_u16 as N,reduce_argmin_strided_i8 as L,reduce_argmin_strided_u8 as U}from"./bins/reduce_argmin.wasm.js";import{resetScratchAllocator as f,resolveInputPtr as y,f16InputToScratchF32 as g,wasmMalloc as Y}from"./runtime.js";import{ArrayStorage as v}from"../storage.js";import{effectiveDType as p}from"../dtype.js";import{wasmConfig as o}from"./config.js";const A=64,W={float64:T,float32:c,float16:c,int64:P,uint64:S,int32:R,uint32:B,int16:w,uint16:k,int8:C,uint8:F},b={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function J(r){if(!r.isCContiguous)return null;const t=r.size;if(t<A*o.thresholdMultiplier)return null;const e=p(r.dtype),n=W[e],i=b[e];if(!n||!i)return null;const a=i.BYTES_PER_ELEMENT;o.wasmCallCount++,f();let u;return e==="float16"?u=g(r,t):u=y(r.data,r.isWasmBacked,r.wasmPtr,r.offset,t,a),Number(n(u,t))}const x={float64:I,float32:_,float16:_,int32:M,uint32:h,int16:D,uint16:N,int8:L,uint8:U};function Q(r,t,e,n){if(!r.isCContiguous)return null;const i=t*e*n;if(i<A*o.thresholdMultiplier)return null;const a=p(r.dtype),u=x[a],s=b[a];if(!u||!s)return null;const E=s.BYTES_PER_ELEMENT,d=t*n,m=Y(d*4);if(!m)return null;o.wasmCallCount++,f();let l;return a==="float16"?l=g(r,i):l=y(r.data,r.isWasmBacked,r.wasmPtr,r.offset,i,E),u(l,m.ptr,t,e,n),v.fromWasmRegion([d],"int32",m,d,Int32Array)}export{J as wasmReduceArgmin,Q as wasmReduceArgminStrided};

package/dist/esm/common/wasm/reduce_count_nz.js

@@ -1 +1 @@
-import{reduce_count_nz_f64 as A,reduce_count_nz_f32 as u,reduce_count_nz_i64 as i,reduce_count_nz_i32 as y,reduce_count_nz_i16 as c,reduce_count_nz_i8 as l}from"./bins/reduce_count_nz.wasm.js";import{ensureMemory as d,resetAllocator as m,copyIn as T,f16ToF32Input as E}from"./runtime.js";import{wasmConfig as b}from"./config.js";const z=64,R={float64:A,float32:u,float16:u,int64:i,uint64:i,int32:y,uint32:y,int16:c,uint16:c,int8:l,uint8:l},g={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function w(r){if(!r.isCContiguous)return null;const t=r.size;if(t<z*b.thresholdMultiplier)return null;const n=r.dtype,e=R[n],o=g[n];if(!e||!o)return null;const s=o.BYTES_PER_ELEMENT;d(t*s),m();const a=r.offset,p=r.data.subarray(a,a+t),f=E(p,n),_=T(f);return Number(e(_,t))}export{w as wasmReduceCountNz};
+import{reduce_count_nz_f64 as p,reduce_count_nz_f32 as u,reduce_count_nz_i64 as a,reduce_count_nz_i32 as c,reduce_count_nz_i16 as l,reduce_count_nz_i8 as y}from"./bins/reduce_count_nz.wasm.js";import{resetScratchAllocator as m,resolveInputPtr as _,f16InputToScratchF32 as A}from"./runtime.js";import{effectiveDType as d}from"../dtype.js";import{wasmConfig as s}from"./config.js";const T=64,E={float64:p,float32:u,float16:u,int64:a,uint64:a,int32:c,uint32:c,int16:l,uint16:l,int8:y,uint8:y},b={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function B(t){if(!t.isCContiguous)return null;const r=t.size;if(r<T*s.thresholdMultiplier)return null;const n=d(t.dtype),o=E[n],i=b[n];if(!o||!i)return null;const f=i.BYTES_PER_ELEMENT;s.wasmCallCount++,m();let e;return n==="float16"?e=A(t,r):e=_(t.data,t.isWasmBacked,t.wasmPtr,t.offset,r,f),Number(o(e,r))}export{B as wasmReduceCountNz};

package/dist/esm/common/wasm/reduce_max.js

@@ -1 +1 @@
-import{reduce_max_f32 as A,reduce_max_i64 as g,reduce_max_i32 as C,reduce_max_i16 as F,reduce_max_i8 as I,reduce_max_u64 as M,reduce_max_u32 as D,reduce_max_u16 as S,reduce_max_u8 as U,reduce_max_strided_f32 as _,reduce_max_strided_i64 as N,reduce_max_strided_i32 as O,reduce_max_strided_i16 as h,reduce_max_strided_i8 as L,reduce_max_strided_u64 as Y,reduce_max_strided_u32 as H,reduce_max_strided_u16 as v,reduce_max_strided_u8 as K}from"./bins/reduce_max.wasm.js";import{ensureMemory as b,resetAllocator as p,copyIn as T,alloc as j,copyOut as q,f16ToF32Input as w,f32ToF16Output as G}from"./runtime.js";import{ArrayStorage as J}from"../storage.js";import{wasmConfig as x}from"./config.js";const B=64,Q={float32:A,float16:A,int64:g,uint64:M,int32:C,uint32:D,int16:F,uint16:S,int8:I,uint8:U},E={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function rr(r){if(!r.isCContiguous)return null;const n=r.size;if(n<B*x.thresholdMultiplier)return null;const t=r.dtype,u=Q[t],a=E[t];if(!u||!a)return null;const e=a.BYTES_PER_ELEMENT;b(n*e),p();const o=r.offset,i=r.data.subarray(o,o+n),f=w(i,t),y=T(f);return Number(u(y,n))}const V={float32:_,float16:_,int64:N,uint64:Y,int32:O,uint32:H,int16:h,uint16:v,int8:L,uint8:K},W={float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function nr(r,n,t,u){if(!r.isCContiguous)return null;const a=n*t*u;if(a<B*x.thresholdMultiplier)return null;const e=r.dtype,o=V[e],i=E[e],f=W[e];if(!o||!i||!f)return null;const y=i.BYTES_PER_ELEMENT,m=y,s=n*u;b(a*y+s*m),p();const l=r.offset,k=r.data.subarray(l,l+a),R=w(k,e),P=T(R),c=j(s*m);o(P,c,n,t,u);let d=q(c,s,f);return d=G(d,e),J.fromData(d,[s],e)}export{rr as wasmReduceMax,nr as wasmReduceMaxStrided};
+import{reduce_max_f64 as P,reduce_max_f32 as A,reduce_max_i64 as C,reduce_max_i32 as F,reduce_max_i16 as I,reduce_max_i8 as M,reduce_max_u64 as S,reduce_max_u32 as U,reduce_max_u16 as h,reduce_max_u8 as D,reduce_max_strided_f64 as N,reduce_max_strided_f32 as b,reduce_max_strided_i64 as L,reduce_max_strided_i32 as W,reduce_max_strided_i16 as Y,reduce_max_strided_i8 as v,reduce_max_strided_u64 as O,reduce_max_strided_u32 as H,reduce_max_strided_u16 as K,reduce_max_strided_u8 as j}from"./bins/reduce_max.wasm.js";import{resetScratchAllocator as p,resolveInputPtr as w,f16InputToScratchF32 as T,wasmMalloc as B,f32OutputToF16Region as q}from"./runtime.js";import{ArrayStorage as x}from"../storage.js";import{effectiveDType as E}from"../dtype.js";import{wasmConfig as m}from"./config.js";const g=64,G={float64:P,float32:A,float16:A,int64:C,uint64:S,int32:F,uint32:U,int16:I,uint16:h,int8:M,uint8:D},R={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function er(r){if(!r.isCContiguous)return null;const e=r.size;if(e<g*m.thresholdMultiplier)return null;const t=E(r.dtype),u=G[t],f=R[t];if(!u||!f)return null;const n=f.BYTES_PER_ELEMENT;m.wasmCallCount++,p();let a;return t==="float16"?a=T(r,e):a=w(r.data,r.isWasmBacked,r.wasmPtr,r.offset,e,n),Number(u(a,e))}const J={float64:N,float32:b,float16:b,int64:L,uint64:O,int32:W,uint32:H,int16:Y,uint16:K,int8:v,uint8:j},Q={float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function nr(r,e,t,u){if(!r.isCContiguous)return null;const f=e*t*u;if(f<g*m.thresholdMultiplier)return null;const n=E(r.dtype),a=J[n],l=R[n],d=Q[n];if(!a||!l||!d)return null;const c=l.BYTES_PER_ELEMENT,k=c,o=e*u;m.wasmCallCount++,p();let i;if(n==="float16"?i=T(r,f):i=w(r.data,r.isWasmBacked,r.wasmPtr,r.offset,f,c),n==="float16"){const s=B(o*4);if(!s)return null;a(i,s.ptr,e,t,u);const _=q(s,o);return s.release(),_?x.fromWasmRegion([o],n,_,o,Float16Array):null}const y=B(o*k);return y?(a(i,y.ptr,e,t,u),x.fromWasmRegion([o],n,y,o,d)):null}export{er as wasmReduceMax,nr as wasmReduceMaxStrided};

package/dist/esm/common/wasm/reduce_mean.js

@@ -1 +1 @@
-import{reduce_mean_f64 as S,reduce_mean_f32 as y,reduce_mean_i64 as w,reduce_mean_i32 as F,reduce_mean_i16 as C,reduce_mean_i8 as D,reduce_mean_u64 as I,reduce_mean_u32 as N,reduce_mean_u16 as k,reduce_mean_u8 as L,reduce_mean_strided_f64 as h,reduce_mean_strided_f32 as l,reduce_mean_strided_i64 as Y,reduce_mean_strided_i32 as O,reduce_mean_strided_i16 as U,reduce_mean_strided_i8 as x,reduce_mean_strided_u64 as H,reduce_mean_strided_u32 as v,reduce_mean_strided_u16 as K,reduce_mean_strided_u8 as j}from"./bins/reduce_mean.wasm.js";import{ensureMemory as f,resetAllocator as p,copyIn as A,alloc as q,copyOut as G,f16ToF32Input as E}from"./runtime.js";import{ArrayStorage as J}from"../storage.js";import{wasmConfig as b}from"./config.js";const T=64,Q={float64:S,float32:y,float16:y,int64:w,uint64:I,int32:F,uint32:N,int16:C,uint16:k,int8:D,uint8:L},R={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function z(r){if(!r.isCContiguous)return null;const e=r.size;if(e<T*b.thresholdMultiplier)return null;const t=r.dtype,n=Q[t],a=R[t];if(!n||!a)return null;const u=a.BYTES_PER_ELEMENT;f(e*u),p();const o=r.offset,i=r.data.subarray(o,o+e),_=E(i,t),d=A(_);return Number(n(d,e))}const V={float64:h,float32:l,float16:l,int64:Y,uint64:H,int32:O,uint32:v,int16:U,uint16:K,int8:x,uint8:j};function rr(r,e,t,n){if(!r.isCContiguous)return null;const a=e*t*n;if(a<T*b.thresholdMultiplier)return null;const u=r.dtype,o=V[u],i=R[u];if(!o||!i)return null;const _=i.BYTES_PER_ELEMENT,d=Float64Array.BYTES_PER_ELEMENT,s=e*n;f(a*_+s*d),p();const c=r.offset,P=r.data.subarray(c,c+a),g=E(P,u),B=A(g),m=q(s*d);o(B,m,e,t,n);const M=G(m,s,Float64Array);return J.fromData(M,[s],"float64")}export{z as wasmReduceMean,rr as wasmReduceMeanStrided};
+import{reduce_mean_f64 as R,reduce_mean_f32 as _,reduce_mean_i64 as g,reduce_mean_i32 as w,reduce_mean_i16 as B,reduce_mean_i8 as C,reduce_mean_u64 as S,reduce_mean_u32 as M,reduce_mean_u16 as F,reduce_mean_u8 as k,reduce_mean_strided_f64 as h,reduce_mean_strided_f32 as c,reduce_mean_strided_i64 as I,reduce_mean_strided_i32 as N,reduce_mean_strided_i16 as D,reduce_mean_strided_i8 as L,reduce_mean_strided_u64 as Y,reduce_mean_strided_u32 as U,reduce_mean_strided_u16 as v,reduce_mean_strided_u8 as W}from"./bins/reduce_mean.wasm.js";import{resetScratchAllocator as f,resolveInputPtr as y,f16InputToScratchF32 as p,wasmMalloc as x}from"./runtime.js";import{ArrayStorage as H}from"../storage.js";import{effectiveDType as A}from"../dtype.js";import{wasmConfig as o}from"./config.js";const E=64,K={float64:R,float32:_,float16:_,int64:g,uint64:S,int32:w,uint32:M,int16:B,uint16:F,int8:C,uint8:k},b={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function X(e){if(!e.isCContiguous)return null;const r=e.size;if(r<E*o.thresholdMultiplier)return null;const t=A(e.dtype),n=K[t],u=b[t];if(!n||!u)return null;const i=u.BYTES_PER_ELEMENT;o.wasmCallCount++,f();let a;return t==="float16"?a=p(e,r):a=y(e.data,e.isWasmBacked,e.wasmPtr,e.offset,r,i),Number(n(a,r))}const O={float64:h,float32:c,float16:c,int64:I,uint64:Y,int32:N,uint32:U,int16:D,uint16:v,int8:L,uint8:W};function Z(e,r,t,n){if(!e.isCContiguous)return null;const u=r*t*n;if(u<E*o.thresholdMultiplier)return null;const i=A(e.dtype),a=O[i],m=b[i];if(!a||!m)return null;const T=m.BYTES_PER_ELEMENT,P=Float64Array.BYTES_PER_ELEMENT,d=r*n,l=x(d*P);if(!l)return null;o.wasmCallCount++,f();let s;return i==="float16"?s=p(e,u):s=y(e.data,e.isWasmBacked,e.wasmPtr,e.offset,u,T),a(s,l.ptr,r,t,n),H.fromWasmRegion([d],"float64",l,d,Float64Array)}export{X as wasmReduceMean,Z as wasmReduceMeanStrided};

package/dist/esm/common/wasm/reduce_min.js

@@ -1 +1 @@
-import{reduce_min_f32 as A,reduce_min_i64 as C,reduce_min_i32 as F,reduce_min_i16 as I,reduce_min_i8 as M,reduce_min_u64 as D,reduce_min_u32 as S,reduce_min_u16 as U,reduce_min_u8 as N,reduce_min_strided_f32 as _,reduce_min_strided_i64 as O,reduce_min_strided_i32 as h,reduce_min_strided_i16 as L,reduce_min_strided_i8 as Y,reduce_min_strided_u64 as x,reduce_min_strided_u32 as H,reduce_min_strided_u16 as v,reduce_min_strided_u8 as K}from"./bins/reduce_min.wasm.js";import{ensureMemory as b,resetAllocator as p,copyIn as T,alloc as j,copyOut as q,f16ToF32Input as w,f32ToF16Output as G}from"./runtime.js";import{ArrayStorage as J}from"../storage.js";import{wasmConfig as B}from"./config.js";const E=64,Q={float32:A,float16:A,int64:C,uint64:D,int32:F,uint32:S,int16:I,uint16:U,int8:M,uint8:N},k={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function rr(r){if(!r.isCContiguous)return null;const n=r.size;if(n<E*B.thresholdMultiplier)return null;const t=r.dtype,u=Q[t],a=k[t];if(!u||!a)return null;const e=a.BYTES_PER_ELEMENT;b(n*e),p();const o=r.offset,i=r.data.subarray(o,o+n),f=w(i,t),y=T(f);return Number(u(y,n))}const V={float32:_,float16:_,int64:O,uint64:x,int32:h,uint32:H,int16:L,uint16:v,int8:Y,uint8:K},W={float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function nr(r,n,t,u){if(!r.isCContiguous)return null;const a=n*t*u;if(a<E*B.thresholdMultiplier)return null;const e=r.dtype,o=V[e],i=k[e],f=W[e];if(!o||!i||!f)return null;const y=i.BYTES_PER_ELEMENT,m=y,s=n*u;b(a*y+s*m),p();const l=r.offset,R=r.data.subarray(l,l+a),P=w(R,e),g=T(P),c=j(s*m);o(g,c,n,t,u);let d=q(c,s,f);return d=G(d,e),J.fromData(d,[s],e)}export{rr as wasmReduceMin,nr as wasmReduceMinStrided};
+import{reduce_min_f64 as C,reduce_min_f32 as A,reduce_min_i64 as F,reduce_min_i32 as I,reduce_min_i16 as M,reduce_min_i8 as S,reduce_min_u64 as U,reduce_min_u32 as h,reduce_min_u16 as D,reduce_min_u8 as N,reduce_min_strided_f64 as L,reduce_min_strided_f32 as b,reduce_min_strided_i64 as W,reduce_min_strided_i32 as Y,reduce_min_strided_i16 as v,reduce_min_strided_i8 as O,reduce_min_strided_u64 as H,reduce_min_strided_u32 as x,reduce_min_strided_u16 as K,reduce_min_strided_u8 as j}from"./bins/reduce_min.wasm.js";import{resetScratchAllocator as p,resolveInputPtr as w,f16InputToScratchF32 as T,wasmMalloc as B,f32OutputToF16Region as q}from"./runtime.js";import{ArrayStorage as E}from"../storage.js";import{effectiveDType as g}from"../dtype.js";import{wasmConfig as m}from"./config.js";const R=64,G={float64:C,float32:A,float16:A,int64:F,uint64:U,int32:I,uint32:h,int16:M,uint16:D,int8:S,uint8:N},k={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function nr(r){if(!r.isCContiguous)return null;const n=r.size;if(n<R*m.thresholdMultiplier)return null;const t=g(r.dtype),u=G[t],o=k[t];if(!u||!o)return null;const e=o.BYTES_PER_ELEMENT;m.wasmCallCount++,p();let a;return t==="float16"?a=T(r,n):a=w(r.data,r.isWasmBacked,r.wasmPtr,r.offset,n,e),Number(u(a,n))}const J={float64:L,float32:b,float16:b,int64:W,uint64:H,int32:Y,uint32:x,int16:v,uint16:K,int8:O,uint8:j},Q={float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function er(r,n,t,u){if(!r.isCContiguous)return null;const o=n*t*u;if(o<R*m.thresholdMultiplier)return null;const e=g(r.dtype),a=J[e],l=k[e],d=Q[e];if(!a||!l||!d)return null;const c=l.BYTES_PER_ELEMENT,P=c,i=n*u;m.wasmCallCount++,p();let f;if(e==="float16"?f=T(r,o):f=w(r.data,r.isWasmBacked,r.wasmPtr,r.offset,o,c),e==="float16"){const s=B(i*4);if(!s)return null;a(f,s.ptr,n,t,u);const _=q(s,i);return s.release(),_?E.fromWasmRegion([i],e,_,i,Float16Array):null}const y=B(i*P);return y?(a(f,y.ptr,n,t,u),E.fromWasmRegion([i],e,y,i,d)):null}export{nr as wasmReduceMin,er as wasmReduceMinStrided};

package/dist/esm/common/wasm/reduce_nanmax.js

@@ -1 +1 @@
-import{reduce_nanmax_f64 as c,reduce_nanmax_f32 as y}from"./bins/reduce_nanmax.wasm.js";import{ensureMemory as f,resetAllocator as m,copyIn as i,f16ToF32Input as d}from"./runtime.js";import{wasmConfig as A}from"./config.js";const T=64,E={float64:c,float32:y,float16:y},b={float64:Float64Array,float32:Float32Array,float16:Float32Array};function P(r){if(!r.isCContiguous)return null;const t=r.size;if(t<T*A.thresholdMultiplier)return null;const e=r.dtype,o=E[e],n=b[e];if(!o||!n)return null;const u=n.BYTES_PER_ELEMENT;f(t*u),m();const a=r.offset,l=r.data.subarray(a,a+t),s=d(l,e),p=i(s);return Number(o(p,t))}export{P as wasmReduceNanmax};
+import{reduce_nanmax_f64 as s,reduce_nanmax_f32 as l}from"./bins/reduce_nanmax.wasm.js";import{resetScratchAllocator as f,resolveInputPtr as c,f16InputToScratchF32 as p}from"./runtime.js";import{effectiveDType as y}from"../dtype.js";import{wasmConfig as u}from"./config.js";const i=64,d={float64:s,float32:l,float16:l},T={float64:Float64Array,float32:Float32Array,float16:Float32Array};function S(r){if(!r.isCContiguous)return null;const e=r.size;if(e<i*u.thresholdMultiplier)return null;const t=y(r.dtype),n=d[t],a=T[t];if(!n||!a)return null;const m=a.BYTES_PER_ELEMENT;u.wasmCallCount++,f();let o;return t==="float16"?o=p(r,e):o=c(r.data,r.isWasmBacked,r.wasmPtr,r.offset,e,m),Number(n(o,e))}export{S as wasmReduceNanmax};

package/dist/esm/common/wasm/reduce_nanmin.js

@@ -1 +1 @@
-import{reduce_nanmin_f64 as c,reduce_nanmin_f32 as y}from"./bins/reduce_nanmin.wasm.js";import{ensureMemory as f,resetAllocator as i,copyIn as m,f16ToF32Input as d}from"./runtime.js";import{wasmConfig as A}from"./config.js";const T=64,E={float64:c,float32:y,float16:y},b={float64:Float64Array,float32:Float32Array,float16:Float32Array};function P(r){if(!r.isCContiguous)return null;const t=r.size;if(t<T*A.thresholdMultiplier)return null;const e=r.dtype,n=E[e],o=b[e];if(!n||!o)return null;const u=o.BYTES_PER_ELEMENT;f(t*u),i();const a=r.offset,l=r.data.subarray(a,a+t),s=d(l,e),p=m(s);return Number(n(p,t))}export{P as wasmReduceNanmin};
+import{reduce_nanmin_f64 as m,reduce_nanmin_f32 as l}from"./bins/reduce_nanmin.wasm.js";import{resetScratchAllocator as s,resolveInputPtr as f,f16InputToScratchF32 as c}from"./runtime.js";import{effectiveDType as p}from"../dtype.js";import{wasmConfig as u}from"./config.js";const y=64,d={float64:m,float32:l,float16:l},T={float64:Float64Array,float32:Float32Array,float16:Float32Array};function S(r){if(!r.isCContiguous)return null;const e=r.size;if(e<y*u.thresholdMultiplier)return null;const t=p(r.dtype),o=d[t],a=T[t];if(!o||!a)return null;const i=a.BYTES_PER_ELEMENT;u.wasmCallCount++,s();let n;return t==="float16"?n=c(r,e):n=f(r.data,r.isWasmBacked,r.wasmPtr,r.offset,e,i),Number(o(n,e))}export{S as wasmReduceNanmin};

package/dist/esm/common/wasm/reduce_nansum.js

@@ -1 +1 @@
-import{reduce_nansum_f64 as l,reduce_nansum_f32 as p}from"./bins/reduce_nansum.wasm.js";import{ensureMemory as m,resetAllocator as c,copyIn as f}from"./runtime.js";import{wasmConfig as i}from"./config.js";const d=64,A={float64:l,float32:p},T={float64:Float64Array,float32:Float32Array};function C(r){if(!r.isCContiguous)return null;const e=r.size;if(e<d*i.thresholdMultiplier)return null;const t=r.dtype,n=A[t],o=T[t];if(!n||!o)return null;const u=o.BYTES_PER_ELEMENT;m(e*u),c();const a=r.offset,s=r.data.subarray(a,a+e),y=f(s);return Number(n(y,e))}export{C as wasmReduceNansum};
+import{reduce_nansum_f64 as l,reduce_nansum_f32 as m}from"./bins/reduce_nansum.wasm.js";import{resetScratchAllocator as p,resolveInputPtr as y}from"./runtime.js";import{wasmConfig as a}from"./config.js";const c=64,i={float64:l,float32:m},f={float64:Float64Array,float32:Float32Array};function _(r){if(!r.isCContiguous)return null;const e=r.size;if(e<c*a.thresholdMultiplier)return null;const t=r.dtype,n=i[t],o=f[t];if(!n||!o)return null;a.wasmCallCount++,p();const u=o.BYTES_PER_ELEMENT,s=y(r.data,r.isWasmBacked,r.wasmPtr,r.offset,e,u);return Number(n(s,e))}export{_ as wasmReduceNansum};

package/dist/esm/common/wasm/reduce_prod.js

@@ -1 +1 @@
-import{reduce_prod_f64 as k,reduce_prod_f32 as D,reduce_prod_i64 as c,reduce_prod_i32 as A,reduce_prod_i16 as C,reduce_prod_i8 as I,reduce_prod_u16 as S,reduce_prod_u8 as F,reduce_prod_strided_f64 as M,reduce_prod_strided_f32 as O,reduce_prod_strided_i64 as U,reduce_prod_strided_i32 as N,reduce_prod_strided_i16 as h,reduce_prod_strided_i8 as L,reduce_prod_strided_u64 as Y,reduce_prod_strided_u32 as x,reduce_prod_strided_u16 as H,reduce_prod_strided_u8 as v}from"./bins/reduce_prod.wasm.js";import{ensureMemory as _,resetAllocator as b,copyIn as m,alloc as K,copyOut as j}from"./runtime.js";import{ArrayStorage as q}from"../storage.js";import{wasmConfig as T}from"./config.js";const w=64,G={float64:k,float32:D,int64:c,uint64:c,int32:A,uint32:A,int16:C,uint16:S,int8:I,uint8:F},B={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function rr(r){if(!r.isCContiguous)return null;const n=r.size;if(n<w*T.thresholdMultiplier)return null;const o=r.dtype,e=G[o],u=B[o];if(!e||!u)return null;const t=u.BYTES_PER_ELEMENT;_(n*t),b();const a=r.offset,i=r.data.subarray(a,a+n),d=m(i);return Number(e(d,n))}const J={float64:M,float32:O,int64:U,uint64:Y,int32:N,uint32:x,int16:h,uint16:H,int8:L,uint8:v},Q={float64:"float64",float32:"float32",int64:"int64",uint64:"uint64",int32:"int32",uint32:"uint32",int16:"int64",uint16:"uint64",int8:"int64",uint8:"uint64"},V={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:BigInt64Array,uint16:BigUint64Array,int8:BigInt64Array,uint8:BigUint64Array},W={float64:8,float32:4,int64:8,uint64:8,int32:4,uint32:4,int16:8,uint16:8,int8:8,uint8:8};function nr(r,n,o,e){if(!r.isCContiguous)return null;const u=n*o*e;if(u<w*T.thresholdMultiplier)return null;const t=r.dtype,a=J[t],i=B[t],d=V[t],s=Q[t],y=W[t];if(!a||!i||!d||!s||!y)return null;const E=i.BYTES_PER_ELEMENT,f=n*e;_(u*E+f*y),b();const p=r.offset,P=r.data.subarray(p,p+u),g=m(P),l=K(f*y);a(g,l,n,o,e);const R=j(l,f,d);return q.fromData(R,[f],s)}export{rr as wasmReduceProd,nr as wasmReduceProdStrided};
+import{reduce_prod_f64 as D,reduce_prod_f32 as g,reduce_prod_i64 as R,reduce_prod_i32 as P,reduce_prod_i16 as I,reduce_prod_i8 as h,reduce_prod_u16 as M,reduce_prod_u8 as S,reduce_prod_strided_f64 as U,reduce_prod_strided_f32 as k,reduce_prod_strided_i64 as N,reduce_prod_strided_i32 as O,reduce_prod_strided_i16 as W,reduce_prod_strided_i8 as x,reduce_prod_strided_u64 as L,reduce_prod_strided_u32 as Y,reduce_prod_strided_u16 as v,reduce_prod_strided_u8 as H,reduce_prod_strided_c128 as K,reduce_prod_strided_c64 as j}from"./bins/reduce_prod.wasm.js";import{resetScratchAllocator as A,resolveInputPtr as b,f16InputToScratchF32 as C,f32OutputToF16Region as q,wasmMalloc as E}from"./runtime.js";import{ArrayStorage as _}from"../storage.js";import{effectiveDType as w}from"../dtype.js";import{wasmConfig as c}from"./config.js";const T=64,G={float64:D,float32:g,float16:g,int64:R,uint64:R,int32:P,uint32:P,int16:I,uint16:M,int8:h,uint8:S},F={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function er(r){if(!r.isCContiguous)return null;const n=r.size;if(n<T*c.thresholdMultiplier)return null;const o=w(r.dtype),t=G[o],u=F[o];if(!t||!u)return null;if(c.wasmCallCount++,A(),o==="float16"){const d=C(r,n),s=Number(t(d,n)),f=new Float16Array(1);return f[0]=s,f[0]}const e=u.BYTES_PER_ELEMENT,i=b(r.data,r.isWasmBacked,r.wasmPtr,r.offset,n,e);return Number(t(i,n))}const J={float64:U,float32:k,float16:k,int64:N,uint64:L,int32:O,uint32:Y,int16:W,uint16:v,int8:x,uint8:H},Q={float64:"float64",float32:"float32",float16:"float16",int64:"int64",uint64:"uint64",int32:"int32",uint32:"uint32",int16:"int64",uint16:"uint64",int8:"int64",uint8:"uint64"},V={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:BigInt64Array,uint16:BigUint64Array,int8:BigInt64Array,uint8:BigUint64Array},X={float64:8,float32:4,float16:4,int64:8,uint64:8,int32:4,uint32:4,int16:8,uint16:8,int8:8,uint8:8};function ur(r,n,o,t){if(!r.isCContiguous)return null;const u=n*o*t;if(u<T*c.thresholdMultiplier)return null;const e=w(r.dtype),i=J[e],d=F[e],s=V[e],f=Q[e],p=X[e];if(!i||!d||!s||!f||!p)return null;const y=d.BYTES_PER_ELEMENT,a=n*t,l=E(a*p);if(!l)return null;c.wasmCallCount++,A();let m;if(e==="float16"?m=C(r,u):m=b(r.data,r.isWasmBacked,r.wasmPtr,r.offset,u,y),i(m,l.ptr,n,o,t),e==="float16"){const B=q(l,a);return l.release(),B?_.fromWasmRegion([a],"float16",B,a,Uint16Array):null}return _.fromWasmRegion([a],f,l,a,s)}function or(r,n,o,t){if(!r.isCContiguous)return null;const u=w(r.dtype);if(u!=="complex128"&&u!=="complex64")return null;const e=n*o*t;if(e<T*c.thresholdMultiplier)return null;const i=u==="complex128",d=i?8:4,s=n*t,f=s*2,p=f*d,y=E(p);if(!y)return null;c.wasmCallCount++,A();const a=b(r.data,r.isWasmBacked,r.wasmPtr,r.offset,e*2,d);i?K(a,y.ptr,n,o,t):j(a,y.ptr,n,o,t);const l=i?Float64Array:Float32Array;return _.fromWasmRegion([s],u,y,f,l)}export{er as wasmReduceProd,ur as wasmReduceProdStrided,or as wasmReduceProdStridedComplex};

package/dist/esm/common/wasm/reduce_quantile.js

@@ -1 +1 @@
-import{reduce_quantile_f64 as l}from"./bins/reduce_quantile.wasm.js";import{ensureMemory as u,resetAllocator as y,copyIn as p,f16ToF32Input as m}from"./runtime.js";import{isBigIntDType as d,isComplexDType as c}from"../dtype.js";import{wasmConfig as A}from"./config.js";const g=64;function F(r,i){if(!r.isCContiguous||c(r.dtype))return null;const t=r.size;if(t<g*A.thresholdMultiplier)return null;const s=new Float64Array(t),n=r.offset,a=r.data;if(r.dtype==="float64")s.set(a.subarray(n,n+t));else if(r.dtype==="float16"){const o=m(a.subarray(n,n+t),r.dtype);for(let e=0;e<t;e++)s[e]=o[e]}else if(d(r.dtype)){const o=a;for(let e=0;e<t;e++)s[e]=Number(o[n+e])}else for(let o=0;o<t;o++)s[o]=Number(a[n+o]);u(t*8),y();const f=p(s);return l(f,t,i)}export{F as wasmReduceQuantile};
+import{sort_f64 as E,sort_f32 as H,sort_f16 as V,sort_i64 as L,sort_u64 as j,sort_i32 as G,sort_u32 as J,sort_i16 as X,sort_u16 as Y,sort_i8 as Z,sort_u8 as $,sort_slices_f64 as q,sort_slices_f32 as z,sort_slices_f16 as x,sort_slices_i64 as tt,sort_slices_u64 as rt,sort_slices_i32 as nt,sort_slices_u32 as et,sort_slices_i16 as ot,sort_slices_u16 as st,sort_slices_i8 as ct,sort_slices_u8 as ut}from"./bins/sort.wasm.js";import{resetScratchAllocator as C,resolveInputPtr as D,scratchAlloc as _,getSharedMemory as d,wasmMalloc as it}from"./runtime.js";import{ArrayStorage as lt}from"../storage.js";import{effectiveDType as U,isComplexDType as R,getDTypeSize as F}from"../dtype.js";import{wasmConfig as S}from"./config.js";const g=64,K={float64:E,float32:H,float16:V,int64:L,uint64:j,int32:G,uint32:J},M={int16:X,uint16:Y,int8:Z,uint8:$},at={float64:q,float32:z,float16:x,int64:tt,uint64:rt,int32:nt,uint32:et,int16:ot,uint16:st,int8:ct,uint8:ut};function B(t,s,n,e){const i=F(e),r=s+n*i;switch(e){case"float64":return new Float64Array(t,r,1)[0];case"float32":return new Float32Array(t,r,1)[0];case"float16":return new Float16Array(t,r,1)[0];case"int64":return Number(new BigInt64Array(t,r,1)[0]);case"uint64":return Number(new BigUint64Array(t,r,1)[0]);case"int32":return new Int32Array(t,r,1)[0];case"uint32":return new Uint32Array(t,r,1)[0];case"int16":return new Int16Array(t,r,1)[0];case"uint16":return new Uint16Array(t,r,1)[0];case"int8":return new Int8Array(t,r,1)[0];case"uint8":return new Uint8Array(t,r,1)[0];default:return 0}}function T(t,s,n,e,i){const r=e*(n-1),c=Math.floor(r),f=Math.ceil(r);if(c===f)return B(t,s,c,i);const u=r-c,y=B(t,s,c,i),o=B(t,s,f,i);return y*(1-u)+o*u}function pt(t,s){if(!t.isCContiguous)return null;const n=U(t.dtype);if(R(n))return null;const e=t.size;if(e<g*S.thresholdMultiplier)return null;const i=K[n],r=M[n];if(!i&&!r)return null;const c=F(n);S.wasmCallCount++,C();const f=D(t.data,t.isWasmBacked,t.wasmPtr,t.offset,e,c);let u;if(t.isWasmBacked&&t.offset===0){const o=e*c;u=_(o);const b=d();new Uint8Array(b.buffer,u,o).set(new Uint8Array(b.buffer,f,o))}else u=f;if(r){const o=_(e*c);r(u,e,o)}else i(u,e);const y=d();return T(y.buffer,u,e,s,n)}function _t(t,s,n,e,i){if(!t.isCContiguous)return null;const r=U(t.dtype);if(R(r))return null;const c=s*n*e;if(c<g*S.thresholdMultiplier)return null;const f=at[r],u=K[r],y=M[r];if(!u&&!y)return null;const o=F(r),b=s*e,v=b*8,P=it(v);if(!P)return null;S.wasmCallCount++,C();const W=D(t.data,t.isWasmBacked,t.wasmPtr,t.offset,c,o);let m;if(t.isWasmBacked&&t.offset===0){const l=c*o;m=_(l);const a=d();new Uint8Array(a.buffer,m,l).set(new Uint8Array(a.buffer,W,l))}else m=W;const p=d(),k=new Float64Array(p.buffer,P.ptr,b);if(e===1&&f){f(m,n,s);for(let l=0;l<s;l++){const a=m+l*n*o;k[l]=T(p.buffer,a,n,i,r)}}else{const l=n*o,a=_(l),I=n*e;for(let h=0;h<s;h++)for(let A=0;A<e;A++){const N=m+(h*I+A)*o,O=new Uint8Array(p.buffer,a,l);for(let w=0;w<n;w++){const Q=N+w*e*o;O.set(new Uint8Array(p.buffer,Q,o),w*o)}if(y){const w=_(n*o);y(a,n,w)}else u(a,n);k[h*e+A]=T(p.buffer,a,n,i,r)}}return lt.fromWasmRegion([b],"float64",P,b,Float64Array)}export{pt as wasmReduceQuantile,_t as wasmReduceQuantileStrided};

package/dist/esm/common/wasm/reduce_std.js

@@ -1 +1 @@
-import{reduce_std_f64 as s,reduce_std_f32 as y,reduce_std_i64 as c,reduce_std_i32 as _,reduce_std_i16 as l,reduce_std_i8 as p,reduce_std_u64 as A,reduce_std_u32 as f,reduce_std_u16 as m,reduce_std_u8 as T}from"./bins/reduce_std.wasm.js";import{ensureMemory as E,resetAllocator as b,copyIn as R}from"./runtime.js";import{wasmConfig as g}from"./config.js";const S=64,C={float64:s,float32:y,int64:c,uint64:A,int32:_,uint32:f,int16:l,uint16:m,int8:p,uint8:T},P={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function F(r){if(!r.isCContiguous)return null;const t=r.size;if(t<S*g.thresholdMultiplier)return null;const e=r.dtype,n=C[e],o=P[e];if(!n||!o)return null;const i=o.BYTES_PER_ELEMENT;E(t*i),b();const u=r.offset,a=r.data.subarray(u,u+t),d=R(a);return Number(n(d,t))}export{F as wasmReduceStd};
+import{reduce_std_f64 as d,reduce_std_f32 as s,reduce_std_i64 as y,reduce_std_i32 as c,reduce_std_i16 as l,reduce_std_i8 as _,reduce_std_u64 as p,reduce_std_u32 as m,reduce_std_u16 as A,reduce_std_u8 as f}from"./bins/reduce_std.wasm.js";import{resetScratchAllocator as E,resolveInputPtr as T}from"./runtime.js";import{wasmConfig as u}from"./config.js";const b=64,g={float64:d,float32:s,int64:y,uint64:p,int32:c,uint32:m,int16:l,uint16:A,int8:_,uint8:f},C={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function I(t){if(!t.isCContiguous)return null;const r=t.size;if(r<b*u.thresholdMultiplier)return null;const e=t.dtype,n=g[e],i=C[e];if(!n||!i)return null;const o=i.BYTES_PER_ELEMENT;u.wasmCallCount++,E();const a=T(t.data,t.isWasmBacked,t.wasmPtr,t.offset,r,o);return Number(n(a,r))}export{I as wasmReduceStd};

package/dist/esm/common/wasm/reduce_sum.js

@@ -1 +1 @@
-import{reduce_sum_f64 as S,reduce_sum_f32 as g,reduce_sum_i64 as m,reduce_sum_i32 as _,reduce_sum_strided_f64 as w,reduce_sum_strided_f32 as B,reduce_sum_strided_i64 as C,reduce_sum_strided_i32 as M,reduce_sum_strided_i16 as D,reduce_sum_strided_i8 as F,reduce_sum_strided_u64 as k,reduce_sum_strided_u32 as I,reduce_sum_strided_u16 as N,reduce_sum_strided_u8 as h}from"./bins/reduce_sum.wasm.js";import{ensureMemory as l,resetAllocator as f,copyIn as p,alloc as L,copyOut as O}from"./runtime.js";import{ArrayStorage as U}from"../storage.js";import{wasmConfig as A}from"./config.js";const b=64,Y={float64:S,float32:g,int64:m,uint64:m,int32:_,uint32:_},E={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function q(r){if(!r.isCContiguous)return null;const t=r.size;if(t<b*A.thresholdMultiplier)return null;const u=r.dtype,e=Y[u],n=E[u];if(!e||!n)return null;const s=n.BYTES_PER_ELEMENT;l(t*s),f();const o=r.offset,i=r.data.subarray(o,o+t),d=p(i);return Number(e(d,t))}const x={float64:w,float32:B,int64:C,uint64:k,int32:M,uint32:I,int16:D,uint16:N,int8:F,uint8:h};function G(r,t,u,e){if(!r.isCContiguous)return null;const n=t*u*e;if(n<b*A.thresholdMultiplier)return null;const s=r.dtype,o=x[s],i=E[s];if(!o||!i)return null;const d=i.BYTES_PER_ELEMENT,a=t*e;l(n*d+a*8),f();const c=r.offset,T=r.data.subarray(c,c+n),R=p(T),y=L(a*8);o(R,y,t,u,e);const P=O(y,a,Float64Array);return U.fromData(P,[a],"float64")}export{q as wasmReduceSum,G as wasmReduceSumStrided};
+import{reduce_sum_f64 as S,reduce_sum_f32 as F,reduce_sum_i64 as b,reduce_sum_i32 as C,reduce_sum_i8_to_i64 as h,reduce_sum_i16_to_i64 as k,reduce_sum_u8_to_u64 as M,reduce_sum_u16_to_u64 as x,reduce_sum_strided_f64 as I,reduce_sum_strided_f32 as w,reduce_sum_strided_i64 as N,reduce_sum_strided_i32 as D,reduce_sum_strided_i16 as W,reduce_sum_strided_i8 as L,reduce_sum_strided_u64 as U,reduce_sum_strided_u32 as Y,reduce_sum_strided_u16 as v,reduce_sum_strided_u8 as H,reduce_sum_c128 as K,reduce_sum_c64 as O,reduce_sum_strided_c128 as j,reduce_sum_strided_c64 as q}from"./bins/reduce_sum.wasm.js";import{resetScratchAllocator as f,resolveInputPtr as _,f16InputToScratchF32 as E,scratchAlloc as G,getSharedMemory as T,wasmMalloc as g}from"./runtime.js";import{ArrayStorage as P}from"../storage.js";import{effectiveDType as y}from"../dtype.js";import{wasmConfig as m}from"./config.js";const p=64,J={float64:S,float32:F,int64:b,uint64:b,int32:C,uint32:C,int16:k,uint16:x,int8:h,uint8:M},B={float64:Float64Array,float32:Float32Array,float16:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function tr(r){if(!r.isCContiguous)return null;const t=r.size;if(t<p*m.thresholdMultiplier)return null;const n=y(r.dtype),e=J[n],u=B[n];if(!e||!u)return null;if(m.wasmCallCount++,f(),n==="float16"){const i=E(r,t);return Number(e(i,t))}const s=u.BYTES_PER_ELEMENT,o=_(r.data,r.isWasmBacked,r.wasmPtr,r.offset,t,s);return Number(e(o,t))}function er(r){if(!r.isCContiguous)return null;const t=y(r.dtype);if(t!=="complex128"&&t!=="complex64")return null;const n=r.size;if(n<p*m.thresholdMultiplier)return null;const e=t==="complex128",u=e?8:4;m.wasmCallCount++,f();const s=_(r.data,r.isWasmBacked,r.wasmPtr,r.offset,n*2,u),o=G(e?16:8);if(e){K(s,n,o);const i=T(),l=new Float64Array(i.buffer,o,2);return[l[0],l[1]]}else{O(s,n,o);const i=T(),l=new Float32Array(i.buffer,o,2);return[l[0],l[1]]}}const Q={float64:I,float32:w,float16:w,int64:N,uint64:U,int32:D,uint32:Y,int16:W,uint16:v,int8:L,uint8:H};function nr(r,t,n,e){if(!r.isCContiguous)return null;const u=t*n*e;if(u<p*m.thresholdMultiplier)return null;const s=y(r.dtype),o=Q[s],i=B[s];if(!o||!i)return null;const l=i.BYTES_PER_ELEMENT,c=t*e,d=g(c*8);if(!d)return null;m.wasmCallCount++,f();let a;return s==="float16"?a=E(r,u):a=_(r.data,r.isWasmBacked,r.wasmPtr,r.offset,u,l),o(a,d.ptr,t,n,e),P.fromWasmRegion([c],"float64",d,c,Float64Array)}function ur(r,t,n,e){if(!r.isCContiguous)return null;const u=y(r.dtype);if(u!=="complex128"&&u!=="complex64")return null;const s=t*n*e;if(s<p*m.thresholdMultiplier)return null;const o=u==="complex128",i=o?8:4,l=t*e,c=l*2,d=c*i,a=g(d);if(!a)return null;m.wasmCallCount++,f();const A=_(r.data,r.isWasmBacked,r.wasmPtr,r.offset,s*2,i);o?j(A,a.ptr,t,n,e):q(A,a.ptr,t,n,e);const R=o?Float64Array:Float32Array;return P.fromWasmRegion([l],u,a,c,R)}export{tr as wasmReduceSum,er as wasmReduceSumComplex,nr as wasmReduceSumStrided,ur as wasmReduceSumStridedComplex};

package/dist/esm/common/wasm/reduce_var.js

@@ -1 +1 @@
-import{reduce_var_f64 as c,reduce_var_f32 as s,reduce_var_i64 as d,reduce_var_i32 as _,reduce_var_i16 as l,reduce_var_i8 as p,reduce_var_u64 as A,reduce_var_u32 as f,reduce_var_u16 as m,reduce_var_u8 as T}from"./bins/reduce_var.wasm.js";import{ensureMemory as E,resetAllocator as b,copyIn as v}from"./runtime.js";import{wasmConfig as R}from"./config.js";const g=64,C={float64:c,float32:s,int64:d,uint64:A,int32:_,uint32:f,int16:l,uint16:m,int8:p,uint8:T},P={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function D(r){if(!r.isCContiguous)return null;const t=r.size;if(t<g*R.thresholdMultiplier)return null;const e=r.dtype,n=C[e],a=P[e];if(!n||!a)return null;const u=a.BYTES_PER_ELEMENT;E(t*u),b();const o=r.offset,i=r.data.subarray(o,o+t),y=v(i);return Number(n(y,t))}export{D as wasmReduceVar};
+import{reduce_var_f64 as y,reduce_var_f32 as c,reduce_var_i64 as l,reduce_var_i32 as s,reduce_var_i16 as d,reduce_var_i8 as _,reduce_var_u64 as p,reduce_var_u32 as m,reduce_var_u16 as A,reduce_var_u8 as f}from"./bins/reduce_var.wasm.js";import{resetScratchAllocator as E,resolveInputPtr as T}from"./runtime.js";import{wasmConfig as i}from"./config.js";const v=64,b={float64:y,float32:c,int64:l,uint64:p,int32:s,uint32:m,int16:d,uint16:A,int8:_,uint8:f},g={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function B(r){if(!r.isCContiguous)return null;const t=r.size;if(t<v*i.thresholdMultiplier)return null;const e=r.dtype,n=b[e],a=g[e];if(!n||!a)return null;const u=a.BYTES_PER_ELEMENT;i.wasmCallCount++,E();const o=T(r.data,r.isWasmBacked,r.wasmPtr,r.offset,t,u);return Number(n(o,t))}export{B as wasmReduceVar};

package/dist/esm/common/wasm/repeat.js

@@ -1 +1 @@
-import{repeat_f64 as g,repeat_f32 as c,repeat_i64 as m,repeat_i32 as T,repeat_i16 as d,repeat_i8 as b}from"./bins/repeat.wasm.js";import{ensureMemory as B,resetAllocator as F,copyIn as P,alloc as R,copyOut as S,f16ToF32Input as D,f32ToF16Output as w}from"./runtime.js";import{ArrayStorage as C}from"../storage.js";import{wasmConfig as I}from"./config.js";const M=64,k={float64:g,float32:c,int64:m,uint64:m,int32:T,uint32:T,int16:d,uint16:d,int8:b,uint8:b,float16:c},O={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array,float16:Float32Array};function N(r,i){if(!r.isCContiguous)return null;const n=r.size;if(n<M*I.thresholdMultiplier)return null;const t=r.dtype,u=k[t],e=O[t];if(!u||!e)return null;const o=n*i,y=e.BYTES_PER_ELEMENT,E=n*y,p=o*y;B(E+p),F();const s=t==="float16",f=r.offset;let a=r.data.subarray(f,f+n);s&&(a=D(a,t));const _=P(a),l=R(p);u(_,l,n,i);const A=S(l,o,e);return C.fromData(s?w(A,t):A,[o],t)}export{N as wasmRepeat};
+import{repeat_f64 as w,repeat_f32 as E,repeat_i64 as f,repeat_i32 as l,repeat_i16 as y,repeat_i8 as p}from"./bins/repeat.wasm.js";import{wasmMalloc as P,resetScratchAllocator as R,resolveInputPtr as m}from"./runtime.js";import{ArrayStorage as A}from"../storage.js";import{effectiveDType as _}from"../dtype.js";import{wasmConfig as c}from"./config.js";const B=64,C={float64:w,float32:E,int64:f,uint64:f,int32:l,uint32:l,int16:y,uint16:y,int8:p,uint8:p,float16:y},F={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array,float16:typeof Float16Array<"u"?Float16Array:Float32Array};function U(r,o){if(!r.isCContiguous)return null;const t=r.size;if(t<B*c.thresholdMultiplier)return null;const e=_(r.dtype),i=C[e],u=F[e];if(!i||!u)return null;const n=t*o,s=u.BYTES_PER_ELEMENT,d=n*s,b=e==="float16",a=P(d);if(!a)return null;if(c.wasmCallCount++,R(),b){const g=m(r.data,r.isWasmBacked,r.wasmPtr,r.offset,t,2);return i(g,a.ptr,t,o),A.fromWasmRegion([n],e,a,n,Float16Array)}const T=m(r.data,r.isWasmBacked,r.wasmPtr,r.offset,t,s);return i(T,a.ptr,t,o),A.fromWasmRegion([n],e,a,n,u)}export{U as wasmRepeat};

package/dist/esm/common/wasm/right_shift.js

@@ -1 +1 @@
-import{right_shift_i64 as C,right_shift_i32 as w,right_shift_i16 as R,right_shift_i8 as M,right_shift_u64 as O,right_shift_u32 as k,right_shift_u16 as N,right_shift_u8 as I,right_shift_scalar_i64 as L,right_shift_scalar_i32 as z,right_shift_scalar_i16 as F,right_shift_scalar_i8 as U,right_shift_scalar_u64 as Y,right_shift_scalar_u32 as v,right_shift_scalar_u16 as x,right_shift_scalar_u8 as H}from"./bins/right_shift.wasm.js";import{ensureMemory as m,resetAllocator as g,copyIn as h,alloc as A,copyOut as b}from"./runtime.js";import{ArrayStorage as d}from"../storage.js";import{promoteDTypes as K}from"../dtype.js";import{wasmConfig as T}from"./config.js";const E=64,j={int64:C,uint64:O,int32:w,uint32:k,int16:R,uint16:N,int8:M,uint8:I},q={int64:L,uint64:Y,int32:z,uint32:v,int16:F,uint16:x,int8:U,uint8:H},P={int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function X(r,i){if(!r.isCContiguous||!i.isCContiguous)return null;const t=r.size;if(t<E*T.thresholdMultiplier)return null;const n=K(r.dtype,i.dtype),s=j[n],a=P[n];if(!s||!a)return null;const e=a.BYTES_PER_ELEMENT,l=t*e,u=t*e,o=t*e;m(l+u+o),g();const y=r.offset,f=i.offset,c=r.data.subarray(y,y+t),_=i.data.subarray(f,f+t),S=h(c),B=h(_),p=A(o);s(S,B,p,t);const D=b(p,t,a);return d.fromData(D,Array.from(r.shape),n)}function Z(r,i){if(!r.isCContiguous)return null;const t=r.size;if(t<E*T.thresholdMultiplier)return null;const n=r.dtype,s=q[n],a=P[n];if(!s||!a)return null;const e=a.BYTES_PER_ELEMENT,l=t*e,u=t*e;m(l+u),g();const o=r.offset,y=r.data.subarray(o,o+t),f=h(y),c=A(u);s(f,c,t,i);const _=b(c,t,a);return d.fromData(_,Array.from(r.shape),n)}export{X as wasmRightShift,Z as wasmRightShiftScalar};
+import{right_shift_i64 as A,right_shift_i32 as d,right_shift_i16 as E,right_shift_i8 as T,right_shift_u64 as P,right_shift_u32 as b,right_shift_u16 as S,right_shift_u8 as w,right_shift_scalar_i64 as B,right_shift_scalar_i32 as C,right_shift_scalar_i16 as R,right_shift_scalar_i8 as k,right_shift_scalar_u64 as M,right_shift_scalar_u32 as z,right_shift_scalar_u16 as D,right_shift_scalar_u8 as N}from"./bins/right_shift.wasm.js";import{wasmMalloc as _,resetScratchAllocator as c,resolveInputPtr as y}from"./runtime.js";import{ArrayStorage as h}from"../storage.js";import{promoteDTypes as I}from"../dtype.js";import{wasmConfig as u}from"./config.js";const m=64,L={int64:A,uint64:P,int32:d,uint32:b,int16:E,uint16:S,int8:T,uint8:w},W={int64:B,uint64:M,int32:C,uint32:z,int16:R,uint16:D,int8:k,uint8:N},p={int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function x(t,n){if(!t.isCContiguous||!n.isCContiguous||t.dtype!==n.dtype||t.size!==n.size)return null;const r=t.size;if(r<m*u.thresholdMultiplier)return null;const i=I(t.dtype,n.dtype),o=L[i],e=p[i];if(!o||!e)return null;const a=e.BYTES_PER_ELEMENT,l=r*a,s=_(l);if(!s)return null;u.wasmCallCount++,c();const f=y(t.data,t.isWasmBacked,t.wasmPtr,t.offset,r,a),g=y(n.data,n.isWasmBacked,n.wasmPtr,n.offset,r,a);return o(f,g,s.ptr,r),h.fromWasmRegion(Array.from(t.shape),i,s,r,e)}function H(t,n){if(!t.isCContiguous)return null;const r=t.size;if(r<m*u.thresholdMultiplier)return null;const i=t.dtype,o=W[i],e=p[i];if(!o||!e)return null;const a=e.BYTES_PER_ELEMENT,l=r*a,s=_(l);if(!s)return null;u.wasmCallCount++,c();const f=y(t.data,t.isWasmBacked,t.wasmPtr,t.offset,r,a);return o(f,s.ptr,r,n),h.fromWasmRegion(Array.from(t.shape),i,s,r,e)}export{x as wasmRightShift,H as wasmRightShiftScalar};

package/dist/esm/common/wasm/rng.js

@@ -1 +1 @@
-import{mt19937_init as c,mt19937_genrand as f,mt19937_random_f64 as p,mt19937_get_state as _,mt19937_set_state as y,seed_sequence as d,pcg64_init_from_ss as g,pcg64_bounded_uint64 as x,pcg64_random_f64 as A,pcg64_get_state as F,pcg64_set_state_ptr as B,standard_normal_pcg as T,standard_exponential_pcg as P,legacy_gauss as S,legacy_standard_exponential as U,legacy_gauss_reset as G,legacy_standard_gamma as E,fill_uniform_f64_mt as I,fill_uniform_f64_pcg as v,fill_standard_normal_pcg as C,fill_standard_exponential_pcg as h,fill_legacy_gauss as L,fill_legacy_standard_exponential as R,fill_rk_interval as w,fill_legacy_standard_gamma as M,fill_legacy_chisquare as N,fill_pareto as k,fill_power as q,fill_weibull as O,fill_logistic as W,fill_gumbel as Y,fill_laplace as z,fill_rayleigh as H,fill_triangular as V,fill_standard_cauchy as Z,fill_lognormal as j,fill_wald as D,fill_standard_t as J,fill_beta as K,fill_f as Q,fill_noncentral_chisquare as X,fill_noncentral_f as $,fill_geometric as rr,fill_poisson as nr,fill_binomial as tr,fill_negative_binomial as er,fill_hypergeometric as lr,fill_logseries as or,fill_zipf as ar,fill_vonmises as ir,fill_randint_i64 as ur,fill_randint_u8 as mr,fill_randint_u16 as br,fill_permutation as sr,fill_permutation_pcg as cr,fill_bounded_uint64_pcg as fr}from"./bins/rng.wasm.js";import{ensureMemory as i,resetAllocator as u,alloc as m,copyOut as b,copyIn as s}from"./runtime.js";function l(r,n,t){const e=n.BYTES_PER_ELEMENT,o=r*e;i(o),u();const a=m(o);return t(a,r),b(a,r,n)}function yr(r){c(r>>>0)}function dr(){return f()}function gr(){return p()}function xr(){i(624*4),u();const r=m(624*4),n=_(r);return{mt:b(r,624,Uint32Array),mti:n}}function Ar(r,n){i(624*4),u();const t=s(r);y(t,n)}function Fr(r){i(32),u();const n=m(32);d(r>>>0,n,8),g(n)}function Br(){return A()}function Tr(r,n){return x(r,n)}function Pr(){return l(6,BigUint64Array,(r,n)=>F(r))}function Sr(r){i(48),u();const n=s(r);B(n)}const Ur=T,Gr=P,Er=S,Ir=U,vr=G,Cr=E,hr=r=>l(r,Float64Array,I),Lr=r=>l(r,Float64Array,v),Rr=r=>l(r,Float64Array,C),wr=r=>l(r,Float64Array,h),Mr=r=>l(r,Float64Array,L),Nr=r=>l(r,Float64Array,R),kr=r=>l(r,Float64Array,Z),qr=r=>l(r,Float64Array,sr),Or=r=>l(r,BigInt64Array,cr),Wr=(r,n)=>l(r,Float64Array,(t,e)=>M(t,e,n)),Yr=(r,n)=>l(r,Float64Array,(t,e)=>N(t,e,n)),zr=(r,n)=>l(r,Float64Array,(t,e)=>k(t,e,n)),Hr=(r,n)=>l(r,Float64Array,(t,e)=>q(t,e,n)),Vr=(r,n)=>l(r,Float64Array,(t,e)=>O(t,e,n)),Zr=(r,n,t)=>l(r,Float64Array,(e,o)=>W(e,o,n,t)),jr=(r,n,t)=>l(r,Float64Array,(e,o)=>Y(e,o,n,t)),Dr=(r,n,t)=>l(r,Float64Array,(e,o)=>z(e,o,n,t)),Jr=(r,n)=>l(r,Float64Array,(t,e)=>H(t,e,n)),Kr=(r,n,t,e)=>l(r,Float64Array,(o,a)=>V(o,a,n,t,e)),Qr=(r,n,t)=>l(r,Float64Array,(e,o)=>j(e,o,n,t)),Xr=(r,n,t)=>l(r,Float64Array,(e,o)=>D(e,o,n,t)),$r=(r,n)=>l(r,Float64Array,(t,e)=>J(t,e,n)),rn=(r,n,t)=>l(r,Float64Array,(e,o)=>K(e,o,n,t)),nn=(r,n,t)=>l(r,Float64Array,(e,o)=>Q(e,o,n,t)),tn=(r,n,t)=>l(r,Float64Array,(e,o)=>X(e,o,n,t)),en=(r,n,t,e)=>l(r,Float64Array,(o,a)=>$(o,a,n,t,e)),ln=(r,n,t)=>l(r,Float64Array,(e,o)=>ir(e,o,n,t)),on=(r,n)=>l(r,BigInt64Array,(t,e)=>rr(t,e,n)),an=(r,n)=>l(r,BigInt64Array,(t,e)=>nr(t,e,n)),un=(r,n,t)=>l(r,BigInt64Array,(e,o)=>tr(e,o,n,t)),mn=(r,n,t)=>l(r,BigInt64Array,(e,o)=>er(e,o,n,t)),bn=(r,n,t,e)=>l(r,BigInt64Array,(o,a)=>lr(o,a,n,t,e)),sn=(r,n)=>l(r,BigInt64Array,(t,e)=>or(t,e,n)),cn=(r,n)=>l(r,BigInt64Array,(t,e)=>ar(t,e,n)),fn=(r,n)=>l(r,Uint32Array,(t,e)=>w(t,e,n)),pn=(r,n,t)=>l(r,BigInt64Array,(e,o)=>ur(e,o,n,t)),_n=(r,n,t)=>l(r,Uint8Array,(e,o)=>mr(e,o,n,t)),yn=(r,n,t)=>l(r,Uint16Array,(e,o)=>br(e,o,n,t)),dn=(r,n,t)=>l(r,BigInt64Array,(e,o)=>fr(e,o,n,t));export{rn as fillBeta,un as fillBinomial,dn as fillBoundedUint64PCG,nn as fillF,on as fillGeometric,jr as fillGumbel,bn as fillHypergeometric,Dr as fillLaplace,Yr as fillLegacyChisquare,Mr as fillLegacyGauss,Nr as fillLegacyStandardExponential,Wr as fillLegacyStandardGamma,Zr as fillLogistic,Qr as fillLognormal,sn as fillLogseries,mn as fillNegativeBinomial,tn as fillNoncentralChisquare,en as fillNoncentralF,zr as fillPareto,qr as fillPermutation,Or as fillPermutationPCG,an as fillPoisson,Hr as fillPower,pn as fillRandintI64,yn as fillRandintU16,_n as fillRandintU8,Jr as fillRayleigh,fn as fillRkInterval,kr as fillStandardCauchy,wr as fillStandardExponentialPCG,Rr as fillStandardNormalPCG,$r as fillStandardT,Kr as fillTriangular,hr as fillUniformF64MT,Lr as fillUniformF64PCG,ln as fillVonmises,Xr as fillWald,Vr as fillWeibull,cn as fillZipf,xr as getMT19937State,yr as initMT19937,Fr as initPCG64FromSeed,Er as legacyGauss,vr as legacyGaussReset,Ir as legacyStandardExponential,gr as mt19937Float64,dr as mt19937Uint32,Tr as pcg64BoundedUint64,Br as pcg64Float64,Sr as pcg64RestoreState,Pr as pcg64SaveState,Ar as setMT19937State,Gr as standardExponentialPCG,Ur as standardNormalPCG,Cr as wasmLegacyStandardGamma};
+import{mt19937_init as $,mt19937_genrand as rr,mt19937_random_f64 as nr,mt19937_get_state as ar,mt19937_set_state as er,seed_sequence as tr,pcg64_init_from_ss as lr,pcg64_bounded_uint64 as ir,pcg64_random_f64 as or,pcg64_get_state as ur,pcg64_set_state_ptr as mr,standard_normal_pcg as sr,standard_exponential_pcg as cr,legacy_gauss as br,legacy_standard_exponential as fr,legacy_gauss_reset as pr,legacy_standard_gamma as _r,fill_uniform_f64_mt as c,fill_uniform_f64_pcg as b,fill_standard_normal_pcg as f,fill_standard_exponential_pcg as p,fill_legacy_gauss as _,fill_legacy_standard_exponential as y,fill_rk_interval as d,fill_legacy_standard_gamma as g,fill_legacy_chisquare as F,fill_pareto as x,fill_power as w,fill_weibull as A,fill_logistic as C,fill_gumbel as P,fill_laplace as B,fill_rayleigh as T,fill_triangular as U,fill_standard_cauchy as G,fill_lognormal as S,fill_wald as h,fill_standard_t as L,fill_beta as v,fill_f as E,fill_noncentral_chisquare as I,fill_noncentral_f as R,fill_geometric as N,fill_poisson as k,fill_binomial as M,fill_negative_binomial as q,fill_hypergeometric as W,fill_logseries as H,fill_zipf as V,fill_vonmises as Y,fill_randint_i64 as Z,fill_randint_u8 as z,fill_randint_u16 as O,fill_permutation as j,fill_permutation_pcg as D,fill_bounded_uint64_pcg as J}from"./bins/rng.wasm.js";import{resetScratchAllocator as u,scratchAlloc as m,scratchCopyIn as K,getSharedMemory as Q}from"./runtime.js";import{wasmConfig as o}from"./config.js";function l(r,n,a){const e=n.BYTES_PER_ELEMENT,t=r*e;o.wasmCallCount++,u();const i=m(t);a(i,r);const X=Q(),s=new n(new ArrayBuffer(t),0,r);return new Uint8Array(s.buffer,0,t).set(new Uint8Array(X.buffer,i,t)),s}function Fr(r,n,a){o.wasmCallCount++,a(r,n)}function xr(r){$(r>>>0)}function wr(){return rr()}function Ar(){return nr()}function Cr(){o.wasmCallCount++,u();const r=m(624*4),n=ar(r),a=Q(),e=new Uint32Array(624);return new Uint8Array(e.buffer,0,624*4).set(new Uint8Array(a.buffer,r,624*4)),{mt:e,mti:n}}function Pr(r,n){o.wasmCallCount++,u();const a=K(r);er(a,n)}function Br(r){o.wasmCallCount++,u();const n=m(32);tr(r>>>0,n,8),lr(n)}function Tr(){return or()}function Ur(r,n){return ir(r,n)}function Gr(){return l(6,BigUint64Array,(r,n)=>ur(r))}function Sr(r){o.wasmCallCount++,u();const n=K(r);mr(n)}const hr=sr,Lr=cr,vr=br,Er=fr,Ir=pr,Rr=_r,Nr=r=>l(r,Float64Array,c),kr=r=>l(r,Float64Array,b),Mr=r=>l(r,Float64Array,f),qr=r=>l(r,Float64Array,p),Wr=r=>l(r,Float64Array,_),Hr=r=>l(r,Float64Array,y),Vr=r=>l(r,Float64Array,G),Yr=r=>l(r,Float64Array,j),Zr=r=>l(r,BigInt64Array,D),zr=(r,n)=>l(r,Float64Array,(a,e)=>g(a,e,n)),Or=(r,n)=>l(r,Float64Array,(a,e)=>F(a,e,n)),jr=(r,n)=>l(r,Float64Array,(a,e)=>x(a,e,n)),Dr=(r,n)=>l(r,Float64Array,(a,e)=>w(a,e,n)),Jr=(r,n)=>l(r,Float64Array,(a,e)=>A(a,e,n)),Kr=(r,n,a)=>l(r,Float64Array,(e,t)=>C(e,t,n,a)),Qr=(r,n,a)=>l(r,Float64Array,(e,t)=>P(e,t,n,a)),Xr=(r,n,a)=>l(r,Float64Array,(e,t)=>B(e,t,n,a)),$r=(r,n)=>l(r,Float64Array,(a,e)=>T(a,e,n)),rn=(r,n,a,e)=>l(r,Float64Array,(t,i)=>U(t,i,n,a,e)),nn=(r,n,a)=>l(r,Float64Array,(e,t)=>S(e,t,n,a)),an=(r,n,a)=>l(r,Float64Array,(e,t)=>h(e,t,n,a)),en=(r,n)=>l(r,Float64Array,(a,e)=>L(a,e,n)),tn=(r,n,a)=>l(r,Float64Array,(e,t)=>v(e,t,n,a)),ln=(r,n,a)=>l(r,Float64Array,(e,t)=>E(e,t,n,a)),on=(r,n,a)=>l(r,Float64Array,(e,t)=>I(e,t,n,a)),un=(r,n,a,e)=>l(r,Float64Array,(t,i)=>R(t,i,n,a,e)),mn=(r,n,a)=>l(r,Float64Array,(e,t)=>Y(e,t,n,a)),sn=(r,n)=>l(r,BigInt64Array,(a,e)=>N(a,e,n)),cn=(r,n)=>l(r,BigInt64Array,(a,e)=>k(a,e,n)),bn=(r,n,a)=>l(r,BigInt64Array,(e,t)=>M(e,t,n,a)),fn=(r,n,a)=>l(r,BigInt64Array,(e,t)=>q(e,t,n,a)),pn=(r,n,a,e)=>l(r,BigInt64Array,(t,i)=>W(t,i,n,a,e)),_n=(r,n)=>l(r,BigInt64Array,(a,e)=>H(a,e,n)),yn=(r,n)=>l(r,BigInt64Array,(a,e)=>V(a,e,n)),dn=(r,n)=>l(r,Uint32Array,(a,e)=>d(a,e,n)),gn=(r,n,a)=>l(r,BigInt64Array,(e,t)=>Z(e,t,n,a)),Fn=(r,n,a)=>l(r,Uint8Array,(e,t)=>z(e,t,n,a)),xn=(r,n,a)=>l(r,Uint16Array,(e,t)=>O(e,t,n,a)),wn=(r,n,a)=>l(r,BigInt64Array,(e,t)=>J(e,t,n,a));export{Fr as directFill,tn as fillBeta,bn as fillBinomial,wn as fillBoundedUint64PCG,ln as fillF,sn as fillGeometric,Qr as fillGumbel,pn as fillHypergeometric,Xr as fillLaplace,Or as fillLegacyChisquare,Wr as fillLegacyGauss,Hr as fillLegacyStandardExponential,zr as fillLegacyStandardGamma,Kr as fillLogistic,nn as fillLognormal,_n as fillLogseries,fn as fillNegativeBinomial,on as fillNoncentralChisquare,un as fillNoncentralF,jr as fillPareto,Yr as fillPermutation,Zr as fillPermutationPCG,cn as fillPoisson,Dr as fillPower,gn as fillRandintI64,xn as fillRandintU16,Fn as fillRandintU8,$r as fillRayleigh,dn as fillRkInterval,Vr as fillStandardCauchy,qr as fillStandardExponentialPCG,Mr as fillStandardNormalPCG,en as fillStandardT,rn as fillTriangular,Nr as fillUniformF64MT,kr as fillUniformF64PCG,mn as fillVonmises,an as fillWald,Jr as fillWeibull,yn as fillZipf,Cr as getMT19937State,xr as initMT19937,Br as initPCG64FromSeed,vr as legacyGauss,Ir as legacyGaussReset,Er as legacyStandardExponential,Ar as mt19937Float64,wr as mt19937Uint32,Ur as pcg64BoundedUint64,Tr as pcg64Float64,Sr as pcg64RestoreState,Gr as pcg64SaveState,v as rawFillBeta,M as rawFillBinomial,J as rawFillBoundedUint64PCG,E as rawFillF,N as rawFillGeometric,P as rawFillGumbel,W as rawFillHypergeometric,B as rawFillLaplace,F as rawFillLegacyChisquare,_ as rawFillLegacyGauss,y as rawFillLegacyStandardExponential,g as rawFillLegacyStandardGamma,C as rawFillLogistic,S as rawFillLognormal,H as rawFillLogseries,q as rawFillNegativeBinomial,I as rawFillNoncentralChisquare,R as rawFillNoncentralF,x as rawFillPareto,j as rawFillPermutation,D as rawFillPermutationPCG,k as rawFillPoisson,w as rawFillPower,Z as rawFillRandintI64,O as rawFillRandintU16,z as rawFillRandintU8,T as rawFillRayleigh,d as rawFillRkInterval,G as rawFillStandardCauchy,p as rawFillStandardExponentialPCG,f as rawFillStandardNormalPCG,L as rawFillStandardT,U as rawFillTriangular,c as rawFillUniformF64MT,b as rawFillUniformF64PCG,Y as rawFillVonmises,h as rawFillWald,A as rawFillWeibull,V as rawFillZipf,Pr as setMT19937State,Lr as standardExponentialPCG,hr as standardNormalPCG,Rr as wasmLegacyStandardGamma};

package/dist/esm/common/wasm/roll.js

@@ -1 +1 @@
-import{roll_f64 as _,roll_f32 as p,roll_i64 as A,roll_i32 as m,roll_i16 as c,roll_i8 as T}from"./bins/roll.wasm.js";import{ensureMemory as g,resetAllocator as B,copyIn as F,alloc as P,copyOut as R,f16ToF32Input as D,f32ToF16Output as S}from"./runtime.js";import{ArrayStorage as w}from"../storage.js";import{wasmConfig as C}from"./config.js";const I=64,h={float64:_,float32:p,int64:A,uint64:A,int32:m,uint32:m,int16:c,uint16:c,int8:T,uint8:T,float16:p},M={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array,float16:Float32Array};function N(r,d){if(!r.isCContiguous)return null;const t=r.size;if(t<I*C.thresholdMultiplier)return null;const n=r.dtype,e=h[n],o=M[n];if(!e||!o)return null;const l=o.BYTES_PER_ELEMENT,b=t*l,i=t*l;g(b+i),B();const y=n==="float16",u=r.offset;let a=r.data.subarray(u,u+t);y&&(a=D(a,n));const E=F(a),s=P(i);e(E,s,t,d);const f=R(s,t,o);return w.fromData(y?S(f,n):f,Array.from(r.shape),n)}export{N as wasmRoll};
+import{roll_f64 as g,roll_f32 as w,roll_i64 as s,roll_i32 as u,roll_i16 as l,roll_i8 as f}from"./bins/roll.wasm.js";import{wasmMalloc as E,resetScratchAllocator as P,resolveInputPtr as m}from"./runtime.js";import{ArrayStorage as A}from"../storage.js";import{effectiveDType as R}from"../dtype.js";import{wasmConfig as p}from"./config.js";const _=64,B={float64:g,float32:w,int64:s,uint64:s,int32:u,uint32:u,int16:l,uint16:l,int8:f,uint8:f,float16:l},C={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array,float16:typeof Float16Array<"u"?Float16Array:Float32Array};function M(r,i){if(!r.isCContiguous)return null;const t=r.size;if(t<_*p.thresholdMultiplier)return null;const n=R(r.dtype),e=B[n],a=C[n];if(!e||!a)return null;const y=a.BYTES_PER_ELEMENT,c=t*y,d=n==="float16",o=E(c);if(!o)return null;if(p.wasmCallCount++,P(),d){const T=m(r.data,r.isWasmBacked,r.wasmPtr,r.offset,t,2);return e(T,o.ptr,t,i),A.fromWasmRegion(Array.from(r.shape),n,o,t,Float16Array)}const b=m(r.data,r.isWasmBacked,r.wasmPtr,r.offset,t,y);return e(b,o.ptr,t,i),A.fromWasmRegion(Array.from(r.shape),n,o,t,a)}export{M as wasmRoll};

package/dist/esm/common/wasm/runtime.js

@@ -1 +1 @@
-import{hasFloat16 as s}from"../dtype.js";import{wasmConfig as i}from"./config.js";let y=null,f=0,u=0;function a(){return y||(y=new WebAssembly.Memory({initial:17})),y}function l(e){const r=a(),n=u+e,o=r.buffer.byteLength;if(n>o){const t=Math.ceil((n-o)/65536);r.grow(t)}}function A(e=u){f=e,i.wasmCallCount++}function c(e){e>u&&(u=e)}function m(e){const r=f+7&-8;return f=r+e,r}function d(e){const r=m(e.byteLength),n=a();return new Uint8Array(n.buffer,r,e.byteLength).set(new Uint8Array(e.buffer,e.byteOffset,e.byteLength)),r}function T(e,r,n){const o=a(),t=new n(new ArrayBuffer(r*n.BYTES_PER_ELEMENT),0,r);return new Uint8Array(t.buffer,0,t.byteLength).set(new Uint8Array(o.buffer,e,t.byteLength)),t}function w(e,r){return r==="float16"&&s?new Float32Array(e):e}function g(e,r){if(r==="float16"&&s){const n=new Float16Array(e.length);return n.set(e),n}return e}export{m as alloc,d as copyIn,T as copyOut,l as ensureMemory,w as f16ToF32Input,g as f32ToF16Output,a as getSharedMemory,A as resetAllocator,c as setHeapBase};
+import{wasmMemoryConfig as o}from"./config.js";import{heap_init as p,heap_malloc as h,heap_free as d,heap_free_bytes as g}from"./bins/alloc.wasm.js";const B=65536;let b=null,i=0,m=!1,a=0,c=0,l=[];function u(){if(!b){const e=Math.ceil(o.maxMemoryBytes/B);b=new WebAssembly.Memory({initial:e,maximum:e})}return b}function _(e){if(e>i&&(i=e,m)){a=o.maxMemoryBytes-o.scratchBytes;const t=a-i;t>0&&p(i,t),c=a}}function y(){if(m)return;m=!0,u();const e=8*1024*1024;i<e&&(i=e),a=o.maxMemoryBytes-o.scratchBytes;const t=a-i;t>0&&p(i,t),c=a}function F(e){if(m)throw new Error("configureWasm() must be called before any array operations. WASM memory has already been initialized.");if(e.maxMemory!==void 0){if(e.maxMemory<=0)throw new Error("maxMemory must be a positive number of bytes.");o.maxMemoryBytes=e.maxMemory,e.scratchSize===void 0&&(o.scratchBytes=Math.min(Math.floor(e.maxMemory/16),32*1024*1024))}if(e.scratchSize!==void 0){if(e.scratchSize<=0)throw new Error("scratchSize must be a positive number of bytes.");o.scratchBytes=e.scratchSize}}class v{constructor(r,t){this._refCount=1;this.ptr=r,this.byteLength=t}retain(){this._refCount++}release(){this._refCount<=0||--this._refCount===0&&m&&this.ptr>=64&&a>0&&this.ptr<a&&d(this.ptr)}get refCount(){return this._refCount}}const w=new FinalizationRegistry(e=>{e.release()});function C(e,r){w.register(e,r,e)}function R(e){w.unregister(e)}function W(e){if(e<=0)return null;y();const r=h(e);if(r===0){if(typeof process<"u"&&process.env?.LOG_HEAP){const t=g();console.error(`[wasm] malloc failed: requested ${e} bytes, ${t} bytes free`)}return null}return new v(r,e)}function O(){return y(),g()}function E(){if(y(),c=a,l.length>0){for(const e of l)d(e);l=[]}}function x(e){y();const r=c+7&-8,t=r+e;if(t>o.maxMemoryBytes){const n=h(e);if(n===0)throw new Error(`WASM OOM: scratch full (${o.scratchBytes} bytes) and heap malloc failed for ${e} bytes`);return l.push(n),n}return c=t,r}function A(e){const r=x(e.byteLength),t=u();return new Uint8Array(t.buffer,r,e.byteLength).set(new Uint8Array(e.buffer,e.byteOffset,e.byteLength)),r}function P(e,r,t,n,s,f){if(r)return t+n*f;const M=e.subarray(n,n+s);return A(M)}function I(e){const r=u();return e.buffer===r.buffer?e.byteOffset:A(e)}function V(e,r){const t=u(),n=x(r*4),s=new Float32Array(t.buffer,n,r);return e.isWasmBacked?s.set(new Float16Array(t.buffer,e.wasmPtr+e.offset*2,r)):s.set(e.data.subarray(e.offset,e.offset+r)),n}function k(e,r){const t=W(r*2);if(!t)return null;const n=u(),s=new Float32Array(n.buffer,e.ptr,r);return new Float16Array(n.buffer,t.ptr,r).set(s),t}function L(e,r){const t=u(),n=new Float32Array(t.buffer,e.ptr,r),s=new Float16Array(t.buffer,e.ptr,r);for(let f=0;f<r;f++)s[f]=n[f]}export{v as WasmRegion,F as configureWasm,V as f16InputToScratchF32,k as f32OutputToF16Region,L as f32ToF16InPlace,u as getSharedMemory,C as registerForCleanup,E as resetScratchAllocator,P as resolveInputPtr,I as resolveTypedArrayPtr,x as scratchAlloc,A as scratchCopyIn,_ as setHeapBase,R as unregisterCleanup,O as wasmFreeBytes,W as wasmMalloc};

package/dist/esm/common/wasm/searchsorted.js

@@ -1 +1 @@
-import{searchsorted_left_f64 as B,searchsorted_right_f64 as D,searchsorted_left_f32 as d,searchsorted_right_f32 as p,searchsorted_left_i64 as C,searchsorted_right_i64 as F,searchsorted_left_u64 as I,searchsorted_right_u64 as M,searchsorted_left_i32 as w,searchsorted_right_i32 as R,searchsorted_left_u32 as k,searchsorted_right_u32 as O,searchsorted_left_i16 as U,searchsorted_right_i16 as L,searchsorted_left_u16 as N,searchsorted_right_u16 as z,searchsorted_left_i8 as H,searchsorted_right_i8 as K,searchsorted_left_u8 as Y,searchsorted_right_u8 as v}from"./bins/searchsorted.wasm.js";import{ensureMemory as x,resetAllocator as j,copyIn as A,alloc as q,copyOut as G,f16ToF32Input as m}from"./runtime.js";import{ArrayStorage as J}from"../storage.js";import{wasmConfig as Q}from"./config.js";const V=64,W={float64:B,float32:d,int64:C,uint64:I,int32:w,uint32:k,int16:U,uint16:N,int8:H,uint8:Y,float16:d},X={float64:D,float32:p,int64:F,uint64:M,int32:R,uint32:O,int16:L,uint16:z,int8:K,uint8:v,float16:p},Z={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array,float16:Float32Array};function ot(n,t,g){if(!n.isCContiguous||!t.isCContiguous)return null;const o=n.size,r=t.size;if(r<V*Q.thresholdMultiplier)return null;const e=n.dtype,i=(g==="left"?W:X)[e],f=Z[e];if(!i||!f||t.dtype!==e)return null;const u=f.BYTES_PER_ELEMENT,T=o*u,b=r*u,c=r*4;x(T+b+c),j();const l=e==="float16",y=n.offset;let a=n.data.subarray(y,y+o);l&&(a=m(a,e));const E=A(a),_=t.offset;let s=t.data.subarray(_,_+r);l&&(s=m(s,e));const S=A(s),h=q(c);i(E,o,S,h,r);const P=G(h,r,Int32Array);return J.fromData(P,Array.from(t.shape),"int32")}export{ot as wasmSearchsorted};
+import{searchsorted_left_f64 as g,searchsorted_right_f64 as T,searchsorted_left_f32 as c,searchsorted_right_f32 as _,searchsorted_left_i64 as b,searchsorted_right_i64 as S,searchsorted_left_u64 as P,searchsorted_right_u64 as E,searchsorted_left_i32 as w,searchsorted_right_i32 as C,searchsorted_left_u32 as B,searchsorted_right_u32 as F,searchsorted_left_i16 as M,searchsorted_right_i16 as R,searchsorted_left_u16 as k,searchsorted_right_u16 as D,searchsorted_left_i8 as I,searchsorted_right_i8 as U,searchsorted_left_u8 as L,searchsorted_right_u8 as N}from"./bins/searchsorted.wasm.js";import{wasmMalloc as W,resetScratchAllocator as z,resolveInputPtr as h,f16InputToScratchF32 as y}from"./runtime.js";import{ArrayStorage as H}from"../storage.js";import{effectiveDType as K}from"../dtype.js";import{wasmConfig as d}from"./config.js";const O=64,Y={float64:g,float32:c,int64:b,uint64:P,int32:w,uint32:B,int16:M,uint16:k,int8:I,uint8:L,float16:c},x={float64:T,float32:_,int64:S,uint64:E,int32:C,uint32:F,int16:R,uint16:D,int8:U,uint8:N,float16:_},j={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array,float16:Float32Array};function $(t,r,m){if(!t.isCContiguous||!r.isCContiguous)return null;const a=t.size,e=r.size;if(e<O*d.thresholdMultiplier)return null;const n=K(t.dtype),l=(m==="left"?Y:x)[n],f=j[n];if(!l||!f||r.dtype!==n)return null;const u=f.BYTES_PER_ELEMENT,p=e*8,o=W(p);if(!o)return null;d.wasmCallCount++,z();const A=n==="float16";let i,s;return A?(i=y(t,a),s=y(r,e)):(i=h(t.data,t.isWasmBacked,t.wasmPtr,t.offset,a,u),s=h(r.data,r.isWasmBacked,r.wasmPtr,r.offset,e,u)),l(i,a,s,o.ptr,e),H.fromWasmRegion(Array.from(r.shape),"float64",o,e,Float64Array)}export{$ as wasmSearchsorted};

package/dist/esm/common/wasm/sign.js

@@ -1 +1 @@
-import{sign_f64 as A,sign_f32 as c,sign_i64 as m,sign_i32 as g,sign_i16 as d,sign_i8 as T}from"./bins/sign.wasm.js";import{ensureMemory as E,resetAllocator as b,copyIn as _,alloc as B,copyOut as P}from"./runtime.js";import{ArrayStorage as S}from"../storage.js";import{wasmConfig as D}from"./config.js";const w=64,C={float64:A,float32:c,int64:m,int32:g,int16:d,int8:T},U={float64:Float64Array,float32:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function k(r){if(!r.isCContiguous)return null;const t=r.size;if(t<w*D.thresholdMultiplier)return null;const n=r.dtype,e=C[n],o=U[n];if(!e||!o)return null;const a=o.BYTES_PER_ELEMENT,u=t*a,i=t*a;E(u+i),b();const y=r.offset,f=r.data.subarray(y,y+t),l=_(f),s=B(i);e(l,s,t);const p=P(s,t,o);return S.fromData(p,Array.from(r.shape),n)}export{k as wasmSign};
+import{sign_f64 as u,sign_f32 as f,sign_f16 as A,sign_i64 as p,sign_i32 as m,sign_i16 as c,sign_i8 as g}from"./bins/sign.wasm.js";import{wasmMalloc as d,resetScratchAllocator as T,resolveInputPtr as E}from"./runtime.js";import{ArrayStorage as _}from"../storage.js";import{wasmConfig as y}from"./config.js";const b=64,w={float64:u,float32:f,float16:A,int64:p,int32:m,int16:c,int8:g},C={float64:Float64Array,float32:Float32Array,float16:typeof Float16Array<"u"?Float16Array:Float32Array,int64:BigInt64Array,uint64:BigUint64Array,int32:Int32Array,uint32:Uint32Array,int16:Int16Array,uint16:Uint16Array,int8:Int8Array,uint8:Uint8Array};function R(r){if(!r.isCContiguous)return null;const t=r.size;if(t<b*y.thresholdMultiplier)return null;const n=r.dtype,a=w[n],o=C[n];if(!a||!o)return null;const i=o.BYTES_PER_ELEMENT,s=t*i,e=d(s);if(!e)return null;y.wasmCallCount++,T();const l=E(r.data,r.isWasmBacked,r.wasmPtr,r.offset,t,i);return a(l,e.ptr,t),_.fromWasmRegion(Array.from(r.shape),n,e,t,o)}export{R as wasmSign};

package/dist/esm/common/wasm/signbit.js

@@ -0,0 +1 @@
+import{signbit_f64 as u,signbit_f32 as l,signbit_f16 as p,signbit_i64 as a,signbit_i32 as b,signbit_i16 as m,signbit_i8 as y}from"./bins/signbit.wasm.js";import{wasmMalloc as g,resetScratchAllocator as c,resolveInputPtr as A}from"./runtime.js";import{ArrayStorage as o}from"../storage.js";import{isComplexDType as d}from"../dtype.js";import{wasmConfig as f}from"./config.js";const S=64,_={float64:{fn:u,bpe:8},float32:{fn:l,bpe:4},float16:{fn:p,bpe:2},int64:{fn:a,bpe:8},int32:{fn:b,bpe:4},int16:{fn:m,bpe:2},int8:{fn:y,bpe:1}};function k(r){if(!r.isCContiguous)return null;const n=r.size;if(n<S*f.thresholdMultiplier)return null;const t=r.dtype;if(d(t))return null;if(t==="uint8"||t==="uint16"||t==="uint32"||t==="uint64")return o.zeros(Array.from(r.shape),"bool");const e=_[t];if(!e)return null;const i=g(n);if(!i)return null;f.wasmCallCount++,c();const s=A(r.data,r.isWasmBacked,r.wasmPtr,r.offset,n,e.bpe);return e.fn(s,i.ptr,n),o.fromWasmRegion(Array.from(r.shape),"bool",i,n,Uint8Array)}export{k as wasmSignbit};

package/dist/esm/common/wasm/sin.js

@@ -0,0 +1 @@
+import{sin_f64 as B,sin_f32 as d,sin_i64_f64 as F,sin_u64_f64 as P,sin_i32_f64 as h,sin_u32_f64 as C,sin_i16_f32 as k,sin_u16_f32 as D,sin_i8_f32 as S,sin_u8_f32 as W}from"./bins/sin.wasm.js";import{wasmMalloc as l,resetScratchAllocator as m,resolveInputPtr as p,f16InputToScratchF32 as K,f32OutputToF16Region as w}from"./runtime.js";import{ArrayStorage as f}from"../storage.js";import{effectiveDType as O,isComplexDType as v,hasFloat16 as I}from"../dtype.js";import{wasmConfig as i}from"./config.js";const U=64,M={float64:B,float32:d},x={int64:F,uint64:P,int32:h,uint32:C},z={int16:k,uint16:D,int8:S,uint8:W},E={int64:8,uint64:8,int32:4,uint32:4,int16:2,uint16:2,int8:1,uint8:1};function G(r){if(!r.isCContiguous)return null;const n=r.size;if(n<U*i.thresholdMultiplier)return null;const t=O(r.dtype);if(v(t))return null;if(t==="float16"){const e=n*4,o=l(e);if(!o)return null;i.wasmCallCount++,m();const s=K(r,n);d(s,o.ptr,n);const a=w(o,n);return o.release(),a?f.fromWasmRegion(Array.from(r.shape),t,a,n,Float16Array):null}const b=M[t];if(b){const u=t==="float32",e=u?4:8,o=u?Float32Array:Float64Array,s=n*e,a=l(s);if(!a)return null;i.wasmCallCount++,m();const T=p(r.data,r.isWasmBacked,r.wasmPtr,r.offset,n,e);return b(T,a.ptr,n),f.fromWasmRegion(Array.from(r.shape),t,a,n,o)}const y=E[t];if(!y)return null;const A=z[t];if(A){const u=n*4,e=l(u);if(!e)return null;i.wasmCallCount++,m();const o=p(r.data,r.isWasmBacked,r.wasmPtr,r.offset,n,y);if(A(o,e.ptr,n),I&&(t==="int8"||t==="uint8"||t==="bool")){const s=w(e,n);return e.release(),s?f.fromWasmRegion(Array.from(r.shape),"float16",s,n,Float16Array):null}return f.fromWasmRegion(Array.from(r.shape),"float32",e,n,Float32Array)}const g=x[t];if(!g)return null;const _=n*8,c=l(_);if(!c)return null;i.wasmCallCount++,m();const R=p(r.data,r.isWasmBacked,r.wasmPtr,r.offset,n,y);return g(R,c.ptr,n),f.fromWasmRegion(Array.from(r.shape),"float64",c,n,Float64Array)}export{G as wasmSin};

package/dist/esm/common/wasm/sinh.js

@@ -1 +1 @@
-import{sinh_f64 as F,sinh_f32 as O,sinh_i64 as B,sinh_u64 as S}from"./bins/sinh.wasm.js";import{ensureMemory as u,resetAllocator as y,copyIn as c,alloc as p,copyOut as i,f16ToF32Input as C,f32ToF16Output as _}from"./runtime.js";import{ArrayStorage as l}from"../storage.js";import{isComplexDType as v,isBigIntDType as I}from"../dtype.js";import{wasmConfig as x}from"./config.js";const z=64,E={float64:F,float32:O};function K(o){if(!o.isCContiguous)return null;const r=o.size;if(r<z*x.thresholdMultiplier)return null;const a=o.dtype;if(v(a))return null;if(a==="float16"){u(r*4*2),y();const e=o.offset,f=C(o.data.subarray(e,e+r),a),n=c(f),s=p(r*4);O(n,s,r);const b=i(s,r,Float32Array);return l.fromData(_(b,a),Array.from(o.shape),a)}const A=E[a];if(A){const t=a==="float32",e=t?4:8,f=t?Float32Array:Float64Array;u(r*e*2),y();const n=o.offset,s=o.data.subarray(n,n+r),b=c(s),w=p(r*e);A(b,w,r);const k=i(w,r,f);return l.fromData(k,Array.from(o.shape),a)}if(a==="int64"||a==="uint64"){u(r*16),y();const t=o.offset,e=o.data.subarray(t,t+r),f=c(e),n=p(r*8);(a==="int64"?B:S)(f,n,r);const s=i(n,r,Float64Array);return l.fromData(s,Array.from(o.shape),"float64")}const d=8;u(r*d*2),y();const D=o.offset,T=o.data,m=new Float64Array(r);if(I(a))for(let t=0;t<r;t++)m[t]=Number(T[D+t]);else for(let t=0;t<r;t++)m[t]=T[D+t];const P=c(m),h=p(r*d);F(P,h,r);const g=i(h,r,Float64Array);return l.fromData(g,Array.from(o.shape),"float64")}export{K as wasmSinh};
+import{sinh_f64 as T,sinh_f32 as g,sinh_i64_f64 as B,sinh_u64_f64 as F,sinh_i32_f64 as P,sinh_u32_f64 as C,sinh_i16_f32 as k,sinh_u16_f32 as D,sinh_i8_f32 as S,sinh_u8_f32 as W}from"./bins/sinh.wasm.js";import{wasmMalloc as l,resetScratchAllocator as m,resolveInputPtr as p,f16InputToScratchF32 as K,f32OutputToF16Region as d}from"./runtime.js";import{ArrayStorage as f}from"../storage.js";import{effectiveDType as O,isComplexDType as v,hasFloat16 as I}from"../dtype.js";import{wasmConfig as i}from"./config.js";const U=64,M={float64:T,float32:g},x={int64:B,uint64:F,int32:P,uint32:C},z={int16:k,uint16:D,int8:S,uint8:W},E={int64:8,uint64:8,int32:4,uint32:4,int16:2,uint16:2,int8:1,uint8:1};function G(r){if(!r.isCContiguous)return null;const n=r.size;if(n<U*i.thresholdMultiplier)return null;const t=O(r.dtype);if(v(t))return null;if(t==="float16"){const e=n*4,o=l(e);if(!o)return null;i.wasmCallCount++,m();const s=K(r,n);g(s,o.ptr,n);const a=d(o,n);return o.release(),a?f.fromWasmRegion(Array.from(r.shape),t,a,n,Float16Array):null}const b=M[t];if(b){const u=t==="float32",e=u?4:8,o=u?Float32Array:Float64Array,s=n*e,a=l(s);if(!a)return null;i.wasmCallCount++,m();const R=p(r.data,r.isWasmBacked,r.wasmPtr,r.offset,n,e);return b(R,a.ptr,n),f.fromWasmRegion(Array.from(r.shape),t,a,n,o)}const y=E[t];if(!y)return null;const A=z[t];if(A){const u=n*4,e=l(u);if(!e)return null;i.wasmCallCount++,m();const o=p(r.data,r.isWasmBacked,r.wasmPtr,r.offset,n,y);if(A(o,e.ptr,n),I&&(t==="int8"||t==="uint8"||t==="bool")){const s=d(e,n);return e.release(),s?f.fromWasmRegion(Array.from(r.shape),"float16",s,n,Float16Array):null}return f.fromWasmRegion(Array.from(r.shape),"float32",e,n,Float32Array)}const h=x[t];if(!h)return null;const w=n*8,c=l(w);if(!c)return null;i.wasmCallCount++,m();const _=p(r.data,r.isWasmBacked,r.wasmPtr,r.offset,n,y);return h(_,c.ptr,n),f.fromWasmRegion(Array.from(r.shape),"float64",c,n,Float64Array)}export{G as wasmSinh};