@sebastienrousseau/crypto-server 0.0.2 → 0.0.8

package/dist/routes/v2/kdf.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modern_1 = require("@sebastienrousseau/crypto-lib/dist/modern");
+const route_helpers_1 = require("../../utils/route-helpers");
+const kdfSchema = {
+    tags: ["Key Derivation"],
+    summary: "Derive a key from a password",
+    description: "Key derivation using scrypt, HKDF-SHA256, or PBKDF2-SHA256.",
+    body: {
+        type: "object",
+        required: ["algorithm", "password"],
+        additionalProperties: false,
+        properties: {
+            algorithm: { type: "string", enum: [...modern_1.KDF_ALGORITHMS] },
+            password: { type: "string", minLength: 1, maxLength: 1024 },
+            salt: { type: "string", maxLength: 128 },
+            keyLength: { type: "number", minimum: 16, maximum: 64 },
+            params: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    N: { type: "integer", minimum: 2, maximum: 131072 },
+                    r: { type: "integer", minimum: 1, maximum: 8 },
+                    p: { type: "integer", minimum: 1, maximum: 4 },
+                    iterations: { type: "integer", minimum: 1, maximum: 1000000 },
+                    info: { type: "string", maxLength: 1024 },
+                },
+            },
+        },
+    },
+};
+exports.default = (app) => {
+    app.post("/v2/kdf", { schema: kdfSchema }, async (request, reply) => {
+        try {
+            const body = request.body;
+            const result = (0, modern_1.kdfDerive)({
+                algorithm: body.algorithm,
+                password: body.password,
+                ...(body.salt ? { salt: body.salt } : {}),
+                ...(body.keyLength ? { keyLength: body.keyLength } : {}),
+                ...(body.params
+                    ? {
+                        params: body.params,
+                    }
+                    : {}),
+            });
+            return reply.send({ data: result });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Key derivation");
+        }
+    });
+};
+//# sourceMappingURL=kdf.js.map

package/dist/routes/v2/key-wrap.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+declare const _default: (app: FastifyInstance) => void;
+export default _default;
+//# sourceMappingURL=key-wrap.d.ts.map

package/dist/routes/v2/key-wrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key-wrap.d.ts","sourceRoot":"","sources":["../../../src/routes/v2/key-wrap.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;yBAI/B,KAAK,eAAe,KAAG,IAAI;AAA3C,wBA8EE"}

