@stackframe/stack-shared 2.8.8 → 2.8.11

package/dist/esm/utils/jwt.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/jwt.tsx"],"sourcesContent":["import crypto from \"crypto\";\nimport elliptic from \"elliptic\";\nimport * as jose from \"jose\";\nimport { JOSEError } from \"jose/errors\";\nimport { encodeBase64Url } from \"./bytes\";\nimport { StackAssertionError } from \"./errors\";\nimport { globalVar } from \"./globals\";\nimport { pick } from \"./objects\";\n\nconst STACK_SERVER_SECRET = process.env.STACK_SERVER_SECRET ?? \"\";\ntry {\n  jose.base64url.decode(STACK_SERVER_SECRET);\n} catch (e) {\n  throw new Error(\"STACK_SERVER_SECRET is not valid. Please use the generateKeys script to generate a new secret.\");\n}\n\n// TODO: remove this after moving everyone to project specific JWTs\nexport async function legacySignGlobalJWT(issuer: string, payload: any, expirationTime = \"5m\") {\n  const privateJwk = await jose.importJWK(await getPrivateJwk(STACK_SERVER_SECRET));\n  return await new jose.SignJWT(payload)\n    .setProtectedHeader({ alg: \"ES256\" })\n    .setIssuer(issuer)\n    .setIssuedAt()\n    .setExpirationTime(expirationTime)\n    .sign(privateJwk);\n}\n\n// TODO: remove this after moving everyone to project specific JWTs\nexport async function legacyVerifyGlobalJWT(issuer: string, jwt: string) {\n  const jwkSet = jose.createLocalJWKSet(await getPublicJwkSet(STACK_SERVER_SECRET));\n  const verified = await jose.jwtVerify(jwt, jwkSet, { issuer });\n  return verified.payload;\n}\n\nexport async function signJWT(options: {\n  issuer: string,\n  audience: string,\n  payload: any,\n  expirationTime?: string,\n}) {\n  const secret = getPerAudienceSecret({ audience: options.audience, secret: STACK_SERVER_SECRET });\n  const kid = getKid({ secret });\n  const privateJwk = await jose.importJWK(await getPrivateJwk(secret));\n  return await new jose.SignJWT(options.payload)\n    .setProtectedHeader({ alg: \"ES256\", kid })\n    .setIssuer(options.issuer)\n    .setIssuedAt()\n    .setAudience(options.audience)\n    .setExpirationTime(options.expirationTime || \"5m\")\n    .sign(privateJwk);\n}\n\nexport async function verifyJWT(options: {\n  issuer: string,\n  jwt: string,\n}) {\n  const audience = jose.decodeJwt(options.jwt).aud;\n  if (!audience || typeof audience !== \"string\") {\n    throw new JOSEError(\"Invalid JWT audience\");\n  }\n  const secret = getPerAudienceSecret({ audience, secret: STACK_SERVER_SECRET });\n  const jwkSet = jose.createLocalJWKSet(await getPublicJwkSet(secret));\n  const verified = await jose.jwtVerify(options.jwt, jwkSet, { issuer: options.issuer });\n  return verified.payload;\n}\n\nexport type PrivateJwk = {\n  kty: \"EC\",\n  alg: \"ES256\",\n  crv: \"P-256\",\n  kid: string,\n  d: string,\n  x: string,\n  y: string,\n};\nexport async function getPrivateJwk(secret: string): Promise<PrivateJwk> {\n  const secretHash = await globalVar.crypto.subtle.digest(\"SHA-256\", jose.base64url.decode(secret));\n  const priv = new Uint8Array(secretHash);\n\n  const ec = new elliptic.ec('p256');\n  const key = ec.keyFromPrivate(priv);\n  const publicKey = key.getPublic();\n\n  return {\n    kty: 'EC',\n    crv: 'P-256',\n    alg: 'ES256',\n    kid: getKid({ secret }),\n    d: encodeBase64Url(priv),\n    x: encodeBase64Url(publicKey.getX().toBuffer()),\n    y: encodeBase64Url(publicKey.getY().toBuffer()),\n  };\n}\n\nexport type PublicJwk = {\n  kty: \"EC\",\n  alg: \"ES256\",\n  crv: \"P-256\",\n  kid: string,\n  x: string,\n  y: string,\n};\nexport async function getPublicJwkSet(secretOrPrivateJwk: string | PrivateJwk): Promise<{ keys: PublicJwk[] }> {\n  const privateJwk = typeof secretOrPrivateJwk === \"string\" ? await getPrivateJwk(secretOrPrivateJwk) : secretOrPrivateJwk;\n  const jwk = pick(privateJwk, [\"kty\", \"alg\", \"crv\", \"x\", \"y\", \"kid\"]);\n  return {\n    keys: [jwk],\n  };\n}\n\nexport function getPerAudienceSecret(options: {\n  audience: string,\n  secret: string,\n}) {\n  if (options.audience === \"kid\") {\n    throw new StackAssertionError(\"You cannot use the 'kid' audience for a per-audience secret, see comment below in jwt.tsx\");\n  }\n  return jose.base64url.encode(\n    crypto\n      .createHash('sha256')\n      // TODO we should prefix a string like \"stack-audience-secret\" before we hash so you can't use `getKid(...)` to get the secret for eg. the \"kid\" audience if the same secret value is used\n      // Sadly doing this modification is a bit annoying as we need to leave the old keys to be valid for a little longer\n      .update(JSON.stringify([options.secret, options.audience]))\n      .digest()\n  );\n};\n\nexport function getKid(options: {\n  secret: string,\n}) {\n  return jose.base64url.encode(\n    crypto\n      .createHash('sha256')\n      .update(JSON.stringify([options.secret, \"kid\"]))  // TODO see above in getPerAudienceSecret\n      .digest()\n  ).slice(0, 12);\n}\n"],"mappings":"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","names":[]}

