@effectionx/jsonl-store 0.3.1 → 0.4.0

package/esm/deps/jsr.io/@std/path/1.1.3/windows/to_namespaced_path.js

@@ -1,49 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-import { CHAR_BACKWARD_SLASH, CHAR_COLON, CHAR_DOT, CHAR_QUESTION_MARK, } from "../_common/constants.js";
-import { isWindowsDeviceRoot } from "./_util.js";
-import { resolve } from "./resolve.js";
-/**
- * Resolves path to a namespace path
- *
- * @example Usage
- * ```ts
- * import { toNamespacedPath } from "@std/path/windows/to-namespaced-path";
- * import { assertEquals } from "@std/assert";
- *
- * const namespaced = toNamespacedPath("C:\\foo\\bar");
- * assertEquals(namespaced, "\\\\?\\C:\\foo\\bar");
- * ```
- *
- * @param path The path to resolve to namespaced path
- * @returns The resolved namespaced path
- */
-export function toNamespacedPath(path) {
-    // Note: this will *probably* throw somewhere.
-    if (typeof path !== "string")
-        return path;
-    if (path.length === 0)
-        return "";
-    const resolvedPath = resolve(path);
-    if (resolvedPath.length >= 3) {
-        if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {
-            // Possible UNC root
-            if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {
-                const code = resolvedPath.charCodeAt(2);
-                if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {
-                    // Matched non-long UNC root, convert the path to a long UNC path
-                    return `\\\\?\\UNC\\${resolvedPath.slice(2)}`;
-                }
-            }
-        }
-        else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) {
-            // Possible device root
-            if (resolvedPath.charCodeAt(1) === CHAR_COLON &&
-                resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
-                // Matched device root, convert the path to a long UNC path
-                return `\\\\?\\${resolvedPath}`;
-            }
-        }
-    }
-    return path;
-}

package/esm/deps/jsr.io/@std/streams/1.0.14/_common.d.ts

@@ -1,5 +0,0 @@
-export declare const DEFAULT_CHUNK_SIZE = 16640;
-export declare const DEFAULT_BUFFER_SIZE: number;
-/** Generate longest proper prefix which is also suffix array. */
-export declare function createLPS(pat: Uint8Array): Uint8Array;
-//# sourceMappingURL=_common.d.ts.map

package/esm/deps/jsr.io/@std/streams/1.0.14/_common.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_common.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.14/_common.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB,QAAS,CAAC;AACzC,eAAO,MAAM,mBAAmB,QAAY,CAAC;AAE7C,iEAAiE;AACjE,wBAAgB,SAAS,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU,CAmBrD"}

package/esm/deps/jsr.io/@std/streams/1.0.14/_common.js

@@ -1,27 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-export const DEFAULT_CHUNK_SIZE = 16_640;
-export const DEFAULT_BUFFER_SIZE = 32 * 1024;
-/** Generate longest proper prefix which is also suffix array. */
-export function createLPS(pat) {
-    const length = pat.length;
-    const lps = new Uint8Array(length);
-    lps[0] = 0;
-    let prefixEnd = 0;
-    let i = 1;
-    while (i < length) {
-        if (pat[i] === pat[prefixEnd]) {
-            prefixEnd++;
-            lps[i] = prefixEnd;
-            i++;
-        }
-        else if (prefixEnd === 0) {
-            lps[i] = 0;
-            i++;
-        }
-        else {
-            prefixEnd = lps[prefixEnd - 1];
-        }
-    }
-    return lps;
-}

package/esm/deps/jsr.io/@std/streams/1.0.14/buffer.d.ts

