@fluidframework/container-runtime 2.0.0-internal.6.1.1 → 2.0.0-internal.6.2.0

package/lib/id-compressor/utils.js

@@ -1,79 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * Fails true iff `array` has at least `length` elements
- */
-export function hasAtLeastLength(array, length) {
-    return array.length >= length;
-}
-/**
- * A numeric comparator used for sorting in ascending order.
- *
- * Handles +/-0 like Map: -0 is equal to +0.
- */
-export function compareFiniteNumbers(a, b) {
-    return a - b;
-}
-/**
- * A numeric comparator used for sorting in descending order.
- *
- * Handles +/-0 like Map: -0 is equal to +0.
- */
-export function compareFiniteNumbersReversed(a, b) {
-    return b - a;
-}
-/**
- * Compare two maps and return true if their contents are equivalent.
- * @param mapA - The first array to compare
- * @param mapB - The second array to compare
- * @param elementComparator - The function used to check if two `T`s are equivalent.
- * Defaults to `Object.is()` equality (a shallow compare)
- */
-export function compareMaps(mapA, mapB, elementComparator = Object.is) {
-    if (mapA.size !== mapB.size) {
-        return false;
-    }
-    for (const [keyA, valueA] of mapA) {
-        const valueB = mapB.get(keyA);
-        if (valueB === undefined || !elementComparator(valueA, valueB)) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Retrieve a value from a map with the given key, or create a new entry if the key is not in the map.
- * @param map - The map to query/update
- * @param key - The key to lookup in the map
- * @param defaultValue - a function which returns a default value. This is called and used to set an initial value for the given key in the map if none exists
- * @returns either the existing value for the given key, or the newly-created value (the result of `defaultValue`)
- */
-export function getOrCreate(map, key, defaultValue) {
-    let value = map.get(key);
-    if (value === undefined) {
-        value = defaultValue(key);
-        map.set(key, value);
-    }
-    return value;
-}
-/**
- * Compares strings lexically to form a strict partial ordering.
- */
-export function compareStrings(a, b) {
-    return a > b ? 1 : a === b ? 0 : -1;
-}
-export function fail(message) {
-    throw new Error(message);
-}
-/**
- * Sets a property in such a way that it is only set on `destination` if the provided value is not undefined.
- * This avoids having explicit undefined values under properties that would cause `Object.hasOwnProperty` to return true.
- */
-export function setPropertyIfDefined(value, destination, property) {
-    if (value !== undefined) {
-        destination[property] = value;
-    }
-}
-//# sourceMappingURL=utils.js.map

package/lib/id-compressor/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/id-compressor/utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAiBH;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAC/B,KAAmB,EACnB,MAAW;IAEX,OAAO,KAAK,CAAC,MAAM,IAAI,MAAM,CAAC;AAC/B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAmB,CAAI,EAAE,CAAI;IAChE,OAAO,CAAC,GAAG,CAAC,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,4BAA4B,CAAmB,CAAI,EAAE,CAAI;IACxE,OAAO,CAAC,GAAG,CAAC,CAAC;AACd,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAC1B,IAAuB,EACvB,IAAuB,EACvB,oBAA6C,MAAM,CAAC,EAAE;IAEtD,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE;QAC5B,OAAO,KAAK,CAAC;KACb;IAED,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,EAAE;QAClC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC9B,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;YAC/D,OAAO,KAAK,CAAC;SACb;KACD;IAED,OAAO,IAAI,CAAC;AACb,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAO,GAAc,EAAE,GAAM,EAAE,YAA2B;IACpF,IAAI,KAAK,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACzB,IAAI,KAAK,KAAK,SAAS,EAAE;QACxB,KAAK,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;QAC1B,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;KACpB;IACD,OAAO,KAAK,CAAC;AACd,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc,CAAmB,CAAI,EAAE,CAAI;IAC1D,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACrC,CAAC;AAED,MAAM,UAAU,IAAI,CAAC,OAAe;IACnC,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;AAC1B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CACnC,KAA0B,EAC1B,WAAiB,EACjB,QAAW;IAEX,IAAI,KAAK,KAAK,SAAS,EAAE;QACxB,WAAW,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC;KAC9B;AACF,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Remove `readonly` from all fields.\n */\nexport type Mutable<T> = { -readonly [P in keyof T]: T[P] };\n\n/** A union type of the first `N` positive integers */\nexport type TakeWholeNumbers<N extends number, A extends never[] = []> = N extends A[\"length\"]\n\t? never\n\t: A[\"length\"] | TakeWholeNumbers<N, [never, ...A]>;\n\n/** Returns a tuple type with exactly `Length` elements of type `T` */\nexport type ArrayOfLength<T, Length extends number, A extends T[] = []> = Length extends A[\"length\"]\n\t? A\n\t: ArrayOfLength<T, Length, [T, ...A]>;\n\n/**\n * Fails true iff `array` has at least `length` elements\n */\nexport function hasAtLeastLength<T, Len extends TakeWholeNumbers<16>>(\n\tarray: readonly T[],\n\tlength: Len,\n): array is [...ArrayOfLength<T, Len>, ...T[]] {\n\treturn array.length >= length;\n}\n\n/**\n * A numeric comparator used for sorting in ascending order.\n *\n * Handles +/-0 like Map: -0 is equal to +0.\n */\nexport function compareFiniteNumbers<T extends number>(a: T, b: T): number {\n\treturn a - b;\n}\n\n/**\n * A numeric comparator used for sorting in descending order.\n *\n * Handles +/-0 like Map: -0 is equal to +0.\n */\nexport function compareFiniteNumbersReversed<T extends number>(a: T, b: T): number {\n\treturn b - a;\n}\n\n/**\n * Compare two maps and return true if their contents are equivalent.\n * @param mapA - The first array to compare\n * @param mapB - The second array to compare\n * @param elementComparator - The function used to check if two `T`s are equivalent.\n * Defaults to `Object.is()` equality (a shallow compare)\n */\nexport function compareMaps<K, V>(\n\tmapA: ReadonlyMap<K, V>,\n\tmapB: ReadonlyMap<K, V>,\n\telementComparator: (a: V, b: V) => boolean = Object.is,\n): boolean {\n\tif (mapA.size !== mapB.size) {\n\t\treturn false;\n\t}\n\n\tfor (const [keyA, valueA] of mapA) {\n\t\tconst valueB = mapB.get(keyA);\n\t\tif (valueB === undefined || !elementComparator(valueA, valueB)) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n\n/**\n * Retrieve a value from a map with the given key, or create a new entry if the key is not in the map.\n * @param map - The map to query/update\n * @param key - The key to lookup in the map\n * @param defaultValue - a function which returns a default value. This is called and used to set an initial value for the given key in the map if none exists\n * @returns either the existing value for the given key, or the newly-created value (the result of `defaultValue`)\n */\nexport function getOrCreate<K, V>(map: Map<K, V>, key: K, defaultValue: (key: K) => V): V {\n\tlet value = map.get(key);\n\tif (value === undefined) {\n\t\tvalue = defaultValue(key);\n\t\tmap.set(key, value);\n\t}\n\treturn value;\n}\n\n/**\n * Compares strings lexically to form a strict partial ordering.\n */\nexport function compareStrings<T extends string>(a: T, b: T): number {\n\treturn a > b ? 1 : a === b ? 0 : -1;\n}\n\nexport function fail(message: string): never {\n\tthrow new Error(message);\n}\n\n/**\n * Sets a property in such a way that it is only set on `destination` if the provided value is not undefined.\n * This avoids having explicit undefined values under properties that would cause `Object.hasOwnProperty` to return true.\n */\nexport function setPropertyIfDefined<TDst, P extends keyof TDst>(\n\tvalue: TDst[P] | undefined,\n\tdestination: TDst,\n\tproperty: P,\n): void {\n\tif (value !== undefined) {\n\t\tdestination[property] = value;\n\t}\n}\n"]}

package/lib/id-compressor/uuidUtilities.d.ts

@@ -1,28 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { StableId, UuidString } from "@fluidframework/runtime-definitions";
-/**
- * Asserts that the given string is a UUID
- */
-export declare function assertIsUuidString(uuidString: string): UuidString;
-/**
- * Returns true iff the given string is a valid UUID-like string of hexadecimal characters
- * 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
- */
-export declare function isUuidString(str: string): str is UuidString;
-/**
- * Generate a random stable ID
- */
-export declare function generateStableId(): StableId;
-/**
- * Asserts that the given string is a stable ID.
- */
-export declare function assertIsStableId(stableId: string): StableId;
-/**
- * Returns true iff the given string is a valid Version 4, variant 2 UUID
- * 'xxxxxxxx-xxxx-4xxx-vxxx-xxxxxxxxxxxx'
- */
-export declare function isStableId(str: string): str is StableId;
-//# sourceMappingURL=uuidUtilities.d.ts.map

package/lib/id-compressor/uuidUtilities.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"uuidUtilities.d.ts","sourceRoot":"","sources":["../../src/id-compressor/uuidUtilities.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAoB3E;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CAGjE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,UAAU,CAqB3D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,QAAQ,CAE3C;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAG3D;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,QAAQ,CAuCvD"}

package/lib/id-compressor/uuidUtilities.js

@@ -1,96 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { assert } from "@fluidframework/common-utils";
-import { v4 } from "uuid";
-const hexadecimalCharCodes = Array.from("09afAF").map((c) => c.charCodeAt(0));
-function isHexadecimalCharacter(charCode) {
-    return ((charCode >= hexadecimalCharCodes[0] && charCode <= hexadecimalCharCodes[1]) ||
-        (charCode >= hexadecimalCharCodes[2] && charCode <= hexadecimalCharCodes[3]) ||
-        (charCode >= hexadecimalCharCodes[4] && charCode <= hexadecimalCharCodes[5]));
-}
-/**
- * Asserts that the given string is a UUID
- */
-export function assertIsUuidString(uuidString) {
-    assert(isUuidString(uuidString), 0x4a2 /* Expected an UuidString */);
-    return uuidString;
-}
-/**
- * Returns true iff the given string is a valid UUID-like string of hexadecimal characters
- * 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
- */
-export function isUuidString(str) {
-    for (let i = 0; i < str.length; i++) {
-        switch (i) {
-            case 8:
-            case 13:
-            case 18:
-            case 23:
-                if (str.charAt(i) !== "-") {
-                    return false;
-                }
-                break;
-            default:
-                if (!isHexadecimalCharacter(str.charCodeAt(i))) {
-                    return false;
-                }
-                break;
-        }
-    }
-    return true;
-}
-/**
- * Generate a random stable ID
- */
-export function generateStableId() {
-    return assertIsStableId(v4());
-}
-/**
- * Asserts that the given string is a stable ID.
- */
-export function assertIsStableId(stableId) {
-    assert(isStableId(stableId), 0x4a3 /* Expected a StableId */);
-    return stableId;
-}
-/**
- * Returns true iff the given string is a valid Version 4, variant 2 UUID
- * 'xxxxxxxx-xxxx-4xxx-vxxx-xxxxxxxxxxxx'
- */
-export function isStableId(str) {
-    if (str.length !== 36) {
-        return false;
-    }
-    for (let i = 0; i < str.length; i++) {
-        switch (i) {
-            case 8:
-            case 13:
-            case 18:
-            case 23:
-                if (str.charAt(i) !== "-") {
-                    return false;
-                }
-                break;
-            case 14:
-                if (str.charAt(i) !== "4") {
-                    return false;
-                }
-                break;
-            case 19: {
-                const char = str.charAt(i);
-                if (char !== "8" && char !== "9" && char !== "a" && char !== "b") {
-                    return false;
-                }
-                break;
-            }
-            default:
-                if (!isHexadecimalCharacter(str.charCodeAt(i))) {
-                    return false;
-                }
-                break;
-        }
-    }
-    return true;
-}
-//# sourceMappingURL=uuidUtilities.js.map

package/lib/id-compressor/uuidUtilities.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"uuidUtilities.js","sourceRoot":"","sources":["../../src/id-compressor/uuidUtilities.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/common-utils\";\nimport { StableId, UuidString } from \"@fluidframework/runtime-definitions\";\nimport { v4 } from \"uuid\";\n\nconst hexadecimalCharCodes = Array.from(\"09afAF\").map((c) => c.charCodeAt(0)) as [\n\tzero: number,\n\tnine: number,\n\ta: number,\n\tf: number,\n\tA: number,\n\tF: number,\n];\n\nfunction isHexadecimalCharacter(charCode: number): boolean {\n\treturn (\n\t\t(charCode >= hexadecimalCharCodes[0] && charCode <= hexadecimalCharCodes[1]) ||\n\t\t(charCode >= hexadecimalCharCodes[2] && charCode <= hexadecimalCharCodes[3]) ||\n\t\t(charCode >= hexadecimalCharCodes[4] && charCode <= hexadecimalCharCodes[5])\n\t);\n}\n\n/**\n * Asserts that the given string is a UUID\n */\nexport function assertIsUuidString(uuidString: string): UuidString {\n\tassert(isUuidString(uuidString), 0x4a2 /* Expected an UuidString */);\n\treturn uuidString;\n}\n\n/**\n * Returns true iff the given string is a valid UUID-like string of hexadecimal characters\n * 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'\n */\nexport function isUuidString(str: string): str is UuidString {\n\tfor (let i = 0; i < str.length; i++) {\n\t\tswitch (i) {\n\t\t\tcase 8:\n\t\t\tcase 13:\n\t\t\tcase 18:\n\t\t\tcase 23:\n\t\t\t\tif (str.charAt(i) !== \"-\") {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\t\t\t\tif (!isHexadecimalCharacter(str.charCodeAt(i))) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n\treturn true;\n}\n\n/**\n * Generate a random stable ID\n */\nexport function generateStableId(): StableId {\n\treturn assertIsStableId(v4());\n}\n\n/**\n * Asserts that the given string is a stable ID.\n */\nexport function assertIsStableId(stableId: string): StableId {\n\tassert(isStableId(stableId), 0x4a3 /* Expected a StableId */);\n\treturn stableId;\n}\n\n/**\n * Returns true iff the given string is a valid Version 4, variant 2 UUID\n * 'xxxxxxxx-xxxx-4xxx-vxxx-xxxxxxxxxxxx'\n */\nexport function isStableId(str: string): str is StableId {\n\tif (str.length !== 36) {\n\t\treturn false;\n\t}\n\n\tfor (let i = 0; i < str.length; i++) {\n\t\tswitch (i) {\n\t\t\tcase 8:\n\t\t\tcase 13:\n\t\t\tcase 18:\n\t\t\tcase 23:\n\t\t\t\tif (str.charAt(i) !== \"-\") {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t\tbreak;\n\n\t\t\tcase 14:\n\t\t\t\tif (str.charAt(i) !== \"4\") {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t\tbreak;\n\n\t\t\tcase 19: {\n\t\t\t\tconst char = str.charAt(i);\n\t\t\t\tif (char !== \"8\" && char !== \"9\" && char !== \"a\" && char !== \"b\") {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tdefault:\n\t\t\t\tif (!isHexadecimalCharacter(str.charCodeAt(i))) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n\treturn true;\n}\n"]}

