@hexclave/shared 1.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"featurebase.d.ts","names":[],"sources":["../../../src/utils/featurebase.tsx"],"mappings":";KAGY,eAAA;EACV,MAAA;EACA,KAAA;EACA,IAAA;EACA,cAAA;AAAA;AAAA,KAGU,aAAA;EACV,EAAA;EACA,YAAA;EACA,WAAA;EACA,eAAA;AAAA;;;;;;;;;iBAgKoB,0BAAA,CACpB,aAAA,EAAe,aAAA,EACf,OAAA;EAAY,MAAA;AAAA,IACX,OAAA;EAAU,MAAA;EAAgB,KAAA;AAAA"}

package/dist/esm/utils/featurebase.js

@@ -0,0 +1,166 @@
+import { HexclaveAssertionError } from "./errors.js";
+import { getEnvVariable } from "./env.js";
+
+//#region src/utils/featurebase.tsx
+/**
+* Find a Featurebase user by their Hexclave user ID
+*/
+async function findFeaturebaseUserById(stackAuthUserId, apiKey) {
+	try {
+		const response = await fetch(`https://do.featurebase.app/v2/organization/identifyUser?id=${stackAuthUserId}`, {
+			method: "GET",
+			headers: { "X-API-Key": apiKey }
+		});
+		if (response.status === 404) return null;
+		if (!response.ok) throw new HexclaveAssertionError(`Failed to find Featurebase user by ID: ${response.statusText}`);
+		const data = await response.json();
+		const user = data.user;
+		if (!user) throw new HexclaveAssertionError(`Featurebase API returned success but no user data for ID: ${stackAuthUserId}`, { data });
+		return {
+			userId: user.externalUserId || user.userId || stackAuthUserId,
+			email: user.email,
+			name: user.name,
+			profilePicture: user.profilePicture
+		};
+	} catch (error) {
+		if (error instanceof HexclaveAssertionError) throw error;
+		throw new HexclaveAssertionError("Failed to find Featurebase user by ID", { cause: error });
+	}
+}
+/**
+* Find a Featurebase user by their email address
+*/
+async function findFeaturebaseUserByEmail(email, apiKey) {
+	try {
+		const response = await fetch(`https://do.featurebase.app/v2/organization/identifyUser?email=${encodeURIComponent(email)}`, {
+			method: "GET",
+			headers: { "X-API-Key": apiKey }
+		});
+		if (response.status === 404) return null;
+		if (!response.ok) throw new HexclaveAssertionError(`Failed to find Featurebase user by email: ${response.statusText}`);
+		const data = await response.json();
+		const user = data.user;
+		if (!user) throw new HexclaveAssertionError(`Featurebase API returned success but no user data for email: ${email}`, { data });
+		return {
+			userId: user.externalUserId || user.userId,
+			email: user.email,
+			name: user.name,
+			profilePicture: user.profilePicture
+		};
+	} catch (error) {
+		console.error("Error finding Featurebase user by email:", error);
+		return null;
+	}
+}
+/**
+* Create a new Featurebase user using the identifyUser endpoint
+*/
+async function createFeaturebaseUser(user, apiKey) {
+	try {
+		const response = await fetch("https://do.featurebase.app/v2/organization/identifyUser", {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				"X-API-Key": apiKey
+			},
+			body: JSON.stringify({
+				userId: user.userId,
+				email: user.email,
+				name: user.name,
+				profilePicture: user.profilePicture
+			})
+		});
+		if (!response.ok) {
+			const errorData = await response.json().catch(() => ({}));
+			throw new HexclaveAssertionError(`Failed to create Featurebase user: ${errorData.error || response.statusText}`, { errorData });
+		}
+		return user;
+	} catch (error) {
+		if (error instanceof HexclaveAssertionError) throw error;
+		throw new HexclaveAssertionError("Failed to create Featurebase user", { cause: error });
+	}
+}
+/**
+* Update an existing Featurebase user (excluding email)
+*/
+async function updateFeaturebaseUser(userId, updates, apiKey) {
+	try {
+		const response = await fetch(`https://do.featurebase.app/v2/users/${userId}`, {
+			method: "PATCH",
+			headers: {
+				"Content-Type": "application/json",
+				"X-API-Key": apiKey
+			},
+			body: JSON.stringify(updates)
+		});
+		if (!response.ok) {
+			const errorData = await response.json().catch(() => ({}));
+			throw new HexclaveAssertionError(`Failed to update Featurebase user: ${errorData.error || response.statusText}`, { errorData });
+		}
+		const data = await response.json();
+		return {
+			userId: data.userId || userId,
+			email: data.email,
+			name: data.name,
+			profilePicture: data.profilePicture
+		};
+	} catch (error) {
+		if (error instanceof HexclaveAssertionError) throw error;
+		throw new HexclaveAssertionError("Failed to update Featurebase user", { cause: error });
+	}
+}
+/**
+* Get or create a Featurebase user based on Hexclave user data.
+* This function ensures that:
+* 1. We never change a user's email address on Featurebase
+* 2. We use Hexclave user ID as the primary identifier
+* 3. We handle email conflicts by using fallback emails
+* 4. We update profile information when needed
+*/
+async function getOrCreateFeaturebaseUser(stackAuthUser, options) {
+	const apiKey = options?.apiKey || getEnvVariable("STACK_FEATUREBASE_API_KEY");
+	const fallbackEmail = `${stackAuthUser.id}@featurebase-user.stack-auth-app.com`;
+	const existingById = await findFeaturebaseUserById(stackAuthUser.id, apiKey);
+	if (existingById) {
+		let ensuredEmail = existingById.email;
+		if (!ensuredEmail) try {
+			await createFeaturebaseUser({
+				userId: existingById.userId,
+				email: fallbackEmail,
+				name: stackAuthUser.displayName || void 0,
+				profilePicture: stackAuthUser.profileImageUrl || void 0
+			}, apiKey);
+			ensuredEmail = fallbackEmail;
+		} catch (e) {
+			throw new HexclaveAssertionError(`Failed to set fallback email for existing Featurebase user ${existingById.userId}`, { cause: e });
+		}
+		try {
+			const updates = {};
+			if (stackAuthUser.displayName && stackAuthUser.displayName !== existingById.name) updates.name = stackAuthUser.displayName;
+			if (stackAuthUser.profileImageUrl && stackAuthUser.profileImageUrl !== existingById.profilePicture) updates.profilePicture = stackAuthUser.profileImageUrl;
+			if (Object.keys(updates).length > 0) await updateFeaturebaseUser(existingById.userId, updates, apiKey);
+		} catch (error) {
+			console.error("Failed to update existing Featurebase user profile:", error);
+		}
+		return {
+			userId: existingById.userId,
+			email: ensuredEmail
+		};
+	}
+	const candidateEmail = stackAuthUser.primaryEmail ?? fallbackEmail;
+	const safeEmail = await findFeaturebaseUserByEmail(candidateEmail, apiKey) ? fallbackEmail : candidateEmail;
+	const created = await createFeaturebaseUser({
+		userId: stackAuthUser.id,
+		email: safeEmail,
+		name: stackAuthUser.displayName || stackAuthUser.primaryEmail?.split("@")[0] || "User",
+		profilePicture: stackAuthUser.profileImageUrl || void 0
+	}, apiKey);
+	return {
+		userId: created.userId,
+		email: created.email
+	};
+}
+
+//#endregion
+export { getOrCreateFeaturebaseUser };
+//# sourceMappingURL=featurebase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"featurebase.js","names":[],"sources":["../../../src/utils/featurebase.tsx"],"sourcesContent":["import { getEnvVariable } from \"./env\";\nimport { HexclaveAssertionError } from \"./errors\";\n\nexport type FeaturebaseUser = {\n  userId: string,\n  email: string,\n  name?: string,\n  profilePicture?: string,\n};\n\nexport type StackAuthUser = {\n  id: string,\n  primaryEmail: string | null,\n  displayName?: string | null,\n  profileImageUrl?: string | null,\n};\n\n/**\n * Find a Featurebase user by their Hexclave user ID\n */\nasync function findFeaturebaseUserById(stackAuthUserId: string, apiKey: string): Promise<FeaturebaseUser | null> {\n  try {\n    const response = await fetch(`https://do.featurebase.app/v2/organization/identifyUser?id=${stackAuthUserId}`, {\n      method: 'GET',\n      headers: {\n        'X-API-Key': apiKey,\n      },\n    });\n\n    if (response.status === 404) {\n      return null;\n    }\n\n    if (!response.ok) {\n      throw new HexclaveAssertionError(`Failed to find Featurebase user by ID: ${response.statusText}`);\n    }\n\n    const data = await response.json();\n    const user = data.user;\n\n    if (!user) {\n      throw new HexclaveAssertionError(`Featurebase API returned success but no user data for ID: ${stackAuthUserId}`, { data });\n    }\n\n    return {\n      userId: user.externalUserId || user.userId || stackAuthUserId,\n      email: user.email,\n      name: user.name,\n      profilePicture: user.profilePicture,\n    };\n  } catch (error) {\n    if (error instanceof HexclaveAssertionError) {\n      throw error;\n    }\n    throw new HexclaveAssertionError(\"Failed to find Featurebase user by ID\", { cause: error });\n  }\n}\n\n/**\n * Find a Featurebase user by their email address\n */\nasync function findFeaturebaseUserByEmail(email: string, apiKey: string): Promise<FeaturebaseUser | null> {\n  try {\n    const response = await fetch(`https://do.featurebase.app/v2/organization/identifyUser?email=${encodeURIComponent(email)}`, {\n      method: 'GET',\n      headers: {\n        'X-API-Key': apiKey,\n      },\n    });\n\n    if (response.status === 404) {\n      return null;\n    }\n\n    if (!response.ok) {\n      throw new HexclaveAssertionError(`Failed to find Featurebase user by email: ${response.statusText}`);\n    }\n\n    const data = await response.json();\n    const user = data.user;\n\n    if (!user) {\n      throw new HexclaveAssertionError(`Featurebase API returned success but no user data for email: ${email}`, { data });\n    }\n\n    return {\n      userId: user.externalUserId || user.userId,\n      email: user.email,\n      name: user.name,\n      profilePicture: user.profilePicture,\n    };\n  } catch (error) {\n    console.error('Error finding Featurebase user by email:', error);\n    return null;\n  }\n}\n\n/**\n * Create a new Featurebase user using the identifyUser endpoint\n */\nasync function createFeaturebaseUser(user: FeaturebaseUser, apiKey: string): Promise<FeaturebaseUser> {\n  try {\n    const response = await fetch('https://do.featurebase.app/v2/organization/identifyUser', {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/json',\n        'X-API-Key': apiKey,\n      },\n      body: JSON.stringify({\n        userId: user.userId,\n        email: user.email,\n        name: user.name,\n        profilePicture: user.profilePicture,\n      }),\n    });\n\n    if (!response.ok) {\n      const errorData = await response.json().catch(() => ({}));\n      throw new HexclaveAssertionError(`Failed to create Featurebase user: ${errorData.error || response.statusText}`, { errorData });\n    }\n\n    // The identifyUser endpoint just returns { \"success\": true }, so we return the input data\n    return user;\n  } catch (error) {\n    if (error instanceof HexclaveAssertionError) {\n      throw error;\n    }\n    throw new HexclaveAssertionError(\"Failed to create Featurebase user\", { cause: error });\n\n  }\n}\n\n/**\n * Update an existing Featurebase user (excluding email)\n */\nasync function updateFeaturebaseUser(userId: string, updates: Partial<Omit<FeaturebaseUser, 'userId' | 'email'>>, apiKey: string): Promise<FeaturebaseUser> {\n  try {\n    const response = await fetch(`https://do.featurebase.app/v2/users/${userId}`, {\n      method: 'PATCH',\n      headers: {\n        'Content-Type': 'application/json',\n        'X-API-Key': apiKey,\n      },\n      body: JSON.stringify(updates),\n    });\n\n    if (!response.ok) {\n      const errorData = await response.json().catch(() => ({}));\n      throw new HexclaveAssertionError(`Failed to update Featurebase user: ${errorData.error || response.statusText}`, { errorData });\n    }\n\n    const data = await response.json();\n    return {\n      userId: data.userId || userId,\n      email: data.email,\n      name: data.name,\n      profilePicture: data.profilePicture,\n    };\n  } catch (error) {\n    if (error instanceof HexclaveAssertionError) {\n      throw error;\n    }\n    throw new HexclaveAssertionError(\"Failed to update Featurebase user\", { cause: error });\n  }\n}\n\n/**\n * Get or create a Featurebase user based on Hexclave user data.\n * This function ensures that:\n * 1. We never change a user's email address on Featurebase\n * 2. We use Hexclave user ID as the primary identifier\n * 3. We handle email conflicts by using fallback emails\n * 4. We update profile information when needed\n */\nexport async function getOrCreateFeaturebaseUser(\n  stackAuthUser: StackAuthUser,\n  options?: { apiKey?: string }\n): Promise<{ userId: string, email: string }> {\n  const apiKey = options?.apiKey || getEnvVariable(\"STACK_FEATUREBASE_API_KEY\");\n  const fallbackEmail = `${stackAuthUser.id}@featurebase-user.stack-auth-app.com`;\n\n  // First, try to find existing user by Hexclave user ID\n  const existingById = await findFeaturebaseUserById(stackAuthUser.id, apiKey);\n  if (existingById) {\n    // Ensure the user has an email on Featurebase.\n    let ensuredEmail = existingById.email;\n    if (!ensuredEmail) {\n      try {\n        await createFeaturebaseUser({\n          userId: existingById.userId,\n          email: fallbackEmail,\n          name: stackAuthUser.displayName || undefined,\n          profilePicture: stackAuthUser.profileImageUrl || undefined,\n        }, apiKey);\n        ensuredEmail = fallbackEmail;\n      } catch (e) {\n        // If setting fallback email failed, keep ensuredEmail as-is (undefined) and let callers handle\n        throw new HexclaveAssertionError(`Failed to set fallback email for existing Featurebase user ${existingById.userId}`, { cause: e });\n      }\n    }\n\n    // Update profile information if needed (but not email)\n    try {\n      const updates: Partial<Omit<FeaturebaseUser, 'userId' | 'email'>> = {};\n\n      if (stackAuthUser.displayName && stackAuthUser.displayName !== existingById.name) {\n        updates.name = stackAuthUser.displayName;\n      }\n\n      if (stackAuthUser.profileImageUrl && stackAuthUser.profileImageUrl !== existingById.profilePicture) {\n        updates.profilePicture = stackAuthUser.profileImageUrl;\n      }\n\n      if (Object.keys(updates).length > 0) {\n        await updateFeaturebaseUser(existingById.userId, updates, apiKey);\n      }\n    } catch (error) {\n      console.error('Failed to update existing Featurebase user profile:', error);\n      // Continue with existing user data even if update fails\n    }\n\n    return {\n      userId: existingById.userId,\n      email: ensuredEmail,\n    };\n  }\n\n  // No existing user found by ID, need to create one\n  const candidateEmail = stackAuthUser.primaryEmail ?? fallbackEmail;\n\n  // Check if someone already has this email on Featurebase\n  const existingByEmail = await findFeaturebaseUserByEmail(candidateEmail, apiKey);\n  const safeEmail = existingByEmail ? fallbackEmail : candidateEmail;\n\n  // Create new user\n  const created = await createFeaturebaseUser({\n    userId: stackAuthUser.id,\n    email: safeEmail,\n    name: stackAuthUser.displayName || stackAuthUser.primaryEmail?.split('@')[0] || 'User',\n    profilePicture: stackAuthUser.profileImageUrl || undefined,\n  }, apiKey);\n\n  return {\n    userId: created.userId,\n    email: created.email,\n  };\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,9 @@
+//#region src/utils/fs.d.ts
+declare function list(path: string): Promise<string[]>;
+declare function listRecursively(p: string, options?: {
+  excludeDirectories?: boolean;
+}): Promise<string[]>;
+declare function writeFileSyncIfChanged(path: string, content: string): void;
+//#endregion
+export { list, listRecursively, writeFileSyncIfChanged };
+//# sourceMappingURL=fs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","names":[],"sources":["../../../src/utils/fs.tsx"],"mappings":";iBAGsB,IAAA,CAAK,IAAA,WAAY,OAAA;AAAA,iBAIjB,eAAA,CAAgB,CAAA,UAAW,OAAA;EAAW,kBAAA;AAAA,IAAsC,OAAA;AAAA,iBAiBlF,sBAAA,CAAuB,IAAA,UAAc,OAAA"}

