@hexclave/shared 1.0.0

package/dist/utils/locks.js

@@ -0,0 +1,56 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let async_mutex = require("async-mutex");
+
+//#region src/utils/locks.tsx
+var ReadWriteLock = class {
+	constructor() {
+		this.semaphore = new async_mutex.Semaphore(1);
+		this.readers = 0;
+		this.readersMutex = new async_mutex.Semaphore(1);
+	}
+	async withReadLock(callback) {
+		await this._acquireReadLock();
+		try {
+			return await callback();
+		} finally {
+			await this._releaseReadLock();
+		}
+	}
+	async withWriteLock(callback) {
+		await this._acquireWriteLock();
+		try {
+			return await callback();
+		} finally {
+			await this._releaseWriteLock();
+		}
+	}
+	async _acquireReadLock() {
+		await this.readersMutex.acquire();
+		try {
+			this.readers += 1;
+			if (this.readers === 1) await this.semaphore.acquire();
+		} finally {
+			this.readersMutex.release();
+		}
+	}
+	async _releaseReadLock() {
+		await this.readersMutex.acquire();
+		try {
+			this.readers -= 1;
+			if (this.readers === 0) this.semaphore.release();
+		} finally {
+			this.readersMutex.release();
+		}
+	}
+	async _acquireWriteLock() {
+		await this.semaphore.acquire();
+	}
+	async _releaseWriteLock() {
+		this.semaphore.release();
+	}
+};
+
+//#endregion
+exports.ReadWriteLock = ReadWriteLock;
+//# sourceMappingURL=locks.js.map

package/dist/utils/locks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"locks.js","names":["Semaphore"],"sources":["../../src/utils/locks.tsx"],"sourcesContent":["import { Semaphore } from 'async-mutex';\n\ntype LockCallback<T> = () => Promise<T>;\n\nexport class ReadWriteLock {\n  private semaphore: Semaphore;\n  private readers: number;\n  private readersMutex: Semaphore;\n\n  constructor() {\n    this.semaphore = new Semaphore(1); // Semaphore with 1 permit\n    this.readers = 0; // Track the number of readers\n    this.readersMutex = new Semaphore(1); // Protect access to `readers` count\n  }\n\n  async withReadLock<T>(callback: LockCallback<T>): Promise<T> {\n    await this._acquireReadLock();\n    try {\n      return await callback();\n    } finally {\n      await this._releaseReadLock();\n    }\n  }\n\n  async withWriteLock<T>(callback: LockCallback<T>): Promise<T> {\n    await this._acquireWriteLock();\n    try {\n      return await callback();\n    } finally {\n      await this._releaseWriteLock();\n    }\n  }\n\n  private async _acquireReadLock(): Promise<void> {\n    // Increment the readers count\n    await this.readersMutex.acquire();\n    try {\n      this.readers += 1;\n      // If this is the first reader, block writers\n      if (this.readers === 1) {\n        await this.semaphore.acquire();\n      }\n    } finally {\n      this.readersMutex.release();\n    }\n  }\n\n  private async _releaseReadLock(): Promise<void> {\n    // Decrement the readers count\n    await this.readersMutex.acquire();\n    try {\n      this.readers -= 1;\n      // If this was the last reader, release the writer block\n      if (this.readers === 0) {\n        this.semaphore.release();\n      }\n    } finally {\n      this.readersMutex.release();\n    }\n  }\n\n  private async _acquireWriteLock(): Promise<void> {\n    // Writers acquire the main semaphore exclusively\n    await this.semaphore.acquire();\n  }\n\n  private async _releaseWriteLock(): Promise<void> {\n    // Writers release the main semaphore\n    this.semaphore.release();\n  }\n}\n"],"mappings":";;;;;AAIA,IAAa,gBAAb,MAA2B;CAKzB,cAAc;AACZ,OAAK,YAAY,IAAIA,sBAAU,EAAE;AACjC,OAAK,UAAU;AACf,OAAK,eAAe,IAAIA,sBAAU,EAAE;;CAGtC,MAAM,aAAgB,UAAuC;AAC3D,QAAM,KAAK,kBAAkB;AAC7B,MAAI;AACF,UAAO,MAAM,UAAU;YACf;AACR,SAAM,KAAK,kBAAkB;;;CAIjC,MAAM,cAAiB,UAAuC;AAC5D,QAAM,KAAK,mBAAmB;AAC9B,MAAI;AACF,UAAO,MAAM,UAAU;YACf;AACR,SAAM,KAAK,mBAAmB;;;CAIlC,MAAc,mBAAkC;AAE9C,QAAM,KAAK,aAAa,SAAS;AACjC,MAAI;AACF,QAAK,WAAW;AAEhB,OAAI,KAAK,YAAY,EACnB,OAAM,KAAK,UAAU,SAAS;YAExB;AACR,QAAK,aAAa,SAAS;;;CAI/B,MAAc,mBAAkC;AAE9C,QAAM,KAAK,aAAa,SAAS;AACjC,MAAI;AACF,QAAK,WAAW;AAEhB,OAAI,KAAK,YAAY,EACnB,MAAK,UAAU,SAAS;YAElB;AACR,QAAK,aAAa,SAAS;;;CAI/B,MAAc,oBAAmC;AAE/C,QAAM,KAAK,UAAU,SAAS;;CAGhC,MAAc,oBAAmC;AAE/C,OAAK,UAAU,SAAS"}

package/dist/utils/maps.d.ts

@@ -0,0 +1,61 @@
+//#region src/utils/maps.d.ts
+declare class WeakRefIfAvailable<T extends object> {
+  private readonly _ref;
+  constructor(value: T);
+  deref(): T | undefined;
+}
+/**
+ * A WeakMap-like object that can be iterated over.
+ *
+ * Note that it relies on WeakRef, and always falls back to the regular Map behavior (ie. no GC) in browsers that don't support it.
+ */
+declare class IterableWeakMap<K extends object, V> {
+  private readonly _weakMap;
+  private readonly _keyRefs;
+  constructor(entries?: readonly (readonly [K, V])[] | null);
+  get(key: K): V | undefined;
+  set(key: K, value: V): this;
+  delete(key: K): boolean;
+  has(key: K): boolean;
+  [Symbol.iterator](): IterableIterator<[K, V]>;
+  [Symbol.toStringTag]: string;
+}
+/**
+ * A map that is a IterableWeakMap for object keys and a regular Map for primitive keys. Also provides iteration over both
+ * object and primitive keys.
+ *
+ * Note that, just like IterableWeakMap, older browsers without support for WeakRef will use a regular Map for object keys.
+ */
+declare class MaybeWeakMap<K, V> {
+  private readonly _primitiveMap;
+  private readonly _weakMap;
+  constructor(entries?: readonly (readonly [K, V])[] | null);
+  private _isAllowedInWeakMap;
+  get(key: K): V | undefined;
+  set(key: K, value: V): this;
+  delete(key: K): boolean;
+  has(key: K): boolean;
+  [Symbol.iterator](): IterableIterator<[K, V]>;
+  [Symbol.toStringTag]: string;
+}
+/**
+ * A map that stores values indexed by an array of keys. If the keys are objects and the environment supports WeakRefs,
+ * they are stored in a WeakMap.
+ */
+declare class DependenciesMap<K extends any[], V> {
+  private _inner;
+  private _valueToResult;
+  private _unwrapFromInner;
+  private _setInInner;
+  private _iterateInner;
+  get(dependencies: K): V | undefined;
+  set(dependencies: K, value: V): this;
+  delete(dependencies: K): boolean;
+  has(dependencies: K): boolean;
+  clear(): void;
+  [Symbol.iterator](): IterableIterator<[K, V]>;
+  [Symbol.toStringTag]: string;
+}
+//#endregion
+export { DependenciesMap, IterableWeakMap, MaybeWeakMap, WeakRefIfAvailable };
+//# sourceMappingURL=maps.d.ts.map

