@hexclave/shared 1.0.0

package/dist/esm/utils/unicode.js

@@ -0,0 +1,24 @@
+import { HexclaveAssertionError } from "./errors.js";
+import { isValidCountryCode, normalizeCountryCode } from "./country-codes.js";
+
+//#region src/utils/unicode.tsx
+function getFlagEmoji(twoLetterCountryCode) {
+	if (!isValidCountryCode(twoLetterCountryCode)) throw new HexclaveAssertionError("Country code must be two alphabetical letters");
+	const codePoints = normalizeCountryCode(twoLetterCountryCode).split("").map((char) => 127397 + char.charCodeAt(0));
+	return String.fromCodePoint(...codePoints);
+}
+(void 0)?.test("getFlagEmoji", ({ expect }) => {
+	expect(getFlagEmoji("US")).toBe("🇺🇸");
+	expect(getFlagEmoji("us")).toBe("🇺🇸");
+	expect(getFlagEmoji("GB")).toBe("🇬🇧");
+	expect(getFlagEmoji("JP")).toBe("🇯🇵");
+	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");
+});
+
+//#endregion
+export { getFlagEmoji };
+//# sourceMappingURL=unicode.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unicode.js","names":[],"sources":["../../../src/utils/unicode.tsx"],"sourcesContent":["import { isValidCountryCode, normalizeCountryCode } from \"./country-codes\";\nimport { HexclaveAssertionError } from \"./errors\";\n\nexport function getFlagEmoji(twoLetterCountryCode: string) {\n  if (!isValidCountryCode(twoLetterCountryCode)) throw new HexclaveAssertionError(\"Country code must be two alphabetical letters\");\n  const codePoints = normalizeCountryCode(twoLetterCountryCode)\n    .split('')\n    .map(char => 127397 + char.charCodeAt(0));\n  return String.fromCodePoint(...codePoints);\n}\nimport.meta.vitest?.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":";;;;AAGA,SAAgB,aAAa,sBAA8B;AACzD,KAAI,CAAC,mBAAmB,qBAAqB,CAAE,OAAM,IAAI,uBAAuB,gDAAgD;CAChI,MAAM,aAAa,qBAAqB,qBAAoB,CACzD,MAAM,GAAE,CACR,KAAI,SAAQ,SAAS,KAAK,WAAW,EAAE,CAAC;AAC3C,QAAO,OAAO,cAAc,GAAG,WAAW;;CAE5C,SAAW,KAAC,iBAAc,EAAA,aAAkB;AAE1C,QAAO,aAAa,KAAK,CAAC,CAAC,KAAK,OAAO;AACvC,QAAO,aAAa,KAAK,CAAC,CAAC,KAAK,OAAO;AACvC,QAAO,aAAa,KAAK,CAAC,CAAC,KAAK,OAAO;AACvC,QAAO,aAAa,KAAK,CAAC,CAAC,KAAK,OAAO;AAGvC,cAAa,aAAa,GAAG,CAAC,CAAC,QAAQ,gDAAgD;AACvF,cAAa,aAAa,IAAI,CAAC,CAAC,QAAQ,gDAAgD;AACxF,cAAa,aAAa,MAAM,CAAC,CAAC,QAAQ,gDAAgD;AAC1F,cAAa,aAAa,KAAK,CAAC,CAAC,QAAQ,gDAAgD;AACzF,cAAa,aAAa,KAAK,CAAC,CAAC,QAAQ,gDAAgD;EACzF"}

package/dist/esm/utils/urls.d.ts

@@ -0,0 +1,28 @@
+//#region src/utils/urls.d.ts
+declare function createUrlIfValid(...args: ConstructorParameters<typeof URL>): URL | null;
+declare function isValidUrl(url: string): boolean;
+declare function isValidHostname(hostname: string): boolean;
+declare function isValidHostnameWithWildcards(hostname: string): boolean;
+declare function matchHostnamePattern(pattern: string, hostname: string): boolean;
+declare function getHardcodedFallbackUrls(primaryBaseUrl: string): string[];
+declare function getDefaultApiUrls(primaryBaseUrl: string): string[];
+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;
+declare function isChildUrl(parentUrl: URL, maybeChildUrl: URL): boolean;
+declare function isChildPath(parentPath: string, maybeChildPath: string): boolean;
+//#endregion
+export { createUrlIfValid, getDefaultApiUrls, getHardcodedFallbackUrls, getRelativePart, isChildPath, isChildUrl, isLocalhost, isRelative, isValidHostname, isValidHostnameWithWildcards, isValidUrl, matchHostnamePattern, url, urlString };
+//# sourceMappingURL=urls.d.ts.map

