@stackframe/stack-shared 2.8.8 → 2.8.11

package/dist/utils/math.js

@@ -1,18 +1,33 @@
-/**
- * Similar to the modulo operator, but always returns a positive number (even when the input is negative).
- */
-export function remainder(n, d) {
-    return ((n % d) + Math.abs(d)) % d;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/math.tsx
+var math_exports = {};
+__export(math_exports, {
+  remainder: () => remainder
+});
+module.exports = __toCommonJS(math_exports);
+function remainder(n, d) {
+  return (n % d + Math.abs(d)) % d;
 }
-import.meta.vitest?.test("remainder", ({ expect }) => {
-    expect(remainder(10, 3)).toBe(1);
-    expect(remainder(10, 5)).toBe(0);
-    expect(remainder(10, 7)).toBe(3);
-    // Test with negative numbers
-    expect(remainder(-10, 3)).toBe(2);
-    expect(remainder(-5, 2)).toBe(1);
-    expect(remainder(-7, 4)).toBe(1);
-    // Test with decimal numbers
-    expect(remainder(10.5, 3)).toBeCloseTo(1.5);
-    expect(remainder(-10.5, 3)).toBeCloseTo(1.5);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  remainder
 });
+//# sourceMappingURL=math.js.map

package/dist/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":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGO,SAAS,UAAU,GAAW,GAAmB;AACtD,UAAS,IAAI,IAAK,KAAK,IAAI,CAAC,KAAK;AACnC;","names":[]}

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

@@ -0,0 +1,15 @@
+import { IncomingMessage, ServerResponse } from 'http';
+
+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]>;
+
+export { createNodeHttpServerDuplex };

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

@@ -1,15 +1,15 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { IncomingMessage, ServerResponse } from "http";
+import { IncomingMessage, ServerResponse } from 'http';
+
 declare class ServerResponseWithBodyChunks extends ServerResponse {
     bodyChunks: Uint8Array[];
     _send(data: string, encoding: BufferEncoding, callback?: (() => void) | null, byteLength?: number): void;
 }
-export declare function createNodeHttpServerDuplex(options: {
+declare function createNodeHttpServerDuplex(options: {
     method: string;
     originalUrl?: URL;
     url: URL;
     headers: Headers;
     body: Uint8Array;
 }): Promise<[IncomingMessage, ServerResponseWithBodyChunks]>;
-export {};
+
+export { createNodeHttpServerDuplex };

package/dist/utils/node-http.js

@@ -1,38 +1,67 @@
-import { IncomingMessage, ServerResponse } from "http";
-import { getRelativePart } from "./urls";
-class ServerResponseWithBodyChunks extends ServerResponse {
-    constructor() {
-        super(...arguments);
-        this.bodyChunks = [];
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/node-http.tsx
+var node_http_exports = {};
+__export(node_http_exports, {
+  createNodeHttpServerDuplex: () => createNodeHttpServerDuplex
+});
+module.exports = __toCommonJS(node_http_exports);
+var import_http = require("http");
+var import_urls = require("./urls");
+var ServerResponseWithBodyChunks = class extends import_http.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";
     }
-    // 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?.();
-    }
-}
-export async function createNodeHttpServerDuplex(options) {
-    // See https://github.com/nodejs/node/blob/main/lib/_http_incoming.js
-    // and https://github.com/nodejs/node/blob/main/lib/_http_common.js (particularly the `parserXyz` functions)
-    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); // originalUrl is an extension used by some servers; for example, oidc-provider reads it to construct the paths for the .well-known/openid-configuration
-    const rawHeaders = [...options.headers.entries()].flat();
-    incomingMessage._addHeaderLines(rawHeaders, rawHeaders.length);
-    incomingMessage.push(Buffer.from(options.body));
-    incomingMessage.complete = true;
-    incomingMessage.push(null); // to emit end event, see: https://github.com/nodejs/node/blob/4cf6fabce20eb3050c5b543d249e931ea3d3cad5/lib/_http_common.js#L150
-    const serverResponse = new ServerResponseWithBodyChunks(incomingMessage);
-    return [incomingMessage, serverResponse];
+    const encodedBuffer = new Uint8Array(Buffer.from(data, encoding));
+    this.bodyChunks.push(encodedBuffer);
+    callback?.();
+  }
+};
+async function createNodeHttpServerDuplex(options) {
+  const incomingMessage = new import_http.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 = (0, import_urls.getRelativePart)(options.url);
+  incomingMessage.originalUrl = options.originalUrl && (0, import_urls.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];
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNodeHttpServerDuplex
+});
+//# sourceMappingURL=node-http.js.map