package/dist/utils/maps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maps.d.ts","names":[],"sources":["../../src/utils/maps.tsx"],"mappings":";cAEa,kBAAA;EAAA,iBACM,IAAA;cAEL,KAAA,EAAO,CAAA;EAQnB,KAAA,CAAA,GAAS,CAAA;AAAA;;;;;;cA4BE,eAAA;EAAA,iBACM,QAAA;EAAA,iBACA,QAAA;cAEL,OAAA,uBAA8B,CAAA,EAAG,CAAA;EAM7C,GAAA,CAAI,GAAA,EAAK,CAAA,GAAI,CAAA;EAIb,GAAA,CAAI,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA;EAQnB,MAAA,CAAO,GAAA,EAAK,CAAA;EAUZ,GAAA,CAAI,GAAA,EAAK,CAAA;EAAA,CAIP,MAAA,CAAO,QAAA,KAAa,gBAAA,EAAkB,CAAA,EAAG,CAAA;EAAA,CAa1C,MAAA,CAAO,WAAA;AAAA;;;;;;;cAuEG,YAAA;EAAA,iBACM,aAAA;EAAA,iBACA,QAAA;cAEL,OAAA,uBAA8B,CAAA,EAAG,CAAA;EAAA,QAMrC,mBAAA;EAIR,GAAA,CAAI,GAAA,EAAK,CAAA,GAAI,CAAA;EAQb,GAAA,CAAI,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA;EASnB,MAAA,CAAO,GAAA,EAAK,CAAA;EAQZ,GAAA,CAAI,GAAA,EAAK,CAAA;EAAA,CAQP,MAAA,CAAO,QAAA,KAAa,gBAAA,EAAkB,CAAA,EAAG,CAAA;EAAA,CAK1C,MAAA,CAAO,WAAA;AAAA;;;;;cA6DG,eAAA;EAAA,QACH,MAAA;EAAA,QAEA,cAAA;EAAA,QASA,gBAAA;EAAA,QAaA,WAAA;EAAA,QAqBC,aAAA;EAST,GAAA,CAAI,YAAA,EAAc,CAAA,GAAI,CAAA;EAItB,GAAA,CAAI,YAAA,EAAc,CAAA,EAAG,KAAA,EAAO,CAAA;EAK5B,MAAA,CAAO,YAAA,EAAc,CAAA;EAIrB,GAAA,CAAI,YAAA,EAAc,CAAA;EAIlB,KAAA,CAAA;EAAA,CAIE,MAAA,CAAO,QAAA,KAAa,gBAAA,EAAkB,CAAA,EAAG,CAAA;EAAA,CAI1C,MAAA,CAAO,WAAA;AAAA"}

package/dist/utils/maps.js

