@graphprotocol/grc-20 0.2.0 → 0.2.2

package/dist/src/base58.d.ts

@@ -1,36 +0,0 @@
-export type Base58 = string;
-/**
- * Base58 encodes the given string value.
- *
- * @example
- * ```ts
- * import { v4 as uuidv4 } from "uuid";
- *
- * const uuid = uuidv4(); // 92539817-7989-4083-ab80-e9c2b2b66669
- * const dashesRemoved = uuid.replaceAll(/-/g, ""); // 9253981779894083ab80e9c2b2b66669
- * const encoded = encodeBase58(dashesRemoved)
- * console.log(encoded) // K51CbDqxW35osbjPo5ZF77
- * ```
- *
- * @param val string to encode as base58
- * @returns the base58 encoded string
- */
-export declare function encodeBase58(val: string): Base58;
-export type UUID = string;
-/**
- * Expand the base58 encoded UUID back to its original UUID format
- *
- * @example
- * ```ts
- * const uuid = 92539817-7989-4083-ab80-e9c2b2b66669;
- * const encoded = encodeBase58(dashesRemoved); // K51CbDqxW35osbjPo5ZF77
- * const decoded = decodeBase58ToUUID(encoded); // 92539817-7989-4083-ab80-e9c2b2b66669
- *
- * expect(decoded).toEqual(uuid);
- * ```
- *
- * @param encoded base58 encoded UUID
- * @returns the expanded UUID from the base58 encoded value
- */
-export declare function decodeBase58ToUUID(encoded: string): UUID;
-//# sourceMappingURL=base58.d.ts.map

package/dist/src/base58.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base58.d.ts","sourceRoot":"","sources":["../../src/base58.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC;AAE5B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAgBhD;AAED,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC;AAE1B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAkBxD"}

package/dist/src/base58.js

@@ -1,62 +0,0 @@
-const BASE58_ALLOWED_CHARS = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
-/**
- * Base58 encodes the given string value.
- *
- * @example
- * ```ts
- * import { v4 as uuidv4 } from "uuid";
- *
- * const uuid = uuidv4(); // 92539817-7989-4083-ab80-e9c2b2b66669
- * const dashesRemoved = uuid.replaceAll(/-/g, ""); // 9253981779894083ab80e9c2b2b66669
- * const encoded = encodeBase58(dashesRemoved)
- * console.log(encoded) // K51CbDqxW35osbjPo5ZF77
- * ```
- *
- * @param val string to encode as base58
- * @returns the base58 encoded string
- */
-export function encodeBase58(val) {
-    const hex = BigInt(`0x${val}`);
-    let remainder = hex;
-    const result = []; // Use an array to store encoded characters
-    while (remainder > 0n) {
-        const mod = remainder % 58n;
-        const base58CharAtMod = BASE58_ALLOWED_CHARS[Number(mod)];
-        if (base58CharAtMod) {
-            result.push(base58CharAtMod);
-        }
-        remainder = remainder / 58n;
-    }
-    // Reverse and join the array to get the final Base58 encoded string
-    return result.reverse().join('');
-}
-/**
- * Expand the base58 encoded UUID back to its original UUID format
- *
- * @example
- * ```ts
- * const uuid = 92539817-7989-4083-ab80-e9c2b2b66669;
- * const encoded = encodeBase58(dashesRemoved); // K51CbDqxW35osbjPo5ZF77
- * const decoded = decodeBase58ToUUID(encoded); // 92539817-7989-4083-ab80-e9c2b2b66669
- *
- * expect(decoded).toEqual(uuid);
- * ```
- *
- * @param encoded base58 encoded UUID
- * @returns the expanded UUID from the base58 encoded value
- */
-export function decodeBase58ToUUID(encoded) {
-    let decoded = 0n;
-    for (const char of encoded) {
-        const index = BASE58_ALLOWED_CHARS.indexOf(char);
-        if (index === -1) {
-            throw new Error('Invalid Base58 character');
-        }
-        decoded = decoded * 58n + BigInt(index);
-    }
-    // Convert the bigint to a hex string, padded to 32 characters
-    let hexStr = decoded.toString(16);
-    hexStr = hexStr.padStart(32, '0'); // Ensure it is 32 characters
-    return [hexStr.slice(0, 8), hexStr.slice(8, 12), hexStr.slice(12, 16), hexStr.slice(16, 20), hexStr.slice(20)].join('-');
-}
-//# sourceMappingURL=base58.js.map