package/dist/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;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAgD;AAChD,kBAAgC;AAEhC,IAAM,+BAAN,cAA2C,2BAAe;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,4BAAgB;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,UAAM,6BAAgB,QAAQ,GAAG;AACjD,EAAC,gBAAwB,cAAc,QAAQ,mBAAe,6BAAgB,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/utils/numbers.d.cts

@@ -0,0 +1,5 @@
+declare function prettyPrintWithMagnitudes(num: number): string;
+declare function toFixedMax(num: number, maxDecimals: number): string;
+declare function numberCompare(a: number, b: number): number;
+
+export { numberCompare, prettyPrintWithMagnitudes, toFixedMax };

package/dist/utils/numbers.d.ts

@@ -1,3 +1,5 @@
-export declare function prettyPrintWithMagnitudes(num: number): string;
-export declare function toFixedMax(num: number, maxDecimals: number): string;
-export declare function numberCompare(a: number, b: number): number;
+declare function prettyPrintWithMagnitudes(num: number): string;
+declare function toFixedMax(num: number, maxDecimals: number): string;
+declare function numberCompare(a: number, b: number): number;
+
+export { numberCompare, prettyPrintWithMagnitudes, toFixedMax };

package/dist/utils/numbers.js

@@ -1,72 +1,59 @@
-const magnitudes = [
-    [1000000000000000, "trln"],
-    [1000000000000, "bln"],
-    [1000000000, "bn"],
-    [1000000, "M"],
-    [1000, "k"],
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/numbers.tsx
+var numbers_exports = {};
+__export(numbers_exports, {
+  numberCompare: () => numberCompare,
+  prettyPrintWithMagnitudes: () => prettyPrintWithMagnitudes,
+  toFixedMax: () => toFixedMax
+});
+module.exports = __toCommonJS(numbers_exports);
+var magnitudes = [
+  [1e15, "trln"],
+  [1e12, "bln"],
+  [1e9, "bn"],
+  [1e6, "M"],
+  [1e3, "k"]
 ];
-export 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 "∞";
-    for (const [magnitude, suffix] of magnitudes) {
-        if (num >= magnitude) {
-            return toFixedMax(num / magnitude, 1) + suffix;
-        }
+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); // Handle numbers less than 1,000 without suffix.
+  }
+  return toFixedMax(num, 1);
 }
