create-croissant 0.1.0 → 0.1.1

package/template/apps/web/node_modules/@better-auth/utils/dist/base32.mjs

@@ -0,0 +1,101 @@
+function getAlphabet(hex) {
+  return hex ? "0123456789ABCDEFGHIJKLMNOPQRSTUV" : "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+}
+function createDecodeMap(alphabet) {
+  const decodeMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < alphabet.length; i++) {
+    decodeMap.set(alphabet[i], i);
+  }
+  return decodeMap;
+}
+function base32Encode(data, alphabet, padding) {
+  let result = "";
+  let buffer = 0;
+  let shift = 0;
+  for (const byte of data) {
+    buffer = buffer << 8 | byte;
+    shift += 8;
+    while (shift >= 5) {
+      shift -= 5;
+      result += alphabet[buffer >> shift & 31];
+    }
+  }
+  if (shift > 0) {
+    result += alphabet[buffer << 5 - shift & 31];
+  }
+  if (padding) {
+    const padCount = (8 - result.length % 8) % 8;
+    result += "=".repeat(padCount);
+  }
+  return result;
+}
+function base32Decode(data, alphabet) {
+  const decodeMap = createDecodeMap(alphabet);
+  const result = [];
+  let buffer = 0;
+  let bitsCollected = 0;
+  for (const char of data) {
+    if (char === "=")
+      break;
+    const value = decodeMap.get(char);
+    if (value === void 0) {
+      throw new Error(`Invalid Base32 character: ${char}`);
+    }
+    buffer = buffer << 5 | value;
+    bitsCollected += 5;
+    while (bitsCollected >= 8) {
+      bitsCollected -= 8;
+      result.push(buffer >> bitsCollected & 255);
+    }
+  }
+  return Uint8Array.from(result);
+}
+const base32 = {
+  /**
+   * Encodes data into a Base32 string.
+   * @param data - The data to encode (ArrayBuffer, TypedArray, or string).
+   * @param options - Encoding options.
+   * @returns The Base32 encoded string.
+   */
+  encode(data, options = {}) {
+    const alphabet = getAlphabet(false);
+    const buffer = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
+    return base32Encode(buffer, alphabet, options.padding ?? true);
+  },
+  /**
+   * Decodes a Base32 string into a Uint8Array.
+   * @param data - The Base32 encoded string or ArrayBuffer/TypedArray.
+   * @returns The decoded Uint8Array.
+   */
+  decode(data) {
+    if (typeof data !== "string") {
+      data = new TextDecoder().decode(data);
+    }
+    const alphabet = getAlphabet(false);
+    return base32Decode(data, alphabet);
+  }
+};
+const base32hex = {
+  /**
+   * Encodes data into a Base32hex string.
+   * @param data - The data to encode (ArrayBuffer, TypedArray, or string).
+   * @param options - Encoding options.
+   * @returns The Base32hex encoded string.
+   */
+  encode(data, options = {}) {
+    const alphabet = getAlphabet(true);
+    const buffer = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
+    return base32Encode(buffer, alphabet, options.padding ?? true);
+  },
+  /**
+   * Decodes a Base32hex string into a Uint8Array.
+   * @param data - The Base32hex encoded string.
+   * @returns The decoded Uint8Array.
+   */
+  decode(data) {
+    const alphabet = getAlphabet(true);
+    return base32Decode(data, alphabet);
+  }
+};
+
+export { base32, base32hex };

package/template/apps/web/node_modules/@better-auth/utils/dist/base64.cjs

