@stackframe/stack-shared 2.8.8 → 2.8.10

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

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

package/dist/esm/utils/urls.js

@@ -0,0 +1,53 @@
+// src/utils/urls.tsx
+import { generateSecureRandomString } from "./crypto";
+import { templateIdentity } from "./strings";
+function createUrlIfValid(...args) {
+  try {
+    return new URL(...args);
+  } catch (e) {
+    return null;
+  }
+}
+function isValidUrl(url2) {
+  return !!createUrlIfValid(url2);
+}
+function isValidHostname(hostname) {
+  const url2 = createUrlIfValid(`https://${hostname}`);
+  if (!url2) return false;
+  return url2.hostname === hostname;
+}
+function isLocalhost(urlOrString) {
+  const url2 = createUrlIfValid(urlOrString);
+  if (!url2) return false;
+  if (url2.hostname === "localhost" || url2.hostname.endsWith(".localhost")) return true;
+  if (url2.hostname.match(/^127\.\d+\.\d+\.\d+$/)) return true;
+  return false;
+}
+function isRelative(url2) {
+  const randomDomain = `${generateSecureRandomString()}.stack-auth.example.com`;
+  const u = createUrlIfValid(url2, `https://${randomDomain}`);
+  if (!u) return false;
+  if (u.host !== randomDomain) return false;
+  if (u.protocol !== "https:") return false;
+  return true;
+}
+function getRelativePart(url2) {
+  return url2.pathname + url2.search + url2.hash;
+}
+function url(strings, ...values) {
+  return new URL(urlString(strings, ...values));
+}
+function urlString(strings, ...values) {
+  return templateIdentity(strings, ...values.map(encodeURIComponent));
+}
+export {
+  createUrlIfValid,
+  getRelativePart,
+  isLocalhost,
+  isRelative,
+  isValidHostname,
+  isValidUrl,
+  url,
+  urlString
+};
+//# sourceMappingURL=urls.js.map

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

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

package/dist/esm/utils/uuids.js

@@ -0,0 +1,16 @@
+// src/utils/uuids.tsx
+import { generateRandomValues } from "./crypto";
+function generateUuid() {
+  return "10000000-1000-4000-8000-100000000000".replace(
+    /[018]/g,
+    (c) => (+c ^ generateRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16)
+  );
+}
+function isUuid(str) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(str);
+}
+export {
+  generateUuid,
+  isUuid
+};
+//# sourceMappingURL=uuids.js.map

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

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

package/dist/global.d.d.cts

@@ -0,0 +1 @@
+import '@simplewebauthn/types';

package/dist/global.d.d.ts

@@ -0,0 +1 @@
+import '@simplewebauthn/types';

package/dist/global.d.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=global.d.js.map

package/dist/global.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/helpers/password.d.cts

@@ -0,0 +1,11 @@
+import '../crud.cjs';
+import { KnownErrors } from '../known-errors.cjs';
+import 'yup';
+import '../utils/types.cjs';
+import '../utils/errors.cjs';
+import '../utils/json.cjs';
+import '../utils/results.cjs';
+
+declare function getPasswordError(password: string): KnownErrors["PasswordRequirementsNotMet"] | undefined;
+
+export { getPasswordError };

package/dist/helpers/password.d.ts

@@ -1,2 +1,11 @@
-import { KnownErrors } from "..";
-export declare function getPasswordError(password: string): KnownErrors["PasswordRequirementsNotMet"] | undefined;
+import '../crud.js';
+import { KnownErrors } from '../known-errors.js';
+import 'yup';
+import '../utils/types.js';
+import '../utils/errors.js';
+import '../utils/json.js';
+import '../utils/results.js';
+
+declare function getPasswordError(password: string): KnownErrors["PasswordRequirementsNotMet"] | undefined;
+
+export { getPasswordError };

package/dist/helpers/password.js