package/dist/src/base58.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"base58.js","sourceRoot":"","sources":["../../src/base58.ts"],"names":[],"mappings":"AAAA,MAAM,oBAAoB,GAAG,4DAA4D,CAAC;AAI1F;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,YAAY,CAAC,GAAW;IACtC,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,GAAG,EAAE,CAAC,CAAC;IAC/B,IAAI,SAAS,GAAG,GAAG,CAAC;IACpB,MAAM,MAAM,GAAa,EAAE,CAAC,CAAC,2CAA2C;IAExE,OAAO,SAAS,GAAG,EAAE,EAAE,CAAC;QACtB,MAAM,GAAG,GAAG,SAAS,GAAG,GAAG,CAAC;QAC5B,MAAM,eAAe,GAAG,oBAAoB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;QAC1D,IAAI,eAAe,EAAE,CAAC;YACpB,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC/B,CAAC;QACD,SAAS,GAAG,SAAS,GAAG,GAAG,CAAC;IAC9B,CAAC;IAED,oEAAoE;IACpE,OAAO,MAAM,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AACnC,CAAC;AAID;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,kBAAkB,CAAC,OAAe;IAChD,IAAI,OAAO,GAAG,EAAE,CAAC;IAEjB,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE,CAAC;QAC3B,MAAM,KAAK,GAAG,oBAAoB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACjD,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAC9C,CAAC;QACD,OAAO,GAAG,OAAO,GAAG,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;IAED,8DAA8D;IAC9D,IAAI,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAClC,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC,6BAA6B;IAEhE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CACjH,GAAG,CACJ,CAAC;AACJ,CAAC"}

package/dist/src/base58.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=base58.test.d.ts.map

package/dist/src/base58.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base58.test.d.ts","sourceRoot":"","sources":["../../src/base58.test.ts"],"names":[],"mappings":""}

package/dist/src/base58.test.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=base58.test.js.map

package/dist/src/base58.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"base58.test.js","sourceRoot":"","sources":["../../src/base58.test.ts"],"names":[],"mappings":""}

package/dist/src/core/ids/generate.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=generate.d.ts.map

package/dist/src/core/ids/generate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../../src/core/ids/generate.ts"],"names":[],"mappings":""}

package/dist/src/core/ids/generate.js

@@ -1,4 +0,0 @@
-import { createGeoId } from '~/src/id.js';
-console.log('generating new id');
-console.log(createGeoId());
-//# sourceMappingURL=generate.js.map

package/dist/src/core/ids/generate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate.js","sourceRoot":"","sources":["../../../../src/core/ids/generate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC;AACjC,OAAO,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC"}

package/dist/src/core/position-strings/cursors.d.ts

