@minnowdb/core 0.6.9 → 0.7.1

package/dist/block-format/checksum.js

@@ -1,59 +1,37 @@
 const TABLES = new Uint32Array(256 * 8);
 for (let index = 0; index < 256; index += 1) {
-    let value = index;
-    for (let bit = 0; bit < 8; bit += 1) {
-        value = (value & 1) === 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
-    }
-    TABLES[index] = value >>> 0;
+  let value = index;
+  for (let bit = 0; bit < 8; bit += 1) {
+    value = (value & 1) === 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
+  }
+  TABLES[index] = value >>> 0;
 }
-// Slicing-by-8 extension tables: TABLES[k*256+b] is the CRC of byte b followed by k zero bytes,
-// letting the hot loop fold eight bytes per iteration instead of one.
 for (let slice = 1; slice < 8; slice += 1) {
-    for (let index = 0; index < 256; index += 1) {
-        const previous = TABLES[(slice - 1) * 256 + index] ?? 0;
-        TABLES[slice * 256 + index] = ((previous >>> 8) ^ (TABLES[previous & 0xff] ?? 0)) >>> 0;
-    }
+  for (let index = 0; index < 256; index += 1) {
+    const previous = TABLES[(slice - 1) * 256 + index] ?? 0;
+    TABLES[slice * 256 + index] = (previous >>> 8 ^ (TABLES[previous & 255] ?? 0)) >>> 0;
+  }
 }
