web-dc-api 0.0.58 → 0.0.60

package/dist/esm/node_modules/is-typed-array/index.js

@@ -0,0 +1,17 @@
+import { __require as requireWhichTypedArray } from '../which-typed-array/index.js';
+
+var isTypedArray;
+var hasRequiredIsTypedArray;
+function requireIsTypedArray() {
+  if (hasRequiredIsTypedArray) return isTypedArray;
+  hasRequiredIsTypedArray = 1;
+  var whichTypedArray = /*@__PURE__*/requireWhichTypedArray();
+
+  /** @type {import('.')} */
+  isTypedArray = function isTypedArray(value) {
+    return !!whichTypedArray(value);
+  };
+  return isTypedArray;
+}
+
+export { requireIsTypedArray as __require };

package/dist/esm/node_modules/it-all/dist/src/index.js

@@ -0,0 +1,53 @@
+/**
+ * @packageDocumentation
+ *
+ * For when you need a one-liner to collect iterable values.
+ *
+ * @example
+ *
+ * ```javascript
+ * import all from 'it-all'
+ *
+ * // This can also be an iterator, etc
+ * const values = function * () {
+ *   yield * [0, 1, 2, 3, 4]
+ * }
+ *
+ * const arr = all(values)
+ *
+ * console.info(arr) // 0, 1, 2, 3, 4
+ * ```
+ *
+ * Async sources must be awaited:
+ *
+ * ```javascript
+ * const values = async function * () {
+ *   yield * [0, 1, 2, 3, 4]
+ * }
+ *
+ * const arr = await all(values())
+ *
+ * console.info(arr) // 0, 1, 2, 3, 4
+ * ```
+ */
+function isAsyncIterable(thing) {
+  return thing[Symbol.asyncIterator] != null;
+}
+function all(source) {
+  if (isAsyncIterable(source)) {
+    return (async () => {
+      const arr = [];
+      for await (const entry of source) {
+        arr.push(entry);
+      }
+      return arr;
+    })();
+  }
+  const arr = [];
+  for (const entry of source) {
+    arr.push(entry);
+  }
+  return arr;
+}
+
+export { all as default };

package/dist/esm/node_modules/it-byte-stream/dist/src/errors.js

@@ -0,0 +1,9 @@
+/**
+ * The incoming stream ended before the expected number of bytes were read
+ */
+class UnexpectedEOFError extends Error {
+  name = 'UnexpectedEOFError';
+  code = 'ERR_UNEXPECTED_EOF';
+}
+
+export { UnexpectedEOFError };

package/dist/esm/node_modules/it-byte-stream/dist/src/index.js

@@ -0,0 +1,101 @@
+import { queuelessPushable } from '../../../it-queueless-pushable/dist/src/index.js';
+import { raceSignal } from '../../../race-signal/dist/src/index.js';
+import { Uint8ArrayList } from '../../../uint8arraylist/dist/src/index.js';
+import { UnexpectedEOFError } from './errors.js';
+
+/**
+ * @packageDocumentation
+ *
+ * This module makes it easy to send and receive bytes over streams.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { byteStream } from 'it-byte-stream'
+ *
+ * const stream = byteStream(duplex)
+ *
+ * // read the next chunk
+ * const bytes = await stream.read()
+ *
+ * // read the next five bytes
+ * const fiveBytes = await stream.read(5)
+ *
+ * // write bytes into the stream
+ * await stream.write(Uint8Array.from([0, 1, 2, 3, 4]))
+ * ```
+ */
+function byteStream(duplex, opts) {
+  const write = queuelessPushable();
+  duplex.sink(write).catch(async err => {
+    await write.end(err);
+  });
+  duplex.sink = async source => {
+    for await (const buf of source) {
+      await write.push(buf);
+    }
+    await write.end();
+  };
+  let source = duplex.source;
+  if (duplex.source[Symbol.iterator] != null) {
+    source = duplex.source[Symbol.iterator]();
+  } else if (duplex.source[Symbol.asyncIterator] != null) {
+    source = duplex.source[Symbol.asyncIterator]();
+  }
+  const readBuffer = new Uint8ArrayList();
+  const W = {
+    read: async options => {
+      options?.signal?.throwIfAborted();
+      if (options?.bytes == null) {
+        // just read whatever arrives
+        const {
+          done,
+          value
+        } = await raceSignal(source.next(), options?.signal);
+        if (done === true) {
+          return null;
+        }
+        return value;
+      }
+      while (readBuffer.byteLength < options.bytes) {
+        const {
+          value,
+          done
+        } = await raceSignal(source.next(), options?.signal);
+        if (done === true) {
+          throw new UnexpectedEOFError('unexpected end of input');
+        }
+        readBuffer.append(value);
+      }
+      const buf = readBuffer.sublist(0, options.bytes);
+      readBuffer.consume(options.bytes);
+      return buf;
+    },
+    write: async (data, options) => {
+      options?.signal?.throwIfAborted();
+      // just write
+      if (data instanceof Uint8Array) {
+        await write.push(data, options);
+      } else {
+        await write.push(data.subarray(), options);
+      }
+    },
+    unwrap: () => {
+      if (readBuffer.byteLength > 0) {
+        const originalStream = duplex.source;
+        duplex.source = async function* () {
+          if (opts?.yieldBytes === false) {
+            yield readBuffer;
+          } else {
+            yield* readBuffer;
+          }
+          yield* originalStream;
+        }();
+      }
+      return duplex;
+    }
+  };
+  return W;
+}
+
+export { byteStream };