@@ -0,0 +1,80 @@
+'use strict';
+
+function getAlphabet(urlSafe) {
+  return urlSafe ? "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_" : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+}
+function base64Encode(data, alphabet, padding) {
+  let result = "";
+  let buffer = 0;
+  let shift = 0;
+  for (const byte of data) {
+    buffer = buffer << 8 | byte;
+    shift += 8;
+    while (shift >= 6) {
+      shift -= 6;
+      result += alphabet[buffer >> shift & 63];
+    }
+  }
+  if (shift > 0) {
+    result += alphabet[buffer << 6 - shift & 63];
+  }
+  if (padding) {
+    const padCount = (4 - result.length % 4) % 4;
+    result += "=".repeat(padCount);
+  }
+  return result;
+}
+function base64Decode(data, alphabet) {
+  const decodeMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < alphabet.length; i++) {
+    decodeMap.set(alphabet[i], i);
+  }
+  const result = [];
+  let buffer = 0;
+  let bitsCollected = 0;
+  for (const char of data) {
+    if (char === "=")
+      break;
+    const value = decodeMap.get(char);
+    if (value === void 0) {
+      throw new Error(`Invalid Base64 character: ${char}`);
+    }
+    buffer = buffer << 6 | value;
+    bitsCollected += 6;
+    if (bitsCollected >= 8) {
+      bitsCollected -= 8;
+      result.push(buffer >> bitsCollected & 255);
+    }
+  }
+  return Uint8Array.from(result);
+}
+const base64 = {
+  encode(data, options = {}) {
+    const alphabet = getAlphabet(false);
+    const buffer = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
+    return base64Encode(buffer, alphabet, options.padding ?? true);
+  },
+  decode(data) {
+    if (typeof data !== "string") {
+      data = new TextDecoder().decode(data);
+    }
+    const urlSafe = data.includes("-") || data.includes("_");
+    const alphabet = getAlphabet(urlSafe);
+    return base64Decode(data, alphabet);
+  }
+};
+const base64Url = {
+  encode(data, options = {}) {
+    const alphabet = getAlphabet(true);
+    const buffer = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
+    return base64Encode(buffer, alphabet, options.padding ?? true);
+  },
+  decode(data) {
+    const urlSafe = data.includes("-") || data.includes("_");
+    const alphabet = getAlphabet(urlSafe);
+    return base64Decode(data, alphabet);
+  }
+};
+
+exports.base64 = base64;
+exports.base64Url = base64Url;

package/template/apps/web/node_modules/@better-auth/utils/dist/base64.d.cts

@@ -0,0 +1,16 @@
+import { T as TypedArray } from './shared/utils.ecd028f7.cjs';
+
+declare const base64: {
+    encode(data: ArrayBuffer | TypedArray | string, options?: {
+        padding?: boolean;
+    }): string;
+    decode(data: string | ArrayBuffer | TypedArray): Uint8Array<ArrayBuffer>;
+};
+declare const base64Url: {
+    encode(data: ArrayBuffer | TypedArray | string, options?: {
+        padding?: boolean;
+    }): string;
+    decode(data: string): Uint8Array<ArrayBuffer>;
+};
+
+export { base64, base64Url };

package/template/apps/web/node_modules/@better-auth/utils/dist/base64.d.mts

@@ -0,0 +1,16 @@
+import { T as TypedArray } from './shared/utils.ecd028f7.mjs';
+
+declare const base64: {
+    encode(data: ArrayBuffer | TypedArray | string, options?: {
+        padding?: boolean;
+    }): string;
+    decode(data: string | ArrayBuffer | TypedArray): Uint8Array<ArrayBuffer>;
+};
+declare const base64Url: {
+    encode(data: ArrayBuffer | TypedArray | string, options?: {
+        padding?: boolean;
+    }): string;
+    decode(data: string): Uint8Array<ArrayBuffer>;
+};
+
+export { base64, base64Url };

package/template/apps/web/node_modules/@better-auth/utils/dist/base64.d.ts

@@ -0,0 +1,16 @@
+import { T as TypedArray } from './shared/utils.ecd028f7.js';
+
+declare const base64: {
+    encode(data: ArrayBuffer | TypedArray | string, options?: {
+        padding?: boolean;
+    }): string;
+    decode(data: string | ArrayBuffer | TypedArray): Uint8Array<ArrayBuffer>;
+};
+declare const base64Url: {
+    encode(data: ArrayBuffer | TypedArray | string, options?: {
+        padding?: boolean;
+    }): string;
+    decode(data: string): Uint8Array<ArrayBuffer>;
+};
+
+export { base64, base64Url };

package/template/apps/web/node_modules/@better-auth/utils/dist/base64.mjs