@@ -1,56 +0,0 @@
-/**
- * Utilities for working with cursors in a collaborative list
- * or text string.
- *
- * A *cursor* points to a particular spot in a list, in between
- * two list elements (or text characters). This class handles
- * cursors for lists that use our position strings.
- *
- * A cursor is represented as a string.
- * Specifically, it is the position of the element
- * to its left, or `PositionSource.FIRST` if it is at the beginning
- * of the list. If that position is later deleted, the cursor stays the
- * same, but its index shifts to next element on its left.
- *
- * You can use cursor strings as ordinary cursors, selection endpoints,
- * range endpoints for a comment or formatting span, etc.
- */
-export declare class Cursors {
-    private constructor();
-    /**
-     * Returns the cursor at `index` within the given list of positions. Invert with `Cursors.toIndex`.
-     *
-     * That is, the cursor is between the list elements at `index - 1` and `index`.
-     *
-     * If this method is inconvenient (e.g., the positions are in a database
-     * instead of an array), you can instead run the following algorithm yourself:
-     * - If `index` is 0, return `PositionSource.FIRST = ""`.
-     * - Else return `positions[index - 1]`.
-     *
-     * @param positions The target list's positions, in lexicographic order.
-     * There should be no duplicate positions.
-     */
-    static fromIndex(index: number, positions: ArrayLike<string>): string;
-    /**
-     * Returns the current index of `cursor` within the given list of
-     * positions. Inverse of `Cursors.fromIndex`.
-     *
-     * That is, the cursor is between the list elements at `index - 1` and `index`.
-     *
-     * If this method is inconvenient (e.g., the positions are in a database
-     * instead of an array), you can instead compute
-     * `index` by finding the number of positions less than
-     * or equal to `position`.
-     * For example, in SQL, use:
-     * ```sql
-     * SELECT COUNT(*) FROM table WHERE position <= $position
-     * ```
-     *
-     * See also: `findPosition`.
-     *
-     * @param positions The target list's positions, in lexicographic order.
-     * There should be no duplicate positions.
-     */
-    static toIndex(cursor: string, positions: ArrayLike<string>): number;
-}
-//# sourceMappingURL=cursors.d.ts.map

package/dist/src/core/position-strings/cursors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cursors.d.ts","sourceRoot":"","sources":["../../../../src/core/position-strings/cursors.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,OAAO;IAClB,OAAO;IAIP;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM;IAKrE;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM;CAMrE"}

package/dist/src/core/position-strings/cursors.js

@@ -1,69 +0,0 @@
-import { findPosition } from './find-position.js';
-import { PositionSource } from './position-source.js';
-import { precond } from './util.js';
-/**
- * Utilities for working with cursors in a collaborative list
- * or text string.
- *
- * A *cursor* points to a particular spot in a list, in between
- * two list elements (or text characters). This class handles
- * cursors for lists that use our position strings.
- *
- * A cursor is represented as a string.
- * Specifically, it is the position of the element
- * to its left, or `PositionSource.FIRST` if it is at the beginning
- * of the list. If that position is later deleted, the cursor stays the
- * same, but its index shifts to next element on its left.
- *
- * You can use cursor strings as ordinary cursors, selection endpoints,
- * range endpoints for a comment or formatting span, etc.
- */
-export class Cursors {
-    constructor() {
-        // Not instantiable.
-    }
-    /**
-     * Returns the cursor at `index` within the given list of positions. Invert with `Cursors.toIndex`.
-     *
-     * That is, the cursor is between the list elements at `index - 1` and `index`.
-     *
-     * If this method is inconvenient (e.g., the positions are in a database
-     * instead of an array), you can instead run the following algorithm yourself:
-     * - If `index` is 0, return `PositionSource.FIRST = ""`.
-     * - Else return `positions[index - 1]`.
-     *
-     * @param positions The target list's positions, in lexicographic order.
-     * There should be no duplicate positions.
-     */
-    static fromIndex(index, positions) {
-        precond(index >= 0 && index <= positions.length, 'Index out of bounds:', index, positions.length);
-        return index === 0 ? PositionSource.FIRST : positions[index - 1];
-    }
-    /**
-     * Returns the current index of `cursor` within the given list of
-     * positions. Inverse of `Cursors.fromIndex`.
-     *
-     * That is, the cursor is between the list elements at `index - 1` and `index`.
-     *
-     * If this method is inconvenient (e.g., the positions are in a database
-     * instead of an array), you can instead compute
-     * `index` by finding the number of positions less than
-     * or equal to `position`.
-     * For example, in SQL, use:
-     * ```sql
-     * SELECT COUNT(*) FROM table WHERE position <= $position
-     * ```
-     *
-     * See also: `findPosition`.
-     *
-     * @param positions The target list's positions, in lexicographic order.
-     * There should be no duplicate positions.
-     */
-    static toIndex(cursor, positions) {
-        const { index, isPresent } = findPosition(cursor, positions);
-        // findPosition gives < elements, but we want <= elements.
-        // So if there's an == element, add 1.
-        return isPresent ? index + 1 : index;
-    }
-}
-//# sourceMappingURL=cursors.js.map