package/dist/esm/utils/urls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"urls.d.ts","names":[],"sources":["../../../src/utils/urls.tsx"],"mappings":";iBAGgB,gBAAA,CAAA,GAAoB,IAAA,EAAM,qBAAA,QAA6B,GAAA,IAAI,GAAA;AAAA,iBAmB3D,UAAA,CAAW,GAAA;AAAA,iBAeX,eAAA,CAAgB,QAAA;AAAA,iBAwBhB,4BAAA,CAA6B,QAAA;AAAA,iBAkF7B,oBAAA,CAAqB,OAAA,UAAiB,QAAA;AAAA,iBAuDtC,wBAAA,CAAyB,cAAA;AAAA,iBAuBzB,iBAAA,CAAkB,cAAA;AAAA,iBAIlB,WAAA,CAAY,WAAA,WAAsB,GAAA;AAAA,iBA+BlC,UAAA,CAAW,GAAA;AAAA,iBA4BX,eAAA,CAAgB,GAAA,EAAK,GAAA;;;;;;iBAsBrB,GAAA,CAAI,OAAA,EAAS,oBAAA,yBAA6C,MAAA,kCAAwC,GAAA;;;;;AA7QlH;iBAiTgB,SAAA,CAAU,OAAA,EAAS,oBAAA,yBAA6C,MAAA;AAAA,iBAyBhE,UAAA,CAAW,SAAA,EAAW,GAAA,EAAK,aAAA,EAAe,GAAA;AAAA,iBAsB1C,WAAA,CAAY,UAAA,UAAoB,cAAA"}

package/dist/esm/utils/urls.js

