@hexclave/shared 1.0.0

package/dist/utils/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../src/utils/types.tsx"],"sourcesContent":["import { DeepPartial } from \"./objects\";\nimport { Join } from \"./strings\";\n\nexport type IsAny<T> = 0 extends (1 & T) ? true : false;\nexport type IsNever<T> = [T] extends [never] ? true : false;\nexport type IsNullish<T> = [T] extends [null | undefined] ? true : false;\nexport type IsUnion<T, U = T> =\n  IsNever<T> extends true ? false\n  : IsAny<T> extends true ? false\n    : T extends U // distributive conditional https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types\n        ? /* if the *whole* original type (`U`) still fits inside the current variant, then `T` wasn’t a union */ ([U] extends [T] ? false : true)\n        : never;\n\nexport type NullishCoalesce<T, U> = T extends null | undefined ? U : T;\n\nexport type LastUnionElement<U> = UnionToIntersection<U extends any ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L & U : never;\n\ntype primitive = string | number | boolean | bigint | symbol | null | undefined;\n\n/**\n * Makes a type prettier by recursively expanding all object types. For example, `Omit<{ a: 1 }, \"a\">` becomes just `{}`.\n */\nexport type Expand<T> = T extends (...args: infer A) => infer R\n  ? ((...args: A) => R) extends T\n    ? (...args: Expand<A>) => Expand<R>\n    : ((...args: Expand<A>) => Expand<R>) & { [K in keyof T]: Expand<T[K]> }\n  : T extends object\n    ? T extends primitive\n      ? T\n      : T extends infer O\n        ? { [K in keyof O]: Expand<O[K]> }\n        : never\n    : T;\n\n\n/**\n * Removes all optional undefined/never keys from an object.\n */\nexport type DeepRemoveOptionalUndefined<T> = T extends object ? { [K in keyof T]: DeepRemoveOptionalUndefined<T[K]> } : T;\n\n// why this works: https://stackoverflow.com/a/50375286\nexport type UnionToIntersection<U> =\n  (U extends any ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never\n\ntype _UnionToTupleInner<U, R extends any[], Last> = UnionToTuple<Exclude<U, Last>, [...R, Last]>\nexport type UnionToTuple<U, R extends any[] = []> = [U] extends [never] ? R : _UnionToTupleInner<U, R, LastUnionElement<U>>;\n\nexport type CollapseObjectUnion<T extends object> = {\n  [K in AllUnionKeys<T>]?: T extends Record<K, infer V> ? V : never;\n};\ntypeAssertIs<CollapseObjectUnion<{ a: string } | { b: number }>, { a?: string, b?: number }>()();\ntypeAssertIs<CollapseObjectUnion<{ a: string } | { a: number }>, { a?: string | number }>()();\n\nexport type IntersectAll<T extends any[]> = UnionToIntersection<T[number]>;\n\nexport type OptionalKeys<T> = {\n  [K in keyof T]: {} extends Pick<T, K> ? K : never;\n}[keyof T];\nexport type RequiredKeys<T> = {\n  [K in keyof T]: {} extends Pick<T, K> ? never : K;\n}[keyof T];\n\n/**\n * Returns a type whose keys are the intersection of the keys of T and U, deeply.\n */\nexport type KeyIntersect<T, U> =\n  & { [K in keyof T & keyof U]?: T[K] & U[K] }\n  & { [K in RequiredKeys<T> & keyof U]: T[K] & U[K] }\n  & { [K in RequiredKeys<U> & keyof T]: U[K] & T[K] }\n\n/**\n * Returns ALL keys of all union elements.\n */\nexport type AllUnionKeys<T extends object> = T extends T ? keyof T : never;\ntypeAssertIs<AllUnionKeys<{ a: string } | { b: number }>, \"a\" | \"b\">()();\n\nexport type SubtractType<T, U> = T extends object ? { [K in keyof T]: K extends keyof U ? SubtractType<T[K], U[K]> : T[K] } : (T extends U ? never : T); // note: this only works due to the distributive property of conditional types https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types\n\nexport type XOR<T extends readonly any[]> = T extends readonly [infer A, infer B, ...infer Rest]\n  ? Rest extends []\n  ? (A & { [K in keyof B]?: never }) | (B & { [K in keyof A]?: never })\n  : XOR<[(A & { [K in keyof B]?: never }) | (B & { [K in keyof A]?: never }), ...Rest]>\n  : T[0];\n\n\ntype _AntiIntersectInner<T, U> = T extends object ? (\n  & Omit<U, keyof T>\n  & { [K in keyof Pick<U, { [K in keyof T & keyof U]: U[K] extends T[K] ? (T[K] extends U[K] ? never : K) : never }[keyof T & keyof U]>]: PseudoAntiIntersect<T[K], U[K]> }\n  & { [K in keyof Pick<U, keyof T & keyof U>]?: PseudoAntiIntersect<T[K], U[K]> }\n) : U;\n/**\n * Returns a type R such that T & R = U.\n */\nexport type AntiIntersect<T, U> = U extends T ? _AntiIntersectInner<T, U> : \"Cannot anti-intersect a type with a type that is not a subtype of it\"; // NOTE: This type is mostly untested — not sure how well it works on the edge cases\nexport type PseudoAntiIntersect<T, U> = _AntiIntersectInner<T, T & U>;\n\n/**\n * A variation of TypeScript's conditionals with slightly different semantics. It is the perfect type for cases where:\n *\n * - If all possible values are contained in `Extends`, then it will be mapped to `Then`.\n * - If all possible values are not contained in `Extends`, then it will be mapped to `Otherwise`.\n * - If some possible values are contained in `Extends` and some are not, then it will be mapped to `Then | Otherwise`.\n *\n * This is different from TypeScript's built-in conditional types (`Value extends Extends ? Then : Otherwise`), which\n * returns `Otherwise` for the third case (causing unsoundness in many real-world cases).\n */\nexport type IfAndOnlyIf<Value, Extends, Then, Otherwise> =\n  | (Value extends Extends ? never : Otherwise)\n  | (Value & Extends extends never ? never : Then);\n\n\n/**\n * Can be used to prettify a type in the IDE; for example, some complicated intersected types can be flattened into a single type.\n */\nexport type PrettifyType<T> = T extends object ? { [K in keyof T]: T[K] } & {} : T;\n\ntype _ToStringAndJoin<T extends any[], Separator extends string> =\n  T extends [infer U, ...infer Rest extends any[]]\n    ? `${TypeToString<U>}${Rest extends [any, ...any[]] ? `${Separator}${_ToStringAndJoin<Rest, Separator>}` : \"\"}`\n    : \"<error-joining-tuple-elements>\";\ntype _TypeToStringInner<T> =\n  IsAny<T> extends true ? \"any\"\n  : IsNever<T> extends true ? \"never\"\n  : IsUnion<T> extends true ? _ToStringAndJoin<UnionToTuple<T>, \" | \">\n  : [T] extends [number] ? (number extends T ? \"number\" : `${T}`)\n  : [T] extends [boolean] ? `${T}`\n  : [T] extends [undefined] ? \"undefined\"\n  : [T] extends [null] ? \"null\"\n  : [T] extends [string] ? (string extends T ? \"string\" : `'${T}'`)\n  : [T] extends [[]] ? \"[]\"\n  : [T] extends [[any, ...any[]]] ? `[${_ToStringAndJoin<T, \", \">}]`\n  : [T] extends [(infer E)[]] ? `${TypeToString<E>}[]`\n  : [T] extends [Function] ? \"function\"\n  : [T] extends [symbol] ? `symbol(${T['description']})`\n  : [T] extends [object] ? `{ ${Join<UnionToTuple<{ [K in keyof T]: `${TypeToString<K>}: ${TypeToString<T[K]>}` }[keyof T]>, \", \">} }`\n  : \"<unknown-type>\"\nexport type TypeToString<T> = _TypeToStringInner<T> extends `${infer S}` ? S : never;\n\n/**\n * Can be used to create assertions on types. For example, if passed any T other than `true`, the following will\n * show a type error:\n *\n * ```ts\n * typeAssert<T>()();  // the second pair of braces is important!\n * ```\n */\nexport function typeAssert<T>(): (\n  IsAny<T> extends true ? TypeAssertionError<`Type assertion failed. Expected true, but got any.`>\n    : IsNever<T> extends true ? TypeAssertionError<`Type assertion failed. Expected true, but got never.`>\n    : T extends true ? (() => undefined)\n    : TypeAssertionError<`Type assertion failed. Expected true, but got: ${TypeToString<T>}`>\n) {\n  return (() => undefined) as any;\n}\ntype TypeAssertionError<T> =\n  & [T]\n  & /* this promise makes sure that if we accidentally forget the second pair of braces, eslint will complain (if we have no-floating-promises enabled) */ Promise<any>;\n\n\ntypeAssertExtends<ReturnType<typeof typeAssert<true>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssert<false>>, TypeAssertionError<`Type assertion failed. Expected true, but got: false`>>()();\ntypeAssertExtends<ReturnType<typeof typeAssert<never>>, TypeAssertionError<`Type assertion failed. Expected true, but got never.`>>()();\ntypeAssertExtends<ReturnType<typeof typeAssert<any>>, TypeAssertionError<`Type assertion failed. Expected true, but got any.`>>()();\n\n/**\n * Functionally equivalent to `typeAssert<T extends S ? true : false>()()`, but with better error messages.\n */\nexport function typeAssertExtends<T, S>(): (\n  [T] extends [S] ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to extend ${TypeToString<S>}`>\n) {\n  return (() => undefined) as any;\n}\n\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<never, true>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<any, true>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<false, false>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<\"abc\", string>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<{a: 1, b: 123}, {a: number}>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<never, never>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<true, any>>, () => undefined>()();\n\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<{a: number}, {a: 1}>>, [\"Type assertion failed. Expected { 'a': number } to extend { 'a': 1 }\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<any, never>>, [\"Type assertion failed. Expected any to extend never\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<false, true>>, [\"Type assertion failed. Expected false to extend true\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<false, never>>, [\"Type assertion failed. Expected false to extend never\"]>()();\n\n\nexport function typeAssertIs<T, U>(): (\n  IsAny<T> extends true ? (IsAny<U> extends true ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>)\n    : IsAny<U> extends true ? TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>\n    : [T] extends [U] ? ([U] extends [T] ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>)\n    : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>\n) {\n  return (() => undefined) as any;\n}\n\ntypeAssertExtends<ReturnType<typeof typeAssertIs<\"123\", \"123\">>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<{a: 1}, {a: 1}>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<DeepPartial<{a: 1}>, {a?: 1}>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<any, any>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<never, never>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<1, any>>, [\"Type assertion failed. Expected 1 to be any\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<any, 1>>, [\"Type assertion failed. Expected any to be 1\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<false, true>>, [\"Type assertion failed. Expected false to be true\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<{a: number}, {a: 1}>>, [\"Type assertion failed. Expected { 'a': number } to be { 'a': 1 }\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<any, never>>, [\"Type assertion failed. Expected any to be never\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<false, true>>, [\"Type assertion failed. Expected false to be true\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<false, never>>, [\"Type assertion failed. Expected false to be never\"]>()();\n"],"mappings":";;;AAkDA,cAA8F,EAAE;AAChG,cAA2F,EAAE;AAuB7F,cAAsE,EAAE;;;;;;;;;AAwExE,SAAgB,aAKd;AACA,eAAc;;AAOhB,mBAAyE,EAAE;AAC3E,mBAAqI,EAAE;AACvI,mBAAqI,EAAE;AACvI,mBAAiI,EAAE;;;;AAKnI,SAAgB,oBAEd;AACA,eAAc;;AAGhB,mBAAuF,EAAE;AACzF,mBAAqF,EAAE;AACvF,mBAAwF,EAAE;AAC1F,mBAAyF,EAAE;AAC3F,mBAAuG,EAAE;AACzG,mBAAwF,EAAE;AAC1F,mBAAqF,EAAE;AAEvF,mBAAwJ,EAAE;AAC1J,mBAA8H,EAAE;AAChI,mBAAgI,EAAE;AAClI,mBAAkI,EAAE;AAGpI,SAAgB,eAKd;AACA,eAAc;;AAGhB,mBAAmF,EAAE;AACrF,mBAAqF,EAAE;AACvF,mBAAmG,EAAE;AACrG,mBAA+E,EAAE;AACjF,mBAAmF,EAAE;AACrF,mBAA6G,EAAE;AAC/G,mBAA6G,EAAE;AAC/G,mBAAuH,EAAE;AACzH,mBAA+I,EAAE;AACjJ,mBAAqH,EAAE;AACvH,mBAAuH,EAAE;AACzH,mBAAyH,EAAE"}