package/dist/esm/node_modules/it-drain/dist/src/index.js

@@ -0,0 +1,42 @@
+/**
+ * @packageDocumentation
+ *
+ * Mostly useful for tests or when you want to be explicit about consuming an iterable without doing anything with any yielded values.
+ *
+ * @example
+ *
+ * ```javascript
+ * import drain from 'it-drain'
+ *
+ * // This can also be an iterator, generator, etc
+ * const values = [0, 1, 2, 3, 4]
+ *
+ * drain(values)
+ * ```
+ *
+ * Async sources must be awaited:
+ *
+ * ```javascript
+ * import drain from 'it-drain'
+ *
+ * const values = async function * {
+ *   yield * [0, 1, 2, 3, 4]
+ * }
+ *
+ * await drain(values())
+ * ```
+ */
+function isAsyncIterable(thing) {
+  return thing[Symbol.asyncIterator] != null;
+}
+function drain(source) {
+  if (isAsyncIterable(source)) {
+    return (async () => {
+      for await (const _ of source) {} // eslint-disable-line no-empty,@typescript-eslint/no-unused-vars
+    })();
+  } else {
+    for (const _ of source) {} // eslint-disable-line no-empty,@typescript-eslint/no-unused-vars
+  }
+}
+
+export { drain as default };

package/dist/esm/node_modules/it-filter/dist/src/index.js

@@ -0,0 +1,91 @@
+import peekable from '../../../it-peekable/dist/src/index.js';
+
+/**
+ * @packageDocumentation
+ *
+ * Filter values out of an (async)iterable
+ *
+ * @example
+ *
+ * ```javascript
+ * import all from 'it-all'
+ * import filter from 'it-filter'
+ *
+ * // This can also be an iterator, generator, etc
+ * const values = [0, 1, 2, 3, 4]
+ *
+ * const fn = (val, index) => val > 2 // Return boolean to keep item
+ *
+ * const arr = all(filter(values, fn))
+ *
+ * console.info(arr) // 3, 4
+ * ```
+ *
+ * Async sources and filter functions must be awaited:
+ *
+ * ```javascript
+ * import all from 'it-all'
+ * import filter from 'it-filter'
+ *
+ * const values = async function * () {
+ *   yield * [0, 1, 2, 3, 4]
+ * }
+ *
+ * const fn = async val => (val, index) > 2 // Return boolean or promise of boolean to keep item
+ *
+ * const arr = await all(filter(values, fn))
+ *
+ * console.info(arr) // 3, 4
+ * ```
+ */
+function isAsyncIterable(thing) {
+  return thing[Symbol.asyncIterator] != null;
+}
+function filter(source, fn) {
+  let index = 0;
+  if (isAsyncIterable(source)) {
+    return async function* () {
+      for await (const entry of source) {
+        if (await fn(entry, index++)) {
+          yield entry;
+        }
+      }
+    }();
+  }
+  // if mapping function returns a promise we have to return an async generator
+  const peekable$1 = peekable(source);
+  const {
+    value,
+    done
+  } = peekable$1.next();
+  if (done === true) {
+    return function* () {}();
+  }
+  const res = fn(value, index++);
+  // @ts-expect-error .then is not present on O
+  if (typeof res.then === 'function') {
+    return async function* () {
+      if (await res) {
+        yield value;
+      }
+      for (const entry of peekable$1) {
+        if (await fn(entry, index++)) {
+          yield entry;
+        }
+      }
+    }();
+  }
+  const func = fn;
+  return function* () {
+    if (res === true) {
+      yield value;
+    }
+    for (const entry of peekable$1) {
+      if (func(entry, index++)) {
+        yield entry;
+      }
+    }
+  }();
+}
+
+export { filter as default };