@@ -1,12 +1,42 @@
-import { KnownErrors } from "..";
-const minLength = 8;
-const maxLength = 70;
-export function getPasswordError(password) {
-    if (password.length < minLength) {
-        return new KnownErrors.PasswordTooShort(minLength);
-    }
-    if (password.length > maxLength) {
-        return new KnownErrors.PasswordTooLong(maxLength);
-    }
-    return undefined;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/helpers/password.ts
+var password_exports = {};
+__export(password_exports, {
+  getPasswordError: () => getPasswordError
+});
+module.exports = __toCommonJS(password_exports);
+var import__ = require("..");
+var minLength = 8;
+var maxLength = 70;
+function getPasswordError(password) {
+  if (password.length < minLength) {
+    return new import__.KnownErrors.PasswordTooShort(minLength);
+  }
+  if (password.length > maxLength) {
+    return new import__.KnownErrors.PasswordTooLong(maxLength);
+  }
+  return void 0;
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPasswordError
+});
+//# sourceMappingURL=password.js.map

package/dist/helpers/password.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/helpers/password.ts"],"sourcesContent":["import { KnownErrors } from \"..\";\n\nconst minLength = 8;\nconst maxLength = 70;\n\nexport function getPasswordError(password: string): KnownErrors[\"PasswordRequirementsNotMet\"] | undefined {\n  if (password.length < minLength) {\n    return new KnownErrors.PasswordTooShort(minLength);\n  }\n\n  if (password.length > maxLength) {\n    return new KnownErrors.PasswordTooLong(maxLength);\n  }\n\n  return undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAA4B;AAE5B,IAAM,YAAY;AAClB,IAAM,YAAY;AAEX,SAAS,iBAAiB,UAAyE;AACxG,MAAI,SAAS,SAAS,WAAW;AAC/B,WAAO,IAAI,qBAAY,iBAAiB,SAAS;AAAA,EACnD;AAEA,MAAI,SAAS,SAAS,WAAW;AAC/B,WAAO,IAAI,qBAAY,gBAAgB,SAAS;AAAA,EAClD;AAEA,SAAO;AACT;","names":[]}

package/dist/helpers/production-mode.d.cts

@@ -0,0 +1,12 @@
+import { ProjectsCrud } from '../interface/crud/projects.cjs';
+import '../crud.cjs';
+import 'yup';
+import '../utils/types.cjs';
+
+type ProductionModeError = {
+    message: string;
+    relativeFixUrl: `/${string}`;
+};
+declare function getProductionModeErrors(project: ProjectsCrud["Admin"]["Read"]): ProductionModeError[];
+
+export { type ProductionModeError, getProductionModeErrors };

package/dist/helpers/production-mode.d.ts

