@stackframe/stack-shared 2.8.8 → 2.8.10

package/dist/utils/unicode.js

@@ -1,23 +1,36 @@
-import { StackAssertionError } from "./errors";
-export function getFlagEmoji(twoLetterCountryCode) {
-    if (!/^[a-zA-Z][a-zA-Z]$/.test(twoLetterCountryCode))
-        throw new StackAssertionError("Country code must be two alphabetical letters");
-    const codePoints = twoLetterCountryCode
-        .toUpperCase()
-        .split('')
-        .map(char => 127397 + char.charCodeAt(0));
-    return String.fromCodePoint(...codePoints);
+"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/unicode.tsx
+var unicode_exports = {};
+__export(unicode_exports, {
+  getFlagEmoji: () => getFlagEmoji
+});
+module.exports = __toCommonJS(unicode_exports);
+var import_errors = require("./errors");
+function getFlagEmoji(twoLetterCountryCode) {
+  if (!/^[a-zA-Z][a-zA-Z]$/.test(twoLetterCountryCode)) throw new import_errors.StackAssertionError("Country code must be two alphabetical letters");
+  const codePoints = twoLetterCountryCode.toUpperCase().split("").map((char) => 127397 + char.charCodeAt(0));
+  return String.fromCodePoint(...codePoints);
 }
-import.meta.vitest?.test("getFlagEmoji", ({ expect }) => {
-    // Test with valid country codes
-    expect(getFlagEmoji("US")).toBe("🇺🇸");
-    expect(getFlagEmoji("us")).toBe("🇺🇸");
-    expect(getFlagEmoji("GB")).toBe("🇬🇧");
-    expect(getFlagEmoji("JP")).toBe("🇯🇵");
-    // Test with invalid country codes
-    expect(() => getFlagEmoji("")).toThrow("Country code must be two alphabetical letters");
-    expect(() => getFlagEmoji("A")).toThrow("Country code must be two alphabetical letters");
-    expect(() => getFlagEmoji("ABC")).toThrow("Country code must be two alphabetical letters");
-    expect(() => getFlagEmoji("12")).toThrow("Country code must be two alphabetical letters");
-    expect(() => getFlagEmoji("A1")).toThrow("Country code must be two alphabetical letters");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFlagEmoji
 });
+//# sourceMappingURL=unicode.js.map

package/dist/utils/unicode.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/unicode.tsx"],"sourcesContent":["import { StackAssertionError } from \"./errors\";\n\nexport function getFlagEmoji(twoLetterCountryCode: string) {\n  if (!/^[a-zA-Z][a-zA-Z]$/.test(twoLetterCountryCode)) throw new StackAssertionError(\"Country code must be two alphabetical letters\");\n  const codePoints = twoLetterCountryCode\n    .toUpperCase()\n    .split('')\n    .map(char => 127397 + char.charCodeAt(0));\n  return String.fromCodePoint(...codePoints);\n}\nundefined?.test(\"getFlagEmoji\", ({ expect }) => {\n  // Test with valid country codes\n  expect(getFlagEmoji(\"US\")).toBe(\"🇺🇸\");\n  expect(getFlagEmoji(\"us\")).toBe(\"🇺🇸\");\n  expect(getFlagEmoji(\"GB\")).toBe(\"🇬🇧\");\n  expect(getFlagEmoji(\"JP\")).toBe(\"🇯🇵\");\n\n  // Test with invalid country codes\n  expect(() => getFlagEmoji(\"\")).toThrow(\"Country code must be two alphabetical letters\");\n  expect(() => getFlagEmoji(\"A\")).toThrow(\"Country code must be two alphabetical letters\");\n  expect(() => getFlagEmoji(\"ABC\")).toThrow(\"Country code must be two alphabetical letters\");\n  expect(() => getFlagEmoji(\"12\")).toThrow(\"Country code must be two alphabetical letters\");\n  expect(() => getFlagEmoji(\"A1\")).toThrow(\"Country code must be two alphabetical letters\");\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAoC;AAE7B,SAAS,aAAa,sBAA8B;AACzD,MAAI,CAAC,qBAAqB,KAAK,oBAAoB,EAAG,OAAM,IAAI,kCAAoB,+CAA+C;AACnI,QAAM,aAAa,qBAChB,YAAY,EACZ,MAAM,EAAE,EACR,IAAI,UAAQ,SAAS,KAAK,WAAW,CAAC,CAAC;AAC1C,SAAO,OAAO,cAAc,GAAG,UAAU;AAC3C;","names":[]}

package/dist/utils/urls.d.cts