package/dist/esm/node_modules/it-foreach/dist/src/index.js

@@ -0,0 +1,94 @@
+import peekable from '../../../it-peekable/dist/src/index.js';
+
+/**
+ * @packageDocumentation
+ *
+ * Calls a function for each value in an (async)iterable.
+ *
+ * The function can be sync or async.
+ *
+ * Async functions can be awaited on so may slow down processing of the (async)iterable.
+ *
+ * @example
+ *
+ * ```javascript
+ * import each from 'it-foreach'
+ * import drain from 'it-drain'
+ *
+ * // This can also be an iterator, generator, etc
+ * const values = [0, 1, 2, 3, 4]
+ *
+ * // prints [0, 0], [1, 1], [2, 2], [3, 3], [4, 4]
+ * const arr = drain(
+ *   each(values, console.info)
+ * )
+ * ```
+ *
+ * Async sources and callbacks must be awaited:
+ *
+ * ```javascript
+ * import each from 'it-foreach'
+ * import drain from 'it-drain'
+ *
+ * const values = async function * () {
+ *   yield * [0, 1, 2, 3, 4]
+ * }
+ *
+ * // prints [0, 0], [1, 1], [2, 2], [3, 3], [4, 4]
+ * const arr = await drain(
+ *   each(values(), console.info)
+ * )
+ * ```
+ */
+function isAsyncIterable(thing) {
+  return thing[Symbol.asyncIterator] != null;
+}
+function isPromise(thing) {
+  return thing?.then != null;
+}
+function forEach(source, fn) {
+  let index = 0;
+  if (isAsyncIterable(source)) {
+    return async function* () {
+      for await (const val of source) {
+        const res = fn(val, index++);
+        if (isPromise(res)) {
+          await res;
+        }
+        yield val;
+      }
+    }();
+  }
+  // if fn function returns a promise we have to return an async generator
+  const peekable$1 = peekable(source);
+  const {
+    value,
+    done
+  } = peekable$1.next();
+  if (done === true) {
+    return function* () {}();
+  }
+  const res = fn(value, index++);
+  if (typeof res?.then === 'function') {
+    return async function* () {
+      yield value;
+      for (const val of peekable$1) {
+        const res = fn(val, index++);
+        if (isPromise(res)) {
+          await res;
+        }
+        yield val;
+      }
+    }();
+  }
+  const func = fn;
+  return function* () {
+    yield value;
+    for (const val of peekable$1) {
+      func(val, index++);
+      yield val;
+    }
+  }();
+}
+
+export { forEach as default };

package/dist/esm/node_modules/it-length-prefixed/dist/src/constants.js

@@ -0,0 +1,6 @@
+// Maximum length of the length section of the message
+const MAX_LENGTH_LENGTH = 8; // Varint.encode(Number.MAX_SAFE_INTEGER).length
+// Maximum length of the data section of the message
+const MAX_DATA_LENGTH = 1024 * 1024 * 4;
+
+export { MAX_DATA_LENGTH, MAX_LENGTH_LENGTH };

package/dist/esm/node_modules/it-length-prefixed/dist/src/decode.js