package/dist/esm/utils/fs.js

@@ -0,0 +1,25 @@
+import * as stackFs from "fs";
+import * as path$1 from "path";
+
+//#region src/utils/fs.tsx
+async function list(path) {
+	return await stackFs.promises.readdir(path);
+}
+async function listRecursively(p, options = {}) {
+	const files = await list(p);
+	return [...(await Promise.all(files.map(async (fileName) => {
+		const filePath = path$1.join(p, fileName);
+		if ((await stackFs.promises.stat(filePath)).isDirectory()) return [...await listRecursively(filePath, options), ...options.excludeDirectories ? [] : [filePath]];
+		else return [filePath];
+	}))).flat()];
+}
+function writeFileSyncIfChanged(path, content) {
+	if (stackFs.existsSync(path)) {
+		if (stackFs.readFileSync(path, "utf-8") === content) return;
+	}
+	stackFs.writeFileSync(path, content);
+}
+
+//#endregion
+export { list, listRecursively, writeFileSyncIfChanged };
+//# sourceMappingURL=fs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fs.js","names":["path"],"sources":["../../../src/utils/fs.tsx"],"sourcesContent":["import * as stackFs from \"fs\";\nimport * as path from \"path\";\n\nexport async function list(path: string) {\n  return await stackFs.promises.readdir(path);\n}\n\nexport async function listRecursively(p: string, options: { excludeDirectories?: boolean } = {}): Promise<string[]> {\n  const files = await list(p);\n  return [\n    ...(await Promise.all(files.map(async (fileName) => {\n      const filePath = path.join(p, fileName);\n      if ((await stackFs.promises.stat(filePath)).isDirectory()) {\n        return [\n          ...(await listRecursively(filePath, options)),\n          ...(options.excludeDirectories ? [] : [filePath]),\n        ];\n      } else {\n        return [filePath];\n      }\n    }))).flat(),\n  ];\n}\n\nexport function writeFileSyncIfChanged(path: string, content: string): void {\n  if (stackFs.existsSync(path)) {\n    const existingContent = stackFs.readFileSync(path, \"utf-8\");\n    if (existingContent === content) {\n      return;\n    }\n  }\n  stackFs.writeFileSync(path, content);\n}\n"],"mappings":";;;;AAGA,eAAsB,KAAK,MAAc;AACvC,QAAO,MAAM,QAAQ,SAAS,QAAQ,KAAK;;AAG7C,eAAsB,gBAAgB,GAAW,UAA4C,EAAE,EAAqB;CAClH,MAAM,QAAQ,MAAM,KAAK,EAAE;AAC3B,QAAO,CACL,IAAI,MAAM,QAAQ,IAAI,MAAM,IAAI,OAAO,aAAa;EAClD,MAAM,WAAWA,OAAK,KAAK,GAAG,SAAS;AACvC,OAAK,MAAM,QAAQ,SAAS,KAAK,SAAS,EAAE,aAAa,CACvD,QAAO,CACL,GAAI,MAAM,gBAAgB,UAAU,QAAQ,EAC5C,GAAI,QAAQ,qBAAqB,EAAE,GAAG,CAAC,SAAS,CACjD;MAED,QAAO,CAAC,SAAS;GAEnB,CAAC,EAAE,MAAM,CACZ;;AAGH,SAAgB,uBAAuB,MAAc,SAAuB;AAC1E,KAAI,QAAQ,WAAW,KAAK,EAE1B;MADwB,QAAQ,aAAa,MAAM,QAAQ,KACnC,QACtB;;AAGJ,SAAQ,cAAc,MAAM,QAAQ"}

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