-/**
- * CRC-32 (IEEE) via slicing-by-8. Every decoded block is checksummed end to end, so this is a
- * per-query hot path: eight table folds per 8-byte word beat the byte-at-a-time loop several
- * times over, and the tail falls back to single-byte steps.
- */
-export function crc32(bytes) {
-    return crc32Continue(0, bytes);
+function crc32(bytes) {
+  return crc32Continue(0, bytes);
 }
-/** Extends an already-finalized CRC-32 without concatenating or retaining the preceding bytes. */
-export function crc32Continue(previous, bytes) {
-    let checksum = (previous ^ 0xffffffff) >>> 0;
-    const length = bytes.byteLength;
-    const wordEnd = length - (length % 8);
-    let index = 0;
-    while (index < wordEnd) {
-        const low = (checksum ^
-            ((bytes[index] ?? 0) |
-                ((bytes[index + 1] ?? 0) << 8) |
-                ((bytes[index + 2] ?? 0) << 16) |
-                ((bytes[index + 3] ?? 0) << 24))) >>>
-            0;
-        const high = ((bytes[index + 4] ?? 0) |
-            ((bytes[index + 5] ?? 0) << 8) |
-            ((bytes[index + 6] ?? 0) << 16) |
-            ((bytes[index + 7] ?? 0) << 24)) >>>
-            0;
-        checksum =
-            ((TABLES[1792 + (low & 0xff)] ?? 0) ^
-                (TABLES[1536 + ((low >>> 8) & 0xff)] ?? 0) ^
-                (TABLES[1280 + ((low >>> 16) & 0xff)] ?? 0) ^
-                (TABLES[1024 + (low >>> 24)] ?? 0) ^
-                (TABLES[768 + (high & 0xff)] ?? 0) ^
-                (TABLES[512 + ((high >>> 8) & 0xff)] ?? 0) ^
-                (TABLES[256 + ((high >>> 16) & 0xff)] ?? 0) ^
-                (TABLES[high >>> 24] ?? 0)) >>>
-                0;
-        index += 8;
-    }
-    for (; index < length; index += 1) {
-        checksum = (checksum >>> 8) ^ (TABLES[(checksum ^ (bytes[index] ?? 0)) & 0xff] ?? 0);
-    }
-    return (checksum ^ 0xffffffff) >>> 0;
+function crc32Continue(previous, bytes) {
+  let checksum = (previous ^ 4294967295) >>> 0;
+  const length = bytes.byteLength;
+  const wordEnd = length - length % 8;
+  let index = 0;
+  while (index < wordEnd) {
+    const low = (checksum ^ ((bytes[index] ?? 0) | (bytes[index + 1] ?? 0) << 8 | (bytes[index + 2] ?? 0) << 16 | (bytes[index + 3] ?? 0) << 24)) >>> 0;
+    const high = ((bytes[index + 4] ?? 0) | (bytes[index + 5] ?? 0) << 8 | (bytes[index + 6] ?? 0) << 16 | (bytes[index + 7] ?? 0) << 24) >>> 0;
+    checksum = ((TABLES[1792 + (low & 255)] ?? 0) ^ (TABLES[1536 + (low >>> 8 & 255)] ?? 0) ^ (TABLES[1280 + (low >>> 16 & 255)] ?? 0) ^ (TABLES[1024 + (low >>> 24)] ?? 0) ^ (TABLES[768 + (high & 255)] ?? 0) ^ (TABLES[512 + (high >>> 8 & 255)] ?? 0) ^ (TABLES[256 + (high >>> 16 & 255)] ?? 0) ^ (TABLES[high >>> 24] ?? 0)) >>> 0;
+    index += 8;
+  }
+  for (; index < length; index += 1) {
+    checksum = checksum >>> 8 ^ (TABLES[(checksum ^ (bytes[index] ?? 0)) & 255] ?? 0);
+  }
+  return (checksum ^ 4294967295) >>> 0;
 }
+export {
+  crc32,
+  crc32Continue
+};

package/dist/block-format/codecs.js

@@ -1,143 +1,130 @@
-/** A caller's explicit compressed-output ceiling was reached before an output join/allocation. */
-export class CompressionOutputLimitError extends RangeError {
-    byteLength;
-    maximumOutputLength;
-    constructor(byteLength, maximumOutputLength) {
-        super("Compressed payload exceeds caller output ceiling");
-        this.byteLength = byteLength;
-        this.maximumOutputLength = maximumOutputLength;
-        this.name = "CompressionOutputLimitError";
-    }
+class CompressionOutputLimitError extends RangeError {
+  byteLength;
+  maximumOutputLength;
+  constructor(byteLength, maximumOutputLength) {
+    super("Compressed payload exceeds caller output ceiling");
+    this.byteLength = byteLength;
+    this.maximumOutputLength = maximumOutputLength;
+    this.name = "CompressionOutputLimitError";
+  }
 }
-/**
- * The raw codec returns its input view unchanged in both directions: callers treat compressed
- * and decompressed payloads as read-only (encode copies the payload into the block envelope,
- * decode consumers only read or copy out), so a full-payload defensive copy per block would be
- * pure overhead on the default compression path. The returned view may share the caller's
- * buffer at a non-zero byte offset.
- */
 const rawCodec = {
-    id: "raw",
-    async compress(bytes, maximumOutputLength) {
-        if (maximumOutputLength !== undefined) {
-            assertCallerOutputLength(maximumOutputLength);
-            if (bytes.byteLength > maximumOutputLength) {
-                throw new CompressionOutputLimitError(bytes.byteLength, maximumOutputLength);
-            }
-        }
-        return bytes;
-    },
-    decompress(bytes, expectedLength) {
-        if (bytes.byteLength !== expectedLength)
-            throw new Error("Raw payload length mismatch");
-        return Promise.resolve(bytes);
-    },
+  id: "raw",
+  async compress(bytes, maximumOutputLength) {
+    if (maximumOutputLength !== void 0) {
+      assertCallerOutputLength(maximumOutputLength);
+      if (bytes.byteLength > maximumOutputLength) {
+        throw new CompressionOutputLimitError(bytes.byteLength, maximumOutputLength);
+      }
+    }
+    return bytes;
+  },
+  decompress(bytes, expectedLength) {
+    if (bytes.byteLength !== expectedLength)
+      throw new Error("Raw payload length mismatch");
+    return Promise.resolve(bytes);
+  }
 };
 function assertInputLength(inputLength, codec) {
-    if (!Number.isSafeInteger(inputLength) || inputLength < 0) {
-        throw new RangeError(`Invalid ${codec} input length`);
-    }
+  if (!Number.isSafeInteger(inputLength) || inputLength < 0) {
+    throw new RangeError(`Invalid ${codec} input length`);
+  }
 }
 function checkedLinearBound(inputLength, multiplier, overhead, codec) {
-    assertInputLength(inputLength, codec);
-    if (inputLength > Math.floor((Number.MAX_SAFE_INTEGER - overhead) / multiplier)) {
-        throw new RangeError(`Invalid ${codec} input length`);
-    }
-    return inputLength * multiplier + overhead;
+  assertInputLength(inputLength, codec);
+  if (inputLength > Math.floor((Number.MAX_SAFE_INTEGER - overhead) / multiplier)) {
+    throw new RangeError(`Invalid ${codec} input length`);
+  }
+  return inputLength * multiplier + overhead;
 }
-export function getCompressionMemoryBound(compression, inputLength) {
-    switch (compression) {
-        case "raw":
-            assertInputLength(inputLength, compression);
-            return { maximumOutputBytes: inputLength, scratchBytes: 0 };
-        case "gzip": {
-            // Native gzip encoders stay well below two bytes per input byte. The extra envelope keeps
-            // small and empty streams bounded too. `transform` retains an input copy and its output
-            // chunks while joining them, so include both as scratch storage at the copy boundary.
-            checkedLinearBound(inputLength, 5, 128, compression);
-            const maximumOutputBytes = checkedLinearBound(inputLength, 2, 64, compression);
-            return { maximumOutputBytes, scratchBytes: inputLength + maximumOutputBytes };
-        }
+function getCompressionMemoryBound(compression, inputLength) {
+  switch (compression) {
+    case "raw":
+      assertInputLength(inputLength, compression);
+      return { maximumOutputBytes: inputLength, scratchBytes: 0 };
+    case "gzip": {
+      checkedLinearBound(inputLength, 5, 128, compression);
+      const maximumOutputBytes = checkedLinearBound(inputLength, 2, 64, compression);
+      return { maximumOutputBytes, scratchBytes: inputLength + maximumOutputBytes };
     }
+  }
 }
 async function transform(bytes, stream, maximumOutputLength = Number.POSITIVE_INFINITY, boundErrorMessage = "Decompressed payload exceeds declared length", outputLimitError) {
-    const write = (async () => {
-        const writer = stream.writable.getWriter();
-        await writer.write(new Uint8Array(bytes));
-        await writer.close();
-    })();
-    const [writeResult, readResult] = await Promise.allSettled([
-        write,
-        readBounded(stream.readable, maximumOutputLength, boundErrorMessage, outputLimitError),
-    ]);
-    // A reader-side bound failure intentionally cancels the writer. Preserve that precise error
-    // instead of racing it against the writer rejection caused by the cancellation.
-    if (readResult.status === "rejected")
-        throw readResult.reason;
-    if (writeResult.status === "rejected")
-        throw writeResult.reason;
-    return readResult.value;
+  const write = (async () => {
+    const writer = stream.writable.getWriter();
+    await writer.write(new Uint8Array(bytes));
+    await writer.close();
+  })();
+  const [writeResult, readResult] = await Promise.allSettled([
+    write,
+    readBounded(stream.readable, maximumOutputLength, boundErrorMessage, outputLimitError)
+  ]);
+  if (readResult.status === "rejected")
+    throw readResult.reason;
+  if (writeResult.status === "rejected")
+    throw writeResult.reason;
+  return readResult.value;
 }
 async function readBounded(readable, maximumLength, boundErrorMessage, outputLimitError) {
-    const reader = readable.getReader();
-    const chunks = [];
-    let length = 0;
-    for (;;) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        length += value.byteLength;
-        if (length > maximumLength) {
-            const error = outputLimitError?.(length) ?? new Error(boundErrorMessage);
-            try {
-                await reader.cancel(error);
-            }
-            catch {
-                // Cancellation is cleanup. The deterministic bound error remains the operation result.
-            }
-            throw error;
-        }
-        chunks.push(value);
-    }
-    const output = new Uint8Array(length);
-    let offset = 0;
-    for (const chunk of chunks) {
-        output.set(chunk, offset);
-        offset += chunk.byteLength;
+  const reader = readable.getReader();
+  const chunks = [];
+  let length = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    length += value.byteLength;
+    if (length > maximumLength) {
+      const error = outputLimitError?.(length) ?? new Error(boundErrorMessage);
+      try {
+        await reader.cancel(error);
+      } catch {
+      }
+      throw error;
     }
-    return output;
+    chunks.push(value);
+  }
+  const output = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return output;
 }
-export const gzipCodec = {
-    id: "gzip",
-    async compress(bytes, maximumOutputLength) {
-        const { maximumOutputBytes } = getCompressionMemoryBound("gzip", bytes.byteLength);
-        if (maximumOutputLength !== undefined)
-            assertCallerOutputLength(maximumOutputLength);
-        const outputLimit = Math.min(maximumOutputBytes, maximumOutputLength ?? maximumOutputBytes);
-        const callerLimited = outputLimit < maximumOutputBytes;
-        return transform(bytes, new CompressionStream("gzip"), outputLimit, callerLimited
-            ? "Compressed payload exceeds caller output ceiling"
-            : "Gzip payload exceeds compression bound", callerLimited
-            ? (byteLength) => new CompressionOutputLimitError(byteLength, outputLimit)
-            : undefined);
-    },
-    async decompress(bytes, expectedLength) {
-        const output = await transform(bytes, new DecompressionStream("gzip"), expectedLength);
-        if (output.byteLength !== expectedLength)
-            throw new Error("Gzip payload length mismatch");
-        return output;
-    },
+const gzipCodec = {
+  id: "gzip",
+  async compress(bytes, maximumOutputLength) {
+    const { maximumOutputBytes } = getCompressionMemoryBound("gzip", bytes.byteLength);
+    if (maximumOutputLength !== void 0)
+      assertCallerOutputLength(maximumOutputLength);
+    const outputLimit = Math.min(maximumOutputBytes, maximumOutputLength ?? maximumOutputBytes);
+    const callerLimited = outputLimit < maximumOutputBytes;
+    return transform(bytes, new CompressionStream("gzip"), outputLimit, callerLimited ? "Compressed payload exceeds caller output ceiling" : "Gzip payload exceeds compression bound", callerLimited ? (byteLength) => new CompressionOutputLimitError(byteLength, outputLimit) : void 0);
+  },
+  async decompress(bytes, expectedLength) {
+    const output = await transform(bytes, new DecompressionStream("gzip"), expectedLength);
+    if (output.byteLength !== expectedLength)
+      throw new Error("Gzip payload length mismatch");
+    return output;
+  }
 };
 function assertCallerOutputLength(value) {
-    if (!Number.isSafeInteger(value) || value < 0) {
-        throw new RangeError("Invalid compression output ceiling");
-    }
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new RangeError("Invalid compression output ceiling");
+  }
 }
-export function getCodec(id) {
-    switch (id) {
-        case "raw":
-            return rawCodec;
-        case "gzip":
-            return gzipCodec;
-    }
+function getCodec(id) {
+  switch (id) {
+    case "raw":
+      return rawCodec;
+    case "gzip":
+      return gzipCodec;
+  }
 }
+export {
+  CompressionOutputLimitError,
+  getCodec,
+  getCompressionMemoryBound,
+  gzipCodec
+};