@@ -0,0 +1,131 @@
+import { decode as decode$1, encodingLength } from '../../../uint8-varint/dist/src/index.js';
+import { Uint8ArrayList } from '../../../uint8arraylist/dist/src/index.js';
+import { MAX_LENGTH_LENGTH, MAX_DATA_LENGTH } from './constants.js';
+import { UnexpectedEOFError, InvalidMessageLengthError, InvalidDataLengthError, InvalidDataLengthLengthError } from './errors.js';
+import { isAsyncIterable } from './utils.js';
+
+/* eslint max-depth: ["error", 6] */
+var ReadMode;
+(function (ReadMode) {
+  ReadMode[ReadMode["LENGTH"] = 0] = "LENGTH";
+  ReadMode[ReadMode["DATA"] = 1] = "DATA";
+})(ReadMode || (ReadMode = {}));
+const defaultDecoder = buf => {
+  const length = decode$1(buf);
+  defaultDecoder.bytes = encodingLength(length);
+  return length;
+};
+defaultDecoder.bytes = 0;
+function decode(source, options) {
+  const buffer = new Uint8ArrayList();
+  let mode = ReadMode.LENGTH;
+  let dataLength = -1;
+  const lengthDecoder = options?.lengthDecoder ?? defaultDecoder;
+  const maxLengthLength = options?.maxLengthLength ?? MAX_LENGTH_LENGTH;
+  const maxDataLength = options?.maxDataLength ?? MAX_DATA_LENGTH;
+  function* maybeYield() {
+    while (buffer.byteLength > 0) {
+      if (mode === ReadMode.LENGTH) {
+        // read length, ignore errors for short reads
+        try {
+          dataLength = lengthDecoder(buffer);
+          if (dataLength < 0) {
+            throw new InvalidMessageLengthError('Invalid message length');
+          }
+          if (dataLength > maxDataLength) {
+            throw new InvalidDataLengthError('Message length too long');
+          }
+          const dataLengthLength = lengthDecoder.bytes;
+          buffer.consume(dataLengthLength);
+          if (options?.onLength != null) {
+            options.onLength(dataLength);
+          }
+          mode = ReadMode.DATA;
+        } catch (err) {
+          if (err instanceof RangeError) {
+            if (buffer.byteLength > maxLengthLength) {
+              throw new InvalidDataLengthLengthError('Message length length too long');
+            }
+            break;
+          }
+          throw err;
+        }
+      }
+      if (mode === ReadMode.DATA) {
+        if (buffer.byteLength < dataLength) {
+          // not enough data, wait for more
+          break;
+        }
+        const data = buffer.sublist(0, dataLength);
+        buffer.consume(dataLength);
+        if (options?.onData != null) {
+          options.onData(data);
+        }
+        yield data;
+        mode = ReadMode.LENGTH;
+      }
+    }
+  }
+  if (isAsyncIterable(source)) {
+    return async function* () {
+      for await (const buf of source) {
+        buffer.append(buf);
+        yield* maybeYield();
+      }
+      if (buffer.byteLength > 0) {
+        throw new UnexpectedEOFError('Unexpected end of input');
+      }
+    }();
+  }
+  return function* () {
+    for (const buf of source) {
+      buffer.append(buf);
+      yield* maybeYield();
+    }
+    if (buffer.byteLength > 0) {
+      throw new UnexpectedEOFError('Unexpected end of input');
+    }
+  }();
+}
+decode.fromReader = (reader, options) => {
+  let byteLength = 1; // Read single byte chunks until the length is known
+  const varByteSource = async function* () {
+    while (true) {
+      try {
+        const {
+          done,
+          value
+        } = await reader.next(byteLength);
+        if (done === true) {
+          return;
+        }
+        if (value != null) {
+          yield value;
+        }
+      } catch (err) {
+        if (err.code === 'ERR_UNDER_READ') {
+          return {
+            done: true,
+            value: null
+          };
+        }
+        throw err;
+      } finally {
+        // Reset the byteLength so we continue to check for varints
+        byteLength = 1;
+      }
+    }
+  }();
+  /**
+   * Once the length has been parsed, read chunk for that length
+   */
+  const onLength = l => {
+    byteLength = l;
+  };
+  return decode(varByteSource, {
+    ...(options ?? {}),
+    onLength
+  });
+};
+
+export { decode };

package/dist/esm/node_modules/it-length-prefixed/dist/src/encode.js