@@ -0,0 +1,77 @@
+function getAlphabet(urlSafe) {
+  return urlSafe ? "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_" : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+}
+function base64Encode(data, alphabet, padding) {
+  let result = "";
+  let buffer = 0;
+  let shift = 0;
+  for (const byte of data) {
+    buffer = buffer << 8 | byte;
+    shift += 8;
+    while (shift >= 6) {
+      shift -= 6;
+      result += alphabet[buffer >> shift & 63];
+    }
+  }
+  if (shift > 0) {
+    result += alphabet[buffer << 6 - shift & 63];
+  }
+  if (padding) {
+    const padCount = (4 - result.length % 4) % 4;
+    result += "=".repeat(padCount);
+  }
+  return result;
+}
+function base64Decode(data, alphabet) {
+  const decodeMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < alphabet.length; i++) {
+    decodeMap.set(alphabet[i], i);
+  }
+  const result = [];
+  let buffer = 0;
+  let bitsCollected = 0;
+  for (const char of data) {
+    if (char === "=")
+      break;
+    const value = decodeMap.get(char);
+    if (value === void 0) {
+      throw new Error(`Invalid Base64 character: ${char}`);
+    }
+    buffer = buffer << 6 | value;
+    bitsCollected += 6;
+    if (bitsCollected >= 8) {
+      bitsCollected -= 8;
+      result.push(buffer >> bitsCollected & 255);
+    }
+  }
+  return Uint8Array.from(result);
+}
+const base64 = {
+  encode(data, options = {}) {
+    const alphabet = getAlphabet(false);
+    const buffer = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
+    return base64Encode(buffer, alphabet, options.padding ?? true);
+  },
+  decode(data) {
+    if (typeof data !== "string") {
+      data = new TextDecoder().decode(data);
+    }
+    const urlSafe = data.includes("-") || data.includes("_");
+    const alphabet = getAlphabet(urlSafe);
+    return base64Decode(data, alphabet);
+  }
+};
+const base64Url = {
+  encode(data, options = {}) {
+    const alphabet = getAlphabet(true);
+    const buffer = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
+    return base64Encode(buffer, alphabet, options.padding ?? true);
+  },
+  decode(data) {
+    const urlSafe = data.includes("-") || data.includes("_");
+    const alphabet = getAlphabet(urlSafe);
+    return base64Decode(data, alphabet);
+  }
+};
+
+export { base64, base64Url };

package/template/apps/web/node_modules/@better-auth/utils/dist/binary.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+const decoders = /* @__PURE__ */ new Map();
+const encoder = new TextEncoder();
+const binary = {
+  decode: (data, encoding = "utf-8") => {
+    if (!decoders.has(encoding)) {
+      decoders.set(encoding, new TextDecoder(encoding));
+    }
+    const decoder = decoders.get(encoding);
+    return decoder.decode(data);
+  },
+  encode: encoder.encode
+};
+
+exports.binary = binary;

package/template/apps/web/node_modules/@better-auth/utils/dist/binary.d.cts

@@ -0,0 +1,8 @@
+type Encoding = "utf-8" | "utf-16" | "iso-8859-1";
+type BinaryData = ArrayBuffer | ArrayBufferView;
+declare const binary: {
+    decode: (data: BinaryData, encoding?: Encoding) => string;
+    encode: (input?: string) => Uint8Array;
+};
+
+export { binary };

package/template/apps/web/node_modules/@better-auth/utils/dist/binary.d.mts

@@ -0,0 +1,8 @@
+type Encoding = "utf-8" | "utf-16" | "iso-8859-1";
+type BinaryData = ArrayBuffer | ArrayBufferView;
+declare const binary: {
+    decode: (data: BinaryData, encoding?: Encoding) => string;
+    encode: (input?: string) => Uint8Array;
+};
+
+export { binary };

package/template/apps/web/node_modules/@better-auth/utils/dist/binary.d.ts

@@ -0,0 +1,8 @@
+type Encoding = "utf-8" | "utf-16" | "iso-8859-1";
+type BinaryData = ArrayBuffer | ArrayBufferView;
+declare const binary: {
+    decode: (data: BinaryData, encoding?: Encoding) => string;
+    encode: (input?: string) => Uint8Array;
+};
+
+export { binary };

package/template/apps/web/node_modules/@better-auth/utils/dist/binary.mjs