package/dist/src/core/position-strings/cursors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cursors.js","sourceRoot":"","sources":["../../../../src/core/position-strings/cursors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,OAAO;IAClB;QACE,oBAAoB;IACtB,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,SAAS,CAAC,KAAa,EAAE,SAA4B;QAC1D,OAAO,CAAC,KAAK,IAAI,CAAC,IAAI,KAAK,IAAI,SAAS,CAAC,MAAM,EAAE,sBAAsB,EAAE,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;QAClG,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAE,SAAS,CAAC,KAAK,GAAG,CAAC,CAAY,CAAC;IAC/E,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,OAAO,CAAC,MAAc,EAAE,SAA4B;QACzD,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QAC7D,0DAA0D;QAC1D,sCAAsC;QACtC,OAAO,SAAS,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IACvC,CAAC;CACF"}

package/dist/src/core/position-strings/find-position.d.ts

@@ -1,24 +0,0 @@
-/**
- * Returns `{ index, isPresent }`, where:
- * - `index` is the current index of `position` in `positions`,
- * or where it would be if added.
- * - `isPresent` is true if `position` is present in `positions`.
- *
- * If this method is inconvenient (e.g., the positions are in a database
- * instead of an array), you can instead compute
- * `index` by finding the number of positions less than `position`.
- * For example, in SQL, use:
- * ```sql
- * SELECT COUNT(*) FROM table WHERE position < $position
- * ```
- *
- * See also: `Cursors.toIndex`.
- *
- * @param positions The target list's positions, in lexicographic order.
- * There should be no duplicate positions.
- */
-export declare function findPosition(position: string, positions: ArrayLike<string>): {
-    index: number;
-    isPresent: boolean;
-};
-//# sourceMappingURL=find-position.d.ts.map

package/dist/src/core/position-strings/find-position.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"find-position.d.ts","sourceRoot":"","sources":["../../../../src/core/position-strings/find-position.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAqBlH"}

package/dist/src/core/position-strings/find-position.js

@@ -1,38 +0,0 @@
-import { assert } from './util.js';
-/**
- * Returns `{ index, isPresent }`, where:
- * - `index` is the current index of `position` in `positions`,
- * or where it would be if added.
- * - `isPresent` is true if `position` is present in `positions`.
- *
- * If this method is inconvenient (e.g., the positions are in a database
- * instead of an array), you can instead compute
- * `index` by finding the number of positions less than `position`.
- * For example, in SQL, use:
- * ```sql
- * SELECT COUNT(*) FROM table WHERE position < $position
- * ```
- *
- * See also: `Cursors.toIndex`.
- *
- * @param positions The target list's positions, in lexicographic order.
- * There should be no duplicate positions.
- */
-export function findPosition(position, positions) {
-    // Binary search: index is the "rank" of position, computed using
-    // https://en.wikipedia.org/wiki/Binary_search_algorithm#Procedure_for_finding_the_leftmost_element
-    let L = 0;
-    let R = positions.length;
-    while (L < R) {
-        const m = Math.floor((L + R) / 2);
-        const left = positions[m];
-        if (left < position)
-            L = m + 1;
-        else
-            R = m;
-    }
-    const left = positions[L - 1];
-    assert((L === 0 || left < position) && (L === positions.length || left >= position), 'Bad binary search (positions out of order?):', position, L);
-    return { index: L, isPresent: left === position };
-}
-//# sourceMappingURL=find-position.js.map