@@ -0,0 +1,20 @@
+declare function createUrlIfValid(...args: ConstructorParameters<typeof URL>): URL | null;
+declare function isValidUrl(url: string): boolean;
+declare function isValidHostname(hostname: string): boolean;
+declare function isLocalhost(urlOrString: string | URL): boolean;
+declare function isRelative(url: string): boolean;
+declare function getRelativePart(url: URL): string;
+/**
+ * A template literal tag that returns a URL.
+ *
+ * Any values passed are encoded.
+ */
+declare function url(strings: TemplateStringsArray | readonly string[], ...values: (string | number | boolean)[]): URL;
+/**
+ * A template literal tag that returns a URL string.
+ *
+ * Any values passed are encoded.
+ */
+declare function urlString(strings: TemplateStringsArray | readonly string[], ...values: (string | number | boolean)[]): string;
+
+export { createUrlIfValid, getRelativePart, isLocalhost, isRelative, isValidHostname, isValidUrl, url, urlString };

package/dist/utils/urls.d.ts

@@ -1,18 +1,20 @@
-export declare function createUrlIfValid(...args: ConstructorParameters<typeof URL>): URL | null;
-export declare function isValidUrl(url: string): boolean;
-export declare function isValidHostname(hostname: string): boolean;
-export declare function isLocalhost(urlOrString: string | URL): boolean;
-export declare function isRelative(url: string): boolean;
-export declare function getRelativePart(url: URL): string;
+declare function createUrlIfValid(...args: ConstructorParameters<typeof URL>): URL | null;
+declare function isValidUrl(url: string): boolean;
+declare function isValidHostname(hostname: string): boolean;
+declare function isLocalhost(urlOrString: string | URL): boolean;
+declare function isRelative(url: string): boolean;
+declare function getRelativePart(url: URL): string;
 /**
  * A template literal tag that returns a URL.
  *
  * Any values passed are encoded.
  */
-export declare function url(strings: TemplateStringsArray | readonly string[], ...values: (string | number | boolean)[]): URL;
+declare function url(strings: TemplateStringsArray | readonly string[], ...values: (string | number | boolean)[]): URL;
 /**
  * A template literal tag that returns a URL string.
  *
  * Any values passed are encoded.
  */
-export declare function urlString(strings: TemplateStringsArray | readonly string[], ...values: (string | number | boolean)[]): string;
+declare function urlString(strings: TemplateStringsArray | readonly string[], ...values: (string | number | boolean)[]): string;
+
+export { createUrlIfValid, getRelativePart, isLocalhost, isRelative, isValidHostname, isValidUrl, url, urlString };

package/dist/utils/urls.js