@@ -0,0 +1,302 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let __results_js = require("./results.js");
+
+//#region src/utils/maps.tsx
+let _Symbol$toStringTag, _Symbol$toStringTag2, _Symbol$toStringTag3;
+var WeakRefIfAvailable = class {
+	constructor(value) {
+		if (typeof WeakRef === "undefined") this._ref = { deref: () => value };
+		else this._ref = new WeakRef(value);
+	}
+	deref() {
+		return this._ref.deref();
+	}
+};
+(void 0)?.test("WeakRefIfAvailable", ({ expect }) => {
+	const obj = {
+		id: 1,
+		name: "test"
+	};
+	expect(new WeakRefIfAvailable(obj).deref()).toBe(obj);
+	const obj2 = {
+		id: 2,
+		name: "test2"
+	};
+	const weakRef2 = new WeakRefIfAvailable(obj2);
+	expect(weakRef2.deref()).toBe(obj2);
+	expect(weakRef2.deref()).not.toBe(obj);
+});
+/**
+* A WeakMap-like object that can be iterated over.
+*
+* Note that it relies on WeakRef, and always falls back to the regular Map behavior (ie. no GC) in browsers that don't support it.
+*/
+var IterableWeakMap = class {
+	static {
+		_Symbol$toStringTag = Symbol.toStringTag;
+	}
+	constructor(entries) {
+		this[_Symbol$toStringTag] = "IterableWeakMap";
+		const mappedEntries = entries?.map((e) => [e[0], {
+			value: e[1],
+			keyRef: new WeakRefIfAvailable(e[0])
+		}]);
+		this._weakMap = new WeakMap(mappedEntries ?? []);
+		this._keyRefs = new Set(mappedEntries?.map((e) => e[1].keyRef) ?? []);
+	}
+	get(key) {
+		return this._weakMap.get(key)?.value;
+	}
+	set(key, value) {
+		const updated = {
+			value,
+			keyRef: this._weakMap.get(key)?.keyRef ?? new WeakRefIfAvailable(key)
+		};
+		this._weakMap.set(key, updated);
+		this._keyRefs.add(updated.keyRef);
+		return this;
+	}
+	delete(key) {
+		const res = this._weakMap.get(key);
+		if (res) {
+			this._weakMap.delete(key);
+			this._keyRefs.delete(res.keyRef);
+			return true;
+		}
+		return false;
+	}
+	has(key) {
+		return this._weakMap.has(key) && this._keyRefs.has(this._weakMap.get(key).keyRef);
+	}
+	*[Symbol.iterator]() {
+		for (const keyRef of this._keyRefs) {
+			const key = keyRef.deref();
+			const existing = key ? this._weakMap.get(key) : void 0;
+			if (!key) this._keyRefs.delete(keyRef);
+			else if (existing) yield [key, existing.value];
+		}
+	}
+};
+(void 0)?.test("IterableWeakMap", ({ expect }) => {
+	const map = new IterableWeakMap();
+	const obj1 = { id: 1 };
+	const obj2 = { id: 2 };
+	map.set(obj1, "value1");
+	expect(map.get(obj1)).toBe("value1");
+	expect(map.has(obj1)).toBe(true);
+	expect(map.has(obj2)).toBe(false);
+	expect(map.has({ id: 1 })).toBe(false);
+	map.set(obj2, "value2");
+	expect(map.get(obj2)).toBe("value2");
+	expect(map.get(obj1)).toBe("value1");
+	expect(map.delete(obj1)).toBe(true);
+	expect(map.has(obj1)).toBe(false);
+	expect(map.get(obj1)).toBeUndefined();
+	expect(map.has(obj2)).toBe(true);
+	expect(map.delete({ id: 3 })).toBe(false);
+	const iterMap = new IterableWeakMap();
+	const iterObj1 = { id: 1 };
+	const iterObj2 = { id: 2 };
+	const iterObj3 = { id: 3 };
+	iterMap.set(iterObj1, 1);
+	iterMap.set(iterObj2, 2);
+	iterMap.set(iterObj3, 3);
+	const entries = Array.from(iterMap);
+	expect(entries.length).toBe(3);
+	const values = entries.map((entry) => entry[1]);
+	expect(values).toContain(1);
+	expect(values).toContain(2);
+	expect(values).toContain(3);
+	const mapWithEntries = new IterableWeakMap([[{ id: 4 }, "initial1"], [{ id: 5 }, "initial2"]]);
+	expect(Array.from(mapWithEntries).length).toBe(2);
+});
+/**
+* A map that is a IterableWeakMap for object keys and a regular Map for primitive keys. Also provides iteration over both
+* object and primitive keys.
+*
+* Note that, just like IterableWeakMap, older browsers without support for WeakRef will use a regular Map for object keys.
+*/
+var MaybeWeakMap = class {
+	static {
+		_Symbol$toStringTag2 = Symbol.toStringTag;
+	}
+	constructor(entries) {
+		this[_Symbol$toStringTag2] = "MaybeWeakMap";
+		const entriesArray = [...entries ?? []];
+		this._primitiveMap = new Map(entriesArray.filter((e) => !this._isAllowedInWeakMap(e[0])));
+		this._weakMap = new IterableWeakMap(entriesArray.filter((e) => this._isAllowedInWeakMap(e[0])));
+	}
+	_isAllowedInWeakMap(key) {
+		return typeof key === "object" && key !== null || typeof key === "symbol" && Symbol.keyFor(key) === void 0;
+	}
+	get(key) {
+		if (this._isAllowedInWeakMap(key)) return this._weakMap.get(key);
+		else return this._primitiveMap.get(key);
+	}
+	set(key, value) {
+		if (this._isAllowedInWeakMap(key)) this._weakMap.set(key, value);
+		else this._primitiveMap.set(key, value);
+		return this;
+	}
+	delete(key) {
+		if (this._isAllowedInWeakMap(key)) return this._weakMap.delete(key);
+		else return this._primitiveMap.delete(key);
+	}
+	has(key) {
+		if (this._isAllowedInWeakMap(key)) return this._weakMap.has(key);
+		else return this._primitiveMap.has(key);
+	}
+	*[Symbol.iterator]() {
+		yield* this._primitiveMap;
+		yield* this._weakMap;
+	}
+};
+(void 0)?.test("MaybeWeakMap", ({ expect }) => {
+	const map = new MaybeWeakMap();
+	map.set("key1", 1);
+	map.set("key2", 2);
+	expect(map.get("key1")).toBe(1);
+	expect(map.get("key2")).toBe(2);
+	expect(map.has("key1")).toBe(true);
+	expect(map.has("nonexistent")).toBe(false);
+	const obj1 = { id: 1 };
+	const obj2 = { id: 2 };
+	map.set(obj1, 3);
+	map.set(obj2, 4);
+	expect(map.get(obj1)).toBe(3);
+	expect(map.get(obj2)).toBe(4);
+	expect(map.has(obj1)).toBe(true);
+	expect(map.delete("key1")).toBe(true);
+	expect(map.has("key1")).toBe(false);
+	expect(map.delete("nonexistent")).toBe(false);
+	expect(map.delete(obj1)).toBe(true);
+	expect(map.has(obj1)).toBe(false);
+	const entries = Array.from(map);
+	expect(entries.length).toBe(2);
+	expect(entries).toContainEqual(["key2", 2]);
+	expect(entries).toContainEqual([obj2, 4]);
+	const initialEntries = [["initial1", 10], [{ id: 3 }, 20]];
+	const mapWithEntries = new MaybeWeakMap(initialEntries);
+	expect(mapWithEntries.get("initial1")).toBe(10);
+	expect(mapWithEntries.get(initialEntries[1][0])).toBe(20);
+});
+/**
+* A map that stores values indexed by an array of keys. If the keys are objects and the environment supports WeakRefs,
+* they are stored in a WeakMap.
+*/
+var DependenciesMap = class {
+	constructor() {
+		this._inner = {
+			map: new MaybeWeakMap(),
+			hasValue: false,
+			value: void 0
+		};
+		this[_Symbol$toStringTag3] = "DependenciesMap";
+	}
+	static {
+		_Symbol$toStringTag3 = Symbol.toStringTag;
+	}
+	_valueToResult(inner) {
+		if (inner.hasValue) return __results_js.Result.ok(inner.value);
+		else return __results_js.Result.error(void 0);
+	}
+	_unwrapFromInner(dependencies, inner) {
+		if (dependencies.length === 0) return this._valueToResult(inner);
+		else {
+			const [key, ...rest] = dependencies;
+			const newInner = inner.map.get(key);
+			if (!newInner) return __results_js.Result.error(void 0);
+			return this._unwrapFromInner(rest, newInner);
+		}
+	}
+	_setInInner(dependencies, value, inner) {
+		if (dependencies.length === 0) {
+			const res = this._valueToResult(inner);
+			if (value.status === "ok") {
+				inner.hasValue = true;
+				inner.value = value.data;
+			} else {
+				inner.hasValue = false;
+				inner.value = void 0;
+			}
+			return res;
+		} else {
+			const [key, ...rest] = dependencies;
+			let newInner = inner.map.get(key);
+			if (!newInner) inner.map.set(key, newInner = {
+				map: new MaybeWeakMap(),
+				hasValue: false,
+				value: void 0
+			});
+			return this._setInInner(rest, value, newInner);
+		}
+	}
+	*_iterateInner(dependencies, inner) {
+		if (inner.hasValue) yield [dependencies, inner.value];
+		for (const [key, value] of inner.map) yield* this._iterateInner([...dependencies, key], value);
+	}
+	get(dependencies) {
+		return __results_js.Result.or(this._unwrapFromInner(dependencies, this._inner), void 0);
+	}
+	set(dependencies, value) {
+		this._setInInner(dependencies, __results_js.Result.ok(value), this._inner);
+		return this;
+	}
+	delete(dependencies) {
+		return this._setInInner(dependencies, __results_js.Result.error(void 0), this._inner).status === "ok";
+	}
+	has(dependencies) {
+		return this._unwrapFromInner(dependencies, this._inner).status === "ok";
+	}
+	clear() {
+		this._inner = {
+			map: new MaybeWeakMap(),
+			hasValue: false,
+			value: void 0
+		};
+	}
+	*[Symbol.iterator]() {
+		yield* this._iterateInner([], this._inner);
+	}
+};
+(void 0)?.test("DependenciesMap", ({ expect }) => {
+	const map = new DependenciesMap();
+	map.set(["key", 1], "value1");
+	expect(map.get(["key", 1])).toBe("value1");
+	expect(map.has(["key", 1])).toBe(true);
+	expect(map.has(["key", 2])).toBe(false);
+	map.set(["key", 2], "value2");
+	expect(map.get(["key", 2])).toBe("value2");
+	expect(map.get(["key", 1])).toBe("value1");
+	expect(map.delete(["key", 1])).toBe(true);
+	expect(map.has(["key", 1])).toBe(false);
+	expect(map.get(["key", 1])).toBeUndefined();
+	expect(map.has(["key", 2])).toBe(true);
+	expect(map.delete(["nonexistent", 1])).toBe(false);
+	map.clear();
+	expect(map.has(["key", 2])).toBe(false);
+	const objMap = new DependenciesMap();
+	const obj1 = { id: 1 };
+	const obj2 = { id: 2 };
+	objMap.set([obj1, 1], "object1");
+	objMap.set([obj2, 2], "object2");
+	expect(objMap.get([obj1, 1])).toBe("object1");
+	expect(objMap.get([obj2, 2])).toBe("object2");
+	const iterMap = new DependenciesMap();
+	iterMap.set(["a"], 1);
+	iterMap.set(["b"], 2);
+	iterMap.set(["c"], 3);
+	const entries = Array.from(iterMap);
+	expect(entries.length).toBe(3);
+	expect(entries).toContainEqual([["a"], 1]);
+	expect(entries).toContainEqual([["b"], 2]);
+	expect(entries).toContainEqual([["c"], 3]);
+});
+
+//#endregion
+exports.DependenciesMap = DependenciesMap;
+exports.IterableWeakMap = IterableWeakMap;
+exports.MaybeWeakMap = MaybeWeakMap;
+exports.WeakRefIfAvailable = WeakRefIfAvailable;
+//# sourceMappingURL=maps.js.map

