@dxos/util 0.10.0 → 0.11.0

package/dist/lib/index.mjs

@@ -0,0 +1,2575 @@
+import { inspect, promisify } from "@dxos/node-std/util";
+import { invariant } from "@dxos/invariant";
+import { inspectObject, raise, truncateKey } from "@dxos/debug";
+import "@hazae41/symbol-dispose-polyfill";
+import { PublicKey } from "@dxos/keys";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/array-to-hex.ts
+var byteToHex = [];
+for (let n = 0; n <= 255; ++n) {
+	const hexOctet = n.toString(16).padStart(2, "0");
+	byteToHex.push(hexOctet);
+}
+var arrayToHex = (buf) => {
+	const buff = new Uint8Array(buf);
+	const hexOctets = [];
+	for (let i = 0; i < buff.length; ++i) hexOctets.push(byteToHex[buff[i]]);
+	return hexOctets.join("");
+};
+//#endregion
+//#region src/array.ts
+/**
+* Compute diff between two arrays.
+* @param previous
+* @param next
+* @param comparator
+*/
+var diff = (previous, next, comparator) => {
+	const remaining = [...previous];
+	const result = {
+		added: [],
+		updated: [],
+		removed: remaining
+	};
+	for (const object of next) {
+		const index = remaining.findIndex((item) => comparator(item, object));
+		if (index === -1) result.added.push(object);
+		else {
+			result.updated.push(object);
+			remaining.splice(index, 1);
+		}
+	}
+	return result;
+};
+var intersection = (a, b, comparator) => a.filter((a) => b.find((b) => comparator(a, b)) !== void 0);
+/**
+* Returns a new array with only the first instance of each unique item
+* based on a specified property.
+*
+* @typeProp T - The type of items in the input array.
+* @param array - The array to filter for distinct items.
+* @param key - The property key to determine uniqueness for each item.
+* @returns A new array with only distinct items based on the specified property.
+*/
+var distinctBy = (array, selector) => {
+	const seenKeys = /* @__PURE__ */ new Set();
+	return array.filter((item) => {
+		const key = selector(item);
+		if (seenKeys.has(key)) return false;
+		seenKeys.add(key);
+		return true;
+	});
+};
+/**
+* Remove elements from array.
+* @param array
+* @param test
+* @returns removed elements.
+*/
+var removeBy = (array, test) => {
+	const removed = [];
+	for (let i = array.length - 1; i >= 0; i--) if (test(array[i], i)) removed.push(...array.splice(i, 1));
+	return removed;
+};
+/**
+* Splits an array based on a type guard predicate function.
+* Infers the output tuple types from the guard function.
+*/
+var partition = (array, guard) => {
+	return array.reduce(([accepted, rejected], item, index, array) => guard(item, index, array) ? [[...accepted, item], rejected] : [accepted, [...rejected, item]], [[], []]);
+};
+/**
+* Returns elements that exist in all provided arrays based on a selector function.
+*
+* @param arrays - Arrays to intersect.
+* @param selector - Function to extract the comparison value from each element.
+* @returns Array containing elements from the first array that exist in all other arrays.
+*/
+var intersectBy = (arrays, selector) => {
+	if (arrays.length === 0) return [];
+	if (arrays.length === 1) return [...arrays[0]];
+	const [first, ...rest] = arrays;
+	const lookups = rest.map((array) => {
+		const map = /* @__PURE__ */ new Map();
+		for (const item of array) map.set(selector(item), item);
+		return map;
+	});
+	return first.filter((item) => {
+		const key = selector(item);
+		return lookups.every((lookup) => lookup.has(key));
+	});
+};
+var coerceArray = (arr) => {
+	if (arr === void 0) return [];
+	return Array.isArray(arr) ? arr : [arr];
+};
+//#endregion
+//#region src/assume.ts
+/**
+* Assumes the type of the value.
+*
+* @param value - The value to assume the type of.
+*
+* @example
+* ```ts
+* const value: unknown = 1;
+* assumeType<number>(value);
+*
+* // value is now of type number
+* ```
+*/
+function assumeType(value) {}
+//#endregion
+//#region src/binder.ts
+/**
+* Function binder replaces pify.
+*/
+var createBinder = (obj) => ({
+	fn: (fn) => fn.bind(obj),
+	async: (fn) => promisify(fn.bind(obj))
+});
+//#endregion
+//#region src/bitfield.ts
+var __dxlog_file$4 = "/__w/dxos/dxos/packages/common/util/src/bitfield.ts";
+/**
+* Bitfield encodes indices from MSB to LSB.
+* Index 0 is the MSB of the first byte.
+*
+*
+* #0       #1       #2       #3
+* 01010101 11110000 00001111 01010101
+* ^      ^
+* MSB    LSB
+*/
+var BitField = class BitField {
+	static get(data, idx) {
+		return !!(data[idx >> 3] >> 7 - idx % 8 & 1);
+	}
+	static set(data, idx, value) {
+		if (value) data[idx >> 3] = data[idx >> 3] | 1 << 7 - idx % 8;
+		else data[idx >> 3] = data[idx >> 3] & ~(1 << 7 - idx % 8);
+	}
+	/**
+	* [start; end)
+	*/
+	static count(data, begin, end) {
+		let count = 0;
+		for (let i = begin; i < end; i++) {
+			const bit = data[i >> 3] >> 7 - i % 8 & 1;
+			count += bit;
+		}
+		return count;
+	}
+	static invert(data) {
+		const result = new Uint8Array(data.length);
+		for (let i = 0; i < data.length; i++) result[i] = ~data[i];
+		return result;
+	}
+	static and(first, second) {
+		invariant(first.length === second.length, "Bitfields must be of the same length", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$4,
+			L: 52,
+			S: this,
+			A: ["first.length === second.length", "'Bitfields must be of the same length'"]
+		});
+		const result = new Uint8Array(first.length);
+		for (let i = 0; i < first.length; i++) result[i] = first[i] & second[i];
+		return result;
+	}
+	static findIndexes(data, opts = {}) {
+		const { start = 0, end = data.length * 8, value = true } = opts;
+		const result = [];
+		for (let i = start; i < end; i++) if (BitField.get(data, i) === value) result.push(i);
+		return result;
+	}
+	static ones(count) {
+		const res = new Uint8Array(Math.ceil(Math.ceil(count) / 8)).fill(255);
+		const bitInLastByte = Math.ceil(count % 8);
+		res[res.length - 1] = 255 << 8 - bitInLastByte;
+		return res;
+	}
+	static zeros(count) {
+		return new Uint8Array(Math.ceil(Math.ceil(count) / 8)).fill(0);
+	}
+};
+//#endregion
+//#region src/browser-storage.ts
+/** Delete all IndexedDB databases for this origin. */
+var clearIndexedDB = async () => {
+	const dbs = await indexedDB.databases();
+	const failures = (await Promise.allSettled(dbs.filter((db) => db.name != null).map((db) => new Promise((resolve, reject) => {
+		const request = indexedDB.deleteDatabase(db.name);
+		request.onsuccess = () => resolve();
+		request.onerror = () => reject(request.error);
+		request.onblocked = () => reject(/* @__PURE__ */ new Error(`IndexedDB deletion blocked: ${db.name}`));
+	})))).filter((r) => r.status === "rejected");
+	if (failures.length > 0) throw new AggregateError(failures.map((r) => r.reason), "Failed to delete some IndexedDB databases");
+};
+/** Remove all entries from the Origin Private File System. */
+var clearOPFS = async () => {
+	const root = await navigator.storage.getDirectory();
+	const errors = [];
+	for await (const [name] of root.entries()) try {
+		await root.removeEntry(name, { recursive: true });
+	} catch (err) {
+		errors.push(err);
+	}
+	if (errors.length > 0) throw new AggregateError(errors, "Failed to remove some OPFS entries");
+};
+/** Unregister all service workers for this origin. */
+var clearServiceWorkers = async () => {
+	const regs = await navigator.serviceWorker.getRegistrations();
+	for (const reg of regs) await reg.unregister();
+};
+/** Delete all HTTP caches for this origin. */
+var clearCaches = async () => {
+	const keys = await caches.keys();
+	for (const key of keys) await caches.delete(key);
+};
+//#endregion
+//#region src/callback-collection.ts
+/**
+* A collection of async functions.
+*/
+var CallbackCollection = class {
+	#callbacks = [];
+	append(callback) {
+		this.#callbacks.push(callback);
+	}
+	prepend(callback) {
+		this.#callbacks.unshift(callback);
+	}
+	remove(callback) {
+		this.#callbacks = this.#callbacks.filter((c) => c !== callback);
+	}
+	callParallel(...args) {
+		return Promise.all(this.#callbacks.map((callback) => callback(...args)));
+	}
+	async callSerial(...args) {
+		const results = [];
+		for (const callback of this.#callbacks) results.push(await callback(...args));
+		return results;
+	}
+};
+//#endregion
+//#region src/callback.ts
+var __dxlog_file$3 = "/__w/dxos/dxos/packages/common/util/src/callback.ts";
+/**
+* Represents a callback that can be set once.
+*
+* Common usage is dependency injection.
+* In contrast to events, callbacks can only have one handler,
+* are executed synchronously,
+* and can return results.
+*/
+var Callback = class {
+	_callback;
+	call(...args) {
+		invariant(this._callback, "Callback not set", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$3,
+			L: 20,
+			S: this,
+			A: ["this._callback", "'Callback not set'"]
+		});
+		return this._callback(...args);
+	}
+	callIfSet(...args) {
+		return this._callback?.(...args);
+	}
+	set(callback) {
+		invariant(!this._callback, "Callback already set", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$3,
+			L: 29,
+			S: this,
+			A: ["!this._callback", "'Callback already set'"]
+		});
+		this._callback = callback;
+	}
+	isSet() {
+		return !!this._callback;
+	}
+};
+/**
+* Create a fan-out callback handler.
+* NOTE: Methods cannot return values.
+*/
+var createSetDispatch = ({ handlers }) => {
+	return new Proxy({ handlers }, { get: (target, prop) => {
+		return (...args) => {
+			handlers.forEach((handler) => {
+				const method = handler[prop];
+				if (method) method.apply(handler, args);
+			});
+		};
+	} });
+};
+//#endregion
+//#region src/case.ts
+var LOW_DASH = "_".codePointAt(0);
+var HI_DASH = "-".codePointAt(0);
+var SMALL_A = "a".codePointAt(0);
+var CAPITAL_A = "A".codePointAt(0);
+var SMALL_Z = "z".codePointAt(0);
+var CAPITAL_Z = "Z".codePointAt(0);
+var isLower = (char) => char >= SMALL_A && char <= SMALL_Z;
+var isUpper = (char) => char >= CAPITAL_A && char <= CAPITAL_Z;
+var toLower = (char) => char + 32;
+/**
+* NOTE: Removed `xcase` due to CF dependency conflicts.
+*/
+var changeCase = (str, delim) => {
+	if (!isLower(str.charCodeAt(0))) return str;
+	const length = str.length;
+	let changed = false;
+	const out = [];
+	for (let i = 0; i < length; ++i) {
+		const c = str.charCodeAt(i);
+		if (isUpper(c)) {
+			out.push(delim);
+			out.push(toLower(c));
+			changed = true;
+		} else out.push(c);
+	}
+	return changed ? String.fromCharCode.apply(void 0, out) : str;
+};
+var decamelize = (str) => changeCase(str, LOW_DASH);
+var hyphenize = (str) => changeCase(str, HI_DASH);
+//#endregion
+//#region src/chunk-array.ts
+var chunkArray = (array, size) => {
+	const result = [];
+	for (let i = 0; i < array.length; i += size) result.push(array.slice(i, i + size));
+	return result;
+};
+//#endregion
+//#region src/circular-buffer.ts
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/common/util/src/circular-buffer.ts";
+var CircularBuffer = class {
+	_buffer;
+	_nextIndex = 0;
+	_elementCount = 0;
+	constructor(size) {
+		invariant(size >= 1, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 13,
+			S: this,
+			A: ["size >= 1", ""]
+		});
+		this._buffer = new Array(size);
+	}
+	push(element) {
+		const evicted = this._elementCount === this._buffer.length ? this._buffer[this._nextIndex] : void 0;
+		this._buffer[this._nextIndex] = element;
+		this._nextIndex = (this._nextIndex + 1) % this._buffer.length;
+		this._elementCount = Math.min(this._buffer.length, this._elementCount + 1);
+		return evicted;
+	}
+	get elementCount() {
+		return this._elementCount;
+	}
+	clear() {
+		this._nextIndex = 0;
+		this._elementCount = 0;
+	}
+	getLast() {
+		if (this._elementCount === 0) return;
+		if (this._nextIndex === 0) return this._buffer[this._buffer.length - 1];
+		return this._buffer[this._nextIndex - 1];
+	}
+	[Symbol.iterator]() {
+		return this.values();
+	}
+	*values() {
+		if (this._elementCount === 0) return;
+		if (this._elementCount < this._buffer.length) {
+			for (let i = 0; i < this._elementCount; i++) yield this._buffer[i];
+			return;
+		}
+		for (let i = this._nextIndex; i < this._buffer.length; i++) yield this._buffer[i];
+		for (let i = 0; i < this._nextIndex; i++) yield this._buffer[i];
+	}
+};
+//#endregion
+//#region src/clear-undefined.ts
+/**
+* Remove undefined values from an object.
+*/
+var clearUndefined = (obj) => {
+	for (const key of [...Object.getOwnPropertyNames(obj), ...Object.getOwnPropertySymbols(obj)]) if (obj[key] === void 0) delete obj[key];
+	return obj;
+};
+//#endregion
+//#region src/complex.ts
+var MAX_SERIALIZATION_LENGTH = 10;
+/**
+* A set implementation that can hold complex values (like Buffer).
+*
+* The user must provide a projection function which returns a primitive
+* representation of the complex value. This function must be 1-to-1 mapping.
+*
+* Look at `../complex.test.ts` for usage examples.
+*/
+var ComplexSet = class {
+	_projection;
+	_values = /* @__PURE__ */ new Map();
+	constructor(_projection, values) {
+		this._projection = _projection;
+		if (values) for (const value of values) this.add(value);
+	}
+	toString() {
+		return inspectObject(this);
+	}
+	toJSON() {
+		return this._values.size > MAX_SERIALIZATION_LENGTH ? { size: this._values.size } : Array.from(this._values.values());
+	}
+	[inspect.custom]() {
+		return inspectObject(this);
+	}
+	add(value) {
+		this._values.set(this._projection(value), value);
+		return this;
+	}
+	clear() {
+		this._values.clear();
+	}
+	delete(value) {
+		return this._values.delete(this._projection(value));
+	}
+	forEach(callbackfn, thisArg) {
+		if (thisArg) callbackfn = callbackfn.bind(thisArg);
+		this._values.forEach((value) => callbackfn(value, value, this));
+	}
+	has(value) {
+		return this._values.has(this._projection(value));
+	}
+	get size() {
+		return this._values.size;
+	}
+	[Symbol.iterator]() {
+		return this._values.values();
+	}
+	*entries() {
+		for (const value of this._values.values()) yield [value, value];
+	}
+	keys() {
+		return this[Symbol.iterator]();
+	}
+	values() {
+		return this[Symbol.iterator]();
+	}
+	get [Symbol.toStringTag]() {
+		return "ComplexSet";
+	}
+	union(other) {
+		throw new Error("Method not implemented.");
+	}
+	intersection(other) {
+		throw new Error("Method not implemented.");
+	}
+	difference(other) {
+		throw new Error("Method not implemented.");
+	}
+	symmetricDifference(other) {
+		throw new Error("Method not implemented.");
+	}
+	isSubsetOf(other) {
+		throw new Error("Method not implemented.");
+	}
+	isSupersetOf(other) {
+		throw new Error("Method not implemented.");
+	}
+	isDisjointFrom(other) {
+		throw new Error("Method not implemented.");
+	}
+};
+/**
+* Create a subclass of ComplexSet with predefined projection function.
+*/
+var makeSet = (projection) => {
+	return class BoundComplexSet extends ComplexSet {
+		constructor(values) {
+			super(projection, values);
+		}
+	};
+};
+/**
+* A map implementation that can hold complex values (like Buffer) as keys.
+* The user must provide a projection function for map keys which returns a primitive
+* representation of the complex value. This function must be 1-to-1 mapping.
+* Look at `../complex.test.ts` for usage examples.
+*/
+var ComplexMap = class ComplexMap {
+	_keyProjection;
+	_keys = /* @__PURE__ */ new Map();
+	_values = /* @__PURE__ */ new Map();
+	constructor(_keyProjection, entries) {
+		this._keyProjection = _keyProjection;
+		if (entries) for (const [key, value] of entries) this.set(key, value);
+	}
+	toString() {
+		return inspectObject(this);
+	}
+	toJSON() {
+		return this._values.size > MAX_SERIALIZATION_LENGTH ? { size: this._values.size } : Array.from(this._values.values());
+	}
+	[inspect.custom]() {
+		return inspectObject(this);
+	}
+	clear() {
+		this._keys.clear();
+		this._values.clear();
+	}
+	delete(key) {
+		const keyDeleted = this._keys.delete(this._keyProjection(key));
+		const valueDeleted = this._values.delete(this._keyProjection(key));
+		return keyDeleted || valueDeleted;
+	}
+	forEach(callbackfn, thisArg) {
+		if (thisArg) callbackfn = callbackfn.bind(thisArg);
+		this._keys.forEach((key, primitive) => callbackfn(this._values.get(primitive) ?? raise(/* @__PURE__ */ new Error("Map corrupted.")), key, this));
+	}
+	get(key) {
+		return this._values.get(this._keyProjection(key));
+	}
+	has(key) {
+		return this._keys.has(this._keyProjection(key));
+	}
+	set(key, value) {
+		const primitive = this._keyProjection(key);
+		this._keys.set(primitive, key);
+		this._values.set(primitive, value);
+		return this;
+	}
+	/**
+	* Returns the value for the given key if present, otherwise inserts and returns the default value.
+	* @param key - The key to look up or insert.
+	* @param defaultValue - The value to insert if the key is not present.
+	* @returns The existing or newly inserted value.
+	*/
+	getOrInsert(key, defaultValue) {
+		const primitive = this._keyProjection(key);
+		if (this._values.has(primitive)) return this._values.get(primitive);
+		this.set(key, defaultValue);
+		return defaultValue;
+	}
+	/**
+	* Returns the value for the given key if present, otherwise computes, inserts, and returns a new value.
+	* The callback is only invoked when the key is missing.
+	* @param key - The key to look up or insert.
+	* @param callbackfn - Function to compute the value if the key is not present.
+	* @returns The existing or newly computed value.
+	*/
+	getOrInsertComputed(key, callbackfn) {
+		const primitive = this._keyProjection(key);
+		if (this._values.has(primitive)) return this._values.get(primitive);
+		const value = callbackfn(key);
+		this.set(key, value);
+		return value;
+	}
+	get size() {
+		return this._keys.size;
+	}
+	*[Symbol.iterator]() {
+		for (const [primitive, key] of this._keys) yield [key, this._values.get(primitive) ?? raise(/* @__PURE__ */ new Error("Map corrupted."))];
+	}
+	entries() {
+		return this[Symbol.iterator]();
+	}
+	keys() {
+		return this._keys.values();
+	}
+	values() {
+		return this._values.values();
+	}
+	mapValues(mapper) {
+		return new ComplexMap(this._keyProjection, [...this.entries()].map(([key, value]) => [key, mapper(value, key)]));
+	}
+	get [Symbol.toStringTag]() {
+		return "ComplexMap";
+	}
+};
+/**
+* Create a subclass of ComplexMap with predefined key projection function.
+*/
+var makeMap = (keyProjection) => class BoundComplexMap extends ComplexMap {
+	constructor(entries) {
+		super(keyProjection, entries);
+	}
+};
+//#endregion
+//#region src/composite-key.ts
+var SEPARATOR = ":";
+/**
+* Build a composite key from string parts joined by a colon separator.
+* Parts must not contain the separator character.
+*/
+var compositeKey = (...parts) => parts.join(SEPARATOR);
+/**
+* Split a composite key back into its parts.
+*/
+var splitCompositeKey = (key) => key.split(SEPARATOR);
+//#endregion
+//#region src/deep.ts
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/common/util/src/deep.ts";
+/**
+* Initialize a deeply nested object.
+* @returns The value of the prop after assignment.
+*/
+var setDeep = (obj, path, value) => {
+	invariant(path.length > 0, void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$1,
+		L: 12,
+		S: void 0,
+		A: ["path.length > 0", ""]
+	});
+	let parent = obj;
+	for (const key of path.slice(0, -1)) {
+		if (parent[key] === void 0) {
+			const isArrayIndex = !isNaN(Number(key));
+			parent[key] = isArrayIndex ? [] : {};
+		}
+		parent = parent[key];
+	}
+	parent[path.at(-1)] = value;
+	return obj;
+};
+/**
+* Gets a value from a deeply nested object.
+* @returns The value of the prop if it exists, otherwise undefined.
+*/
+var getDeep = (obj, path) => {
+	let parent = obj;
+	for (const key of path) parent = parent?.[key];
+	return parent;
+};
+//#endregion
+//#region src/defer-function.ts
+/**
+* Wraps a function provider in a function that will defer the execution of the provided function.
+*
+* Example:
+*
+* ```typescript
+* const fn = deferFunction(() => impl);
+*
+* // Impl can be defined after the usage.
+* const impl = () => {
+*  console.log('Hello World!')
+* }
+* ```
+*/
+var deferFunction = (fnProvider) => (...args) => fnProvider()(...args);
+//#endregion
+//#region src/defer.ts
+/**
+* Run function on scope exit. Go style.
+*
+* @example
+* ```ts
+* {
+*   using _ = defer(() => console.log('exiting'));
+*
+*   ...
+* }
+*/
+var defer = (fn) => new DeferGuard(fn);
+var DeferGuard = class {
+	_fn;
+	/**
+	* @internal
+	*/
+	constructor(_fn) {
+		this._fn = _fn;
+	}
+	[Symbol.dispose]() {
+		if (this._fn() instanceof Promise) throw new Error("Async functions in defer are not supported. Use deferAsync instead.");
+	}
+};
+/**
+* Run async function on scope exit. Go style.
+*
+* @example
+* ```ts
+* {
+*   await using _ = deferAsync(async () => console.log('exiting'));
+*
+*   ...
+* }
+*/
+var deferAsync = (fn) => new DeferAsyncGuard(fn);
+var DeferAsyncGuard = class {
+	_fn;
+	/**
+	* @internal
+	*/
+	constructor(_fn) {
+		this._fn = _fn;
+	}
+	async [Symbol.asyncDispose]() {
+		await this._fn();
+	}
+};
+//#endregion
+//#region src/entry.ts
+/**
+* Inspired by https://doc.rust-lang.org/std/collections/struct.HashMap.html#method.entry
+*/
+var entry = (map, key) => new MapEntry(map, key);
+var MapEntry = class {
+	_map;
+	_key;
+	/**
+	* @internal
+	*/
+	constructor(_map, _key) {
+		this._map = _map;
+		this._key = _key;
+	}
+	get key() {
+		return this._key;
+	}
+	get value() {
+		return this._map.get(this._key);
+	}
+	orInsert(value) {
+		if (!this._map.has(this._key)) this._map.set(this._key, value);
+		return this;
+	}
+	deep(key) {
+		return entry(this.value, key);
+	}
+};
+//#endregion
+//#region src/error-format.ts
+/**
+* Formats an error with its cause chain.
+*/
+var formatErrorWithCauses = (error) => {
+	const lines = [];
+	let current = error;
+	let level = 0;
+	while (current) {
+		const prefix = level === 0 ? "" : `Caused by: `;
+		lines.push(prefix + (current.stack ?? String(current)));
+		if (!(current.cause instanceof Error)) break;
+		current = current.cause;
+		level += 1;
+	}
+	return lines.join("\n\n");
+};
+//#endregion
+//#region src/filename.ts
+/**
+* Creates a unique filename.
+*/
+var createFilename = ({ parts = [], ext, date = /* @__PURE__ */ new Date() }) => [date.toISOString().replace(/[:.]/g, "-"), ...parts].join("_") + (ext ? `.${ext}` : "");
+//#endregion
+//#region src/for-each-async.ts
+var forEachAsync = (items, fn) => Promise.all(items.map(fn));
+//#endregion
+//#region src/human-hash.ts
+var DEFAULT_WORDLIST = [
+	"ack",
+	"alabama",
+	"alanine",
+	"alaska",
+	"alpha",
+	"angel",
+	"apart",
+	"april",
+	"arizona",
+	"arkansas",
+	"artist",
+	"asparagus",
+	"aspen",
+	"august",
+	"autumn",
+	"avocado",
+	"bacon",
+	"bakerloo",
+	"batman",
+	"beer",
+	"berlin",
+	"beryllium",
+	"black",
+	"blossom",
+	"blue",
+	"bluebird",
+	"bravo",
+	"bulldog",
+	"burger",
+	"butter",
+	"california",
+	"carbon",
+	"cardinal",
+	"carolina",
+	"carpet",
+	"cat",
+	"ceiling",
+	"charlie",
+	"chicken",
+	"coffee",
+	"cola",
+	"cold",
+	"colorado",
+	"comet",
+	"connecticut",
+	"crazy",
+	"cup",
+	"dakota",
+	"december",
+	"delaware",
+	"delta",
+	"diet",
+	"don",
+	"double",
+	"early",
+	"earth",
+	"east",
+	"echo",
+	"edward",
+	"eight",
+	"eighteen",
+	"eleven",
+	"emma",
+	"enemy",
+	"equal",
+	"failed",
+	"fanta",
+	"fifteen",
+	"fillet",
+	"finch",
+	"fish",
+	"five",
+	"fix",
+	"floor",
+	"florida",
+	"football",
+	"four",
+	"fourteen",
+	"foxtrot",
+	"freddie",
+	"friend",
+	"fruit",
+	"gee",
+	"georgia",
+	"glucose",
+	"golf",
+	"green",
+	"grey",
+	"hamper",
+	"happy",
+	"harry",
+	"hawaii",
+	"helium",
+	"high",
+	"hot",
+	"hotel",
+	"hydrogen",
+	"idaho",
+	"illinois",
+	"india",
+	"indigo",
+	"ink",
+	"iowa",
+	"island",
+	"item",
+	"jersey",
+	"jig",
+	"johnny",
+	"juliet",
+	"july",
+	"jupiter",
+	"kansas",
+	"kentucky",
+	"kilo",
+	"king",
+	"kitten",
+	"lactose",
+	"lake",
+	"lamp",
+	"lemon",
+	"leopard",
+	"lima",
+	"lion",
+	"lithium",
+	"london",
+	"louisiana",
+	"low",
+	"magazine",
+	"magnesium",
+	"maine",
+	"mango",
+	"march",
+	"mars",
+	"maryland",
+	"massachusetts",
+	"may",
+	"mexico",
+	"michigan",
+	"mike",
+	"minnesota",
+	"mirror",
+	"mississippi",
+	"missouri",
+	"mobile",
+	"mockingbird",
+	"monkey",
+	"montana",
+	"moon",
+	"mountain",
+	"muppet",
+	"music",
+	"nebraska",
+	"neptune",
+	"network",
+	"nevada",
+	"nine",
+	"nineteen",
+	"nitrogen",
+	"north",
+	"november",
+	"nuts",
+	"october",
+	"ohio",
+	"oklahoma",
+	"one",
+	"orange",
+	"oranges",
+	"oregon",
+	"oscar",
+	"oven",
+	"oxygen",
+	"papa",
+	"paris",
+	"pasta",
+	"pennsylvania",
+	"pip",
+	"pizza",
+	"pluto",
+	"potato",
+	"princess",
+	"purple",
+	"quebec",
+	"queen",
+	"quiet",
+	"red",
+	"river",
+	"robert",
+	"robin",
+	"romeo",
+	"rugby",
+	"sad",
+	"salami",
+	"saturn",
+	"september",
+	"seven",
+	"seventeen",
+	"shade",
+	"sierra",
+	"single",
+	"sink",
+	"six",
+	"sixteen",
+	"skylark",
+	"snake",
+	"social",
+	"sodium",
+	"solar",
+	"south",
+	"spaghetti",
+	"speaker",
+	"spring",
+	"stairway",
+	"steak",
+	"stream",
+	"summer",
+	"sweet",
+	"table",
+	"tango",
+	"ten",
+	"tennessee",
+	"tennis",
+	"texas",
+	"thirteen",
+	"three",
+	"timing",
+	"triple",
+	"twelve",
+	"twenty",
+	"two",
+	"uncle",
+	"undress",
+	"uniform",
+	"uranus",
+	"utah",
+	"vegan",
+	"venus",
+	"vermont",
+	"victor",
+	"video",
+	"violet",
+	"virginia",
+	"washington",
+	"west",
+	"whiskey",
+	"white",
+	"william",
+	"winner",
+	"winter",
+	"wisconsin",
+	"wolfram",
+	"wyoming",
+	"xray",
+	"yankee",
+	"yellow",
+	"zebra",
+	"zulu"
+];
+/**
+* humanhash: Human-readable representations of digests.
+*/
+var HumanHasher = class {
+	wordlist;
+	/**
+	* Transforms hex digests to human-readable strings.
+	*
+	* The format of these strings will look something like:
+	* `victor-bacon-zulu-lima`. The output is obtained by compressing the input
+	* digest to a fixed number of bytes, then mapping those bytes to one of 256
+	* words. A default wordlist is provided, but you can override this if you
+	* prefer.
+	* As long as you use the same wordlist, the output will be consistent (i.e.
+	* the same digest will always render the same representation).
+	*
+	* @param wordlist A list of exactly 256 words to choose from
+	*/
+	constructor(wordlist = DEFAULT_WORDLIST) {
+		this.wordlist = wordlist;
+		if (wordlist.length !== 256) throw new Error("Wordlist must have exactly 256 items");
+		this.wordlist = wordlist;
+	}
+	/**
+	* Humanize a given hexadecimal digest.
+	*
+	* Change the number of words output by specifying `words`. Change the
+	* word separator with `separator`.
+	*
+	* @param hexdigest A string of hexadecimal characters to humanize
+	* @param words How many words to output (more = safer)
+	* @param separator The string used to seperate the words
+	*/
+	humanize(hexdigest, words = 4, separator = "-") {
+		const pairs = hexdigest.match(/(..?)/g);
+		if (!pairs) throw new Error("");
+		const bytes = pairs.map((x) => parseInt(x, 16));
+		return this._compress(bytes, words).map((x) => this.wordlist[x]).join(separator);
+	}
+	/**
+	* Compress a list of byte values to a fixed target length.
+	*
+	* @param bytes A list of bytes (numbers from 0-254)
+	* @param target The number of bytes to return / compress to
+	*/
+	_compress(bytes, target) {
+		const length = bytes.length;
+		if (target > length) throw new Error("Fewer input bytes than requested output");
+		const segSize = length / target >> 0;
+		const segments = [];
+		for (let i = 0; i < segSize * target; i += segSize) segments.push(bytes.slice(i, i + segSize));
+		segments[segments.length - 1] = segments[segments.length - 1].concat(bytes.slice(target * segSize));
+		return segments.map((x) => x.reduce((acc, curr) => acc ^ curr));
+	}
+};
+var hasher = new HumanHasher();
+var humanize = (value) => {
+	if (value instanceof Buffer || value instanceof Uint8Array || value instanceof ArrayBuffer) value = PublicKey.stringify(value);
+	else if (value instanceof PublicKey) value = value.toHex();
+	return hasher.humanize(value);
+};
+//#endregion
+//#region src/id.ts
+var PART = /^[a-zA-Z][a-zA-Z0-9]{0,62}$/;
+var ID = /^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z]([a-zA-Z0-9]{0,62})?)$/;
+/**
+* Tagged template literal that constructs a well-formed, dot-delimited id string.
+* Throws if the resulting string is not well-formed.
+*
+* Follows the AT Protocol NSID convention (https://atproto.com/specs/nsid)
+* Full NSID: authority segments (hyphens allowed) + dot + name segment (no hyphens).
+* - Authority segments: at most 253 characters (including periods), and must contain at least two segments.
+* - Name segment: starts with alpha, alphanumeric only (no hyphens), max 63 chars.
+*
+* @example
+*   id`org.dxos.plugin.deck` // 'org.dxos.plugin.deck'
+*   id`${ns}.${plugin}.deck` // joins interpolated values
+*/
+function id(strings, ...values) {
+	const raw = strings.reduce((out, str, i) => out + str + (i < values.length ? String(values[i]) : ""), "");
+	if (!ID.test(raw)) throw new Error(`Invalid id (expected AT Protocol NSID): ${JSON.stringify(raw)}`);
+	return raw;
+}
+/**
+* Returns true if the given string is a well-formed NSID.
+*/
+var isWellFormedId = (value) => ID.test(value);
+/**
+* Returns true if the given string is a well-formed NSID name segment:
+* `/^[a-zA-Z][a-zA-Z0-9]{0,62}$/` (starts with alpha, alphanumeric only, no dots or hyphens).
+*/
+var isWellFormedIdPart = (value) => PART.test(value);
+//#endregion
+//#region src/map.ts
+/**
+* Get or set map value.
+*/
+var defaultMap = (map, key, def) => {
+	let value = map.get(key);
+	if (value === void 0) {
+		value = typeof def === "function" ? def() : def;
+		map.set(key, value);
+	}
+	return value;
+};
+//#endregion
+//#region src/instance-id.ts
+var symbol = Symbol.for("dxos.instance-contexts");
+var instanceContexts = globalThis[symbol] ??= /* @__PURE__ */ new WeakMap();
+/**
+* Returns a unique instance id for a given object.
+* Ids are generated as incrementing numbers.
+* Ids are only unique within the scope of a given prototype.
+* Instances of different classes may have the same id.
+*/
+var getPrototypeSpecificInstanceId = (instance) => {
+	const instanceCtx = defaultMap(instanceContexts, Object.getPrototypeOf(instance), () => ({
+		nextId: 0,
+		instanceIds: /* @__PURE__ */ new WeakMap()
+	}));
+	let id = instanceCtx.instanceIds.get(instance);
+	if (id === void 0) {
+		id = instanceCtx.nextId++;
+		instanceCtx.instanceIds.set(instance, id);
+	}
+	return id;
+};
+var getDebugName = (instance) => {
+	if (instance == null) return "null";
+	return `${Object.getPrototypeOf(instance).constructor?.name ?? "Object"}#${getPrototypeSpecificInstanceId(instance)}`;
+};
+//#endregion
+//#region src/interval.ts
+/**
+* Runs the callback in an exponentially increasing interval.
+* @returns Callback to clear the interval.
+*/
+var exponentialBackoffInterval = (cb, initialInterval) => {
+	let interval = initialInterval;
+	const repeat = () => {
+		cb();
+		interval *= 2;
+		timeoutId = setTimeout(repeat, interval);
+	};
+	let timeoutId = setTimeout(repeat, interval);
+	return () => clearTimeout(timeoutId);
+};
+//#endregion
+//#region src/join-tables.ts
+/**
+* Joins two untyped tables on the given columns.
+* @param leftColumn The column to join on in the first table.
+* @param rightColumn The column to join on in the second table.
+*/
+var joinTables = (leftColumn, rightColumn, left, right) => {
+	const map = /* @__PURE__ */ new Map();
+	const used = /* @__PURE__ */ new Set();
+	for (const row of right) map.set(row[rightColumn], row);
+	const result = [];
+	for (const row of left) {
+		const right = map.get(row[leftColumn]);
+		used.add(right);
+		result.push(Object.assign(right ?? {}, row));
+	}
+	for (const row of right) if (!used.has(row)) result.push(row);
+	return result;
+};
+//#endregion
+//#region src/uint8array.ts
+var arraysEqual = (a, b) => {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+};
+/**
+* Non-copying conversion of Uint8Array to Buffer.
+* The resulting buffer will share the same allocated memory as the Uint8Array.
+*/
+var arrayToBuffer = (array) => {
+	return Buffer.from(array.buffer, array.byteOffset, array.byteLength);
+};
+/**
+* Non-copying conversion of Buffer to Uint8Array.
+* The resulting Uint8Array will share the same allocated memory as the Buffer.
+*/
+var bufferToArray = (buffer) => {
+	return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+};
+var stringToArray = (string) => bufferToArray(Buffer.from(string, "hex"));
+var arrayToString = (array) => arrayToBuffer(array).toString("hex");
+var toUnpaddedBase64 = (bytes) => arrayToBuffer(bytes).toString("base64").replace(/=+$/, "");
+/**
+* Encode a `Uint8Array` as the DAG-JSON bytes form `{ '/': { bytes: '<base64-no-padding>' } }`.
+*/
+var encodeUint8ArrayToJson = (bytes) => ({ "/": { bytes: toUnpaddedBase64(bytes) } });
+/**
+* Type-guard that returns true iff `value` is the DAG-JSON bytes form produced by
+* {@link encodeUint8ArrayToJson} — an object with exactly one key `'/'` whose value is an
+* object with exactly one string key `bytes`.
+*/
+var isEncodedUint8Array = (value) => {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	if (Object.keys(value).length !== 1) return false;
+	const inner = value["/"];
+	if (typeof inner !== "object" || inner === null || Array.isArray(inner)) return false;
+	return Object.keys(inner).length === 1 && typeof inner.bytes === "string";
+};
+/**
+* Decode a DAG-JSON bytes form (as produced by {@link encodeUint8ArrayToJson}) back to a
+* `Uint8Array`. The base64 string is tolerated with or without padding.
+*/
+var decodeUint8ArrayFromJson = (encoded) => bufferToArray(Buffer.from(encoded["/"].bytes, "base64"));
+//#endregion
+//#region src/json.ts
+var MAX_DEPTH = 5;
+var LOG_MAX_DEPTH = 7;
+/**
+* JSON.stringify replacer.
+*/
+var jsonReplacer = (key, value) => {
+	if (value !== null && typeof value === "object" && typeof value[inspect.custom] === "function") return value[inspect.custom]();
+	if (value !== null && typeof value === "object" && value.type === "Buffer" && Array.isArray(value.data)) if (value.data.length === 32) {
+		const key = Buffer.from(value.data);
+		return `[${humanize(key)}]:[${PublicKey.stringify(key)}]`;
+	} else return Buffer.from(value.data).toString("hex");
+	return value;
+};
+/**
+* Recursively converts an object into a JSON-compatible object.
+*/
+var jsonify = (value, depth = 0, visitedObjects = /* @__PURE__ */ new WeakSet()) => {
+	if (depth > MAX_DEPTH) return null;
+	else if (typeof value === "function") return null;
+	else if (typeof value === "object" && value !== null) {
+		if (visitedObjects.has(value)) return null;
+		visitedObjects.add(value);
+		try {
+			if (value instanceof Uint8Array) return arrayToBuffer(value).toString("hex");
+			else if (Array.isArray(value)) return value.map((x) => jsonify(x, depth + 1, visitedObjects));
+			else if (typeof value.toJSON === "function") return value.toJSON();
+			else {
+				const res = {};
+				for (const key of Object.keys(value)) res[key] = jsonify(value[key], depth + 1, visitedObjects);
+				return res;
+			}
+		} finally {
+			visitedObjects.delete(value);
+		}
+	} else return value;
+};
+/**
+* Recursively converts an object into a JSON-compatible object appropriate for logging.
+*/
+var jsonlogify = (value, depth = 0, visitedObjects = /* @__PURE__ */ new WeakSet()) => {
+	if (depth > LOG_MAX_DEPTH) return null;
+	else if (typeof value === "function") return null;
+	else if (typeof value === "object" && value !== null) {
+		if (visitedObjects.has(value)) return null;
+		visitedObjects.add(value);
+		try {
+			if (value instanceof Uint8Array) return arrayToBuffer(value).toString("hex");
+			else if (Array.isArray(value)) return value.map((x) => jsonlogify(x, depth + 1, visitedObjects));
+			else if (typeof value.toJSONL === "function") return value.toJSONL();
+			else if (typeof value.toJSON === "function") return value.toJSON();
+			else {
+				const res = {};
+				for (const key of Object.keys(value)) res[key] = jsonlogify(value[key], depth + 1, visitedObjects);
+				return res;
+			}
+		} finally {
+			visitedObjects.delete(value);
+		}
+	} else return value;
+};
+var jsonKeyReplacer = (options = {}) => (key, value) => {
+	if (typeof value === "string") {
+		const key = PublicKey.fromHex(value);
+		if (key.toHex() === value) return options.humanize ? humanize(key) : options.truncate ? key.truncate() : key.toHex();
+	}
+	return value;
+};
+//#endregion
+//#region src/map-values.ts
+var mapValues = (obj, fn) => {
+	const result = {};
+	Object.keys(obj).forEach((key) => {
+		result[key] = fn(obj[key], key);
+	});
+	return result;
+};
+/**
+* Recursively maps values traversing arrays and objects.
+* @param fn Function to apply to each value. Second argument is a function to recurse into the value.
+*/
+var deepMapValues = (value, fn) => {
+	return new DeepMapper(fn).map(value);
+};
+var DeepMapper = class {
+	_fn;
+	_cyclic = /* @__PURE__ */ new Map();
+	constructor(_fn) {
+		this._fn = _fn;
+	}
+	map(value) {
+		return this._map(value, void 0);
+	}
+	_map(value, key) {
+		if (this._cyclic.has(value)) return this._cyclic.get(value);
+		return this._fn(value, this._recurse, key);
+	}
+	_recurse = (value) => {
+		if (this._cyclic.has(value)) return this._cyclic.get(value);
+		if (Array.isArray(value)) {
+			const res = new Array(value.length);
+			this._cyclic.set(value, res);
+			for (let i = 0; i < value.length; i++) res[i] = this._map(value[i], i);
+			return res;
+		} else if (ArrayBuffer.isView(value)) return value;
+		else if (value !== null && typeof value === "object") {
+			const res = {};
+			this._cyclic.set(value, res);
+			for (const key in value) res[key] = this._map(value[key], key);
+			return res;
+		} else return value;
+	};
+};
+/**
+* Recursively maps values traversing arrays and objects.
+* @param fn Function to apply to each value. Second argument is a function to recurse into the value.
+* Async version.
+*/
+var deepMapValuesAsync = (value, fn) => {
+	return new DeepMapperAsync(fn).map(value);
+};
+var DeepMapperAsync = class {
+	_fn;
+	_cyclic = /* @__PURE__ */ new Map();
+	constructor(_fn) {
+		this._fn = _fn;
+	}
+	map(value) {
+		return this._map(value, void 0);
+	}
+	_map(value, key) {
+		if (this._cyclic.has(value)) return this._cyclic.get(value);
+		return this._fn(value, this._recurse, key);
+	}
+	_recurse = async (value) => {
+		if (this._cyclic.has(value)) return this._cyclic.get(value);
+		if (Array.isArray(value)) {
+			const res = new Array(value.length);
+			this._cyclic.set(value, res);
+			for (let i = 0; i < value.length; i++) res[i] = await this._map(value[i], i);
+			return res;
+		} else if (ArrayBuffer.isView(value)) return value;
+		else if (value !== null && typeof value === "object") {
+			const res = {};
+			this._cyclic.set(value, res);
+			for (const key in value) res[key] = await this._map(value[key], key);
+			return res;
+		} else return value;
+	};
+};
+/**
+* Visits all values on an object or every item in an array.
+* No-op if the value is not an object or array.
+*/
+var visitValues = (object, visitor) => {
+	if (Array.isArray(object)) object.forEach((item, index) => visitor(item, index));
+	else if (typeof object === "object" && object !== null) for (const [key, value] of Object.entries(object)) visitor(value, key);
+};
+//#endregion
+//#region src/object.ts
+/**
+* @deprecated Use `Struct.keys` from effect.
+*/
+var keys = (obj) => Object.keys(obj);
+var entries = (obj) => Object.entries(obj);
+//#endregion
+//#region src/order-keys.ts
+var orderKeys = (obj, order) => {
+	const ordered = {};
+	for (const key of order) if (key in obj) ordered[key] = obj[key];
+	for (const key in obj) if (!(key in ordered)) ordered[key] = obj[key];
+	return ordered;
+};
+//#endregion
+//#region src/order.ts
+/**
+* Uses an array of string id’s to order a map of objects, returning an array of those objects. Objects not listed by
+* the array of id’s occur later in the resulting array of objects based on the map’s key order.
+* @param objectMap
+* @param order
+*/
+var inferObjectOrder = (objectMap, order = []) => {
+	const orderedObjects = order.reduce((acc, id) => {
+		if (id in objectMap) {
+			acc.objects.push(objectMap[id]);
+			acc.ids.add(id);
+		}
+		return acc;
+	}, {
+		objects: [],
+		ids: /* @__PURE__ */ new Set()
+	});
+	const { objects } = Object.keys(objectMap).reduce((acc, id) => {
+		if (!acc.ids.has(id)) acc.objects.push(objectMap[id]);
+		return acc;
+	}, orderedObjects);
+	return objects;
+};
+/**
+* Uses an array of string id’s to order a map of objects, returning a new map with the keys in the prescribed order.
+* Objects not listed by the array of id’s occur later in the resulting array of objects based on the map’s key order.
+* @param objectMap
+* @param order
+*/
+var inferRecordOrder = (objectMap, order = []) => {
+	return Object.assign(order.filter((id) => id in objectMap).reduce((acc, id) => {
+		acc[id] = null;
+		return acc;
+	}, {}), objectMap);
+};
+//#endregion
+//#region src/pick.ts
+/**
+* Creates an object composed of the object properties predicate returns truthy for.
+*/
+var pick = (obj, keys) => {
+	return keys.reduce((result, key) => {
+		if (obj && key in obj) result[key] = obj[key];
+		return result;
+	}, {});
+};
+/**
+* Creates an object composed of the object properties predicate returns truthy for.
+*/
+var pickBy = (obj, predicate) => {
+	const result = {};
+	for (const key in obj) if (predicate(obj[key])) result[key] = obj[key];
+	return result;
+};
+/**
+* Omit given props.
+* @param obj
+* @param keys
+*/
+var omit = (obj, keys) => {
+	const result = { ...obj };
+	keys.forEach((key) => {
+		delete result[key];
+	});
+	return result;
+};
+//#endregion
+//#region src/platform.ts
+var isNode = () => typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var isBun = () => globalThis.Bun !== void 0;
+var isTauri = () => !!globalThis.__TAURI__;
+var isMobile = () => {
+	let check = false;
+	(function(a) {
+		if (/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i.test(a) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(a.substr(0, 4))) check = true;
+	})(navigator.userAgent || navigator.vendor || window.opera);
+	return check;
+};
+var isMobileOrTablet = () => {
+	let check = false;
+	((a) => {
+		if (/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ipad|playbook|silk/i.test(a) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(a.substr(0, 4))) check = true;
+	})(navigator.userAgent || navigator.vendor || window.opera);
+	return check;
+};
+var iosCheck = () => {
+	return [
+		"iPad Simulator",
+		"iPhone Simulator",
+		"iPod Simulator",
+		"iPad",
+		"iPhone",
+		"iPod"
+	].includes(navigator.platform) || navigator.userAgent.includes("Mac") && "ontouchend" in document;
+};
+var safariCheck = () => typeof navigator !== "undefined" && /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+/**
+* Retrieve the host platform in a best-effort way with normalized output.
+*/
+var getHostPlatform = () => {
+	if (!("navigator" in globalThis)) return "unknown";
+	const platform = (navigator.userAgentData?.platform || navigator.platform)?.toLowerCase();
+	if (platform.startsWith("win")) return "windows";
+	else if (platform.startsWith("mac")) return "macos";
+	else if (platform.startsWith("ipad") || platform.startsWith("iphone") || platform.startsWith("ipod")) return "ios";
+	else if (platform.startsWith("linux")) return "linux";
+	else return "unknown";
+};
+//#endregion
+//#region src/Position.ts
+var Position_exports = /* @__PURE__ */ __exportAll({
+	compare: () => compare,
+	first: () => first,
+	last: () => last
+});
+var first = -Infinity;
+var last = Infinity;
+/**
+* Comparator for sorting by position.
+*/
+var compare = ({ position: a }, { position: b }) => {
+	const aVal = a ?? 0;
+	const bVal = b ?? 0;
+	if (aVal === bVal) return 0;
+	return aVal < bVal ? -1 : 1;
+};
+//#endregion
+//#region src/random.ts
+var randomInt = (max, min = 0) => {
+	min = Math.ceil(min);
+	max = Math.floor(max);
+	return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+//#endregion
+//#region src/range.ts
+var range = (n = 0, mapper) => {
+	const range = Array.from(Array(n).keys());
+	return mapper == null ? range : range.map(mapper);
+};
+var rangeFromTo = (from, to, mapper) => {
+	return mapper == null ? range(to - from, (i) => i + from) : range(to - from, (i) => mapper(i + from));
+};
+/**
+* Clamps a value between a minimum and maximum value.
+*/
+var clamp = (value, min, max) => {
+	return Math.min(Math.max(value, min), max);
+};
+//#endregion
+//#region src/reducers.ts
+var accessBy = (value, accessor) => typeof accessor === "function" ? accessor(value) : value[accessor];
+var median = (values) => {
+	const mid = Math.floor(values.length / 2);
+	if (values.length % 2 === 1) return values[mid];
+	else return (values[mid - 1] + values[mid]) / 2;
+};
+/**
+* Returns an array of unique values.
+*/
+var numericalValues = (values, accessor) => {
+	const result = {
+		total: 0,
+		count: 0
+	};
+	const sorted = values.map((value) => {
+		const v = accessBy(value, accessor);
+		if (v === void 0 || isNaN(v)) return;
+		result.total += v;
+		if (result.min === void 0 || v < result.min) result.min = v;
+		if (result.max === void 0 || v > result.max) result.max = v;
+		return v;
+	}).filter((value) => value !== void 0).sort((a, b) => a - b);
+	if (sorted.length) Object.assign(result, {
+		count: sorted.length,
+		mean: result.total / sorted.length,
+		median: median(sorted)
+	});
+	return result;
+};
+/**
+* Returns an array of unique values.
+*/
+var reduceSet = (values, accessor) => {
+	return values.reduce((values, value) => {
+		const v = accessBy(value, accessor);
+		values.add(v);
+		return values;
+	}, /* @__PURE__ */ new Set());
+};
+/**
+* Returns an object containing values grouped by the given key accessor.
+*/
+var reduceGroupBy = (values, accessor) => {
+	return values.reduce((values, value) => {
+		defaultMap(values, accessBy(value, accessor), []).push(value);
+		return values;
+	}, /* @__PURE__ */ new Map());
+};
+/**
+* Applies the reducer to the array of values.
+*/
+var reduceSeries = (reducer, events) => {
+	const state = reducer.initialState();
+	for (const event of events) reducer.reduce(state, event);
+	return state;
+};
+/**
+* Reducer to group values.
+*/
+var createGroupReducer = (groupBy, sub) => ({
+	initialState: () => ({}),
+	reduce: (state, event) => {
+		const key = groupBy(event);
+		state[key] = sub.reduce(state[key] ?? sub.initialState(), event);
+		return state;
+	}
+});
+var getDate = (value) => value instanceof Date ? value : new Date(value);
+/**
+* Reducer to group by time period.
+*/
+var createBucketReducer = (period) => ({
+	initialState: () => [],
+	reduce: (series, event) => {
+		const timestamp = getDate(event.timestamp);
+		let bucket = series[series.length - 1];
+		if (!bucket || bucket.start + period < timestamp.getTime()) {
+			bucket = {
+				start: timestamp.getTime(),
+				period,
+				count: 0
+			};
+			series.push(bucket);
+		}
+		bucket.count++;
+		return series;
+	}
+});
+//#endregion
+//#region src/remove-undefined-keys.ts
+var removeUndefinedProperties = (object) => {
+	for (const prop of [...Object.getOwnPropertyNames(object), ...Object.getOwnPropertySymbols(object)]) if (object[prop] === void 0) delete object[prop];
+	return object;
+};
+/**
+* Recursively remove properties from the object, returning the modified object.
+*/
+var removeProperties = (root, condition) => {
+	if (!root || typeof root !== "object") return root;
+	if (Array.isArray(root)) return root.map((item) => removeProperties(item, condition));
+	const result = { ...root };
+	if (typeof condition === "function") {
+		for (const [key, value] of Object.entries(result)) if (condition(key, value)) delete result[key];
+	} else for (const key of condition) delete result[key];
+	for (const [key, value] of Object.entries(result)) if (typeof value === "object") result[key] = removeProperties(value, condition);
+	return result;
+};
+//#endregion
+//#region src/retry.ts
+var DEFAULT_RETRY_OPTIONS = {
+	count: 3,
+	delayMs: 100,
+	exponent: 2,
+	retryOnError: async () => true,
+	retryOnValue: async () => false
+};
+/**
+* Retries the operation a number of times.
+* @returns The result of the succesfull invocation
+* @throws Last error if all retries failed
+*/
+var retry = async (options, cb) => {
+	const fullOptions = {
+		...DEFAULT_RETRY_OPTIONS,
+		...options
+	};
+	let numRetries = 0, currentDelay = fullOptions.delayMs;
+	while (true) {
+		let result;
+		try {
+			result = await cb();
+		} catch (err) {
+			if (numRetries > fullOptions.count || !await fullOptions.retryOnError(err)) throw err;
+			await new Promise((resolve) => setTimeout(resolve, currentDelay));
+			currentDelay *= fullOptions.exponent;
+			numRetries++;
+			continue;
+		}
+		if (!await fullOptions.retryOnValue(result)) return result;
+		await new Promise((resolve) => setTimeout(resolve, currentDelay));
+		currentDelay *= fullOptions.exponent;
+		numRetries++;
+		continue;
+	}
+};
+//#endregion
+//#region src/safe-await.ts
+/**
+* A utility for safely performing an asynchronous action on every item from source.
+* @param source elements passed to taskFactory.
+* @param taskFactory a function that converts an elements into an async task.
+* @param onError if provided will be called for every failed task.
+* @returns elements for which task execution failed.
+*/
+var safeAwaitAll = async (source, taskFactory, onError) => {
+	const failedItems = [];
+	await Promise.all([...source].map(async (item, idx) => {
+		try {
+			await taskFactory(item);
+		} catch (err) {
+			if (onError) onError(err, item, idx);
+			failedItems.push(item);
+		}
+	}));
+	return failedItems;
+};
+//#endregion
+//#region src/safe-instanceof.ts
+var instanceTag = Symbol("instanceTag");
+/**
+* Makes instanceof work correctly even if the class definition was duplicated (e.g. when bundling).
+* The comparison is done by comparing the tag passed to this function.
+*
+* Example:
+*
+* ```typescript
+* @safeInstanceof('Tagged')
+* class Tagged {}
+* ```
+*/
+var safeInstanceof = (tag) => (target) => {
+	target.prototype[instanceTag] = tag;
+	Object.defineProperty(target.prototype, Symbol.hasInstance, { value: (instance) => instance?.[instanceTag] === tag });
+	Object.defineProperty(target, Symbol.hasInstance, { value: (instance) => instance?.[instanceTag] === tag });
+};
+//#endregion
+//#region src/safe-parse.ts
+function safeParseInt(str, defaultValue) {
+	try {
+		const value = parseInt(str ?? "");
+		return isNaN(value) ? defaultValue : value;
+	} catch {
+		return defaultValue;
+	}
+}
+function safeParseFloat(str, defaultValue) {
+	try {
+		const value = parseFloat(str ?? "");
+		return isNaN(value) ? defaultValue : value;
+	} catch {
+		return defaultValue;
+	}
+}
+var safeParseJson = (str, defaultValue) => {
+	if (str && str.length > 0) try {
+		return JSON.parse(str);
+	} catch {}
+	return defaultValue;
+};
+var safeUrl = (str) => {
+	try {
+		return new URL(str ?? "");
+	} catch {
+		return;
+	}
+};
+//#endregion
+//#region src/safe-stringify.ts
+var SKIP = Object.freeze({});
+/**
+* Safely stringifies an object.
+*/
+function safeStringify(obj, filter = defaultFilter, indent = 2) {
+	const seen = /* @__PURE__ */ new WeakMap();
+	function replacer(key, value) {
+		try {
+			let path = key;
+			if (!key) {
+				path = "$";
+				if (value != null && typeof value === "object") seen.set(value, path);
+				return value;
+			} else if (this) {
+				const parentPath = seen.get(this);
+				path = parentPath ? `${parentPath}.${key}` : key;
+			}
+			if (value == null) return value;
+			if (typeof value === "function") return;
+			if (typeof value === "object" && Object.getPrototypeOf(value) !== Object.prototype && !Array.isArray(value)) return;
+			if (typeof value === "object" && value !== null) {
+				const exists = seen.get(value);
+				if (exists) return `[${path} => ${exists}]`;
+				seen.set(value, path);
+			}
+			if (filter) {
+				const filteredValue = filter?.(key, value);
+				if (filteredValue !== void 0) return filteredValue === SKIP ? void 0 : filteredValue;
+			}
+			return value;
+		} catch (error) {
+			return `ERROR: ${error.message}`;
+		}
+	}
+	try {
+		return JSON.stringify(obj, replacer, indent);
+	} catch (error) {
+		return `ERROR: ${error.message}`;
+	}
+}
+/**
+* Construct JSON.stringify replacer.
+*/
+var createReplacer = ({ omit, parse, maxDepth, maxArrayLen, maxStringLen } = {}) => {
+	let currentDepth = 0;
+	const depthMap = /* @__PURE__ */ new WeakMap();
+	return function(key, value) {
+		if (key === "") currentDepth = 0;
+		else if (this && typeof this === "object") currentDepth = (depthMap.get(this) ?? 0) + 1;
+		if (typeof value === "function") return SKIP;
+		if (maxArrayLen != null && Array.isArray(value) && value.length > maxArrayLen) return `[length: ${value.length}]`;
+		if (value && typeof value === "object") {
+			depthMap.set(value, currentDepth);
+			if (maxDepth != null && currentDepth >= maxDepth) return Array.isArray(value) ? `[{ length: ${value.length} }]` : `{ keys: ${Object.keys(value).length} }`;
+		}
+		if (omit?.includes(key)) return SKIP;
+		if (parse?.includes(key) && typeof value === "string") try {
+			return JSON.parse(value);
+		} catch {
+			return value;
+		}
+		if (maxStringLen != null && typeof value === "string" && value.length > maxStringLen) return value.slice(0, maxStringLen) + "...";
+		return value;
+	};
+};
+var defaultFilter = createReplacer();
+//#endregion
+//#region src/sliding-window-summary.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/common/util/src/sliding-window-summary.ts";
+var SlidingWindowSummary = class {
+	_buffer;
+	_sum = 0;
+	_precision;
+	constructor(options) {
+		this._buffer = new CircularBuffer(options.dataPoints);
+		if (options.precision != null) {
+			invariant(options.precision >= 0, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 26,
+				S: this,
+				A: ["options.precision >= 0", ""]
+			});
+			this._precision = Math.pow(10, options.precision);
+		}
+	}
+	record(value) {
+		const evicted = this._buffer.push(value);
+		this._sum += value - (evicted ?? 0);
+	}
+	average() {
+		return this._buffer.elementCount === 0 ? 0 : this._withPrecision(this._sum / this._buffer.elementCount);
+	}
+	computeWindowSummary() {
+		const mean = this.average();
+		const sortedElements = [...this._buffer].sort();
+		const median = this._withPrecision(sortedElements.length % 2 === 0 ? (sortedElements[sortedElements.length / 2] + sortedElements[sortedElements.length / 2 - 1]) / 2 : sortedElements[sortedElements.length / 2]);
+		const p90 = this._withPrecision(sortedElements[Math.round(sortedElements.length * .9)]);
+		const variance = sortedElements.reduce((acc, v) => acc + Math.pow(v - mean, 2)) / sortedElements.length;
+		return {
+			mean,
+			median,
+			p90,
+			stdDev: this._withPrecision(Math.sqrt(variance)),
+			histogram: sortedElements.reduce((acc, v) => {
+				acc[v] += 1;
+				return acc;
+			}, {})
+		};
+	}
+	_withPrecision(value) {
+		if (this._precision == null) return value;
+		return Math.round(value * this._precision) / this._precision;
+	}
+};
+//#endregion
+//#region src/sort.ts
+var compareScalar = (inc = true) => (a, b) => (inc ? 1 : -1) * (a < b ? -1 : a > b ? 1 : 0);
+var compareString = (inc = true, caseInsensitive = true) => (a, b) => {
+	if (caseInsensitive) {
+		a = a?.toLowerCase();
+		b = b?.toLowerCase();
+	}
+	return (inc ? 1 : -1) * (a < b ? -1 : a > b ? 1 : 0);
+};
+var compareObject = (prop, sorter, inc = true) => (a, b) => (inc ? 1 : -1) * sorter(a[prop], b[prop]);
+var compareMulti = (sorters) => (a, b) => {
+	const sort = (i = 0) => {
+		const s = sorters[i](a, b);
+		if (s === 0 && i < sorters.length - 1) return sort(i + 1);
+		else return s;
+	};
+	return sort();
+};
+//#endregion
+//#region src/string.ts
+/**
+* Capitalizes the first letter of a string.
+*/
+var capitalize = (str) => {
+	if (str.length === 0) return "";
+	return str.charAt(0).toUpperCase() + str.slice(1);
+};
+/**
+* Collapse a multi-line tagged template literal to a single space-separated string.
+* Useful for statically concatenating long lists of class names across multiple lines:
+*
+* ```ts
+* const cls = inline`
+*   rounded-xs outline-none
+*   data-[focused]:bg-accent-bg
+* `;
+* ```
+*/
+function inline(strings, ...values) {
+	return strings.reduce((out, str, i) => out + str + (i < values.length ? String(values[i]) : ""), "").replace(/\s+/g, " ").trim();
+}
+/**
+* Remove leading space from multi-line strings.
+*/
+function trim(strings, ...values) {
+	const lines = strings.reduce((out, str, i) => {
+		out += str;
+		if (i < values.length) {
+			const match = str.match(/(^|\n)([ \t]*)$/);
+			const baseIndent = match ? match[2] : "";
+			const val = String(values[i]).replace(/\r?\n/g, "\n" + baseIndent);
+			out += val;
+		}
+		return out;
+	}, "").split("\n");
+	while (lines.length && !lines[0].trim()) lines.shift();
+	while (lines.length && !lines[lines.length - 1].trim()) lines.pop();
+	const minIndent = Math.min(...lines.filter((l) => l.trim()).map((l) => l.match(/^[ \t]*/)?.[0].length ?? 0));
+	return lines.map((l) => l.slice(minIndent)).join("\n");
+}
+/**
+* Converts a string to kebab case.
+*/
+var kebabize = (str) => str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, ($, ofs) => (ofs ? "-" : "") + $.toLowerCase());
+//#endregion
+//#region src/sum.ts
+var sum = (values) => values.reduce((a, b) => a + b, 0);
+//#endregion
+//#region src/throw-unhandled-error.ts
+/**
+* Throws an unhandled error for the runtime to catch.
+* Does not cause stack unwinding.
+* Error will be thrown in the next microtask.
+*/
+var throwUnhandledError = (error) => {
+	queueMicrotask(() => {
+		throw error;
+	});
+};
+//#endregion
+//#region src/to-fallback.ts
+/**
+* When changing this set, please check the result in a console or e.g. RunKit (https://runkit.com/thure/642214441dd6ae000855a8de)
+* Emoji sometimes use a combination of code points, and some code points aren't visible on their own, so by adding or deleting you may unintentionally create non-visible items.
+* This set was chosen from the characters in Unicode Emoji v15.0 based on the following criteria:
+* – not people or isolated anthropomorphic faces
+* – not flags
+* – more concrete than abstract
+* – less culturally specific
+* – less easily confused with another emoji in the set
+* – requires less special knowledge to identify
+* – less likely to evoke negative feelings (no meat, no drugs, no weapons, etc)
+* – less common as a signifier in UX
+* NOTE that this is intentionally an array of strings because of the way emoji graphemes work.
+*/
+var idEmoji = [
+	"👻",
+	"👹",
+	"👽",
+	"🤖",
+	"🎃",
+	"🦾",
+	"🦿",
+	"🦷",
+	"👣",
+	"👁️",
+	"🧶",
+	"👑",
+	"🐒",
+	"🦆",
+	"🦉",
+	"🐴",
+	"🦄",
+	"🐝",
+	"🦋",
+	"🐞",
+	"🪲",
+	"🐢",
+	"🦎",
+	"🦕",
+	"🦑",
+	"🦀",
+	"🐠",
+	"🐬",
+	"🐋",
+	"🦭",
+	"🐅",
+	"🐆",
+	"🦓",
+	"🦍",
+	"🦧",
+	"🐘",
+	"🐫",
+	"🦒",
+	"🦘",
+	"🦬",
+	"🐖",
+	"🐏",
+	"🦌",
+	"🐕",
+	"🐈",
+	"🐓",
+	"🦚",
+	"🦜",
+	"🦢",
+	"🦩",
+	"🦦",
+	"🐁",
+	"🐿️",
+	"🌵",
+	"🌲",
+	"🌳",
+	"🪵",
+	"🌱",
+	"🍁",
+	"🪺",
+	"🍄",
+	"🐚",
+	"🪸",
+	"🪨",
+	"🌾",
+	"🌷",
+	"🌻",
+	"☀️",
+	"🌙",
+	"🪐",
+	"⭐️",
+	"⚡️",
+	"☄️",
+	"🔥",
+	"🌈",
+	"☁️",
+	"💧",
+	"⛱️",
+	"🌊",
+	"🍎",
+	"🍋",
+	"🍉",
+	"🍇",
+	"🫐",
+	"🍈",
+	"🍒",
+	"🍑",
+	"🥭",
+	"🍍",
+	"🥥",
+	"🥝",
+	"🥑",
+	"🌶️",
+	"🌽",
+	"🥕",
+	"🍬",
+	"🥜",
+	"🫖",
+	"☕️",
+	"🍵",
+	"🧊",
+	"🧂",
+	"🏔️",
+	"⚓️",
+	"🛟",
+	"🏝️",
+	"🛶",
+	"🚀",
+	"🛰️",
+	"⛲️",
+	"🏰",
+	"🚲",
+	"⛺️",
+	"🎙️",
+	"🧲",
+	"⚙️",
+	"🔩",
+	"🔮",
+	"🔭",
+	"🔬",
+	"🧬",
+	"🌡️",
+	"🧺",
+	"🛎️",
+	"🔑",
+	"🪑",
+	"🧸",
+	"🎈",
+	"🎀",
+	"🎊",
+	"♻️",
+	"🎵"
+];
+var idHue = [
+	"red",
+	"orange",
+	"amber",
+	"yellow",
+	"lime",
+	"green",
+	"emerald",
+	"teal",
+	"cyan",
+	"violet",
+	"purple",
+	"fuchsia",
+	"pink",
+	"rose"
+];
+/** FNV-1a hash of an arbitrary string, as an unsigned 32-bit integer. */
+var fnv1a = (id) => {
+	let hash = 2166136261;
+	for (let index = 0; index < id.length; index++) {
+		hash ^= id.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return Math.abs(hash);
+};
+/**
+* Deterministic palette hue for an arbitrary id string that isn't hex-parseable (e.g. an identity
+* DID). Seeds the shared {@link idHue} palette via FNV-1a so the same id always maps to the same hue,
+* matching the colouring used for avatars/tags elsewhere. Prefer {@link hexToHue} when a hex
+* identity key is available (it aligns with the awareness-cursor palette).
+*/
+var stringToHue = (id) => idHue[fnv1a(id) % idHue.length];
+/**
+* Deterministic avatar fallback (emoji + hue) for an arbitrary id string (e.g. an identity DID).
+* Shares {@link stringToHue}'s FNV-1a seed, so `stringToFallback(id).hue === stringToHue(id)` — an
+* avatar seeded from an id and a tag coloured by {@link stringToHue} for the same id agree.
+*/
+var stringToFallback = (id) => {
+	const hash = fnv1a(id);
+	return {
+		emoji: idEmoji[Math.floor(hash / idHue.length) % idEmoji.length],
+		hue: idHue[hash % idHue.length]
+	};
+};
+var keyToEmoji = (key) => keyToFallback(key).emoji;
+var hexToEmoji = (hex) => hexToFallback(hex).emoji;
+var toEmoji = (hash) => toFallback(hash).emoji;
+var keyToHue = (key) => keyToFallback(key).hue;
+var hexToHue = (hex) => hexToFallback(hex).hue;
+var toHue = (hash) => toFallback(hash).hue;
+var keyToFallback = (key) => hexToFallback(key.toHex());
+var hexToFallback = (hex) => toFallback(parseInt(hex, 16));
+var toFallback = (hash) => {
+	const combinationIndex = hash % (idEmoji.length * idHue.length);
+	const emojiIndex = Math.floor(combinationIndex / idHue.length);
+	const hueIndex = combinationIndex % idHue.length;
+	return {
+		emoji: idEmoji[emojiIndex],
+		hue: idHue[hueIndex]
+	};
+};
+//#endregion
+//#region src/tracer.ts
+/**
+* Event sink.
+*/
+var Tracer = class {
+	_events = /* @__PURE__ */ new Map();
+	_recording = false;
+	get recording() {
+		return this._recording;
+	}
+	keys() {
+		return Array.from(this._events.keys());
+	}
+	get(id, filter) {
+		const events = this._events.get(id);
+		if (filter) return events?.filter((event) => Object.entries(filter).every(([key, value]) => event?.value[key] === value));
+		return events;
+	}
+	clear() {
+		this._events.clear();
+	}
+	start() {
+		this._recording = true;
+		return this;
+	}
+	stop() {
+		this._recording = false;
+		return this;
+	}
+	emit(id, value) {
+		this._post(this._createEvent(id, value));
+	}
+	mark(id, value) {
+		const event = this._createEvent(id, value);
+		const start = performance.now();
+		return {
+			start,
+			end: () => {
+				event.duration = performance.now() - start;
+				this._post(event);
+			}
+		};
+	}
+	_createEvent(id, value) {
+		const event = {
+			id,
+			timestamp: Date.now()
+		};
+		if (value !== void 0) event.value = value;
+		return event;
+	}
+	_post(event) {
+		if (this._recording) defaultMap(this._events, event.id, []).push(event);
+	}
+};
+var tracer = new Tracer();
+//#endregion
+//#region src/tree.ts
+/**
+* Create tree using depth first traversal.
+* https://waylonwalker.com/drawing-ascii-boxes/#connectors
+*/
+var stringifyTree = (node, ancestors = [], rows = []) => {
+	if (node.children?.length) node.children.forEach((child, i) => {
+		stringifyTree(child, [...ancestors, [node, i]], rows);
+	});
+	else {
+		const keyLen = 8;
+		const name = (node) => truncateKey(node.id, keyLen);
+		const parts = [];
+		ancestors.forEach(([node, i], j) => {
+			const first = ancestors.slice(j).every(([_, i]) => i === 0);
+			parts.push(j === 0 ? first ? "├" : " " : "");
+			parts.push(first ? `─(${name(node)})─` : "".padEnd(12));
+			if (node.children) if (first) parts.push(node.children.length > 1 ? "┬" : "─");
+			else {
+				const childFirst = ancestors.slice(j + 1).every(([_, i]) => i === 0);
+				if (node.children.length - 1 === i) parts.push(childFirst ? "╰" : " ");
+				else parts.push(childFirst ? "├" : "│");
+			}
+		});
+		parts.push(`─(${name(node)})`);
+		rows.push(parts.join(""));
+	}
+	return rows;
+};
+//#endregion
+//#region src/types.ts
+/**
+* Use with filter chaining instead of filter(Boolean) to preserve type.
+* NOTE: To filter by type:
+* items.filter((item: any): item is RangeSet<Decoration> => item instanceof RangeSet)
+*/
+var isTruthy = (value) => !!value;
+var isNonNullable = (value) => value != null;
+var doAsync = async (fn) => fn();
+/**
+* Get value from a provider.
+*/
+var getProviderValue = (provider, arg) => {
+	return typeof provider === "function" ? provider(arg) : provider;
+};
+/**
+* Get value from a provider, which may be async.
+*/
+var getAsyncProviderValue = (provider, arg) => {
+	return getProviderValue(provider, arg);
+};
+/**
+* Remove keys with undefined values.
+*/
+var stripUndefined = (obj) => {
+	if (typeof obj === "object") Object.keys(obj).forEach((key) => {
+		const value = obj[key];
+		if (value === void 0) delete obj[key];
+		else if (value !== null && typeof value === "object") stripUndefined(value);
+	});
+	return obj;
+};
+/**
+* Return new object with sorted keys.
+*/
+var sortKeys = (obj) => Object.keys(obj).sort().reduce((sorted, key) => {
+	sorted[key] = obj[key];
+	return sorted;
+}, {});
+/**
+* Move element within array.
+*/
+var arrayMove = (array, from, to) => {
+	array.splice(to < 0 ? array.length + to : to, 0, array.splice(from, 1)[0]);
+	return array;
+};
+/**
+* Swap position of element within array.
+*/
+function arraySwap(array, from, to) {
+	const current = array[from];
+	array[from] = array[to];
+	array[to] = current;
+	return array;
+}
+//#endregion
+//#region src/unit.ts
+var createFormat = (unit) => {
+	return (n, precision = unit.precision ?? 0) => {
+		const value = n / unit.quotient;
+		const formattedValue = value.toLocaleString("en-US", {
+			minimumFractionDigits: precision,
+			maximumFractionDigits: precision
+		});
+		return {
+			unit,
+			value,
+			formattedValue,
+			toString: () => `${formattedValue}${unit.symbol}`
+		};
+	};
+};
+var MS_SECONDS = 1e3;
+var MS_MINUTES = 60 * MS_SECONDS;
+var MS_HOURS = 60 * MS_MINUTES;
+var Unit = {
+	Percent: createFormat({
+		symbol: "%",
+		quotient: 1 / 100,
+		precision: 1
+	}),
+	Thousand: createFormat({
+		symbol: "k",
+		quotient: 1e3,
+		precision: 1
+	}),
+	Million: createFormat({
+		symbol: "M",
+		quotient: 1e6,
+		precision: 1
+	}),
+	Gigabyte: createFormat({
+		symbol: "GB",
+		quotient: 1e3 * 1e3 * 1e3,
+		precision: 1
+	}),
+	Megabyte: createFormat({
+		symbol: "MB",
+		quotient: 1e3 * 1e3,
+		precision: 1
+	}),
+	Kilobyte: createFormat({
+		symbol: "KB",
+		quotient: 1e3,
+		precision: 1
+	}),
+	Byte: createFormat({
+		symbol: "B",
+		quotient: 1
+	}),
+	Hour: createFormat({
+		symbol: "h",
+		quotient: MS_HOURS
+	}),
+	Minute: createFormat({
+		symbol: "m",
+		quotient: MS_MINUTES
+	}),
+	Second: createFormat({
+		symbol: "s",
+		quotient: MS_SECONDS,
+		precision: 1
+	}),
+	Millisecond: createFormat({
+		symbol: "ms",
+		quotient: 1
+	}),
+	Duration: (n) => {
+		const hours = Math.floor(n / MS_HOURS);
+		const minutes = Math.floor(n % MS_HOURS / MS_MINUTES);
+		if (hours) {
+			const formattedValue = minutes ? `${hours}h ${minutes}m` : `${hours}h`;
+			return {
+				unit: {
+					symbol: "h",
+					quotient: MS_HOURS
+				},
+				value: hours,
+				formattedValue,
+				toString: () => formattedValue
+			};
+		}
+		if (minutes) {
+			const seconds = (n - MS_MINUTES * minutes) / MS_SECONDS;
+			const formattedValue = seconds ? `${minutes}m ${Math.round(seconds)}s` : `${minutes}m`;
+			return {
+				unit: {
+					symbol: "m",
+					quotient: MS_MINUTES
+				},
+				value: minutes,
+				formattedValue,
+				toString: () => formattedValue
+			};
+		}
+		if (n >= MS_SECONDS) return Unit.Second(n);
+		return Unit.Millisecond(n);
+	}
+};
+//#endregion
+//#region src/url.ts
+/**
+* Normalize construction of URLs.
+*/
+var createUrl = (url, search) => {
+	const base = typeof url === "string" ? new URL(url) : url;
+	if (search) base.search = new URLSearchParams(Object.entries(search).filter(([_, value]) => value != null)).toString();
+	return base;
+};
+//#endregion
+//#region src/weak.ts
+/**
+* Weak dictionary. It is a map that holds weak references to its values and allows garbage collection of values and keys.
+*/
+var WeakDictionary = class {
+	_internal = /* @__PURE__ */ new Map();
+	_finalization = new FinalizationRegistry(({ key, ref }) => {
+		if (this._internal.get(key) === ref) this._internal.delete(key);
+	});
+	constructor(entries) {
+		if (entries) for (const [key, value] of entries) {
+			const ref = new WeakRef(value);
+			this._internal.set(key, ref);
+			this._register(key, value, ref);
+		}
+	}
+	*entries() {
+		for (const [key, value] of this._internal) yield [key, value.deref()];
+	}
+	keys() {
+		return this._internal.keys();
+	}
+	*values() {
+		for (const value of this._internal.values()) {
+			const deref = value.deref();
+			if (!deref) continue;
+			yield deref;
+		}
+	}
+	*[Symbol.iterator]() {
+		for (const [key, value] of this._internal) yield [key, value.deref()];
+	}
+	get [Symbol.toStringTag]() {
+		return "WeakDictionary";
+	}
+	get size() {
+		return this._internal.size;
+	}
+	get(key) {
+		return this._internal.get(key)?.deref();
+	}
+	set(key, value) {
+		const previous = this._internal.get(key)?.deref();
+		if (previous) this._unregister(previous);
+		const ref = new WeakRef(value);
+		this._internal.set(key, ref);
+		this._register(key, value, ref);
+		return this;
+	}
+	/**
+	* Returns the value for the given key if present, otherwise inserts and returns the default value.
+	* @param key - The key to look up or insert.
+	* @param defaultValue - The value to insert if the key is not present.
+	* @returns The existing or newly inserted value.
+	*/
+	getOrInsert(key, defaultValue) {
+		const existing = this.get(key);
+		if (existing !== void 0) return existing;
+		this.set(key, defaultValue);
+		return defaultValue;
+	}
+	/**
+	* Returns the value for the given key if present, otherwise computes, inserts, and returns a new value.
+	* The callback is only invoked when the key is missing.
+	* @param key - The key to look up or insert.
+	* @param callbackfn - Function to compute the value if the key is not present.
+	* @returns The existing or newly computed value.
+	*/
+	getOrInsertComputed(key, callbackfn) {
+		const existing = this.get(key);
+		if (existing !== void 0) return existing;
+		const value = callbackfn(key);
+		this.set(key, value);
+		return value;
+	}
+	has(key) {
+		return this._internal.has(key) && this._internal.get(key).deref() !== void 0;
+	}
+	delete(key) {
+		const value = this._internal.get(key)?.deref();
+		if (value) this._unregister(value);
+		return this._internal.delete(key);
+	}
+	clear() {
+		this._internal.forEach((value) => {
+			const v = value.deref();
+			if (v) this._unregister(v);
+		});
+		this._internal.clear();
+	}
+	forEach(callbackfn, thisArg) {
+		if (thisArg) callbackfn = callbackfn.bind(thisArg);
+		this._internal.forEach((value, key) => {
+			const v = value.deref();
+			if (v) callbackfn(v, key, this);
+		});
+	}
+	_register(key, value, ref) {
+		this._finalization.register(value, {
+			key,
+			ref
+		}, value);
+	}
+	_unregister(value) {
+		this._finalization.unregister(value);
+	}
+};
+//#endregion
+export { BitField, Callback, CallbackCollection, CircularBuffer, ComplexMap, ComplexSet, HumanHasher, MapEntry, Position_exports as Position, SKIP, SlidingWindowSummary, Tracer, Unit, WeakDictionary, accessBy, arrayMove, arraySwap, arrayToBuffer, arrayToHex, arrayToString, arraysEqual, assumeType, bufferToArray, capitalize, chunkArray, clamp, clearCaches, clearIndexedDB, clearOPFS, clearServiceWorkers, clearUndefined, coerceArray, compareMulti, compareObject, compareScalar, compareString, compositeKey, createBinder, createBucketReducer, createFilename, createGroupReducer, createReplacer, createSetDispatch, createUrl, decamelize, decodeUint8ArrayFromJson, deepMapValues, deepMapValuesAsync, defaultFilter, defaultMap, defer, deferAsync, deferFunction, diff, distinctBy, doAsync, encodeUint8ArrayToJson, entries, entry, exponentialBackoffInterval, forEachAsync, formatErrorWithCauses, getAsyncProviderValue, getDate, getDebugName, getDeep, getHostPlatform, getPrototypeSpecificInstanceId, getProviderValue, hexToEmoji, hexToFallback, hexToHue, humanize, hyphenize, id, idEmoji, idHue, inferObjectOrder, inferRecordOrder, inline, intersectBy, intersection, iosCheck, isBun, isEncodedUint8Array, isMobile, isMobileOrTablet, isNode, isNonNullable, isTauri, isTruthy, isWellFormedId, isWellFormedIdPart, joinTables, jsonKeyReplacer, jsonReplacer, jsonify, jsonlogify, kebabize, keyToEmoji, keyToFallback, keyToHue, keys, makeMap, makeSet, mapValues, median, numericalValues, omit, orderKeys, partition, pick, pickBy, randomInt, range, rangeFromTo, reduceGroupBy, reduceSeries, reduceSet, removeBy, removeProperties, removeUndefinedProperties, retry, safariCheck, safeAwaitAll, safeInstanceof, safeParseFloat, safeParseInt, safeParseJson, safeStringify, safeUrl, setDeep, sortKeys, splitCompositeKey, stringToArray, stringToFallback, stringToHue, stringifyTree, stripUndefined, sum, throwUnhandledError, toEmoji, toFallback, toHue, tracer, trim, visitValues };
+
+//# sourceMappingURL=index.mjs.map