@@ -1,6 +1,12 @@
-import { ProjectsCrud } from "../interface/crud/projects";
-export type ProductionModeError = {
+import { ProjectsCrud } from '../interface/crud/projects.js';
+import '../crud.js';
+import 'yup';
+import '../utils/types.js';
+
+type ProductionModeError = {
     message: string;
     relativeFixUrl: `/${string}`;
 };
-export declare function getProductionModeErrors(project: ProjectsCrud["Admin"]["Read"]): ProductionModeError[];
+declare function getProductionModeErrors(project: ProjectsCrud["Admin"]["Read"]): ProductionModeError[];
+
+export { type ProductionModeError, getProductionModeErrors };

package/dist/helpers/production-mode.js

@@ -1,48 +1,75 @@
-import { StackAssertionError, captureError } from "../utils/errors";
-import { isLocalhost } from "../utils/urls";
-export function getProductionModeErrors(project) {
-    const errors = [];
-    const domainsFixUrl = `/projects/${project.id}/domains`;
-    if (project.config.allow_localhost) {
-        errors.push({
-            message: "Localhost is not allowed in production mode, turn off 'Allow localhost' in project settings",
-            relativeFixUrl: domainsFixUrl,
-        });
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/helpers/production-mode.ts
+var production_mode_exports = {};
+__export(production_mode_exports, {
+  getProductionModeErrors: () => getProductionModeErrors
+});
+module.exports = __toCommonJS(production_mode_exports);
+var import_errors = require("../utils/errors");
+var import_urls = require("../utils/urls");
+function getProductionModeErrors(project) {
+  const errors = [];
+  const domainsFixUrl = `/projects/${project.id}/domains`;
+  if (project.config.allow_localhost) {
+    errors.push({
+      message: "Localhost is not allowed in production mode, turn off 'Allow localhost' in project settings",
+      relativeFixUrl: domainsFixUrl
+    });
+  }
+  for (const { domain } of project.config.domains) {
+    let url;
+    try {
+      url = new URL(domain);
+    } catch (e) {
+      (0, import_errors.captureError)("production-mode-domain-not-valid", new import_errors.StackAssertionError("Domain was somehow not a valid URL; we should've caught this when setting the domain in the first place", {
+        domain,
+        projectId: project
+      }));
+      errors.push({
+        message: "Trusted domain is not a valid URL: " + domain,
+        relativeFixUrl: domainsFixUrl
+      });
+      continue;
     }
-    for (const { domain } of project.config.domains) {
-        let url;
-        try {
-            url = new URL(domain);
-        }
-        catch (e) {
-            captureError("production-mode-domain-not-valid", new StackAssertionError("Domain was somehow not a valid URL; we should've caught this when setting the domain in the first place", {
-                domain,
-                projectId: project
-            }));
-            errors.push({
-                message: "Trusted domain is not a valid URL: " + domain,
-                relativeFixUrl: domainsFixUrl,
-            });
-            continue;
-        }
-        if (isLocalhost(url)) {
-            errors.push({
-                message: "Localhost domains are not allowed to be trusted in production mode: " + domain,
-                relativeFixUrl: domainsFixUrl,
-            });
-        }
-        else if (url.hostname.match(/^\d+(\.\d+)*$/)) {
-            errors.push({
-                message: "Direct IPs are not valid for trusted domains in production mode: " + domain,
-                relativeFixUrl: domainsFixUrl,
-            });
-        }
-        else if (url.protocol !== "https:") {
-            errors.push({
-                message: "Trusted domains should be HTTPS: " + domain,
-                relativeFixUrl: domainsFixUrl,
-            });
-        }
+    if ((0, import_urls.isLocalhost)(url)) {
+      errors.push({
+        message: "Localhost domains are not allowed to be trusted in production mode: " + domain,
+        relativeFixUrl: domainsFixUrl
+      });
+    } else if (url.hostname.match(/^\d+(\.\d+)*$/)) {
+      errors.push({
+        message: "Direct IPs are not valid for trusted domains in production mode: " + domain,
+        relativeFixUrl: domainsFixUrl
+      });
+    } else if (url.protocol !== "https:") {
+      errors.push({
+        message: "Trusted domains should be HTTPS: " + domain,
+        relativeFixUrl: domainsFixUrl
+      });
     }
-    return errors;
+  }
+  return errors;
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getProductionModeErrors
+});
+//# sourceMappingURL=production-mode.js.map

package/dist/helpers/production-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/helpers/production-mode.ts"],"sourcesContent":["import { ProjectsCrud } from \"../interface/crud/projects\";\nimport { StackAssertionError, captureError } from \"../utils/errors\";\nimport { isLocalhost } from \"../utils/urls\";\n\nexport type ProductionModeError = {\n  message: string,\n  relativeFixUrl: `/${string}`,\n};\n\nexport function getProductionModeErrors(project: ProjectsCrud[\"Admin\"][\"Read\"]): ProductionModeError[] {\n  const errors: ProductionModeError[] = [];\n  const domainsFixUrl = `/projects/${project.id}/domains` as const;\n\n  if (project.config.allow_localhost) {\n    errors.push({\n      message: \"Localhost is not allowed in production mode, turn off 'Allow localhost' in project settings\",\n      relativeFixUrl: domainsFixUrl,\n    });\n  }\n\n  for (const { domain } of project.config.domains) {\n    let url;\n    try {\n      url = new URL(domain);\n    } catch (e) {\n      captureError(\"production-mode-domain-not-valid\", new StackAssertionError(\"Domain was somehow not a valid URL; we should've caught this when setting the domain in the first place\", {\n        domain,\n        projectId: project\n      }));\n      errors.push({\n        message: \"Trusted domain is not a valid URL: \" + domain,\n        relativeFixUrl: domainsFixUrl,\n      });\n      continue;\n    }\n\n    if (isLocalhost(url)) {\n      errors.push({\n        message: \"Localhost domains are not allowed to be trusted in production mode: \" + domain,\n        relativeFixUrl: domainsFixUrl,\n      });\n    } else if (url.hostname.match(/^\\d+(\\.\\d+)*$/)) {\n      errors.push({\n        message: \"Direct IPs are not valid for trusted domains in production mode: \" + domain,\n        relativeFixUrl: domainsFixUrl,\n      });\n    } else if (url.protocol !== \"https:\") {\n      errors.push({\n        message: \"Trusted domains should be HTTPS: \" + domain,\n        relativeFixUrl: domainsFixUrl,\n      });\n    }\n  }\n\n  return errors;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oBAAkD;AAClD,kBAA4B;AAOrB,SAAS,wBAAwB,SAA+D;AACrG,QAAM,SAAgC,CAAC;AACvC,QAAM,gBAAgB,aAAa,QAAQ,EAAE;AAE7C,MAAI,QAAQ,OAAO,iBAAiB;AAClC,WAAO,KAAK;AAAA,MACV,SAAS;AAAA,MACT,gBAAgB;AAAA,IAClB,CAAC;AAAA,EACH;AAEA,aAAW,EAAE,OAAO,KAAK,QAAQ,OAAO,SAAS;AAC/C,QAAI;AACJ,QAAI;AACF,YAAM,IAAI,IAAI,MAAM;AAAA,IACtB,SAAS,GAAG;AACV,sCAAa,oCAAoC,IAAI,kCAAoB,2GAA2G;AAAA,QAClL;AAAA,QACA,WAAW;AAAA,MACb,CAAC,CAAC;AACF,aAAO,KAAK;AAAA,QACV,SAAS,wCAAwC;AAAA,QACjD,gBAAgB;AAAA,MAClB,CAAC;AACD;AAAA,IACF;AAEA,YAAI,yBAAY,GAAG,GAAG;AACpB,aAAO,KAAK;AAAA,QACV,SAAS,yEAAyE;AAAA,QAClF,gBAAgB;AAAA,MAClB,CAAC;AAAA,IACH,WAAW,IAAI,SAAS,MAAM,eAAe,GAAG;AAC9C,aAAO,KAAK;AAAA,QACV,SAAS,sEAAsE;AAAA,QAC/E,gBAAgB;AAAA,MAClB,CAAC;AAAA,IACH,WAAW,IAAI,aAAa,UAAU;AACpC,aAAO,KAAK;AAAA,QACV,SAAS,sCAAsC;AAAA,QAC/C,gBAAgB;AAAA,MAClB,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/hooks/use-async-callback.d.cts

@@ -0,0 +1,6 @@
+import React from 'react';
+
+declare function useAsyncCallback<A extends any[], R>(callback: (...args: A) => Promise<R>, deps: React.DependencyList): [cb: (...args: A) => Promise<R>, loading: boolean, error: unknown | undefined];
+declare function useAsyncCallbackWithLoggedError<A extends any[], R>(callback: (...args: A) => Promise<R>, deps: React.DependencyList): [cb: (...args: A) => Promise<R>, loading: boolean];
+
+export { useAsyncCallback, useAsyncCallbackWithLoggedError };

package/dist/hooks/use-async-callback.d.ts

@@ -1,3 +1,6 @@
-import React from "react";
-export declare function useAsyncCallback<A extends any[], R>(callback: (...args: A) => Promise<R>, deps: React.DependencyList): [cb: (...args: A) => Promise<R>, loading: boolean, error: unknown | undefined];
-export declare function useAsyncCallbackWithLoggedError<A extends any[], R>(callback: (...args: A) => Promise<R>, deps: React.DependencyList): [cb: (...args: A) => Promise<R>, loading: boolean];
+import React from 'react';
+
+declare function useAsyncCallback<A extends any[], R>(callback: (...args: A) => Promise<R>, deps: React.DependencyList): [cb: (...args: A) => Promise<R>, loading: boolean, error: unknown | undefined];
+declare function useAsyncCallbackWithLoggedError<A extends any[], R>(callback: (...args: A) => Promise<R>, deps: React.DependencyList): [cb: (...args: A) => Promise<R>, loading: boolean];
+
+export { useAsyncCallback, useAsyncCallbackWithLoggedError };

package/dist/hooks/use-async-callback.js

@@ -1,32 +1,74 @@
-import React from "react";
-import { captureError } from "../utils/errors";
-export function useAsyncCallback(callback, deps) {
-    const [error, setError] = React.useState(undefined);
-    const [loadingCount, setLoadingCount] = React.useState(0);
-    const cb = React.useCallback(async (...args) => {
-        setLoadingCount((c) => c + 1);
-        try {
-            return await callback(...args);
-        }
-        catch (e) {
-            setError(e);
-            throw e;
-        }
-        finally {
-            setLoadingCount((c) => c - 1);
-        }
-    }, deps);
-    return [cb, loadingCount > 0, error];
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/use-async-callback.tsx
+var use_async_callback_exports = {};
+__export(use_async_callback_exports, {
+  useAsyncCallback: () => useAsyncCallback,
+  useAsyncCallbackWithLoggedError: () => useAsyncCallbackWithLoggedError
+});
+module.exports = __toCommonJS(use_async_callback_exports);
+var import_react = __toESM(require("react"), 1);
+var import_errors = require("../utils/errors");
+function useAsyncCallback(callback, deps) {
+  const [error, setError] = import_react.default.useState(void 0);
+  const [loadingCount, setLoadingCount] = import_react.default.useState(0);
+  const cb = import_react.default.useCallback(
+    async (...args) => {
+      setLoadingCount((c) => c + 1);
+      try {
+        return await callback(...args);
+      } catch (e) {
+        setError(e);
+        throw e;
+      } finally {
+        setLoadingCount((c) => c - 1);
+      }
+    },
+    deps
+  );
+  return [cb, loadingCount > 0, error];
 }
-export function useAsyncCallbackWithLoggedError(callback, deps) {
-    const [newCallback, loading] = useAsyncCallback(async (...args) => {
-        try {
-            return await callback(...args);
-        }
-        catch (e) {
-            captureError("async-callback", e);
-            throw e;
-        }
-    }, deps);
-    return [newCallback, loading];
+function useAsyncCallbackWithLoggedError(callback, deps) {
+  const [newCallback, loading] = useAsyncCallback(async (...args) => {
+    try {
+      return await callback(...args);
+    } catch (e) {
+      (0, import_errors.captureError)("async-callback", e);
+      throw e;
+    }
+  }, deps);
+  return [newCallback, loading];
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useAsyncCallback,
+  useAsyncCallbackWithLoggedError
+});
+//# sourceMappingURL=use-async-callback.js.map

package/dist/hooks/use-async-callback.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-async-callback.tsx"],"sourcesContent":["import React from \"react\";\nimport { captureError } from \"../utils/errors\";\n\nexport function useAsyncCallback<A extends any[], R>(\n  callback: (...args: A) => Promise<R>,\n  deps: React.DependencyList\n): [cb: (...args: A) => Promise<R>, loading: boolean, error: unknown | undefined] {\n  const [error, setError] = React.useState<unknown | undefined>(undefined);\n  const [loadingCount, setLoadingCount] = React.useState(0);\n\n  const cb = React.useCallback(\n    async (...args: A) => {\n      setLoadingCount((c) => c + 1);\n      try {\n        return await callback(...args);\n      } catch (e) {\n        setError(e);\n        throw e;\n      } finally {\n        setLoadingCount((c) => c - 1);\n      }\n    },\n    deps,\n  );\n\n  return [cb, loadingCount > 0, error];\n}\n\nexport function useAsyncCallbackWithLoggedError<A extends any[], R>(\n  callback: (...args: A) => Promise<R>,\n  deps: React.DependencyList\n): [cb: (...args: A) => Promise<R>, loading: boolean] {\n  const [newCallback, loading] = useAsyncCallback<A, R>(async (...args) => {\n    try {\n      return await callback(...args);\n    } catch (e) {\n      captureError(\"async-callback\", e);\n      throw e;\n    }\n  }, deps);\n\n  return [newCallback, loading];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAkB;AAClB,oBAA6B;AAEtB,SAAS,iBACd,UACA,MACgF;AAChF,QAAM,CAAC,OAAO,QAAQ,IAAI,aAAAA,QAAM,SAA8B,MAAS;AACvE,QAAM,CAAC,cAAc,eAAe,IAAI,aAAAA,QAAM,SAAS,CAAC;AAExD,QAAM,KAAK,aAAAA,QAAM;AAAA,IACf,UAAU,SAAY;AACpB,sBAAgB,CAAC,MAAM,IAAI,CAAC;AAC5B,UAAI;AACF,eAAO,MAAM,SAAS,GAAG,IAAI;AAAA,MAC/B,SAAS,GAAG;AACV,iBAAS,CAAC;AACV,cAAM;AAAA,MACR,UAAE;AACA,wBAAgB,CAAC,MAAM,IAAI,CAAC;AAAA,MAC9B;AAAA,IACF;AAAA,IACA;AAAA,EACF;AAEA,SAAO,CAAC,IAAI,eAAe,GAAG,KAAK;AACrC;AAEO,SAAS,gCACd,UACA,MACoD;AACpD,QAAM,CAAC,aAAa,OAAO,IAAI,iBAAuB,UAAU,SAAS;AACvE,QAAI;AACF,aAAO,MAAM,SAAS,GAAG,IAAI;AAAA,IAC/B,SAAS,GAAG;AACV,sCAAa,kBAAkB,CAAC;AAChC,YAAM;AAAA,IACR;AAAA,EACF,GAAG,IAAI;AAEP,SAAO,CAAC,aAAa,OAAO;AAC9B;","names":["React"]}

package/dist/hooks/use-async-external-store.d.cts

@@ -0,0 +1,7 @@
+import { AsyncResult } from '../utils/results.cjs';
+
+declare function useAsyncExternalStore<T>(subscribe: (callback: (t: T) => void) => (() => void)): AsyncResult<T, never> & {
+    status: "ok" | "pending";
+};
+
+export { useAsyncExternalStore };

package/dist/hooks/use-async-external-store.d.ts

@@ -1,4 +1,7 @@
-import { AsyncResult } from "../utils/results";
-export declare function useAsyncExternalStore<T>(subscribe: (callback: (t: T) => void) => (() => void)): AsyncResult<T, never> & {
+import { AsyncResult } from '../utils/results.js';
+
+declare function useAsyncExternalStore<T>(subscribe: (callback: (t: T) => void) => (() => void)): AsyncResult<T, never> & {
     status: "ok" | "pending";
 };
+
+export { useAsyncExternalStore };

package/dist/hooks/use-async-external-store.js

@@ -1,20 +1,48 @@
-import { useEffect, useState } from "react";
-import { AsyncResult } from "../utils/results";
-export function useAsyncExternalStore(subscribe) {
-    // sure, the "sync" in useSyncExternalStore refers to "synchronize a store" and not "sync/async", but it's too good of a name to pass up on
-    const [isAvailable, setIsAvailable] = useState(false);
-    const [value, setValue] = useState();
-    useEffect(() => {
-        const unsubscribe = subscribe((value) => {
-            setValue(() => value);
-            setIsAvailable(() => true);
-        });
-        return unsubscribe;
-    }, [subscribe]);
-    if (isAvailable) {
-        return AsyncResult.ok(value);
-    }
-    else {
-        return AsyncResult.pending();
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/use-async-external-store.tsx
+var use_async_external_store_exports = {};
+__export(use_async_external_store_exports, {
+  useAsyncExternalStore: () => useAsyncExternalStore
+});
+module.exports = __toCommonJS(use_async_external_store_exports);
+var import_react = require("react");
+var import_results = require("../utils/results");
+function useAsyncExternalStore(subscribe) {
+  const [isAvailable, setIsAvailable] = (0, import_react.useState)(false);
+  const [value, setValue] = (0, import_react.useState)();
+  (0, import_react.useEffect)(() => {
+    const unsubscribe = subscribe((value2) => {
+      setValue(() => value2);
+      setIsAvailable(() => true);
+    });
+    return unsubscribe;
+  }, [subscribe]);
+  if (isAvailable) {
+    return import_results.AsyncResult.ok(value);
+  } else {
+    return import_results.AsyncResult.pending();
+  }
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useAsyncExternalStore
+});
+//# sourceMappingURL=use-async-external-store.js.map

package/dist/hooks/use-async-external-store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-async-external-store.tsx"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { AsyncResult } from \"../utils/results\";\n\nexport function useAsyncExternalStore<T>(\n  subscribe: (callback: (t: T) => void) => (() => void),\n): AsyncResult<T, never> & { status: \"ok\" | \"pending\" } {\n  // sure, the \"sync\" in useSyncExternalStore refers to \"synchronize a store\" and not \"sync/async\", but it's too good of a name to pass up on\n\n  const [isAvailable, setIsAvailable] = useState(false);\n  const [value, setValue] = useState<T>();\n  useEffect(() => {\n    const unsubscribe = subscribe((value: T) => {\n      setValue(() => value);\n      setIsAvailable(() => true);\n    });\n    return unsubscribe;\n  }, [subscribe]);\n\n  if (isAvailable) {\n    return AsyncResult.ok(value as T);\n  } else {\n    return AsyncResult.pending();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAoC;AACpC,qBAA4B;AAErB,SAAS,sBACd,WACsD;AAGtD,QAAM,CAAC,aAAa,cAAc,QAAI,uBAAS,KAAK;AACpD,QAAM,CAAC,OAAO,QAAQ,QAAI,uBAAY;AACtC,8BAAU,MAAM;AACd,UAAM,cAAc,UAAU,CAACA,WAAa;AAC1C,eAAS,MAAMA,MAAK;AACpB,qBAAe,MAAM,IAAI;AAAA,IAC3B,CAAC;AACD,WAAO;AAAA,EACT,GAAG,CAAC,SAAS,CAAC;AAEd,MAAI,aAAa;AACf,WAAO,2BAAY,GAAG,KAAU;AAAA,EAClC,OAAO;AACL,WAAO,2BAAY,QAAQ;AAAA,EAC7B;AACF;","names":["value"]}

package/dist/hooks/use-hash.d.cts

@@ -0,0 +1,3 @@
+declare const useHash: () => string;
+
+export { useHash };

package/dist/hooks/use-hash.d.ts

@@ -1 +1,3 @@
-export declare const useHash: () => string;
+declare const useHash: () => string;
+
+export { useHash };