package/dist/routes/v2/key-wrap.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const route_helpers_1 = require("../../utils/route-helpers");
+exports.default = (app) => {
+    app.post("/v2/keys/wrap", {
+        schema: {
+            tags: ["Key Wrapping"],
+            summary: "Wrap a key using AES-KW or AES-KWP (RFC 3394/5649)",
+            body: {
+                type: "object",
+                required: ["kek", "keyToWrap"],
+                additionalProperties: false,
+                properties: {
+                    kek: { type: "string", minLength: 1 },
+                    keyToWrap: { type: "string", minLength: 1 },
+                    algorithm: { type: "string", enum: ["aes-kw", "aes-kwp"] },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { aesKwWrap, aesKwpWrap } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/high-level/key-wrap")));
+            const { kek, keyToWrap, algorithm } = request.body;
+            const result = algorithm === "aes-kwp"
+                ? aesKwpWrap(kek, keyToWrap)
+                : aesKwWrap(kek, keyToWrap);
+            return reply.send({ data: result });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Key wrapping");
+        }
+    });
+    app.post("/v2/keys/unwrap", {
+        schema: {
+            tags: ["Key Wrapping"],
+            summary: "Unwrap a key using AES-KW or AES-KWP (RFC 3394/5649)",
+            body: {
+                type: "object",
+                required: ["kek", "wrappedKey"],
+                additionalProperties: false,
+                properties: {
+                    kek: { type: "string", minLength: 1 },
+                    wrappedKey: { type: "string", minLength: 1 },
+                    algorithm: { type: "string", enum: ["aes-kw", "aes-kwp"] },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { aesKwUnwrap, aesKwpUnwrap } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/high-level/key-wrap")));
+            const { kek, wrappedKey, algorithm } = request.body;
+            const result = algorithm === "aes-kwp"
+                ? aesKwpUnwrap(kek, wrappedKey)
+                : aesKwUnwrap(kek, wrappedKey);
+            return reply.send({
+                data: Buffer.from(result).toString("hex"),
+            });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Key unwrapping");
+        }
+    });
+};
+//# sourceMappingURL=key-wrap.js.map

package/dist/routes/v2/keys.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+declare const _default: (app: FastifyInstance) => void;
+export default _default;
+//# sourceMappingURL=keys.d.ts.map

package/dist/routes/v2/keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../../src/routes/v2/keys.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;yBAI/B,KAAK,eAAe,KAAG,IAAI;AAA3C,wBA0DE"}

package/dist/routes/v2/keys.js

@@ -0,0 +1,88 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const route_helpers_1 = require("../../utils/route-helpers");
+exports.default = (app) => {
+    app.post("/v2/keys/generate", {
+        schema: {
+            tags: ["Key Management"],
+            summary: "Generate a key pair for any supported algorithm",
+            body: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    algorithm: {
+                        default: "ed25519",
+                        type: "string",
+                        enum: [
+                            "ed25519",
+                            "x25519",
+                            "ed448",
+                            "x448",
+                            "p256",
+                            "p384",
+                            "ml-kem-512",
+                            "ml-kem-768",
+                            "ml-kem-1024",
+                            "ml-dsa-44",
+                            "ml-dsa-65",
+                            "ml-dsa-87",
+                        ],
+                    },
+                    metadata: {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            kid: { type: "string" },
+                            use: { type: "string", enum: ["sig", "enc"] },
+                            exp: { type: "string" },
+                        },
+                    },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { generateKeyPair } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/keys/keygen")));
+            const { algorithm, metadata } = request.body;
+            const result = generateKeyPair(algorithm, metadata);
+            return reply.send({ data: result });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Key generation");
+        }
+    });
+};
+//# sourceMappingURL=keys.js.map

package/dist/routes/v2/mac.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+declare const _default: (app: FastifyInstance) => void;
+export default _default;
+//# sourceMappingURL=mac.d.ts.map

package/dist/routes/v2/mac.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mac.d.ts","sourceRoot":"","sources":["../../../src/routes/v2/mac.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;yBAQ/B,KAAK,eAAe,KAAG,IAAI;AAA3C,wBAiFE"}

package/dist/routes/v2/mac.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const route_helpers_1 = require("../../utils/route-helpers");
+const HMAC_ALGORITHMS = ["sha256", "sha384", "sha512", "sha3-256", "sha3-512"];
+exports.default = (app) => {
+    app.post("/v2/hmac", {
+        schema: {
+            tags: ["MAC"],
+            summary: "Compute an HMAC",
+            body: {
+                type: "object",
+                required: ["algorithm", "key", "data"],
+                additionalProperties: false,
+                properties: {
+                    algorithm: { type: "string", enum: HMAC_ALGORITHMS },
+                    key: { type: "string", minLength: 1 },
+                    data: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { computeHmac } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/modern/mac")));
+            const body = request.body;
+            const result = computeHmac({
+                algorithm: body.algorithm,
+                key: body.key,
+                data: body.data,
+            });
+            return reply.send({ data: result });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "HMAC computation");
+        }
+    });
+    app.post("/v2/hmac/verify", {
+        schema: {
+            tags: ["MAC"],
+            summary: "Verify an HMAC",
+            body: {
+                type: "object",
+                required: ["algorithm", "key", "data", "mac"],
+                additionalProperties: false,
+                properties: {
+                    algorithm: { type: "string", enum: HMAC_ALGORITHMS },
+                    key: { type: "string", minLength: 1 },
+                    data: { type: "string", minLength: 1 },
+                    mac: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { verifyHmac } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/modern/mac")));
+            const body = request.body;
+            const result = verifyHmac({
+                algorithm: body.algorithm,
+                key: body.key,
+                data: body.data,
+                mac: body.mac,
+            });
+            return reply.send({ data: result });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "HMAC verification");
+        }
+    });
+};
+//# sourceMappingURL=mac.js.map

package/dist/routes/v2/multi-recipient.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+declare const _default: (app: FastifyInstance) => void;
+export default _default;
+//# sourceMappingURL=multi-recipient.d.ts.map

package/dist/routes/v2/multi-recipient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi-recipient.d.ts","sourceRoot":"","sources":["../../../src/routes/v2/multi-recipient.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;yBAI/B,KAAK,eAAe,KAAG,IAAI;AAA3C,wBAgEE"}

package/dist/routes/v2/multi-recipient.js

@@ -0,0 +1,88 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const route_helpers_1 = require("../../utils/route-helpers");
+exports.default = (app) => {
+    app.post("/v2/multi-recipient/encrypt", {
+        schema: {
+            tags: ["Multi-Recipient"],
+            summary: "Encrypt for multiple recipients (hybrid key wrapping)",
+            body: {
+                type: "object",
+                required: ["plaintext", "recipients"],
+                additionalProperties: false,
+                properties: {
+                    plaintext: { type: "string", minLength: 1 },
+                    recipients: {
+                        type: "array",
+                        minItems: 1,
+                        items: {
+                            type: "object",
+                            required: ["type", "publicKey"],
+                            properties: {
+                                type: {
+                                    type: "string",
+                                    enum: ["classical", "pq"],
+                                },
+                                publicKey: { type: "string", minLength: 1 },
+                                mlKemPublicKey: { type: "string" },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { multiEncrypt } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/high-level/multi-recipient")));
+            const { plaintext, recipients } = request.body;
+            const libRecipients = recipients.map((r) => {
+                if (r.type === "classical") {
+                    return { type: "x25519", publicKey: r.publicKey };
+                }
+                return {
+                    type: "x25519-ml-kem-768",
+                    x25519PublicKey: r.publicKey,
+                    mlKemPublicKey: r.mlKemPublicKey,
+                };
+            });
+            return reply.send({ data: multiEncrypt(libRecipients, plaintext) });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Encryption");
+        }
+    });
+};
+//# sourceMappingURL=multi-recipient.js.map

package/dist/routes/v2/password-encrypt.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+declare const _default: (app: FastifyInstance) => void;
+export default _default;
+//# sourceMappingURL=password-encrypt.d.ts.map

package/dist/routes/v2/password-encrypt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"password-encrypt.d.ts","sourceRoot":"","sources":["../../../src/routes/v2/password-encrypt.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;yBAI/B,KAAK,eAAe,KAAG,IAAI;AAA3C,wBAsEE"}

package/dist/routes/v2/password-encrypt.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const route_helpers_1 = require("../../utils/route-helpers");
+exports.default = (app) => {
+    app.post("/v2/password/encrypt", {
+        schema: {
+            tags: ["Password Encryption"],
+            summary: "Encrypt with password (Argon2id + XChaCha20-Poly1305)",
+            body: {
+                type: "object",
+                required: ["password", "plaintext"],
+                additionalProperties: false,
+                properties: {
+                    password: { type: "string", minLength: 1 },
+                    plaintext: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { passwordEncrypt } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/high-level/password-encrypt")));
+            const { password, plaintext } = request.body;
+            return reply.send({
+                data: passwordEncrypt({ password, plaintext }),
+            });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Encryption");
+        }
+    });
+    app.post("/v2/password/decrypt", {
+        schema: {
+            tags: ["Password Encryption"],
+            summary: "Decrypt with password (Argon2id + XChaCha20-Poly1305)",
+            body: {
+                type: "object",
+                required: ["password", "ciphertext"],
+                additionalProperties: false,
+                properties: {
+                    password: { type: "string", minLength: 1 },
+                    ciphertext: { type: "string", minLength: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        try {
+            const { passwordDecrypt } = await Promise.resolve().then(() => __importStar(require("@sebastienrousseau/crypto-lib/dist/high-level/password-encrypt")));
+            const { password, ciphertext } = request.body;
+            const plaintext = passwordDecrypt(password, ciphertext);
+            return reply.send({
+                data: Buffer.from(plaintext).toString("utf8"),
+            });
+        }
+        catch (error) {
+            return (0, route_helpers_1.classifyCryptoError)(error, request, reply, "Decryption");
+        }
+    });
+};
+//# sourceMappingURL=password-encrypt.js.map

package/dist/routes/v2/password.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+declare const _default: (app: FastifyInstance) => void;
+export default _default;
+//# sourceMappingURL=password.d.ts.map

package/dist/routes/v2/password.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"password.d.ts","sourceRoot":"","sources":["../../../src/routes/v2/password.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;yBAI/B,KAAK,eAAe,KAAG,IAAI;AAA3C,wBAiGE"}