@@ -0,0 +1,14 @@
+const decoders = /* @__PURE__ */ new Map();
+const encoder = new TextEncoder();
+const binary = {
+  decode: (data, encoding = "utf-8") => {
+    if (!decoders.has(encoding)) {
+      decoders.set(encoding, new TextDecoder(encoding));
+    }
+    const decoder = decoders.get(encoding);
+    return decoder.decode(data);
+  },
+  encode: encoder.encode
+};
+
+export { binary };

package/template/apps/web/node_modules/@better-auth/utils/dist/ecdsa.cjs

@@ -0,0 +1,90 @@
+'use strict';
+
+const index = require('./index.cjs');
+
+const ecdsa = {
+  generateKeyPair: async (curve = "P-256") => {
+    const subtle = index.getWebcryptoSubtle();
+    const keyPair = await subtle.generateKey(
+      {
+        name: "ECDSA",
+        namedCurve: curve
+      },
+      true,
+      ["sign", "verify"]
+    );
+    const privateKey = await subtle.exportKey("pkcs8", keyPair.privateKey);
+    const publicKey = await subtle.exportKey("spki", keyPair.publicKey);
+    return { privateKey, publicKey };
+  },
+  importPrivateKey: async (privateKey, curve, extractable = false) => {
+    if (typeof privateKey === "string") {
+      privateKey = new TextEncoder().encode(privateKey);
+    }
+    return await index.getWebcryptoSubtle().importKey(
+      "pkcs8",
+      privateKey,
+      {
+        name: "ECDSA",
+        namedCurve: curve
+      },
+      extractable,
+      ["sign"]
+    );
+  },
+  importPublicKey: async (publicKey, curve, extractable = false) => {
+    if (typeof publicKey === "string") {
+      publicKey = new TextEncoder().encode(publicKey);
+    }
+    return await index.getWebcryptoSubtle().importKey(
+      "spki",
+      publicKey,
+      {
+        name: "ECDSA",
+        namedCurve: curve
+      },
+      extractable,
+      ["verify"]
+    );
+  },
+  sign: async (privateKey, data, hash = "SHA-256") => {
+    if (typeof data === "string") {
+      data = new TextEncoder().encode(data);
+    }
+    const signature = await index.getWebcryptoSubtle().sign(
+      {
+        name: "ECDSA",
+        hash: { name: hash }
+      },
+      privateKey,
+      data
+    );
+    return signature;
+  },
+  verify: async (publicKey, {
+    signature,
+    data,
+    hash = "SHA-256"
+  }) => {
+    if (typeof signature === "string") {
+      signature = new TextEncoder().encode(signature);
+    }
+    if (typeof data === "string") {
+      data = new TextEncoder().encode(data);
+    }
+    return await index.getWebcryptoSubtle().verify(
+      {
+        name: "ECDSA",
+        hash: { name: hash }
+      },
+      publicKey,
+      signature,
+      data
+    );
+  },
+  exportKey: async (key, format) => {
+    return await index.getWebcryptoSubtle().exportKey(format, key);
+  }
+};
+
+exports.ecdsa = ecdsa;

package/template/apps/web/node_modules/@better-auth/utils/dist/ecdsa.d.cts

@@ -0,0 +1,19 @@
+import { a as ECDSACurve, T as TypedArray, S as SHAFamily, b as ExportKeyFormat } from './shared/utils.ecd028f7.cjs';
+
+declare const ecdsa: {
+    generateKeyPair: (curve?: ECDSACurve) => Promise<{
+        privateKey: ArrayBuffer;
+        publicKey: ArrayBuffer;
+    }>;
+    importPrivateKey: (privateKey: ArrayBuffer | TypedArray | string, curve: ECDSACurve, extractable?: boolean) => Promise<CryptoKey>;
+    importPublicKey: (publicKey: ArrayBuffer | TypedArray | string, curve: ECDSACurve, extractable?: boolean) => Promise<CryptoKey>;
+    sign: (privateKey: CryptoKey, data: ArrayBuffer | TypedArray | string, hash?: SHAFamily) => Promise<ArrayBuffer>;
+    verify: (publicKey: CryptoKey, { signature, data, hash, }: {
+        signature: ArrayBuffer | TypedArray | string;
+        data: ArrayBuffer | string;
+        hash?: SHAFamily;
+    }) => Promise<boolean>;
+    exportKey: <E extends ExportKeyFormat>(key: CryptoKey, format: E) => Promise<E extends "jwk" ? JsonWebKey : ArrayBuffer>;
+};
+
+export { ecdsa };