package/dist/esm/utils/locks.js

@@ -0,0 +1,57 @@
+// src/utils/locks.tsx
+import { Semaphore } from "async-mutex";
+var ReadWriteLock = class {
+  constructor() {
+    this.semaphore = new Semaphore(1);
+    this.readers = 0;
+    this.readersMutex = new 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();
+  }
+};
+export {
+  ReadWriteLock
+};
+//# sourceMappingURL=locks.js.map

package/dist/esm/utils/locks.js.map

@@ -0,0 +1 @@
+{"version":3,"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":";AAAA,SAAS,iBAAiB;AAInB,IAAM,gBAAN,MAAoB;AAAA,EAKzB,cAAc;AACZ,SAAK,YAAY,IAAI,UAAU,CAAC;AAChC,SAAK,UAAU;AACf,SAAK,eAAe,IAAI,UAAU,CAAC;AAAA,EACrC;AAAA,EAEA,MAAM,aAAgB,UAAuC;AAC3D,UAAM,KAAK,iBAAiB;AAC5B,QAAI;AACF,aAAO,MAAM,SAAS;AAAA,IACxB,UAAE;AACA,YAAM,KAAK,iBAAiB;AAAA,IAC9B;AAAA,EACF;AAAA,EAEA,MAAM,cAAiB,UAAuC;AAC5D,UAAM,KAAK,kBAAkB;AAC7B,QAAI;AACF,aAAO,MAAM,SAAS;AAAA,IACxB,UAAE;AACA,YAAM,KAAK,kBAAkB;AAAA,IAC/B;AAAA,EACF;AAAA,EAEA,MAAc,mBAAkC;AAE9C,UAAM,KAAK,aAAa,QAAQ;AAChC,QAAI;AACF,WAAK,WAAW;AAEhB,UAAI,KAAK,YAAY,GAAG;AACtB,cAAM,KAAK,UAAU,QAAQ;AAAA,MAC/B;AAAA,IACF,UAAE;AACA,WAAK,aAAa,QAAQ;AAAA,IAC5B;AAAA,EACF;AAAA,EAEA,MAAc,mBAAkC;AAE9C,UAAM,KAAK,aAAa,QAAQ;AAChC,QAAI;AACF,WAAK,WAAW;AAEhB,UAAI,KAAK,YAAY,GAAG;AACtB,aAAK,UAAU,QAAQ;AAAA,MACzB;AAAA,IACF,UAAE;AACA,WAAK,aAAa,QAAQ;AAAA,IAC5B;AAAA,EACF;AAAA,EAEA,MAAc,oBAAmC;AAE/C,UAAM,KAAK,UAAU,QAAQ;AAAA,EAC/B;AAAA,EAEA,MAAc,oBAAmC;AAE/C,SAAK,UAAU,QAAQ;AAAA,EACzB;AACF;","names":[]}