package/dist/src/core/position-strings/find-position.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"find-position.js","sourceRoot":"","sources":["../../../../src/core/position-strings/find-position.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,YAAY,CAAC,QAAgB,EAAE,SAA4B;IACzE,iEAAiE;IACjE,mGAAmG;IACnG,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,IAAI,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC;IACzB,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACb,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAClC,MAAM,IAAI,GAAG,SAAS,CAAC,CAAC,CAAW,CAAC;QACpC,IAAI,IAAI,GAAG,QAAQ;YAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;;YAC1B,CAAC,GAAG,CAAC,CAAC;IACb,CAAC;IAED,MAAM,IAAI,GAAG,SAAS,CAAC,CAAC,GAAG,CAAC,CAAW,CAAC;IAExC,MAAM,CACJ,CAAC,CAAC,KAAK,CAAC,IAAI,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,SAAS,CAAC,MAAM,IAAI,IAAI,IAAI,QAAQ,CAAC,EAC5E,8CAA8C,EAC9C,QAAQ,EACR,CAAC,CACF,CAAC;IACF,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,SAAS,EAAE,IAAI,KAAK,QAAQ,EAAE,CAAC;AACpD,CAAC"}

package/dist/src/core/position-strings/ids.d.ts

@@ -1,37 +0,0 @@
-/**
- * Utitilies for generating `PositionSource` IDs
- * (the `options.ID` constructor argument).
- */
-export declare class IDs {
-    private constructor();
-    /**
-     * Default characters used in IDs: alphanumeric chars.
-     */
-    static readonly DEFAULT_CHARS: string;
-    /**
-     * The default length of an ID, in characters.
-     */
-    static readonly DEFAULT_LENGTH: number;
-    /**
-     * Returns a cryptographically random ID made of alphanumeric characters.
-     *
-     * @param options.length The length of the ID, in characters.
-     * Default: `IDs.DEFAULT_LENGTH`.
-     * @param options.chars The characters to draw from. Default: `IDs.DEFAULT_CHARS`.
-     *
-     * If specified, only the first 256 elements are used, and you achieve
-     * about `log_2(chars.length)` bits of entropy per `length`.
-     */
-    static random(options?: {
-        length?: number;
-        chars?: string;
-    }): string;
-    /**
-     * Throws an error if `ID` does not satisfy the
-     * following requirements from `PositionSource`'s constructor:
-     * - It does not contain `','` or `'.'`.
-     * - The first character is lexicographically less than `'~'` (code point 126).
-     */
-    static validate(ID: string): void;
-}
-//# sourceMappingURL=ids.d.ts.map

package/dist/src/core/position-strings/ids.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../../../src/core/position-strings/ids.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,qBAAa,GAAG;IACd,OAAO;IAIP;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAoE;IAUzG;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAK;IAE3C;;;;;;;;;OASG;IACH,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM;IA+BpE;;;;;OAKG;IACH,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;CAKlC"}

package/dist/src/core/position-strings/ids.js

