deepbox 0.1.0 → 0.2.0

package/dist/{chunk-PHV2DKRS.cjs → chunk-HDKMIG6E.cjs}

@@ -1,11 +1,11 @@
 'use strict';
 
-var chunk6AE5FKKQ_cjs = require('./chunk-6AE5FKKQ.cjs');
-var chunkJSCDE774_cjs = require('./chunk-JSCDE774.cjs');
+var chunk724CXHFH_cjs = require('./chunk-724CXHFH.cjs');
+var chunkZ6BGACIH_cjs = require('./chunk-Z6BGACIH.cjs');
 
 // src/random/index.ts
 var random_exports = {};
-chunkJSCDE774_cjs.__export(random_exports, {
+chunkZ6BGACIH_cjs.__export(random_exports, {
   beta: () => beta,
   binomial: () => binomial,
   choice: () => choice,
@@ -81,7 +81,7 @@ var __SeededRandom = class {
 var __rng = null;
 function __setSeed(seed) {
   if (!Number.isFinite(seed)) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError(`seed must be a finite number; received ${seed}`, "seed", seed);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError(`seed must be a finite number; received ${seed}`, "seed", seed);
   }
   __globalSeed = seed;
   const seedUint64 = BigInt.asUintN(64, BigInt(Math.trunc(seed)));
@@ -106,7 +106,7 @@ function getCrypto() {
 function randomUint32FromCrypto() {
   const crypto2 = getCrypto();
   if (!crypto2) {
-    throw new chunkJSCDE774_cjs.NotImplementedError(
+    throw new chunkZ6BGACIH_cjs.NotImplementedError(
       "Cryptographically secure randomness is unavailable in this environment. Provide a seed for deterministic randomness."
     );
   }
@@ -114,7 +114,7 @@ function randomUint32FromCrypto() {
   crypto2.getRandomValues(buf);
   const value = buf[0];
   if (value === void 0) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("Failed to read cryptographic randomness", "crypto", value);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("Failed to read cryptographic randomness", "crypto", value);
   }
   return value >>> 0;
 }
@@ -145,7 +145,7 @@ function __normalRandom() {
 }
 function __gammaLarge(shape) {
   if (!Number.isFinite(shape) || shape <= 1 / 3) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError(
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError(
       "shape must be a finite number > 1/3 for Marsaglia-Tsang method",
       "shape",
       shape
@@ -177,31 +177,31 @@ var INT32_MAX = 2147483647;
 var UINT32_RANGE = 2 ** 32;
 var UINT53_RANGE = 2 ** 53;
 function resolveDevice(device) {
-  const resolved = device ?? chunkJSCDE774_cjs.getConfig().defaultDevice;
-  return chunkJSCDE774_cjs.validateDevice(resolved, "device");
+  const resolved = device ?? chunkZ6BGACIH_cjs.getConfig().defaultDevice;
+  return chunkZ6BGACIH_cjs.validateDevice(resolved, "device");
 }
 function resolveFloatDType(dtype, functionName) {
   const resolved = dtype ?? "float32";
   if (resolved !== "float32" && resolved !== "float64") {
-    throw new chunkJSCDE774_cjs.DTypeError(`${functionName} only supports float32 or float64 dtype`);
+    throw new chunkZ6BGACIH_cjs.DTypeError(`${functionName} only supports float32 or float64 dtype`);
   }
   return resolved;
 }
 function resolveIntegerDType(dtype, functionName) {
   const resolved = dtype ?? "int32";
   if (resolved !== "int32" && resolved !== "int64") {
-    throw new chunkJSCDE774_cjs.DTypeError(`${functionName} only supports int32 or int64 dtype`);
+    throw new chunkZ6BGACIH_cjs.DTypeError(`${functionName} only supports int32 or int64 dtype`);
   }
   return resolved;
 }
 function assertSafeInteger(value, name) {
   if (!Number.isFinite(value) || !Number.isInteger(value) || !Number.isSafeInteger(value)) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError(`${name} must be a safe integer`, name, value);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError(`${name} must be a safe integer`, name, value);
   }
 }
 function assertInt32Bounds(value, name) {
   if (value < INT32_MIN || value > INT32_MAX) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError(
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError(
       `${name} must be within int32 range [${INT32_MIN}, ${INT32_MAX}]`,
       name,
       value
@@ -210,7 +210,7 @@ function assertInt32Bounds(value, name) {
 }
 function randomIntBelow(maxExclusive) {
   if (!Number.isSafeInteger(maxExclusive) || maxExclusive <= 0) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("range must be a positive safe integer", "range", maxExclusive);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("range must be a positive safe integer", "range", maxExclusive);
   }
   if (maxExclusive <= UINT32_RANGE) {
     const limit = Math.floor(UINT32_RANGE / maxExclusive) * maxExclusive;
@@ -228,7 +228,7 @@ function randomIntBelow(maxExclusive) {
     }
     return value % maxExclusive;
   }
-  throw new chunkJSCDE774_cjs.InvalidParameterError(
+  throw new chunkZ6BGACIH_cjs.InvalidParameterError(
     "range must be <= 2^53 for unbiased sampling",
     "range",
     maxExclusive
@@ -256,7 +256,7 @@ function randomOpenUnit() {
 }
 function validateContiguous(t, functionName) {
   if (t.offset !== 0) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError(
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError(
       `${functionName} currently requires offset === 0`,
       "offset",
       t.offset
@@ -266,7 +266,7 @@ function validateContiguous(t, functionName) {
     const expected = t.strides[axis];
     const tail = t.shape.slice(axis + 1).reduce((acc, v) => acc * v, 1);
     if (expected !== tail) {
-      throw new chunkJSCDE774_cjs.InvalidParameterError(
+      throw new chunkZ6BGACIH_cjs.InvalidParameterError(
         `${functionName} currently requires a contiguous tensor`,
         "strides",
         t.strides
@@ -286,7 +286,7 @@ var LANCZOS_COEFFS = [
 ];
 function logGamma(z) {
   if (!Number.isFinite(z) || z <= 0) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("logGamma requires a positive finite input", "z", z);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("logGamma requires a positive finite input", "z", z);
   }
   let x = 0.9999999999998099;
   for (const [i, coeff] of LANCZOS_COEFFS.entries()) {
@@ -324,13 +324,13 @@ function clearSeed() {
   __clearSeed();
 }
 function rand(shape, opts = {}) {
-  const size = chunkJSCDE774_cjs.shapeToSize(shape);
+  const size = chunkZ6BGACIH_cjs.shapeToSize(shape);
   const dtype = resolveFloatDType(opts.dtype, "rand");
   const data = allocateFloatBuffer(dtype, size);
   for (let i = 0; i < size; i++) {
     data[i] = __random();
   }
-  return chunk6AE5FKKQ_cjs.Tensor.fromTypedArray({
+  return chunk724CXHFH_cjs.Tensor.fromTypedArray({
     data,
     shape,
     dtype,
@@ -338,13 +338,13 @@ function rand(shape, opts = {}) {
   });
 }
 function randn(shape, opts = {}) {
-  const size = chunkJSCDE774_cjs.shapeToSize(shape);
+  const size = chunkZ6BGACIH_cjs.shapeToSize(shape);
   const dtype = resolveFloatDType(opts.dtype, "randn");
   const data = allocateFloatBuffer(dtype, size);
   for (let i = 0; i < size; i++) {
     data[i] = __normalRandom();
   }
-  return chunk6AE5FKKQ_cjs.Tensor.fromTypedArray({
+  return chunk724CXHFH_cjs.Tensor.fromTypedArray({
     data,
     shape,
     dtype,
@@ -355,30 +355,30 @@ function randint(low, high, shape, opts = {}) {
   assertSafeInteger(low, "low");
   assertSafeInteger(high, "high");
   if (high <= low) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("high must be > low", "high", high);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("high must be > low", "high", high);
   }
   const dtype = resolveIntegerDType(opts.dtype, "randint");
   if (dtype === "int32") {
     assertInt32Bounds(low, "low");
     if (high > INT32_MAX + 1) {
-      throw new chunkJSCDE774_cjs.InvalidParameterError(
+      throw new chunkZ6BGACIH_cjs.InvalidParameterError(
         `high must be <= ${INT32_MAX + 1} for int32 output`,
         "high",
         high
       );
     }
   }
-  const size = chunkJSCDE774_cjs.shapeToSize(shape);
+  const size = chunkZ6BGACIH_cjs.shapeToSize(shape);
   const data = allocateIntegerBuffer(dtype, size);
   const range = high - low;
   if (!Number.isSafeInteger(range) || range <= 0) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("range must be a positive safe integer", "high", high);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("range must be a positive safe integer", "high", high);
   }
   for (let i = 0; i < size; i++) {
     const sample = randomIntBelow(range) + low;
     writeInteger(data, i, sample);
   }
-  return chunk6AE5FKKQ_cjs.Tensor.fromTypedArray({
+  return chunk724CXHFH_cjs.Tensor.fromTypedArray({
     data,
     shape,
     dtype,
@@ -387,22 +387,22 @@ function randint(low, high, shape, opts = {}) {
 }
 function uniform(low = 0, high = 1, shape = [], opts = {}) {
   if (!Number.isFinite(low) || !Number.isFinite(high)) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("low and high must be finite", "low/high", {
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("low and high must be finite", "low/high", {
       low,
       high
     });
   }
   if (high < low) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("high must be >= low", "high", high);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("high must be >= low", "high", high);
   }
-  const size = chunkJSCDE774_cjs.shapeToSize(shape);
+  const size = chunkZ6BGACIH_cjs.shapeToSize(shape);
   const dtype = resolveFloatDType(opts.dtype, "uniform");
   const data = allocateFloatBuffer(dtype, size);
   const range = high - low;
   for (let i = 0; i < size; i++) {
     data[i] = __random() * range + low;
   }
-  return chunk6AE5FKKQ_cjs.Tensor.fromTypedArray({
+  return chunk724CXHFH_cjs.Tensor.fromTypedArray({
     data,
     shape,
     dtype,
@@ -411,21 +411,21 @@ function uniform(low = 0, high = 1, shape = [], opts = {}) {
 }
 function normal(mean = 0, std = 1, shape = [], opts = {}) {
   if (!Number.isFinite(mean) || !Number.isFinite(std)) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("mean and std must be finite", "mean/std", {
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("mean and std must be finite", "mean/std", {
       mean,
       std
     });
   }
   if (std < 0) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("std must be >= 0", "std", std);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("std must be >= 0", "std", std);
   }
-  const size = chunkJSCDE774_cjs.shapeToSize(shape);
+  const size = chunkZ6BGACIH_cjs.shapeToSize(shape);
   const dtype = resolveFloatDType(opts.dtype, "normal");
   const data = allocateFloatBuffer(dtype, size);
   for (let i = 0; i < size; i++) {
     data[i] = __normalRandom() * std + mean;
   }
-  return chunk6AE5FKKQ_cjs.Tensor.fromTypedArray({
+  return chunk724CXHFH_cjs.Tensor.fromTypedArray({
     data,
     shape,
     dtype,
@@ -480,21 +480,21 @@ function binomialChopDown(n, p, q, mode, pmfMode) {
 function binomial(n, p, shape = [], opts = {}) {
   assertSafeInteger(n, "n");
   if (n < 0) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("n must be >= 0", "n", n);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("n must be >= 0", "n", n);
   }
   if (!Number.isFinite(p) || p < 0 || p > 1) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("p must be in [0, 1]", "p", p);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("p must be in [0, 1]", "p", p);
   }
-  const size = chunkJSCDE774_cjs.shapeToSize(shape);
+  const size = chunkZ6BGACIH_cjs.shapeToSize(shape);
   const dtype = resolveIntegerDType(opts.dtype, "binomial");
   if (dtype === "int32") {
     if (n > INT32_MAX) {
-      throw new chunkJSCDE774_cjs.InvalidParameterError(`n must be <= ${INT32_MAX} for int32 output`, "n", n);
+      throw new chunkZ6BGACIH_cjs.InvalidParameterError(`n must be <= ${INT32_MAX} for int32 output`, "n", n);
     }
   }
   const data = allocateIntegerBuffer(dtype, size);
   if (n === 0) {
-    return chunk6AE5FKKQ_cjs.Tensor.fromTypedArray({
+    return chunk724CXHFH_cjs.Tensor.fromTypedArray({
       data,
       shape,
       dtype,
@@ -502,7 +502,7 @@ function binomial(n, p, shape = [], opts = {}) {
     });
   }
   if (p === 0) {
-    return chunk6AE5FKKQ_cjs.Tensor.fromTypedArray({
+    return chunk724CXHFH_cjs.Tensor.fromTypedArray({
       data,
       shape,
       dtype,
@@ -513,7 +513,7 @@ function binomial(n, p, shape = [], opts = {}) {
     for (let i = 0; i < size; i++) {
       writeInteger(data, i, n);
     }
-    return chunk6AE5FKKQ_cjs.Tensor.fromTypedArray({
+    return chunk724CXHFH_cjs.Tensor.fromTypedArray({
       data,
       shape,
       dtype,
@@ -528,7 +528,7 @@ function binomial(n, p, shape = [], opts = {}) {
     for (let i = 0; i < size; i++) {
       writeInteger(data, i, value);
     }
-    return chunk6AE5FKKQ_cjs.Tensor.fromTypedArray({
+    return chunk724CXHFH_cjs.Tensor.fromTypedArray({
       data,
       shape,
       dtype,
@@ -548,14 +548,14 @@ function binomial(n, p, shape = [], opts = {}) {
     const logPmfMode = logFactorial(n) - logFactorial(mode) - logFactorial(n - mode) + mode * logP + (n - mode) * logQ;
     const pmfMode = Math.exp(logPmfMode);
     if (!Number.isFinite(pmfMode) || pmfMode <= 0) {
-      throw new chunkJSCDE774_cjs.InvalidParameterError("Failed to initialize binomial sampler", "p", p);
+      throw new chunkZ6BGACIH_cjs.InvalidParameterError("Failed to initialize binomial sampler", "p", p);
     }
     for (let i = 0; i < size; i++) {
       const sample = binomialChopDown(n, prob, q, mode, pmfMode);
       writeInteger(data, i, flip ? n - sample : sample);
     }
   }
-  return chunk6AE5FKKQ_cjs.Tensor.fromTypedArray({
+  return chunk724CXHFH_cjs.Tensor.fromTypedArray({
     data,
     shape,
     dtype,
@@ -564,13 +564,13 @@ function binomial(n, p, shape = [], opts = {}) {
 }
 function poisson(lambda, shape = [], opts = {}) {
   if (!Number.isFinite(lambda) || lambda < 0) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("lambda must be a finite number >= 0", "lambda", lambda);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("lambda must be a finite number >= 0", "lambda", lambda);
   }
-  const size = chunkJSCDE774_cjs.shapeToSize(shape);
+  const size = chunkZ6BGACIH_cjs.shapeToSize(shape);
   const dtype = resolveIntegerDType(opts.dtype, "poisson");
   if (dtype === "int32") {
     if (lambda > INT32_MAX) {
-      throw new chunkJSCDE774_cjs.InvalidParameterError(
+      throw new chunkZ6BGACIH_cjs.InvalidParameterError(
         `lambda must be <= ${INT32_MAX} for int32 output`,
         "lambda",
         lambda
@@ -589,14 +589,14 @@ function poisson(lambda, shape = [], opts = {}) {
       } while (p > L);
       const sample = k - 1;
       if (!Number.isSafeInteger(sample)) {
-        throw new chunkJSCDE774_cjs.InvalidParameterError(
+        throw new chunkZ6BGACIH_cjs.InvalidParameterError(
           "poisson sample exceeds safe integer range",
           "lambda",
           lambda
         );
       }
       if (dtype === "int32" && sample > INT32_MAX) {
-        throw new chunkJSCDE774_cjs.InvalidParameterError("poisson sample exceeds int32 range", "lambda", lambda);
+        throw new chunkZ6BGACIH_cjs.InvalidParameterError("poisson sample exceeds int32 range", "lambda", lambda);
       }
       writeInteger(data, i, sample);
     }
@@ -618,14 +618,14 @@ function poisson(lambda, shape = [], opts = {}) {
         const rhs = k + n * Math.log(lambda) - logFactorial(n);
         if (lhs <= rhs) {
           if (!Number.isSafeInteger(n)) {
-            throw new chunkJSCDE774_cjs.InvalidParameterError(
+            throw new chunkZ6BGACIH_cjs.InvalidParameterError(
               "poisson sample exceeds safe integer range",
               "lambda",
               lambda
             );
           }
           if (dtype === "int32" && n > INT32_MAX) {
-            throw new chunkJSCDE774_cjs.InvalidParameterError("poisson sample exceeds int32 range", "lambda", lambda);
+            throw new chunkZ6BGACIH_cjs.InvalidParameterError("poisson sample exceeds int32 range", "lambda", lambda);
           }
           writeInteger(data, i, n);
           break;
@@ -633,7 +633,7 @@ function poisson(lambda, shape = [], opts = {}) {
       }
     }
   }
-  return chunk6AE5FKKQ_cjs.Tensor.fromTypedArray({
+  return chunk724CXHFH_cjs.Tensor.fromTypedArray({
     data,
     shape,
     dtype,
@@ -642,16 +642,16 @@ function poisson(lambda, shape = [], opts = {}) {
 }
 function exponential(scale = 1, shape = [], opts = {}) {
   if (!Number.isFinite(scale) || scale <= 0) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("scale must be a finite number > 0", "scale", scale);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("scale must be a finite number > 0", "scale", scale);
   }
-  const size = chunkJSCDE774_cjs.shapeToSize(shape);
+  const size = chunkZ6BGACIH_cjs.shapeToSize(shape);
   const dtype = resolveFloatDType(opts.dtype, "exponential");
   const data = allocateFloatBuffer(dtype, size);
   for (let i = 0; i < size; i++) {
     const u = randomOpenUnit();
     data[i] = -scale * Math.log(u);
   }
-  return chunk6AE5FKKQ_cjs.Tensor.fromTypedArray({
+  return chunk724CXHFH_cjs.Tensor.fromTypedArray({
     data,
     shape,
     dtype,
@@ -660,22 +660,22 @@ function exponential(scale = 1, shape = [], opts = {}) {
 }
 function gamma(shape_param, scale = 1, shape = [], opts = {}) {
   if (!Number.isFinite(shape_param) || shape_param <= 0) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError(
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError(
       "shape_param must be a finite number > 0",
       "shape_param",
       shape_param
     );
   }
   if (!Number.isFinite(scale) || scale <= 0) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("scale must be a finite number > 0", "scale", scale);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("scale must be a finite number > 0", "scale", scale);
   }
-  const size = chunkJSCDE774_cjs.shapeToSize(shape);
+  const size = chunkZ6BGACIH_cjs.shapeToSize(shape);
   const dtype = resolveFloatDType(opts.dtype, "gamma");
   const data = allocateFloatBuffer(dtype, size);
   for (let i = 0; i < size; i++) {
     data[i] = sampleGammaUnit(shape_param) * scale;
   }
-  return chunk6AE5FKKQ_cjs.Tensor.fromTypedArray({
+  return chunk724CXHFH_cjs.Tensor.fromTypedArray({
     data,
     shape,
     dtype,
@@ -684,12 +684,12 @@ function gamma(shape_param, scale = 1, shape = [], opts = {}) {
 }
 function beta(alpha, beta_param, shape = [], opts = {}) {
   if (!Number.isFinite(alpha) || alpha <= 0) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("alpha must be a finite number > 0", "alpha", alpha);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("alpha must be a finite number > 0", "alpha", alpha);
   }
   if (!Number.isFinite(beta_param) || beta_param <= 0) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("beta must be a finite number > 0", "beta_param", beta_param);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("beta must be a finite number > 0", "beta_param", beta_param);
   }
-  const size = chunkJSCDE774_cjs.shapeToSize(shape);
+  const size = chunkZ6BGACIH_cjs.shapeToSize(shape);
   const dtype = resolveFloatDType(opts.dtype, "beta");
   const data = allocateFloatBuffer(dtype, size);
   for (let i = 0; i < size; i++) {
@@ -709,14 +709,14 @@ function beta(alpha, beta_param, shape = [], opts = {}) {
       }
     }
     if (!sampled) {
-      throw new chunkJSCDE774_cjs.InvalidParameterError(
+      throw new chunkZ6BGACIH_cjs.InvalidParameterError(
         "beta sampling failed to produce a finite sample",
         "alpha/beta_param",
         { alpha, beta_param }
       );
     }
   }
-  return chunk6AE5FKKQ_cjs.Tensor.fromTypedArray({
+  return chunk724CXHFH_cjs.Tensor.fromTypedArray({
     data,
     shape,
     dtype,
@@ -725,13 +725,13 @@ function beta(alpha, beta_param, shape = [], opts = {}) {
 }
 function readNumericTensorValue(t, index) {
   if (t.dtype === "string") {
-    throw new chunkJSCDE774_cjs.DTypeError("Expected numeric tensor");
+    throw new chunkZ6BGACIH_cjs.DTypeError("Expected numeric tensor");
   }
   const value = t.data[index];
   if (typeof value === "number" || typeof value === "bigint") {
     return value;
   }
-  throw new chunkJSCDE774_cjs.InvalidParameterError("Internal error: tensor index out of bounds", "index", index);
+  throw new chunkZ6BGACIH_cjs.InvalidParameterError("Internal error: tensor index out of bounds", "index", index);
 }
 function allocateNumericBuffer(dtype, size) {
   switch (dtype) {
@@ -747,7 +747,7 @@ function allocateNumericBuffer(dtype, size) {
     case "bool":
       return new Uint8Array(size);
     case "string":
-      throw new chunkJSCDE774_cjs.DTypeError("choice() does not support string tensors");
+      throw new chunkZ6BGACIH_cjs.DTypeError("choice() does not support string tensors");
   }
 }
 function writeNumericValue(out, index, value) {
@@ -763,13 +763,13 @@ function writeNumericValue(out, index, value) {
 }
 function buildNormalizedProbabilities(probabilities, n) {
   if (probabilities.dtype === "string") {
-    throw new chunkJSCDE774_cjs.DTypeError("choice() probabilities must be numeric");
+    throw new chunkZ6BGACIH_cjs.DTypeError("choice() probabilities must be numeric");
   }
   if (probabilities.ndim !== 1) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("p must be a 1D tensor", "p", probabilities.shape);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("p must be a 1D tensor", "p", probabilities.shape);
   }
   if (probabilities.size !== n) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError(
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError(
       "p must have the same length as the population",
       "p",
       probabilities.size
@@ -781,7 +781,7 @@ function buildNormalizedProbabilities(probabilities, n) {
   for (let i = 0; i < n; i++) {
     const value = Number(readNumericTensorValue(probabilities, i));
     if (!Number.isFinite(value) || value < 0) {
-      throw new chunkJSCDE774_cjs.InvalidParameterError(
+      throw new chunkZ6BGACIH_cjs.InvalidParameterError(
         "p must contain finite non-negative probabilities",
         "p",
         value
@@ -791,7 +791,7 @@ function buildNormalizedProbabilities(probabilities, n) {
     sum += value;
   }
   if (!Number.isFinite(sum) || sum <= 0) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("sum(p) must be > 0 and finite", "p", sum);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("sum(p) must be > 0 and finite", "p", sum);
   }
   for (let i = 0; i < n; i++) {
     normalized[i] = (normalized[i] ?? 0) / sum;
@@ -806,7 +806,7 @@ function sampleFromCdf(cdf) {
     const mid = Math.floor((left + right) / 2);
     const value = cdf[mid];
     if (value === void 0) {
-      throw new chunkJSCDE774_cjs.InvalidParameterError("Internal error: invalid CDF index", "mid", mid);
+      throw new chunkZ6BGACIH_cjs.InvalidParameterError("Internal error: invalid CDF index", "mid", mid);
     }
     if (u <= value) {
       right = mid;
@@ -820,44 +820,44 @@ function choice(a, size, replace = true, p) {
   if (typeof a === "number") {
     assertSafeInteger(a, "a");
     if (a < 0) {
-      throw new chunkJSCDE774_cjs.InvalidParameterError("Invalid population size", "a", a);
+      throw new chunkZ6BGACIH_cjs.InvalidParameterError("Invalid population size", "a", a);
     }
     if (a > INT32_MAX + 1) {
-      throw new chunkJSCDE774_cjs.InvalidParameterError(
+      throw new chunkZ6BGACIH_cjs.InvalidParameterError(
         `Population size must be <= ${INT32_MAX + 1} for choice()`,
         "a",
         a
       );
     }
   }
-  const aa = typeof a === "number" ? chunk6AE5FKKQ_cjs.arange(0, a, 1, { dtype: "int32" }) : a;
+  const aa = typeof a === "number" ? chunk724CXHFH_cjs.arange(0, a, 1, { dtype: "int32" }) : a;
   if (aa.dtype === "string") {
-    throw new chunkJSCDE774_cjs.DTypeError("choice() does not support string tensors");
+    throw new chunkZ6BGACIH_cjs.DTypeError("choice() does not support string tensors");
   }
   const n = aa.size;
   if (!Number.isInteger(n) || n < 0) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("Invalid tensor size", "n", n);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("Invalid tensor size", "n", n);
   }
   if (n > INT32_MAX + 1) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError(`Population size must be <= ${INT32_MAX + 1}`, "n", n);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError(`Population size must be <= ${INT32_MAX + 1}`, "n", n);
   }
   let outputSize;
   if (typeof size === "number") {
     outputSize = size;
   } else if (size) {
-    chunkJSCDE774_cjs.validateShape(size);
-    outputSize = chunkJSCDE774_cjs.shapeToSize(size);
+    chunkZ6BGACIH_cjs.validateShape(size);
+    outputSize = chunkZ6BGACIH_cjs.shapeToSize(size);
   } else {
     outputSize = 1;
   }
   if (!Number.isSafeInteger(outputSize) || outputSize < 0) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("size must be an integer >= 0", "size", size);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("size must be an integer >= 0", "size", size);
   }
   if (outputSize > INT32_MAX) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError(`size must be <= ${INT32_MAX}`, "size", outputSize);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError(`size must be <= ${INT32_MAX}`, "size", outputSize);
   }
   if (n === 0 && outputSize > 0) {
-    throw new chunkJSCDE774_cjs.InvalidParameterError("Cannot sample from an empty population", "a", a);
+    throw new chunkZ6BGACIH_cjs.InvalidParameterError("Cannot sample from an empty population", "a", a);
   }
   const indices = new Int32Array(outputSize);
   const weights = p ? buildNormalizedProbabilities(p, n) : void 0;
@@ -879,7 +879,7 @@ function choice(a, size, replace = true, p) {
         if ((weights[i] ?? 0) > 0) nonZeroCount++;
       }
       if (outputSize > nonZeroCount) {
-        throw new chunkJSCDE774_cjs.InvalidParameterError(
+        throw new chunkZ6BGACIH_cjs.InvalidParameterError(
           "Cannot sample without replacement with zero-probability mass for requested size",
           "size",
           outputSize
@@ -889,7 +889,7 @@ function choice(a, size, replace = true, p) {
       let remainingMass = 1;
       for (let i = 0; i < outputSize; i++) {
         if (remainingMass <= 0) {
-          throw new chunkJSCDE774_cjs.InvalidParameterError(
+          throw new chunkZ6BGACIH_cjs.InvalidParameterError(
             "Insufficient probability mass to sample",
             "p",
             remainingMass
@@ -918,7 +918,7 @@ function choice(a, size, replace = true, p) {
           }
         }
         if (chosen < 0) {
-          throw new chunkJSCDE774_cjs.InvalidParameterError("Failed to select weighted sample", "p", weights);
+          throw new chunkZ6BGACIH_cjs.InvalidParameterError("Failed to select weighted sample", "p", weights);
         }
         indices[i] = chosen;
         remainingMass -= remaining[chosen] ?? 0;
@@ -931,7 +931,7 @@ function choice(a, size, replace = true, p) {
     }
   } else {
     if (outputSize > n) {
-      throw new chunkJSCDE774_cjs.InvalidParameterError(
+      throw new chunkZ6BGACIH_cjs.InvalidParameterError(
         "Cannot sample without replacement when size > population",
         "size",
         outputSize
@@ -943,7 +943,7 @@ function choice(a, size, replace = true, p) {
       const poolI = pool[i];
       const poolJ = pool[j];
       if (poolI === void 0 || poolJ === void 0) {
-        throw new chunkJSCDE774_cjs.InvalidParameterError("Internal error: pool index out of bounds", "pool", {
+        throw new chunkZ6BGACIH_cjs.InvalidParameterError("Internal error: pool index out of bounds", "pool", {
           i,
           j,
           n
@@ -960,12 +960,12 @@ function choice(a, size, replace = true, p) {
   for (let i = 0; i < outputSize; i++) {
     const idx = indices[i];
     if (idx === void 0) {
-      throw new chunkJSCDE774_cjs.InvalidParameterError("Internal error: undefined index", "indices", i);
+      throw new chunkZ6BGACIH_cjs.InvalidParameterError("Internal error: undefined index", "indices", i);
     }
     const value = readNumericTensorValue(aa, idx);
     writeNumericValue(out, i, value);
   }
-  return chunk6AE5FKKQ_cjs.Tensor.fromTypedArray({
+  return chunk724CXHFH_cjs.Tensor.fromTypedArray({
     data: out,
     shape: outputShape,
     dtype: aa.dtype,
@@ -974,12 +974,12 @@ function choice(a, size, replace = true, p) {
 }
 function shuffle(x) {
   if (x.dtype === "string") {
-    throw new chunkJSCDE774_cjs.DTypeError("shuffle() does not support string tensors");
+    throw new chunkZ6BGACIH_cjs.DTypeError("shuffle() does not support string tensors");
   }
   validateContiguous(x, "shuffle()");
   const data = x.data;
-  if (!chunkJSCDE774_cjs.isTypedArray(data)) {
-    throw new chunkJSCDE774_cjs.DTypeError("shuffle() does not support string tensors");
+  if (!chunkZ6BGACIH_cjs.isTypedArray(data)) {
+    throw new chunkZ6BGACIH_cjs.DTypeError("shuffle() does not support string tensors");
   }
   const n = data.length;
   if (data instanceof BigInt64Array) {
@@ -988,7 +988,7 @@ function shuffle(x) {
       const temp = data[i];
       const swap = data[j];
       if (temp === void 0 || swap === void 0) {
-        throw new chunkJSCDE774_cjs.DeepboxError("Internal error: shuffle index out of bounds");
+        throw new chunkZ6BGACIH_cjs.DeepboxError("Internal error: shuffle index out of bounds");
       }
       data[i] = swap;
       data[j] = temp;
@@ -999,7 +999,7 @@ function shuffle(x) {
       const temp = data[i];
       const swap = data[j];
       if (temp === void 0 || swap === void 0) {
-        throw new chunkJSCDE774_cjs.DeepboxError("Internal error: shuffle index out of bounds");
+        throw new chunkZ6BGACIH_cjs.DeepboxError("Internal error: shuffle index out of bounds");
       }
       data[i] = swap;
       data[j] = temp;
@@ -1011,10 +1011,10 @@ function permutation(x) {
     assertSafeInteger(x, "x");
     const n = x;
     if (n < 0) {
-      throw new chunkJSCDE774_cjs.InvalidParameterError("x must be a non-negative integer", "x", x);
+      throw new chunkZ6BGACIH_cjs.InvalidParameterError("x must be a non-negative integer", "x", x);
     }
     if (n > INT32_MAX + 1) {
-      throw new chunkJSCDE774_cjs.InvalidParameterError(`x must be <= ${INT32_MAX + 1} for int32 output`, "x", x);
+      throw new chunkZ6BGACIH_cjs.InvalidParameterError(`x must be <= ${INT32_MAX + 1} for int32 output`, "x", x);
     }
     const indices = Array.from({ length: n }, (_, i) => i);
     for (let i = n - 1; i > 0; i--) {
@@ -1022,7 +1022,7 @@ function permutation(x) {
       const indicesI = indices[i];
       const indicesJ = indices[j];
       if (indicesI === void 0 || indicesJ === void 0) {
-        throw new chunkJSCDE774_cjs.InvalidParameterError("Internal error: indices out of bounds", "indices", {
+        throw new chunkZ6BGACIH_cjs.InvalidParameterError("Internal error: indices out of bounds", "indices", {
           i,
           j,
           n
@@ -1031,17 +1031,17 @@ function permutation(x) {
       indices[i] = indicesJ;
       indices[j] = indicesI;
     }
-    return chunk6AE5FKKQ_cjs.tensor(indices, { dtype: "int32" });
+    return chunk724CXHFH_cjs.tensor(indices, { dtype: "int32" });
   }
   if (x.dtype === "string") {
-    throw new chunkJSCDE774_cjs.DTypeError("permutation() does not support string tensors");
+    throw new chunkZ6BGACIH_cjs.DTypeError("permutation() does not support string tensors");
   }
   validateContiguous(x, "permutation()");
   const data = x.data;
-  if (!chunkJSCDE774_cjs.isTypedArray(data)) {
-    throw new chunkJSCDE774_cjs.DTypeError("permutation() does not support string tensors");
+  if (!chunkZ6BGACIH_cjs.isTypedArray(data)) {
+    throw new chunkZ6BGACIH_cjs.DTypeError("permutation() does not support string tensors");
   }
-  const copy = chunk6AE5FKKQ_cjs.Tensor.fromTypedArray({
+  const copy = chunk724CXHFH_cjs.Tensor.fromTypedArray({
     data: data.slice(),
     shape: x.shape,
     dtype: x.dtype,
@@ -1068,5 +1068,5 @@ exports.random_exports = random_exports;
 exports.setSeed = setSeed;
 exports.shuffle = shuffle;
 exports.uniform = uniform;
-//# sourceMappingURL=chunk-PHV2DKRS.cjs.map
-//# sourceMappingURL=chunk-PHV2DKRS.cjs.map
+//# sourceMappingURL=chunk-HDKMIG6E.cjs.map
+//# sourceMappingURL=chunk-HDKMIG6E.cjs.map