package/dist/esm/utils/maps.js

@@ -0,0 +1,181 @@
+// src/utils/maps.tsx
+import { Result } from "./results";
+var WeakRefIfAvailable = class {
+  constructor(value) {
+    if (typeof WeakRef === "undefined") {
+      this._ref = { deref: () => value };
+    } else {
+      this._ref = new WeakRef(value);
+    }
+  }
+  deref() {
+    return this._ref.deref();
+  }
+};
+var _a, _b;
+var IterableWeakMap = class {
+  constructor(entries) {
+    this[_a] = "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 existing = this._weakMap.get(key);
+    const updated = { value, keyRef: existing?.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);
+  }
+  *[(_b = Symbol.iterator, _a = Symbol.toStringTag, _b)]() {
+    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];
+      }
+    }
+  }
+};
+var _a2, _b2;
+var MaybeWeakMap = class {
+  constructor(entries) {
+    this[_a2] = "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);
+    }
+  }
+  *[(_b2 = Symbol.iterator, _a2 = Symbol.toStringTag, _b2)]() {
+    yield* this._primitiveMap;
+    yield* this._weakMap;
+  }
+};
+var _a3, _b3;
+var DependenciesMap = class {
+  constructor() {
+    this._inner = { map: new MaybeWeakMap(), hasValue: false, value: void 0 };
+    this[_a3] = "DependenciesMap";
+  }
+  _valueToResult(inner) {
+    if (inner.hasValue) {
+      return Result.ok(inner.value);
+    } else {
+      return 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 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 Result.or(this._unwrapFromInner(dependencies, this._inner), void 0);
+  }
+  set(dependencies, value) {
+    this._setInInner(dependencies, Result.ok(value), this._inner);
+    return this;
+  }
+  delete(dependencies) {
+    return this._setInInner(dependencies, 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 };
+  }
+  *[(_b3 = Symbol.iterator, _a3 = Symbol.toStringTag, _b3)]() {
+    yield* this._iterateInner([], this._inner);
+  }
+};
+export {
+  DependenciesMap,
+  IterableWeakMap,
+  MaybeWeakMap,
+  WeakRefIfAvailable
+};
+//# sourceMappingURL=maps.js.map

package/dist/esm/utils/maps.js.map

@@ -0,0 +1 @@
+{"version":3,"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}\nundefined?.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}\nundefined?.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}\nundefined?.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}\nundefined?.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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","names":["_a","_b"]}

package/dist/esm/utils/math.js

@@ -0,0 +1,8 @@
+// src/utils/math.tsx
+function remainder(n, d) {
+  return (n % d + Math.abs(d)) % d;
+}
+export {
+  remainder
+};
+//# sourceMappingURL=math.js.map

package/dist/esm/utils/math.js.map

@@ -0,0 +1 @@
+{"version":3,"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}\nundefined?.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":";AAGO,SAAS,UAAU,GAAW,GAAmB;AACtD,UAAS,IAAI,IAAK,KAAK,IAAI,CAAC,KAAK;AACnC;","names":[]}

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

@@ -0,0 +1,42 @@
+// src/utils/node-http.tsx
+import { IncomingMessage, ServerResponse } from "http";
+import { getRelativePart } from "./urls";
+var ServerResponseWithBodyChunks = class extends ServerResponse {
+  constructor() {
+    super(...arguments);
+    this.bodyChunks = [];
+  }
+  // note: we actually override this, even though it's private in the parent
+  _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 IncomingMessage({
+    encrypted: options.originalUrl?.protocol === "https:"
+    // trick frameworks into believing this is an HTTPS request
+  });
+  incomingMessage.httpVersionMajor = 1;
+  incomingMessage.httpVersionMinor = 1;
+  incomingMessage.httpVersion = "1.1";
+  incomingMessage.method = options.method;
+  incomingMessage.url = getRelativePart(options.url);
+  incomingMessage.originalUrl = options.originalUrl && 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);
+  const serverResponse = new ServerResponseWithBodyChunks(incomingMessage);
+  return [incomingMessage, serverResponse];
+}
+export {
+  createNodeHttpServerDuplex
+};
+//# sourceMappingURL=node-http.js.map

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