@@ -1,79 +0,0 @@
-import * as crypto from 'crypto';
-import { LastInternal, precond } from './util.js';
-/**
- * Utitilies for generating `PositionSource` IDs
- * (the `options.ID` constructor argument).
- */
-export class IDs {
-    constructor() {
-        // Not instantiable.
-    }
-    /**
-     * Default characters used in IDs: alphanumeric chars.
-     */
-    static DEFAULT_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-    // Rationale for value 8:
-    // Each character of the ID gives us ~6 bits of entropy,
-    //  for a total of ~48 bits.  This gives a < 1%
-    // probability that two connected `PositionSource`s
-    // will ever choose the same IDs, even if we
-    // consider the total probability across 100,000,000
-    // documents with 1,000 IDs each
-    // (= 10 users x 100 days x 1 ID/user/day).
-    /**
-     * The default length of an ID, in characters.
-     */
-    static DEFAULT_LENGTH = 8;
-    /**
-     * Returns a cryptographically random ID made of alphanumeric characters.
-     *
-     * @param options.length The length of the ID, in characters.
-     * Default: `IDs.DEFAULT_LENGTH`.
-     * @param options.chars The characters to draw from. Default: `IDs.DEFAULT_CHARS`.
-     *
-     * If specified, only the first 256 elements are used, and you achieve
-     * about `log_2(chars.length)` bits of entropy per `length`.
-     */
-    static random(options) {
-        const length = options?.length ?? this.DEFAULT_LENGTH;
-        const chars = options?.chars ?? this.DEFAULT_CHARS;
-        const arr = new Array(length);
-        let randomValues = new Uint8Array(length);
-        if (typeof window === 'undefined') {
-            // Use Node crypto library.
-            // We use eval("require") to prevent Webpack from attempting
-            // to bundle the crypto module and complaining.
-            // In theory we should also be able to do this by
-            // adding "browser": {"crypto": false} to package.json,
-            // but that is not working, and besides, every user
-            // of this package would have to remember to do so.
-            // See https://github.com/webpack/webpack/issues/8826
-            const cryptoReal = crypto;
-            const randomBuffer = cryptoReal.randomBytes(length);
-            randomValues = new Uint8Array(randomBuffer);
-        }
-        else {
-            // Use browser crypto library.
-            window.crypto.getRandomValues(randomValues);
-        }
-        for (let i = 0; i < length; i++) {
-            // This will be biased if chars.length does not divide 256,
-            // but it will still give at least floor(log_2(chars.length))
-            // bits of entropy.
-            arr[i] = chars[randomValues[i] % chars.length];
-        }
-        return arr.join('');
-    }
-    /**
-     * Throws an error if `ID` does not satisfy the
-     * following requirements from `PositionSource`'s constructor:
-     * - It does not contain `','` or `'.'`.
-     * - The first character is lexicographically less than `'~'` (code point 126).
-     */
-    static validate(ID) {
-        precond(ID < LastInternal, 'ID must be less than', LastInternal, ':', ID);
-        precond(!ID.includes(','), "ID must not contain ',':", ID);
-        precond(!ID.includes('.'), "ID must not contain '.':", ID);
-    }
-}
-//# sourceMappingURL=ids.js.map