package/dist/utils/maps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maps.js","names":[],"sources":["../../src/utils/maps.tsx"],"sourcesContent":["import { Result } from \"./results\";\n\nexport class WeakRefIfAvailable<T extends object> {\n  private readonly _ref: { deref: () => T | undefined };\n\n  constructor(value: T) {\n    if (typeof WeakRef === \"undefined\") {\n      this._ref = { deref: () => value };\n    } else {\n      this._ref = new WeakRef<T>(value);\n    }\n  }\n\n  deref(): T | undefined {\n    return this._ref.deref();\n  }\n}\nimport.meta.vitest?.test(\"WeakRefIfAvailable\", ({ expect }) => {\n  // Test with an object\n  const obj = { id: 1, name: \"test\" };\n  const weakRef = new WeakRefIfAvailable(obj);\n\n  // Test deref returns the original object\n  expect(weakRef.deref()).toBe(obj);\n\n  // Test with a different object\n  const obj2 = { id: 2, name: \"test2\" };\n  const weakRef2 = new WeakRefIfAvailable(obj2);\n  expect(weakRef2.deref()).toBe(obj2);\n  expect(weakRef2.deref()).not.toBe(obj);\n\n  // We can't easily test garbage collection in this environment,\n  // but we can verify the basic functionality works\n});\n\n\n/**\n * A WeakMap-like object that can be iterated over.\n *\n * Note that it relies on WeakRef, and always falls back to the regular Map behavior (ie. no GC) in browsers that don't support it.\n */\nexport class IterableWeakMap<K extends object, V> {\n  private readonly _weakMap: WeakMap<K & WeakKey, { value: V, keyRef: WeakRefIfAvailable<K & WeakKey> }>;\n  private readonly _keyRefs: Set<WeakRefIfAvailable<K & WeakKey>>;\n\n  constructor(entries?: readonly (readonly [K, V])[] | null) {\n    const mappedEntries = entries?.map((e) => [e[0], { value: e[1], keyRef: new WeakRefIfAvailable(e[0]) }] as const);\n    this._weakMap = new WeakMap(mappedEntries ?? []);\n    this._keyRefs = new Set(mappedEntries?.map((e) => e[1].keyRef) ?? []);\n  }\n\n  get(key: K): V | undefined {\n    return this._weakMap.get(key)?.value;\n  }\n\n  set(key: K, value: V): this {\n    const existing = this._weakMap.get(key);\n    const updated = { value, keyRef: existing?.keyRef ?? new WeakRefIfAvailable(key) };\n    this._weakMap.set(key, updated);\n    this._keyRefs.add(updated.keyRef);\n    return this;\n  }\n\n  delete(key: K): boolean {\n    const res = this._weakMap.get(key);\n    if (res) {\n      this._weakMap.delete(key);\n      this._keyRefs.delete(res.keyRef);\n      return true;\n    }\n    return false;\n  }\n\n  has(key: K): boolean {\n    return this._weakMap.has(key) && this._keyRefs.has(this._weakMap.get(key)!.keyRef);\n  }\n\n  *[Symbol.iterator](): IterableIterator<[K, V]> {\n    for (const keyRef of this._keyRefs) {\n      const key = keyRef.deref();\n      const existing = key ? this._weakMap.get(key) : undefined;\n      if (!key) {\n        // This can happen if the key was GCed. Remove it so the next iteration is faster.\n        this._keyRefs.delete(keyRef);\n      } else if (existing) {\n        yield [key, existing.value];\n      }\n    }\n  }\n\n  [Symbol.toStringTag] = \"IterableWeakMap\";\n}\nimport.meta.vitest?.test(\"IterableWeakMap\", ({ expect }) => {\n  // Test basic functionality\n  const map = new IterableWeakMap<{ id: number }, string>();\n\n  // Create object keys\n  const obj1 = { id: 1 };\n  const obj2 = { id: 2 };\n\n  // Test set and get\n  map.set(obj1, \"value1\");\n  expect(map.get(obj1)).toBe(\"value1\");\n\n  // Test has\n  expect(map.has(obj1)).toBe(true);\n  expect(map.has(obj2)).toBe(false);\n  expect(map.has({ id: 1 })).toBe(false); // Different object with same content\n\n  // Test with multiple keys\n  map.set(obj2, \"value2\");\n  expect(map.get(obj2)).toBe(\"value2\");\n  expect(map.get(obj1)).toBe(\"value1\"); // Original still exists\n\n  // Test delete\n  expect(map.delete(obj1)).toBe(true);\n  expect(map.has(obj1)).toBe(false);\n  expect(map.get(obj1)).toBeUndefined();\n  expect(map.has(obj2)).toBe(true); // Other key still exists\n\n  // Test delete non-existent key\n  expect(map.delete({ id: 3 })).toBe(false);\n\n  // Test iteration\n  const iterMap = new IterableWeakMap<{ id: number }, number>();\n  const iterObj1 = { id: 1 };\n  const iterObj2 = { id: 2 };\n  const iterObj3 = { id: 3 };\n\n  iterMap.set(iterObj1, 1);\n  iterMap.set(iterObj2, 2);\n  iterMap.set(iterObj3, 3);\n\n  const entries = Array.from(iterMap);\n  expect(entries.length).toBe(3);\n\n  // Find entries by their values since we can't directly compare objects in the array\n  const values = entries.map(entry => entry[1]);\n  expect(values).toContain(1);\n  expect(values).toContain(2);\n  expect(values).toContain(3);\n\n  // Test constructor with entries\n  const initialEntries: [{ id: number }, string][] = [\n    [{ id: 4 }, \"initial1\"],\n    [{ id: 5 }, \"initial2\"]\n  ];\n  const mapWithEntries = new IterableWeakMap(initialEntries);\n\n  // We can't directly access the initial entries since they're different object references\n  // But we can verify the map has the correct number of entries\n  const entriesFromConstructor = Array.from(mapWithEntries);\n  expect(entriesFromConstructor.length).toBe(2);\n});\n\n/**\n * A map that is a IterableWeakMap for object keys and a regular Map for primitive keys. Also provides iteration over both\n * object and primitive keys.\n *\n * Note that, just like IterableWeakMap, older browsers without support for WeakRef will use a regular Map for object keys.\n */\nexport class MaybeWeakMap<K, V> {\n  private readonly _primitiveMap: Map<K, V>;\n  private readonly _weakMap: IterableWeakMap<K & WeakKey, V>;\n\n  constructor(entries?: readonly (readonly [K, V])[] | null) {\n    const entriesArray = [...entries ?? []];\n    this._primitiveMap = new Map(entriesArray.filter((e) => !this._isAllowedInWeakMap(e[0])));\n    this._weakMap = new IterableWeakMap(entriesArray.filter((e): e is [K & WeakKey, V] => this._isAllowedInWeakMap(e[0])));\n  }\n\n  private _isAllowedInWeakMap(key: K): key is K & WeakKey {\n    return (typeof key === \"object\" && key !== null) || (typeof key === \"symbol\" && Symbol.keyFor(key) === undefined);\n  }\n\n  get(key: K): V | undefined {\n    if (this._isAllowedInWeakMap(key)) {\n      return this._weakMap.get(key);\n    } else {\n      return this._primitiveMap.get(key);\n    }\n  }\n\n  set(key: K, value: V): this {\n    if (this._isAllowedInWeakMap(key)) {\n      this._weakMap.set(key, value);\n    } else {\n      this._primitiveMap.set(key, value);\n    }\n    return this;\n  }\n\n  delete(key: K): boolean {\n    if (this._isAllowedInWeakMap(key)) {\n      return this._weakMap.delete(key);\n    } else {\n      return this._primitiveMap.delete(key);\n    }\n  }\n\n  has(key: K): boolean {\n    if (this._isAllowedInWeakMap(key)) {\n      return this._weakMap.has(key);\n    } else {\n      return this._primitiveMap.has(key);\n    }\n  }\n\n  *[Symbol.iterator](): IterableIterator<[K, V]> {\n    yield* this._primitiveMap;\n    yield* this._weakMap;\n  }\n\n  [Symbol.toStringTag] = \"MaybeWeakMap\";\n}\nimport.meta.vitest?.test(\"MaybeWeakMap\", ({ expect }) => {\n  // Test with primitive keys\n  const map = new MaybeWeakMap<string | object, number>();\n\n  // Test with string keys\n  map.set(\"key1\", 1);\n  map.set(\"key2\", 2);\n  expect(map.get(\"key1\")).toBe(1);\n  expect(map.get(\"key2\")).toBe(2);\n  expect(map.has(\"key1\")).toBe(true);\n  expect(map.has(\"nonexistent\")).toBe(false);\n\n  // Test with object keys\n  const obj1 = { id: 1 };\n  const obj2 = { id: 2 };\n  map.set(obj1, 3);\n  map.set(obj2, 4);\n  expect(map.get(obj1)).toBe(3);\n  expect(map.get(obj2)).toBe(4);\n  expect(map.has(obj1)).toBe(true);\n\n  // Test delete with primitive key\n  expect(map.delete(\"key1\")).toBe(true);\n  expect(map.has(\"key1\")).toBe(false);\n  expect(map.delete(\"nonexistent\")).toBe(false);\n\n  // Test delete with object key\n  expect(map.delete(obj1)).toBe(true);\n  expect(map.has(obj1)).toBe(false);\n\n  // Test iteration\n  const entries = Array.from(map);\n  expect(entries.length).toBe(2);\n  expect(entries).toContainEqual([\"key2\", 2]);\n  expect(entries).toContainEqual([obj2, 4]);\n\n  // Test constructor with entries\n  const initialEntries: [string | object, number][] = [\n    [\"initial1\", 10],\n    [{ id: 3 }, 20]\n  ];\n  const mapWithEntries = new MaybeWeakMap(initialEntries);\n  expect(mapWithEntries.get(\"initial1\")).toBe(10);\n  expect(mapWithEntries.get(initialEntries[1][0])).toBe(20);\n});\n\n\ntype DependenciesMapInner<V> = (\n  & { map: MaybeWeakMap<unknown, DependenciesMapInner<V>> }\n  & (\n    | { hasValue: true, value: V }\n    | { hasValue: false, value: undefined }\n  )\n);\n\n/**\n * A map that stores values indexed by an array of keys. If the keys are objects and the environment supports WeakRefs,\n * they are stored in a WeakMap.\n */\nexport class DependenciesMap<K extends any[], V> {\n  private _inner: DependenciesMapInner<V> = { map: new MaybeWeakMap(), hasValue: false, value: undefined };\n\n  private _valueToResult(inner: DependenciesMapInner<V>): Result<V, void> {\n    if (inner.hasValue) {\n      return Result.ok(inner.value);\n    } else {\n      return Result.error(undefined);\n    }\n  }\n\n\n  private _unwrapFromInner(dependencies: any[], inner: DependenciesMapInner<V>): Result<V, void> {\n    if ((dependencies.length === 0)) {\n      return this._valueToResult(inner);\n    } else {\n      const [key, ...rest] = dependencies;\n      const newInner = inner.map.get(key);\n      if (!newInner) {\n        return Result.error(undefined);\n      }\n      return this._unwrapFromInner(rest, newInner);\n    }\n  }\n\n  private _setInInner(dependencies: any[], value: Result<V, void>, inner: DependenciesMapInner<V>): Result<V, void> {\n    if (dependencies.length === 0) {\n      const res = this._valueToResult(inner);\n      if (value.status === \"ok\") {\n        inner.hasValue = true;\n        inner.value = value.data;\n      } else {\n        inner.hasValue = false;\n        inner.value = undefined;\n      }\n      return res;\n    } else {\n      const [key, ...rest] = dependencies;\n      let newInner = inner.map.get(key);\n      if (!newInner) {\n        inner.map.set(key, newInner = { map: new MaybeWeakMap(), hasValue: false, value: undefined });\n      }\n      return this._setInInner(rest, value, newInner);\n    }\n  }\n\n  private *_iterateInner(dependencies: any[], inner: DependenciesMapInner<V>): IterableIterator<[K, V]> {\n    if (inner.hasValue) {\n      yield [dependencies as K, inner.value];\n    }\n    for (const [key, value] of inner.map) {\n      yield* this._iterateInner([...dependencies, key], value);\n    }\n  }\n\n  get(dependencies: K): V | undefined {\n    return Result.or(this._unwrapFromInner(dependencies, this._inner), undefined);\n  }\n\n  set(dependencies: K, value: V): this {\n    this._setInInner(dependencies, Result.ok(value), this._inner);\n    return this;\n  }\n\n  delete(dependencies: K): boolean {\n    return this._setInInner(dependencies, Result.error(undefined), this._inner).status === \"ok\";\n  }\n\n  has(dependencies: K): boolean {\n    return this._unwrapFromInner(dependencies, this._inner).status === \"ok\";\n  }\n\n  clear(): void {\n    this._inner = { map: new MaybeWeakMap(), hasValue: false, value: undefined };\n  }\n\n  *[Symbol.iterator](): IterableIterator<[K, V]> {\n    yield* this._iterateInner([], this._inner);\n  }\n\n  [Symbol.toStringTag] = \"DependenciesMap\";\n}\nimport.meta.vitest?.test(\"DependenciesMap\", ({ expect }) => {\n  // Test basic functionality\n  const map = new DependenciesMap<[string, number], string>();\n\n  // Test set and get\n  map.set([\"key\", 1], \"value1\");\n  expect(map.get([\"key\", 1])).toBe(\"value1\");\n\n  // Test has\n  expect(map.has([\"key\", 1])).toBe(true);\n  expect(map.has([\"key\", 2])).toBe(false);\n\n  // Test with different dependencies\n  map.set([\"key\", 2], \"value2\");\n  expect(map.get([\"key\", 2])).toBe(\"value2\");\n  expect(map.get([\"key\", 1])).toBe(\"value1\"); // Original still exists\n\n  // Test delete\n  expect(map.delete([\"key\", 1])).toBe(true);\n  expect(map.has([\"key\", 1])).toBe(false);\n  expect(map.get([\"key\", 1])).toBeUndefined();\n  expect(map.has([\"key\", 2])).toBe(true); // Other key still exists\n\n  // Test delete non-existent key\n  expect(map.delete([\"nonexistent\", 1])).toBe(false);\n\n  // Test clear\n  map.clear();\n  expect(map.has([\"key\", 2])).toBe(false);\n\n  // Test with object keys\n  const objMap = new DependenciesMap<[object, number], string>();\n  const obj1 = { id: 1 };\n  const obj2 = { id: 2 };\n  objMap.set([obj1, 1], \"object1\");\n  objMap.set([obj2, 2], \"object2\");\n  expect(objMap.get([obj1, 1])).toBe(\"object1\");\n  expect(objMap.get([obj2, 2])).toBe(\"object2\");\n\n  // Test iteration\n  const iterMap = new DependenciesMap<[string], number>();\n  iterMap.set([\"a\"], 1);\n  iterMap.set([\"b\"], 2);\n  iterMap.set([\"c\"], 3);\n\n  const entries = Array.from(iterMap);\n  expect(entries.length).toBe(3);\n  expect(entries).toContainEqual([[\"a\"], 1]);\n  expect(entries).toContainEqual([[\"b\"], 2]);\n  expect(entries).toContainEqual([[\"c\"], 3]);\n});\n"],"mappings":"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"}