@@ -0,0 +1 @@
+{"version":3,"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":";AAAA,SAAS,iBAAiB,sBAAsB;AAChD,SAAS,uBAAuB;AAEhC,IAAM,+BAAN,cAA2C,eAAe;AAAA,EAA1D;AAAA;AACE,sBAA2B,CAAC;AAAA;AAAA;AAAA,EAG5B,MAAM,MAAc,UAA0B,UAAgC,YAAqB;AACjG,QAAI,OAAO,aAAa,YAAY;AAClC,iBAAW;AACX,iBAAW;AAAA,IACb;AACA,UAAM,gBAAgB,IAAI,WAAW,OAAO,KAAK,MAAM,QAAQ,CAAC;AAChE,SAAK,WAAW,KAAK,aAAa;AAClC,eAAW;AAAA,EACb;AACF;AAEA,eAAsB,2BAA2B,SAMY;AAI3D,QAAM,kBAAkB,IAAI,gBAAgB;AAAA,IAC1C,WAAW,QAAQ,aAAa,aAAa;AAAA;AAAA,EAC/C,CAAQ;AACR,kBAAgB,mBAAmB;AACnC,kBAAgB,mBAAmB;AACnC,kBAAgB,cAAc;AAC9B,kBAAgB,SAAS,QAAQ;AACjC,kBAAgB,MAAM,gBAAgB,QAAQ,GAAG;AACjD,EAAC,gBAAwB,cAAc,QAAQ,eAAe,gBAAgB,QAAQ,WAAW;AACjG,QAAM,aAAa,CAAC,GAAG,QAAQ,QAAQ,QAAQ,CAAC,EAAE,KAAK;AACvD,EAAC,gBAAwB,gBAAgB,YAAY,WAAW,MAAM;AACtE,kBAAgB,KAAK,OAAO,KAAK,QAAQ,IAAI,CAAC;AAC9C,kBAAgB,WAAW;AAC3B,kBAAgB,KAAK,IAAI;AAEzB,QAAM,iBAAiB,IAAI,6BAA6B,eAAe;AAEvE,SAAO,CAAC,iBAAiB,cAAc;AACzC;","names":[]}

package/dist/esm/utils/numbers.js

@@ -0,0 +1,32 @@
+// src/utils/numbers.tsx
+var magnitudes = [
+  [1e15, "trln"],
+  [1e12, "bln"],
+  [1e9, "bn"],
+  [1e6, "M"],
+  [1e3, "k"]
+];
+function prettyPrintWithMagnitudes(num) {
+  if (typeof num !== "number") throw new Error("Expected a number");
+  if (Number.isNaN(num)) return "NaN";
+  if (num < 0) return "-" + prettyPrintWithMagnitudes(-num);
+  if (!Number.isFinite(num)) return "\u221E";
+  for (const [magnitude, suffix] of magnitudes) {
+    if (num >= magnitude) {
+      return toFixedMax(num / magnitude, 1) + suffix;
+    }
+  }
+  return toFixedMax(num, 1);
+}
+function toFixedMax(num, maxDecimals) {
+  return num.toFixed(maxDecimals).replace(/\.?0+$/, "");
+}
+function numberCompare(a, b) {
+  return Math.sign(a - b);
+}
+export {
+  numberCompare,
+  prettyPrintWithMagnitudes,
+  toFixedMax
+};
+//# sourceMappingURL=numbers.js.map