@@ -1,300 +0,0 @@
-/** Options for {@linkcode Buffer.bytes}. */
-export interface BufferBytesOptions {
-    /**
-     * If true, {@linkcode Buffer.bytes} will return a copy of the buffered data.
-     *
-     * If false, it will return a slice to the buffer's data.
-     *
-     * @default {true}
-     */
-    copy?: boolean;
-}
-/**
- * A variable-sized buffer of bytes with `readable` and `writable` getters that
- * allows you to work with {@link https://developer.mozilla.org/en-US/docs/Web/API/Streams_API | Web Streams API}.
- *
- * Buffer is almost always used with some I/O like files and sockets. It allows
- * one to buffer up a download from a socket. Buffer grows and shrinks as
- * necessary.
- *
- * Buffer is NOT the same thing as Node's Buffer. Node's Buffer was created in
- * 2009 before JavaScript had the concept of ArrayBuffers. It's simply a
- * non-standard ArrayBuffer.
- *
- * ArrayBuffer is a fixed memory allocation. Buffer is implemented on top of
- * ArrayBuffer.
- *
- * Based on {@link https://golang.org/pkg/bytes/#Buffer | Go Buffer}.
- *
- * @example Buffer input bytes and convert it to a string
- * ```ts
- * import { Buffer } from "@std/streams/buffer";
- * import { toText } from "@std/streams/to-text";
- * import { assert } from "@std/assert";
- * import { assertEquals } from "@std/assert";
- *
- * // Create a new buffer
- * const buf = new Buffer();
- * assertEquals(buf.capacity, 0);
- * assertEquals(buf.length, 0);
- *
- * // Dummy input stream
- * const inputStream = ReadableStream.from([
- *   "hello, ",
- *   "world",
- *   "!",
- * ]);
- *
- * // Pipe the input stream to the buffer
- * await inputStream.pipeThrough(new TextEncoderStream()).pipeTo(buf.writable);
- * assert(buf.capacity > 0);
- * assert(buf.length > 0);
- *
- * // Convert the buffered bytes to a string
- * const result = await toText(buf.readable);
- * assertEquals(result, "hello, world!");
- * assert(buf.empty());
- * ```
- */
-export declare class Buffer {
-    #private;
-    /**
-     * Getter returning the instance's {@linkcode ReadableStream}.
-     *
-     * @returns A `ReadableStream` of the buffer.
-     *
-     * @example Read the content out of the buffer to stdout
-     * ```ts ignore
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const buf = new Buffer();
-     * await buf.readable.pipeTo(Deno.stdout.writable);
-     * ```
-     */
-    get readable(): ReadableStream<Uint8Array>;
-    /**
-     * Getter returning the instance's {@linkcode WritableStream}.
-     *
-     * @returns A `WritableStream` of the buffer.
-     *
-     * @example Write the data from stdin to the buffer
-     * ```ts ignore
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const buf = new Buffer();
-     * await Deno.stdin.readable.pipeTo(buf.writable);
-     * ```
-     */
-    get writable(): WritableStream<Uint8Array>;
-    /**
-     * Constructs a new instance.
-     *
-     * @param ab An optional buffer to use as the initial buffer.
-     */
-    constructor(ab?: ArrayBufferLike | ArrayLike<number>);
-    /**
-     * Returns a slice holding the unread portion of the buffer.
-     *
-     * The slice is valid for use only until the next buffer modification (that
-     * is, only until the next call to a method that mutates or consumes the
-     * buffer, like reading data out via `readable`, `reset()`, or `truncate()`).
-     *
-     * If `options.copy` is false the slice aliases the buffer content at least
-     * until the next buffer modification, so immediate changes to the slice will
-     * affect the result of future reads. If `options` is not provided,
-     * `options.copy` defaults to `true`.
-     *
-     * @param options Options for the bytes method.
-     * @returns A copy or a slice of the buffer.
-     *
-     * @example Copy the buffer
-     * ```ts
-     * import { assertEquals } from "@std/assert";
-     * import { assertNotEquals } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const array = new Uint8Array([0, 1, 2]);
-     * const buf = new Buffer(array.buffer);
-     * const copied = buf.bytes();
-     * assertEquals(copied.length, array.length);
-     *
-     * // Modify an element in the original array
-     * array[1] = 99;
-     * assertEquals(copied[0], array[0]);
-     * // The copied buffer is not affected by the modification
-     * assertNotEquals(copied[1], array[1]);
-     * assertEquals(copied[2], array[2]);
-     * ```
-     *
-     * @example Get a slice to the buffer
-     * ```ts
-     * import { assertEquals } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const array = new Uint8Array([0, 1, 2]);
-     * const buf = new Buffer(array.buffer);
-     * const slice = buf.bytes({ copy: false });
-     * assertEquals(slice.length, array.length);
-     *
-     * // Modify an element in the original array
-     * array[1] = 99;
-     * assertEquals(slice[0], array[0]);
-     * // The slice _is_ affected by the modification
-     * assertEquals(slice[1], array[1]);
-     * assertEquals(slice[2], array[2]);
-     * ```
-     */
-    bytes(options?: BufferBytesOptions): Uint8Array;
-    /**
-     * Returns whether the unread portion of the buffer is empty.
-     *
-     * @returns Whether the buffer is empty.
-     *
-     * @example Empty buffer
-     * ```ts
-     * import { assert } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const buf = new Buffer();
-     * assert(buf.empty());
-     * ```
-     *
-     * @example Non-empty buffer
-     * ```ts
-     * import { assert } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const array = new Uint8Array([42]);
-     * const buf = new Buffer(array.buffer);
-     * assert(!buf.empty());
-     * ```
-     *
-     * @example Non-empty, but the content was already read
-     * ```ts ignore
-     * import { assert } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const array = new Uint8Array([42]);
-     * const buf = new Buffer(array.buffer);
-     * assert(!buf.empty());
-     * // Read the content out of the buffer
-     * await buf.readable.pipeTo(Deno.stdout.writable);
-     * // The buffer is now empty
-     * assert(buf.empty());
-     * ```
-     */
-    empty(): boolean;
-    /**
-     * A read only number of bytes of the unread portion of the buffer.
-     *
-     * @returns The number of bytes in the unread portion of the buffer.
-     *
-     * @example Basic usage
-     * ```ts
-     * import { assertEquals } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const array = new Uint8Array([0, 1, 2]);
-     * const buf = new Buffer(array.buffer);
-     * assertEquals(buf.length, 3);
-     * ```
-     *
-     * @example Length becomes 0 after the content is read
-     * ```ts ignore
-     * import { assertEquals } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const array = new Uint8Array([42]);
-     * const buf = new Buffer(array.buffer);
-     * assertEquals(buf.length, 1);
-     * // Read the content out of the buffer
-     * await buf.readable.pipeTo(Deno.stdout.writable);
-     * // The length is now 0
-     * assertEquals(buf.length, 0);
-     * ```
-     */
-    get length(): number;
-    /**
-     * The read only capacity of the buffer's underlying byte slice, that is,
-     * the total space allocated for the buffer's data.
-     *
-     * @returns The number of allocated bytes for the buffer.
-     *
-     * @example Basic usage
-     * ```ts
-     * import { assertEquals } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const arrayBuffer = new ArrayBuffer(256);
-     * const buf = new Buffer(arrayBuffer);
-     * assertEquals(buf.capacity, 256);
-     * ```
-     */
-    get capacity(): number;
-    /**
-     * Discards all but the first `n` unread bytes from the buffer but
-     * continues to use the same allocated storage. It throws if `n` is
-     * negative or greater than the length of the buffer.
-     *
-     * @param n The number of bytes to keep.
-     *
-     * @example Basic usage
-     * ```ts
-     * import { assertEquals } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const array = new Uint8Array([0, 1, 2]);
-     * const buf = new Buffer(array.buffer);
-     * assertEquals(buf.bytes(), array);
-     *
-     * // Discard all but the first 2 bytes
-     * buf.truncate(2);
-     * assertEquals(buf.bytes(), array.slice(0, 2));
-     * ```
-     */
-    truncate(n: number): void;
-    /**
-     * Resets to an empty buffer.
-     *
-     * @example Basic usage
-     * ```ts
-     * import { assert } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const array = new Uint8Array([0, 1, 2]);
-     * const buf = new Buffer(array.buffer);
-     * assert(!buf.empty());
-     *
-     * // Reset
-     * buf.reset();
-     * assert(buf.empty());
-     * ```
-     */
-    reset(): void;
-    /**
-     * Grows the buffer's capacity, if necessary, to guarantee space for
-     * another `n` bytes. After `.grow(n)`, at least `n` bytes can be written to
-     * the buffer without another allocation. If `n` is negative, `.grow()` will
-     * throw. If the buffer can't grow it will throw an error.
-     *
-     * @param n The number of bytes to grow the buffer by.
-     *
-     * Based on Go Lang's
-     * {@link https://golang.org/pkg/bytes/#Buffer.Grow | Buffer.Grow}.
-     *
-     * @example Basic usage
-     * ```ts
-     * import { assert } from "@std/assert";
-     * import { assertEquals } from "@std/assert";
-     * import { Buffer } from "@std/streams/buffer";
-     *
-     * const buf = new Buffer();
-     * assertEquals(buf.capacity, 0);
-     *
-     * buf.grow(200);
-     * assert(buf.capacity >= 200);
-     * ```
-     */
-    grow(n: number): void;
-}
-//# sourceMappingURL=buffer.d.ts.map

package/esm/deps/jsr.io/@std/streams/1.0.14/buffer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buffer.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.14/buffer.ts"],"names":[],"mappings":"AAQA,4CAA4C;AAC5C,MAAM,WAAW,kBAAkB;IACjC;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,qBAAa,MAAM;;IAqBjB;;;;;;;;;;;;OAYG;IACH,IAAI,QAAQ,IAAI,cAAc,CAAC,UAAU,CAAC,CAEzC;IASD;;;;;;;;;;;;OAYG;IACH,IAAI,QAAQ,IAAI,cAAc,CAAC,UAAU,CAAC,CAEzC;IAED;;;;OAIG;gBACS,EAAE,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC,MAAM,CAAC;IAQpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmDG;IACH,KAAK,CAAC,OAAO,GAAE,kBAAmC,GAAG,UAAU;IAK/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,KAAK,IAAI,OAAO;IAIhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAazB;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK;IAoDL;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,IAAI,CAAC,CAAC,EAAE,MAAM;CASf"}