@@ -0,0 +1,64 @@
+import { encodingLength, encode as encode$1 } from '../../../uint8-varint/dist/src/index.js';
+import { Uint8ArrayList } from '../../../uint8arraylist/dist/src/index.js';
+import { allocUnsafe } from '../../../uint8arrays/dist/src/alloc.js';
+import { MAX_DATA_LENGTH } from './constants.js';
+import { InvalidDataLengthError } from './errors.js';
+import { isAsyncIterable } from './utils.js';
+
+// Helper function to validate the chunk size against maxDataLength
+function validateMaxDataLength(chunk, maxDataLength) {
+  if (chunk.byteLength > maxDataLength) {
+    throw new InvalidDataLengthError('Message length too long');
+  }
+}
+const defaultEncoder = length => {
+  const lengthLength = encodingLength(length);
+  const lengthBuf = allocUnsafe(lengthLength);
+  encode$1(length, lengthBuf);
+  defaultEncoder.bytes = lengthLength;
+  return lengthBuf;
+};
+defaultEncoder.bytes = 0;
+function encode(source, options) {
+  options = options ?? {};
+  const encodeLength = options.lengthEncoder ?? defaultEncoder;
+  const maxDataLength = options?.maxDataLength ?? MAX_DATA_LENGTH;
+  function* maybeYield(chunk) {
+    validateMaxDataLength(chunk, maxDataLength);
+    // length + data
+    const length = encodeLength(chunk.byteLength);
+    // yield only Uint8Arrays
+    if (length instanceof Uint8Array) {
+      yield length;
+    } else {
+      yield* length;
+    }
+    // yield only Uint8Arrays
+    if (chunk instanceof Uint8Array) {
+      yield chunk;
+    } else {
+      yield* chunk;
+    }
+  }
+  if (isAsyncIterable(source)) {
+    return async function* () {
+      for await (const chunk of source) {
+        yield* maybeYield(chunk);
+      }
+    }();
+  }
+  return function* () {
+    for (const chunk of source) {
+      yield* maybeYield(chunk);
+    }
+  }();
+}
+encode.single = (chunk, options) => {
+  options = options ?? {};
+  const encodeLength = options.lengthEncoder ?? defaultEncoder;
+  const maxDataLength = options?.maxDataLength ?? MAX_DATA_LENGTH;
+  validateMaxDataLength(chunk, maxDataLength);
+  return new Uint8ArrayList(encodeLength(chunk.byteLength), chunk);
+};
+
+export { encode };

package/dist/esm/node_modules/it-length-prefixed/dist/src/errors.js

@@ -0,0 +1,32 @@
+/**
+ * The reported length of the next data message was not a positive integer
+ */
+class InvalidMessageLengthError extends Error {
+  name = 'InvalidMessageLengthError';
+  code = 'ERR_INVALID_MSG_LENGTH';
+}
+/**
+ * The reported length of the next data message was larger than the configured
+ * max allowable value
+ */
+class InvalidDataLengthError extends Error {
+  name = 'InvalidDataLengthError';
+  code = 'ERR_MSG_DATA_TOO_LONG';
+}
+/**
+ * The varint used to specify the length of the next data message contained more
+ * bytes than the configured max allowable value
+ */
+class InvalidDataLengthLengthError extends Error {
+  name = 'InvalidDataLengthLengthError';
+  code = 'ERR_MSG_LENGTH_TOO_LONG';
+}
+/**
+ * The incoming stream ended before the expected number of bytes were read
+ */
+class UnexpectedEOFError extends Error {
+  name = 'UnexpectedEOFError';
+  code = 'ERR_UNEXPECTED_EOF';
+}
+
+export { InvalidDataLengthError, InvalidDataLengthLengthError, InvalidMessageLengthError, UnexpectedEOFError };

package/dist/esm/node_modules/it-length-prefixed/dist/src/utils.js

@@ -0,0 +1,5 @@
+function isAsyncIterable(thing) {
+  return thing[Symbol.asyncIterator] != null;
+}
+
+export { isAsyncIterable };

package/dist/esm/node_modules/it-length-prefixed-stream/dist/src/errors.js

@@ -0,0 +1,25 @@
+/**
+ * The reported length of the next data message was not a positive integer
+ */
+class InvalidMessageLengthError extends Error {
+  name = 'InvalidMessageLengthError';
+  code = 'ERR_INVALID_MSG_LENGTH';
+}
+/**
+ * The reported length of the next data message was larger than the configured
+ * max allowable value
+ */
+class InvalidDataLengthError extends Error {
+  name = 'InvalidDataLengthError';
+  code = 'ERR_MSG_DATA_TOO_LONG';
+}
+/**
+ * The varint used to specify the length of the next data message contained more
+ * bytes than the configured max allowable value
+ */
+class InvalidDataLengthLengthError extends Error {
+  name = 'InvalidDataLengthLengthError';
+  code = 'ERR_MSG_LENGTH_TOO_LONG';
+}
+
+export { InvalidDataLengthError, InvalidDataLengthLengthError, InvalidMessageLengthError };