package/dist/esm/utils/numbers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/numbers.tsx"],"sourcesContent":["const magnitudes = [\n  [1_000_000_000_000_000, \"trln\"],\n  [1_000_000_000_000, \"bln\"],\n  [1_000_000_000, \"bn\"],\n  [1_000_000, \"M\"],\n  [1_000, \"k\"],\n] as const;\n\nexport function prettyPrintWithMagnitudes(num: number): string {\n  if (typeof num !== \"number\") throw new Error(\"Expected a number\");\n  if (Number.isNaN(num)) return \"NaN\";\n  if (num < 0) return \"-\" + prettyPrintWithMagnitudes(-num);\n  if (!Number.isFinite(num)) return \"∞\";\n\n  for (const [magnitude, suffix] of magnitudes) {\n    if (num >= magnitude) {\n      return toFixedMax(num / magnitude, 1) + suffix;\n    }\n  }\n  return toFixedMax(num, 1); // Handle numbers less than 1,000 without suffix.\n}\nundefined?.test(\"prettyPrintWithMagnitudes\", ({ expect }) => {\n  // Test different magnitudes\n  expect(prettyPrintWithMagnitudes(1000)).toBe(\"1k\");\n  expect(prettyPrintWithMagnitudes(1500)).toBe(\"1.5k\");\n  expect(prettyPrintWithMagnitudes(1000000)).toBe(\"1M\");\n  expect(prettyPrintWithMagnitudes(1500000)).toBe(\"1.5M\");\n  expect(prettyPrintWithMagnitudes(1000000000)).toBe(\"1bn\");\n  expect(prettyPrintWithMagnitudes(1500000000)).toBe(\"1.5bn\");\n  expect(prettyPrintWithMagnitudes(1000000000000)).toBe(\"1bln\");\n  expect(prettyPrintWithMagnitudes(1500000000000)).toBe(\"1.5bln\");\n  expect(prettyPrintWithMagnitudes(1000000000000000)).toBe(\"1trln\");\n  expect(prettyPrintWithMagnitudes(1500000000000000)).toBe(\"1.5trln\");\n  // Test small numbers\n  expect(prettyPrintWithMagnitudes(100)).toBe(\"100\");\n  expect(prettyPrintWithMagnitudes(0)).toBe(\"0\");\n  expect(prettyPrintWithMagnitudes(0.5)).toBe(\"0.5\");\n  // Test negative numbers\n  expect(prettyPrintWithMagnitudes(-1000)).toBe(\"-1k\");\n  expect(prettyPrintWithMagnitudes(-1500000)).toBe(\"-1.5M\");\n  // Test special cases\n  expect(prettyPrintWithMagnitudes(NaN)).toBe(\"NaN\");\n  expect(prettyPrintWithMagnitudes(Infinity)).toBe(\"∞\");\n  expect(prettyPrintWithMagnitudes(-Infinity)).toBe(\"-∞\");\n});\n\nexport function toFixedMax(num: number, maxDecimals: number): string {\n  return num.toFixed(maxDecimals).replace(/\\.?0+$/, \"\");\n}\nundefined?.test(\"toFixedMax\", ({ expect }) => {\n  expect(toFixedMax(1, 2)).toBe(\"1\");\n  expect(toFixedMax(1.2, 2)).toBe(\"1.2\");\n  expect(toFixedMax(1.23, 2)).toBe(\"1.23\");\n  expect(toFixedMax(1.234, 2)).toBe(\"1.23\");\n  expect(toFixedMax(1.0, 2)).toBe(\"1\");\n  expect(toFixedMax(1.20, 2)).toBe(\"1.2\");\n  expect(toFixedMax(0, 2)).toBe(\"0\");\n});\n\nexport function numberCompare(a: number, b: number): number {\n  return Math.sign(a - b);\n}\nundefined?.test(\"numberCompare\", ({ expect }) => {\n  expect(numberCompare(1, 2)).toBe(-1);\n  expect(numberCompare(2, 1)).toBe(1);\n  expect(numberCompare(1, 1)).toBe(0);\n  expect(numberCompare(0, 0)).toBe(0);\n  expect(numberCompare(-1, -2)).toBe(1);\n  expect(numberCompare(-2, -1)).toBe(-1);\n  expect(numberCompare(-1, 1)).toBe(-1);\n  expect(numberCompare(1, -1)).toBe(1);\n});\n"],"mappings":";AAAA,IAAM,aAAa;AAAA,EACjB,CAAC,MAAuB,MAAM;AAAA,EAC9B,CAAC,MAAmB,KAAK;AAAA,EACzB,CAAC,KAAe,IAAI;AAAA,EACpB,CAAC,KAAW,GAAG;AAAA,EACf,CAAC,KAAO,GAAG;AACb;AAEO,SAAS,0BAA0B,KAAqB;AAC7D,MAAI,OAAO,QAAQ,SAAU,OAAM,IAAI,MAAM,mBAAmB;AAChE,MAAI,OAAO,MAAM,GAAG,EAAG,QAAO;AAC9B,MAAI,MAAM,EAAG,QAAO,MAAM,0BAA0B,CAAC,GAAG;AACxD,MAAI,CAAC,OAAO,SAAS,GAAG,EAAG,QAAO;AAElC,aAAW,CAAC,WAAW,MAAM,KAAK,YAAY;AAC5C,QAAI,OAAO,WAAW;AACpB,aAAO,WAAW,MAAM,WAAW,CAAC,IAAI;AAAA,IAC1C;AAAA,EACF;AACA,SAAO,WAAW,KAAK,CAAC;AAC1B;AA0BO,SAAS,WAAW,KAAa,aAA6B;AACnE,SAAO,IAAI,QAAQ,WAAW,EAAE,QAAQ,UAAU,EAAE;AACtD;AAWO,SAAS,cAAc,GAAW,GAAmB;AAC1D,SAAO,KAAK,KAAK,IAAI,CAAC;AACxB;","names":[]}