@@ -0,0 +1,259 @@
+import { generateSecureRandomString } from "./crypto.js";
+import { templateIdentity } from "./strings.js";
+
+//#region src/utils/urls.tsx
+function createUrlIfValid(...args) {
+	try {
+		return new URL(...args);
+	} catch (e) {
+		return null;
+	}
+}
+(void 0)?.test("createUrlIfValid", ({ expect }) => {
+	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);
+	expect(createUrlIfValid("")).toBeNull();
+	expect(createUrlIfValid("not a url")).toBeNull();
+	expect(createUrlIfValid("http://")).toBeNull();
+});
+function isValidUrl(url) {
+	return !!createUrlIfValid(url);
+}
+(void 0)?.test("isValidUrl", ({ expect }) => {
+	expect(isValidUrl("https://example.com")).toBe(true);
+	expect(isValidUrl("http://localhost:3000")).toBe(true);
+	expect(isValidUrl("ftp://example.com")).toBe(true);
+	expect(isValidUrl("")).toBe(false);
+	expect(isValidUrl("not a url")).toBe(false);
+	expect(isValidUrl("http://")).toBe(false);
+});
+function isValidHostname(hostname) {
+	if (!hostname || hostname.startsWith(".") || hostname.endsWith(".") || hostname.includes("..")) return false;
+	const url = createUrlIfValid(`https://${hostname}`);
+	if (!url) return false;
+	return url.hostname === hostname;
+}
+(void 0)?.test("isValidHostname", ({ expect }) => {
+	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);
+	expect(isValidHostname("")).toBe(false);
+	expect(isValidHostname("example.com/path")).toBe(false);
+	expect(isValidHostname("https://example.com")).toBe(false);
+	expect(isValidHostname("example com")).toBe(false);
+});
+function isValidHostnameWithWildcards(hostname) {
+	if (!hostname) return false;
+	if (!hostname.includes("*")) return isValidHostname(hostname);
+	if (hostname.startsWith(".") || hostname.endsWith(".")) return false;
+	if (hostname.includes("..")) return false;
+	const testHostname = hostname.replace(/\*+/g, "wildcard");
+	if (!/^[a-zA-Z0-9.-]+$/.test(testHostname)) return false;
+	const segments = hostname.split(/\*+/);
+	for (let i = 0; i < segments.length; i++) {
+		const segment = segments[i];
+		if (segment === "") continue;
+		if (i === 0 && segment.startsWith(".")) return false;
+		if (i === segments.length - 1 && segment.endsWith(".")) return false;
+		if (segment.includes("..")) return false;
+	}
+	return true;
+}
+(void 0)?.test("isValidHostnameWithWildcards", ({ expect }) => {
+	expect(isValidHostnameWithWildcards("example.com")).toBe(true);
+	expect(isValidHostnameWithWildcards("localhost")).toBe(true);
+	expect(isValidHostnameWithWildcards("sub.domain.example.com")).toBe(true);
+	expect(isValidHostnameWithWildcards("*.example.com")).toBe(true);
+	expect(isValidHostnameWithWildcards("a-*.example.com")).toBe(true);
+	expect(isValidHostnameWithWildcards("*.*.org")).toBe(true);
+	expect(isValidHostnameWithWildcards("**.example.com")).toBe(true);
+	expect(isValidHostnameWithWildcards("sub.**.com")).toBe(true);
+	expect(isValidHostnameWithWildcards("*-api.*.com")).toBe(true);
+	expect(isValidHostnameWithWildcards("")).toBe(false);
+	expect(isValidHostnameWithWildcards("example.com/path")).toBe(false);
+	expect(isValidHostnameWithWildcards("https://example.com")).toBe(false);
+	expect(isValidHostnameWithWildcards("example com")).toBe(false);
+	expect(isValidHostnameWithWildcards(".example.com")).toBe(false);
+	expect(isValidHostnameWithWildcards("example.com.")).toBe(false);
+	expect(isValidHostnameWithWildcards("example..com")).toBe(false);
+	expect(isValidHostnameWithWildcards("*.example..com")).toBe(false);
+});
+function matchHostnamePattern(pattern, hostname) {
+	if (!pattern.includes("*")) return pattern === hostname;
+	let regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+	const doubleWildcardPlaceholder = "\0DOUBLE_WILDCARD\0";
+	regexPattern = regexPattern.replace(/\*\*/g, doubleWildcardPlaceholder);
+	regexPattern = regexPattern.replace(/\*/g, "[^.]*");
+	regexPattern = regexPattern.replace(new RegExp(doubleWildcardPlaceholder, "g"), ".*");
+	regexPattern = "^" + regexPattern + "$";
+	try {
+		return new RegExp(regexPattern).test(hostname);
+	} catch {
+		return false;
+	}
+}
+(void 0)?.test("matchHostnamePattern", ({ expect }) => {
+	expect(matchHostnamePattern("example.com", "example.com")).toBe(true);
+	expect(matchHostnamePattern("example.com", "other.com")).toBe(false);
+	expect(matchHostnamePattern("*.example.com", "api.example.com")).toBe(true);
+	expect(matchHostnamePattern("*.example.com", "www.example.com")).toBe(true);
+	expect(matchHostnamePattern("*.example.com", "example.com")).toBe(false);
+	expect(matchHostnamePattern("*.example.com", "api.v2.example.com")).toBe(false);
+	expect(matchHostnamePattern("**.example.com", "api.example.com")).toBe(true);
+	expect(matchHostnamePattern("**.example.com", "api.v2.example.com")).toBe(true);
+	expect(matchHostnamePattern("**.example.com", "a.b.c.example.com")).toBe(true);
+	expect(matchHostnamePattern("**.example.com", "example.com")).toBe(false);
+	expect(matchHostnamePattern("api-*.example.com", "api-v1.example.com")).toBe(true);
+	expect(matchHostnamePattern("api-*.example.com", "api-v2.example.com")).toBe(true);
+	expect(matchHostnamePattern("api-*.example.com", "api.example.com")).toBe(false);
+	expect(matchHostnamePattern("*.*.org", "mail.example.org")).toBe(true);
+	expect(matchHostnamePattern("*.*.org", "example.org")).toBe(false);
+});
+function getHardcodedFallbackUrls(primaryBaseUrl) {
+	if (primaryBaseUrl === "https://api.hexclave.com") return ["https://api1.hexclave.com", "https://api2.hexclave.com"];
+	if (primaryBaseUrl === "https://api.dev.hexclave.com") return ["https://api1.dev.hexclave.com", "https://api2.dev.hexclave.com"];
+	if (primaryBaseUrl === "https://api.stack-auth.com") return ["https://api1.stack-auth.com", "https://api2.stack-auth.com"];
+	if (primaryBaseUrl === "https://api.dev.stack-auth.com") return ["https://api1.dev.stack-auth.com", "https://api2.dev.stack-auth.com"];
+	const localhostMatch = primaryBaseUrl.match(/^http:\/\/localhost:(\d+)02$/);
+	if (localhostMatch) return [`http://localhost:${localhostMatch[1]}10`];
+	return [];
+}
+function getDefaultApiUrls(primaryBaseUrl) {
+	return [primaryBaseUrl, ...getHardcodedFallbackUrls(primaryBaseUrl)];
+}
+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;
+	if (url.hostname === "[::1]" || url.hostname === "::1") return true;
+	return false;
+}
+(void 0)?.test("isLocalhost", ({ expect }) => {
+	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);
+	expect(isLocalhost("http://[::1]")).toBe(true);
+	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);
+	expect(isLocalhost(new URL("http://localhost"))).toBe(true);
+	expect(isLocalhost(new URL("https://example.com"))).toBe(false);
+	expect(isLocalhost("not a url")).toBe(false);
+	expect(isLocalhost("")).toBe(false);
+});
+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;
+}
+(void 0)?.test("isRelative", ({ expect }) => {
+	expect(isRelative("/")).toBe(true);
+	expect(isRelative("/path")).toBe(true);
+	expect(isRelative("/path?query=value#hash")).toBe(true);
+	expect(isRelative("https://example.com")).toBe(false);
+	expect(isRelative("http://example.com")).toBe(false);
+	expect(isRelative("//example.com")).toBe(false);
+	expect(isRelative("")).toBe(true);
+	expect(isRelative("not a url")).toBe(true);
+});
+function getRelativePart(url) {
+	return url.pathname + url.search + url.hash;
+}
+(void 0)?.test("getRelativePart", ({ expect }) => {
+	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");
+	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.
+*/
+function url(strings, ...values) {
+	return new URL(urlString(strings, ...values));
+}
+(void 0)?.test("url", ({ expect }) => {
+	expect(url`https://example.com`).toBeInstanceOf(URL);
+	expect(url`https://example.com`.href).toBe("https://example.com/");
+	expect(url`https://example.com/${"path"}`).toBeInstanceOf(URL);
+	expect(url`https://example.com/${"path"}`.pathname).toBe("/path");
+	expect(url`https://example.com/${42}`).toBeInstanceOf(URL);
+	expect(url`https://example.com/${42}`.pathname).toBe("/42");
+	expect(url`https://example.com/${true}`).toBeInstanceOf(URL);
+	expect(url`https://example.com/${true}`.pathname).toBe("/true");
+	expect(url`https://example.com/${"path with spaces"}`).toBeInstanceOf(URL);
+	expect(url`https://example.com/${"path with spaces"}`.pathname).toBe("/path%20with%20spaces");
+	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.
+*/
+function urlString(strings, ...values) {
+	return templateIdentity(strings, ...values.map(encodeURIComponent));
+}
+(void 0)?.test("urlString", ({ expect }) => {
+	expect(urlString`https://example.com`).toBe("https://example.com");
+	expect(urlString`https://example.com/${"path"}`).toBe("https://example.com/path");
+	expect(urlString`https://example.com/${42}`).toBe("https://example.com/42");
+	expect(urlString`https://example.com/${true}`).toBe("https://example.com/true");
+	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");
+	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");
+});
+function isChildUrl(parentUrl, maybeChildUrl) {
+	return parentUrl.origin === maybeChildUrl.origin && isChildPath(parentUrl.pathname, maybeChildUrl.pathname) && [...parentUrl.searchParams].every(([key, value]) => maybeChildUrl.searchParams.get(key) === value) && (!parentUrl.hash || parentUrl.hash === maybeChildUrl.hash);
+}
+(void 0)?.test("isChildUrl", ({ expect }) => {
+	expect(isChildUrl(new URL("https://abc.com/"), new URL("https://abc.com/"))).toBe(true);
+	expect(isChildUrl(new URL("https://abc.com/"), new URL("https://abc.com/path"))).toBe(true);
+	expect(isChildUrl(new URL("https://abc.com/"), new URL("https://abc.com/path?query=value"))).toBe(true);
+	expect(isChildUrl(new URL("https://abc.com/"), new URL("https://abc.com/path?query=value#hash"))).toBe(true);
+	expect(isChildUrl(new URL("https://abc.com"), new URL("https://example.com"))).toBe(false);
+	expect(isChildUrl(new URL("https://abc.com/"), new URL("https://example.com/path"))).toBe(false);
+	expect(isChildUrl(new URL("https://abc.com/"), new URL("https://example.com/path?query=value"))).toBe(false);
+	expect(isChildUrl(new URL("https://abc.com/"), new URL("https://example.com/path?query=value#hash"))).toBe(false);
+	expect(isChildUrl(new URL("https://example.com"), new URL("https://abc.com/path?query=value#hash"))).toBe(false);
+	expect(isChildUrl(new URL("https://example.com?query=value123"), new URL("https://example.com/path?query=value#hash"))).toBe(false);
+});
+function isChildPath(parentPath, maybeChildPath) {
+	parentPath = parentPath.endsWith("/") ? parentPath : parentPath + "/";
+	maybeChildPath = maybeChildPath.endsWith("/") ? maybeChildPath : maybeChildPath + "/";
+	return maybeChildPath.startsWith(parentPath);
+}
+(void 0)?.test("isSubPath", ({ expect }) => {
+	expect(isChildPath("/", "/")).toBe(true);
+	expect(isChildPath("/", "/path")).toBe(true);
+	expect(isChildPath("/path", "/")).toBe(false);
+	expect(isChildPath("/path", "/path")).toBe(true);
+	expect(isChildPath("/path/", "/path")).toBe(true);
+	expect(isChildPath("/path", "/path/")).toBe(true);
+	expect(isChildPath("/path/", "/path/")).toBe(true);
+	expect(isChildPath("/path", "/path/abc")).toBe(true);
+	expect(isChildPath("/path/", "/path/abc")).toBe(true);
+	expect(isChildPath("/path", "/path-abc")).toBe(false);
+	expect(isChildPath("/path", "/path-abc/")).toBe(false);
+	expect(isChildPath("/path/", "/path-abc")).toBe(false);
+	expect(isChildPath("/path/", "/path-abc/")).toBe(false);
+});
+
+//#endregion
+export { createUrlIfValid, getDefaultApiUrls, getHardcodedFallbackUrls, getRelativePart, isChildPath, isChildUrl, isLocalhost, isRelative, isValidHostname, isValidHostnameWithWildcards, isValidUrl, matchHostnamePattern, url, urlString };
+//# sourceMappingURL=urls.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"urls.js","names":[],"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}\nimport.meta.vitest?.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}\nimport.meta.vitest?.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  // Basic validation\n  if (!hostname || hostname.startsWith('.') || hostname.endsWith('.') || hostname.includes('..')) {\n    return false;\n  }\n\n  const url = createUrlIfValid(`https://${hostname}`);\n  if (!url) return false;\n  return url.hostname === hostname;\n}\nimport.meta.vitest?.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 isValidHostnameWithWildcards(hostname: string) {\n  // Empty hostnames are invalid\n  if (!hostname) return false;\n\n  // Check if it contains wildcards\n  const hasWildcard = hostname.includes('*');\n\n  if (!hasWildcard) {\n    // If no wildcards, validate as a normal hostname\n    return isValidHostname(hostname);\n  }\n\n  // Basic validation checks that apply even with wildcards\n  // - Hostname cannot start or end with a dot\n  if (hostname.startsWith('.') || hostname.endsWith('.')) {\n    return false;\n  }\n\n  // - No consecutive dots\n  if (hostname.includes('..')) {\n    return false;\n  }\n\n  // For wildcard validation, check that non-wildcard parts contain valid characters\n  // Replace wildcards with a valid placeholder to check the rest\n  const testHostname = hostname.replace(/\\*+/g, 'wildcard');\n\n  // Check if the resulting string would be a valid hostname\n  if (!/^[a-zA-Z0-9.-]+$/.test(testHostname)) {\n    return false;\n  }\n\n  // Additional check: ensure the pattern makes sense\n  // Check each segment between wildcards\n  const segments = hostname.split(/\\*+/);\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i];\n    if (segment === '') continue; // Empty segments are OK (consecutive wildcards)\n\n    // First segment can't start with dot\n    if (i === 0 && segment.startsWith('.')) {\n      return false;\n    }\n\n    // Last segment can't end with dot\n    if (i === segments.length - 1 && segment.endsWith('.')) {\n      return false;\n    }\n\n    // No segment should have consecutive dots\n    if (segment.includes('..')) {\n      return false;\n    }\n  }\n\n  return true;\n}\nimport.meta.vitest?.test(\"isValidHostnameWithWildcards\", ({ expect }) => {\n  // Test with valid regular hostnames\n  expect(isValidHostnameWithWildcards(\"example.com\")).toBe(true);\n  expect(isValidHostnameWithWildcards(\"localhost\")).toBe(true);\n  expect(isValidHostnameWithWildcards(\"sub.domain.example.com\")).toBe(true);\n\n  // Test with valid wildcard hostnames\n  expect(isValidHostnameWithWildcards(\"*.example.com\")).toBe(true);\n  expect(isValidHostnameWithWildcards(\"a-*.example.com\")).toBe(true);\n  expect(isValidHostnameWithWildcards(\"*.*.org\")).toBe(true);\n  expect(isValidHostnameWithWildcards(\"**.example.com\")).toBe(true);\n  expect(isValidHostnameWithWildcards(\"sub.**.com\")).toBe(true);\n  expect(isValidHostnameWithWildcards(\"*-api.*.com\")).toBe(true);\n\n  // Test with invalid hostnames\n  expect(isValidHostnameWithWildcards(\"\")).toBe(false);\n  expect(isValidHostnameWithWildcards(\"example.com/path\")).toBe(false);\n  expect(isValidHostnameWithWildcards(\"https://example.com\")).toBe(false);\n  expect(isValidHostnameWithWildcards(\"example com\")).toBe(false);\n  expect(isValidHostnameWithWildcards(\".example.com\")).toBe(false);\n  expect(isValidHostnameWithWildcards(\"example.com.\")).toBe(false);\n  expect(isValidHostnameWithWildcards(\"example..com\")).toBe(false);\n  expect(isValidHostnameWithWildcards(\"*.example..com\")).toBe(false);\n});\n\nexport function matchHostnamePattern(pattern: string, hostname: string): boolean {\n  // If no wildcards, it's an exact match\n  if (!pattern.includes('*')) {\n    return pattern === hostname;\n  }\n\n  // Convert the pattern to a regex\n  // First, escape all regex special characters except *\n  let regexPattern = pattern.replace(/[.+?^${}()|[\\]\\\\]/g, '\\\\$&');\n\n  // Use a placeholder for ** to handle it separately from single *\n  const doubleWildcardPlaceholder = '\\x00DOUBLE_WILDCARD\\x00';\n  regexPattern = regexPattern.replace(/\\*\\*/g, doubleWildcardPlaceholder);\n\n  // Replace single * with a pattern that matches anything except dots\n  regexPattern = regexPattern.replace(/\\*/g, '[^.]*');\n\n  // Replace the double wildcard placeholder with a pattern that matches anything including dots\n  regexPattern = regexPattern.replace(new RegExp(doubleWildcardPlaceholder, 'g'), '.*');\n\n  // Anchor the pattern to match the entire hostname\n  regexPattern = '^' + regexPattern + '$';\n\n  try {\n    const regex = new RegExp(regexPattern);\n    return regex.test(hostname);\n  } catch {\n    return false;\n  }\n}\nimport.meta.vitest?.test(\"matchHostnamePattern\", ({ expect }) => {\n  // Test exact matches\n  expect(matchHostnamePattern(\"example.com\", \"example.com\")).toBe(true);\n  expect(matchHostnamePattern(\"example.com\", \"other.com\")).toBe(false);\n\n  // Test single wildcard matches\n  expect(matchHostnamePattern(\"*.example.com\", \"api.example.com\")).toBe(true);\n  expect(matchHostnamePattern(\"*.example.com\", \"www.example.com\")).toBe(true);\n  expect(matchHostnamePattern(\"*.example.com\", \"example.com\")).toBe(false);\n  expect(matchHostnamePattern(\"*.example.com\", \"api.v2.example.com\")).toBe(false);\n\n  // Test double wildcard matches\n  expect(matchHostnamePattern(\"**.example.com\", \"api.example.com\")).toBe(true);\n  expect(matchHostnamePattern(\"**.example.com\", \"api.v2.example.com\")).toBe(true);\n  expect(matchHostnamePattern(\"**.example.com\", \"a.b.c.example.com\")).toBe(true);\n  expect(matchHostnamePattern(\"**.example.com\", \"example.com\")).toBe(false);\n\n  // Test complex patterns\n  expect(matchHostnamePattern(\"api-*.example.com\", \"api-v1.example.com\")).toBe(true);\n  expect(matchHostnamePattern(\"api-*.example.com\", \"api-v2.example.com\")).toBe(true);\n  expect(matchHostnamePattern(\"api-*.example.com\", \"api.example.com\")).toBe(false);\n  expect(matchHostnamePattern(\"*.*.org\", \"mail.example.org\")).toBe(true);\n  expect(matchHostnamePattern(\"*.*.org\", \"example.org\")).toBe(false);\n});\n\nexport function getHardcodedFallbackUrls(primaryBaseUrl: string): string[] {\n  if (primaryBaseUrl === \"https://api.hexclave.com\") {\n    return [\"https://api1.hexclave.com\", \"https://api2.hexclave.com\"];\n  }\n  if (primaryBaseUrl === \"https://api.dev.hexclave.com\") {\n    return [\"https://api1.dev.hexclave.com\", \"https://api2.dev.hexclave.com\"];\n  }\n  // Backward-compat: customers with explicit `baseUrl: \"https://api.stack-auth.com\"`\n  // (the pre-rebrand canonical) keep the same fallbacks they had before. Both\n  // hostnames resolve to the same backend during the deprecation window.\n  if (primaryBaseUrl === \"https://api.stack-auth.com\") {\n    return [\"https://api1.stack-auth.com\", \"https://api2.stack-auth.com\"];\n  }\n  if (primaryBaseUrl === \"https://api.dev.stack-auth.com\") {\n    return [\"https://api1.dev.stack-auth.com\", \"https://api2.dev.stack-auth.com\"];\n  }\n  const localhostMatch = primaryBaseUrl.match(/^http:\\/\\/localhost:(\\d+)02$/);\n  if (localhostMatch) {\n    return [`http://localhost:${localhostMatch[1]}10`];\n  }\n  return [];\n}\n\nexport function getDefaultApiUrls(primaryBaseUrl: string): string[] {\n  return [primaryBaseUrl, ...getHardcodedFallbackUrls(primaryBaseUrl)];\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  if (url.hostname === \"[::1]\" || url.hostname === \"::1\") return true;\n  return false;\n}\nimport.meta.vitest?.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  expect(isLocalhost(\"http://[::1]\")).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}\nimport.meta.vitest?.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}\nimport.meta.vitest?.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}\nimport.meta.vitest?.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}\nimport.meta.vitest?.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\nexport function isChildUrl(parentUrl: URL, maybeChildUrl: URL) {\n  return parentUrl.origin === maybeChildUrl.origin\n    && isChildPath(parentUrl.pathname, maybeChildUrl.pathname)\n    && [...parentUrl.searchParams].every(([key, value]) => maybeChildUrl.searchParams.get(key) === value)\n    && (!parentUrl.hash || parentUrl.hash === maybeChildUrl.hash);\n}\nimport.meta.vitest?.test(\"isChildUrl\", ({ expect }) => {\n  // true\n  expect(isChildUrl(new URL(\"https://abc.com/\"), new URL(\"https://abc.com/\"))).toBe(true);\n  expect(isChildUrl(new URL(\"https://abc.com/\"), new URL(\"https://abc.com/path\"))).toBe(true);\n  expect(isChildUrl(new URL(\"https://abc.com/\"), new URL(\"https://abc.com/path?query=value\"))).toBe(true);\n  expect(isChildUrl(new URL(\"https://abc.com/\"), new URL(\"https://abc.com/path?query=value#hash\"))).toBe(true);\n\n  // false\n  expect(isChildUrl(new URL(\"https://abc.com\"), new URL(\"https://example.com\"))).toBe(false);\n  expect(isChildUrl(new URL(\"https://abc.com/\"), new URL(\"https://example.com/path\"))).toBe(false);\n  expect(isChildUrl(new URL(\"https://abc.com/\"), new URL(\"https://example.com/path?query=value\"))).toBe(false);\n  expect(isChildUrl(new URL(\"https://abc.com/\"), new URL(\"https://example.com/path?query=value#hash\"))).toBe(false);\n  expect(isChildUrl(new URL(\"https://example.com\"), new URL(\"https://abc.com/path?query=value#hash\"))).toBe(false);\n  expect(isChildUrl(new URL(\"https://example.com?query=value123\"), new URL(\"https://example.com/path?query=value#hash\"))).toBe(false);\n});\n\nexport function isChildPath(parentPath: string, maybeChildPath: string) {\n  parentPath = parentPath.endsWith(\"/\") ? parentPath : parentPath + \"/\";\n  maybeChildPath = maybeChildPath.endsWith(\"/\") ? maybeChildPath : maybeChildPath + \"/\";\n  return maybeChildPath.startsWith(parentPath);\n}\nimport.meta.vitest?.test(\"isSubPath\", ({ expect }) => {\n  expect(isChildPath(\"/\", \"/\")).toBe(true);\n  expect(isChildPath(\"/\", \"/path\")).toBe(true);\n  expect(isChildPath(\"/path\", \"/\")).toBe(false);\n  expect(isChildPath(\"/path\", \"/path\")).toBe(true);\n  expect(isChildPath(\"/path/\", \"/path\")).toBe(true);\n  expect(isChildPath(\"/path\", \"/path/\")).toBe(true);\n  expect(isChildPath(\"/path/\", \"/path/\")).toBe(true);\n  expect(isChildPath(\"/path\", \"/path/abc\")).toBe(true);\n  expect(isChildPath(\"/path/\", \"/path/abc\")).toBe(true);\n  expect(isChildPath(\"/path\", \"/path-abc\")).toBe(false);\n  expect(isChildPath(\"/path\", \"/path-abc/\")).toBe(false);\n  expect(isChildPath(\"/path/\", \"/path-abc\")).toBe(false);\n  expect(isChildPath(\"/path/\", \"/path-abc/\")).toBe(false);\n});\n"],"mappings":"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"}

package/dist/esm/utils/uuids.d.ts

@@ -0,0 +1,6 @@
+//#region src/utils/uuids.d.ts
+declare function generateUuid(): string;
+declare function isUuid(str: string): boolean;
+//#endregion
+export { generateUuid, isUuid };
+//# sourceMappingURL=uuids.d.ts.map

package/dist/esm/utils/uuids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuids.d.ts","names":[],"sources":["../../../src/utils/uuids.tsx"],"mappings":";iBAEgB,YAAA,CAAA;AAAA,iBAsBA,MAAA,CAAO,GAAA"}

package/dist/esm/utils/uuids.js

@@ -0,0 +1,36 @@
+import { generateRandomValues } from "./crypto.js";
+
+//#region src/utils/uuids.tsx
+function generateUuid() {
+	return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ generateRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16));
+}
+(void 0)?.test("generateUuid", ({ expect }) => {
+	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}$/);
+	const uuid2 = generateUuid();
+	expect(uuid).not.toBe(uuid2);
+	expect(uuid.charAt(14)).toBe("4");
+	expect("89ab").toContain(uuid.charAt(19));
+});
+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);
+}
+(void 0)?.test("isUuid", ({ expect }) => {
+	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);
+	expect(isUuid("")).toBe(false);
+	expect(isUuid("not-a-uuid")).toBe(false);
+	expect(isUuid("123e4567-e89b-12d3-a456-426614174000")).toBe(false);
+	expect(isUuid("123e4567-e89b-42d3-c456-426614174000")).toBe(false);
+	expect(isUuid("123e4567-e89b-42d3-a456-42661417400")).toBe(false);
+	expect(isUuid("123e4567-e89b-42d3-a456-4266141740000")).toBe(false);
+	expect(isUuid("123e4567-e89b-42d3-a456_426614174000")).toBe(false);
+	expect(isUuid("123E4567-E89B-42D3-A456-426614174000")).toBe(false);
+});
+
+//#endregion
+export { generateUuid, isUuid };
+//# sourceMappingURL=uuids.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uuids.js","names":[],"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}\nimport.meta.vitest?.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}\nimport.meta.vitest?.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":";;;AAEA,SAAgB,eAAe;AAE7B,QAAO,uCAAuC,QAAQ,WAAU,OAC7D,CAAC,IAAI,qBAAqB,IAAI,WAAW,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,IAAI,GAAG,SAAS,GAAE,CAC7E;;CAEH,SAAW,KAAC,iBAAc,EAAA,aAAkB;CAE1C,MAAM,OAAO,cAAc;AAC3B,QAAO,KAAK,CAAC,QAAQ,wEAAwE;CAG7F,MAAM,QAAQ,cAAc;AAC5B,QAAO,KAAK,CAAC,IAAI,KAAK,MAAM;AAG5B,QAAO,KAAK,OAAO,GAAG,CAAC,CAAC,KAAK,IAAI;AAGjC,QAAO,OAAO,CAAC,UAAU,KAAK,OAAO,GAAG,CAAC;EACzC;AAEF,SAAgB,OAAO,KAAa;AAClC,QAAO,wEAAwE,KAAK,IAAI;;CAE1F,SAAW,KAAC,WAAc,EAAA,aAAY;AAEpC,QAAO,OAAO,uCAAuC,CAAC,CAAC,KAAK,KAAK;AACjE,QAAO,OAAO,uCAAuC,CAAC,CAAC,KAAK,KAAK;AACjE,QAAO,OAAO,uCAAuC,CAAC,CAAC,KAAK,KAAK;AACjE,QAAO,OAAO,uCAAuC,CAAC,CAAC,KAAK,KAAK;AACjE,QAAO,OAAO,uCAAuC,CAAC,CAAC,KAAK,KAAK;AAGjE,QAAO,OAAO,GAAG,CAAC,CAAC,KAAK,MAAM;AAC9B,QAAO,OAAO,aAAa,CAAC,CAAC,KAAK,MAAM;AACxC,QAAO,OAAO,uCAAuC,CAAC,CAAC,KAAK,MAAM;AAClE,QAAO,OAAO,uCAAuC,CAAC,CAAC,KAAK,MAAM;AAClE,QAAO,OAAO,sCAAsC,CAAC,CAAC,KAAK,MAAM;AACjE,QAAO,OAAO,wCAAwC,CAAC,CAAC,KAAK,MAAM;AACnE,QAAO,OAAO,uCAAuC,CAAC,CAAC,KAAK,MAAM;AAGlE,QAAO,OAAO,uCAAuC,CAAC,CAAC,KAAK,MAAM;EAClE"}