package/template/apps/web/node_modules/@better-auth/utils/dist/ecdsa.d.mts

@@ -0,0 +1,19 @@
+import { a as ECDSACurve, T as TypedArray, S as SHAFamily, b as ExportKeyFormat } from './shared/utils.ecd028f7.mjs';
+
+declare const ecdsa: {
+    generateKeyPair: (curve?: ECDSACurve) => Promise<{
+        privateKey: ArrayBuffer;
+        publicKey: ArrayBuffer;
+    }>;
+    importPrivateKey: (privateKey: ArrayBuffer | TypedArray | string, curve: ECDSACurve, extractable?: boolean) => Promise<CryptoKey>;
+    importPublicKey: (publicKey: ArrayBuffer | TypedArray | string, curve: ECDSACurve, extractable?: boolean) => Promise<CryptoKey>;
+    sign: (privateKey: CryptoKey, data: ArrayBuffer | TypedArray | string, hash?: SHAFamily) => Promise<ArrayBuffer>;
+    verify: (publicKey: CryptoKey, { signature, data, hash, }: {
+        signature: ArrayBuffer | TypedArray | string;
+        data: ArrayBuffer | string;
+        hash?: SHAFamily;
+    }) => Promise<boolean>;
+    exportKey: <E extends ExportKeyFormat>(key: CryptoKey, format: E) => Promise<E extends "jwk" ? JsonWebKey : ArrayBuffer>;
+};
+
+export { ecdsa };

package/template/apps/web/node_modules/@better-auth/utils/dist/ecdsa.d.ts

@@ -0,0 +1,19 @@
+import { a as ECDSACurve, T as TypedArray, S as SHAFamily, b as ExportKeyFormat } from './shared/utils.ecd028f7.js';
+
+declare const ecdsa: {
+    generateKeyPair: (curve?: ECDSACurve) => Promise<{
+        privateKey: ArrayBuffer;
+        publicKey: ArrayBuffer;
+    }>;
+    importPrivateKey: (privateKey: ArrayBuffer | TypedArray | string, curve: ECDSACurve, extractable?: boolean) => Promise<CryptoKey>;
+    importPublicKey: (publicKey: ArrayBuffer | TypedArray | string, curve: ECDSACurve, extractable?: boolean) => Promise<CryptoKey>;
+    sign: (privateKey: CryptoKey, data: ArrayBuffer | TypedArray | string, hash?: SHAFamily) => Promise<ArrayBuffer>;
+    verify: (publicKey: CryptoKey, { signature, data, hash, }: {
+        signature: ArrayBuffer | TypedArray | string;
+        data: ArrayBuffer | string;
+        hash?: SHAFamily;
+    }) => Promise<boolean>;
+    exportKey: <E extends ExportKeyFormat>(key: CryptoKey, format: E) => Promise<E extends "jwk" ? JsonWebKey : ArrayBuffer>;
+};
+
+export { ecdsa };

package/template/apps/web/node_modules/@better-auth/utils/dist/ecdsa.mjs