package/dist/esm/utils/oauth.js

@@ -0,0 +1,10 @@
+// src/utils/oauth.tsx
+var standardProviders = ["google", "github", "microsoft", "spotify", "facebook", "discord", "gitlab", "bitbucket", "linkedin", "apple", "x"];
+var sharedProviders = ["google", "github", "microsoft", "spotify"];
+var allProviders = standardProviders;
+export {
+  allProviders,
+  sharedProviders,
+  standardProviders
+};
+//# sourceMappingURL=oauth.js.map

package/dist/esm/utils/oauth.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/oauth.tsx"],"sourcesContent":["export const standardProviders = [\"google\", \"github\", \"microsoft\", \"spotify\", \"facebook\", \"discord\", \"gitlab\", \"bitbucket\", \"linkedin\", \"apple\", \"x\"] as const;\n// No more shared providers should be added except for special cases\nexport const sharedProviders = [\"google\", \"github\", \"microsoft\", \"spotify\"] as const;\nexport const allProviders = standardProviders;\n\nexport type ProviderType = typeof allProviders[number];\nexport type StandardProviderType = typeof standardProviders[number];\nexport type SharedProviderType = typeof sharedProviders[number];\n"],"mappings":";AAAO,IAAM,oBAAoB,CAAC,UAAU,UAAU,aAAa,WAAW,YAAY,WAAW,UAAU,aAAa,YAAY,SAAS,GAAG;AAE7I,IAAM,kBAAkB,CAAC,UAAU,UAAU,aAAa,SAAS;AACnE,IAAM,eAAe;","names":[]}

package/dist/esm/utils/objects.js

