@akterjs/cli 0.0.0-stage → 0.1.1

package/dist/Digest-CBd3uv5B.mjs

@@ -0,0 +1,348 @@
+import { $i as encode, $t as suspend, M as fail$1, O as die, Ot as promise, Vn as effect, Xt as succeed, aa as Service, cn as tryPromise, dt as map, en as sync } from "./Effect-CKFpqbmw.mjs";
+import { qt as hasProperty } from "./Option-DkxSnBhp.mjs";
+import { i as TaggedError } from "./Data-CeCULr0-.mjs";
+import { t as WebCrypto } from "./WebCrypto-ZI_GNVlw.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/crypto/CryptoError.js
+/**
+* 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
+*/
+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
+*/
+var InvalidArgument = class extends (/*#__PURE__*/ 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
+*/
+var InvalidKey = class extends (/*#__PURE__*/ 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
+*/
+var DecryptionFailed = class extends (/*#__PURE__*/ 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
+*/
+var Unsupported = class extends (/*#__PURE__*/ 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
+*/
+var NotExtractable = class extends (/*#__PURE__*/ 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
+*/
+var CryptoError = class extends (/*#__PURE__*/ 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 : void 0;
+	get message() {
+		return `${this.module}.${this.method}: ${this.reason.message}`;
+	}
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/crypto/internal/webCrypto.js
+/** @internal */
+const subtleUnavailable = () => /* @__PURE__ */ new Error("crypto.subtle is unavailable; browsers expose it only in secure contexts");
+/** @internal */
+const fail = (module, method, reason) => fail$1(new CryptoError({
+	module,
+	method,
+	reason
+}));
+/** @internal */
+const invalidKey = (module, method, description) => fail(module, method, new InvalidKey({ description }));
+/** @internal */
+const notExtractable = (module, method) => fail(module, method, new NotExtractable({ description: "The CryptoKey is not extractable" }));
+/**
+* Thrown inside {@link run} to fail with a typed reason instead of a defect,
+* for checks that need the imported `CryptoKey`.
+*
+* @internal
+*/
+var Failure = class {
+	reason;
+	constructor(reason) {
+		this.reason = reason;
+	}
+};
+/**
+* Maps an exception thrown by `crypto.subtle` in `module.layerWebCrypto` to a
+* `CryptoError`.
+*
+* A {@link Failure} carries its own reason. `DataError` and
+* `InvalidAccessError` are `InvalidKey`, and `NotSupportedError` is
+* `Unsupported`, naming the algorithm and the layer. An `OperationError`
+* becomes the reason from `onOperationError`, such as `DecryptionFailed` for a
+* decryption. Any other exception is rethrown, which `Effect.tryPromise` turns
+* into a defect.
+*
+* @internal
+*/
+const webCryptoError = (module, method, algorithm, cause, onOperationError) => toCryptoError(module, method, `${module}.layerWebCrypto`, algorithm, cause, onOperationError);
+const toCryptoError = (module, method, provider, algorithm, cause, onOperationError) => {
+	const reason = reasonFor(method, provider, algorithm, cause, onOperationError);
+	if (reason === void 0) throw cause;
+	return new CryptoError({
+		module,
+		method,
+		reason
+	});
+};
+const reasonFor = (method, provider, algorithm, cause, onOperationError) => {
+	if (cause instanceof Failure) return cause.reason;
+	switch (hasProperty(cause, "name") ? cause.name : void 0) {
+		case "DataError": return new InvalidKey({
+			description: "Invalid key data",
+			cause
+		});
+		case "InvalidAccessError": return new InvalidKey({
+			description: `The key cannot be used for ${method}`,
+			cause
+		});
+		case "NotSupportedError": return new Unsupported({
+			description: `${provider} does not provide ${algorithm}`,
+			cause
+		});
+		case "OperationError": return onOperationError?.();
+		default: return;
+	}
+};
+/**
+* Runs `f` on the `subtle` of a `Crypto` object in `module.layerWebCrypto`,
+* dying when it is missing, as in an insecure browser context. Exceptions go
+* through `onError`, which defaults to {@link webCryptoError}.
+*
+* @internal
+*/
+const run = (module, method, algorithm, crypto, f, onError = (cause) => webCryptoError(module, method, algorithm, cause)) => suspend(() => {
+	const subtle = crypto?.subtle;
+	if (subtle === void 0) return die(subtleUnavailable());
+	return tryPromise({
+		try: () => f(subtle),
+		catch: onError
+	});
+});
+/**
+* {@link run} on the `WebCrypto` reference, for the top-level functions that
+* have no layer to read it from. `crypto.subtle` is named as the provider
+* that declined an algorithm.
+*
+* @internal
+*/
+const runWithReference = (module, method, algorithm, f) => WebCrypto.use((crypto) => run(module, method, algorithm, crypto, f, (cause) => toCryptoError(module, method, "crypto.subtle", algorithm, cause)));
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/crypto/internal/digest.js
+/** @internal */
+const webCryptoDigest = (crypto, algorithm, data) => {
+	const implementation = algorithm.implementation;
+	if (implementation !== void 0) return sync(() => implementation(data));
+	return suspend(() => {
+		const subtle = crypto?.subtle;
+		if (subtle === void 0) return die(subtleUnavailable());
+		return promise(async () => new Uint8Array(await subtle.digest(algorithm.name, data)));
+	});
+};
+/**
+* SHA-256, with a 32-byte output.
+*
+* @stability unstable
+* @category algorithms
+* @since 4.0.0
+*/
+const sha256 = {
+	name: "SHA-256",
+	outputLength: 32,
+	implementation: void 0
+};
+/**
+* Converts a hash name to an algorithm-name suffix: `"SHA-256"` to `"Sha256"`.
+*
+* @internal
+*/
+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
+*/
+var Digest = class extends (/*#__PURE__*/ 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
+*/
+const layerWebCrypto = /*#__PURE__*/ effect(Digest, /*#__PURE__*/ WebCrypto.use((crypto) => succeed({
+	digest: (algorithm, data) => webCryptoDigest(crypto, algorithm, data),
+	digestHex: (algorithm, data) => map(webCryptoDigest(crypto, algorithm, data), encode)
+})));
+export { webCryptoDigest as a, notExtractable as c, webCryptoError as d, DecryptionFailed as f, Unsupported as h, sha256 as i, run as l, InvalidKey as m, layerWebCrypto as n, fail as o, InvalidArgument as p, nameSuffix as r, invalidKey as s, Digest as t, runWithReference as u };