@push.rocks/smartsecret 1.0.2 → 1.2.0

package/dist_ts/smartsecret.keyring.js

@@ -0,0 +1,758 @@
+import * as plugins from './smartsecret.plugins.js';
+import { SmartSecretKeyringError, createSmartSecretKeyringError, } from './smartsecret.keyring.error.js';
+import { SMARTSECRET_KEYRING_MAX_CONTEXT_BYTES, SMARTSECRET_KEYRING_MAX_PAYLOAD_BYTES, SMARTSECRET_KEYRING_MIN_CONTEXT_BYTES, SMARTSECRET_KEYRING_PROFILE, SMARTSECRET_KEYRING_SCHEMA_VERSION, createSmartSecretPayloadDigest, createSmartSecretWrapAad, encodeCanonicalBase64Url, fingerprintToBytes, parseSmartSecretEnvelope, requireEpochMilliseconds, requireFingerprint, requireKekVersion, requireSmartSecretIdentifier, sha256Bytes, timingSafeEqual, wipeCiphertext, } from './smartsecret.keyring.protocol.js';
+const descriptorKeys = [
+    'version',
+    'status',
+    'credentialPath',
+    'expectedFingerprint',
+    'createdAt',
+    'activatedAt',
+    'retiredAt',
+    'revokedAt',
+    'escrowReference',
+    'escrowedAt',
+    'recoveryTestedAt',
+];
+const requireConfigObject = (valueArg, allowedKeysArg, requiredKeysArg, errorCodeArg = 'CONFIG_INVALID') => {
+    try {
+        if (valueArg === null || typeof valueArg !== 'object' || Array.isArray(valueArg)) {
+            throw createSmartSecretKeyringError(errorCodeArg);
+        }
+        const prototype = Object.getPrototypeOf(valueArg);
+        if (prototype !== Object.prototype && prototype !== null) {
+            throw createSmartSecretKeyringError(errorCodeArg);
+        }
+        const ownKeys = Reflect.ownKeys(valueArg);
+        if (ownKeys.length < requiredKeysArg.length
+            || ownKeys.length > allowedKeysArg.length
+            || ownKeys.some((keyArg) => typeof keyArg !== 'string')) {
+            throw createSmartSecretKeyringError(errorCodeArg);
+        }
+        const keys = ownKeys;
+        if (keys.some((keyArg) => !allowedKeysArg.includes(keyArg))
+            || requiredKeysArg.some((keyArg) => !keys.includes(keyArg))) {
+            throw createSmartSecretKeyringError(errorCodeArg);
+        }
+        const result = Object.create(null);
+        for (const key of keys) {
+            const descriptor = Object.getOwnPropertyDescriptor(valueArg, key);
+            if (!descriptor?.enumerable || !('value' in descriptor)) {
+                throw createSmartSecretKeyringError(errorCodeArg);
+            }
+            result[key] = descriptor.value;
+        }
+        return result;
+    }
+    catch (error) {
+        if (error instanceof SmartSecretKeyringError) {
+            throw error;
+        }
+        throw createSmartSecretKeyringError(errorCodeArg);
+    }
+};
+const requireDescriptorArray = (valueArg) => {
+    try {
+        if (!Array.isArray(valueArg) || Object.getPrototypeOf(valueArg) !== Array.prototype) {
+            throw createSmartSecretKeyringError('CONFIG_INVALID');
+        }
+        const ownKeys = Reflect.ownKeys(valueArg);
+        const lengthDescriptor = Object.getOwnPropertyDescriptor(valueArg, 'length');
+        if (!lengthDescriptor
+            || !('value' in lengthDescriptor)
+            || !Number.isSafeInteger(lengthDescriptor.value)
+            || lengthDescriptor.value < 0
+            || ownKeys.length !== lengthDescriptor.value + 1) {
+            throw createSmartSecretKeyringError('CONFIG_INVALID');
+        }
+        if (ownKeys.some((keyArg) => typeof keyArg === 'symbol')) {
+            throw createSmartSecretKeyringError('CONFIG_INVALID');
+        }
+        const result = new Array(lengthDescriptor.value);
+        for (let index = 0; index < lengthDescriptor.value; index++) {
+            const descriptor = Object.getOwnPropertyDescriptor(valueArg, String(index));
+            if (!descriptor?.enumerable || !('value' in descriptor)) {
+                throw createSmartSecretKeyringError('CONFIG_INVALID');
+            }
+            result[index] = descriptor.value;
+        }
+        return result;
+    }
+    catch (error) {
+        if (error instanceof SmartSecretKeyringError) {
+            throw error;
+        }
+        throw createSmartSecretKeyringError('CONFIG_INVALID');
+    }
+};
+const requireOptionalTimestamp = (valueArg, keyArg) => {
+    if (!Object.hasOwn(valueArg, keyArg)) {
+        return undefined;
+    }
+    return requireEpochMilliseconds(valueArg[keyArg]);
+};
+const normalizeDescriptor = (valueArg) => {
+    const value = requireConfigObject(valueArg, descriptorKeys, [
+        'version',
+        'status',
+        'createdAt',
+        'activatedAt',
+    ]);
+    const version = requireKekVersion(value.version);
+    if (value.status !== 'active' && value.status !== 'retired' && value.status !== 'revoked') {
+        throw createSmartSecretKeyringError('CONFIG_INVALID');
+    }
+    const status = value.status;
+    const createdAt = requireEpochMilliseconds(value.createdAt);
+    const activatedAt = requireEpochMilliseconds(value.activatedAt);
+    const retiredAt = requireOptionalTimestamp(value, 'retiredAt');
+    const revokedAt = requireOptionalTimestamp(value, 'revokedAt');
+    const escrowedAt = requireOptionalTimestamp(value, 'escrowedAt');
+    const recoveryTestedAt = requireOptionalTimestamp(value, 'recoveryTestedAt');
+    if (createdAt > activatedAt) {
+        throw createSmartSecretKeyringError('CONFIG_INVALID');
+    }
+    if (status === 'active' && (retiredAt !== undefined || revokedAt !== undefined)) {
+        throw createSmartSecretKeyringError('CONFIG_INVALID');
+    }
+    if (status === 'retired' && (retiredAt === undefined || revokedAt !== undefined)) {
+        throw createSmartSecretKeyringError('CONFIG_INVALID');
+    }
+    if (status === 'revoked' && revokedAt === undefined) {
+        throw createSmartSecretKeyringError('CONFIG_INVALID');
+    }
+    if (retiredAt !== undefined && retiredAt < activatedAt) {
+        throw createSmartSecretKeyringError('CONFIG_INVALID');
+    }
+    if (revokedAt !== undefined && revokedAt < (retiredAt ?? activatedAt)) {
+        throw createSmartSecretKeyringError('CONFIG_INVALID');
+    }
+    const hasEscrowReference = Object.hasOwn(value, 'escrowReference');
+    const hasEscrowedAt = escrowedAt !== undefined;
+    if (hasEscrowReference !== hasEscrowedAt) {
+        throw createSmartSecretKeyringError('CONFIG_INVALID');
+    }
+    let escrowReference;
+    if (hasEscrowReference) {
+        escrowReference = requireSmartSecretIdentifier(value.escrowReference);
+    }
+    if (escrowedAt !== undefined && escrowedAt < createdAt) {
+        throw createSmartSecretKeyringError('CONFIG_INVALID');
+    }
+    if (recoveryTestedAt !== undefined) {
+        if (escrowedAt === undefined || recoveryTestedAt < escrowedAt) {
+            throw createSmartSecretKeyringError('CONFIG_INVALID');
+        }
+        if (revokedAt !== undefined && recoveryTestedAt > revokedAt) {
+            throw createSmartSecretKeyringError('CONFIG_INVALID');
+        }
+    }
+    let credentialPath;
+    let expectedFingerprint;
+    if (status === 'revoked') {
+        if (Object.hasOwn(value, 'credentialPath') || Object.hasOwn(value, 'expectedFingerprint')) {
+            throw createSmartSecretKeyringError('CONFIG_INVALID');
+        }
+    }
+    else {
+        if (typeof value.credentialPath !== 'string') {
+            throw createSmartSecretKeyringError('CONFIG_INVALID');
+        }
+        credentialPath = value.credentialPath;
+        if (!plugins.path.isAbsolute(credentialPath)
+            || plugins.path.resolve(credentialPath) !== credentialPath) {
+            throw createSmartSecretKeyringError('CONFIG_INVALID');
+        }
+        expectedFingerprint = requireFingerprint(value.expectedFingerprint);
+    }
+    return Object.freeze({
+        version,
+        status,
+        ...(credentialPath === undefined ? {} : { credentialPath }),
+        ...(expectedFingerprint === undefined ? {} : { expectedFingerprint }),
+        createdAt,
+        activatedAt,
+        ...(retiredAt === undefined ? {} : { retiredAt }),
+        ...(revokedAt === undefined ? {} : { revokedAt }),
+        ...(escrowReference === undefined ? {} : { escrowReference }),
+        ...(escrowedAt === undefined ? {} : { escrowedAt }),
+        ...(recoveryTestedAt === undefined ? {} : { recoveryTestedAt }),
+    });
+};
+const normalizeConfig = (valueArg) => {
+    const value = requireConfigObject(valueArg, ['keyringId', 'keys'], ['keyringId', 'keys']);
+    const keyringId = requireSmartSecretIdentifier(value.keyringId);
+    const descriptorValues = requireDescriptorArray(value.keys);
+    const descriptors = descriptorValues.map((descriptorArg) => normalizeDescriptor(descriptorArg));
+    if (descriptors.length === 0) {
+        throw createSmartSecretKeyringError('CONFIG_INVALID');
+    }
+    for (let index = 1; index < descriptors.length; index++) {
+        if (descriptors[index - 1].version >= descriptors[index].version) {
+            throw createSmartSecretKeyringError('CONFIG_INVALID');
+        }
+    }
+    const active = descriptors.filter((descriptorArg) => descriptorArg.status === 'active');
+    if (active.length !== 1) {
+        throw createSmartSecretKeyringError('CONFIG_INVALID');
+    }
+    return {
+        keyringId,
+        descriptors: Object.freeze(descriptors),
+        activeVersion: active[0].version,
+    };
+};
+const statsMatch = (leftArg, rightArg) => leftArg.dev === rightArg.dev
+    && leftArg.ino === rightArg.ino
+    && leftArg.mode === rightArg.mode
+    && leftArg.nlink === rightArg.nlink
+    && leftArg.uid === rightArg.uid
+    && leftArg.gid === rightArg.gid
+    && leftArg.rdev === rightArg.rdev
+    && leftArg.size === rightArg.size
+    && leftArg.mtimeNs === rightArg.mtimeNs
+    && leftArg.ctimeNs === rightArg.ctimeNs;
+const statsIdentityMatches = (leftArg, rightArg) => leftArg.dev === rightArg.dev
+    && leftArg.ino === rightArg.ino
+    && leftArg.mode === rightArg.mode
+    && leftArg.uid === rightArg.uid
+    && leftArg.gid === rightArg.gid;
+const lstatPathComponents = async (credentialPathArg) => {
+    const root = plugins.path.parse(credentialPathArg).root;
+    const relative = plugins.path.relative(root, credentialPathArg);
+    const components = relative.split(plugins.path.sep).filter(Boolean);
+    const result = [];
+    let currentPath = root;
+    const rootStats = await plugins.fs.promises.lstat(root, { bigint: true });
+    if (rootStats.isSymbolicLink() || !rootStats.isDirectory()) {
+        throw createSmartSecretKeyringError('CREDENTIAL_FILE_INVALID');
+    }
+    result.push({ path: root, stats: rootStats });
+    for (let index = 0; index < components.length; index++) {
+        currentPath = plugins.path.join(currentPath, components[index]);
+        const stats = await plugins.fs.promises.lstat(currentPath, { bigint: true });
+        const isFinal = index === components.length - 1;
+        if (stats.isSymbolicLink()
+            || (isFinal ? !stats.isFile() : !stats.isDirectory())) {
+            throw createSmartSecretKeyringError('CREDENTIAL_FILE_INVALID');
+        }
+        result.push({ path: currentPath, stats });
+    }
+    return result;
+};
+const loadCredential = async (descriptorArg) => {
+    let handle;
+    let key;
+    let readBuffer;
+    let didFail = false;
+    try {
+        const credentialPath = descriptorArg.credentialPath;
+        const beforeComponents = await lstatPathComponents(credentialPath);
+        const beforeFinal = beforeComponents[beforeComponents.length - 1].stats;
+        if (typeof plugins.fs.constants.O_NOFOLLOW !== 'number') {
+            throw createSmartSecretKeyringError('PLATFORM_UNSUPPORTED');
+        }
+        handle = await plugins.fs.promises.open(credentialPath, plugins.fs.constants.O_RDONLY | plugins.fs.constants.O_NOFOLLOW);
+        const beforeFd = await handle.stat({ bigint: true });
+        if (!beforeFd.isFile()
+            || beforeFd.size !== 32n
+            || (beforeFd.mode & 18n) !== 0n
+            || !statsMatch(beforeFinal, beforeFd)) {
+            throw createSmartSecretKeyringError('CREDENTIAL_FILE_INVALID');
+        }
+        readBuffer = Buffer.alloc(33);
+        let totalBytesRead = 0;
+        while (totalBytesRead < readBuffer.byteLength) {
+            const { bytesRead } = await handle.read(readBuffer, totalBytesRead, readBuffer.byteLength - totalBytesRead, totalBytesRead);
+            if (bytesRead === 0) {
+                break;
+            }
+            totalBytesRead += bytesRead;
+        }
+        if (totalBytesRead !== 32) {
+            throw createSmartSecretKeyringError('CREDENTIAL_FILE_INVALID');
+        }
+        const afterFd = await handle.stat({ bigint: true });
+        const afterComponents = await lstatPathComponents(credentialPath);
+        if (beforeComponents.length !== afterComponents.length) {
+            throw createSmartSecretKeyringError('CREDENTIAL_FILE_INVALID');
+        }
+        for (let index = 0; index < beforeComponents.length - 1; index++) {
+            if (!statsIdentityMatches(beforeComponents[index].stats, afterComponents[index].stats)) {
+                throw createSmartSecretKeyringError('CREDENTIAL_FILE_INVALID');
+            }
+        }
+        const afterFinal = afterComponents[afterComponents.length - 1].stats;
+        if (!statsMatch(beforeFd, afterFd) || !statsMatch(afterFd, afterFinal)) {
+            throw createSmartSecretKeyringError('CREDENTIAL_FILE_INVALID');
+        }
+        key = new Uint8Array(readBuffer.subarray(0, 32));
+        const actualFingerprint = sha256Bytes(key);
+        const expectedFingerprint = fingerprintToBytes(descriptorArg.expectedFingerprint);
+        try {
+            if (!timingSafeEqual(actualFingerprint, expectedFingerprint)) {
+                throw createSmartSecretKeyringError('CREDENTIAL_FILE_INVALID');
+            }
+        }
+        finally {
+            actualFingerprint.fill(0);
+            expectedFingerprint.fill(0);
+        }
+    }
+    catch {
+        didFail = true;
+    }
+    finally {
+        readBuffer?.fill(0);
+        if (handle) {
+            try {
+                await handle.close();
+            }
+            catch {
+                didFail = true;
+            }
+        }
+    }
+    if (didFail || !key) {
+        key?.fill(0);
+        throw createSmartSecretKeyringError('CREDENTIAL_FILE_INVALID');
+    }
+    return key;
+};
+const copyBytes = (valueArg, minimumBytesArg, maximumBytesArg) => {
+    if (!(valueArg instanceof Uint8Array)) {
+        throw createSmartSecretKeyringError('INVALID_ARGUMENT');
+    }
+    if (valueArg.byteLength < minimumBytesArg || valueArg.byteLength > maximumBytesArg) {
+        throw createSmartSecretKeyringError('SIZE_LIMIT_EXCEEDED');
+    }
+    return new Uint8Array(valueArg);
+};
+const copyIdentifier = (valueArg) => {
+    try {
+        return requireSmartSecretIdentifier(valueArg);
+    }
+    catch {
+        throw createSmartSecretKeyringError('INVALID_ARGUMENT');
+    }
+};
+const encodeCiphertext = (valueArg) => ({
+    nonce: encodeCanonicalBase64Url(valueArg.nonce),
+    ciphertext: encodeCanonicalBase64Url(valueArg.ciphertext),
+    tag: encodeCanonicalBase64Url(valueArg.tag),
+});
+const wipeParsedEnvelope = (valueArg) => {
+    valueArg.contextDigest.fill(0);
+    valueArg.kekFingerprint.fill(0);
+    wipeCiphertext(valueArg.payload);
+    wipeCiphertext(valueArg.wrappedDek);
+};
+/**
+ * A Linux-only, immutable KEK snapshot for strict DEK/KEK envelopes.
+ * Envelope persistence and compare-and-swap coordination remain consumer responsibilities.
+ */
+export class SmartSecretKeyring {
+    constructor(keyringId, descriptors, activeVersion, loadedKeys) {
+        this.keyringId = keyringId;
+        this.descriptors = descriptors;
+        this.activeVersion = activeVersion;
+        this.loadedKeys = loadedKeys;
+        this.destroyed = false;
+    }
+    static async create(configArg) {
+        if (process.platform !== 'linux') {
+            throw createSmartSecretKeyringError('PLATFORM_UNSUPPORTED');
+        }
+        const config = normalizeConfig(configArg);
+        const loadedKeys = new Map();
+        try {
+            for (const descriptor of config.descriptors) {
+                if (descriptor.status === 'revoked') {
+                    continue;
+                }
+                let key;
+                try {
+                    key = await loadCredential(descriptor);
+                    loadedKeys.set(descriptor.version, { descriptor, key });
+                    key = undefined;
+                }
+                finally {
+                    key?.fill(0);
+                }
+            }
+            return new SmartSecretKeyring(config.keyringId, config.descriptors, config.activeVersion, loadedKeys);
+        }
+        catch (error) {
+            for (const loaded of loadedKeys.values()) {
+                loaded.key.fill(0);
+            }
+            if (error instanceof SmartSecretKeyringError) {
+                throw error;
+            }
+            throw createSmartSecretKeyringError('CREDENTIAL_FILE_INVALID');
+        }
+    }
+    requireAlive() {
+        if (this.destroyed) {
+            throw createSmartSecretKeyringError('DESTROYED');
+        }
+    }
+    requireEnvelopeKey(envelopeArg) {
+        if (envelopeArg.kek.keyringId !== this.keyringId) {
+            throw createSmartSecretKeyringError('KEK_UNAVAILABLE');
+        }
+        const loaded = this.loadedKeys.get(envelopeArg.kek.version);
+        if (!loaded || loaded.descriptor.status === 'revoked') {
+            throw createSmartSecretKeyringError('KEK_UNAVAILABLE');
+        }
+        if (envelopeArg.kek.fingerprint !== loaded.descriptor.expectedFingerprint) {
+            throw createSmartSecretKeyringError('KEK_FINGERPRINT_MISMATCH');
+        }
+        return new Uint8Array(loaded.key);
+    }
+    inspect() {
+        this.requireAlive();
+        return {
+            keyringId: this.keyringId,
+            activeVersion: this.activeVersion,
+            keys: this.descriptors.map((descriptorArg) => ({
+                version: descriptorArg.version,
+                status: descriptorArg.status,
+                ...(descriptorArg.expectedFingerprint === undefined
+                    ? {}
+                    : { expectedFingerprint: descriptorArg.expectedFingerprint }),
+                createdAt: descriptorArg.createdAt,
+                activatedAt: descriptorArg.activatedAt,
+                ...(descriptorArg.retiredAt === undefined ? {} : { retiredAt: descriptorArg.retiredAt }),
+                ...(descriptorArg.revokedAt === undefined ? {} : { revokedAt: descriptorArg.revokedAt }),
+                ...(descriptorArg.escrowReference === undefined
+                    ? {}
+                    : { escrowReference: descriptorArg.escrowReference }),
+                ...(descriptorArg.escrowedAt === undefined ? {} : { escrowedAt: descriptorArg.escrowedAt }),
+                ...(descriptorArg.recoveryTestedAt === undefined
+                    ? {}
+                    : { recoveryTestedAt: descriptorArg.recoveryTestedAt }),
+            })),
+        };
+    }
+    destroy() {
+        if (this.destroyed) {
+            return;
+        }
+        this.destroyed = true;
+        for (const loaded of this.loadedKeys.values()) {
+            loaded.key.fill(0);
+        }
+    }
+    async encryptEnvelope(optionsArg) {
+        this.requireAlive();
+        const options = requireConfigObject(optionsArg, ['envelopeId', 'plaintext', 'context', 'createdAt'], ['envelopeId', 'plaintext', 'context'], 'INVALID_ARGUMENT');
+        const envelopeId = copyIdentifier(options.envelopeId);
+        let createdAt;
+        try {
+            createdAt = options.createdAt === undefined
+                ? Date.now()
+                : requireEpochMilliseconds(options.createdAt);
+        }
+        catch {
+            throw createSmartSecretKeyringError('INVALID_ARGUMENT');
+        }
+        let plaintext;
+        let context;
+        let kek;
+        let kekFingerprint;
+        let contextDigest;
+        let dek;
+        let payload;
+        let wrappedDek;
+        let payloadDigest;
+        let wrapAad;
+        try {
+            plaintext = copyBytes(options.plaintext, 0, SMARTSECRET_KEYRING_MAX_PAYLOAD_BYTES);
+            context = copyBytes(options.context, SMARTSECRET_KEYRING_MIN_CONTEXT_BYTES, SMARTSECRET_KEYRING_MAX_CONTEXT_BYTES);
+            const active = this.loadedKeys.get(this.activeVersion);
+            kek = new Uint8Array(active.key);
+            kekFingerprint = fingerprintToBytes(active.descriptor.expectedFingerprint);
+            contextDigest = sha256Bytes(context);
+            dek = plugins.smartcrypto.generateDek();
+            try {
+                payload = await plugins.smartcrypto.aesGcmEncrypt({
+                    key: dek,
+                    plaintext,
+                    aad: context,
+                });
+                payloadDigest = createSmartSecretPayloadDigest(payload);
+                wrapAad = createSmartSecretWrapAad({
+                    envelopeId,
+                    createdAt,
+                    contextDigest,
+                    payloadDigest,
+                    keyringId: this.keyringId,
+                    kekVersion: active.descriptor.version,
+                    kekFingerprint,
+                });
+                wrappedDek = await plugins.smartcrypto.wrapDek({ dek, kek, wrapAad });
+            }
+            catch (error) {
+                if (error instanceof SmartSecretKeyringError) {
+                    throw error;
+                }
+                throw createSmartSecretKeyringError('CRYPTO_OPERATION_FAILED');
+            }
+            return {
+                schemaVersion: SMARTSECRET_KEYRING_SCHEMA_VERSION,
+                profile: SMARTSECRET_KEYRING_PROFILE,
+                envelopeId,
+                createdAt,
+                contextDigest: encodeCanonicalBase64Url(contextDigest),
+                kek: {
+                    keyringId: this.keyringId,
+                    version: active.descriptor.version,
+                    fingerprint: active.descriptor.expectedFingerprint,
+                },
+                payload: encodeCiphertext(payload),
+                wrappedDek: encodeCiphertext(wrappedDek),
+            };
+        }
+        finally {
+            plaintext?.fill(0);
+            context?.fill(0);
+            contextDigest?.fill(0);
+            dek?.fill(0);
+            kek?.fill(0);
+            kekFingerprint?.fill(0);
+            payloadDigest?.fill(0);
+            wrapAad?.fill(0);
+            wipeCiphertext(payload);
+            wipeCiphertext(wrappedDek);
+        }
+    }
+    async decryptEnvelope(optionsArg) {
+        this.requireAlive();
+        const options = requireConfigObject(optionsArg, ['envelope', 'expectedEnvelopeId', 'context'], ['envelope', 'expectedEnvelopeId', 'context'], 'INVALID_ARGUMENT');
+        const expectedEnvelopeId = copyIdentifier(options.expectedEnvelopeId);
+        const parsed = parseSmartSecretEnvelope(options.envelope);
+        let context;
+        let envelopeKey;
+        let contextDigest;
+        let payloadDigest;
+        let wrapAad;
+        let dek;
+        try {
+            context = copyBytes(options.context, SMARTSECRET_KEYRING_MIN_CONTEXT_BYTES, SMARTSECRET_KEYRING_MAX_CONTEXT_BYTES);
+            envelopeKey = this.requireEnvelopeKey(parsed.envelope);
+            contextDigest = sha256Bytes(context);
+            payloadDigest = createSmartSecretPayloadDigest(parsed.payload);
+            wrapAad = createSmartSecretWrapAad({
+                envelopeId: parsed.envelope.envelopeId,
+                createdAt: parsed.envelope.createdAt,
+                contextDigest: parsed.contextDigest,
+                payloadDigest,
+                keyringId: parsed.envelope.kek.keyringId,
+                kekVersion: parsed.envelope.kek.version,
+                kekFingerprint: parsed.kekFingerprint,
+            });
+            if (parsed.envelope.envelopeId !== expectedEnvelopeId) {
+                throw createSmartSecretKeyringError('ENVELOPE_ID_MISMATCH');
+            }
+            if (!timingSafeEqual(contextDigest, parsed.contextDigest)) {
+                throw createSmartSecretKeyringError('CONTEXT_MISMATCH');
+            }
+            try {
+                dek = await plugins.smartcrypto.unwrapDek({
+                    wrappedDek: parsed.wrappedDek,
+                    kek: envelopeKey,
+                    wrapAad,
+                });
+                return await plugins.smartcrypto.aesGcmDecrypt({
+                    key: dek,
+                    encryptedData: parsed.payload,
+                    aad: context,
+                });
+            }
+            catch {
+                throw createSmartSecretKeyringError('AUTHENTICATION_FAILED');
+            }
+        }
+        finally {
+            context?.fill(0);
+            contextDigest?.fill(0);
+            payloadDigest?.fill(0);
+            wrapAad?.fill(0);
+            envelopeKey?.fill(0);
+            dek?.fill(0);
+            wipeParsedEnvelope(parsed);
+        }
+    }
+    async rewrapEnvelope(optionsArg) {
+        this.requireAlive();
+        const options = requireConfigObject(optionsArg, ['envelope', 'expectedEnvelopeId', 'context', 'targetVersion'], ['envelope', 'expectedEnvelopeId', 'context'], 'INVALID_ARGUMENT');
+        const expectedEnvelopeId = copyIdentifier(options.expectedEnvelopeId);
+        const parsed = parseSmartSecretEnvelope(options.envelope);
+        let context;
+        let currentKey;
+        let targetKey;
+        let targetFingerprint;
+        let contextDigest;
+        let payloadDigest;
+        let currentWrapAad;
+        let newWrapAad;
+        let wrappedDek;
+        try {
+            context = copyBytes(options.context, SMARTSECRET_KEYRING_MIN_CONTEXT_BYTES, SMARTSECRET_KEYRING_MAX_CONTEXT_BYTES);
+            currentKey = this.requireEnvelopeKey(parsed.envelope);
+            if (options.targetVersion !== undefined) {
+                let targetVersion;
+                try {
+                    targetVersion = requireKekVersion(options.targetVersion);
+                }
+                catch {
+                    throw createSmartSecretKeyringError('TARGET_VERSION_MISMATCH');
+                }
+                if (targetVersion !== this.activeVersion) {
+                    throw createSmartSecretKeyringError('TARGET_VERSION_MISMATCH');
+                }
+            }
+            const active = this.loadedKeys.get(this.activeVersion);
+            targetKey = new Uint8Array(active.key);
+            targetFingerprint = fingerprintToBytes(active.descriptor.expectedFingerprint);
+            contextDigest = sha256Bytes(context);
+            payloadDigest = createSmartSecretPayloadDigest(parsed.payload);
+            currentWrapAad = createSmartSecretWrapAad({
+                envelopeId: parsed.envelope.envelopeId,
+                createdAt: parsed.envelope.createdAt,
+                contextDigest: parsed.contextDigest,
+                payloadDigest,
+                keyringId: parsed.envelope.kek.keyringId,
+                kekVersion: parsed.envelope.kek.version,
+                kekFingerprint: parsed.kekFingerprint,
+            });
+            newWrapAad = createSmartSecretWrapAad({
+                envelopeId: parsed.envelope.envelopeId,
+                createdAt: parsed.envelope.createdAt,
+                contextDigest: parsed.contextDigest,
+                payloadDigest,
+                keyringId: this.keyringId,
+                kekVersion: active.descriptor.version,
+                kekFingerprint: targetFingerprint,
+            });
+            if (parsed.envelope.envelopeId !== expectedEnvelopeId) {
+                throw createSmartSecretKeyringError('ENVELOPE_ID_MISMATCH');
+            }
+            if (!timingSafeEqual(contextDigest, parsed.contextDigest)) {
+                throw createSmartSecretKeyringError('CONTEXT_MISMATCH');
+            }
+            try {
+                wrappedDek = await plugins.smartcrypto.rewrapDek({
+                    wrappedDek: parsed.wrappedDek,
+                    currentKek: currentKey,
+                    currentWrapAad,
+                    newKek: targetKey,
+                    newWrapAad,
+                });
+            }
+            catch {
+                throw createSmartSecretKeyringError('AUTHENTICATION_FAILED');
+            }
+            return {
+                schemaVersion: parsed.envelope.schemaVersion,
+                profile: parsed.envelope.profile,
+                envelopeId: parsed.envelope.envelopeId,
+                createdAt: parsed.envelope.createdAt,
+                contextDigest: parsed.envelope.contextDigest,
+                kek: {
+                    keyringId: this.keyringId,
+                    version: active.descriptor.version,
+                    fingerprint: active.descriptor.expectedFingerprint,
+                },
+                payload: { ...parsed.envelope.payload },
+                wrappedDek: encodeCiphertext(wrappedDek),
+            };
+        }
+        finally {
+            context?.fill(0);
+            contextDigest?.fill(0);
+            payloadDigest?.fill(0);
+            currentWrapAad?.fill(0);
+            newWrapAad?.fill(0);
+            currentKey?.fill(0);
+            targetKey?.fill(0);
+            targetFingerprint?.fill(0);
+            wipeCiphertext(wrappedDek);
+            wipeParsedEnvelope(parsed);
+        }
+    }
+    async recoverySelfTest(versionArg) {
+        this.requireAlive();
+        let version;
+        try {
+            version = requireKekVersion(versionArg);
+        }
+        catch {
+            throw createSmartSecretKeyringError('INVALID_ARGUMENT');
+        }
+        const loaded = this.loadedKeys.get(version);
+        if (!loaded || loaded.descriptor.status === 'revoked') {
+            throw createSmartSecretKeyringError('KEK_UNAVAILABLE');
+        }
+        let key;
+        let fingerprint;
+        let dek;
+        let keyringId;
+        let length;
+        let versionBytes;
+        let aad;
+        let wrappedDek;
+        let unwrappedDek;
+        try {
+            key = new Uint8Array(loaded.key);
+            fingerprint = fingerprintToBytes(loaded.descriptor.expectedFingerprint);
+            dek = plugins.smartcrypto.generateDek();
+            keyringId = Buffer.from(this.keyringId, 'utf8');
+            length = Buffer.allocUnsafe(4);
+            length.writeUInt32BE(keyringId.byteLength, 0);
+            versionBytes = Buffer.allocUnsafe(8);
+            versionBytes.writeBigUInt64BE(BigInt(version), 0);
+            aad = Buffer.concat([
+                Buffer.from('smartsecret-keyring-recovery-aad-v1', 'ascii'),
+                length,
+                keyringId,
+                versionBytes,
+                fingerprint,
+            ]);
+            try {
+                wrappedDek = await plugins.smartcrypto.wrapDek({ dek, kek: key, wrapAad: aad });
+                unwrappedDek = await plugins.smartcrypto.unwrapDek({
+                    wrappedDek,
+                    kek: key,
+                    wrapAad: aad,
+                });
+            }
+            catch {
+                throw createSmartSecretKeyringError('CRYPTO_OPERATION_FAILED');
+            }
+            if (!timingSafeEqual(dek, unwrappedDek)) {
+                throw createSmartSecretKeyringError('CRYPTO_OPERATION_FAILED');
+            }
+            return {
+                keyringId: this.keyringId,
+                version,
+                status: loaded.descriptor.status,
+                fingerprint: loaded.descriptor.expectedFingerprint,
+                testedAt: Date.now(),
+            };
+        }
+        finally {
+            key?.fill(0);
+            fingerprint?.fill(0);
+            dek?.fill(0);
+            keyringId?.fill(0);
+            length?.fill(0);
+            versionBytes?.fill(0);
+            aad?.fill(0);
+            wipeCiphertext(wrappedDek);
+            unwrappedDek?.fill(0);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartsecret.keyring.js","sourceRoot":"","sources":["../ts/smartsecret.keyring.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,0BAA0B,CAAC;AACpD,OAAO,EACL,uBAAuB,EACvB,6BAA6B,GAC9B,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,qCAAqC,EACrC,qCAAqC,EACrC,qCAAqC,EACrC,2BAA2B,EAC3B,kCAAkC,EAClC,8BAA8B,EAC9B,wBAAwB,EACxB,wBAAwB,EACxB,kBAAkB,EAClB,wBAAwB,EACxB,wBAAwB,EACxB,kBAAkB,EAClB,iBAAiB,EACjB,4BAA4B,EAC5B,WAAW,EACX,eAAe,EACf,cAAc,GAGf,MAAM,mCAAmC,CAAC;AAkF3C,MAAM,cAAc,GAAG;IACrB,SAAS;IACT,QAAQ;IACR,gBAAgB;IAChB,qBAAqB;IACrB,WAAW;IACX,aAAa;IACb,WAAW;IACX,WAAW;IACX,iBAAiB;IACjB,YAAY;IACZ,kBAAkB;CACV,CAAC;AAEX,MAAM,mBAAmB,GAAG,CAC1B,QAAiB,EACjB,cAAiC,EACjC,eAAkC,EAClC,eAAsD,gBAAgB,EAC7C,EAAE;IAC3B,IAAI,CAAC;QACH,IAAI,QAAQ,KAAK,IAAI,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YACjF,MAAM,6BAA6B,CAAC,YAAY,CAAC,CAAC;QACpD,CAAC;QACD,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;QAClD,IAAI,SAAS,KAAK,MAAM,CAAC,SAAS,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;YACzD,MAAM,6BAA6B,CAAC,YAAY,CAAC,CAAC;QACpD,CAAC;QACD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC1C,IACE,OAAO,CAAC,MAAM,GAAG,eAAe,CAAC,MAAM;eACpC,OAAO,CAAC,MAAM,GAAG,cAAc,CAAC,MAAM;eACtC,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,OAAO,MAAM,KAAK,QAAQ,CAAC,EACvD,CAAC;YACD,MAAM,6BAA6B,CAAC,YAAY,CAAC,CAAC;QACpD,CAAC;QACD,MAAM,IAAI,GAAG,OAAmB,CAAC;QACjC,IACE,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;eACpD,eAAe,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAC3D,CAAC;YACD,MAAM,6BAA6B,CAAC,YAAY,CAAC,CAAC;QACpD,CAAC;QACD,MAAM,MAAM,GAA4B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC5D,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;YAClE,IAAI,CAAC,UAAU,EAAE,UAAU,IAAI,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC,EAAE,CAAC;gBACxD,MAAM,6BAA6B,CAAC,YAAY,CAAC,CAAC;YACpD,CAAC;YACD,MAAM,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC;QACjC,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,uBAAuB,EAAE,CAAC;YAC7C,MAAM,KAAK,CAAC;QACd,CAAC;QACD,MAAM,6BAA6B,CAAC,YAAY,CAAC,CAAC;IACpD,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,sBAAsB,GAAG,CAAC,QAAiB,EAAsB,EAAE;IACvE,IAAI,CAAC;QACH,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,KAAK,CAAC,SAAS,EAAE,CAAC;YACpF,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;QACxD,CAAC;QACD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC1C,MAAM,gBAAgB,GAAG,MAAM,CAAC,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAC7E,IACE,CAAC,gBAAgB;eACd,CAAC,CAAC,OAAO,IAAI,gBAAgB,CAAC;eAC9B,CAAC,MAAM,CAAC,aAAa,CAAC,gBAAgB,CAAC,KAAK,CAAC;eAC7C,gBAAgB,CAAC,KAAK,GAAG,CAAC;eAC1B,OAAO,CAAC,MAAM,KAAK,gBAAgB,CAAC,KAAK,GAAG,CAAC,EAChD,CAAC;YACD,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;QACxD,CAAC;QACD,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,OAAO,MAAM,KAAK,QAAQ,CAAC,EAAE,CAAC;YACzD,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;QACxD,CAAC;QACD,MAAM,MAAM,GAAG,IAAI,KAAK,CAAU,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAC1D,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC;YAC5D,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YAC5E,IAAI,CAAC,UAAU,EAAE,UAAU,IAAI,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC,EAAE,CAAC;gBACxD,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;YACxD,CAAC;YACD,MAAM,CAAC,KAAK,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC;QACnC,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,uBAAuB,EAAE,CAAC;YAC7C,MAAM,KAAK,CAAC;QACd,CAAC;QACD,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;IACxD,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,wBAAwB,GAAG,CAC/B,QAAiC,EACjC,MAAc,EACM,EAAE;IACtB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,CAAC;QACrC,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,wBAAwB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;AACpD,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAG,CAAC,QAAiB,EAAuC,EAAE;IACrF,MAAM,KAAK,GAAG,mBAAmB,CAAC,QAAQ,EAAE,cAAc,EAAE;QAC1D,SAAS;QACT,QAAQ;QACR,WAAW;QACX,aAAa;KACd,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,iBAAiB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACjD,IAAI,KAAK,CAAC,MAAM,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAC1F,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;IACxD,CAAC;IACD,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;IAC5B,MAAM,SAAS,GAAG,wBAAwB,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAC5D,MAAM,WAAW,GAAG,wBAAwB,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;IAChE,MAAM,SAAS,GAAG,wBAAwB,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IAC/D,MAAM,SAAS,GAAG,wBAAwB,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IAC/D,MAAM,UAAU,GAAG,wBAAwB,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IACjE,MAAM,gBAAgB,GAAG,wBAAwB,CAAC,KAAK,EAAE,kBAAkB,CAAC,CAAC;IAC7E,IAAI,SAAS,GAAG,WAAW,EAAE,CAAC;QAC5B,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;IACxD,CAAC;IAED,IAAI,MAAM,KAAK,QAAQ,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI,SAAS,KAAK,SAAS,CAAC,EAAE,CAAC;QAChF,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;IACxD,CAAC;IACD,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI,SAAS,KAAK,SAAS,CAAC,EAAE,CAAC;QACjF,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;IACxD,CAAC;IACD,IAAI,MAAM,KAAK,SAAS,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QACpD,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;IACxD,CAAC;IACD,IAAI,SAAS,KAAK,SAAS,IAAI,SAAS,GAAG,WAAW,EAAE,CAAC;QACvD,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;IACxD,CAAC;IACD,IAAI,SAAS,KAAK,SAAS,IAAI,SAAS,GAAG,CAAC,SAAS,IAAI,WAAW,CAAC,EAAE,CAAC;QACtE,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;IACxD,CAAC;IAED,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;IACnE,MAAM,aAAa,GAAG,UAAU,KAAK,SAAS,CAAC;IAC/C,IAAI,kBAAkB,KAAK,aAAa,EAAE,CAAC;QACzC,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;IACxD,CAAC;IACD,IAAI,eAAmC,CAAC;IACxC,IAAI,kBAAkB,EAAE,CAAC;QACvB,eAAe,GAAG,4BAA4B,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;IACxE,CAAC;IACD,IAAI,UAAU,KAAK,SAAS,IAAI,UAAU,GAAG,SAAS,EAAE,CAAC;QACvD,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;IACxD,CAAC;IACD,IAAI,gBAAgB,KAAK,SAAS,EAAE,CAAC;QACnC,IAAI,UAAU,KAAK,SAAS,IAAI,gBAAgB,GAAG,UAAU,EAAE,CAAC;YAC9D,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;QACxD,CAAC;QACD,IAAI,SAAS,KAAK,SAAS,IAAI,gBAAgB,GAAG,SAAS,EAAE,CAAC;YAC5D,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;IAED,IAAI,cAAkC,CAAC;IACvC,IAAI,mBAAmD,CAAC;IACxD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,gBAAgB,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,qBAAqB,CAAC,EAAE,CAAC;YAC1F,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;SAAM,CAAC;QACN,IAAI,OAAO,KAAK,CAAC,cAAc,KAAK,QAAQ,EAAE,CAAC;YAC7C,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;QACxD,CAAC;QACD,cAAc,GAAG,KAAK,CAAC,cAAc,CAAC;QACtC,IACE,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC;eACrC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,KAAK,cAAc,EAC1D,CAAC;YACD,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;QACxD,CAAC;QACD,mBAAmB,GAAG,kBAAkB,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,OAAO;QACP,MAAM;QACN,GAAG,CAAC,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC;QAC3D,GAAG,CAAC,mBAAmB,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,mBAAmB,EAAE,CAAC;QACrE,SAAS;QACT,WAAW;QACX,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC;QACjD,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC;QACjD,GAAG,CAAC,eAAe,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC;QAC7D,GAAG,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC;QACnD,GAAG,CAAC,gBAAgB,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,CAAC;KAChE,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,eAAe,GAAG,CAAC,QAAiB,EAIxC,EAAE;IACF,MAAM,KAAK,GAAG,mBAAmB,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC;IAC1F,MAAM,SAAS,GAAG,4BAA4B,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAChE,MAAM,gBAAgB,GAAG,sBAAsB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC5D,MAAM,WAAW,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAC,CAAC;IAChG,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;IACxD,CAAC;IACD,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACxD,IAAI,WAAW,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,OAAO,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC;YACjE,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;IACD,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,aAAa,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC;IACxF,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,MAAM,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;IACxD,CAAC;IACD,OAAO;QACL,SAAS;QACT,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC;QACvC,aAAa,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO;KACjC,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,UAAU,GAAG,CAAC,OAAqB,EAAE,QAAsB,EAAW,EAAE,CAC5E,OAAO,CAAC,GAAG,KAAK,QAAQ,CAAC,GAAG;OACzB,OAAO,CAAC,GAAG,KAAK,QAAQ,CAAC,GAAG;OAC5B,OAAO,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI;OAC9B,OAAO,CAAC,KAAK,KAAK,QAAQ,CAAC,KAAK;OAChC,OAAO,CAAC,GAAG,KAAK,QAAQ,CAAC,GAAG;OAC5B,OAAO,CAAC,GAAG,KAAK,QAAQ,CAAC,GAAG;OAC5B,OAAO,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI;OAC9B,OAAO,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI;OAC9B,OAAO,CAAC,OAAO,KAAK,QAAQ,CAAC,OAAO;OACpC,OAAO,CAAC,OAAO,KAAK,QAAQ,CAAC,OAAO,CAAC;AAE1C,MAAM,oBAAoB,GAAG,CAAC,OAAqB,EAAE,QAAsB,EAAW,EAAE,CACtF,OAAO,CAAC,GAAG,KAAK,QAAQ,CAAC,GAAG;OACzB,OAAO,CAAC,GAAG,KAAK,QAAQ,CAAC,GAAG;OAC5B,OAAO,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI;OAC9B,OAAO,CAAC,GAAG,KAAK,QAAQ,CAAC,GAAG;OAC5B,OAAO,CAAC,GAAG,KAAK,QAAQ,CAAC,GAAG,CAAC;AAElC,MAAM,mBAAmB,GAAG,KAAK,EAC/B,iBAAyB,EAC8B,EAAE;IACzD,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,IAAI,CAAC;IACxD,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC;IAChE,MAAM,UAAU,GAAG,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACpE,MAAM,MAAM,GAAiD,EAAE,CAAC;IAChE,IAAI,WAAW,GAAG,IAAI,CAAC;IACvB,MAAM,SAAS,GAAG,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1E,IAAI,SAAS,CAAC,cAAc,EAAE,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,EAAE,CAAC;QAC3D,MAAM,6BAA6B,CAAC,yBAAyB,CAAC,CAAC;IACjE,CAAC;IACD,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;IAC9C,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACvD,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC;QAChE,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;QAC7E,MAAM,OAAO,GAAG,KAAK,KAAK,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC;QAChD,IACE,KAAK,CAAC,cAAc,EAAE;eACnB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,EACrD,CAAC;YACD,MAAM,6BAA6B,CAAC,yBAAyB,CAAC,CAAC;QACjE,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC;IAC5C,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,cAAc,GAAG,KAAK,EAC1B,aAAkD,EAC7B,EAAE;IACvB,IAAI,MAAkD,CAAC;IACvD,IAAI,GAA2B,CAAC;IAChC,IAAI,UAA8B,CAAC;IACnC,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,IAAI,CAAC;QACH,MAAM,cAAc,GAAG,aAAa,CAAC,cAAe,CAAC;QACrD,MAAM,gBAAgB,GAAG,MAAM,mBAAmB,CAAC,cAAc,CAAC,CAAC;QACnE,MAAM,WAAW,GAAG,gBAAgB,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;QACxE,IAAI,OAAO,OAAO,CAAC,EAAE,CAAC,SAAS,CAAC,UAAU,KAAK,QAAQ,EAAE,CAAC;YACxD,MAAM,6BAA6B,CAAC,sBAAsB,CAAC,CAAC;QAC9D,CAAC;QACD,MAAM,GAAG,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CACrC,cAAc,EACd,OAAO,CAAC,EAAE,CAAC,SAAS,CAAC,QAAQ,GAAG,OAAO,CAAC,EAAE,CAAC,SAAS,CAAC,UAAU,CAChE,CAAC;QACF,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;QACrD,IACE,CAAC,QAAQ,CAAC,MAAM,EAAE;eACf,QAAQ,CAAC,IAAI,KAAK,GAAG;eACrB,CAAC,QAAQ,CAAC,IAAI,GAAG,GAAM,CAAC,KAAK,EAAE;eAC/B,CAAC,UAAU,CAAC,WAAW,EAAE,QAAQ,CAAC,EACrC,CAAC;YACD,MAAM,6BAA6B,CAAC,yBAAyB,CAAC,CAAC;QACjE,CAAC;QAED,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAC9B,IAAI,cAAc,GAAG,CAAC,CAAC;QACvB,OAAO,cAAc,GAAG,UAAU,CAAC,UAAU,EAAE,CAAC;YAC9C,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,MAAM,CAAC,IAAI,CACrC,UAAU,EACV,cAAc,EACd,UAAU,CAAC,UAAU,GAAG,cAAc,EACtC,cAAc,CACf,CAAC;YACF,IAAI,SAAS,KAAK,CAAC,EAAE,CAAC;gBACpB,MAAM;YACR,CAAC;YACD,cAAc,IAAI,SAAS,CAAC;QAC9B,CAAC;QACD,IAAI,cAAc,KAAK,EAAE,EAAE,CAAC;YAC1B,MAAM,6BAA6B,CAAC,yBAAyB,CAAC,CAAC;QACjE,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;QACpD,MAAM,eAAe,GAAG,MAAM,mBAAmB,CAAC,cAAc,CAAC,CAAC;QAClE,IAAI,gBAAgB,CAAC,MAAM,KAAK,eAAe,CAAC,MAAM,EAAE,CAAC;YACvD,MAAM,6BAA6B,CAAC,yBAAyB,CAAC,CAAC;QACjE,CAAC;QACD,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;YACjE,IAAI,CAAC,oBAAoB,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;gBACvF,MAAM,6BAA6B,CAAC,yBAAyB,CAAC,CAAC;YACjE,CAAC;QACH,CAAC;QACD,MAAM,UAAU,GAAG,eAAe,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;QACrE,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,UAAU,CAAC,EAAE,CAAC;YACvE,MAAM,6BAA6B,CAAC,yBAAyB,CAAC,CAAC;QACjE,CAAC;QAED,GAAG,GAAG,IAAI,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;QACjD,MAAM,iBAAiB,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;QAC3C,MAAM,mBAAmB,GAAG,kBAAkB,CAAC,aAAa,CAAC,mBAAoB,CAAC,CAAC;QACnF,IAAI,CAAC;YACH,IAAI,CAAC,eAAe,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,EAAE,CAAC;gBAC7D,MAAM,6BAA6B,CAAC,yBAAyB,CAAC,CAAC;YACjE,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAC1B,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,GAAG,IAAI,CAAC;IACjB,CAAC;YAAS,CAAC;QACT,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;QACpB,IAAI,MAAM,EAAE,CAAC;YACX,IAAI,CAAC;gBACH,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;YACvB,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,GAAG,IAAI,CAAC;YACjB,CAAC;QACH,CAAC;IACH,CAAC;IACD,IAAI,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC;QACpB,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;QACb,MAAM,6BAA6B,CAAC,yBAAyB,CAAC,CAAC;IACjE,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC,CAAC;AAEF,MAAM,SAAS,GAAG,CAChB,QAAiB,EACjB,eAAuB,EACvB,eAAuB,EACX,EAAE;IACd,IAAI,CAAC,CAAC,QAAQ,YAAY,UAAU,CAAC,EAAE,CAAC;QACtC,MAAM,6BAA6B,CAAC,kBAAkB,CAAC,CAAC;IAC1D,CAAC;IACD,IAAI,QAAQ,CAAC,UAAU,GAAG,eAAe,IAAI,QAAQ,CAAC,UAAU,GAAG,eAAe,EAAE,CAAC;QACnF,MAAM,6BAA6B,CAAC,qBAAqB,CAAC,CAAC;IAC7D,CAAC;IACD,OAAO,IAAI,UAAU,CAAC,QAAQ,CAAC,CAAC;AAClC,CAAC,CAAC;AAEF,MAAM,cAAc,GAAG,CAAC,QAAiB,EAAU,EAAE;IACnD,IAAI,CAAC;QACH,OAAO,4BAA4B,CAAC,QAAQ,CAAC,CAAC;IAChD,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,6BAA6B,CAAC,kBAAkB,CAAC,CAAC;IAC1D,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,gBAAgB,GAAG,CACvB,QAA+C,EACK,EAAE,CAAC,CAAC;IACxD,KAAK,EAAE,wBAAwB,CAAC,QAAQ,CAAC,KAAK,CAAC;IAC/C,UAAU,EAAE,wBAAwB,CAAC,QAAQ,CAAC,UAAU,CAAC;IACzD,GAAG,EAAE,wBAAwB,CAAC,QAAQ,CAAC,GAAG,CAAC;CAC5C,CAAC,CAAC;AAEH,MAAM,kBAAkB,GAAG,CAAC,QAAsC,EAAQ,EAAE;IAC1E,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC/B,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAChC,cAAc,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IACjC,cAAc,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AACtC,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,OAAO,kBAAkB;IAG7B,YACmB,SAAiB,EACjB,WAA2D,EAC3D,aAAqB,EACrB,UAAsD;QAHtD,cAAS,GAAT,SAAS,CAAQ;QACjB,gBAAW,GAAX,WAAW,CAAgD;QAC3D,kBAAa,GAAb,aAAa,CAAQ;QACrB,eAAU,GAAV,UAAU,CAA4C;QANjE,cAAS,GAAG,KAAK,CAAC;IAOvB,CAAC;IAEG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,SAAoC;QAC7D,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;YACjC,MAAM,6BAA6B,CAAC,sBAAsB,CAAC,CAAC;QAC9D,CAAC;QACD,MAAM,MAAM,GAAG,eAAe,CAAC,SAAS,CAAC,CAAC;QAC1C,MAAM,UAAU,GAAG,IAAI,GAAG,EAAiC,CAAC;QAC5D,IAAI,CAAC;YACH,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,WAAW,EAAE,CAAC;gBAC5C,IAAI,UAAU,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;oBACpC,SAAS;gBACX,CAAC;gBACD,IAAI,GAA2B,CAAC;gBAChC,IAAI,CAAC;oBACH,GAAG,GAAG,MAAM,cAAc,CAAC,UAAU,CAAC,CAAC;oBACvC,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,UAAU,EAAE,GAAG,EAAE,CAAC,CAAC;oBACxD,GAAG,GAAG,SAAS,CAAC;gBAClB,CAAC;wBAAS,CAAC;oBACT,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;gBACf,CAAC;YACH,CAAC;YACD,OAAO,IAAI,kBAAkB,CAC3B,MAAM,CAAC,SAAS,EAChB,MAAM,CAAC,WAAW,EAClB,MAAM,CAAC,aAAa,EACpB,UAAU,CACX,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,KAAK,MAAM,MAAM,IAAI,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC;gBACzC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACrB,CAAC;YACD,IAAI,KAAK,YAAY,uBAAuB,EAAE,CAAC;gBAC7C,MAAM,KAAK,CAAC;YACd,CAAC;YACD,MAAM,6BAA6B,CAAC,yBAAyB,CAAC,CAAC;QACjE,CAAC;IACH,CAAC;IAEO,YAAY;QAClB,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,MAAM,6BAA6B,CAAC,WAAW,CAAC,CAAC;QACnD,CAAC;IACH,CAAC;IAEO,kBAAkB,CACxB,WAAmC;QAEnC,IAAI,WAAW,CAAC,GAAG,CAAC,SAAS,KAAK,IAAI,CAAC,SAAS,EAAE,CAAC;YACjD,MAAM,6BAA6B,CAAC,iBAAiB,CAAC,CAAC;QACzD,CAAC;QACD,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC5D,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,UAAU,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YACtD,MAAM,6BAA6B,CAAC,iBAAiB,CAAC,CAAC;QACzD,CAAC;QACD,IAAI,WAAW,CAAC,GAAG,CAAC,WAAW,KAAK,MAAM,CAAC,UAAU,CAAC,mBAAmB,EAAE,CAAC;YAC1E,MAAM,6BAA6B,CAAC,0BAA0B,CAAC,CAAC;QAClE,CAAC;QACD,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACpC,CAAC;IAEM,OAAO;QACZ,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,OAAO;YACL,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC;gBAC7C,OAAO,EAAE,aAAa,CAAC,OAAO;gBAC9B,MAAM,EAAE,aAAa,CAAC,MAAM;gBAC5B,GAAG,CAAC,aAAa,CAAC,mBAAmB,KAAK,SAAS;oBACjD,CAAC,CAAC,EAAE;oBACJ,CAAC,CAAC,EAAE,mBAAmB,EAAE,aAAa,CAAC,mBAAmB,EAAE,CAAC;gBAC/D,SAAS,EAAE,aAAa,CAAC,SAAS;gBAClC,WAAW,EAAE,aAAa,CAAC,WAAW;gBACtC,GAAG,CAAC,aAAa,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,aAAa,CAAC,SAAS,EAAE,CAAC;gBACxF,GAAG,CAAC,aAAa,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,aAAa,CAAC,SAAS,EAAE,CAAC;gBACxF,GAAG,CAAC,aAAa,CAAC,eAAe,KAAK,SAAS;oBAC7C,CAAC,CAAC,EAAE;oBACJ,CAAC,CAAC,EAAE,eAAe,EAAE,aAAa,CAAC,eAAe,EAAE,CAAC;gBACvD,GAAG,CAAC,aAAa,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,aAAa,CAAC,UAAU,EAAE,CAAC;gBAC3F,GAAG,CAAC,aAAa,CAAC,gBAAgB,KAAK,SAAS;oBAC9C,CAAC,CAAC,EAAE;oBACJ,CAAC,CAAC,EAAE,gBAAgB,EAAE,aAAa,CAAC,gBAAgB,EAAE,CAAC;aAC1D,CAAC,CAAC;SACJ,CAAC;IACJ,CAAC;IAEM,OAAO;QACZ,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC;YAC9C,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,eAAe,CAC1B,UAA8C;QAE9C,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,MAAM,OAAO,GAAG,mBAAmB,CACjC,UAAU,EACV,CAAC,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,CAAC,EACnD,CAAC,YAAY,EAAE,WAAW,EAAE,SAAS,CAAC,EACtC,kBAAkB,CACnB,CAAC;QACF,MAAM,UAAU,GAAG,cAAc,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QACtD,IAAI,SAAiB,CAAC;QACtB,IAAI,CAAC;YACH,SAAS,GAAG,OAAO,CAAC,SAAS,KAAK,SAAS;gBACzC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;gBACZ,CAAC,CAAC,wBAAwB,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAClD,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,6BAA6B,CAAC,kBAAkB,CAAC,CAAC;QAC1D,CAAC;QACD,IAAI,SAAiC,CAAC;QACtC,IAAI,OAA+B,CAAC;QACpC,IAAI,GAA2B,CAAC;QAChC,IAAI,cAAsC,CAAC;QAC3C,IAAI,aAAqC,CAAC;QAC1C,IAAI,GAA2B,CAAC;QAChC,IAAI,OAA0D,CAAC;QAC/D,IAAI,UAA6D,CAAC;QAClE,IAAI,aAAqC,CAAC;QAC1C,IAAI,OAA+B,CAAC;QACpC,IAAI,CAAC;YACH,SAAS,GAAG,SAAS,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,EAAE,qCAAqC,CAAC,CAAC;YACnF,OAAO,GAAG,SAAS,CACjB,OAAO,CAAC,OAAO,EACf,qCAAqC,EACrC,qCAAqC,CACtC,CAAC;YACF,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAE,CAAC;YACxD,GAAG,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACjC,cAAc,GAAG,kBAAkB,CAAC,MAAM,CAAC,UAAU,CAAC,mBAAoB,CAAC,CAAC;YAC5E,aAAa,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;YACrC,GAAG,GAAG,OAAO,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;YACxC,IAAI,CAAC;gBACH,OAAO,GAAG,MAAM,OAAO,CAAC,WAAW,CAAC,aAAa,CAAC;oBAChD,GAAG,EAAE,GAAG;oBACR,SAAS;oBACT,GAAG,EAAE,OAAO;iBACb,CAAC,CAAC;gBACH,aAAa,GAAG,8BAA8B,CAAC,OAAO,CAAC,CAAC;gBACxD,OAAO,GAAG,wBAAwB,CAAC;oBACjC,UAAU;oBACV,SAAS;oBACT,aAAa;oBACb,aAAa;oBACb,SAAS,EAAE,IAAI,CAAC,SAAS;oBACzB,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC,OAAO;oBACrC,cAAc;iBACf,CAAC,CAAC;gBACH,UAAU,GAAG,MAAM,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,CAAC;YACxE,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,KAAK,YAAY,uBAAuB,EAAE,CAAC;oBAC7C,MAAM,KAAK,CAAC;gBACd,CAAC;gBACD,MAAM,6BAA6B,CAAC,yBAAyB,CAAC,CAAC;YACjE,CAAC;YACD,OAAO;gBACL,aAAa,EAAE,kCAAkC;gBACjD,OAAO,EAAE,2BAA2B;gBACpC,UAAU;gBACV,SAAS;gBACT,aAAa,EAAE,wBAAwB,CAAC,aAAa,CAAC;gBACtD,GAAG,EAAE;oBACH,SAAS,EAAE,IAAI,CAAC,SAAS;oBACzB,OAAO,EAAE,MAAM,CAAC,UAAU,CAAC,OAAO;oBAClC,WAAW,EAAE,MAAM,CAAC,UAAU,CAAC,mBAAoB;iBACpD;gBACD,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC;gBAClC,UAAU,EAAE,gBAAgB,CAAC,UAAU,CAAC;aACzC,CAAC;QACJ,CAAC;gBAAS,CAAC;YACT,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACnB,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACjB,aAAa,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACvB,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACb,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACb,cAAc,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACxB,aAAa,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACvB,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACjB,cAAc,CAAC,OAAO,CAAC,CAAC;YACxB,cAAc,CAAC,UAAU,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,eAAe,CAC1B,UAA8C;QAE9C,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,MAAM,OAAO,GAAG,mBAAmB,CACjC,UAAU,EACV,CAAC,UAAU,EAAE,oBAAoB,EAAE,SAAS,CAAC,EAC7C,CAAC,UAAU,EAAE,oBAAoB,EAAE,SAAS,CAAC,EAC7C,kBAAkB,CACnB,CAAC;QACF,MAAM,kBAAkB,GAAG,cAAc,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;QACtE,MAAM,MAAM,GAAG,wBAAwB,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC1D,IAAI,OAA+B,CAAC;QACpC,IAAI,WAAmC,CAAC;QACxC,IAAI,aAAqC,CAAC;QAC1C,IAAI,aAAqC,CAAC;QAC1C,IAAI,OAA+B,CAAC;QACpC,IAAI,GAA2B,CAAC;QAChC,IAAI,CAAC;YACH,OAAO,GAAG,SAAS,CACjB,OAAO,CAAC,OAAO,EACf,qCAAqC,EACrC,qCAAqC,CACtC,CAAC;YACF,WAAW,GAAG,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YACvD,aAAa,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;YACrC,aAAa,GAAG,8BAA8B,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YAC/D,OAAO,GAAG,wBAAwB,CAAC;gBACjC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,UAAU;gBACtC,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,SAAS;gBACpC,aAAa,EAAE,MAAM,CAAC,aAAa;gBACnC,aAAa;gBACb,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS;gBACxC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO;gBACvC,cAAc,EAAE,MAAM,CAAC,cAAc;aACtC,CAAC,CAAC;YACH,IAAI,MAAM,CAAC,QAAQ,CAAC,UAAU,KAAK,kBAAkB,EAAE,CAAC;gBACtD,MAAM,6BAA6B,CAAC,sBAAsB,CAAC,CAAC;YAC9D,CAAC;YACD,IAAI,CAAC,eAAe,CAAC,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC;gBAC1D,MAAM,6BAA6B,CAAC,kBAAkB,CAAC,CAAC;YAC1D,CAAC;YACD,IAAI,CAAC;gBACH,GAAG,GAAG,MAAM,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC;oBACxC,UAAU,EAAE,MAAM,CAAC,UAAU;oBAC7B,GAAG,EAAE,WAAW;oBAChB,OAAO;iBACR,CAAC,CAAC;gBACH,OAAO,MAAM,OAAO,CAAC,WAAW,CAAC,aAAa,CAAC;oBAC7C,GAAG,EAAE,GAAG;oBACR,aAAa,EAAE,MAAM,CAAC,OAAO;oBAC7B,GAAG,EAAE,OAAO;iBACb,CAAC,CAAC;YACL,CAAC;YAAC,MAAM,CAAC;gBACP,MAAM,6BAA6B,CAAC,uBAAuB,CAAC,CAAC;YAC/D,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACjB,aAAa,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACvB,aAAa,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACvB,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACjB,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACrB,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACb,kBAAkB,CAAC,MAAM,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,cAAc,CACzB,UAA6C;QAE7C,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,MAAM,OAAO,GAAG,mBAAmB,CACjC,UAAU,EACV,CAAC,UAAU,EAAE,oBAAoB,EAAE,SAAS,EAAE,eAAe,CAAC,EAC9D,CAAC,UAAU,EAAE,oBAAoB,EAAE,SAAS,CAAC,EAC7C,kBAAkB,CACnB,CAAC;QACF,MAAM,kBAAkB,GAAG,cAAc,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;QACtE,MAAM,MAAM,GAAG,wBAAwB,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC1D,IAAI,OAA+B,CAAC;QACpC,IAAI,UAAkC,CAAC;QACvC,IAAI,SAAiC,CAAC;QACtC,IAAI,iBAAyC,CAAC;QAC9C,IAAI,aAAqC,CAAC;QAC1C,IAAI,aAAqC,CAAC;QAC1C,IAAI,cAAsC,CAAC;QAC3C,IAAI,UAAkC,CAAC;QACvC,IAAI,UAA6D,CAAC;QAClE,IAAI,CAAC;YACH,OAAO,GAAG,SAAS,CACjB,OAAO,CAAC,OAAO,EACf,qCAAqC,EACrC,qCAAqC,CACtC,CAAC;YACF,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YACtD,IAAI,OAAO,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;gBACxC,IAAI,aAAqB,CAAC;gBAC1B,IAAI,CAAC;oBACH,aAAa,GAAG,iBAAiB,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;gBAC3D,CAAC;gBAAC,MAAM,CAAC;oBACP,MAAM,6BAA6B,CAAC,yBAAyB,CAAC,CAAC;gBACjE,CAAC;gBACD,IAAI,aAAa,KAAK,IAAI,CAAC,aAAa,EAAE,CAAC;oBACzC,MAAM,6BAA6B,CAAC,yBAAyB,CAAC,CAAC;gBACjE,CAAC;YACH,CAAC;YACD,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAE,CAAC;YACxD,SAAS,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACvC,iBAAiB,GAAG,kBAAkB,CAAC,MAAM,CAAC,UAAU,CAAC,mBAAoB,CAAC,CAAC;YAC/E,aAAa,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;YACrC,aAAa,GAAG,8BAA8B,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YAC/D,cAAc,GAAG,wBAAwB,CAAC;gBACxC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,UAAU;gBACtC,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,SAAS;gBACpC,aAAa,EAAE,MAAM,CAAC,aAAa;gBACnC,aAAa;gBACb,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS;gBACxC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO;gBACvC,cAAc,EAAE,MAAM,CAAC,cAAc;aACtC,CAAC,CAAC;YACH,UAAU,GAAG,wBAAwB,CAAC;gBACpC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,UAAU;gBACtC,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,SAAS;gBACpC,aAAa,EAAE,MAAM,CAAC,aAAa;gBACnC,aAAa;gBACb,SAAS,EAAE,IAAI,CAAC,SAAS;gBACzB,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC,OAAO;gBACrC,cAAc,EAAE,iBAAiB;aAClC,CAAC,CAAC;YACH,IAAI,MAAM,CAAC,QAAQ,CAAC,UAAU,KAAK,kBAAkB,EAAE,CAAC;gBACtD,MAAM,6BAA6B,CAAC,sBAAsB,CAAC,CAAC;YAC9D,CAAC;YACD,IAAI,CAAC,eAAe,CAAC,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC;gBAC1D,MAAM,6BAA6B,CAAC,kBAAkB,CAAC,CAAC;YAC1D,CAAC;YACD,IAAI,CAAC;gBACH,UAAU,GAAG,MAAM,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC;oBAC/C,UAAU,EAAE,MAAM,CAAC,UAAU;oBAC7B,UAAU,EAAE,UAAU;oBACtB,cAAc;oBACd,MAAM,EAAE,SAAS;oBACjB,UAAU;iBACX,CAAC,CAAC;YACL,CAAC;YAAC,MAAM,CAAC;gBACP,MAAM,6BAA6B,CAAC,uBAAuB,CAAC,CAAC;YAC/D,CAAC;YACD,OAAO;gBACL,aAAa,EAAE,MAAM,CAAC,QAAQ,CAAC,aAAa;gBAC5C,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,OAAO;gBAChC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,UAAU;gBACtC,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,SAAS;gBACpC,aAAa,EAAE,MAAM,CAAC,QAAQ,CAAC,aAAa;gBAC5C,GAAG,EAAE;oBACH,SAAS,EAAE,IAAI,CAAC,SAAS;oBACzB,OAAO,EAAE,MAAM,CAAC,UAAU,CAAC,OAAO;oBAClC,WAAW,EAAE,MAAM,CAAC,UAAU,CAAC,mBAAoB;iBACpD;gBACD,OAAO,EAAE,EAAE,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE;gBACvC,UAAU,EAAE,gBAAgB,CAAC,UAAU,CAAC;aACzC,CAAC;QACJ,CAAC;gBAAS,CAAC;YACT,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACjB,aAAa,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACvB,aAAa,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACvB,cAAc,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACxB,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACpB,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACpB,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACnB,iBAAiB,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YAC3B,cAAc,CAAC,UAAU,CAAC,CAAC;YAC3B,kBAAkB,CAAC,MAAM,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,gBAAgB,CAAC,UAAkB;QAC9C,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,IAAI,OAAe,CAAC;QACpB,IAAI,CAAC;YACH,OAAO,GAAG,iBAAiB,CAAC,UAAU,CAAC,CAAC;QAC1C,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,6BAA6B,CAAC,kBAAkB,CAAC,CAAC;QAC1D,CAAC;QACD,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC5C,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,UAAU,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YACtD,MAAM,6BAA6B,CAAC,iBAAiB,CAAC,CAAC;QACzD,CAAC;QACD,IAAI,GAA2B,CAAC;QAChC,IAAI,WAAmC,CAAC;QACxC,IAAI,GAA2B,CAAC;QAChC,IAAI,SAA6B,CAAC;QAClC,IAAI,MAA0B,CAAC;QAC/B,IAAI,YAAgC,CAAC;QACrC,IAAI,GAAuB,CAAC;QAC5B,IAAI,UAA6D,CAAC;QAClE,IAAI,YAAoC,CAAC;QACzC,IAAI,CAAC;YACH,GAAG,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACjC,WAAW,GAAG,kBAAkB,CAAC,MAAM,CAAC,UAAU,CAAC,mBAAoB,CAAC,CAAC;YACzE,GAAG,GAAG,OAAO,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;YACxC,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;YAChD,MAAM,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;YAC/B,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;YAC9C,YAAY,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;YACrC,YAAY,CAAC,gBAAgB,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC;YAClD,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC;gBAClB,MAAM,CAAC,IAAI,CAAC,qCAAqC,EAAE,OAAO,CAAC;gBAC3D,MAAM;gBACN,SAAS;gBACT,YAAY;gBACZ,WAAW;aACZ,CAAC,CAAC;YACH,IAAI,CAAC;gBACH,UAAU,GAAG,MAAM,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC;gBAChF,YAAY,GAAG,MAAM,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC;oBACjD,UAAU;oBACV,GAAG,EAAE,GAAG;oBACR,OAAO,EAAE,GAAG;iBACb,CAAC,CAAC;YACL,CAAC;YAAC,MAAM,CAAC;gBACP,MAAM,6BAA6B,CAAC,yBAAyB,CAAC,CAAC;YACjE,CAAC;YACD,IAAI,CAAC,eAAe,CAAC,GAAG,EAAE,YAAY,CAAC,EAAE,CAAC;gBACxC,MAAM,6BAA6B,CAAC,yBAAyB,CAAC,CAAC;YACjE,CAAC;YACD,OAAO;gBACL,SAAS,EAAE,IAAI,CAAC,SAAS;gBACzB,OAAO;gBACP,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,MAAM;gBAChC,WAAW,EAAE,MAAM,CAAC,UAAU,CAAC,mBAAoB;gBACnD,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE;aACrB,CAAC;QACJ,CAAC;gBAAS,CAAC;YACT,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACb,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACrB,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACb,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACnB,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YAChB,YAAY,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACtB,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACb,cAAc,CAAC,UAAU,CAAC,CAAC;YAC3B,YAAY,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;QACxB,CAAC;IACH,CAAC;CACF"}