@@ -0,0 +1,6 @@
+//#region src/utils/functions.d.ts
+declare function identity<T>(t: T): T;
+declare function identityArgs<T extends any[]>(...args: T): T;
+//#endregion
+export { identity, identityArgs };
+//# sourceMappingURL=functions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"functions.d.ts","names":[],"sources":["../../../src/utils/functions.tsx"],"mappings":";iBAAgB,QAAA,GAAA,CAAY,CAAA,EAAG,CAAA,GAAI,CAAA;AAAA,iBAYnB,YAAA,iBAAA,CAAA,GAAiC,IAAA,EAAM,CAAA,GAAI,CAAA"}

package/dist/esm/utils/functions.js

@@ -0,0 +1,34 @@
+//#region src/utils/functions.tsx
+function identity(t) {
+	return t;
+}
+(void 0)?.test("identity", ({ expect }) => {
+	expect(identity(1)).toBe(1);
+	expect(identity("test")).toBe("test");
+	expect(identity(null)).toBe(null);
+	expect(identity(void 0)).toBe(void 0);
+	const obj = { a: 1 };
+	expect(identity(obj)).toBe(obj);
+});
+function identityArgs(...args) {
+	return args;
+}
+(void 0)?.test("identityArgs", ({ expect }) => {
+	expect(identityArgs()).toEqual([]);
+	expect(identityArgs(1)).toEqual([1]);
+	expect(identityArgs(1, 2, 3)).toEqual([
+		1,
+		2,
+		3
+	]);
+	expect(identityArgs("a", "b", "c")).toEqual([
+		"a",
+		"b",
+		"c"
+	]);
+	expect(identityArgs(null, void 0)).toEqual([null, void 0]);
+});
+
+//#endregion
+export { identity, identityArgs };
+//# sourceMappingURL=functions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"functions.js","names":[],"sources":["../../../src/utils/functions.tsx"],"sourcesContent":["export function identity<T>(t: T): T {\n  return t;\n}\nimport.meta.vitest?.test(\"identity\", ({ expect }) => {\n  expect(identity(1)).toBe(1);\n  expect(identity(\"test\")).toBe(\"test\");\n  expect(identity(null)).toBe(null);\n  expect(identity(undefined)).toBe(undefined);\n  const obj = { a: 1 };\n  expect(identity(obj)).toBe(obj);\n});\n\nexport function identityArgs<T extends any[]>(...args: T): T {\n  return args;\n}\nimport.meta.vitest?.test(\"identityArgs\", ({ expect }) => {\n  expect(identityArgs()).toEqual([]);\n  expect(identityArgs(1)).toEqual([1]);\n  expect(identityArgs(1, 2, 3)).toEqual([1, 2, 3]);\n  expect(identityArgs(\"a\", \"b\", \"c\")).toEqual([\"a\", \"b\", \"c\"]);\n  expect(identityArgs(null, undefined)).toEqual([null, undefined]);\n});\n"],"mappings":";AAAA,SAAgB,SAAY,GAAS;AACnC,QAAO;;CAET,SAAW,KAAC,aAAc,EAAA,aAAc;AACtC,QAAO,SAAS,EAAE,CAAC,CAAC,KAAK,EAAE;AAC3B,QAAO,SAAS,OAAO,CAAC,CAAC,KAAK,OAAO;AACrC,QAAO,SAAS,KAAK,CAAC,CAAC,KAAK,KAAK;AACjC,QAAO,SAAS,OAAU,CAAC,CAAC,KAAK,OAAU;CAC3C,MAAM,MAAM,EAAE,GAAG,GAAG;AACpB,QAAO,SAAS,IAAI,CAAC,CAAC,KAAK,IAAI;EAC/B;AAEF,SAAgB,aAA8B,GAAG,MAAY;AAC3D,QAAO;;CAET,SAAW,KAAC,iBAAc,EAAA,aAAkB;AAC1C,QAAO,cAAc,CAAC,CAAC,QAAQ,EAAE,CAAC;AAClC,QAAO,aAAa,EAAE,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC;AACpC,QAAO,aAAa,GAAG,GAAG,EAAE,CAAC,CAAC,QAAQ;EAAC;EAAG;EAAG;EAAE,CAAC;AAChD,QAAO,aAAa,KAAK,KAAK,IAAI,CAAC,CAAC,QAAQ;EAAC;EAAK;EAAK;EAAI,CAAC;AAC5D,QAAO,aAAa,MAAM,OAAU,CAAC,CAAC,QAAQ,CAAC,MAAM,OAAU,CAAC;EAChE"}

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