-import.meta.vitest?.test("prettyPrintWithMagnitudes", ({ expect }) => {
-    // Test different magnitudes
-    expect(prettyPrintWithMagnitudes(1000)).toBe("1k");
-    expect(prettyPrintWithMagnitudes(1500)).toBe("1.5k");
-    expect(prettyPrintWithMagnitudes(1000000)).toBe("1M");
-    expect(prettyPrintWithMagnitudes(1500000)).toBe("1.5M");
-    expect(prettyPrintWithMagnitudes(1000000000)).toBe("1bn");
-    expect(prettyPrintWithMagnitudes(1500000000)).toBe("1.5bn");
-    expect(prettyPrintWithMagnitudes(1000000000000)).toBe("1bln");
-    expect(prettyPrintWithMagnitudes(1500000000000)).toBe("1.5bln");
-    expect(prettyPrintWithMagnitudes(1000000000000000)).toBe("1trln");
-    expect(prettyPrintWithMagnitudes(1500000000000000)).toBe("1.5trln");
-    // Test small numbers
-    expect(prettyPrintWithMagnitudes(100)).toBe("100");
-    expect(prettyPrintWithMagnitudes(0)).toBe("0");
-    expect(prettyPrintWithMagnitudes(0.5)).toBe("0.5");
-    // Test negative numbers
-    expect(prettyPrintWithMagnitudes(-1000)).toBe("-1k");
-    expect(prettyPrintWithMagnitudes(-1500000)).toBe("-1.5M");
-    // Test special cases
-    expect(prettyPrintWithMagnitudes(NaN)).toBe("NaN");
-    expect(prettyPrintWithMagnitudes(Infinity)).toBe("∞");
-    expect(prettyPrintWithMagnitudes(-Infinity)).toBe("-∞");
-});
-export function toFixedMax(num, maxDecimals) {
-    return num.toFixed(maxDecimals).replace(/\.?0+$/, "");
+function toFixedMax(num, maxDecimals) {
+  return num.toFixed(maxDecimals).replace(/\.?0+$/, "");
 }
-import.meta.vitest?.test("toFixedMax", ({ expect }) => {
-    expect(toFixedMax(1, 2)).toBe("1");
-    expect(toFixedMax(1.2, 2)).toBe("1.2");
-    expect(toFixedMax(1.23, 2)).toBe("1.23");
-    expect(toFixedMax(1.234, 2)).toBe("1.23");
-    expect(toFixedMax(1.0, 2)).toBe("1");
-    expect(toFixedMax(1.20, 2)).toBe("1.2");
-    expect(toFixedMax(0, 2)).toBe("0");
-});
-export function numberCompare(a, b) {
-    return Math.sign(a - b);
+function numberCompare(a, b) {
+  return Math.sign(a - b);
 }
-import.meta.vitest?.test("numberCompare", ({ expect }) => {
-    expect(numberCompare(1, 2)).toBe(-1);
-    expect(numberCompare(2, 1)).toBe(1);
-    expect(numberCompare(1, 1)).toBe(0);
-    expect(numberCompare(0, 0)).toBe(0);
-    expect(numberCompare(-1, -2)).toBe(1);
-    expect(numberCompare(-2, -1)).toBe(-1);
-    expect(numberCompare(-1, 1)).toBe(-1);
-    expect(numberCompare(1, -1)).toBe(1);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  numberCompare,
+  prettyPrintWithMagnitudes,
+  toFixedMax
 });
+//# sourceMappingURL=numbers.js.map

package/dist/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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;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/utils/oauth.d.cts

@@ -0,0 +1,8 @@
+declare const standardProviders: readonly ["google", "github", "microsoft", "spotify", "facebook", "discord", "gitlab", "bitbucket", "linkedin", "apple", "x"];
+declare const sharedProviders: readonly ["google", "github", "microsoft", "spotify"];
+declare const allProviders: readonly ["google", "github", "microsoft", "spotify", "facebook", "discord", "gitlab", "bitbucket", "linkedin", "apple", "x"];
+type ProviderType = typeof allProviders[number];
+type StandardProviderType = typeof standardProviders[number];
+type SharedProviderType = typeof sharedProviders[number];
+
+export { type ProviderType, type SharedProviderType, type StandardProviderType, allProviders, sharedProviders, standardProviders };

package/dist/utils/oauth.d.ts

@@ -1,6 +1,8 @@
-export declare const standardProviders: readonly ["google", "github", "microsoft", "spotify", "facebook", "discord", "gitlab", "bitbucket", "linkedin", "apple", "x"];
-export declare const sharedProviders: readonly ["google", "github", "microsoft", "spotify"];
-export declare const allProviders: readonly ["google", "github", "microsoft", "spotify", "facebook", "discord", "gitlab", "bitbucket", "linkedin", "apple", "x"];
-export type ProviderType = typeof allProviders[number];
-export type StandardProviderType = typeof standardProviders[number];
-export type SharedProviderType = typeof sharedProviders[number];
+declare const standardProviders: readonly ["google", "github", "microsoft", "spotify", "facebook", "discord", "gitlab", "bitbucket", "linkedin", "apple", "x"];
+declare const sharedProviders: readonly ["google", "github", "microsoft", "spotify"];
+declare const allProviders: readonly ["google", "github", "microsoft", "spotify", "facebook", "discord", "gitlab", "bitbucket", "linkedin", "apple", "x"];
+type ProviderType = typeof allProviders[number];
+type StandardProviderType = typeof standardProviders[number];
+type SharedProviderType = typeof sharedProviders[number];
+
+export { type ProviderType, type SharedProviderType, type StandardProviderType, allProviders, sharedProviders, standardProviders };

package/dist/utils/oauth.js

@@ -1,4 +1,37 @@
-export const standardProviders = ["google", "github", "microsoft", "spotify", "facebook", "discord", "gitlab", "bitbucket", "linkedin", "apple", "x"];
-// No more shared providers should be added except for special cases
-export const sharedProviders = ["google", "github", "microsoft", "spotify"];
-export const allProviders = standardProviders;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/oauth.tsx
+var oauth_exports = {};
+__export(oauth_exports, {
+  allProviders: () => allProviders,
+  sharedProviders: () => sharedProviders,
+  standardProviders: () => standardProviders
+});
+module.exports = __toCommonJS(oauth_exports);
+var standardProviders = ["google", "github", "microsoft", "spotify", "facebook", "discord", "gitlab", "bitbucket", "linkedin", "apple", "x"];
+var sharedProviders = ["google", "github", "microsoft", "spotify"];
+var allProviders = standardProviders;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  allProviders,
+  sharedProviders,
+  standardProviders
+});
+//# sourceMappingURL=oauth.js.map

