@hexclave/shared 1.0.41 → 1.0.42

package/dist/utils/turnstile.js.map

@@ -1 +1 @@
-{"version":3,"file":"turnstile.js","names":[],"sources":["../../src/utils/turnstile.ts"],"sourcesContent":["export const turnstileActionValues = [\n  \"sign_up_with_credential\",\n  \"send_magic_link_email\",\n  \"oauth_authenticate\",\n] as const;\n\nexport type TurnstileAction = typeof turnstileActionValues[number];\n\nexport const turnstilePhaseValues = [\n  \"invisible\",\n  \"visible\",\n] as const;\n\nexport type TurnstilePhase = typeof turnstilePhaseValues[number];\n\nexport const turnstileResultValues = [\n  \"ok\",\n  \"invalid\",\n  \"error\",\n] as const;\n\nexport type TurnstileResult = typeof turnstileResultValues[number];\n\nexport const turnstileDevelopmentKeys = {\n  visibleSiteKey: \"1x00000000000000000000AA\",\n  invisibleSiteKey: \"1x00000000000000000000BB\",\n  secretKey: \"1x0000000000000000000000000000000AA\",\n  forcedChallengeSiteKey: \"3x00000000000000000000FF\",\n} as const;\n\n\nexport function isTurnstileResult(value: unknown): value is TurnstileResult {\n  return typeof value === \"string\" && turnstileResultValues.some((status) => status === value);\n}\n"],"mappings":";;;AAAA,MAAa,wBAAwB;CACnC;CACA;CACA;CACD;AAID,MAAa,uBAAuB,CAClC,aACA,UACD;AAID,MAAa,wBAAwB;CACnC;CACA;CACA;CACD;AAID,MAAa,2BAA2B;CACtC,gBAAgB;CAChB,kBAAkB;CAClB,WAAW;CACX,wBAAwB;CACzB;AAGD,SAAgB,kBAAkB,OAA0C;AAC1E,QAAO,OAAO,UAAU,YAAY,sBAAsB,MAAM,WAAW,WAAW,MAAM"}
+{"version":3,"file":"turnstile.js","names":[],"sources":["../../src/utils/turnstile.ts"],"sourcesContent":["export const turnstileActionValues = [\n  \"sign_up_with_credential\",\n  \"send_magic_link_email\",\n  \"oauth_authenticate\",\n] as const;\n\nexport type TurnstileAction = typeof turnstileActionValues[number];\n\nexport const turnstilePhaseValues = [\n  \"invisible\",\n  \"visible\",\n] as const;\n\nexport type TurnstilePhase = typeof turnstilePhaseValues[number];\n\nexport const turnstileResultValues = [\n  \"ok\",\n  \"invalid\",\n  \"error\",\n] as const;\n\nexport type TurnstileResult = typeof turnstileResultValues[number];\n\nexport const turnstileDevelopmentKeys = {\n  visibleSiteKey: \"1x00000000000000000000AA\",\n  invisibleSiteKey: \"1x00000000000000000000BB\",\n  secretKey: \"1x0000000000000000000000000000000AA\",\n  forcedChallengeSiteKey: \"3x00000000000000000000FF\",\n} as const;\n\n\nexport function isTurnstileResult(value: unknown): value is TurnstileResult {\n  return typeof value === \"string\" && turnstileResultValues.some((status) => status === value);\n}\n"],"mappings":";;AAAA,MAAa,wBAAwB;CACnC;CACA;CACA;AACF;AAIA,MAAa,uBAAuB,CAClC,aACA,SACF;AAIA,MAAa,wBAAwB;CACnC;CACA;CACA;AACF;AAIA,MAAa,2BAA2B;CACtC,gBAAgB;CAChB,kBAAkB;CAClB,WAAW;CACX,wBAAwB;AAC1B;AAGA,SAAgB,kBAAkB,OAA0C;CAC1E,OAAO,OAAO,UAAU,YAAY,sBAAsB,MAAM,WAAW,WAAW,KAAK;AAC7F"}