package/dist/src/core/position-strings/ids.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ids.js","sourceRoot":"","sources":["../../../../src/core/position-strings/ids.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEjC,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAElD;;;GAGG;AACH,MAAM,OAAO,GAAG;IACd;QACE,oBAAoB;IACtB,CAAC;IAED;;OAEG;IACH,MAAM,CAAU,aAAa,GAAW,gEAAgE,CAAC;IAEzG,yBAAyB;IACzB,wDAAwD;IACxD,+CAA+C;IAC/C,mDAAmD;IACnD,4CAA4C;IAC5C,oDAAoD;IACpD,gCAAgC;IAChC,2CAA2C;IAC3C;;OAEG;IACH,MAAM,CAAU,cAAc,GAAW,CAAC,CAAC;IAE3C;;;;;;;;;OASG;IACH,MAAM,CAAC,MAAM,CAAC,OAA6C;QACzD,MAAM,MAAM,GAAG,OAAO,EAAE,MAAM,IAAI,IAAI,CAAC,cAAc,CAAC;QACtD,MAAM,KAAK,GAAG,OAAO,EAAE,KAAK,IAAI,IAAI,CAAC,aAAa,CAAC;QAEnD,MAAM,GAAG,GAAG,IAAI,KAAK,CAAS,MAAM,CAAC,CAAC;QACtC,IAAI,YAAY,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;QAC1C,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;YAClC,2BAA2B;YAC3B,4DAA4D;YAC5D,+CAA+C;YAC/C,iDAAiD;YACjD,uDAAuD;YACvD,mDAAmD;YACnD,mDAAmD;YACnD,qDAAqD;YACrD,MAAM,UAAU,GAAG,MAAM,CAAC;YAC1B,MAAM,YAAY,GAAG,UAAU,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;YACpD,YAAY,GAAG,IAAI,UAAU,CAAC,YAAY,CAAC,CAAC;QAC9C,CAAC;aAAM,CAAC;YACN,8BAA8B;YAC9B,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC;QAC9C,CAAC;QACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAChC,2DAA2D;YAC3D,6DAA6D;YAC7D,mBAAmB;YACnB,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAE,YAAY,CAAC,CAAC,CAAY,GAAG,KAAK,CAAC,MAAM,CAAW,CAAC;QACvE,CAAC;QACD,OAAO,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACtB,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,QAAQ,CAAC,EAAU;QACxB,OAAO,CAAC,EAAE,GAAG,YAAY,EAAE,sBAAsB,EAAE,YAAY,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;QAC1E,OAAO,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,0BAA0B,EAAE,EAAE,CAAC,CAAC;QAC3D,OAAO,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,0BAA0B,EAAE,EAAE,CAAC,CAAC;IAC7D,CAAC"}

package/dist/src/core/position-strings/index.d.ts

@@ -1,5 +0,0 @@
-export * from './cursors.js';
-export * from './ids.js';
-export * from './position-source.js';
-export * from './find-position.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/core/position-strings/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/position-strings/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC"}

package/dist/src/core/position-strings/index.js

@@ -1,6 +0,0 @@
-export * from './cursors.js';
-export * from './ids.js';
-export * from './position-source.js';
-export * from './find-position.js';
-// utils.ts is internal only.
-//# sourceMappingURL=index.js.map

package/dist/src/core/position-strings/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/core/position-strings/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,6BAA6B"}

package/dist/src/core/position-strings/position-source.d.ts

