@query-farm/vgi 0.25.3 → 0.25.4

package/dist/arrow/repr.test-d.d.ts

@@ -1,4 +1,4 @@
-import { list, asDate64Ms } from "./index.js";
+import { dateMillisecond, list, bool, float64, asDate64Ms } from "./index.js";
 import type { RichValue, RawValue, ValueFor, Date32Type, Date64Type, Int64Type, Int32Type, Utf8Type, BoolType, TimestampType, DecimalType, FloatType, StructType, ListType, TypedField, Date32, TimestampMicros, UnscaledDecimal } from "./index.js";
 type Expect<T extends true> = T;
 type Equal<A, B> = (<G>() => G extends A ? 1 : 2) extends (<G>() => G extends B ? 1 : 2) ? true : false;
@@ -43,9 +43,9 @@ export type _AllChecks = [
     _r15
 ];
 export declare const _unusedFactories: {
-    dateMillisecond: () => Date64Type;
-    bool: () => BoolType;
-    float64: () => FloatType;
+    dateMillisecond: typeof dateMillisecond;
+    bool: typeof bool;
+    float64: typeof float64;
     list: typeof list;
     asDate64Ms: typeof asDate64Ms;
 };

package/dist/index.js

@@ -8394,45 +8394,48 @@ init_arrow();
 function isBytes(a) {
   return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
 }
