@moyodb/sdk 1.4.0 → 1.5.0

package/dist/chunks/{indexing-B0duqlUs.js → indexing-DdpU69Fd.js}

@@ -1187,6 +1187,8 @@ var COMPOUND_ESCAPE = 0;
 var COMPOUND_ESCAPE_CONT = 255;
 var COMPOUND_TERM = 0;
 var F64_MASK = BigInt("0xffffffffffffffff");
+var sortableNumberBytes = /* @__PURE__ */ new Uint8Array(9);
+var sortableNumberView = new DataView(sortableNumberBytes.buffer);
 function utf8Encode(value) {
 	return encoder.encode(value);
 }
@@ -1214,11 +1216,11 @@ function isCompoundKeyPartList(value) {
 	return Array.isArray(value);
 }
 function indexKey(value) {
-	if (isCompoundKeyPartList(value)) return compoundKey(...value);
+	if (isCompoundKeyPartList(value)) return encodeCompoundKeyList(value);
 	return encodeCompoundKeyPart(value);
 }
 function compoundKey(...parts) {
-	return encodeCompoundBytes(parts.map((part) => encodeCompoundKeyPart(part)));
+	return encodeCompoundKeyList(parts);
 }
 function encodeIndexScalar(value) {
 	return encodeCompoundKeyPart(value);
@@ -1228,37 +1230,55 @@ function encodeCompoundKeyParts(parts) {
 }
 function splitCompoundKey(key) {
 	const parts = [];
-	const current = [];
-	for (let index = 0; index < key.length; index += 1) {
-		const byte = key[index];
-		if (byte !== COMPOUND_ESCAPE) {
-			current.push(byte);
-			continue;
-		}
-		const next = key[index + 1];
-		if (next === COMPOUND_ESCAPE_CONT) {
-			current.push(COMPOUND_ESCAPE);
-			index += 1;
-			continue;
+	let index = 0;
+	while (index < key.length) {
+		const start = index;
+		let length = 0;
+		let closed = false;
+		for (; index < key.length; index += 1) {
+			if (key[index] !== COMPOUND_ESCAPE) {
+				length += 1;
+				continue;
+			}
+			const next = key[index + 1];
+			if (next === COMPOUND_ESCAPE_CONT) {
+				length += 1;
+				index += 1;
+				continue;
+			}
+			if (next === COMPOUND_TERM) {
+				index += 2;
+				closed = true;
+				break;
+			}
+			throw new TypeError("invalid compound key encoding");
 		}
-		if (next === COMPOUND_TERM) {
-			parts.push(Uint8Array.from(current));
-			current.length = 0;
-			index += 1;
-			continue;
+		if (!closed) throw new TypeError("compound key terminated unexpectedly");
+		const part = new Uint8Array(length);
+		let offset = 0;
+		for (let cursor = start; cursor < index - 2; cursor += 1) {
+			const byte = key[cursor];
+			if (byte !== COMPOUND_ESCAPE) {
+				part[offset] = byte;
+				offset += 1;
+				continue;
+			}
+			part[offset] = COMPOUND_ESCAPE;
+			offset += 1;
+			cursor += 1;
 		}
-		throw new TypeError("invalid compound key encoding");
+		parts.push(part);
 	}
-	if (current.length !== 0) throw new TypeError("compound key terminated unexpectedly");
 	return parts;
 }
 function prefixSuccessor(prefix) {
-	const out = prefix.slice();
-	for (let index = out.length - 1; index >= 0; index -= 1) if (out[index] !== 255) {
-		out[index] += 1;
-		return out.subarray(0, index + 1);
-	}
-	return null;
+	let end = prefix.length;
+	while (end > 0 && prefix[end - 1] === 255) end -= 1;
+	if (end === 0) return null;
+	const out = new Uint8Array(end);
+	out.set(end === prefix.length ? prefix : prefix.subarray(0, end));
+	out[end - 1] += 1;
+	return out;
 }
 function prefixRange(prefix) {
 	const upper = prefixSuccessor(prefix);
@@ -1274,17 +1294,7 @@ function encodeCompoundKeyPart(value) {
 	if (value === null) return Uint8Array.of(TYPE_NULL);
 	if (typeof value === "boolean") return Uint8Array.of(value ? TYPE_TRUE : TYPE_FALSE);
 	if (typeof value === "number") return encodeSortableNumber(value);
-	if (typeof value === "string") {
-		for (const character of value) {
-			const codePoint = character.codePointAt(0);
-			if (codePoint >= 55296 && codePoint <= 57343) throw new TypeError("compound key string parts must contain valid Unicode scalar values");
-		}
-		const body = utf8Encode(value);
-		const out = new Uint8Array(1 + body.length);
-		out[0] = TYPE_STRING;
-		out.set(body, 1);
-		return out;
-	}
+	if (typeof value === "string") return encodeStringKey(value);
 	if (value instanceof Uint8Array) {
 		const out = new Uint8Array(1 + value.length);
 		out[0] = TYPE_BYTES;
@@ -1293,16 +1303,64 @@ function encodeCompoundKeyPart(value) {
 	}
 	throw new TypeError("compound key parts must be string, number, boolean, null, or Uint8Array");
 }
-function encodeCompoundBytes(parts) {
+function encodeCompoundKeyList(parts) {
 	let length = 0;
-	for (const part of parts) {
-		for (const byte of part) length += byte === COMPOUND_ESCAPE ? 2 : 1;
-		length += 2;
+	for (let index = 0; index < parts.length; index += 1) length += compoundPartEncodedLength(parts[index]);
+	const out = new Uint8Array(length);
+	let offset = 0;
+	for (let index = 0; index < parts.length; index += 1) offset = writeCompoundPart$1(out, offset, parts[index]);
+	return out;
+}
+function compoundPartEncodedLength(value) {
+	if (value === null || typeof value === "boolean") return 3;
+	if (typeof value === "number") {
+		writeSortableNumber(sortableNumberView, value);
+		return escapedByteLength(sortableNumberBytes) + 2;
 	}
+	if (typeof value === "string") return 1 + walkUtf8(value, null, 0, true) + 2;
+	if (value instanceof Uint8Array) return 1 + escapedByteLength(value) + 2;
+	throw new TypeError("compound key parts must be string, number, boolean, null, or Uint8Array");
+}
+function writeCompoundPart$1(out, offset, value) {
+	if (value === null) {
+		out[offset] = TYPE_NULL;
+		return writeTerminator(out, offset + 1);
+	}
+	if (typeof value === "boolean") {
+		out[offset] = value ? TYPE_TRUE : TYPE_FALSE;
+		return writeTerminator(out, offset + 1);
+	}
+	if (typeof value === "number") {
+		writeSortableNumber(sortableNumberView, value);
+		return writeTerminator(out, writeEscapedBytes(out, offset, sortableNumberBytes));
+	}
+	if (typeof value === "string") {
+		out[offset] = TYPE_STRING;
+		return writeTerminator(out, walkUtf8(value, out, offset + 1, true));
+	}
+	if (value instanceof Uint8Array) {
+		out[offset] = TYPE_BYTES;
+		return writeTerminator(out, writeEscapedBytes(out, offset + 1, value));
+	}
+	throw new TypeError("compound key parts must be string, number, boolean, null, or Uint8Array");
+}
+function encodeCompoundBytes(parts) {
+	let length = 0;
+	for (let index = 0; index < parts.length; index += 1) length += escapedByteLength(parts[index]) + 2;
 	const out = new Uint8Array(length);
 	let offset = 0;
-	for (const part of parts) {
-		for (const byte of part) if (byte === COMPOUND_ESCAPE) {
+	for (let index = 0; index < parts.length; index += 1) offset = writeTerminator(out, writeEscapedBytes(out, offset, parts[index]));
+	return out;
+}
+function escapedByteLength(bytes) {
+	let extra = 0;
+	for (let index = 0; index < bytes.length; index += 1) if (bytes[index] === COMPOUND_ESCAPE) extra += 1;
+	return bytes.length + extra;
+}
+function writeEscapedBytes(out, offset, bytes) {
+	for (let index = 0; index < bytes.length; index += 1) {
+		const byte = bytes[index];
+		if (byte === COMPOUND_ESCAPE) {
 			out[offset] = COMPOUND_ESCAPE;
 			out[offset + 1] = COMPOUND_ESCAPE_CONT;
 			offset += 2;
@@ -1310,23 +1368,83 @@ function encodeCompoundBytes(parts) {
 			out[offset] = byte;
 			offset += 1;
 		}
-		out[offset] = COMPOUND_TERM;
-		out[offset + 1] = COMPOUND_TERM;
-		offset += 2;
 	}
+	return offset;
+}
+function writeTerminator(out, offset) {
+	out[offset] = COMPOUND_TERM;
+	out[offset + 1] = COMPOUND_TERM;
+	return offset + 2;
+}
+function encodeStringKey(value) {
+	const length = walkUtf8(value, null, 0, false);
+	const out = new Uint8Array(1 + length);
+	out[0] = TYPE_STRING;
+	walkUtf8(value, out, 1, false);
 	return out;
 }
+function walkUtf8(value, out, offset, escapeNul) {
+	for (let index = 0; index < value.length; index += 1) {
+		const code = value.charCodeAt(index);
+		if (code <= 127) {
+			if (escapeNul && code === 0) {
+				if (out !== null) {
+					out[offset] = COMPOUND_ESCAPE;
+					out[offset + 1] = COMPOUND_ESCAPE_CONT;
+				}
+				offset += 2;
+			} else {
+				if (out !== null) out[offset] = code;
+				offset += 1;
+			}
+			continue;
+		}
+		if (code <= 2047) {
+			if (out !== null) {
+				out[offset] = 192 | code >> 6;
+				out[offset + 1] = 128 | code & 63;
+			}
+			offset += 2;
+			continue;
+		}
+		if (code >= 55296 && code <= 56319) {
+			const next = value.charCodeAt(index + 1);
+			if (next >= 56320 && next <= 57343) {
+				const point = (code - 55296 << 10) + (next - 56320) + 65536;
+				if (out !== null) {
+					out[offset] = 240 | point >> 18;
+					out[offset + 1] = 128 | point >> 12 & 63;
+					out[offset + 2] = 128 | point >> 6 & 63;
+					out[offset + 3] = 128 | point & 63;
+				}
+				offset += 4;
+				index += 1;
+				continue;
+			}
+		}
+		if (code >= 55296 && code <= 57343) throw new TypeError("compound key string parts must contain valid Unicode scalar values");
+		if (out !== null) {
+			out[offset] = 224 | code >> 12;
+			out[offset + 1] = 128 | code >> 6 & 63;
+			out[offset + 2] = 128 | code & 63;
+		}
+		offset += 3;
+	}
+	return offset;
+}
 function encodeSortableNumber(value) {
+	const bytes = /* @__PURE__ */ new Uint8Array(9);
+	writeSortableNumber(new DataView(bytes.buffer), value);
+	return bytes;
+}
+function writeSortableNumber(view, value) {
 	if (!Number.isFinite(value)) throw new TypeError("compound key number parts must be finite");
 	const normalized = Object.is(value, -0) ? 0 : value;
-	const buffer = /* @__PURE__ */ new ArrayBuffer(9);
-	const view = new DataView(buffer);
 	view.setUint8(0, TYPE_NUMBER);
 	view.setFloat64(1, normalized, false);
 	let bits = view.getBigUint64(1, false);
 	bits = (bits & 1n << 63n) !== 0n ? ~bits & F64_MASK : bits ^ 1n << 63n;
 	view.setBigUint64(1, bits, false);
-	return new Uint8Array(buffer);
 }
 //#endregion
 //#region src/indexing.ts
@@ -1412,37 +1530,50 @@ function decodeIndexMetadataValue(bytes) {
 	}
 }
 function encodeIndexEntryKey(logicalIndexKey, primaryKey) {
-	return encodeCompoundKeyParts([logicalIndexKey, primaryKey]);
+	const out = new Uint8Array(compoundEncodedLength(logicalIndexKey) + compoundEncodedLength(primaryKey));
+	writeCompoundPart(out, writeCompoundPart(out, 0, logicalIndexKey), primaryKey);
+	return out;
 }
 function decodeIndexEntryKey(bytes) {
-	let parts;
 	try {
-		parts = splitCompoundKey(bytes);
+		return decodeTwoPartIndexKey(bytes);
 	} catch (error) {
+		if (error instanceof SerializationError) throw error;
 		throw new SerializationError(`invalid index entry key encoding: ${String(error)}`);
 	}
-	if (parts.length !== 2) throw new SerializationError("invalid index entry key encoding");
-	return {
-		logicalKey: parts[0],
-		primaryKey: parts[1]
-	};
 }
 function indexKeyExactRange(logicalIndexKey) {
-	return prefixRange(encodeCompoundKeyParts([logicalIndexKey]));
+	const gte = encodeCompoundPrefix(logicalIndexKey);
+	const lt = advanceEncodedPrefix(gte.slice());
+	return lt ? {
+		gte,
+		lt
+	} : { gte };
+}
+/** WASM `usize` is 32-bit, so this is the largest limit the engine can accept. */
+var MAX_ENGINE_SCAN_LIMIT = 4294967295;
+/**
+* Bounds and limits follow the engine `RangeSpec` contract.
+* Conflicting bounds and a limit the engine cannot store are `InvalidRangeError`.
+*/
+function assertValidScanRange(range = {}) {
+	if (range.gt !== void 0 && range.gte !== void 0) throw new InvalidRangeError("range cannot include both gt and gte");
+	if (range.lt !== void 0 && range.lte !== void 0) throw new InvalidRangeError("range cannot include both lt and lte");
+	if (range.limit !== void 0 && (!Number.isSafeInteger(range.limit) || range.limit < 0 || range.limit > 4294967295)) throw new InvalidRangeError("limit must be an integer between 0 and 4294967295");
 }
 function indexRangeToPhysicalRange(range = {}) {
-	validateIndexRangeShape(range);
+	assertValidScanRange(range);
 	const physical = {};
 	if (range.reverse !== void 0) physical.reverse = range.reverse;
 	if (range.limit !== void 0) physical.limit = range.limit;
-	if (range.gte) physical.gte = encodeCompoundKeyParts([range.gte]);
+	if (range.gte) physical.gte = encodeCompoundPrefix(range.gte);
 	if (range.gt) {
-		const lower = prefixSuccessor(encodeCompoundKeyParts([range.gt]));
+		const lower = advanceEncodedPrefix(encodeCompoundPrefix(range.gt));
 		if (lower) physical.gte = lower;
 	}
-	if (range.lt) physical.lt = encodeCompoundKeyParts([range.lt]);
+	if (range.lt) physical.lt = encodeCompoundPrefix(range.lt);
 	if (range.lte) {
-		const upper = prefixSuccessor(encodeCompoundKeyParts([range.lte]));
+		const upper = advanceEncodedPrefix(encodeCompoundPrefix(range.lte));
 		if (upper) physical.lt = upper;
 	}
 	return physical;
@@ -1573,11 +1704,113 @@ function describeValue(value) {
 	if (Array.isArray(value)) return "array";
 	return typeof value;
 }
-function validateIndexRangeShape(range) {
-	if (range.gt !== void 0 && range.gte !== void 0) throw new TypeError("index range cannot specify both gt and gte");
-	if (range.lt !== void 0 && range.lte !== void 0) throw new TypeError("index range cannot specify both lt and lte");
+var INDEX_KEY_ESCAPE = 0;
+var INDEX_KEY_ESCAPE_CONT = 255;
+var INDEX_KEY_TERM = 0;
+function compoundEncodedLength(part) {
+	let zeros = 0;
+	const length = part.length;
+	for (let index = 0; index < length; index += 1) if (part[index] === INDEX_KEY_ESCAPE) zeros += 1;
+	return length + zeros + 2;
+}
+function writeCompoundPart(out, offset, part) {
+	const length = part.length;
+	for (let index = 0; index < length; index += 1) {
+		const byte = part[index];
+		if (byte === INDEX_KEY_ESCAPE) {
+			out[offset] = INDEX_KEY_ESCAPE;
+			out[offset + 1] = INDEX_KEY_ESCAPE_CONT;
+			offset += 2;
+		} else {
+			out[offset] = byte;
+			offset += 1;
+		}
+	}
+	out[offset] = INDEX_KEY_TERM;
+	out[offset + 1] = INDEX_KEY_TERM;
+	return offset + 2;
+}
+function encodeCompoundPrefix(part) {
+	const out = new Uint8Array(compoundEncodedLength(part));
+	writeCompoundPart(out, 0, part);
+	return out;
+}
+function advanceEncodedPrefix(prefix) {
+	for (let index = prefix.length - 1; index >= 0; index -= 1) if (prefix[index] !== 255) {
+		prefix[index] += 1;
+		return index + 1 === prefix.length ? prefix : prefix.subarray(0, index + 1);
+	}
+	return null;
+}
+function decodeTwoPartIndexKey(bytes) {
+	const cursor = {
+		unescaped: 0,
+		end: 0
+	};
+	if (!readCompoundPart(bytes, 0, cursor)) throw new SerializationError("invalid index entry key encoding");
+	const logicalLength = cursor.unescaped;
+	const primaryStart = cursor.end;
+	if (!readCompoundPart(bytes, primaryStart, cursor)) throw new SerializationError("invalid index entry key encoding");
+	const primaryLength = cursor.unescaped;
+	let end = cursor.end;
+	if (end !== bytes.length) for (;;) {
+		if (!readCompoundPart(bytes, end, cursor)) throw new SerializationError("invalid index entry key encoding");
+		if (cursor.end <= end) throw new TypeError("invalid compound key encoding");
+		end = cursor.end;
+		if (end === bytes.length) throw new SerializationError("invalid index entry key encoding");
+	}
+	const logicalKey = new Uint8Array(logicalLength);
+	const primaryKey = new Uint8Array(primaryLength);
+	copyUnescapedPart(bytes, 0, logicalKey);
+	copyUnescapedPart(bytes, primaryStart, primaryKey);
+	return {
+		logicalKey,
+		primaryKey
+	};
+}
+function readCompoundPart(bytes, start, cursor) {
+	if (start >= bytes.length) return false;
+	let unescaped = 0;
+	for (let index = start; index < bytes.length; index += 1) {
+		if (bytes[index] !== INDEX_KEY_ESCAPE) {
+			unescaped += 1;
+			continue;
+		}
+		const next = bytes[index + 1];
+		if (next === INDEX_KEY_ESCAPE_CONT) {
+			unescaped += 1;
+			index += 1;
+			continue;
+		}
+		if (next === INDEX_KEY_TERM) {
+			cursor.unescaped = unescaped;
+			cursor.end = index + 2;
+			return true;
+		}
+		throw new TypeError("invalid compound key encoding");
+	}
+	throw new TypeError("compound key terminated unexpectedly");
+}
+function copyUnescapedPart(bytes, start, out) {
+	const needed = out.length;
+	let offset = 0;
+	for (let index = start; offset < needed; index += 1) {
+		const byte = bytes[index];
+		if (byte !== INDEX_KEY_ESCAPE) {
+			out[offset] = byte;
+			offset += 1;
+			continue;
+		}
+		if (bytes[index + 1] === INDEX_KEY_ESCAPE_CONT) {
+			out[offset] = INDEX_KEY_ESCAPE;
+			offset += 1;
+			index += 1;
+			continue;
+		}
+		return;
+	}
 }
 //#endregion
-export { StoreExistsError as $, prefixRange as A, packedBinaryListBytes as At, DatabaseClosedError as B, unpackPackedOptionalValues as Bt, compoundKey as C, isWorkerProtocolReadyEnvelope as Ct, indexKey as D, isWorkerProtocolResponseBatchMessage as Dt, encodeIndexScalar as E, isWorkerProtocolRequestMessage as Et, utf8Encode as F, serializeWorkerError as Ft, InvalidRangeError as G, isRecord as Gt, InjectedFailureError as H, workerProtocolError as Ht, ChangeFeedCompactedError as I, unpackPackedBatchOpKeys as It, ReadonlyTransactionError as J, KeyTooLargeError as K, ConstraintError as L, unpackPackedBatchOps as Lt, splitCompoundKey as M, packedScanRows as Mt, u64Key as N, prepareWorkerCommandPayload as Nt, jsonDecode as O, isWorkerProtocolResponseMessage as Ot, utf8Decode as P, prepareWorkerResponsePayload as Pt, StorageError as Q, CorruptionError as R, unpackPackedBinaryList as Rt, toPublicIndexDefinitions as S, isWorkerProtocolEnvelope as St, encodeCompoundKeyParts as T, isWorkerProtocolRequestBatchMessage as Tt, InternalError as U, clampTimerDelayMs as Ut, IndexNotFoundError as V, unpackPackedScanRows as Vt, InvalidOpenOptionsError as W, compareStringsByCodeUnit as Wt, ReservedStoreNameError as X, RecoveryRequiredError as Y, SerializationError as Z, indexRangeToPhysicalRange as _, decodeWorkerCommandPayload as _t, createIndexKeyExtractor as a, UnsupportedPlatformError as at, normalizeIndexDefinitions as b, isAutocommitCommand as bt, decodeIndexedDocument as c, WriteTransactionAlreadyOpenError as ct, encodeIndexMetadataValue as d, WORKER_PROTOCOL_READY as dt, StoreNameTooLongError as et, extractLogicalIndexKey as f, WORKER_PROTOCOL_REQUEST as ft, indexKeyExactRange as g, captureWorkerPayload as gt, indexDefinitionIdentity as h, WORKER_PROTOCOL_RESPONSE_BATCH as ht, compareNormalizedIndexDefinitions as i, UniqueIndexConstraintError as it, prefixSuccessor as j, packedOptionalValues as jt, jsonEncode as k, packedBatchOpsBytes as kt, encodeIndexEntryKey as l, normalizeError as lt, findIndexDefinition as m, WORKER_PROTOCOL_RESPONSE as mt, assertPublicStoreName as n, TransactionClosedError as nt, decodeIndexEntryKey as o, ValueTooLargeError as ot, extractLogicalIndexKeyFromDocument as p, WORKER_PROTOCOL_REQUEST_BATCH as pt, MoyoDbError as q, cloneNormalizedIndexDefinitions as r, TransactionConflictError as rt, decodeIndexMetadataValue as s, VersionError as st, INDEX_METADATA_STORE as t, StoreNotFoundError as tt, encodeIndexMetadataKey as u, MAX_WORKER_BATCH_BYTES as ut, indexesForStore as v, decodeWorkerResponsePayload as vt, compoundKeyRange as w, isWorkerProtocolReadyMessage as wt, serializeNormalizedIndexDefinitions as x, isWorkerCommand as xt, isInternalStoreName as y, deserializeWorkerError as yt, DatabaseBusyError as z, unpackPackedBinaryPairKeys as zt };
+export { SerializationError as $, jsonDecode as A, isWorkerProtocolResponseMessage as At, CorruptionError as B, unpackPackedBinaryList as Bt, serializeNormalizedIndexDefinitions as C, isWorkerCommand as Ct, encodeCompoundKeyParts as D, isWorkerProtocolRequestBatchMessage as Dt, compoundKeyRange as E, isWorkerProtocolReadyMessage as Et, u64Key as F, prepareWorkerCommandPayload as Ft, InternalError as G, clampTimerDelayMs as Gt, DatabaseClosedError as H, unpackPackedOptionalValues as Ht, utf8Decode as I, prepareWorkerResponsePayload as It, KeyTooLargeError as J, InvalidOpenOptionsError as K, compareStringsByCodeUnit as Kt, utf8Encode as L, serializeWorkerError as Lt, prefixRange as M, packedBinaryListBytes as Mt, prefixSuccessor as N, packedOptionalValues as Nt, encodeIndexScalar as O, isWorkerProtocolRequestMessage as Ot, splitCompoundKey as P, packedScanRows as Pt, ReservedStoreNameError as Q, ChangeFeedCompactedError as R, unpackPackedBatchOpKeys as Rt, normalizeIndexDefinitions as S, isAutocommitCommand as St, compoundKey as T, isWorkerProtocolReadyEnvelope as Tt, IndexNotFoundError as U, unpackPackedScanRows as Ut, DatabaseBusyError as V, unpackPackedBinaryPairKeys as Vt, InjectedFailureError as W, workerProtocolError as Wt, ReadonlyTransactionError as X, MoyoDbError as Y, RecoveryRequiredError as Z, indexDefinitionIdentity as _, WORKER_PROTOCOL_RESPONSE_BATCH as _t, cloneNormalizedIndexDefinitions as a, TransactionConflictError as at, indexesForStore as b, decodeWorkerResponsePayload as bt, decodeIndexEntryKey as c, ValueTooLargeError as ct, encodeIndexEntryKey as d, normalizeError as dt, StorageError as et, encodeIndexMetadataKey as f, MAX_WORKER_BATCH_BYTES as ft, findIndexDefinition as g, WORKER_PROTOCOL_RESPONSE as gt, extractLogicalIndexKeyFromDocument as h, WORKER_PROTOCOL_REQUEST_BATCH as ht, assertValidScanRange as i, TransactionClosedError as it, jsonEncode as j, packedBatchOpsBytes as jt, indexKey as k, isWorkerProtocolResponseBatchMessage as kt, decodeIndexMetadataValue as l, VersionError as lt, extractLogicalIndexKey as m, WORKER_PROTOCOL_REQUEST as mt, MAX_ENGINE_SCAN_LIMIT as n, StoreNameTooLongError as nt, compareNormalizedIndexDefinitions as o, UniqueIndexConstraintError as ot, encodeIndexMetadataValue as p, WORKER_PROTOCOL_READY as pt, InvalidRangeError as q, isRecord as qt, assertPublicStoreName as r, StoreNotFoundError as rt, createIndexKeyExtractor as s, UnsupportedPlatformError as st, INDEX_METADATA_STORE as t, StoreExistsError as tt, decodeIndexedDocument as u, WriteTransactionAlreadyOpenError as ut, indexKeyExactRange as v, captureWorkerPayload as vt, toPublicIndexDefinitions as w, isWorkerProtocolEnvelope as wt, isInternalStoreName as x, deserializeWorkerError as xt, indexRangeToPhysicalRange as y, decodeWorkerCommandPayload as yt, ConstraintError as z, unpackPackedBatchOps as zt };
 
-//# sourceMappingURL=indexing-B0duqlUs.js.map
+//# sourceMappingURL=indexing-DdpU69Fd.js.map