@@ -0,0 +1,24 @@
+import * as yup$1 from "yup";
+
+//#region src/utils/geo.d.ts
+declare const geoInfoSchema: yup$1.ObjectSchema<{
+  ip: string;
+  countryCode: string | null | undefined;
+  regionCode: string | null | undefined;
+  cityName: string | null | undefined;
+  latitude: number | null | undefined;
+  longitude: number | null | undefined;
+  tzIdentifier: string | null | undefined;
+}, yup$1.AnyObject, {
+  ip: undefined;
+  countryCode: undefined;
+  regionCode: undefined;
+  cityName: undefined;
+  latitude: undefined;
+  longitude: undefined;
+  tzIdentifier: undefined;
+}, "">;
+type GeoInfo = yup$1.InferType<typeof geoInfoSchema>;
+//#endregion
+export { GeoInfo, geoInfoSchema };
+//# sourceMappingURL=geo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geo.d.ts","names":[],"sources":["../../../src/utils/geo.tsx"],"mappings":";;;cAIa,aAAA,EAAa,KAAA,CAAA,YAAA;;;;;;;;GAQxB,KAAA,CAAA,SAAA;;;;;;;;;KAEU,OAAA,GAAU,KAAA,CAAI,SAAA,QAAiB,aAAA"}

package/dist/esm/utils/geo.js