@@ -0,0 +1,88 @@
+import { getWebcryptoSubtle } from './index.mjs';
+
+const ecdsa = {
+  generateKeyPair: async (curve = "P-256") => {
+    const subtle = getWebcryptoSubtle();
+    const keyPair = await subtle.generateKey(
+      {
+        name: "ECDSA",
+        namedCurve: curve
+      },
+      true,
+      ["sign", "verify"]
+    );
+    const privateKey = await subtle.exportKey("pkcs8", keyPair.privateKey);
+    const publicKey = await subtle.exportKey("spki", keyPair.publicKey);
+    return { privateKey, publicKey };
+  },
+  importPrivateKey: async (privateKey, curve, extractable = false) => {
+    if (typeof privateKey === "string") {
+      privateKey = new TextEncoder().encode(privateKey);
+    }
+    return await getWebcryptoSubtle().importKey(
+      "pkcs8",
+      privateKey,
+      {
+        name: "ECDSA",
+        namedCurve: curve
+      },
+      extractable,
+      ["sign"]
+    );
+  },
+  importPublicKey: async (publicKey, curve, extractable = false) => {
+    if (typeof publicKey === "string") {
+      publicKey = new TextEncoder().encode(publicKey);
+    }
+    return await getWebcryptoSubtle().importKey(
+      "spki",
+      publicKey,
+      {
+        name: "ECDSA",
+        namedCurve: curve
+      },
+      extractable,
+      ["verify"]
+    );
+  },
+  sign: async (privateKey, data, hash = "SHA-256") => {
+    if (typeof data === "string") {
+      data = new TextEncoder().encode(data);
+    }
+    const signature = await getWebcryptoSubtle().sign(
+      {
+        name: "ECDSA",
+        hash: { name: hash }
+      },
+      privateKey,
+      data
+    );
+    return signature;
+  },
+  verify: async (publicKey, {
+    signature,
+    data,
+    hash = "SHA-256"
+  }) => {
+    if (typeof signature === "string") {
+      signature = new TextEncoder().encode(signature);
+    }
+    if (typeof data === "string") {
+      data = new TextEncoder().encode(data);
+    }
+    return await getWebcryptoSubtle().verify(
+      {
+        name: "ECDSA",
+        hash: { name: hash }
+      },
+      publicKey,
+      signature,
+      data
+    );
+  },
+  exportKey: async (key, format) => {
+    return await getWebcryptoSubtle().exportKey(format, key);
+  }
+};
+
+export { ecdsa };

package/template/apps/web/node_modules/@better-auth/utils/dist/hash.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+const base64 = require('./base64.cjs');
+const index = require('./index.cjs');
+
+function createHash(algorithm, encoding) {
+  return {
+    digest: async (input) => {
+      const encoder = new TextEncoder();
+      const data = typeof input === "string" ? encoder.encode(input) : input;
+      const hashBuffer = await index.getWebcryptoSubtle().digest(algorithm, data);
+      if (encoding === "hex") {
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+        return hashHex;
+      }
+      if (encoding === "base64" || encoding === "base64url" || encoding === "base64urlnopad") {
+        if (encoding.includes("url")) {
+          return base64.base64Url.encode(hashBuffer, {
+            padding: encoding !== "base64urlnopad"
+          });
+        }
+        const hashBase64 = base64.base64.encode(hashBuffer);
+        return hashBase64;
+      }
+      return hashBuffer;
+    }
+  };
+}
+
+exports.createHash = createHash;

package/template/apps/web/node_modules/@better-auth/utils/dist/hash.d.cts

@@ -0,0 +1,7 @@
+import { E as EncodingFormat, S as SHAFamily, T as TypedArray } from './shared/utils.ecd028f7.cjs';
+
+declare function createHash<Encoding extends EncodingFormat = "none">(algorithm: SHAFamily, encoding?: Encoding): {
+    digest: (input: string | ArrayBuffer | TypedArray) => Promise<Encoding extends "none" ? ArrayBuffer : string>;
+};
+
+export { createHash };

package/template/apps/web/node_modules/@better-auth/utils/dist/hash.d.mts

@@ -0,0 +1,7 @@
+import { E as EncodingFormat, S as SHAFamily, T as TypedArray } from './shared/utils.ecd028f7.mjs';
+
+declare function createHash<Encoding extends EncodingFormat = "none">(algorithm: SHAFamily, encoding?: Encoding): {
+    digest: (input: string | ArrayBuffer | TypedArray) => Promise<Encoding extends "none" ? ArrayBuffer : string>;
+};
+
+export { createHash };

package/template/apps/web/node_modules/@better-auth/utils/dist/hash.d.ts

@@ -0,0 +1,7 @@
+import { E as EncodingFormat, S as SHAFamily, T as TypedArray } from './shared/utils.ecd028f7.js';
+
+declare function createHash<Encoding extends EncodingFormat = "none">(algorithm: SHAFamily, encoding?: Encoding): {
+    digest: (input: string | ArrayBuffer | TypedArray) => Promise<Encoding extends "none" ? ArrayBuffer : string>;
+};
+
+export { createHash };