@@ -0,0 +1,177 @@
+// src/utils/objects.tsx
+import { StackAssertionError } from "./errors";
+import { identity } from "./functions";
+import { stringCompare } from "./strings";
+function isNotNull(value) {
+  return value !== null && value !== void 0;
+}
+function deepPlainEquals(obj1, obj2, options = {}) {
+  if (typeof obj1 !== typeof obj2) return false;
+  if (obj1 === obj2) return true;
+  switch (typeof obj1) {
+    case "object": {
+      if (!obj1 || !obj2) return false;
+      if (Array.isArray(obj1) || Array.isArray(obj2)) {
+        if (!Array.isArray(obj1) || !Array.isArray(obj2)) return false;
+        if (obj1.length !== obj2.length) return false;
+        return obj1.every((v, i) => deepPlainEquals(v, obj2[i], options));
+      }
+      const entries1 = Object.entries(obj1).filter(([k, v]) => !options.ignoreUndefinedValues || v !== void 0);
+      const entries2 = Object.entries(obj2).filter(([k, v]) => !options.ignoreUndefinedValues || v !== void 0);
+      if (entries1.length !== entries2.length) return false;
+      return entries1.every(([k, v1]) => {
+        const e2 = entries2.find(([k2]) => k === k2);
+        if (!e2) return false;
+        return deepPlainEquals(v1, e2[1], options);
+      });
+    }
+    case "undefined":
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "symbol":
+    case "function": {
+      return false;
+    }
+    default: {
+      throw new Error("Unexpected typeof " + typeof obj1);
+    }
+  }
+}
+function isCloneable(obj) {
+  return typeof obj !== "symbol" && typeof obj !== "function";
+}
+function shallowClone(obj) {
+  if (!isCloneable(obj)) throw new StackAssertionError("shallowClone does not support symbols or functions", { obj });
+  if (Array.isArray(obj)) return obj.map(identity);
+  return { ...obj };
+}
+function deepPlainClone(obj) {
+  if (typeof obj === "function") throw new StackAssertionError("deepPlainClone does not support functions");
+  if (typeof obj === "symbol") throw new StackAssertionError("deepPlainClone does not support symbols");
+  if (typeof obj !== "object" || !obj) return obj;
+  if (Array.isArray(obj)) return obj.map(deepPlainClone);
+  return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, deepPlainClone(v)]));
+}
+function deepMerge(baseObj, mergeObj) {
+  if ([baseObj, mergeObj, ...Object.values(baseObj), ...Object.values(mergeObj)].some((o) => !isCloneable(o))) throw new StackAssertionError("deepMerge does not support functions or symbols", { baseObj, mergeObj });
+  const res = shallowClone(baseObj);
+  for (const [key, mergeValue] of Object.entries(mergeObj)) {
+    if (has(res, key)) {
+      const baseValue = get(res, key);
+      if (isObjectLike(baseValue) && isObjectLike(mergeValue)) {
+        set(res, key, deepMerge(baseValue, mergeValue));
+        continue;
+      }
+    }
+    set(res, key, mergeValue);
+  }
+  return res;
+}
+function typedEntries(obj) {
+  return Object.entries(obj);
+}
+function typedFromEntries(entries) {
+  return Object.fromEntries(entries);
+}
+function typedKeys(obj) {
+  return Object.keys(obj);
+}
+function typedValues(obj) {
+  return Object.values(obj);
+}
+function typedAssign(target, source) {
+  return Object.assign(target, source);
+}
+function filterUndefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0));
+}
+function filterUndefinedOrNull(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0 && v !== null));
+}
+function deepFilterUndefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0).map(([k, v]) => [k, isObjectLike(v) ? deepFilterUndefined(v) : v]));
+}
+function pick(obj, keys) {
+  return Object.fromEntries(Object.entries(obj).filter(([k]) => keys.includes(k)));
+}
+function omit(obj, keys) {
+  if (!Array.isArray(keys)) throw new StackAssertionError("omit: keys must be an array", { obj, keys });
+  return Object.fromEntries(Object.entries(obj).filter(([k]) => !keys.includes(k)));
+}
+function split(obj, keys) {
+  return [pick(obj, keys), omit(obj, keys)];
+}
+function mapValues(obj, fn) {
+  if (Array.isArray(obj)) {
+    return obj.map((v) => fn(v));
+  }
+  return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, fn(v)]));
+}
+function sortKeys(obj) {
+  if (Array.isArray(obj)) {
+    return [...obj];
+  }
+  return Object.fromEntries(Object.entries(obj).sort(([a], [b]) => stringCompare(a, b)));
+}
+function deepSortKeys(obj) {
+  return sortKeys(mapValues(obj, (v) => isObjectLike(v) ? deepSortKeys(v) : v));
+}
+function set(obj, key, value) {
+  Object.defineProperty(obj, key, { value, writable: true, configurable: true, enumerable: true });
+}
+function get(obj, key) {
+  const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+  if (!descriptor) throw new StackAssertionError(`get: key ${String(key)} does not exist`, { obj, key });
+  return descriptor.value;
+}
+function getOrUndefined(obj, key) {
+  return has(obj, key) ? get(obj, key) : void 0;
+}
+function has(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function hasAndNotUndefined(obj, key) {
+  return has(obj, key) && get(obj, key) !== void 0;
+}
+function deleteKey(obj, key) {
+  if (has(obj, key)) {
+    Reflect.deleteProperty(obj, key);
+  } else {
+    throw new StackAssertionError(`deleteKey: key ${String(key)} does not exist`, { obj, key });
+  }
+}
+function isObjectLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null;
+}
+export {
+  deepFilterUndefined,
+  deepMerge,
+  deepPlainClone,
+  deepPlainEquals,
+  deepSortKeys,
+  deleteKey,
+  filterUndefined,
+  filterUndefinedOrNull,
+  get,
+  getOrUndefined,
+  has,
+  hasAndNotUndefined,
+  isCloneable,
+  isNotNull,
+  isObjectLike,
+  mapValues,
+  omit,
+  pick,
+  set,
+  shallowClone,
+  sortKeys,
+  split,
+  typedAssign,
+  typedEntries,
+  typedFromEntries,
+  typedKeys,
+  typedValues
+};
+//# sourceMappingURL=objects.js.map