package/dist/utils/math.d.ts

@@ -0,0 +1,8 @@
+//#region src/utils/math.d.ts
+/**
+ * Similar to the modulo operator, but always returns a positive number (even when the input is negative).
+ */
+declare function remainder(n: number, d: number): number;
+//#endregion
+export { remainder };
+//# sourceMappingURL=math.d.ts.map

package/dist/utils/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","names":[],"sources":["../../src/utils/math.tsx"],"mappings":";;AAGA;;iBAAgB,SAAA,CAAU,CAAA,UAAW,CAAA"}

package/dist/utils/math.js

@@ -0,0 +1,23 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/utils/math.tsx
+/**
+* Similar to the modulo operator, but always returns a positive number (even when the input is negative).
+*/
+function remainder(n, d) {
+	return (n % d + Math.abs(d)) % d;
+}
+(void 0)?.test("remainder", ({ expect }) => {
+	expect(remainder(10, 3)).toBe(1);
+	expect(remainder(10, 5)).toBe(0);
+	expect(remainder(10, 7)).toBe(3);
+	expect(remainder(-10, 3)).toBe(2);
+	expect(remainder(-5, 2)).toBe(1);
+	expect(remainder(-7, 4)).toBe(1);
+	expect(remainder(10.5, 3)).toBeCloseTo(1.5);
+	expect(remainder(-10.5, 3)).toBeCloseTo(1.5);
+});
+
+//#endregion
+exports.remainder = remainder;
+//# sourceMappingURL=math.js.map