package/dist/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":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;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/utils/objects.d.cts

@@ -0,0 +1,69 @@
+declare function isNotNull<T>(value: T): value is NonNullable<T>;
+type DeepPartial<T> = T extends object ? (T extends (infer E)[] ? T : {
+    [P in keyof T]?: DeepPartial<T[P]>;
+}) : T;
+type DeepRequired<T> = T extends object ? (T extends (infer E)[] ? T : {
+    [P in keyof T]-?: DeepRequired<T[P]>;
+}) : T;
+/**
+ * Assumes both objects are primitives, arrays, or non-function plain objects, and compares them deeply.
+ *
+ * Note that since they are assumed to be plain objects, this function does not compare prototypes.
+ */
+declare function deepPlainEquals<T>(obj1: T, obj2: unknown, options?: {
+    ignoreUndefinedValues?: boolean;
+}): obj2 is T;
+declare function isCloneable<T>(obj: T): obj is Exclude<T, symbol | Function>;
+declare function shallowClone<T extends object>(obj: T): T;
+declare function deepPlainClone<T>(obj: T): T;
+type DeepMerge<T, U> = Omit<T, keyof U> & Omit<U, keyof T> & DeepMergeInner<Pick<T, keyof U & keyof T>, Pick<U, keyof U & keyof T>>;
+type DeepMergeInner<T, U> = {
+    [K in keyof U]-?: undefined extends U[K] ? K extends keyof T ? T[K] extends object ? Exclude<U[K], undefined> extends object ? DeepMerge<T[K], Exclude<U[K], undefined>> : T[K] | Exclude<U[K], undefined> : T[K] | Exclude<U[K], undefined> : Exclude<U[K], undefined> : K extends keyof T ? T[K] extends object ? U[K] extends object ? DeepMerge<T[K], U[K]> : U[K] : U[K] : U[K];
+};
+declare function deepMerge<T extends {}, U extends {}>(baseObj: T, mergeObj: U): DeepMerge<T, U>;
+declare function typedEntries<T extends {}>(obj: T): [keyof T, T[keyof T]][];
+declare function typedFromEntries<K extends PropertyKey, V>(entries: (readonly [K, V])[]): Record<K, V>;
+declare function typedKeys<T extends {}>(obj: T): (keyof T)[];
+declare function typedValues<T extends {}>(obj: T): T[keyof T][];
+declare function typedAssign<T extends {}, U extends {}>(target: T, source: U): T & U;
+type FilterUndefined<T> = {
+    [k in keyof T as (undefined extends T[k] ? (T[k] extends undefined | void ? never : k) : never)]+?: T[k] & ({} | null);
+} & {
+    [k in keyof T as (undefined extends T[k] ? never : k)]: T[k] & ({} | null);
+};
+/**
+ * Returns a new object with all undefined values removed. Useful when spreading optional parameters on an object, as
+ * TypeScript's `Partial<XYZ>` type allows `undefined` values.
+ */
+declare function filterUndefined<T extends object>(obj: T): FilterUndefined<T>;
+type FilterUndefinedOrNull<T> = FilterUndefined<{
+    [k in keyof T]: null extends T[k] ? NonNullable<T[k]> | undefined : T[k];
+}>;
+/**
+ * Returns a new object with all undefined and null values removed. Useful when spreading optional parameters on an object, as
+ * TypeScript's `Partial<XYZ>` type allows `undefined` values.
+ */
+declare function filterUndefinedOrNull<T extends object>(obj: T): FilterUndefinedOrNull<T>;
+type DeepFilterUndefined<T> = T extends object ? FilterUndefined<{
+    [K in keyof T]: DeepFilterUndefined<T[K]>;
+}> : T;
+declare function deepFilterUndefined<T extends object>(obj: T): DeepFilterUndefined<T>;
+declare function pick<T extends {}, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+declare function omit<T extends {}, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+declare function split<T extends {}, K extends keyof T>(obj: T, keys: K[]): [Pick<T, K>, Omit<T, K>];
+declare function mapValues<T extends object, U>(obj: T, fn: (value: T extends (infer E)[] ? E : T[keyof T]) => U): Record<keyof T, U>;
+declare function sortKeys<T extends object>(obj: T): T;
+declare function deepSortKeys<T extends object>(obj: T): T;
+declare function set<T extends object, K extends keyof T>(obj: T, key: K, value: T[K]): void;
+declare function get<T extends object, K extends keyof T>(obj: T, key: K): T[K];
+declare function getOrUndefined<T extends object, K extends keyof T>(obj: T, key: K): T[K] | undefined;
+declare function has<T extends object, K extends keyof T>(obj: T, key: K): obj is T & {
+    [k in K]: unknown;
+};
+declare function hasAndNotUndefined<T extends object, K extends keyof T>(obj: T, key: K): obj is T & {
+    [k in K]: Exclude<T[K], undefined>;
+};
+declare function deleteKey<T extends object, K extends keyof T>(obj: T, key: K): void;
+declare function isObjectLike(value: unknown): value is object;
+
+export { type DeepFilterUndefined, type DeepMerge, type DeepPartial, type DeepRequired, type FilterUndefined, type FilterUndefinedOrNull, 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 };