package/dist/utils/unicode.d.ts

@@ -0,0 +1,5 @@
+//#region src/utils/unicode.d.ts
+declare function getFlagEmoji(twoLetterCountryCode: string): string;
+//#endregion
+export { getFlagEmoji };
+//# sourceMappingURL=unicode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unicode.d.ts","names":[],"sources":["../../src/utils/unicode.tsx"],"mappings":";iBAGgB,YAAA,CAAa,oBAAA"}

package/dist/utils/unicode.js

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let __errors_js = require("./errors.js");
+let __country_codes_js = require("./country-codes.js");
+
+//#region src/utils/unicode.tsx
+function getFlagEmoji(twoLetterCountryCode) {
+	if (!(0, __country_codes_js.isValidCountryCode)(twoLetterCountryCode)) throw new __errors_js.HexclaveAssertionError("Country code must be two alphabetical letters");
+	const codePoints = (0, __country_codes_js.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
+exports.getFlagEmoji = getFlagEmoji;
+//# sourceMappingURL=unicode.js.map

package/dist/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,4CAAoB,qBAAqB,CAAE,OAAM,IAAI,mCAAuB,gDAAgD;CAChI,MAAM,0DAAkC,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/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/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/utils/urls.js

@@ -0,0 +1,274 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let __crypto_js = require("./crypto.js");
+let __strings_js = require("./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 = `${(0, __crypto_js.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 (0, __strings_js.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
+exports.createUrlIfValid = createUrlIfValid;
+exports.getDefaultApiUrls = getDefaultApiUrls;
+exports.getHardcodedFallbackUrls = getHardcodedFallbackUrls;
+exports.getRelativePart = getRelativePart;
+exports.isChildPath = isChildPath;
+exports.isChildUrl = isChildUrl;
+exports.isLocalhost = isLocalhost;
+exports.isRelative = isRelative;
+exports.isValidHostname = isValidHostname;
+exports.isValidHostnameWithWildcards = isValidHostnameWithWildcards;
+exports.isValidUrl = isValidUrl;
+exports.matchHostnamePattern = matchHostnamePattern;
+exports.url = url;
+exports.urlString = urlString;
+//# sourceMappingURL=urls.js.map

package/dist/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/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/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/utils/uuids.js

@@ -0,0 +1,39 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let __crypto_js = require("./crypto.js");
+
+//#region src/utils/uuids.tsx
+function generateUuid() {
+	return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ (0, __crypto_js.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
+exports.generateUuid = generateUuid;
+exports.isUuid = isUuid;
+//# sourceMappingURL=uuids.js.map

package/dist/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,0CAAyB,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/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@hexclave/shared",
+  "version": "1.0.0",
+  "repository": "https://github.com/hexclave/hexclave",
+  "files": [
+    "README.md",
+    "dist",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": {
+        "default": "./dist/index.js"
+      },
+      "default": "./dist/esm/index.js"
+    },
+    "./config": {
+      "types": "./dist/config-authoring.d.ts",
+      "require": {
+        "default": "./dist/config-authoring.js"
+      },
+      "default": "./dist/esm/config-authoring.js"
+    },
+    "./dist/*": {
+      "types": "./dist/*.d.ts",
+      "require": {
+        "default": "./dist/*.js"
+      },
+      "default": "./dist/esm/*.js"
+    }
+  },
+  "peerDependencies": {
+    "@types/react": ">=19.0.0",
+    "@types/react-dom": ">=19.0.0",
+    "react": ">=19.0.0",
+    "react-dom": ">=19.0.0",
+    "yup": "^1.7.1"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "@types/react": {
+      "optional": true
+    },
+    "@types/react-dom": {
+      "optional": true
+    },
+    "yup": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@aws-sdk/client-kms": "^3.876.0",
+    "@aws-sdk/credential-provider-web-identity": "^3.972.27",
+    "@babel/core": "^7.28.5",
+    "@babel/generator": "^7.28.5",
+    "@babel/parser": "^7.28.5",
+    "@babel/traverse": "^7.28.5",
+    "@babel/types": "^7.28.5",
+    "@opentelemetry/api": "^1.9.0",
+    "@simplewebauthn/browser": "^11.0.0",
+    "@vercel/functions": "^2.0.0",
+    "async-mutex": "^0.5.0",
+    "bcryptjs": "^3.0.2",
+    "crc": "^4.3.2",
+    "elliptic": "^6.5.7",
+    "esbuild-wasm": "^0.20.2",
+    "ip-regex": "^5.0.0",
+    "jose": "^6.1.3",
+    "oauth4webapi": "^3.8.3",
+    "semver": "^7.6.3",
+    "uuid": "^9.0.1"
+  },
+  "devDependencies": {
+    "@sentry/nextjs": "^10.11.0",
+    "@simplewebauthn/types": "^11.0.0",
+    "@types/babel__core": "^7.20.5",
+    "@types/babel__generator": "^7.27.0",
+    "@types/babel__traverse": "^7.28.0",
+    "@types/bcryptjs": "^3.0.0",
+    "@types/elliptic": "^6.4.18",
+    "@types/semver": "^7.5.8",
+    "@types/uuid": "^9.0.8",
+    "react": "^19.0.1",
+    "react-dom": "^19.0.1",
+    "rimraf": "^6.1.2"
+  },
+  "scripts": {
+    "build": "rimraf dist && tsdown",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "clean": "rimraf dist && rimraf node_modules",
+    "dev": "tsdown --watch",
+    "lint": "eslint --ext .tsx,.ts ."
+  }
+}