package/dist/utils/math.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.js","names":[],"sources":["../../src/utils/math.tsx"],"sourcesContent":["/**\n * Similar to the modulo operator, but always returns a positive number (even when the input is negative).\n */\nexport function remainder(n: number, d: number): number {\n  return ((n % d) + Math.abs(d)) % d;\n}\nimport.meta.vitest?.test(\"remainder\", ({ expect }) => {\n  expect(remainder(10, 3)).toBe(1);\n  expect(remainder(10, 5)).toBe(0);\n  expect(remainder(10, 7)).toBe(3);\n  // Test with negative numbers\n  expect(remainder(-10, 3)).toBe(2);\n  expect(remainder(-5, 2)).toBe(1);\n  expect(remainder(-7, 4)).toBe(1);\n  // Test with decimal numbers\n  expect(remainder(10.5, 3)).toBeCloseTo(1.5);\n  expect(remainder(-10.5, 3)).toBeCloseTo(1.5);\n});\n"],"mappings":";;;;;;AAGA,SAAgB,UAAU,GAAW,GAAmB;AACtD,SAAS,IAAI,IAAK,KAAK,IAAI,EAAE,IAAI;;CAEnC,SAAW,KAAC,cAAc,EAAA,aAAe;AACvC,QAAO,UAAU,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;AAChC,QAAO,UAAU,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;AAChC,QAAO,UAAU,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;AAEhC,QAAO,UAAU,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE;AACjC,QAAO,UAAU,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;AAChC,QAAO,UAAU,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;AAEhC,QAAO,UAAU,MAAM,EAAE,CAAC,CAAC,YAAY,IAAI;AAC3C,QAAO,UAAU,OAAO,EAAE,CAAC,CAAC,YAAY,IAAI;EAC5C"}