@@ -0,0 +1,16 @@
+import { yupNumber, yupObject, yupString } from "../schema-fields.js";
+
+//#region src/utils/geo.tsx
+const geoInfoSchema = yupObject({
+	ip: yupString().defined(),
+	countryCode: yupString().nullable(),
+	regionCode: yupString().nullable(),
+	cityName: yupString().nullable(),
+	latitude: yupNumber().nullable(),
+	longitude: yupNumber().nullable(),
+	tzIdentifier: yupString().nullable()
+});
+
+//#endregion
+export { geoInfoSchema };
+//# sourceMappingURL=geo.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geo.js","names":[],"sources":["../../../src/utils/geo.tsx"],"sourcesContent":["\nimport * as yup from \"yup\";\nimport { yupNumber, yupObject, yupString } from \"../schema-fields\";\n\nexport const geoInfoSchema = yupObject({\n  ip: yupString().defined(),\n  countryCode: yupString().nullable(),\n  regionCode: yupString().nullable(),\n  cityName: yupString().nullable(),\n  latitude: yupNumber().nullable(),\n  longitude: yupNumber().nullable(),\n  tzIdentifier: yupString().nullable(),\n});\n\nexport type GeoInfo = yup.InferType<typeof geoInfoSchema>;\n\n"],"mappings":";;;AAIA,MAAa,gBAAgB,UAAU;CACrC,IAAI,WAAW,CAAC,SAAS;CACzB,aAAa,WAAW,CAAC,UAAU;CACnC,YAAY,WAAW,CAAC,UAAU;CAClC,UAAU,WAAW,CAAC,UAAU;CAChC,UAAU,WAAW,CAAC,UAAU;CAChC,WAAW,WAAW,CAAC,UAAU;CACjC,cAAc,WAAW,CAAC,UAAU;CACrC,CAAC"}

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

@@ -0,0 +1,13 @@
+//#region src/utils/globals.d.ts
+declare const globalVar: any;
+declare function createGlobal<T>(key: string, init: () => T): T;
+/**
+ * Like createGlobal, but if the asynchronous initialization fails, the global will be reset and recomputed on the next
+ * invocation.
+ */
+declare function createGlobalAsync<T>(key: string, init: () => Promise<T>): Promise<T>;
+declare function getGlobal(key: string): any;
+declare function setGlobal(key: string, value: any): void;
+//#endregion
+export { createGlobal, createGlobalAsync, getGlobal, globalVar, setGlobal };
+//# sourceMappingURL=globals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"globals.d.ts","names":[],"sources":["../../../src/utils/globals.tsx"],"mappings":";cAAM,SAAA;AAAA,iBAkBU,YAAA,GAAA,CAAgB,GAAA,UAAa,IAAA,QAAY,CAAA,GAIV,CAAA;;;;AAJ/C;iBAWgB,iBAAA,GAAA,CAAqB,GAAA,UAAa,IAAA,QAAY,OAAA,CAAQ,CAAA,IAAK,OAAA,CAAQ,CAAA;AAAA,iBAYnE,SAAA,CAAU,GAAA;AAAA,iBAIV,SAAA,CAAU,GAAA,UAAa,KAAA"}

package/dist/esm/utils/globals.js

@@ -0,0 +1,34 @@
+//#region src/utils/globals.tsx
+const globalVar = typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {};
+if (typeof globalThis === "undefined") globalVar.globalThis = globalVar;
+const stackGlobalsSymbol = Symbol.for("__hexclave-globals");
+globalVar[stackGlobalsSymbol] ??= {};
+function createGlobal(key, init) {
+	if (!globalVar[stackGlobalsSymbol][key]) globalVar[stackGlobalsSymbol][key] = init();
+	return globalVar[stackGlobalsSymbol][key];
+}
+/**
+* Like createGlobal, but if the asynchronous initialization fails, the global will be reset and recomputed on the next
+* invocation.
+*/
+function createGlobalAsync(key, init) {
+	let promise = null;
+	if (!globalVar[stackGlobalsSymbol][key]) {
+		promise = init().catch((e) => {
+			delete globalVar[stackGlobalsSymbol][key];
+			throw e;
+		});
+		globalVar[stackGlobalsSymbol][key] = promise;
+	}
+	return promise ?? globalVar[stackGlobalsSymbol][key];
+}
+function getGlobal(key) {
+	return globalVar[stackGlobalsSymbol][key];
+}
+function setGlobal(key, value) {
+	globalVar[stackGlobalsSymbol][key] = value;
+}
+
+//#endregion
+export { createGlobal, createGlobalAsync, getGlobal, globalVar, setGlobal };
+//# sourceMappingURL=globals.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"globals.js","names":[],"sources":["../../../src/utils/globals.tsx"],"sourcesContent":["const globalVar: any =\n  typeof globalThis !== 'undefined' ? globalThis :\n    typeof global !== 'undefined' ? global :\n      typeof window !== 'undefined' ? window :\n        typeof self !== 'undefined' ? self :\n          {};\nexport {\n  globalVar\n};\n\nif (typeof globalThis === 'undefined') {\n  (globalVar as any).globalThis = globalVar;\n}\n\n// Hexclave rebrand: file-private symbol key, renamed outright (no cross-version compat needed).\nconst stackGlobalsSymbol = Symbol.for('__hexclave-globals');\nglobalVar[stackGlobalsSymbol] ??= {};\n\nexport function createGlobal<T>(key: string, init: () => T) {\n  if (!globalVar[stackGlobalsSymbol][key]) {\n    globalVar[stackGlobalsSymbol][key] = init();\n  }\n  return globalVar[stackGlobalsSymbol][key] as T;\n}\n\n/**\n * Like createGlobal, but if the asynchronous initialization fails, the global will be reset and recomputed on the next\n * invocation.\n */\nexport function createGlobalAsync<T>(key: string, init: () => Promise<T>): Promise<T> {\n  let promise: Promise<T> | null = null;\n  if (!globalVar[stackGlobalsSymbol][key]) {\n    promise = init().catch((e) => {\n      delete globalVar[stackGlobalsSymbol][key];\n      throw e;\n    });\n    globalVar[stackGlobalsSymbol][key] = promise;\n  }\n  return promise ?? globalVar[stackGlobalsSymbol][key] as Promise<T>;\n}\n\nexport function getGlobal(key: string): any {\n  return globalVar[stackGlobalsSymbol][key];\n}\n\nexport function setGlobal(key: string, value: any) {\n  globalVar[stackGlobalsSymbol][key] = value;\n}\n"],"mappings":";AAAA,MAAM,YACJ,OAAO,eAAe,cAAc,aAClC,OAAO,WAAW,cAAc,SAC9B,OAAO,WAAW,cAAc,SAC9B,OAAO,SAAS,cAAc,OAC5B,EAAE;AAKZ,IAAI,OAAO,eAAe,YACxB,CAAC,UAAkB,aAAa;AAIlC,MAAM,qBAAqB,OAAO,IAAI,qBAAqB;AAC3D,UAAU,wBAAwB,EAAE;AAEpC,SAAgB,aAAgB,KAAa,MAAe;AAC1D,KAAI,CAAC,UAAU,oBAAoB,KACjC,WAAU,oBAAoB,OAAO,MAAM;AAE7C,QAAO,UAAU,oBAAoB;;;;;;AAOvC,SAAgB,kBAAqB,KAAa,MAAoC;CACpF,IAAI,UAA6B;AACjC,KAAI,CAAC,UAAU,oBAAoB,MAAM;AACvC,YAAU,MAAM,CAAC,OAAO,MAAM;AAC5B,UAAO,UAAU,oBAAoB;AACrC,SAAM;IACN;AACF,YAAU,oBAAoB,OAAO;;AAEvC,QAAO,WAAW,UAAU,oBAAoB;;AAGlD,SAAgB,UAAU,KAAkB;AAC1C,QAAO,UAAU,oBAAoB;;AAGvC,SAAgB,UAAU,KAAa,OAAY;AACjD,WAAU,oBAAoB,OAAO"}

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