package/dist/utils/typed-arrays.js

@@ -1,7 +1,5 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_chunk = require('../chunk-BE-pF4vm.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let __errors_js = require("./errors.js");
-
 //#region src/utils/typed-arrays.tsx
 /**
 * Ensures a Uint8Array is backed by a regular ArrayBuffer (not SharedArrayBuffer).
@@ -16,7 +14,7 @@ function toArrayBufferBacked(arr) {
 	if (arr.buffer instanceof SharedArrayBuffer) throw new __errors_js.HexclaveAssertionError("SharedArrayBuffer-backed Uint8Arrays are not supported in this context");
 	return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
 }
-
 //#endregion
 exports.toArrayBufferBacked = toArrayBufferBacked;
+
 //# sourceMappingURL=typed-arrays.js.map

package/dist/utils/typed-arrays.js.map

@@ -1 +1 @@
-{"version":3,"file":"typed-arrays.js","names":["HexclaveAssertionError"],"sources":["../../src/utils/typed-arrays.tsx"],"sourcesContent":["import { HexclaveAssertionError } from \"./errors\";\n\n/**\n * Ensures a Uint8Array is backed by a regular ArrayBuffer (not SharedArrayBuffer).\n *\n * TypeScript 5.7+ made typed arrays generic over their buffer type. Bare `Uint8Array`\n * defaults to `Uint8Array<ArrayBufferLike>`, which includes SharedArrayBuffer. Web Crypto\n * APIs require `BufferSource` which only accepts `ArrayBufferView<ArrayBuffer>`. This\n * function narrows the type using an instanceof guard, creating a same-buffer view\n * (zero-copy) when the buffer is already an ArrayBuffer.\n */\nexport function toArrayBufferBacked(arr: Uint8Array): Uint8Array<ArrayBuffer> {\n  if (arr.buffer instanceof SharedArrayBuffer) {\n    throw new HexclaveAssertionError(\"SharedArrayBuffer-backed Uint8Arrays are not supported in this context\");\n  }\n  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n"],"mappings":";;;;;;;;;;;;;;AAWA,SAAgB,oBAAoB,KAA0C;AAC5E,KAAI,IAAI,kBAAkB,kBACxB,OAAM,IAAIA,mCAAuB,yEAAyE;AAE5G,QAAO,IAAI,WAAW,IAAI,QAAQ,IAAI,YAAY,IAAI,WAAW"}
+{"version":3,"file":"typed-arrays.js","names":["HexclaveAssertionError"],"sources":["../../src/utils/typed-arrays.tsx"],"sourcesContent":["import { HexclaveAssertionError } from \"./errors\";\n\n/**\n * Ensures a Uint8Array is backed by a regular ArrayBuffer (not SharedArrayBuffer).\n *\n * TypeScript 5.7+ made typed arrays generic over their buffer type. Bare `Uint8Array`\n * defaults to `Uint8Array<ArrayBufferLike>`, which includes SharedArrayBuffer. Web Crypto\n * APIs require `BufferSource` which only accepts `ArrayBufferView<ArrayBuffer>`. This\n * function narrows the type using an instanceof guard, creating a same-buffer view\n * (zero-copy) when the buffer is already an ArrayBuffer.\n */\nexport function toArrayBufferBacked(arr: Uint8Array): Uint8Array<ArrayBuffer> {\n  if (arr.buffer instanceof SharedArrayBuffer) {\n    throw new HexclaveAssertionError(\"SharedArrayBuffer-backed Uint8Arrays are not supported in this context\");\n  }\n  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n"],"mappings":";;;;;;;;;;;;AAWA,SAAgB,oBAAoB,KAA0C;CAC5E,IAAI,IAAI,kBAAkB,mBACxB,MAAM,IAAIA,YAAAA,uBAAuB,wEAAwE;CAE3G,OAAO,IAAI,WAAW,IAAI,QAAQ,IAAI,YAAY,IAAI,UAAU;AAClE"}

package/dist/utils/types.d.ts

@@ -1,77 +1,2 @@
-import { Join } from "./strings.js";
-
-//#region src/utils/types.d.ts
-type IsAny<T> = 0 extends (1 & T) ? true : false;
-type IsNever<T> = [T] extends [never] ? true : false;
-type IsNullish<T> = [T] extends [null | undefined] ? true : false;
-type IsUnion<T, U = T> = IsNever<T> extends true ? false : IsAny<T> extends true ? false : T extends U ? ([U] extends [T] ? false : true) : never;
-type NullishCoalesce<T, U> = T extends null | undefined ? U : T;
-type LastUnionElement<U> = UnionToIntersection<U extends any ? (x: U) => 0 : never> extends ((x: infer L) => 0) ? L & U : never;
-type primitive = string | number | boolean | bigint | symbol | null | undefined;
-/**
- * Makes a type prettier by recursively expanding all object types. For example, `Omit<{ a: 1 }, "a">` becomes just `{}`.
- */
-type Expand<T> = T extends ((...args: infer A) => infer R) ? ((...args: A) => R) extends T ? (...args: Expand<A>) => Expand<R> : ((...args: Expand<A>) => Expand<R>) & { [K in keyof T]: Expand<T[K]> } : T extends object ? T extends primitive ? T : T extends infer O ? { [K in keyof O]: Expand<O[K]> } : never : T;
-/**
- * Removes all optional undefined/never keys from an object.
- */
-type DeepRemoveOptionalUndefined<T> = T extends object ? { [K in keyof T]: DeepRemoveOptionalUndefined<T[K]> } : T;
-type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
-type _UnionToTupleInner<U, R extends any[], Last> = UnionToTuple<Exclude<U, Last>, [...R, Last]>;
-type UnionToTuple<U, R extends any[] = []> = [U] extends [never] ? R : _UnionToTupleInner<U, R, LastUnionElement<U>>;
-type CollapseObjectUnion<T extends object> = { [K in AllUnionKeys<T>]?: T extends Record<K, infer V> ? V : never };
-type IntersectAll<T extends any[]> = UnionToIntersection<T[number]>;
-type OptionalKeys<T> = { [K in keyof T]: {} extends Pick<T, K> ? K : never }[keyof T];
-type RequiredKeys<T> = { [K in keyof T]: {} extends Pick<T, K> ? never : K }[keyof T];
-/**
- * Returns a type whose keys are the intersection of the keys of T and U, deeply.
- */
-type KeyIntersect<T, U> = { [K in keyof T & keyof U]?: T[K] & U[K] } & { [K in RequiredKeys<T> & keyof U]: T[K] & U[K] } & { [K in RequiredKeys<U> & keyof T]: U[K] & T[K] };
-/**
- * Returns ALL keys of all union elements.
- */
-type AllUnionKeys<T extends object> = T extends T ? keyof T : never;
-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);
-type XOR<T extends readonly any[]> = T extends readonly [infer A, infer B, ...infer Rest] ? Rest extends [] ? (A & { [K in keyof B]?: never }) | (B & { [K in keyof A]?: never }) : XOR<[(A & { [K in keyof B]?: never }) | (B & { [K in keyof A]?: never }), ...Rest]> : T[0];
-type _AntiIntersectInner<T, U> = T extends object ? (Omit<U, keyof T> & { [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]> } & { [K in keyof Pick<U, keyof T & keyof U>]?: PseudoAntiIntersect<T[K], U[K]> }) : U;
-/**
- * Returns a type R such that T & R = U.
- */
-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";
-type PseudoAntiIntersect<T, U> = _AntiIntersectInner<T, T & U>;
-/**
- * A variation of TypeScript's conditionals with slightly different semantics. It is the perfect type for cases where:
- *
- * - If all possible values are contained in `Extends`, then it will be mapped to `Then`.
- * - If all possible values are not contained in `Extends`, then it will be mapped to `Otherwise`.
- * - If some possible values are contained in `Extends` and some are not, then it will be mapped to `Then | Otherwise`.
- *
- * This is different from TypeScript's built-in conditional types (`Value extends Extends ? Then : Otherwise`), which
- * returns `Otherwise` for the third case (causing unsoundness in many real-world cases).
- */
-type IfAndOnlyIf<Value, Extends, Then, Otherwise> = (Value extends Extends ? never : Otherwise) | (Value & Extends extends never ? never : Then);
-/**
- * Can be used to prettify a type in the IDE; for example, some complicated intersected types can be flattened into a single type.
- */
-type PrettifyType<T> = T extends object ? { [K in keyof T]: T[K] } & {} : T;
-type _ToStringAndJoin<T extends any[], Separator extends string> = T extends [infer U, ...infer Rest extends any[]] ? `${TypeToString<U>}${Rest extends [any, ...any[]] ? `${Separator}${_ToStringAndJoin<Rest, Separator>}` : ""}` : "<error-joining-tuple-elements>";
-type _TypeToStringInner<T> = IsAny<T> extends true ? "any" : IsNever<T> extends true ? "never" : IsUnion<T> extends true ? _ToStringAndJoin<UnionToTuple<T>, " | "> : [T] extends [number] ? (number extends T ? "number" : `${T}`) : [T] extends [boolean] ? `${T}` : [T] extends [undefined] ? "undefined" : [T] extends [null] ? "null" : [T] extends [string] ? (string extends T ? "string" : `'${T}'`) : [T] extends [[]] ? "[]" : [T] extends [[any, ...any[]]] ? `[${_ToStringAndJoin<T, ", ">}]` : [T] extends [(infer E)[]] ? `${TypeToString<E>}[]` : [T] extends [Function] ? "function" : [T] extends [symbol] ? `symbol(${T['description']})` : [T] extends [object] ? `{ ${Join<UnionToTuple<{ [K in keyof T]: `${TypeToString<K>}: ${TypeToString<T[K]>}` }[keyof T]>, ", ">} }` : "<unknown-type>";
-type TypeToString<T> = _TypeToStringInner<T> extends `${infer S}` ? S : never;
-/**
- * Can be used to create assertions on types. For example, if passed any T other than `true`, the following will
- * show a type error:
- *
- * ```ts
- * typeAssert<T>()();  // the second pair of braces is important!
- * ```
- */
-declare function typeAssert<T>(): (IsAny<T> extends true ? TypeAssertionError<`Type assertion failed. Expected true, but got any.`> : IsNever<T> extends true ? TypeAssertionError<`Type assertion failed. Expected true, but got never.`> : T extends true ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected true, but got: ${TypeToString<T>}`>);
-type TypeAssertionError<T> = [T] & /* 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>;
-/**
- * Functionally equivalent to `typeAssert<T extends S ? true : false>()()`, but with better error messages.
- */
-declare function typeAssertExtends<T, S>(): ([T] extends [S] ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to extend ${TypeToString<S>}`>);
-declare function typeAssertIs<T, U>(): (IsAny<T> extends true ? (IsAny<U> extends true ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>) : IsAny<U> extends true ? TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`> : [T] extends [U] ? ([U] extends [T] ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>);
-//#endregion
-export { AllUnionKeys, AntiIntersect, CollapseObjectUnion, DeepRemoveOptionalUndefined, Expand, IfAndOnlyIf, IntersectAll, IsAny, IsNever, IsNullish, IsUnion, KeyIntersect, LastUnionElement, NullishCoalesce, OptionalKeys, PrettifyType, PseudoAntiIntersect, RequiredKeys, SubtractType, TypeToString, UnionToIntersection, UnionToTuple, XOR, typeAssert, typeAssertExtends, typeAssertIs };
-//# sourceMappingURL=types.d.ts.map
+import { C as XOR, E as typeAssertIs, S as UnionToTuple, T as typeAssertExtends, _ as PseudoAntiIntersect, a as Expand, b as TypeToString, c as IsAny, d as IsUnion, f as KeyIntersect, g as PrettifyType, h as OptionalKeys, i as DeepRemoveOptionalUndefined, l as IsNever, m as NullishCoalesce, n as AntiIntersect, o as IfAndOnlyIf, p as LastUnionElement, r as CollapseObjectUnion, s as IntersectAll, t as AllUnionKeys, u as IsNullish, v as RequiredKeys, w as typeAssert, x as UnionToIntersection, y as SubtractType } from "../types-DfTcxNtM.js";
+export { AllUnionKeys, AntiIntersect, CollapseObjectUnion, DeepRemoveOptionalUndefined, Expand, IfAndOnlyIf, IntersectAll, IsAny, IsNever, IsNullish, IsUnion, KeyIntersect, LastUnionElement, NullishCoalesce, OptionalKeys, PrettifyType, PseudoAntiIntersect, RequiredKeys, SubtractType, TypeToString, UnionToIntersection, UnionToTuple, XOR, typeAssert, typeAssertExtends, typeAssertIs };

package/dist/utils/types.js

@@ -1,5 +1,4 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/utils/types.tsx
 typeAssertIs()();
 typeAssertIs()();
@@ -51,9 +50,9 @@ typeAssertExtends()();
 typeAssertExtends()();
 typeAssertExtends()();
 typeAssertExtends()();
-
 //#endregion
 exports.typeAssert = typeAssert;
 exports.typeAssertExtends = typeAssertExtends;
 exports.typeAssertIs = typeAssertIs;
+
 //# sourceMappingURL=types.js.map

package/dist/utils/types.js.map

@@ -1 +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"}
+{"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,aAA6F,CAAC,CAAC;AAC/F,aAA0F,CAAC,CAAC;AAuB5F,aAAqE,CAAC,CAAC;;;;;;;;;AAwEvE,SAAgB,aAKd;CACA,cAAc,KAAA;AAChB;AAMA,kBAAwE,CAAC,CAAC;AAC1E,kBAAoI,CAAC,CAAC;AACtI,kBAAoI,CAAC,CAAC;AACtI,kBAAgI,CAAC,CAAC;;;;AAKlI,SAAgB,oBAEd;CACA,cAAc,KAAA;AAChB;AAEA,kBAAsF,CAAC,CAAC;AACxF,kBAAoF,CAAC,CAAC;AACtF,kBAAuF,CAAC,CAAC;AACzF,kBAAwF,CAAC,CAAC;AAC1F,kBAAsG,CAAC,CAAC;AACxG,kBAAuF,CAAC,CAAC;AACzF,kBAAoF,CAAC,CAAC;AAEtF,kBAAuJ,CAAC,CAAC;AACzJ,kBAA6H,CAAC,CAAC;AAC/H,kBAA+H,CAAC,CAAC;AACjI,kBAAiI,CAAC,CAAC;AAGnI,SAAgB,eAKd;CACA,cAAc,KAAA;AAChB;AAEA,kBAAkF,CAAC,CAAC;AACpF,kBAAoF,CAAC,CAAC;AACtF,kBAAkG,CAAC,CAAC;AACpG,kBAA8E,CAAC,CAAC;AAChF,kBAAkF,CAAC,CAAC;AACpF,kBAA4G,CAAC,CAAC;AAC9G,kBAA4G,CAAC,CAAC;AAC9G,kBAAsH,CAAC,CAAC;AACxH,kBAA8I,CAAC,CAAC;AAChJ,kBAAoH,CAAC,CAAC;AACtH,kBAAsH,CAAC,CAAC;AACxH,kBAAwH,CAAC,CAAC"}

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

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

package/dist/utils/unicode.js

@@ -1,26 +1,13 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_chunk = require('../chunk-BE-pF4vm.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 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

@@ -1 +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"}
+{"version":3,"file":"unicode.js","names":["HexclaveAssertionError"],"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;CACzD,IAAI,EAAA,GAAA,mBAAA,mBAAA,CAAoB,oBAAoB,GAAG,MAAM,IAAIA,YAAAA,uBAAuB,+CAA+C;CAC/H,MAAM,cAAA,GAAA,mBAAA,qBAAA,CAAkC,oBAAoB,CAAC,CAC1D,MAAM,EAAE,CAAC,CACT,KAAI,SAAQ,SAAS,KAAK,WAAW,CAAC,CAAC;CAC1C,OAAO,OAAO,cAAc,GAAG,UAAU;AAC3C"}

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

@@ -1 +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,iBAyBzB,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;;;;;AA/QlH;iBAmTgB,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"}
+{"version":3,"file":"urls.d.ts","names":[],"sources":["../../src/utils/urls.tsx"],"mappings":";iBAGgB,gBAAA,IAAoB,IAAA,EAAM,qBAAA,QAA6B,GAAA,IAAI,GAAA;AAAA,iBAmB3D,UAAA,CAAW,GAAW;AAAA,iBAetB,eAAA,CAAgB,QAAgB;AAAA,iBAwBhC,4BAAA,CAA6B,QAAgB;AAAA,iBAkF7C,oBAAA,CAAqB,OAAA,UAAiB,QAAgB;AAAA,iBAuDtD,wBAAA,CAAyB,cAAsB;AAAA,iBAyB/C,iBAAA,CAAkB,cAAsB;AAAA,iBAIxC,WAAA,CAAY,WAAyB,WAAH,GAAG;AAAA,iBA+BrC,UAAA,CAAW,GAAW;AAAA,iBA4BtB,eAAA,CAAgB,GAAQ,EAAH,GAAG;;;;;AA3RmC;iBAiT3D,GAAA,CAAI,OAAA,EAAS,oBAAA,yBAA6C,MAAA,kCAAwC,GAAG;;;;AA9R/E;AAetC;iBAmTgB,SAAA,CAAU,OAAA,EAAS,oBAAoB,yBAAyB,MAAA;AAAA,iBAyBhE,UAAA,CAAW,SAAA,EAAW,GAAA,EAAK,aAAA,EAAe,GAAG;AAAA,iBAsB7C,WAAA,CAAY,UAAA,UAAoB,cAAsB"}

package/dist/utils/urls.js

@@ -1,8 +1,6 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_chunk = require('../chunk-BE-pF4vm.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let __crypto_js = require("./crypto.js");
 let __strings_js = require("./strings.js");
-
 //#region src/utils/urls.tsx
 function createUrlIfValid(...args) {
 	try {
@@ -11,41 +9,15 @@ function createUrlIfValid(...args) {
 		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);
@@ -63,25 +35,6 @@ function isValidHostnameWithWildcards(hostname) {
 	}
 	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, "\\$&");
@@ -96,23 +49,6 @@ function matchHostnamePattern(pattern, hostname) {
 		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.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"];
@@ -133,21 +69,6 @@ function isLocalhost(urlOrString) {
 	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}`);
@@ -156,29 +77,9 @@ function isRelative(url) {
 	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.
 *
@@ -187,21 +88,6 @@ function getRelativePart(url) {
 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.
 *
@@ -210,52 +96,14 @@ function url(strings, ...values) {
 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;
@@ -271,4 +119,5 @@ exports.isValidUrl = isValidUrl;
 exports.matchHostnamePattern = matchHostnamePattern;
 exports.url = url;
 exports.urlString = urlString;
+
 //# sourceMappingURL=urls.js.map