package/dist/utils/monkey-patch.d.ts

@@ -0,0 +1,7 @@
+//#region src/utils/monkey-patch.d.ts
+declare const NO_SUSPENSE_BOUNDARY_ERROR_SENTINEL = "__stack-no-suspense-boundary-error__";
+declare function isNoSuspenseBoundaryError(value: unknown): boolean;
+declare function ensureMonkeyPatch(): void;
+//#endregion
+export { NO_SUSPENSE_BOUNDARY_ERROR_SENTINEL, ensureMonkeyPatch, isNoSuspenseBoundaryError };
+//# sourceMappingURL=monkey-patch.d.ts.map

package/dist/utils/monkey-patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monkey-patch.d.ts","names":[],"sources":["../../src/utils/monkey-patch.tsx"],"mappings":";cAEa,mCAAA;AAAA,iBAEG,yBAAA,CAA0B,KAAA;AAAA,iBAQ1B,iBAAA,CAAA"}

package/dist/utils/monkey-patch.js

@@ -0,0 +1,25 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let __globals_js = require("./globals.js");
+
+//#region src/utils/monkey-patch.tsx
+const NO_SUSPENSE_BOUNDARY_ERROR_SENTINEL = "__stack-no-suspense-boundary-error__";
+function isNoSuspenseBoundaryError(value) {
+	return typeof value === "object" && value !== null && value.__noSuspenseBoundarySentinel === NO_SUSPENSE_BOUNDARY_ERROR_SENTINEL;
+}
+function ensureMonkeyPatch() {
+	(0, __globals_js.createGlobal)("__console-error-monkey-patch__", () => {
+		const originalConsoleError = console.error;
+		console.error = function(...args) {
+			if (args.length === 1 && isNoSuspenseBoundaryError(args[0])) return;
+			return originalConsoleError.apply(this, args);
+		};
+		return true;
+	});
+}
+
+//#endregion
+exports.NO_SUSPENSE_BOUNDARY_ERROR_SENTINEL = NO_SUSPENSE_BOUNDARY_ERROR_SENTINEL;
+exports.ensureMonkeyPatch = ensureMonkeyPatch;
+exports.isNoSuspenseBoundaryError = isNoSuspenseBoundaryError;
+//# sourceMappingURL=monkey-patch.js.map

package/dist/utils/monkey-patch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"monkey-patch.js","names":[],"sources":["../../src/utils/monkey-patch.tsx"],"sourcesContent":["import { createGlobal } from \"./globals\";\n\nexport const NO_SUSPENSE_BOUNDARY_ERROR_SENTINEL = \"__stack-no-suspense-boundary-error__\";\n\nexport function isNoSuspenseBoundaryError(value: unknown): boolean {\n  return (\n    typeof value === \"object\"\n    && value !== null\n    && (value as Record<string, unknown>).__noSuspenseBoundarySentinel === NO_SUSPENSE_BOUNDARY_ERROR_SENTINEL\n  );\n}\n\nexport function ensureMonkeyPatch() {\n  createGlobal(\"__console-error-monkey-patch__\", () => {\n    const originalConsoleError = console.error;\n    console.error = function (...args: unknown[]) {\n      // React's default error handlers will log all errors to the console, even those that we intentionally use to suppress SSR.\n      // Next.js among others override the default error handler and will not log SSR errors to the console.\n      // However, vanilla React and other frameworks like TanStack Start use the default error handler.\n      // Hence, we suppress the error here if it is a NoSuspenseBoundaryError.\n      // It's very cursed, but it's really our best option. Talk to @konsti if you want to know more.\n      if (args.length === 1 && isNoSuspenseBoundaryError(args[0])) {\n        return;\n      }\n      return originalConsoleError.apply(this, args);\n    };\n    return true;\n  });\n}\n"],"mappings":";;;;;AAEA,MAAa,sCAAsC;AAEnD,SAAgB,0BAA0B,OAAyB;AACjE,QACE,OAAO,UAAU,YACd,UAAU,QACT,MAAkC,iCAAiC;;AAI3E,SAAgB,oBAAoB;AAClC,gCAAa,wCAAwC;EACnD,MAAM,uBAAuB,QAAQ;AACrC,UAAQ,QAAQ,SAAU,GAAG,MAAiB;AAM5C,OAAI,KAAK,WAAW,KAAK,0BAA0B,KAAK,GAAG,CACzD;AAEF,UAAO,qBAAqB,MAAM,MAAM,KAAK;;AAE/C,SAAO;GACP"}

package/dist/utils/node-http.d.ts

@@ -0,0 +1,17 @@
+import { IncomingMessage, ServerResponse } from "http";
+
+//#region src/utils/node-http.d.ts
+declare class ServerResponseWithBodyChunks extends ServerResponse {
+  bodyChunks: Uint8Array[];
+  _send(data: string, encoding: BufferEncoding, callback?: (() => void) | null, byteLength?: number): void;
+}
+declare function createNodeHttpServerDuplex(options: {
+  method: string;
+  originalUrl?: URL;
+  url: URL;
+  headers: Headers;
+  body: Uint8Array;
+}): Promise<[IncomingMessage, ServerResponseWithBodyChunks]>;
+//#endregion
+export { createNodeHttpServerDuplex };
+//# sourceMappingURL=node-http.d.ts.map

package/dist/utils/node-http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-http.d.ts","names":[],"sources":["../../src/utils/node-http.tsx"],"mappings":";;;cAGM,4BAAA,SAAqC,cAAA;EACzC,UAAA,EAAY,UAAA;EAGZ,KAAA,CAAM,IAAA,UAAc,QAAA,EAAU,cAAA,EAAgB,QAAA,wBAAgC,UAAA;AAAA;AAAA,iBAW1D,0BAAA,CAA2B,OAAA;EAC/C,MAAA;EACA,WAAA,GAAc,GAAA;EACd,GAAA,EAAK,GAAA;EACL,OAAA,EAAS,OAAA;EACT,IAAA,EAAM,UAAA;AAAA,IACJ,OAAA,EAAS,eAAA,EAAiB,4BAAA"}

package/dist/utils/node-http.js