package/src/id-compressor/idRange.ts

@@ -1,35 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { assert } from "@fluidframework/common-utils";
-import type { IdCreationRange, UnackedLocalId } from "@fluidframework/runtime-definitions";
-
-export function getIds(
-	range: IdCreationRange,
-):
-	| { first: UnackedLocalId; last: UnackedLocalId; overrides?: IdCreationRange.Overrides }
-	| undefined {
-	const { ids } = range;
-	if (ids === undefined) {
-		return undefined;
-	}
-
-	let first = ids.first;
-	let last = ids.last;
-
-	const overrides = ids as Partial<IdCreationRange.HasOverrides>;
-	if (overrides.overrides !== undefined) {
-		first ??= overrides.overrides[0][0];
-		last ??= overrides.overrides[overrides.overrides.length - 1][0];
-	}
-
-	assert(first !== undefined && last !== undefined, 0x49b /* malformed IdCreationRange */);
-
-	return {
-		first,
-		last,
-		overrides: overrides.overrides,
-	};
-}

package/src/id-compressor/numericUuid.ts

@@ -1,383 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-/* eslint-disable no-bitwise */
-/* eslint-disable @typescript-eslint/no-namespace */
-
-import { assert } from "@fluidframework/common-utils";
-import { SessionId, StableId } from "@fluidframework/runtime-definitions";
-import { fail } from "./utils";
-import { generateStableId } from "./uuidUtilities";
-
-/**
- * A UUID (128 bit identifier) optimized for use as a 128 bit unsigned integer with fast addition and toString operations.
- * The string entry is the upper 76 bits of the uuid and the integer entry holds the lower 52 bits:
- *
- * ```
- * UUUUUUUU-UUUU-VUUU-vUUU-UUUUUUUUUUUU - the uuid
- * SSSSSSSS-SSSS-SSSS-SSS               - array[0]: string
- *                       N NNNNNNNNNNNN - array[1]: integer
- * ```
- *
- * The integer keeps the common case cost of incrementing and computing deltas very low.
- * The string optimizes toString by caching the the majority of the resulting string.
- */
-export type NumericUuid = readonly [string, number] & {
-	readonly NumericUuid: "9132ea20-a811-4756-85f8-aa6da5ca90f8";
-};
-
-const bitsInNumericUuidInteger = 52; // Not tunable. Do not change.
-const nibblesInNumericUuidInteger = bitsInNumericUuidInteger / 4;
-const stringEntryLength = 22;
-const maxNumericUuidInteger = 2 ** bitsInNumericUuidInteger - 1;
-const fiftyThirdBit = 2 ** 52;
-
-/**
- * Calculates the numeric delta between a and b (i.e. a - b).
- * @param a - an uuid
- * @param b - an other uuid
- * @param maxDelta - the maximum integer delta (inclusive) to tolerate.
- * @returns undefined if the delta is negative or greater than `maxDelta`
- */
-export function getPositiveDelta(
-	a: NumericUuid,
-	b: NumericUuid,
-	maxDelta: number,
-): number | undefined {
-	const [stringEntryA, lowNumberA] = a;
-	const [stringEntryB, lowNumberB] = b;
-
-	if (stringEntryA === stringEntryB) {
-		const difference = lowNumberA - lowNumberB;
-		if (difference >= 0 && difference <= maxDelta) {
-			return difference;
-		}
-		return undefined;
-	}
-
-	const highNumberA = Number.parseInt(ChunkMath.Upper.parse(stringEntryA), 16);
-	const highNumberB = Number.parseInt(ChunkMath.Upper.parse(stringEntryB), 16);
-
-	let subtractHigh = highNumberA - highNumberB;
-	if (Math.abs(subtractHigh) > 1) {
-		// If the high bits differ by more than 1, then there is no chance that any lower bits could compensate
-		return undefined;
-	}
-
-	let midNumberA = ChunkMath.getNumericValue(ChunkMath.Variant.parse(stringEntryA));
-	const midNumberB = ChunkMath.getNumericValue(ChunkMath.Variant.parse(stringEntryB));
-
-	let subtractLow = lowNumberA - lowNumberB;
-	if (subtractLow < 0) {
-		midNumberA -= 1;
-		subtractLow += fiftyThirdBit;
-	}
-
-	let subtractMid = midNumberA - midNumberB;
-	if (subtractMid < 0) {
-		subtractHigh -= 1;
-		subtractMid += ChunkMath.twentyThirdBit;
-	}
-
-	if (subtractHigh !== 0) {
-		// a < b, no positive delta, or
-		// a > b by much more than MAX_SAFE_INTEGER
-		return undefined;
-	}
-
-	if (subtractMid > 1) {
-		return undefined;
-	} else {
-		const trueDelta = fiftyThirdBit * subtractMid + subtractLow;
-		return trueDelta > maxDelta ? undefined : trueDelta;
-	}
-}
-
-// Pre-allocated array of strings of zeros.
-// Used to pad hex strings up to 52 bits
-const zeros: string[] = [];
-for (let i = 0; i < nibblesInNumericUuidInteger; i++) {
-	zeros.push("0".repeat(i));
-}
-
-function padToLengthWithZeros(str: string, count: number): string {
-	return str.length === count ? str : zeros[count - str.length] + str;
-}
-
-/**
- * @param offset - an optional offset to increment the returned StableId
- * @returns the string representation of a `NumericUuid`.
- */
-export function stableIdFromNumericUuid(uuid: NumericUuid, offset = 0): StableId {
-	const lowerAdd = uuid[1] + offset;
-	// Common fast-path
-	if (lowerAdd <= maxNumericUuidInteger) {
-		const lowerString = padToLengthWithZeros(
-			lowerAdd.toString(16),
-			nibblesInNumericUuidInteger,
-		);
-		return `${uuid[0] + lowerString.slice(0, 1)}-${lowerString.slice(1)}` as StableId;
-	}
-	return stableIdFromNumericUuid(incrementUuid(uuid, offset));
-}
-
-/**
- * @param stableId - a minimal uuid string
- * @returns a numeric representation of `stableId`.
- */
-export function numericUuidFromStableId(stableId: StableId): NumericUuid {
-	const uuid: (string | number)[] = new Array(2);
-	uuid[0] = stableId.slice(0, stringEntryLength);
-	uuid[1] = Number.parseInt(ChunkMath.Lower.parse(stableId), 16);
-	return uuid as readonly (number | string)[] as NumericUuid;
-}
-
-/**
- * Creates a session base ID.
- * This method (rather than standard uuid generation methods) should be used to generate session IDs.
- */
-export function createSessionId(): SessionId {
-	return ensureSessionUuid(generateStableId());
-}
-
-/**
- * Compares numeric uuids for equality.
- */
-export function numericUuidEquals(a: NumericUuid, b: NumericUuid): boolean {
-	return a[0] === b[0] && a[1] === b[1];
-}
-
-/**
- * The maximum value that can be contained in the upper string region of a numeric UUID (i.e. the string region excluding the version
- * nibble and the variant chunk)
- */
-const maxUpperNumber = 2 ** 48 - 1;
-
-/**
- * Increments the uuid. `amount` must be a positive integer.
- * @returns the result of incrementing the uuid by `amount`.
- */
-export function incrementUuid(uuid: NumericUuid, amount: number): NumericUuid {
-	/*
-	 * UUIDs incremented beyond the max UUID "ffffffff-ffff-4fff-bfff-ffffffffffff" will cause a failure.
-	 * Also, some reserved bits of the v4 UUID must be treated as immutable (e.g. the version and
-	 * variant bits) and thus must not be incremented.
-	 */
-	let newUuid: [string, number];
-	const result = uuid[1] + amount;
-	if (result <= maxNumericUuidInteger) {
-		// The new number still fits within the number region of a numeric UUID.
-		// Incrementing is usually done with small amounts, so this is the dominantly common case.
-		newUuid = [uuid[0], result];
-	} else {
-		// The numeric UUID's number region has overflowed. We will need to carry the overflow into the variant chunk (see `VariantChunk`).
-		/** The amount left over after filling up the rest of the uuid's number region with the increment amount */
-		const remainder = amount - (maxNumericUuidInteger - uuid[1]) - 1;
-		const stringEntry = uuid[0];
-		const [newVariantChunkString, carried] = ChunkMath.increment(stringEntry);
-
-		if (carried) {
-			// The variant chunk itself also overflowed. We'll need to carry the overflow further, into the upper string region of the UUID.
-			const upperString = ChunkMath.Upper.parse(stringEntry);
-			const upperNumber = Number.parseInt(upperString, 16);
-			assert(
-				upperNumber <= maxUpperNumber,
-				0x49c /* Unexpectedly large upper number when incrementing UUID */,
-			);
-			const newUpperNumber = upperNumber + 1;
-			if (newUpperNumber > maxUpperNumber) {
-				fail("Exceeded maximum numeric UUID");
-			} else {
-				// The variant chunk overflowed but the upper string region did not. Splice in the incremented string region.
-				const newUpperChunk = padToLengthWithZeros(newUpperNumber.toString(16), 12);
-				newUuid = [
-					`${ChunkMath.Upper.hyphenate(newUpperChunk)}-4${ChunkMath.Variant.hyphenate(
-						newVariantChunkString,
-					)}`,
-					remainder,
-				];
-			}
-		} else {
-			// The variant chunk did not overflow, so just splice it back in.
-			newUuid = [
-				`${ChunkMath.Upper.slice(stringEntry)}-4${ChunkMath.Variant.hyphenate(
-					newVariantChunkString,
-				)}`,
-				remainder,
-			];
-		}
-	}
-
-	return newUuid as readonly [string, number] as NumericUuid;
-}
-
-namespace ChunkMath {
-	/*
-	 * Recall the UUID diagram from the top of this file which describes the layout of a Numeric UUID. To implement addition, we define
-	 * another region called the "variant chunk" which overlaps with the "string" region. Note that it is just beneath the required v4 uuid
-	 * version identifier (the 13th nibble 'V' which is always '4' in a v4 UUID) and just above the "number" region of the layout. It
-	 * contains inside of it the v4 UUID variant identifier bits as well (see https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.1).
-	 *
-	 * UUUUUUUU-UUUU-VUUU-vUUU-UUUUUUUUUUUU - the uuid
-	 * SSSSSSSS SSSS SSSS SSS               - array[0]: string
-	 *                       N NNNNNNNNNNNN - array[1]: integer
-	 *                VVV-VVV               - the variant chunk
-	 *
-	 * By defining the variant chunk in this way it is simple to splice in the v4 UUID version identifier ('V') just above it and any
-	 * "bit math" required due to the fact that the variant identifier bits ('v') do not fill up an entire nibble is handled within it.
-	 * The variant chunk is made up of 6 nibbles. Note the "vv" which denotes the two bits used for the v4 UUID variant identifier:
-	 *
-	 * AAAA BBBB CCCC vvDD EEEE FFFF
-	 *
-	 * Since we'll be needing to "skip" the variant bits ("vv") when doing addition, we define a a few masks which will be used below to
-	 * separate the variant chunk into pieces before recombining it:
-	 */
-
-	//                                         AAAA BBBB CCCC vvDD EEEE FFFF
-	const upperVariantChunkMask = 0xfff000; // XXXX XXXX XXXX
-	const variantBitMask = 0x800; //                          XX
-	const middleVariantChunkMask = 0x300; //                    XX
-	const lowerVariantChunkMask = 0xff; //                         XXXX XXXX
-
-	/** The maximum numeric value that can be represented by the numerically relevant bits in the variant chunk */
-	const maxVariantNumber = 2 ** 22 - 1;
-
-	export const twentyThirdBit = 2 ** 22;
-
-	/**
-	 * The upper chunk, denoted by 'U's in UUUUUUUU-UUUU-VVVV-vVVL-LLLLLLLLLLLL
-	 */
-	export namespace Upper {
-		export function parse(stringEntry: string): string {
-			return stringEntry.slice(0, 8) + stringEntry.slice(9, 13);
-		}
-
-		export function hyphenate(upperChunk: string): string {
-			return `${upperChunk.slice(0, 8)}-${upperChunk.slice(8)}`;
-		}
-
-		export function slice(stringEntry: string): string {
-			return stringEntry.slice(0, 13);
-		}
-	}
-
-	/**
-	 * The variant chunk, denoted by 'V's in UUUUUUUU-UUUU-VVVV-vVVL-LLLLLLLLLLLL
-	 */
-	export namespace Variant {
-		export function parse(stringEntry: string): string {
-			return stringEntry.slice(15, 18) + stringEntry.slice(19, 22);
-		}
-
-		export function hyphenate(variantChunk: string): string {
-			return `${variantChunk.slice(0, 3)}-${variantChunk.slice(3)}`;
-		}
-	}
-
-	/**
-	 * The lower chunk, denoted by 'L's in UUUUUUUU-UUUU-VVVV-vVVL-LLLLLLLLLLLL
-	 */
-	export namespace Lower {
-		export function parse(stableId: StableId): string {
-			return (
-				stableId.slice(stringEntryLength, stringEntryLength + 1) +
-				stableId.slice(stringEntryLength + 2)
-			);
-		}
-
-		export function hyphenate(lowerChunk: string): string {
-			return `${lowerChunk.slice(0, 1)}-${lowerChunk.slice(1)}`;
-		}
-	}
-
-	/**
-	 * Returns the number representation of the given bits corresponding to the variant chunk. The value is derived by
-	 * parsing all bits except for reserved bits (i.e. the variant bits).
-	 * @param variantChunk - the variantChunk
-	 */
-	export function getNumericValue(variantChunk: string): number {
-		const variantChunkBits = Number.parseInt(variantChunk, 16);
-		const upperVariantBits = (variantChunkBits & upperVariantChunkMask) >> 2;
-		const middleVariantBits = variantChunkBits & middleVariantChunkMask;
-		const lowerVariantBits = variantChunkBits & lowerVariantChunkMask;
-		return upperVariantBits + middleVariantBits + lowerVariantBits;
-	}
-
-	/**
-	 * Given the string portion of a numeric uuid, add one to it.
-	 * @returns the resulting hex string and whether or not the new value overflowed, i.e. it exceeds `maxVariantNumber`. In this case,
-	 * the resulting hex string will wrap around to its minimum value '000b00'
-	 */
-	export function increment(stringEntry: string): [newVariantChunk: string, overflowed: boolean] {
-		// To implement addition, the variant identifier bits are extracted from the variant chunk, the chunk is interpreted as a number,
-		// that number is incremented by 1, and then the variant identifier bits are returned as we convert the number back into a hex
-		// string.
-
-		// This diagram may be helpful for seeing how the nibbles line up before and after the variant identifier bits are extracted. The
-		// letters used for each nibble ("AAAA", "BBBB") etc. are arbitrary and are simply there to differentiate the nibbles as they shift.
-		// --------------------------------
-		// 1. AAAA BBBB CCCC vvDD EEEE FFFF
-		// 2.   AA AABB BBCC CCDD EEEE FFFF
-		// 3.   AA AABB BBCC CCDD EEEE FFFF
-		//                              + 1
-		//    = GG GGHH HHII IIJJ JJKK KKLL
-		// 4. GGGG HHHH IIII vvJJ JJKK KKLL
-
-		// 1. The variant chunk is given as a 6 character (6 nibble) hex string, where the fourth nibble contains the variant bits
-		// 2. The numerically important bits (i.e. not the variant identifier bits vv which are constant) are extracted into a single number
-		const variantChunk = Variant.parse(stringEntry);
-		const variantNumber = getNumericValue(variantChunk);
-		assert(
-			variantNumber <= maxVariantNumber,
-			0x49d /* Unexpectedly large variant number when incrementing UUID */,
-		);
-		// 3. Add one to the variant number to produce our new variant number.
-		const newVariantNumber = variantNumber + 1;
-		// 4. The variant identifier bits are added back into the number, which is then turned back into a hex string
-		const newUpperVariantBits = (newVariantNumber & (upperVariantChunkMask >> 2)) << 2;
-		const newMiddleVariantBits = (newVariantNumber & middleVariantChunkMask) | variantBitMask; // Add the variant bits back in
-		const newLowerVariantBits = newVariantNumber & lowerVariantChunkMask;
-		const newVariantChunkBits =
-			newUpperVariantBits + newMiddleVariantBits + newLowerVariantBits;
-		const newVariantChunk = padToLengthWithZeros(
-			newVariantChunkBits.toString(16),
-			variantChunk.length,
-		);
-		return [newVariantChunk, newVariantNumber > maxVariantNumber];
-	}
-}
-
-const maxUpperUuid = "ffffffff-ffff-4fff-bf";
-const maxNibbleCount = [...maxUpperUuid].filter((n) => n === "f").length;
-const newNibbles = ["7", "b", "d", "e"];
-function isMaxUpperNibble(index: number): boolean {
-	return maxUpperUuid.charAt(index) === "f";
-}
-
-/**
- * Any session uuid with all of its highish bits set is in danger of overflowing after fewer than 2^53 increments.
- * By zeroing one of those bits at random, potential overflow is prevented.
- */
-export function ensureSessionUuid(uuid: StableId): SessionId {
-	if (uuid.startsWith(maxUpperUuid)) {
-		const targetNibble = Math.floor(Math.random() * maxNibbleCount);
-		let actualIndex = 0;
-		for (
-			let nibbleIndex = 0;
-			nibbleIndex < targetNibble && !isMaxUpperNibble(actualIndex);
-			actualIndex += 1
-		) {
-			if (isMaxUpperNibble(actualIndex)) {
-				nibbleIndex++;
-			}
-		}
-
-		const newNibble = newNibbles[Math.floor(Math.random() * newNibbles.length)]; // Randomly choose a bit to zero
-		const newUuid = uuid.slice(0, actualIndex) + newNibble + uuid.slice(actualIndex + 1);
-		return newUuid as SessionId;
-	}
-
-	return uuid as SessionId;
-}