@@ -0,0 +1,9 @@
+//#region src/utils/hashes.d.ts
+declare function sha512(input: Uint8Array | string): Promise<Uint8Array>;
+declare function hashPassword(password: string): Promise<string>;
+declare function comparePassword(password: string, hash: string): Promise<boolean>;
+declare function isPasswordHashValid(hash: string): Promise<boolean>;
+declare function getPasswordHashAlgorithm(hash: string): Promise<"bcrypt" | undefined>;
+//#endregion
+export { comparePassword, getPasswordHashAlgorithm, hashPassword, isPasswordHashValid, sha512 };
+//# sourceMappingURL=hashes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hashes.d.ts","names":[],"sources":["../../../src/utils/hashes.tsx"],"mappings":";iBAIsB,MAAA,CAAO,KAAA,EAAO,UAAA,YAAsB,OAAA,CAAQ,UAAA;AAAA,iBAK5C,YAAA,CAAa,QAAA,WAAgB,OAAA;AAAA,iBAS7B,eAAA,CAAgB,QAAA,UAAkB,IAAA,WAAe,OAAA;AAAA,iBAWjD,mBAAA,CAAoB,IAAA,WAAY,OAAA;AAAA,iBAIhC,wBAAA,CAAyB,IAAA,WAAe,OAAA"}

package/dist/esm/utils/hashes.js

