effect 4.0.7 → 4.1.1

package/dist/crypto/CryptoError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CryptoError.d.ts","sourceRoot":"","sources":["../../src/crypto/CryptoError.ts"],"names":[],"mappings":"AAsBA,QAAA,MAAM,MAAM,EAAG,4BAAqC,CAAA;AACpD,QAAA,MAAM,YAAY,EAAG,mCAA4C,CAAA;;;;AAEjE;;;;;;;;GAQG;AACH,qBAAa,eAAgB,SAAQ,qBAAoC;IACvE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CACzB,CAAC;IACA;;;;OAIG;IACH,QAAQ,CAAC,CAAC,YAAY,CAAC,sCAAe;IAEtC,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;;;;;;;GAQG;AACH,qBAAa,UAAW,SAAQ,gBAA+B;IAC7D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CACzB,CAAC;IACA;;;;OAIG;IACH,QAAQ,CAAC,CAAC,YAAY,CAAC,sCAAe;IAEtC,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,gBAAiB,SAAQ,sBAAqC,EAAE,CAAC;IAC5E;;;;OAIG;IACH,QAAQ,CAAC,CAAC,YAAY,CAAC,sCAAe;IAEtC,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;;;;;;;GAQG;AACH,qBAAa,WAAY,SAAQ,iBAAgC;IAC/D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CACzB,CAAC;IACA;;;;OAIG;IACH,QAAQ,CAAC,CAAC,YAAY,CAAC,sCAAe;IAEtC,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;;;;;;GAOG;AACH,qBAAa,cAAe,SAAQ,oBAAmC;IACrE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CACzB,CAAC;IACA;;;;OAIG;IACH,QAAQ,CAAC,CAAC,YAAY,CAAC,sCAAe;IAEtC,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;AAED;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG,eAAe,GAAG,UAAU,GAAG,gBAAgB,GAAG,WAAW,GAAG,cAAc,CAAA;;;;AAE9G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAAa,WAAY,SAAQ,iBAAgC;IAC/D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAA;CACnC,CAAC;IACA;;;;OAIG;IACH,QAAQ,CAAC,CAAC,MAAM,CAAC,+BAAS;IAE1B;;;;OAIG;IACH,SAAkB,KAAK,EAAE,OAAO,CAAyD;IAEzF,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;AAED;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,MAAO,OAAO,KAAG,CAAC,IAAI,WAA+C,CAAA;AAE/F;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,MAAO,OAAO,KAAG,CAAC,IAAI,iBAA2D,CAAA"}

package/dist/crypto/CryptoError.js