@@ -1,128 +0,0 @@
-/**
- * A source of lexicographically-ordered "position strings" for
- * collaborative lists and text.
- *
- * In a collaborative list (or text string), you need a way to refer
- * to "positions" within that list that:
- * 1. Point to a specific list element (or text character).
- * 2. Are global (all users agree on them) and immutable (they do not
- * change over time).
- * 3. Can be sorted.
- * 4. Are unique, even if different users concurrently create positions
- * at the same place.
- *
- * `PositionSource` gives you such positions, in the form
- * of lexicographically-ordered strings. Specifically, `createBetween`
- * returns a new "position string" in between two existing position strings.
- *
- * These strings have the bonus properties:
- * - 5. (Non-Interleaving) If two `PositionSource`s concurrently create a (forward or backward)
- * sequence of positions at the same place,
- * their sequences will not be interleaved.
- * For example, if
- * Alice types "Hello" while Bob types "World" at the same place,
- * and they each use a `PositionSource` to create a position for each
- * character, then
- * the resulting order will be "HelloWorld" or "WorldHello", not
- * "HWeolrllod".
- * - 6. If a `PositionSource` creates positions in a forward (increasing)
- * sequence, their lengths as strings will only grow logarithmically,
- * not linearly.
- *
- * Position strings are printable ASCII. Specifically, they
- * contain alphanumeric characters, `','`, and `'.'`.
- * Also, the special string `PositionSource.LAST` is `'~'`.
- *
- * Further reading:
- * - [Fractional indexing](https://www.figma.com/blog/realtime-editing-of-ordered-sequences/#fractional-indexing),
- * a related scheme that satisfies 1-3 but not 4-6.
- * - [List CRDTs](https://mattweidner.com/2022/10/21/basic-list-crdt.html)
- * and how they map to position strings. `PositionSource` uses an optimized
- * variant of that link's string implementation.
- * - [Paper about interleaving](https://www.repository.cam.ac.uk/handle/1810/290391)
- * in collaborative text editors.
- */
-export declare class PositionSource {
-    /**
-     * A string that is less than all positions.
-     *
-     * Value: `""`.
-     */
-    static readonly FIRST: string;
-    /**
-     * A string that is greater than all positions.
-     *
-     * Value: `"~"`.
-     */
-    static readonly LAST: string;
-    /**
-     * The unique ID for this `PositionSource`.
-     */
-    readonly ID: string;
-    /**
-     * Our waypoints' long name: `,${ID}.`.
-     */
-    private readonly longName;
-    /**
-     * Variant of longName used for a position's first ID: `${ID}.`.
-     * (Otherwise every position would start with a redundant ','.)
-     */
-    private readonly firstName;
-    /**
-     * For each waypoint that we created, maps a prefix (see getPrefix)
-     * for that waypoint to its last (most recent) valueSeq.
-     * We always store the right-side version (odd valueSeq).
-     */
-    private lastValueSeqs;
-    /**
-     * Constructs a new `PositionSource`.
-     *
-     * It is okay to share a single `PositionSource` between
-     * all documents (lists/text strings) in the same JavaScript runtime.
-     *
-     * For efficiency (shorter position strings),
-     * within each JavaScript runtime, you should not use
-     * more than one `PositionSource` for the same document.
-     * An exception is if multiple logical users share the same runtime;
-     * we then recommend one `PositionSource` per user.
-     *
-     * @param options.ID A unique ID for this `PositionSource`. Defaults to
-     * `IDs.random()`.
-     *
-     * If provided, `options.ID` must satisfy:
-     * - It is unique across the entire collaborative application, i.e.,
-     * all `PositionSource`s whose positions may be compared to ours. This
-     * includes past `PositionSource`s, even if they correspond to the same
-     * user/device.
-     * - It does not contain `','` or `'.'`.
-     * - The first character is lexicographically less than `'~'` (code point 126).
-     *
-     * If `options.ID` contains non-alphanumeric characters, then created
-     * positions will contain those characters in addition to
-     * alphanumeric characters, `','`, and `'.'`.
-     */
-    constructor(options?: {
-        ID?: string;
-    });
-    /**
-     * Returns a new position between `left` and `right`
-     * (`left < new < right`).
-     *
-     * The new position is unique across the entire collaborative application,
-     * even in the face of concurrent calls to this method on other
-     * `PositionSource`s.
-     *
-     * @param left Defaults to `PositionSource.FIRST` (insert at the beginning).
-     *
-     * @param right Defaults to `PositionSource.LAST` (insert at the end).
-     */
-    createBetween(left?: string, right?: string): string;
-    /**
-     * Appends a wayoint to the given ancestor (= prefix adjusted for
-     * side), returning a unique new position using that waypoint.
-     *
-     * lastValueSeqs is also updated as needed for the waypoint.
-     */
-    private appendWaypoint;
-}
-//# sourceMappingURL=position-source.d.ts.map

package/dist/src/core/position-strings/position-source.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"position-source.d.ts","sourceRoot":"","sources":["../../../../src/core/position-strings/position-source.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,qBAAa,cAAc;IACzB;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAM;IACnC;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAgB;IAE5C;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IAEnC;;;;OAIG;IACH,OAAO,CAAC,aAAa,CAA6B;IAElD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;gBACS,OAAO,CAAC,EAAE;QAAE,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE;IASrC;;;;;;;;;;;OAWG;IACH,aAAa,CAAC,IAAI,GAAE,MAA6B,EAAE,KAAK,GAAE,MAA4B,GAAG,MAAM;IA+C/F;;;;;OAKG;IACH,OAAO,CAAC,cAAc;CA2BvB"}