package/dist/utils/objects.d.ts

@@ -1,32 +1,32 @@
-export declare function isNotNull<T>(value: T): value is NonNullable<T>;
-export type DeepPartial<T> = T extends object ? {
+declare function isNotNull<T>(value: T): value is NonNullable<T>;
+type DeepPartial<T> = T extends object ? (T extends (infer E)[] ? T : {
     [P in keyof T]?: DeepPartial<T[P]>;
-} : T;
-export type DeepRequired<T> = T extends object ? {
+}) : T;
+type DeepRequired<T> = T extends object ? (T extends (infer E)[] ? T : {
     [P in keyof T]-?: DeepRequired<T[P]>;
-} : T;
+}) : T;
 /**
  * Assumes both objects are primitives, arrays, or non-function plain objects, and compares them deeply.
  *
  * Note that since they are assumed to be plain objects, this function does not compare prototypes.
  */
-export declare function deepPlainEquals<T>(obj1: T, obj2: unknown, options?: {
+declare function deepPlainEquals<T>(obj1: T, obj2: unknown, options?: {
     ignoreUndefinedValues?: boolean;
 }): obj2 is T;
-export declare function isCloneable<T>(obj: T): obj is Exclude<T, symbol | Function>;
-export declare function shallowClone<T extends object>(obj: T): T;
-export declare function deepPlainClone<T>(obj: T): T;
-export type DeepMerge<T, U> = Omit<T, keyof U> & Omit<U, keyof T> & DeepMergeInner<Pick<T, keyof U & keyof T>, Pick<U, keyof U & keyof T>>;
+declare function isCloneable<T>(obj: T): obj is Exclude<T, symbol | Function>;
+declare function shallowClone<T extends object>(obj: T): T;
+declare function deepPlainClone<T>(obj: T): T;
+type DeepMerge<T, U> = Omit<T, keyof U> & Omit<U, keyof T> & DeepMergeInner<Pick<T, keyof U & keyof T>, Pick<U, keyof U & keyof T>>;
 type DeepMergeInner<T, U> = {
     [K in keyof U]-?: undefined extends U[K] ? K extends keyof T ? T[K] extends object ? Exclude<U[K], undefined> extends object ? DeepMerge<T[K], Exclude<U[K], undefined>> : T[K] | Exclude<U[K], undefined> : T[K] | Exclude<U[K], undefined> : Exclude<U[K], undefined> : K extends keyof T ? T[K] extends object ? U[K] extends object ? DeepMerge<T[K], U[K]> : U[K] : U[K] : U[K];
 };
-export declare function deepMerge<T extends {}, U extends {}>(baseObj: T, mergeObj: U): DeepMerge<T, U>;
-export declare function typedEntries<T extends {}>(obj: T): [keyof T, T[keyof T]][];
-export declare function typedFromEntries<K extends PropertyKey, V>(entries: (readonly [K, V])[]): Record<K, V>;
-export declare function typedKeys<T extends {}>(obj: T): (keyof T)[];
-export declare function typedValues<T extends {}>(obj: T): T[keyof T][];
-export declare function typedAssign<T extends {}, U extends {}>(target: T, source: U): T & U;
-export type FilterUndefined<T> = {
+declare function deepMerge<T extends {}, U extends {}>(baseObj: T, mergeObj: U): DeepMerge<T, U>;
+declare function typedEntries<T extends {}>(obj: T): [keyof T, T[keyof T]][];
+declare function typedFromEntries<K extends PropertyKey, V>(entries: (readonly [K, V])[]): Record<K, V>;
+declare function typedKeys<T extends {}>(obj: T): (keyof T)[];
+declare function typedValues<T extends {}>(obj: T): T[keyof T][];
+declare function typedAssign<T extends {}, U extends {}>(target: T, source: U): T & U;
+type FilterUndefined<T> = {
     [k in keyof T as (undefined extends T[k] ? (T[k] extends undefined | void ? never : k) : never)]+?: T[k] & ({} | null);
 } & {
     [k in keyof T as (undefined extends T[k] ? never : k)]: T[k] & ({} | null);
@@ -35,30 +35,35 @@ export type FilterUndefined<T> = {
  * Returns a new object with all undefined values removed. Useful when spreading optional parameters on an object, as
  * TypeScript's `Partial<XYZ>` type allows `undefined` values.
  */
-export declare function filterUndefined<T extends object>(obj: T): FilterUndefined<T>;
-export type FilterUndefinedOrNull<T> = FilterUndefined<{
+declare function filterUndefined<T extends object>(obj: T): FilterUndefined<T>;
+type FilterUndefinedOrNull<T> = FilterUndefined<{
     [k in keyof T]: null extends T[k] ? NonNullable<T[k]> | undefined : T[k];
 }>;
 /**
  * Returns a new object with all undefined and null values removed. Useful when spreading optional parameters on an object, as
  * TypeScript's `Partial<XYZ>` type allows `undefined` values.
  */
-export declare function filterUndefinedOrNull<T extends object>(obj: T): FilterUndefinedOrNull<T>;
-export type DeepFilterUndefined<T> = T extends object ? FilterUndefined<{
+declare function filterUndefinedOrNull<T extends object>(obj: T): FilterUndefinedOrNull<T>;
+type DeepFilterUndefined<T> = T extends object ? FilterUndefined<{
     [K in keyof T]: DeepFilterUndefined<T[K]>;
 }> : T;
-export declare function deepFilterUndefined<T extends object>(obj: T): DeepFilterUndefined<T>;
-export declare function pick<T extends {}, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
-export declare function omit<T extends {}, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
-export declare function split<T extends {}, K extends keyof T>(obj: T, keys: K[]): [Pick<T, K>, Omit<T, K>];
-export declare function set<T extends object, K extends keyof T>(obj: T, key: K, value: T[K]): void;
-export declare function get<T extends object, K extends keyof T>(obj: T, key: K): T[K];
-export declare function has<T extends object, K extends keyof T>(obj: T, key: K): obj is T & {
+declare function deepFilterUndefined<T extends object>(obj: T): DeepFilterUndefined<T>;
+declare function pick<T extends {}, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+declare function omit<T extends {}, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+declare function split<T extends {}, K extends keyof T>(obj: T, keys: K[]): [Pick<T, K>, Omit<T, K>];
+declare function mapValues<T extends object, U>(obj: T, fn: (value: T extends (infer E)[] ? E : T[keyof T]) => U): Record<keyof T, U>;
+declare function sortKeys<T extends object>(obj: T): T;
+declare function deepSortKeys<T extends object>(obj: T): T;
+declare function set<T extends object, K extends keyof T>(obj: T, key: K, value: T[K]): void;
+declare function get<T extends object, K extends keyof T>(obj: T, key: K): T[K];
+declare function getOrUndefined<T extends object, K extends keyof T>(obj: T, key: K): T[K] | undefined;
+declare function has<T extends object, K extends keyof T>(obj: T, key: K): obj is T & {
     [k in K]: unknown;
 };
-export declare function hasAndNotUndefined<T extends object, K extends keyof T>(obj: T, key: K): obj is T & {
+declare function hasAndNotUndefined<T extends object, K extends keyof T>(obj: T, key: K): obj is T & {
     [k in K]: Exclude<T[K], undefined>;
 };
-export declare function deleteKey<T extends object, K extends keyof T>(obj: T, key: K): void;
-export declare function isObjectLike(value: unknown): value is object;
-export {};
+declare function deleteKey<T extends object, K extends keyof T>(obj: T, key: K): void;
+declare function isObjectLike(value: unknown): value is object;
+
+export { type DeepFilterUndefined, type DeepMerge, type DeepPartial, type DeepRequired, type FilterUndefined, type FilterUndefinedOrNull, 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 };