@@ -0,0 +1,202 @@
+/**
+ * The `CryptoError` returned by the `effect/crypto` modules, and the reasons it
+ * carries.
+ *
+ * Every failure is one `CryptoError` whose `module` and `method` name the
+ * operation, such as `"Aead"` and `"decrypt"`, and whose `reason` says what
+ * went wrong: `InvalidArgument`, `InvalidKey`, `DecryptionFailed`,
+ * `Unsupported`, or `NotExtractable`.
+ *
+ * **Gotchas**
+ *
+ * The error is not serializable, so it cannot be a typed failure in an Rpc or
+ * HttpApi schema. Map it before it reaches a client, for example
+ * `DecryptionFailed` to a 401. Sending crypto failure detail to clients is how
+ * oracles leak.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import * as Data from "../Data.js";
+import * as Predicate from "../Predicate.js";
+const TypeId = "~effect/crypto/CryptoError";
+const ReasonTypeId = "~effect/crypto/CryptoError/Reason";
+/**
+ * Reason for an argument that the operation rejects before using the key or
+ * data, such as a wrong nonce length, an out-of-range iteration count, or
+ * `info` passed to a key derivation other than HKDF.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.0.0
+ */
+export class InvalidArgument extends /*#__PURE__*/Data.TaggedError("InvalidArgument") {
+  /**
+   * Marks this value as a `CryptoError` reason for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ReasonTypeId] = ReasonTypeId;
+  get message() {
+    return this.description;
+  }
+}
+/**
+ * Reason for key material that is rejected, such as a wrong raw key length,
+ * malformed DER, PEM, or JWK data, a `CryptoKey` that does not match the typed
+ * key, or a peer public key that produces an all-zero shared secret.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.0.0
+ */
+export class InvalidKey extends /*#__PURE__*/Data.TaggedError("InvalidKey") {
+  /**
+   * Marks this value as a `CryptoError` reason for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ReasonTypeId] = ReasonTypeId;
+  get message() {
+    return this.description;
+  }
+}
+/**
+ * Reason for a decryption or unwrap that failed its integrity check, or a CBC
+ * ciphertext with bad padding or length.
+ *
+ * **Details**
+ *
+ * The reason is identical for every cause and carries no `cause` or runtime
+ * message, so callers cannot tell a tampered tag from bad padding. Keeping
+ * either would create a padding oracle.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.0.0
+ */
+export class DecryptionFailed extends /*#__PURE__*/Data.TaggedError("DecryptionFailed") {
+  /**
+   * Marks this value as a `CryptoError` reason for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ReasonTypeId] = ReasonTypeId;
+  get message() {
+    return "Could not decrypt the data";
+  }
+}
+/**
+ * Reason for an algorithm or key that a layer does not provide, such as
+ * Argon2id under `Kdf.layerWebCrypto`, or a `CryptoKey`-backed key passed to a
+ * layer that cannot use it.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.0.0
+ */
+export class Unsupported extends /*#__PURE__*/Data.TaggedError("Unsupported") {
+  /**
+   * Marks this value as a `CryptoError` reason for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ReasonTypeId] = ReasonTypeId;
+  get message() {
+    return this.description;
+  }
+}
+/**
+ * Reason for exporting or wrapping a `CryptoKey` that was created as
+ * non-extractable.
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.0.0
+ */
+export class NotExtractable extends /*#__PURE__*/Data.TaggedError("NotExtractable") {
+  /**
+   * Marks this value as a `CryptoError` reason for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ReasonTypeId] = ReasonTypeId;
+  get message() {
+    return this.description;
+  }
+}
+/**
+ * Error returned by the `effect/crypto` modules.
+ *
+ * **When to use**
+ *
+ * Use to handle failures from any `effect/crypto` operation, matching on
+ * `reason` to separate caller mistakes from failed decryption.
+ *
+ * **Details**
+ *
+ * `module` and `method` name the operation, such as `"Aead"` and `"decrypt"`.
+ * The message reads `"Aead.decrypt: <reason message>"`. The error's `cause`
+ * is the reason's `cause`, when it has one.
+ *
+ * **Example** (Recovering from failed decryption)
+ *
+ * ```ts import.meta.vitest
+ * import { Effect } from "effect"
+ * import { CryptoError } from "effect/crypto"
+ *
+ * const decrypt = Effect.fail(
+ *   new CryptoError.CryptoError({
+ *     module: "Aead",
+ *     method: "decrypt",
+ *     reason: new CryptoError.DecryptionFailed()
+ *   })
+ * )
+ *
+ * const program = decrypt.pipe(
+ *   Effect.catchReason("CryptoError", "DecryptionFailed", () => Effect.succeed("rejected"))
+ * )
+ *
+ * await Effect.runPromise(program) // => "rejected"
+ * ```
+ *
+ * @see {@link isCryptoError} for narrowing unknown values
+ *
+ * @stability unstable
+ * @category errors
+ * @since 4.0.0
+ */
+export class CryptoError extends /*#__PURE__*/Data.TaggedError("CryptoError") {
+  /**
+   * Marks this value as a `CryptoError` for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [TypeId] = TypeId;
+  /**
+   * The reason's cause, when it has one.
+   *
+   * @since 4.0.0
+   */
+  cause = "cause" in this.reason ? this.reason.cause : undefined;
+  get message() {
+    return `${this.module}.${this.method}: ${this.reason.message}`;
+  }
+}
+/**
+ * Checks whether a value is a `CryptoError`.
+ *
+ * @stability unstable
+ * @category guards
+ * @since 4.0.0
+ */
+export const isCryptoError = u => Predicate.hasProperty(u, TypeId);
+/**
+ * Checks whether a value is one of the reasons carried by `CryptoError`.
+ *
+ * @stability unstable
+ * @category guards
+ * @since 4.0.0
+ */
+export const isCryptoErrorReason = u => Predicate.hasProperty(u, ReasonTypeId);
+//# sourceMappingURL=CryptoError.js.map

package/dist/crypto/CryptoError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CryptoError.js","names":[],"sources":["../../src/crypto/CryptoError.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;AAmBA,OAAO,KAAK,IAAI,MAAM,YAAY;AAClC,OAAO,KAAK,SAAS,MAAM,iBAAiB;AAE5C,MAAM,MAAM,GAAG,4BAAqC;AACpD,MAAM,YAAY,GAAG,mCAA4C;AAEjE;;;;;;;;;AASA,OAAM,MAAO,eAAgB,sBAAQ,IAAI,CAAC,WAAW,CAAC,iBAAiB,CAGrE;EACA;;;;;EAKS,CAAC,YAAY,IAAI,YAAY;EAEtC,IAAa,OAAO;IAClB,OAAO,IAAI,CAAC,WAAW;EACzB;;AAGF;;;;;;;;;AASA,OAAM,MAAO,UAAW,sBAAQ,IAAI,CAAC,WAAW,CAAC,YAAY,CAG3D;EACA;;;;;EAKS,CAAC,YAAY,IAAI,YAAY;EAEtC,IAAa,OAAO;IAClB,OAAO,IAAI,CAAC,WAAW;EACzB;;AAGF;;;;;;;;;;;;;;AAcA,OAAM,MAAO,gBAAiB,sBAAQ,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAK;EAC5E;;;;;EAKS,CAAC,YAAY,IAAI,YAAY;EAEtC,IAAa,OAAO;IAClB,OAAO,4BAA4B;EACrC;;AAGF;;;;;;;;;AASA,OAAM,MAAO,WAAY,sBAAQ,IAAI,CAAC,WAAW,CAAC,aAAa,CAG7D;EACA;;;;;EAKS,CAAC,YAAY,IAAI,YAAY;EAEtC,IAAa,OAAO;IAClB,OAAO,IAAI,CAAC,WAAW;EACzB;;AAGF;;;;;;;;AAQA,OAAM,MAAO,cAAe,sBAAQ,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAGnE;EACA;;;;;EAKS,CAAC,YAAY,IAAI,YAAY;EAEtC,IAAa,OAAO;IAClB,OAAO,IAAI,CAAC,WAAW;EACzB;;AAYF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,OAAM,MAAO,WAAY,sBAAQ,IAAI,CAAC,WAAW,CAAC,aAAa,CAI7D;EACA;;;;;EAKS,CAAC,MAAM,IAAI,MAAM;EAE1B;;;;;EAKkB,KAAK,GAAY,OAAO,IAAI,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,GAAG,SAAS;EAEzF,IAAa,OAAO;IAClB,OAAO,GAAG,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE;EAChE;;AAGF;;;;;;;AAOA,OAAO,MAAM,aAAa,GAAI,CAAU,IAAuB,SAAS,CAAC,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC;AAE/F;;;;;;;AAOA,OAAO,MAAM,mBAAmB,GAAI,CAAU,IAA6B,SAAS,CAAC,WAAW,CAAC,CAAC,EAAE,YAAY,CAAC","ignoreList":[]}

package/dist/crypto/Digest.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Message digests: MD5, SHA-1, SHA-256, SHA-384, and SHA-512.
+ *
+ * The {@link Digest} service computes digests and lowercase hex strings.
+ * Provide {@link layerWebCrypto} to run it on the `WebCrypto` reference,
+ * or mock the service with `Layer.mock`.
+ *
+ * MD5 runs a pure TypeScript implementation vendored from `@noble/hashes`
+ * 2.4.0, because WebCrypto does not provide it. Whether the `@noble/hashes`
+ * audit covers its MD5 code has not been confirmed. The SHA algorithms run on
+ * `crypto.subtle`.
+ *
+ * Output is stable byte for byte, so digests can be persisted.
+ *
+ * **Gotchas**
+ *
+ * MD5 and SHA-1 are broken for collision resistance. Use them only for
+ * interoperability with existing protocols and checksums.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import * as Context from "../Context.ts";
+import * as Effect from "../Effect.ts";
+import * as Layer from "../Layer.ts";
+/**
+ * A digest algorithm, such as {@link sha256}.
+ *
+ * **Details**
+ *
+ * `name` is the WebCrypto algorithm name. `implementation` is the pure
+ * TypeScript code for algorithms that WebCrypto does not provide, which a
+ * layer calls when it has no native mapping for `name`.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface Algorithm {
+    readonly name: "MD5" | "SHA-1" | "SHA-256" | "SHA-384" | "SHA-512";
+    readonly outputLength: number;
+    readonly implementation: ((data: Uint8Array) => Uint8Array) | undefined;
+}
+/**
+ * MD5 (RFC 1321), with a 16-byte output.
+ *
+ * **Gotchas**
+ *
+ * MD5 is broken for collision resistance. Use it only for interoperability
+ * with existing protocols and checksums.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export declare const md5: Algorithm;
+/**
+ * SHA-1, with a 20-byte output.
+ *
+ * **Gotchas**
+ *
+ * SHA-1 is broken for collision resistance. Use it only for interoperability
+ * with existing protocols.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export declare const sha1: Algorithm;
+/**
+ * SHA-256, with a 32-byte output.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export declare const sha256: Algorithm;
+/**
+ * SHA-384, with a 48-byte output.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export declare const sha384: Algorithm;
+/**
+ * SHA-512, with a 64-byte output.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export declare const sha512: Algorithm;
+declare const Digest_base: Context.ServiceClass<Digest, "effect/crypto/Digest", {
+    /**
+     * Computes the digest of `data`.
+     */
+    readonly digest: (algorithm: Algorithm, data: Uint8Array) => Effect.Effect<Uint8Array>;
+    /**
+     * Computes the digest of `data` as lowercase hex.
+     */
+    readonly digestHex: (algorithm: Algorithm, data: Uint8Array) => Effect.Effect<string>;
+}>;
+/**
+ * Service that computes message digests.
+ *
+ * **Example** (Hashing with SHA-256)
+ *
+ * ```ts import.meta.vitest
+ * import { Effect } from "effect"
+ * import { Digest } from "effect/crypto"
+ *
+ * const program = Effect.gen(function*() {
+ *   const digest = yield* Digest.Digest
+ *   return yield* digest.digestHex(Digest.sha256, new TextEncoder().encode("abc"))
+ * })
+ *
+ * const hex = await Effect.runPromise(program.pipe(Effect.provide(Digest.layerWebCrypto)))
+ * hex.length // => 64
+ * ```
+ *
+ * @stability unstable
+ * @category services
+ * @since 4.0.0
+ */
+export declare class Digest extends Digest_base {
+}
+/**
+ * Layer that provides `Digest` on the `WebCrypto` reference.
+ *
+ * **Details**
+ *
+ * The SHA algorithms run on `crypto.subtle`, and MD5 on the pure TypeScript
+ * implementation. Without `crypto.subtle`, the layer still builds and MD5
+ * keeps working, but SHA digests die.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerWebCrypto: Layer.Layer<Digest>;
+export {};
+//# sourceMappingURL=Digest.d.ts.map

package/dist/crypto/Digest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Digest.d.ts","sourceRoot":"","sources":["../../src/crypto/Digest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,OAAO,MAAM,eAAe,CAAA;AACxC,OAAO,KAAK,MAAM,MAAM,cAAc,CAAA;AAEtC,OAAO,KAAK,KAAK,MAAM,aAAa,CAAA;AAKpC;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,KAAK,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAA;IAClE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,cAAc,EAAE,CAAC,CAAC,IAAI,EAAE,UAAU,KAAK,UAAU,CAAC,GAAG,SAAS,CAAA;CACxE;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,GAAG,EAAE,SAAsE,CAAA;AAExF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,IAAI,EAAE,SAA0E,CAAA;AAE7F;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,EAAE,SAA4E,CAAA;AAEjG;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,EAAE,SAA4E,CAAA;AAEjG;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,EAAE,SAA4E,CAAA;;IAiC/F;;OAEG;qBACc,CAAC,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,KAAK,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC;IACtF;;OAEG;wBACiB,CAAC,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;;AA9BvF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,MAAO,SAAQ,WASA;CAAG;AAE/B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,CAQ9C,CAAA"}

package/dist/crypto/Digest.js

@@ -0,0 +1,146 @@
+/**
+ * Message digests: MD5, SHA-1, SHA-256, SHA-384, and SHA-512.
+ *
+ * The {@link Digest} service computes digests and lowercase hex strings.
+ * Provide {@link layerWebCrypto} to run it on the `WebCrypto` reference,
+ * or mock the service with `Layer.mock`.
+ *
+ * MD5 runs a pure TypeScript implementation vendored from `@noble/hashes`
+ * 2.4.0, because WebCrypto does not provide it. Whether the `@noble/hashes`
+ * audit covers its MD5 code has not been confirmed. The SHA algorithms run on
+ * `crypto.subtle`.
+ *
+ * Output is stable byte for byte, so digests can be persisted.
+ *
+ * **Gotchas**
+ *
+ * MD5 and SHA-1 are broken for collision resistance. Use them only for
+ * interoperability with existing protocols and checksums.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import * as Context from "../Context.js";
+import * as Effect from "../Effect.js";
+import * as Hex from "../encoding/Hex.js";
+import * as Layer from "../Layer.js";
+import { webCryptoDigest } from "./internal/digest.js";
+import * as Md5 from "./internal/md5.js";
+import { WebCrypto } from "./WebCrypto.js";
+/**
+ * MD5 (RFC 1321), with a 16-byte output.
+ *
+ * **Gotchas**
+ *
+ * MD5 is broken for collision resistance. Use it only for interoperability
+ * with existing protocols and checksums.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export const md5 = {
+  name: "MD5",
+  outputLength: 16,
+  implementation: Md5.md5
+};
+/**
+ * SHA-1, with a 20-byte output.
+ *
+ * **Gotchas**
+ *
+ * SHA-1 is broken for collision resistance. Use it only for interoperability
+ * with existing protocols.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export const sha1 = {
+  name: "SHA-1",
+  outputLength: 20,
+  implementation: undefined
+};
+/**
+ * SHA-256, with a 32-byte output.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export const sha256 = {
+  name: "SHA-256",
+  outputLength: 32,
+  implementation: undefined
+};
+/**
+ * SHA-384, with a 48-byte output.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export const sha384 = {
+  name: "SHA-384",
+  outputLength: 48,
+  implementation: undefined
+};
+/**
+ * SHA-512, with a 64-byte output.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export const sha512 = {
+  name: "SHA-512",
+  outputLength: 64,
+  implementation: undefined
+};
+/**
+ * Converts a hash name to an algorithm-name suffix: `"SHA-256"` to `"Sha256"`.
+ *
+ * @internal
+ */
+export const nameSuffix = hash => hash.name.charAt(0) + hash.name.slice(1).toLowerCase().replace("-", "");
+/**
+ * Service that computes message digests.
+ *
+ * **Example** (Hashing with SHA-256)
+ *
+ * ```ts import.meta.vitest
+ * import { Effect } from "effect"
+ * import { Digest } from "effect/crypto"
+ *
+ * const program = Effect.gen(function*() {
+ *   const digest = yield* Digest.Digest
+ *   return yield* digest.digestHex(Digest.sha256, new TextEncoder().encode("abc"))
+ * })
+ *
+ * const hex = await Effect.runPromise(program.pipe(Effect.provide(Digest.layerWebCrypto)))
+ * hex.length // => 64
+ * ```
+ *
+ * @stability unstable
+ * @category services
+ * @since 4.0.0
+ */
+export class Digest extends /*#__PURE__*/Context.Service()("effect/crypto/Digest") {}
+/**
+ * Layer that provides `Digest` on the `WebCrypto` reference.
+ *
+ * **Details**
+ *
+ * The SHA algorithms run on `crypto.subtle`, and MD5 on the pure TypeScript
+ * implementation. Without `crypto.subtle`, the layer still builds and MD5
+ * keeps working, but SHA digests die.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export const layerWebCrypto = /*#__PURE__*/Layer.effect(Digest, /*#__PURE__*/WebCrypto.use(crypto => Effect.succeed({
+  digest: (algorithm, data) => webCryptoDigest(crypto, algorithm, data),
+  digestHex: (algorithm, data) => Effect.map(webCryptoDigest(crypto, algorithm, data), Hex.encode)
+})));
+//# sourceMappingURL=Digest.js.map

package/dist/crypto/Digest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Digest.js","names":[],"sources":["../../src/crypto/Digest.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;AAsBA,OAAO,KAAK,OAAO,MAAM,eAAe;AACxC,OAAO,KAAK,MAAM,MAAM,cAAc;AACtC,OAAO,KAAK,GAAG,MAAM,oBAAoB;AACzC,OAAO,KAAK,KAAK,MAAM,aAAa;AACpC,SAAS,eAAe,QAAQ,sBAAsB;AACtD,OAAO,KAAK,GAAG,MAAM,mBAAmB;AACxC,SAAS,SAAS,QAAQ,gBAAgB;AAqB1C;;;;;;;;;;;;AAYA,OAAO,MAAM,GAAG,GAAc;EAAE,IAAI,EAAE,KAAK;EAAE,YAAY,EAAE,EAAE;EAAE,cAAc,EAAE,GAAG,CAAC;AAAG,CAAE;AAExF;;;;;;;;;;;;AAYA,OAAO,MAAM,IAAI,GAAc;EAAE,IAAI,EAAE,OAAO;EAAE,YAAY,EAAE,EAAE;EAAE,cAAc,EAAE;AAAS,CAAE;AAE7F;;;;;;;AAOA,OAAO,MAAM,MAAM,GAAc;EAAE,IAAI,EAAE,SAAS;EAAE,YAAY,EAAE,EAAE;EAAE,cAAc,EAAE;AAAS,CAAE;AAEjG;;;;;;;AAOA,OAAO,MAAM,MAAM,GAAc;EAAE,IAAI,EAAE,SAAS;EAAE,YAAY,EAAE,EAAE;EAAE,cAAc,EAAE;AAAS,CAAE;AAEjG;;;;;;;AAOA,OAAO,MAAM,MAAM,GAAc;EAAE,IAAI,EAAE,SAAS;EAAE,YAAY,EAAE,EAAE;EAAE,cAAc,EAAE;AAAS,CAAE;AAEjG;;;;;AAKA,OAAO,MAAM,UAAU,GAAI,IAAe,IACxC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;AAsBA,OAAM,MAAO,MAAO,sBAAQ,OAAO,CAAC,OAAO,EASvC,CAAC,sBAAsB,CAAC;AAE5B;;;;;;;;;;;;;AAaA,OAAO,MAAM,cAAc,gBAAwB,KAAK,CAAC,MAAM,CAC7D,MAAM,eACN,SAAS,CAAC,GAAG,CAAE,MAAM,IACnB,MAAM,CAAC,OAAO,CAAC;EACb,MAAM,EAAE,CAAC,SAAS,EAAE,IAAI,KAAK,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC;EACrE,SAAS,EAAE,CAAC,SAAS,EAAE,IAAI,KAAK,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,GAAG,CAAC,MAAM;CAChG,CAAC,CACH,CACF","ignoreList":[]}