-function abool(b) {
-  if (typeof b !== "boolean")
-    throw new TypeError(`boolean expected, not ${b}`);
+var atitle = (title) => title ? `"${title}" ` : "";
+function abool(value, title = "") {
+  if (typeof value !== "boolean")
+    throw new TypeError(atitle(title) + "expected boolean, got type=" + typeof value);
+  return value;
 }
-function anumber(n) {
+function anumber(n, title = "") {
   if (typeof n !== "number")
-    throw new TypeError("number expected, got " + typeof n);
+    throw new TypeError(atitle(title) + "expected number, got " + typeof n);
   if (!Number.isSafeInteger(n) || n < 0)
-    throw new RangeError("positive integer expected, got " + n);
+    throw new RangeError(atitle(title) + "expected integer >= 0, got " + n);
+  return n;
 }
 function abytes(value, length, title = "") {
+  if (isBytes(value) && (length === undefined || value.length === length))
+    return value;
+  if (length !== undefined)
+    anumber(length, "length");
   const bytes = isBytes(value);
-  const len = value?.length;
-  const needsLen = length !== undefined;
-  if (!bytes || needsLen && len !== length) {
-    const prefix = title && `"${title}" `;
-    const ofLen = needsLen ? ` of length ${length}` : "";
-    const got = bytes ? `length=${len}` : `type=${typeof value}`;
-    const message = prefix + "expected Uint8Array" + ofLen + ", got " + got;
-    if (!bytes)
-      throw new TypeError(message);
-    throw new RangeError(message);
-  }
-  return value;
-}
+  const ofLen = length !== undefined ? ` of length ${length}` : "";
+  const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
+  const message = atitle(title) + "expected Uint8Array" + ofLen + ", got " + got;
+  if (!bytes)
+    throw new TypeError(message);
+  throw new RangeError(message);
+}
+var aobject = (value, label) => {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    throw new TypeError(label === "object" ? "expected valid options object" : `"${label}" expected object, got type=${typeof value}`);
+};
 function aexists(instance, checkFinished = true) {
   if (instance.destroyed)
-    throw new Error("Hash instance has been destroyed");
+    throw new Error("hash was destroyed");
   if (checkFinished && instance.finished)
-    throw new Error("Hash#digest() has already been called");
+    throw new Error("digest() was already called");
 }
-function aoutput(out, instance, onlyAligned = false) {
+function aoutput(out, instance) {
   abytes(out, undefined, "output");
   const min = instance.outputLen;
-  if (out.length < min) {
-    throw new RangeError("digestInto() expects output buffer of length at least " + min);
+  if (!(out.length >= min)) {
+    throw new RangeError('"output" expected length >= ' + min);
   }
-  if (onlyAligned && !isAligned32(out))
-    throw new Error("invalid output, must be aligned");
 }
 function u32(arr) {
   return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
@@ -8446,21 +8449,25 @@ function createView(arr) {
   return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 }
 var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
-var byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
-var swap8IfBE = isLE ? (n) => n : (n) => byteSwap(n) >>> 0;
-var byteSwap32 = (arr) => {
-  for (let i = 0;i < arr.length; i++)
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+function byteSwap32(arr) {
+  for (let i = 0;i < arr.length; i++) {
     arr[i] = byteSwap(arr[i]);
+  }
   return arr;
-};
+}
 var swap32IfBE = isLE ? (u) => u : byteSwap32;
 function checkOpts(defaults, opts) {
-  if (opts == null || typeof opts !== "object")
-    throw new Error("options must be defined");
+  aobject(defaults, "defaults");
+  aobject(opts, "opts");
   const merged = Object.assign(defaults, opts);
   return merged;
 }
 function equalBytes(a, b) {
+  a = abytes(a);
+  b = abytes(b);
   if (a.length !== b.length)
     return false;
   let diff = 0;
@@ -8486,8 +8493,14 @@ var wrapCipher = (params, constructor) => {
       abytes(nonce, params.varSizeNonce ? undefined : params.nonceLength, "nonce");
     }
     const tagl = params.tagLength;
-    if (tagl && args[1] !== undefined)
-      abytes(args[1], undefined, "AAD");
+    const aadStart = params.nonceLength !== undefined ? 1 : 0;
+    if (!params.withAAD) {
+      for (let i = aadStart;i < args.length; i++)
+        if (isBytes(args[i]))
+          throw new Error("AAD not supported");
+    }
+    if (params.withAAD && args[aadStart] !== undefined)
+      abytes(args[aadStart], undefined, "AAD");
     const cipher = constructor(key, ...args);
     const checkOutput = (fnLength, output) => {
       if (output !== undefined) {
@@ -8502,14 +8515,14 @@ var wrapCipher = (params, constructor) => {
         if (called)
           throw new Error("cannot encrypt() twice with same key + nonce");
         called = true;
-        abytes(data);
+        abytes(data, undefined, "data");
         checkOutput(cipher.encrypt.length, output);
         return cipher.encrypt(data, output);
       },
       decrypt(data, output) {
-        abytes(data);
+        abytes(data, undefined, "data");
         if (tagl && data.length < tagl)
-          throw new Error('"ciphertext" expected length bigger than tagLength=' + tagl);
+          throw new Error('"ciphertext" expected length >= tagLength=' + tagl);
         checkOutput(cipher.decrypt.length, output);
         return cipher.decrypt(data, output);
       }
@@ -8522,9 +8535,7 @@ var wrapCipher = (params, constructor) => {
 function getOutput(expectedLength, out, onlyAligned = true) {
   if (out === undefined)
     return new Uint8Array(expectedLength);
-  abytes(out, undefined, "output");
-  if (out.length !== expectedLength)
-    throw new Error('"output" expected Uint8Array of length ' + expectedLength + ", got: " + out.length);
+  abytes(out, expectedLength, "output");
   if (onlyAligned && !isAligned32(out))
     throw new Error("invalid output, must be aligned");
   return out;
@@ -8641,7 +8652,7 @@ function createCipher(core, opts) {
     let k32 = u32(k);
     if (extendNonceFn) {
       if (nonce.length !== 24)
-        throw new Error(`arx: extended nonce must be 24 bytes`);
+        throw new Error("arx: extended nonce must be 24 bytes");
       const n16 = nonce.subarray(0, 16);
       if (isLE)
         extendNonceFn(sigma, k32, u32(n16), k32);
@@ -8677,6 +8688,7 @@ function createCipher(core, opts) {
 function u8to16(a, i) {
   return a[i++] & 255 | (a[i++] & 255) << 8;
 }
+
 class Poly1305 {
   blockLen = 16;
   outputLen = 16;
@@ -9011,83 +9023,24 @@ function chachaCore(s, k, n, out, cnt, rounds = 20) {
   out[oi++] = y15 + x15 | 0;
 }
 function hchacha(s, k, i, out) {
-  let x00 = swap8IfBE(s[0]), x01 = swap8IfBE(s[1]), x02 = swap8IfBE(s[2]), x03 = swap8IfBE(s[3]), x04 = swap8IfBE(k[0]), x05 = swap8IfBE(k[1]), x06 = swap8IfBE(k[2]), x07 = swap8IfBE(k[3]), x08 = swap8IfBE(k[4]), x09 = swap8IfBE(k[5]), x10 = swap8IfBE(k[6]), x11 = swap8IfBE(k[7]), x12 = swap8IfBE(i[0]), x13 = swap8IfBE(i[1]), x14 = swap8IfBE(i[2]), x15 = swap8IfBE(i[3]);
-  for (let r = 0;r < 20; r += 2) {
-    x00 = x00 + x04 | 0;
-    x12 = rotl(x12 ^ x00, 16);
-    x08 = x08 + x12 | 0;
-    x04 = rotl(x04 ^ x08, 12);
-    x00 = x00 + x04 | 0;
-    x12 = rotl(x12 ^ x00, 8);
-    x08 = x08 + x12 | 0;
-    x04 = rotl(x04 ^ x08, 7);
-    x01 = x01 + x05 | 0;
-    x13 = rotl(x13 ^ x01, 16);
-    x09 = x09 + x13 | 0;
-    x05 = rotl(x05 ^ x09, 12);
-    x01 = x01 + x05 | 0;
-    x13 = rotl(x13 ^ x01, 8);
-    x09 = x09 + x13 | 0;
-    x05 = rotl(x05 ^ x09, 7);
-    x02 = x02 + x06 | 0;
-    x14 = rotl(x14 ^ x02, 16);
-    x10 = x10 + x14 | 0;
-    x06 = rotl(x06 ^ x10, 12);
-    x02 = x02 + x06 | 0;
-    x14 = rotl(x14 ^ x02, 8);
-    x10 = x10 + x14 | 0;
-    x06 = rotl(x06 ^ x10, 7);
-    x03 = x03 + x07 | 0;
-    x15 = rotl(x15 ^ x03, 16);
-    x11 = x11 + x15 | 0;
-    x07 = rotl(x07 ^ x11, 12);
-    x03 = x03 + x07 | 0;
-    x15 = rotl(x15 ^ x03, 8);
-    x11 = x11 + x15 | 0;
-    x07 = rotl(x07 ^ x11, 7);
-    x00 = x00 + x05 | 0;
-    x15 = rotl(x15 ^ x00, 16);
-    x10 = x10 + x15 | 0;
-    x05 = rotl(x05 ^ x10, 12);
-    x00 = x00 + x05 | 0;
-    x15 = rotl(x15 ^ x00, 8);
-    x10 = x10 + x15 | 0;
-    x05 = rotl(x05 ^ x10, 7);
-    x01 = x01 + x06 | 0;
-    x12 = rotl(x12 ^ x01, 16);
-    x11 = x11 + x12 | 0;
-    x06 = rotl(x06 ^ x11, 12);
-    x01 = x01 + x06 | 0;
-    x12 = rotl(x12 ^ x01, 8);
-    x11 = x11 + x12 | 0;
-    x06 = rotl(x06 ^ x11, 7);
-    x02 = x02 + x07 | 0;
-    x13 = rotl(x13 ^ x02, 16);
-    x08 = x08 + x13 | 0;
-    x07 = rotl(x07 ^ x08, 12);
-    x02 = x02 + x07 | 0;
-    x13 = rotl(x13 ^ x02, 8);
-    x08 = x08 + x13 | 0;
-    x07 = rotl(x07 ^ x08, 7);
-    x03 = x03 + x04 | 0;
-    x14 = rotl(x14 ^ x03, 16);
-    x09 = x09 + x14 | 0;
-    x04 = rotl(x04 ^ x09, 12);
-    x03 = x03 + x04 | 0;
-    x14 = rotl(x14 ^ x03, 8);
-    x09 = x09 + x14 | 0;
-    x04 = rotl(x04 ^ x09, 7);
-  }
+  const s2 = isLE ? s : swap32IfBE(s.slice(0, 4));
+  const k2 = isLE ? k : swap32IfBE(k.slice(0, 8));
+  const i2 = isLE ? i : swap32IfBE(i.slice(0, 4));
+  const t = new Uint32Array(16);
+  chachaCore(s2, k2, i2.subarray(1), t, i2[0]);
   let oi = 0;
-  out[oi++] = x00;
-  out[oi++] = x01;
-  out[oi++] = x02;
-  out[oi++] = x03;
-  out[oi++] = x12;
-  out[oi++] = x13;
-  out[oi++] = x14;
-  out[oi++] = x15;
+  out[oi++] = t[0] - s2[0] | 0;
+  out[oi++] = t[1] - s2[1] | 0;
+  out[oi++] = t[2] - s2[2] | 0;
+  out[oi++] = t[3] - s2[3] | 0;
+  out[oi++] = t[12] - i2[0] | 0;
+  out[oi++] = t[13] - i2[1] | 0;
+  out[oi++] = t[14] - i2[2] | 0;
+  out[oi++] = t[15] - i2[3] | 0;
   swap32IfBE(out);
+  if (!isLE)
+    clean(s2, k2, i2);
+  clean(t);
 }
 var xchacha20 = /* @__PURE__ */ createCipher(chachaCore, {
   counterRight: false,
@@ -9147,7 +9100,7 @@ var _poly1305_aead = (xorStream) => (key, nonce, AAD) => {
     }
   };
 };
-var xchacha20poly1305 = /* @__PURE__ */ wrapCipher({ blockSize: 64, nonceLength: 24, tagLength: 16 }, /* @__PURE__ */ _poly1305_aead(xchacha20));
+var xchacha20poly1305 = /* @__PURE__ */ wrapCipher({ blockSize: 64, nonceLength: 24, tagLength: 16, withAAD: true }, /* @__PURE__ */ _poly1305_aead(xchacha20));
 
 // src/crypto.ts
 var _UTF8 = new TextEncoder;
@@ -11812,4 +11765,4 @@ export {
   ArgumentValidationError
 };
 
-//# debugId=DE208C45586A782664756E2164756E21
+//# debugId=A73B01C43FCD566E64756E2164756E21