package/dist/global.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/helpers/emails.d.ts

@@ -0,0 +1,69 @@
+//#region src/helpers/emails.d.ts
+declare const defaultNewTemplateSource: string;
+declare const previewTemplateSource: string;
+declare const emptyEmailTheme: string;
+declare const LightEmailTheme = "import { Html, Head, Tailwind, Body, Container, Section } from '@react-email/components';\nimport { ThemeProps, ProjectLogo } from \"@stackframe/emails\";\n\nexport function EmailTheme({ children, unsubscribeLink, projectLogos }: ThemeProps) {\n  return (\n    <Html>\n      <Head />\n      <Tailwind>\n        <Body className=\"bg-[#fafbfb] font-sans text-base m-0 p-0\" style={{ overflowX: 'hidden' }}>\n          <div className=\"py-8 px-4 flex justify-center\">\n            <Container className=\"bg-white p-[45px] rounded-lg shadow-sm mx-auto\" style={{ width: '100%', maxWidth: '600px' }}>\n              <ProjectLogo data={projectLogos} mode=\"light\" />\n              {children}\n            </Container>\n          </div>\n          {unsubscribeLink && (\n            <Section className=\"p-4 opacity-60 text-center\" style={{ textAlign: 'center' }}>\n              <a href={unsubscribeLink} className=\"text-blue-600\" target=\"_blank\" rel=\"noopener noreferrer\">Click here</a> to unsubscribe from these emails\n            </Section>\n          )}\n        </Body>\n      </Tailwind>\n    </Html>\n  );\n}\n\nEmailTheme.PreviewProps = {\n  unsubscribeLink: \"https://example.com\",\n} satisfies Partial<ThemeProps>\n";
+declare const DEFAULT_EMAIL_THEME_ID = "1df07ae6-abf3-4a40-83a5-a1a2cbe336ac";
+declare const DEFAULT_EMAIL_THEMES: {
+  "1df07ae6-abf3-4a40-83a5-a1a2cbe336ac": {
+    displayName: string;
+    tsxSource: string;
+  };
+  "a0172b5d-cff0-463b-83bb-85124697373a": {
+    displayName: string;
+    tsxSource: string;
+  };
+  "c7e2d94f-8a1b-4e6d-b3f5-9d0a2e7c1b8f": {
+    displayName: string;
+    tsxSource: string;
+  };
+};
+declare const DEFAULT_EMAIL_TEMPLATES: {
+  "e7d009ce-8d47-4528-b245-5bf119f2ffa3": {
+    displayName: string;
+    tsxSource: string;
+    themeId: undefined;
+  };
+  "a70fb3a4-56c1-4e42-af25-49d25603abd0": {
+    displayName: string;
+    tsxSource: string;
+    themeId: undefined;
+  };
+  "822687fe-8d0a-4467-a0d1-416b6e639478": {
+    displayName: string;
+    tsxSource: string;
+    themeId: undefined;
+  };
+  "e84de395-2076-4831-9c19-8e9a96a868e4": {
+    displayName: string;
+    tsxSource: string;
+    themeId: undefined;
+  };
+  "066dd73c-36da-4fd0-b6d6-ebf87683f8bc": {
+    displayName: string;
+    tsxSource: string;
+    themeId: undefined;
+  };
+  "70372aee-0441-4d80-974c-2e858e40123a": {
+    displayName: string;
+    tsxSource: string;
+    themeId: undefined;
+  };
+  "f64b1afe-27ec-4a28-a277-7178f3261f9a": {
+    displayName: string;
+    tsxSource: string;
+    themeId: undefined;
+  };
+};
+declare const DEFAULT_TEMPLATE_IDS: {
+  readonly email_verification: "e7d009ce-8d47-4528-b245-5bf119f2ffa3";
+  readonly password_reset: "a70fb3a4-56c1-4e42-af25-49d25603abd0";
+  readonly magic_link: "822687fe-8d0a-4467-a0d1-416b6e639478";
+  readonly team_invitation: "e84de395-2076-4831-9c19-8e9a96a868e4";
+  readonly sign_in_invitation: "066dd73c-36da-4fd0-b6d6-ebf87683f8bc";
+  readonly payment_receipt: "70372aee-0441-4d80-974c-2e858e40123a";
+  readonly payment_failed: "f64b1afe-27ec-4a28-a277-7178f3261f9a";
+};
+//#endregion
+export { DEFAULT_EMAIL_TEMPLATES, DEFAULT_EMAIL_THEMES, DEFAULT_EMAIL_THEME_ID, DEFAULT_TEMPLATE_IDS, LightEmailTheme, defaultNewTemplateSource, emptyEmailTheme, previewTemplateSource };
+//# sourceMappingURL=emails.d.ts.map

package/dist/helpers/emails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emails.d.ts","names":[],"sources":["../../src/helpers/emails.ts"],"mappings":";cAEa,wBAAA;AAAA,cA0BA,qBAAA;AAAA,cAwCA,eAAA;AAAA,cAeA,eAAA;AAAA,cA+FA,sBAAA;AAAA,cAEA,oBAAA;;;;;;;;;;;;;;cAuBA,uBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCA,oBAAA;EAAA"}