@@ -1,174 +1,85 @@
-import { generateSecureRandomString } from "./crypto";
-import { templateIdentity } from "./strings";
-export function createUrlIfValid(...args) {
-    try {
-        return new URL(...args);
-    }
-    catch (e) {
-        return null;
-    }
-}
-import.meta.vitest?.test("createUrlIfValid", ({ expect }) => {
-    // Test with valid URLs
-    expect(createUrlIfValid("https://example.com")).toBeInstanceOf(URL);
-    expect(createUrlIfValid("https://example.com/path?query=value#hash")).toBeInstanceOf(URL);
-    expect(createUrlIfValid("/path", "https://example.com")).toBeInstanceOf(URL);
-    // Test with invalid URLs
-    expect(createUrlIfValid("")).toBeNull();
-    expect(createUrlIfValid("not a url")).toBeNull();
-    expect(createUrlIfValid("http://")).toBeNull();
+"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/urls.tsx
+var urls_exports = {};
+__export(urls_exports, {
+  createUrlIfValid: () => createUrlIfValid,
+  getRelativePart: () => getRelativePart,
+  isLocalhost: () => isLocalhost,
+  isRelative: () => isRelative,
+  isValidHostname: () => isValidHostname,
+  isValidUrl: () => isValidUrl,
+  url: () => url,
+  urlString: () => urlString
 });
-export function isValidUrl(url) {
-    return !!createUrlIfValid(url);
+module.exports = __toCommonJS(urls_exports);
+var import_crypto = require("./crypto");
+var import_strings = require("./strings");
+function createUrlIfValid(...args) {
+  try {
+    return new URL(...args);
+  } catch (e) {
+    return null;
+  }
 }
-import.meta.vitest?.test("isValidUrl", ({ expect }) => {
-    // Test with valid URLs
-    expect(isValidUrl("https://example.com")).toBe(true);
-    expect(isValidUrl("http://localhost:3000")).toBe(true);
-    expect(isValidUrl("ftp://example.com")).toBe(true);
-    // Test with invalid URLs
-    expect(isValidUrl("")).toBe(false);
-    expect(isValidUrl("not a url")).toBe(false);
-    expect(isValidUrl("http://")).toBe(false);
-});
-export function isValidHostname(hostname) {
-    const url = createUrlIfValid(`https://${hostname}`);
-    if (!url)
-        return false;
-    return url.hostname === hostname;
+function isValidUrl(url2) {
+  return !!createUrlIfValid(url2);
 }
-import.meta.vitest?.test("isValidHostname", ({ expect }) => {
-    // Test with valid hostnames
-    expect(isValidHostname("example.com")).toBe(true);
-    expect(isValidHostname("localhost")).toBe(true);
-    expect(isValidHostname("sub.domain.example.com")).toBe(true);
-    expect(isValidHostname("127.0.0.1")).toBe(true);
-    // Test with invalid hostnames
-    expect(isValidHostname("")).toBe(false);
-    expect(isValidHostname("example.com/path")).toBe(false);
-    expect(isValidHostname("https://example.com")).toBe(false);
-    expect(isValidHostname("example com")).toBe(false);
-});
-export function isLocalhost(urlOrString) {
-    const url = createUrlIfValid(urlOrString);
-    if (!url)
-        return false;
-    if (url.hostname === "localhost" || url.hostname.endsWith(".localhost"))
-        return true;
-    if (url.hostname.match(/^127\.\d+\.\d+\.\d+$/))
-        return true;
-    return false;
+function isValidHostname(hostname) {
+  const url2 = createUrlIfValid(`https://${hostname}`);
+  if (!url2) return false;
+  return url2.hostname === hostname;
 }
-import.meta.vitest?.test("isLocalhost", ({ expect }) => {
-    // Test with localhost URLs
-    expect(isLocalhost("http://localhost")).toBe(true);
-    expect(isLocalhost("https://localhost:8080")).toBe(true);
-    expect(isLocalhost("http://sub.localhost")).toBe(true);
-    expect(isLocalhost("http://127.0.0.1")).toBe(true);
-    expect(isLocalhost("http://127.1.2.3")).toBe(true);
-    // Test with non-localhost URLs
-    expect(isLocalhost("https://example.com")).toBe(false);
-    expect(isLocalhost("http://192.168.1.1")).toBe(false);
-    expect(isLocalhost("http://10.0.0.1")).toBe(false);
-    // Test with URL objects
-    expect(isLocalhost(new URL("http://localhost"))).toBe(true);
-    expect(isLocalhost(new URL("https://example.com"))).toBe(false);
-    // Test with invalid URLs
-    expect(isLocalhost("not a url")).toBe(false);
-    expect(isLocalhost("")).toBe(false);
-});
-export function isRelative(url) {
-    const randomDomain = `${generateSecureRandomString()}.stack-auth.example.com`;
-    const u = createUrlIfValid(url, `https://${randomDomain}`);
-    if (!u)
-        return false;
-    if (u.host !== randomDomain)
-        return false;
-    if (u.protocol !== "https:")
-        return false;
-    return true;
+function isLocalhost(urlOrString) {
+  const url2 = createUrlIfValid(urlOrString);
+  if (!url2) return false;
+  if (url2.hostname === "localhost" || url2.hostname.endsWith(".localhost")) return true;
+  if (url2.hostname.match(/^127\.\d+\.\d+\.\d+$/)) return true;
+  return false;
 }
-import.meta.vitest?.test("isRelative", ({ expect }) => {
-    // We can't easily mock generateSecureRandomString in this context
-    // but we can still test the function's behavior
-    // Test with relative URLs
-    expect(isRelative("/")).toBe(true);
-    expect(isRelative("/path")).toBe(true);
-    expect(isRelative("/path?query=value#hash")).toBe(true);
-    // Test with absolute URLs
-    expect(isRelative("https://example.com")).toBe(false);
-    expect(isRelative("http://example.com")).toBe(false);
-    expect(isRelative("//example.com")).toBe(false);
-    // Note: The implementation treats empty strings and invalid URLs as relative
-    // This is because they can be resolved against a base URL
-    expect(isRelative("")).toBe(true);
-    expect(isRelative("not a url")).toBe(true);
-});
-export function getRelativePart(url) {
-    return url.pathname + url.search + url.hash;
+function isRelative(url2) {
+  const randomDomain = `${(0, import_crypto.generateSecureRandomString)()}.stack-auth.example.com`;
+  const u = createUrlIfValid(url2, `https://${randomDomain}`);
+  if (!u) return false;
+  if (u.host !== randomDomain) return false;
+  if (u.protocol !== "https:") return false;
+  return true;
 }
-import.meta.vitest?.test("getRelativePart", ({ expect }) => {
-    // Test with various URLs
-    expect(getRelativePart(new URL("https://example.com"))).toBe("/");
-    expect(getRelativePart(new URL("https://example.com/path"))).toBe("/path");
-    expect(getRelativePart(new URL("https://example.com/path?query=value"))).toBe("/path?query=value");
-    expect(getRelativePart(new URL("https://example.com/path#hash"))).toBe("/path#hash");
-    expect(getRelativePart(new URL("https://example.com/path?query=value#hash"))).toBe("/path?query=value#hash");
-    // Test with different domains but same paths
-    const url1 = new URL("https://example.com/path?query=value#hash");
-    const url2 = new URL("https://different.com/path?query=value#hash");
-    expect(getRelativePart(url1)).toBe(getRelativePart(url2));
-});
-/**
- * A template literal tag that returns a URL.
- *
- * Any values passed are encoded.
- */
-export function url(strings, ...values) {
-    return new URL(urlString(strings, ...values));
+function getRelativePart(url2) {
+  return url2.pathname + url2.search + url2.hash;
 }
-import.meta.vitest?.test("url", ({ expect }) => {
-    // Test with no interpolation
-    expect(url `https://example.com`).toBeInstanceOf(URL);
-    expect(url `https://example.com`.href).toBe("https://example.com/");
-    // Test with string interpolation
-    expect(url `https://example.com/${"path"}`).toBeInstanceOf(URL);
-    expect(url `https://example.com/${"path"}`.pathname).toBe("/path");
-    // Test with number interpolation
-    expect(url `https://example.com/${42}`).toBeInstanceOf(URL);
-    expect(url `https://example.com/${42}`.pathname).toBe("/42");
-    // Test with boolean interpolation
-    expect(url `https://example.com/${true}`).toBeInstanceOf(URL);
-    expect(url `https://example.com/${true}`.pathname).toBe("/true");
-    // Test with special characters in interpolation
-    expect(url `https://example.com/${"path with spaces"}`).toBeInstanceOf(URL);
-    expect(url `https://example.com/${"path with spaces"}`.pathname).toBe("/path%20with%20spaces");
-    // Test with multiple interpolations
-    expect(url `https://example.com/${"path"}?query=${"value"}`).toBeInstanceOf(URL);
-    expect(url `https://example.com/${"path"}?query=${"value"}`.pathname).toBe("/path");
-    expect(url `https://example.com/${"path"}?query=${"value"}`.search).toBe("?query=value");
-});
-/**
- * A template literal tag that returns a URL string.
- *
- * Any values passed are encoded.
- */
-export function urlString(strings, ...values) {
-    return templateIdentity(strings, ...values.map(encodeURIComponent));
+function url(strings, ...values) {
+  return new URL(urlString(strings, ...values));
+}
+function urlString(strings, ...values) {
+  return (0, import_strings.templateIdentity)(strings, ...values.map(encodeURIComponent));
 }
-import.meta.vitest?.test("urlString", ({ expect }) => {
-    // Test with no interpolation
-    expect(urlString `https://example.com`).toBe("https://example.com");
-    // Test with string interpolation
-    expect(urlString `https://example.com/${"path"}`).toBe("https://example.com/path");
-    // Test with number interpolation
-    expect(urlString `https://example.com/${42}`).toBe("https://example.com/42");
-    // Test with boolean interpolation
-    expect(urlString `https://example.com/${true}`).toBe("https://example.com/true");
-    // Test with special characters in interpolation
-    expect(urlString `https://example.com/${"path with spaces"}`).toBe("https://example.com/path%20with%20spaces");
-    expect(urlString `https://example.com/${"?&="}`).toBe("https://example.com/%3F%26%3D");
-    // Test with multiple interpolations
-    expect(urlString `https://example.com/${"path"}?query=${"value"}`).toBe("https://example.com/path?query=value");
-    expect(urlString `https://example.com/${"path"}?query=${"value with spaces"}`).toBe("https://example.com/path?query=value%20with%20spaces");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createUrlIfValid,
+  getRelativePart,
+  isLocalhost,
+  isRelative,
+  isValidHostname,
+  isValidUrl,
+  url,
+  urlString
 });
+//# sourceMappingURL=urls.js.map

package/dist/utils/urls.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/urls.tsx"],"sourcesContent":["import { generateSecureRandomString } from \"./crypto\";\nimport { templateIdentity } from \"./strings\";\n\nexport function createUrlIfValid(...args: ConstructorParameters<typeof URL>) {\n  try {\n    return new URL(...args);\n  } catch (e) {\n    return null;\n  }\n}\nundefined?.test(\"createUrlIfValid\", ({ expect }) => {\n  // Test with valid URLs\n  expect(createUrlIfValid(\"https://example.com\")).toBeInstanceOf(URL);\n  expect(createUrlIfValid(\"https://example.com/path?query=value#hash\")).toBeInstanceOf(URL);\n  expect(createUrlIfValid(\"/path\", \"https://example.com\")).toBeInstanceOf(URL);\n\n  // Test with invalid URLs\n  expect(createUrlIfValid(\"\")).toBeNull();\n  expect(createUrlIfValid(\"not a url\")).toBeNull();\n  expect(createUrlIfValid(\"http://\")).toBeNull();\n});\n\nexport function isValidUrl(url: string) {\n  return !!createUrlIfValid(url);\n}\nundefined?.test(\"isValidUrl\", ({ expect }) => {\n  // Test with valid URLs\n  expect(isValidUrl(\"https://example.com\")).toBe(true);\n  expect(isValidUrl(\"http://localhost:3000\")).toBe(true);\n  expect(isValidUrl(\"ftp://example.com\")).toBe(true);\n\n  // Test with invalid URLs\n  expect(isValidUrl(\"\")).toBe(false);\n  expect(isValidUrl(\"not a url\")).toBe(false);\n  expect(isValidUrl(\"http://\")).toBe(false);\n});\n\nexport function isValidHostname(hostname: string) {\n  const url = createUrlIfValid(`https://${hostname}`);\n  if (!url) return false;\n  return url.hostname === hostname;\n}\nundefined?.test(\"isValidHostname\", ({ expect }) => {\n  // Test with valid hostnames\n  expect(isValidHostname(\"example.com\")).toBe(true);\n  expect(isValidHostname(\"localhost\")).toBe(true);\n  expect(isValidHostname(\"sub.domain.example.com\")).toBe(true);\n  expect(isValidHostname(\"127.0.0.1\")).toBe(true);\n\n  // Test with invalid hostnames\n  expect(isValidHostname(\"\")).toBe(false);\n  expect(isValidHostname(\"example.com/path\")).toBe(false);\n  expect(isValidHostname(\"https://example.com\")).toBe(false);\n  expect(isValidHostname(\"example com\")).toBe(false);\n});\n\nexport function isLocalhost(urlOrString: string | URL) {\n  const url = createUrlIfValid(urlOrString);\n  if (!url) return false;\n  if (url.hostname === \"localhost\" || url.hostname.endsWith(\".localhost\")) return true;\n  if (url.hostname.match(/^127\\.\\d+\\.\\d+\\.\\d+$/)) return true;\n  return false;\n}\nundefined?.test(\"isLocalhost\", ({ expect }) => {\n  // Test with localhost URLs\n  expect(isLocalhost(\"http://localhost\")).toBe(true);\n  expect(isLocalhost(\"https://localhost:8080\")).toBe(true);\n  expect(isLocalhost(\"http://sub.localhost\")).toBe(true);\n  expect(isLocalhost(\"http://127.0.0.1\")).toBe(true);\n  expect(isLocalhost(\"http://127.1.2.3\")).toBe(true);\n\n  // Test with non-localhost URLs\n  expect(isLocalhost(\"https://example.com\")).toBe(false);\n  expect(isLocalhost(\"http://192.168.1.1\")).toBe(false);\n  expect(isLocalhost(\"http://10.0.0.1\")).toBe(false);\n\n  // Test with URL objects\n  expect(isLocalhost(new URL(\"http://localhost\"))).toBe(true);\n  expect(isLocalhost(new URL(\"https://example.com\"))).toBe(false);\n\n  // Test with invalid URLs\n  expect(isLocalhost(\"not a url\")).toBe(false);\n  expect(isLocalhost(\"\")).toBe(false);\n});\n\nexport function isRelative(url: string) {\n  const randomDomain = `${generateSecureRandomString()}.stack-auth.example.com`;\n  const u = createUrlIfValid(url, `https://${randomDomain}`);\n  if (!u) return false;\n  if (u.host !== randomDomain) return false;\n  if (u.protocol !== \"https:\") return false;\n  return true;\n}\nundefined?.test(\"isRelative\", ({ expect }) => {\n  // We can't easily mock generateSecureRandomString in this context\n  // but we can still test the function's behavior\n\n  // Test with relative URLs\n  expect(isRelative(\"/\")).toBe(true);\n  expect(isRelative(\"/path\")).toBe(true);\n  expect(isRelative(\"/path?query=value#hash\")).toBe(true);\n\n  // Test with absolute URLs\n  expect(isRelative(\"https://example.com\")).toBe(false);\n  expect(isRelative(\"http://example.com\")).toBe(false);\n  expect(isRelative(\"//example.com\")).toBe(false);\n\n  // Note: The implementation treats empty strings and invalid URLs as relative\n  // This is because they can be resolved against a base URL\n  expect(isRelative(\"\")).toBe(true);\n  expect(isRelative(\"not a url\")).toBe(true);\n});\n\nexport function getRelativePart(url: URL) {\n  return url.pathname + url.search + url.hash;\n}\nundefined?.test(\"getRelativePart\", ({ expect }) => {\n  // Test with various URLs\n  expect(getRelativePart(new URL(\"https://example.com\"))).toBe(\"/\");\n  expect(getRelativePart(new URL(\"https://example.com/path\"))).toBe(\"/path\");\n  expect(getRelativePart(new URL(\"https://example.com/path?query=value\"))).toBe(\"/path?query=value\");\n  expect(getRelativePart(new URL(\"https://example.com/path#hash\"))).toBe(\"/path#hash\");\n  expect(getRelativePart(new URL(\"https://example.com/path?query=value#hash\"))).toBe(\"/path?query=value#hash\");\n\n  // Test with different domains but same paths\n  const url1 = new URL(\"https://example.com/path?query=value#hash\");\n  const url2 = new URL(\"https://different.com/path?query=value#hash\");\n  expect(getRelativePart(url1)).toBe(getRelativePart(url2));\n});\n\n/**\n * A template literal tag that returns a URL.\n *\n * Any values passed are encoded.\n */\nexport function url(strings: TemplateStringsArray | readonly string[], ...values: (string|number|boolean)[]): URL {\n  return new URL(urlString(strings, ...values));\n}\nundefined?.test(\"url\", ({ expect }) => {\n  // Test with no interpolation\n  expect(url`https://example.com`).toBeInstanceOf(URL);\n  expect(url`https://example.com`.href).toBe(\"https://example.com/\");\n\n  // Test with string interpolation\n  expect(url`https://example.com/${\"path\"}`).toBeInstanceOf(URL);\n  expect(url`https://example.com/${\"path\"}`.pathname).toBe(\"/path\");\n\n  // Test with number interpolation\n  expect(url`https://example.com/${42}`).toBeInstanceOf(URL);\n  expect(url`https://example.com/${42}`.pathname).toBe(\"/42\");\n\n  // Test with boolean interpolation\n  expect(url`https://example.com/${true}`).toBeInstanceOf(URL);\n  expect(url`https://example.com/${true}`.pathname).toBe(\"/true\");\n\n  // Test with special characters in interpolation\n  expect(url`https://example.com/${\"path with spaces\"}`).toBeInstanceOf(URL);\n  expect(url`https://example.com/${\"path with spaces\"}`.pathname).toBe(\"/path%20with%20spaces\");\n\n  // Test with multiple interpolations\n  expect(url`https://example.com/${\"path\"}?query=${\"value\"}`).toBeInstanceOf(URL);\n  expect(url`https://example.com/${\"path\"}?query=${\"value\"}`.pathname).toBe(\"/path\");\n  expect(url`https://example.com/${\"path\"}?query=${\"value\"}`.search).toBe(\"?query=value\");\n});\n\n\n/**\n * A template literal tag that returns a URL string.\n *\n * Any values passed are encoded.\n */\nexport function urlString(strings: TemplateStringsArray | readonly string[], ...values: (string|number|boolean)[]): string {\n  return templateIdentity(strings, ...values.map(encodeURIComponent));\n}\nundefined?.test(\"urlString\", ({ expect }) => {\n  // Test with no interpolation\n  expect(urlString`https://example.com`).toBe(\"https://example.com\");\n\n  // Test with string interpolation\n  expect(urlString`https://example.com/${\"path\"}`).toBe(\"https://example.com/path\");\n\n  // Test with number interpolation\n  expect(urlString`https://example.com/${42}`).toBe(\"https://example.com/42\");\n\n  // Test with boolean interpolation\n  expect(urlString`https://example.com/${true}`).toBe(\"https://example.com/true\");\n\n  // Test with special characters in interpolation\n  expect(urlString`https://example.com/${\"path with spaces\"}`).toBe(\"https://example.com/path%20with%20spaces\");\n  expect(urlString`https://example.com/${\"?&=\"}`).toBe(\"https://example.com/%3F%26%3D\");\n\n  // Test with multiple interpolations\n  expect(urlString`https://example.com/${\"path\"}?query=${\"value\"}`).toBe(\"https://example.com/path?query=value\");\n  expect(urlString`https://example.com/${\"path\"}?query=${\"value with spaces\"}`).toBe(\"https://example.com/path?query=value%20with%20spaces\");\n});\n\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA2C;AAC3C,qBAAiC;AAE1B,SAAS,oBAAoB,MAAyC;AAC3E,MAAI;AACF,WAAO,IAAI,IAAI,GAAG,IAAI;AAAA,EACxB,SAAS,GAAG;AACV,WAAO;AAAA,EACT;AACF;AAaO,SAAS,WAAWA,MAAa;AACtC,SAAO,CAAC,CAAC,iBAAiBA,IAAG;AAC/B;AAaO,SAAS,gBAAgB,UAAkB;AAChD,QAAMA,OAAM,iBAAiB,WAAW,QAAQ,EAAE;AAClD,MAAI,CAACA,KAAK,QAAO;AACjB,SAAOA,KAAI,aAAa;AAC1B;AAeO,SAAS,YAAY,aAA2B;AACrD,QAAMA,OAAM,iBAAiB,WAAW;AACxC,MAAI,CAACA,KAAK,QAAO;AACjB,MAAIA,KAAI,aAAa,eAAeA,KAAI,SAAS,SAAS,YAAY,EAAG,QAAO;AAChF,MAAIA,KAAI,SAAS,MAAM,sBAAsB,EAAG,QAAO;AACvD,SAAO;AACT;AAuBO,SAAS,WAAWA,MAAa;AACtC,QAAM,eAAe,OAAG,0CAA2B,CAAC;AACpD,QAAM,IAAI,iBAAiBA,MAAK,WAAW,YAAY,EAAE;AACzD,MAAI,CAAC,EAAG,QAAO;AACf,MAAI,EAAE,SAAS,aAAc,QAAO;AACpC,MAAI,EAAE,aAAa,SAAU,QAAO;AACpC,SAAO;AACT;AAqBO,SAAS,gBAAgBA,MAAU;AACxC,SAAOA,KAAI,WAAWA,KAAI,SAASA,KAAI;AACzC;AAoBO,SAAS,IAAI,YAAsD,QAAwC;AAChH,SAAO,IAAI,IAAI,UAAU,SAAS,GAAG,MAAM,CAAC;AAC9C;AAkCO,SAAS,UAAU,YAAsD,QAA2C;AACzH,aAAO,iCAAiB,SAAS,GAAG,OAAO,IAAI,kBAAkB,CAAC;AACpE;","names":["url"]}

package/dist/utils/uuids.d.cts

@@ -0,0 +1,4 @@
+declare function generateUuid(): string;
+declare function isUuid(str: string): boolean;
+
+export { generateUuid, isUuid };

package/dist/utils/uuids.d.ts

@@ -1,2 +1,4 @@
-export declare function generateUuid(): string;
-export declare function isUuid(str: string): boolean;
+declare function generateUuid(): string;
+declare function isUuid(str: string): boolean;
+
+export { generateUuid, isUuid };

package/dist/utils/uuids.js

@@ -1,38 +1,42 @@
-import { generateRandomValues } from "./crypto";
-export function generateUuid() {
-    // crypto.randomUuid is not supported in all browsers, so this is a polyfill
-    return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, c => (+c ^ generateRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16));
-}
-import.meta.vitest?.test("generateUuid", ({ expect }) => {
-    // Test that the function returns a valid UUID
-    const uuid = generateUuid();
-    expect(uuid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
-    // Test that multiple calls generate different UUIDs
-    const uuid2 = generateUuid();
-    expect(uuid).not.toBe(uuid2);
-    // Test that the UUID is version 4 (random)
-    expect(uuid.charAt(14)).toBe('4');
-    // Test that the UUID has the correct variant (8, 9, a, or b in position 19)
-    expect('89ab').toContain(uuid.charAt(19));
+"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/uuids.tsx
+var uuids_exports = {};
+__export(uuids_exports, {
+  generateUuid: () => generateUuid,
+  isUuid: () => isUuid
 });
-export function isUuid(str) {
-    return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(str);
+module.exports = __toCommonJS(uuids_exports);
+var import_crypto = require("./crypto");
+function generateUuid() {
+  return "10000000-1000-4000-8000-100000000000".replace(
+    /[018]/g,
+    (c) => (+c ^ (0, import_crypto.generateRandomValues)(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16)
+  );
+}
+function isUuid(str) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(str);
 }
-import.meta.vitest?.test("isUuid", ({ expect }) => {
-    // Test with valid UUIDs
-    expect(isUuid("123e4567-e89b-42d3-a456-426614174000")).toBe(true);
-    expect(isUuid("123e4567-e89b-42d3-8456-426614174000")).toBe(true);
-    expect(isUuid("123e4567-e89b-42d3-9456-426614174000")).toBe(true);
-    expect(isUuid("123e4567-e89b-42d3-a456-426614174000")).toBe(true);
-    expect(isUuid("123e4567-e89b-42d3-b456-426614174000")).toBe(true);
-    // Test with invalid UUIDs
-    expect(isUuid("")).toBe(false);
-    expect(isUuid("not-a-uuid")).toBe(false);
-    expect(isUuid("123e4567-e89b-12d3-a456-426614174000")).toBe(false); // Wrong version (not 4)
-    expect(isUuid("123e4567-e89b-42d3-c456-426614174000")).toBe(false); // Wrong variant (not 8, 9, a, or b)
-    expect(isUuid("123e4567-e89b-42d3-a456-42661417400")).toBe(false); // Too short
-    expect(isUuid("123e4567-e89b-42d3-a456-4266141740000")).toBe(false); // Too long
-    expect(isUuid("123e4567-e89b-42d3-a456_426614174000")).toBe(false); // Wrong format (underscore instead of dash)
-    // Test with uppercase letters (should fail as UUID should be lowercase)
-    expect(isUuid("123E4567-E89B-42D3-A456-426614174000")).toBe(false);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateUuid,
+  isUuid
 });
+//# sourceMappingURL=uuids.js.map

package/dist/utils/uuids.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/uuids.tsx"],"sourcesContent":["import { generateRandomValues } from \"./crypto\";\n\nexport function generateUuid() {\n  // crypto.randomUuid is not supported in all browsers, so this is a polyfill\n  return \"10000000-1000-4000-8000-100000000000\".replace(/[018]/g, c =>\n    (+c ^ generateRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16)\n  );\n}\nundefined?.test(\"generateUuid\", ({ expect }) => {\n  // Test that the function returns a valid UUID\n  const uuid = generateUuid();\n  expect(uuid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);\n\n  // Test that multiple calls generate different UUIDs\n  const uuid2 = generateUuid();\n  expect(uuid).not.toBe(uuid2);\n\n  // Test that the UUID is version 4 (random)\n  expect(uuid.charAt(14)).toBe('4');\n\n  // Test that the UUID has the correct variant (8, 9, a, or b in position 19)\n  expect('89ab').toContain(uuid.charAt(19));\n});\n\nexport function isUuid(str: string) {\n  return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(str);\n}\nundefined?.test(\"isUuid\", ({ expect }) => {\n  // Test with valid UUIDs\n  expect(isUuid(\"123e4567-e89b-42d3-a456-426614174000\")).toBe(true);\n  expect(isUuid(\"123e4567-e89b-42d3-8456-426614174000\")).toBe(true);\n  expect(isUuid(\"123e4567-e89b-42d3-9456-426614174000\")).toBe(true);\n  expect(isUuid(\"123e4567-e89b-42d3-a456-426614174000\")).toBe(true);\n  expect(isUuid(\"123e4567-e89b-42d3-b456-426614174000\")).toBe(true);\n\n  // Test with invalid UUIDs\n  expect(isUuid(\"\")).toBe(false);\n  expect(isUuid(\"not-a-uuid\")).toBe(false);\n  expect(isUuid(\"123e4567-e89b-12d3-a456-426614174000\")).toBe(false); // Wrong version (not 4)\n  expect(isUuid(\"123e4567-e89b-42d3-c456-426614174000\")).toBe(false); // Wrong variant (not 8, 9, a, or b)\n  expect(isUuid(\"123e4567-e89b-42d3-a456-42661417400\")).toBe(false); // Too short\n  expect(isUuid(\"123e4567-e89b-42d3-a456-4266141740000\")).toBe(false); // Too long\n  expect(isUuid(\"123e4567-e89b-42d3-a456_426614174000\")).toBe(false); // Wrong format (underscore instead of dash)\n\n  // Test with uppercase letters (should fail as UUID should be lowercase)\n  expect(isUuid(\"123E4567-E89B-42D3-A456-426614174000\")).toBe(false);\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAqC;AAE9B,SAAS,eAAe;AAE7B,SAAO,uCAAuC;AAAA,IAAQ;AAAA,IAAU,QAC7D,CAAC,QAAI,oCAAqB,IAAI,WAAW,CAAC,CAAC,EAAE,CAAC,IAAI,MAAM,CAAC,IAAI,GAAG,SAAS,EAAE;AAAA,EAC9E;AACF;AAiBO,SAAS,OAAO,KAAa;AAClC,SAAO,wEAAwE,KAAK,GAAG;AACzF;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.8.8",
+  "version": "2.8.10",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
@@ -13,11 +13,11 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "default": "./dist/esm/index.js"
     },
     "./dist/*": {
       "types": "./dist/*.d.ts",
-      "default": "./dist/*.js"
+      "default": "./dist/esm/*.js"
     }
   },
   "peerDependencies": {
@@ -65,11 +65,11 @@
     "rimraf": "^5.0.5"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "rimraf dist && tsup-node",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "clean": "rimraf dist && rimraf node_modules",
-    "dev": "tsc -w --preserveWatchOutput --declarationMap",
+    "dev": "tsup-node --watch",
     "lint": "eslint --ext .tsx,.ts ."
   }
 }