@@ -0,0 +1,40 @@
+import { HexclaveAssertionError } from "./errors.js";
+import { toArrayBufferBacked } from "./typed-arrays.js";
+import bcrypt from "bcryptjs";
+
+//#region src/utils/hashes.tsx
+async function sha512(input) {
+	const bytes = typeof input === "string" ? new TextEncoder().encode(input) : toArrayBufferBacked(input);
+	return new Uint8Array(await crypto.subtle.digest("SHA-512", bytes));
+}
+async function hashPassword(password) {
+	const passwordBytes = new TextEncoder().encode(password);
+	if (passwordBytes.length >= 72) throw new HexclaveAssertionError(`Password is too long for bcrypt`, { len: passwordBytes.length });
+	const salt = await bcrypt.genSalt(10);
+	return await bcrypt.hash(password, salt);
+}
+async function comparePassword(password, hash) {
+	switch (await getPasswordHashAlgorithm(hash)) {
+		case "bcrypt": return await bcrypt.compare(password, hash);
+		default: return false;
+	}
+}
+async function isPasswordHashValid(hash) {
+	return !!await getPasswordHashAlgorithm(hash);
+}
+async function getPasswordHashAlgorithm(hash) {
+	if (typeof hash !== "string") throw new HexclaveAssertionError(`Passed non-string value to getPasswordHashAlgorithm`, { hash });
+	if (hash.match(/^\$2[ayb]\$.{56}$/)) try {
+		if (bcrypt.getRounds(hash) > 16) return;
+		await bcrypt.compare("any string", hash);
+		return "bcrypt";
+	} catch (e) {
+		console.warn(`Error while checking bcrypt password hash. Assuming the hash is invalid`, e);
+		return;
+	}
+	else return;
+}
+
+//#endregion
+export { comparePassword, getPasswordHashAlgorithm, hashPassword, isPasswordHashValid, sha512 };
+//# sourceMappingURL=hashes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hashes.js","names":[],"sources":["../../../src/utils/hashes.tsx"],"sourcesContent":["import bcrypt from 'bcryptjs';\nimport { HexclaveAssertionError } from './errors';\nimport { toArrayBufferBacked } from './typed-arrays';\n\nexport async function sha512(input: Uint8Array | string): Promise<Uint8Array> {\n  const bytes = typeof input === \"string\" ? new TextEncoder().encode(input) : toArrayBufferBacked(input);\n  return new Uint8Array(await crypto.subtle.digest(\"SHA-512\", bytes));\n}\n\nexport async function hashPassword(password: string) {\n  const passwordBytes = new TextEncoder().encode(password);\n  if (passwordBytes.length >= 72) {\n    throw new HexclaveAssertionError(`Password is too long for bcrypt`, { len: passwordBytes.length });\n  }\n  const salt = await bcrypt.genSalt(10);\n  return await bcrypt.hash(password, salt);\n}\n\nexport async function comparePassword(password: string, hash: string): Promise<boolean> {\n  switch (await getPasswordHashAlgorithm(hash)) {\n    case \"bcrypt\": {\n      return await bcrypt.compare(password, hash);\n    }\n    default: {\n      return false;\n    }\n  }\n}\n\nexport async function isPasswordHashValid(hash: string) {\n  return !!(await getPasswordHashAlgorithm(hash));\n}\n\nexport async function getPasswordHashAlgorithm(hash: string): Promise<\"bcrypt\" | undefined> {\n  if (typeof hash !== \"string\") {\n    throw new HexclaveAssertionError(`Passed non-string value to getPasswordHashAlgorithm`, { hash });\n  }\n  if (hash.match(/^\\$2[ayb]\\$.{56}$/)) {\n    try {\n      if (bcrypt.getRounds(hash) > 16) {\n        return undefined;\n      }\n      await bcrypt.compare(\"any string\", hash);\n      return \"bcrypt\";\n    } catch (e) {\n      console.warn(`Error while checking bcrypt password hash. Assuming the hash is invalid`, e);\n      return undefined;\n    }\n  } else {\n    return undefined;\n  }\n}\n"],"mappings":";;;;;AAIA,eAAsB,OAAO,OAAiD;CAC5E,MAAM,QAAQ,OAAO,UAAU,WAAW,IAAI,aAAa,CAAC,OAAO,MAAM,GAAG,oBAAoB,MAAM;AACtG,QAAO,IAAI,WAAW,MAAM,OAAO,OAAO,OAAO,WAAW,MAAM,CAAC;;AAGrE,eAAsB,aAAa,UAAkB;CACnD,MAAM,gBAAgB,IAAI,aAAa,CAAC,OAAO,SAAS;AACxD,KAAI,cAAc,UAAU,GAC1B,OAAM,IAAI,uBAAuB,mCAAmC,EAAE,KAAK,cAAc,QAAQ,CAAC;CAEpG,MAAM,OAAO,MAAM,OAAO,QAAQ,GAAG;AACrC,QAAO,MAAM,OAAO,KAAK,UAAU,KAAK;;AAG1C,eAAsB,gBAAgB,UAAkB,MAAgC;AACtF,SAAQ,MAAM,yBAAyB,KAAK,EAA5C;EACE,KAAK,SACH,QAAO,MAAM,OAAO,QAAQ,UAAU,KAAK;EAE7C,QACE,QAAO;;;AAKb,eAAsB,oBAAoB,MAAc;AACtD,QAAO,CAAC,CAAE,MAAM,yBAAyB,KAAK;;AAGhD,eAAsB,yBAAyB,MAA6C;AAC1F,KAAI,OAAO,SAAS,SAClB,OAAM,IAAI,uBAAuB,uDAAuD,EAAE,MAAM,CAAC;AAEnG,KAAI,KAAK,MAAM,oBAAoB,CACjC,KAAI;AACF,MAAI,OAAO,UAAU,KAAK,GAAG,GAC3B;AAEF,QAAM,OAAO,QAAQ,cAAc,KAAK;AACxC,SAAO;UACA,GAAG;AACV,UAAQ,KAAK,2EAA2E,EAAE;AAC1F;;KAGF"}

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

@@ -0,0 +1,7 @@
+//#region src/utils/html.d.ts
+declare function escapeHtml(unsafe: string): string;
+declare function html(strings: TemplateStringsArray, ...values: any[]): string;
+declare function htmlToText(untrustedHtml: string): string;
+//#endregion
+export { escapeHtml, html, htmlToText };
+//# sourceMappingURL=html.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.ts","names":[],"sources":["../../../src/utils/html.tsx"],"mappings":";iBAEgB,UAAA,CAAW,MAAA;AAAA,iBA2BX,IAAA,CAAK,OAAA,EAAS,oBAAA,KAAyB,MAAA;AAAA,iBAwBvC,UAAA,CAAW,aAAA"}

package/dist/esm/utils/html.js

