effect 4.0.6 → 4.1.0

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":[]}

package/dist/crypto/Kdf.d.ts

@@ -0,0 +1,220 @@
+/**
+ * Key derivation: HKDF, PBKDF2, and Argon2id.
+ *
+ * The {@link Kdf} service derives bytes from a secret with an algorithm value
+ * such as {@link hkdfSha256}, {@link pbkdf2Sha256}, or `argon2id()`. The
+ * output is plain bytes: turn it into a typed key with the target family's raw
+ * constructor, such as `Mac.key`.
+ *
+ * **Gotchas**
+ *
+ * - The secret is bytes, with no string overload. Encode passwords yourself,
+ *   and normalize their Unicode form first if users type them on different
+ *   platforms.
+ * - `layerWebCrypto` does not provide Argon2id, because WebCrypto has no
+ *   Argon2. Deriving with it fails with an `Unsupported` reason, so programs
+ *   can fall back to PBKDF2. `NodeCrypto.layerKdf` provides Argon2id on
+ *   Node.js 24.7 or later and Bun 1.4.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import * as Context from "../Context.ts";
+import * as Effect from "../Effect.ts";
+import * as Layer from "../Layer.ts";
+import * as CryptoError from "./CryptoError.ts";
+import * as Digest from "./Digest.ts";
+/**
+ * HKDF (RFC 5869) with a hash, from {@link hkdf}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface Hkdf {
+    readonly _tag: "Hkdf";
+    readonly name: string;
+    readonly hash: Digest.Algorithm;
+}
+/**
+ * PBKDF2 (RFC 8018) with a hash and an iteration count, from {@link pbkdf2}.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface Pbkdf2 {
+    readonly _tag: "Pbkdf2";
+    readonly name: string;
+    readonly hash: Digest.Algorithm;
+    readonly iterations: number;
+}
+/**
+ * Argon2id (RFC 9106) with its cost parameters, from {@link argon2id}.
+ *
+ * **Details**
+ *
+ * `memory` is in KiB, `passes` is the number of passes over the memory, and
+ * `parallelism` is the number of lanes.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface Argon2id {
+    readonly _tag: "Argon2id";
+    readonly name: string;
+    readonly memory: number;
+    readonly passes: number;
+    readonly parallelism: number;
+}
+/**
+ * A key derivation algorithm.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export type Algorithm = Hkdf | Pbkdf2 | Argon2id;
+/**
+ * Builds the HKDF algorithm for a hash.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export declare const hkdf: (hash: Digest.Algorithm) => Hkdf;
+/**
+ * Builds a PBKDF2 algorithm for a hash and an iteration count.
+ *
+ * **Details**
+ *
+ * Deriving with an iteration count outside 1 to 2^31 - 1 fails with an
+ * `InvalidArgument` reason.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export declare const pbkdf2: (options: {
+    readonly hash: Digest.Algorithm;
+    readonly iterations: number;
+}) => Pbkdf2;
+/**
+ * HKDF with SHA-1.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export declare const hkdfSha1: Hkdf;
+/**
+ * HKDF with SHA-256.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export declare const hkdfSha256: Hkdf;
+/**
+ * HKDF with SHA-384.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export declare const hkdfSha384: Hkdf;
+/**
+ * HKDF with SHA-512.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export declare const hkdfSha512: Hkdf;
+/**
+ * PBKDF2 with SHA-256 at 600,000 iterations, OWASP's current figure.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export declare const pbkdf2Sha256: Pbkdf2;
+/**
+ * Builds an Argon2id algorithm, with `memory` in KiB.
+ *
+ * **Details**
+ *
+ * Omitted costs default to RFC 9106's second recommended setting: 64 MiB of
+ * memory (`65_536`), 3 passes, and 4 lanes.
+ *
+ * **Gotchas**
+ *
+ * `Kdf.layerWebCrypto` does not provide Argon2id. Use `NodeCrypto.layerKdf`,
+ * or fall back to PBKDF2 on the `Unsupported` reason.
+ *
+ * @stability unstable
+ * @category algorithms
+ * @since 4.0.0
+ */
+export declare const argon2id: (options?: {
+    readonly memory?: number | undefined;
+    readonly passes?: number | undefined;
+    readonly parallelism?: number | undefined;
+}) => Argon2id;
+declare const Kdf_base: Context.ServiceClass<Kdf, "effect/crypto/Kdf", {
+    /**
+     * Derives `length` bytes from `secret`.
+     *
+     * `info` only applies to HKDF; passing it with PBKDF2 or Argon2id fails
+     * with an `InvalidArgument` reason.
+     */
+    readonly derive: (algorithm: Algorithm, secret: Uint8Array, options: {
+        readonly salt: Uint8Array;
+        readonly length: number;
+        readonly info?: Uint8Array | undefined;
+    }) => Effect.Effect<Uint8Array, CryptoError.CryptoError>;
+}>;
+/**
+ * Service that derives bytes from a secret.
+ *
+ * **Example** (Deriving a key with HKDF)
+ *
+ * ```ts import.meta.vitest
+ * import { Effect } from "effect"
+ * import { Kdf } from "effect/crypto"
+ *
+ * const program = Effect.gen(function*() {
+ *   const kdf = yield* Kdf.Kdf
+ *   return yield* kdf.derive(Kdf.hkdfSha256, new Uint8Array(32), {
+ *     salt: new Uint8Array(16),
+ *     info: new TextEncoder().encode("encryption"),
+ *     length: 32
+ *   })
+ * })
+ *
+ * const bytes = await Effect.runPromise(program.pipe(Effect.provide(Kdf.layerWebCrypto)))
+ * bytes.length // => 32
+ * ```
+ *
+ * @stability unstable
+ * @category services
+ * @since 4.0.0
+ */
+export declare class Kdf extends Kdf_base {
+}
+/**
+ * Layer that provides `Kdf` on the `WebCrypto` reference.
+ *
+ * **Details**
+ *
+ * HKDF and PBKDF2 run on `crypto.subtle`, off the event loop where the runtime
+ * supports it. Argon2id fails with an `Unsupported` reason.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerWebCrypto: Layer.Layer<Kdf>;
+export {};
+//# sourceMappingURL=Kdf.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Kdf.d.ts","sourceRoot":"","sources":["../../src/crypto/Kdf.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,OAAO,MAAM,eAAe,CAAA;AACxC,OAAO,KAAK,MAAM,MAAM,cAAc,CAAA;AACtC,OAAO,KAAK,KAAK,MAAM,aAAa,CAAA;AACpC,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAC/C,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAIrC;;;;;;GAMG;AACH,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,SAAS,CAAA;CAChC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,SAAS,CAAA;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B;AAED;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,MAAM,GAAG,QAAQ,CAAA;AAEhD;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,SAAU,MAAM,CAAC,SAAS,KAAG,IAAwE,CAAA;AAEtH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM,YAAa;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,SAAS,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAAE,KAAG,MAKjG,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,EAAE,IAAwB,CAAA;AAE/C;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,IAA0B,CAAA;AAEnD;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,IAA0B,CAAA;AAEnD;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,IAA0B,CAAA;AAEnD;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,MAA6D,CAAA;AAExF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,QAAQ,aAAc;IACjC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACpC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC1C,KAAG,QAMF,CAAA;;IA6BA;;;;;OAKG;qBACc,CACf,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE;QACP,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;QACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;QACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,GAAG,SAAS,CAAA;KACvC,KACE,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,WAAW,CAAC,WAAW,CAAC;;AAzCzD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,GAAI,SAAQ,QAgBA;CAAG;AAgD5B;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,CAyB3C,CAAA"}