@@ -0,0 +1,40 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let http = require("http");
+let __urls_js = require("./urls.js");
+
+//#region src/utils/node-http.tsx
+var ServerResponseWithBodyChunks = class extends http.ServerResponse {
+	constructor(..._args) {
+		super(..._args);
+		this.bodyChunks = [];
+	}
+	_send(data, encoding, callback, byteLength) {
+		if (typeof encoding === "function") {
+			callback = encoding;
+			encoding = "utf-8";
+		}
+		const encodedBuffer = new Uint8Array(Buffer.from(data, encoding));
+		this.bodyChunks.push(encodedBuffer);
+		callback?.();
+	}
+};
+async function createNodeHttpServerDuplex(options) {
+	const incomingMessage = new http.IncomingMessage({ encrypted: options.originalUrl?.protocol === "https:" });
+	incomingMessage.httpVersionMajor = 1;
+	incomingMessage.httpVersionMinor = 1;
+	incomingMessage.httpVersion = "1.1";
+	incomingMessage.method = options.method;
+	incomingMessage.url = (0, __urls_js.getRelativePart)(options.url);
+	incomingMessage.originalUrl = options.originalUrl && (0, __urls_js.getRelativePart)(options.originalUrl);
+	const rawHeaders = [...options.headers.entries()].flat();
+	incomingMessage._addHeaderLines(rawHeaders, rawHeaders.length);
+	incomingMessage.push(Buffer.from(options.body));
+	incomingMessage.complete = true;
+	incomingMessage.push(null);
+	return [incomingMessage, new ServerResponseWithBodyChunks(incomingMessage)];
+}
+
+//#endregion
+exports.createNodeHttpServerDuplex = createNodeHttpServerDuplex;
+//# sourceMappingURL=node-http.js.map

package/dist/utils/node-http.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-http.js","names":["ServerResponse","IncomingMessage"],"sources":["../../src/utils/node-http.tsx"],"sourcesContent":["import { IncomingMessage, ServerResponse } from \"http\";\nimport { getRelativePart } from \"./urls\";\n\nclass ServerResponseWithBodyChunks extends ServerResponse {\n  bodyChunks: Uint8Array[] = [];\n\n  // note: we actually override this, even though it's private in the parent\n  _send(data: string, encoding: BufferEncoding, callback?: (() => void) | null, byteLength?: number) {\n    if (typeof encoding === \"function\") {\n      callback = encoding;\n      encoding = \"utf-8\";\n    }\n    const encodedBuffer = new Uint8Array(Buffer.from(data, encoding));\n    this.bodyChunks.push(encodedBuffer);\n    callback?.();\n  }\n}\n\nexport async function createNodeHttpServerDuplex(options: {\n  method: string,\n  originalUrl?: URL,\n  url: URL,\n  headers: Headers,\n  body: Uint8Array,\n}): Promise<[IncomingMessage, ServerResponseWithBodyChunks]> {\n  // See https://github.com/nodejs/node/blob/main/lib/_http_incoming.js\n  // and https://github.com/nodejs/node/blob/main/lib/_http_common.js (particularly the `parserXyz` functions)\n\n  const incomingMessage = new IncomingMessage({\n    encrypted: options.originalUrl?.protocol === \"https:\",  // trick frameworks into believing this is an HTTPS request\n  } as any);\n  incomingMessage.httpVersionMajor = 1;\n  incomingMessage.httpVersionMinor = 1;\n  incomingMessage.httpVersion = '1.1';\n  incomingMessage.method = options.method;\n  incomingMessage.url = getRelativePart(options.url);\n  (incomingMessage as any).originalUrl = options.originalUrl && getRelativePart(options.originalUrl);  // originalUrl is an extension used by some servers; for example, oidc-provider reads it to construct the paths for the .well-known/openid-configuration\n  const rawHeaders = [...options.headers.entries()].flat();\n  (incomingMessage as any)._addHeaderLines(rawHeaders, rawHeaders.length);\n  incomingMessage.push(Buffer.from(options.body));\n  incomingMessage.complete = true;\n  incomingMessage.push(null);  // to emit end event, see: https://github.com/nodejs/node/blob/4cf6fabce20eb3050c5b543d249e931ea3d3cad5/lib/_http_common.js#L150\n\n  const serverResponse = new ServerResponseWithBodyChunks(incomingMessage);\n\n  return [incomingMessage, serverResponse];\n}\n"],"mappings":";;;;;;AAGA,IAAM,+BAAN,cAA2CA,oBAAe;;;oBAC7B,EAAE;;CAG7B,MAAM,MAAc,UAA0B,UAAgC,YAAqB;AACjG,MAAI,OAAO,aAAa,YAAY;AAClC,cAAW;AACX,cAAW;;EAEb,MAAM,gBAAgB,IAAI,WAAW,OAAO,KAAK,MAAM,SAAS,CAAC;AACjE,OAAK,WAAW,KAAK,cAAc;AACnC,cAAY;;;AAIhB,eAAsB,2BAA2B,SAMY;CAI3D,MAAM,kBAAkB,IAAIC,qBAAgB,EAC1C,WAAW,QAAQ,aAAa,aAAa,UAC9C,CAAQ;AACT,iBAAgB,mBAAmB;AACnC,iBAAgB,mBAAmB;AACnC,iBAAgB,cAAc;AAC9B,iBAAgB,SAAS,QAAQ;AACjC,iBAAgB,qCAAsB,QAAQ,IAAI;AAClD,CAAC,gBAAwB,cAAc,QAAQ,8CAA+B,QAAQ,YAAY;CAClG,MAAM,aAAa,CAAC,GAAG,QAAQ,QAAQ,SAAS,CAAC,CAAC,MAAM;AACxD,CAAC,gBAAwB,gBAAgB,YAAY,WAAW,OAAO;AACvE,iBAAgB,KAAK,OAAO,KAAK,QAAQ,KAAK,CAAC;AAC/C,iBAAgB,WAAW;AAC3B,iBAAgB,KAAK,KAAK;AAI1B,QAAO,CAAC,iBAFe,IAAI,6BAA6B,gBAAgB,CAEhC"}

package/dist/utils/numbers.d.ts

@@ -0,0 +1,7 @@
+//#region src/utils/numbers.d.ts
+declare function prettyPrintWithMagnitudes(num: number): string;
+declare function toFixedMax(num: number, maxDecimals: number): string;
+declare function numberCompare(a: number, b: number): number;
+//#endregion
+export { numberCompare, prettyPrintWithMagnitudes, toFixedMax };
+//# sourceMappingURL=numbers.d.ts.map

package/dist/utils/numbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numbers.d.ts","names":[],"sources":["../../src/utils/numbers.tsx"],"mappings":";iBAQgB,yBAAA,CAA0B,GAAA;AAAA,iBAgD1B,UAAA,CAAW,GAAA,UAAa,WAAA;AAAA,iBAaxB,aAAA,CAAc,CAAA,UAAW,CAAA"}