@@ -0,0 +1,33 @@
+import { templateIdentity } from "./strings.js";
+
+//#region src/utils/html.tsx
+function escapeHtml(unsafe) {
+	return `${unsafe}`.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+(void 0)?.test("escapeHtml", ({ expect }) => {
+	expect(escapeHtml("")).toBe("");
+	expect(escapeHtml("hello world")).toBe("hello world");
+	expect(escapeHtml("<div>")).toBe("&lt;div&gt;");
+	expect(escapeHtml("a & b")).toBe("a &amp; b");
+	expect(escapeHtml("a \"quoted\" string")).toBe("a &quot;quoted&quot; string");
+	expect(escapeHtml("it's a test")).toBe("it&#039;s a test");
+	expect(escapeHtml("<a href=\"test\">It's a link</a>")).toBe("&lt;a href=&quot;test&quot;&gt;It&#039;s a link&lt;/a&gt;");
+});
+function html(strings, ...values) {
+	return templateIdentity(strings, ...values.map((v) => escapeHtml(`${v}`)));
+}
+(void 0)?.test("html", ({ expect }) => {
+	expect(html`simple string`).toBe("simple string");
+	expect(html`Hello, ${"world"}!`).toBe("Hello, world!");
+	expect(html`Count: ${42}`).toBe("Count: 42");
+	expect(html`<div>${"<script>"}</div>`).toBe("<div>&lt;script&gt;</div>");
+	expect(html`${1} + ${2} = ${"<3"}`).toBe("1 + 2 = &lt;3");
+	expect(html`Object: ${{ toString: () => "<object>" }}`).toBe("Object: &lt;object&gt;");
+});
+function htmlToText(untrustedHtml) {
+	return new DOMParser().parseFromString(untrustedHtml, "text/html").body.textContent;
+}
+
+//#endregion
+export { escapeHtml, html, htmlToText };
+//# sourceMappingURL=html.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"html.js","names":[],"sources":["../../../src/utils/html.tsx"],"sourcesContent":["import { templateIdentity } from \"./strings\";\n\nexport function escapeHtml(unsafe: string): string {\n  return `${unsafe}`\n    .replace(/&/g, '&amp;')\n    .replace(/</g, '&lt;')\n    .replace(/>/g, '&gt;')\n    .replace(/\"/g, \"&quot;\")\n    .replace(/'/g, \"&#039;\");\n}\nimport.meta.vitest?.test(\"escapeHtml\", ({ expect }) => {\n  // Test with empty string\n  expect(escapeHtml(\"\")).toBe(\"\");\n\n  // Test with string without special characters\n  expect(escapeHtml(\"hello world\")).toBe(\"hello world\");\n\n  // Test with special characters\n  expect(escapeHtml(\"<div>\")).toBe(\"&lt;div&gt;\");\n  expect(escapeHtml(\"a & b\")).toBe(\"a &amp; b\");\n  expect(escapeHtml('a \"quoted\" string')).toBe(\"a &quot;quoted&quot; string\");\n  expect(escapeHtml(\"it's a test\")).toBe(\"it&#039;s a test\");\n\n  // Test with multiple special characters\n  expect(escapeHtml(\"<a href=\\\"test\\\">It's a link</a>\")).toBe(\n    \"&lt;a href=&quot;test&quot;&gt;It&#039;s a link&lt;/a&gt;\"\n  );\n});\n\nexport function html(strings: TemplateStringsArray, ...values: any[]): string {\n  return templateIdentity(strings, ...values.map(v => escapeHtml(`${v}`)));\n}\nimport.meta.vitest?.test(\"html\", ({ expect }) => {\n  // Test with no interpolation\n  expect(html`simple string`).toBe(\"simple string\");\n\n  // Test with string interpolation\n  expect(html`Hello, ${\"world\"}!`).toBe(\"Hello, world!\");\n\n  // Test with number interpolation\n  expect(html`Count: ${42}`).toBe(\"Count: 42\");\n\n  // Test with HTML special characters in interpolated values\n  expect(html`<div>${\"<script>\"}</div>`).toBe(\"<div>&lt;script&gt;</div>\");\n\n  // Test with multiple interpolations\n  expect(html`${1} + ${2} = ${\"<3\"}`).toBe(\"1 + 2 = &lt;3\");\n\n  // Test with object interpolation\n  const obj = { toString: () => \"<object>\" };\n  expect(html`Object: ${obj}`).toBe(\"Object: &lt;object&gt;\");\n});\n\nexport function htmlToText(untrustedHtml: string): string {\n\n  const doc = new DOMParser().parseFromString(untrustedHtml, 'text/html');\n\n  return doc.body.textContent;\n\n}\n"],"mappings":";;;AAEA,SAAgB,WAAW,QAAwB;AACjD,QAAO,GAAG,SACP,QAAQ,MAAM,QAAO,CACrB,QAAQ,MAAM,OAAM,CACpB,QAAQ,MAAM,OAAM,CACpB,QAAQ,MAAM,SAAQ,CACtB,QAAQ,MAAM,SAAS;;CAE5B,SAAW,KAAC,eAAc,EAAA,aAAgB;AAExC,QAAO,WAAW,GAAG,CAAC,CAAC,KAAK,GAAG;AAG/B,QAAO,WAAW,cAAc,CAAC,CAAC,KAAK,cAAc;AAGrD,QAAO,WAAW,QAAQ,CAAC,CAAC,KAAK,cAAc;AAC/C,QAAO,WAAW,QAAQ,CAAC,CAAC,KAAK,YAAY;AAC7C,QAAO,WAAW,sBAAoB,CAAC,CAAC,KAAK,8BAA8B;AAC3E,QAAO,WAAW,cAAc,CAAC,CAAC,KAAK,mBAAmB;AAG1D,QAAO,WAAW,mCAAmC,CAAC,CAAC,KACrD,4DACD;EACD;AAEF,SAAgB,KAAK,SAA+B,GAAG,QAAuB;AAC5E,QAAO,iBAAiB,SAAS,GAAG,OAAO,KAAI,MAAK,WAAW,GAAG,IAAI,CAAC,CAAC;;CAE1E,SAAW,KAAC,SAAa,EAAC,aAAU;AAElC,QAAO,IAAI,gBAAgB,CAAC,KAAK,gBAAgB;AAGjD,QAAO,IAAI,UAAU,QAAQ,GAAG,CAAC,KAAK,gBAAgB;AAGtD,QAAO,IAAI,UAAU,KAAK,CAAC,KAAK,YAAY;AAG5C,QAAO,IAAI,QAAQ,WAAW,QAAQ,CAAC,KAAK,4BAA4B;AAGxE,QAAO,IAAI,GAAG,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC,KAAK,gBAAgB;AAIzD,QAAO,IAAI,WADC,EAAE,gBAAgB,YAAY,GACd,CAAC,KAAK,yBAAyB;EAC3D;AAEF,SAAgB,WAAW,eAA+B;AAIxD,QAFY,IAAI,WAAW,CAAC,gBAAgB,eAAe,YAAY,CAE5D,KAAK"}

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

@@ -0,0 +1,45 @@
+//#region src/utils/http.d.ts
+declare const HTTP_METHODS: {
+  readonly GET: {
+    readonly safe: true;
+    readonly idempotent: true;
+  };
+  readonly POST: {
+    readonly safe: false;
+    readonly idempotent: false;
+  };
+  readonly PUT: {
+    readonly safe: false;
+    readonly idempotent: true;
+  };
+  readonly DELETE: {
+    readonly safe: false;
+    readonly idempotent: true;
+  };
+  readonly PATCH: {
+    readonly safe: false;
+    readonly idempotent: false;
+  };
+  readonly OPTIONS: {
+    readonly safe: true;
+    readonly idempotent: true;
+  };
+  readonly HEAD: {
+    readonly safe: true;
+    readonly idempotent: true;
+  };
+  readonly TRACE: {
+    readonly safe: true;
+    readonly idempotent: true;
+  };
+  readonly CONNECT: {
+    readonly safe: false;
+    readonly idempotent: false;
+  };
+};
+type HttpMethod = keyof typeof HTTP_METHODS;
+declare function decodeBasicAuthorizationHeader(value: string): [string, string] | null;
+declare function encodeBasicAuthorizationHeader(id: string, password: string): string;
+//#endregion
+export { HTTP_METHODS, HttpMethod, decodeBasicAuthorizationHeader, encodeBasicAuthorizationHeader };
+//# sourceMappingURL=http.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","names":[],"sources":["../../../src/utils/http.tsx"],"mappings":";cAEa,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsCD,UAAA,gBAA0B,YAAA;AAAA,iBAEtB,8BAAA,CAA+B,KAAA;AAAA,iBA6B/B,8BAAA,CAA+B,EAAA,UAAY,QAAA"}