@serve.zone/dcrouter 17.0.0 → 17.1.1

package/dist_ts_web/elements/email/email-domain-creation-progress.js

@@ -0,0 +1,257 @@
+const settledIntentStatuses = new Set([
+    'satisfied',
+    'valid',
+    'conflict',
+    'failed',
+]);
+const formatOperationError = (errorArg) => {
+    const location = errorArg.recordKey ? `${errorArg.recordKey}: ` : '';
+    return `${location}${errorArg.message} [${errorArg.code}]`;
+};
+const appendDnsStatusLines = (linesArg, dnsStatusArg) => {
+    for (const [label, status] of [
+        ['MX', dnsStatusArg.mx],
+        ['SPF', dnsStatusArg.spf],
+        ['DKIM', dnsStatusArg.dkim],
+        ['DMARC', dnsStatusArg.dmarc],
+    ]) {
+        if (status !== 'unchecked') {
+            linesArg.push(`${label}: ${status}`);
+        }
+    }
+};
+export const getEmailDomainCreationProgress = (inputArg) => {
+    const { domain, operation, requestCompleted } = inputArg;
+    if (!domain) {
+        if (!requestCompleted) {
+            return {
+                percentage: 0,
+                indeterminate: true,
+                showPercentage: false,
+                statusText: 'Generating DKIM material and creating the domain record...',
+                terminalLines: ['Submitting email domain configuration'],
+            };
+        }
+        const lines = ['Email domain creation request completed without a persisted domain'];
+        for (const error of operation?.errors || []) {
+            lines.push(formatOperationError(error));
+        }
+        if (operation?.message && !lines.includes(operation.message)) {
+            lines.push(operation.message);
+        }
+        return {
+            percentage: 100,
+            indeterminate: false,
+            showPercentage: false,
+            statusText: operation?.message || 'Email domain creation failed.',
+            terminalLines: lines,
+        };
+    }
+    const reconciliation = domain.reconciliation;
+    const lines = [`Domain record persisted: ${domain.domain}`];
+    if (!reconciliation || reconciliation.intents.length === 0) {
+        if (!requestCompleted) {
+            lines.push('Preparing the managed DNS plan');
+            return {
+                percentage: 0,
+                indeterminate: true,
+                showPercentage: false,
+                statusText: 'Preparing the managed DNS plan...',
+                terminalLines: lines,
+            };
+        }
+        lines.push('No DNS reconciliation plan is available');
+        const errors = reconciliation?.errors.length
+            ? reconciliation.errors
+            : operation?.errors || [];
+        for (const error of errors) {
+            lines.push(formatOperationError(error));
+        }
+        const retryAt = reconciliation?.retryAt || operation?.retryAt;
+        if (retryAt) {
+            lines.push(`Retry scheduled for ${retryAt}`);
+        }
+        const statusText = reconciliation?.lifecycleStatus === 'failed'
+            ? operation?.message || `DNS setup failed for ${domain.domain}.`
+            : retryAt
+                ? 'DNS reconciliation is pending and will retry automatically.'
+                : operation?.message || 'The domain was created without a DNS reconciliation plan.';
+        return {
+            percentage: 100,
+            indeterminate: false,
+            showPercentage: false,
+            statusText,
+            terminalLines: lines,
+        };
+    }
+    const settledCount = reconciliation.intents.filter((intent) => settledIntentStatuses.has(intent.status)).length;
+    lines.push(`DNS plan prepared: ${reconciliation.intents.length} managed records`);
+    lines.push(`DNS reconciliation: ${settledCount} settled, ${reconciliation.intents.length - settledCount} pending`);
+    appendDnsStatusLines(lines, domain.dnsStatus);
+    if (reconciliation.lifecycleStatus === 'active') {
+        lines.push('Email domain is active');
+        return {
+            percentage: 100,
+            indeterminate: false,
+            showPercentage: true,
+            statusText: `${domain.domain} is active.`,
+            terminalLines: lines,
+        };
+    }
+    if (!requestCompleted) {
+        return {
+            percentage: 0,
+            indeterminate: true,
+            showPercentage: false,
+            statusText: 'Reconciling and validating managed DNS records...',
+            terminalLines: lines,
+        };
+    }
+    const errors = reconciliation.errors.length > 0
+        ? reconciliation.errors
+        : operation?.errors || [];
+    for (const error of errors) {
+        lines.push(formatOperationError(error));
+    }
+    const retryAt = reconciliation.retryAt || operation?.retryAt;
+    if (retryAt) {
+        lines.push(`Retry scheduled for ${retryAt}`);
+    }
+    if (reconciliation.lifecycleStatus === 'failed') {
+        return {
+            percentage: 100,
+            indeterminate: false,
+            showPercentage: false,
+            statusText: operation?.message || `DNS setup failed for ${domain.domain}.`,
+            terminalLines: lines,
+        };
+    }
+    return {
+        percentage: 100,
+        indeterminate: false,
+        showPercentage: false,
+        statusText: retryAt
+            ? `DNS reconciliation is pending and will retry automatically.`
+            : `DNS reconciliation is pending for ${domain.domain}.`,
+        terminalLines: lines,
+    };
+};
+export const findNewEmailDomain = (domainsArg, expectedDomainArg, existingIdsArg) => {
+    const expectedDomain = expectedDomainArg.trim().toLowerCase();
+    const candidates = domainsArg.filter((domain) => domain.domain.toLowerCase() === expectedDomain && !existingIdsArg.has(domain.id));
+    if (candidates.length > 1) {
+        throw new Error(`Multiple new email domains appeared for ${expectedDomain}`);
+    }
+    return candidates[0];
+};
+const waitForPollInterval = async (delayMsArg, signalArg) => {
+    if (signalArg.aborted)
+        return;
+    await new Promise((resolve) => {
+        const finish = () => {
+            signalArg.removeEventListener('abort', handleAbort);
+            resolve();
+        };
+        const handleAbort = () => {
+            clearTimeout(timeoutId);
+            finish();
+        };
+        const timeoutId = setTimeout(finish, delayMsArg);
+        signalArg.addEventListener('abort', handleAbort, { once: true });
+    });
+};
+export const observeNewEmailDomain = async (optionsArg) => {
+    const startedAt = Date.now();
+    const pollIntervalMs = optionsArg.pollIntervalMs ?? (optionsArg.subscribeToDomains ? 15_000 : 600);
+    const timeoutMs = optionsArg.timeoutMs ?? 120_000;
+    let observedId;
+    let latestDomain;
+    let pushedDomains;
+    let wakeObserver;
+    const unsubscribe = optionsArg.subscribeToDomains?.((domainsArg) => {
+        pushedDomains = domainsArg;
+        wakeObserver?.();
+    });
+    try {
+        while (!optionsArg.signal.aborted && Date.now() - startedAt < timeoutMs) {
+            try {
+                let domain;
+                if (!observedId) {
+                    const domainSnapshot = pushedDomains || await optionsArg.listDomains();
+                    pushedDomains = undefined;
+                    const foundDomain = findNewEmailDomain(domainSnapshot, optionsArg.expectedDomain, optionsArg.existingIds);
+                    observedId = foundDomain?.id;
+                    domain = foundDomain;
+                }
+                else if (pushedDomains) {
+                    domain = pushedDomains.find((candidate) => candidate.id === observedId);
+                    pushedDomains = undefined;
+                }
+                else {
+                    domain = await optionsArg.getDomain(observedId);
+                }
+                if (optionsArg.signal.aborted)
+                    break;
+                if (domain) {
+                    if (domain !== latestDomain) {
+                        latestDomain = domain;
+                        optionsArg.onDomain(domain);
+                    }
+                    const lifecycleStatus = domain.reconciliation?.lifecycleStatus;
+                    if (lifecycleStatus === 'active' || lifecycleStatus === 'failed') {
+                        return domain;
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.startsWith('Multiple new email domains')) {
+                    throw error;
+                }
+                // The realtime subscription or bounded fallback read will retry.
+            }
+            const updatePromise = new Promise((resolve) => {
+                wakeObserver = resolve;
+            });
+            if (pushedDomains) {
+                wakeObserver = undefined;
+                continue;
+            }
+            await Promise.race([
+                updatePromise,
+                waitForPollInterval(pollIntervalMs, optionsArg.signal),
+            ]);
+            wakeObserver = undefined;
+        }
+    }
+    finally {
+        unsubscribe?.();
+        wakeObserver?.();
+    }
+    return latestDomain;
+};
+export const withAbortableDeadline = async (promiseArg, optionsArg) => {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (callbackArg) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeoutId);
+            optionsArg.signal?.removeEventListener('abort', handleAbort);
+            callbackArg();
+        };
+        const handleAbort = () => {
+            finish(() => reject(new Error('Email domain creation progress was interrupted')));
+        };
+        const timeoutId = setTimeout(() => {
+            finish(() => reject(new Error(optionsArg.timeoutMessage)));
+        }, optionsArg.timeoutMs);
+        if (optionsArg.signal?.aborted) {
+            handleAbort();
+            return;
+        }
+        optionsArg.signal?.addEventListener('abort', handleAbort, { once: true });
+        promiseArg.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
+    });
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"email-domain-creation-progress.js","sourceRoot":"","sources":["../../../../ts_web/elements/email/email-domain-creation-progress.ts"],"names":[],"mappings":"AAgBA,MAAM,qBAAqB,GAAG,IAAI,GAAG,CAAwC;IAC3E,WAAW;IACX,OAAO;IACP,UAAU;IACV,QAAQ;CACT,CAAC,CAAC;AAEH,MAAM,oBAAoB,GAAG,CAC3B,QAAkG,EAC1F,EAAE;IACV,MAAM,QAAQ,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,SAAS,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;IACrE,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC,OAAO,KAAK,QAAQ,CAAC,IAAI,GAAG,CAAC;AAC7D,CAAC,CAAC;AAEF,MAAM,oBAAoB,GAAG,CAC3B,QAAkB,EAClB,YAAmD,EAC7C,EAAE;IACR,KAAK,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI;QAC5B,CAAC,IAAI,EAAE,YAAY,CAAC,EAAE,CAAC;QACvB,CAAC,KAAK,EAAE,YAAY,CAAC,GAAG,CAAC;QACzB,CAAC,MAAM,EAAE,YAAY,CAAC,IAAI,CAAC;QAC3B,CAAC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC;KACrB,EAAE,CAAC;QACX,IAAI,MAAM,KAAK,WAAW,EAAE,CAAC;YAC3B,QAAQ,CAAC,IAAI,CAAC,GAAG,KAAK,KAAK,MAAM,EAAE,CAAC,CAAC;QACvC,CAAC;IACH,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAC5C,QAA2C,EACb,EAAE;IAChC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,gBAAgB,EAAE,GAAG,QAAQ,CAAC;IAEzD,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,OAAO;gBACL,UAAU,EAAE,CAAC;gBACb,aAAa,EAAE,IAAI;gBACnB,cAAc,EAAE,KAAK;gBACrB,UAAU,EAAE,4DAA4D;gBACxE,aAAa,EAAE,CAAC,uCAAuC,CAAC;aACzD,CAAC;QACJ,CAAC;QAED,MAAM,KAAK,GAAG,CAAC,oEAAoE,CAAC,CAAC;QACrF,KAAK,MAAM,KAAK,IAAI,SAAS,EAAE,MAAM,IAAI,EAAE,EAAE,CAAC;YAC5C,KAAK,CAAC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAAC;QAC1C,CAAC;QACD,IAAI,SAAS,EAAE,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC;YAC7D,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QAChC,CAAC;QACD,OAAO;YACL,UAAU,EAAE,GAAG;YACf,aAAa,EAAE,KAAK;YACpB,cAAc,EAAE,KAAK;YACrB,UAAU,EAAE,SAAS,EAAE,OAAO,IAAI,+BAA+B;YACjE,aAAa,EAAE,KAAK;SACrB,CAAC;IACJ,CAAC;IAED,MAAM,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC;IAC7C,MAAM,KAAK,GAAG,CAAC,4BAA4B,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;IAC5D,IAAI,CAAC,cAAc,IAAI,cAAc,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3D,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,KAAK,CAAC,IAAI,CAAC,gCAAgC,CAAC,CAAC;YAC7C,OAAO;gBACL,UAAU,EAAE,CAAC;gBACb,aAAa,EAAE,IAAI;gBACnB,cAAc,EAAE,KAAK;gBACrB,UAAU,EAAE,mCAAmC;gBAC/C,aAAa,EAAE,KAAK;aACrB,CAAC;QACJ,CAAC;QAED,KAAK,CAAC,IAAI,CAAC,yCAAyC,CAAC,CAAC;QACtD,MAAM,MAAM,GAAG,cAAc,EAAE,MAAM,CAAC,MAAM;YAC1C,CAAC,CAAC,cAAc,CAAC,MAAM;YACvB,CAAC,CAAC,SAAS,EAAE,MAAM,IAAI,EAAE,CAAC;QAC5B,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,KAAK,CAAC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAAC;QAC1C,CAAC;QACD,MAAM,OAAO,GAAG,cAAc,EAAE,OAAO,IAAI,SAAS,EAAE,OAAO,CAAC;QAC9D,IAAI,OAAO,EAAE,CAAC;YACZ,KAAK,CAAC,IAAI,CAAC,uBAAuB,OAAO,EAAE,CAAC,CAAC;QAC/C,CAAC;QACD,MAAM,UAAU,GACd,cAAc,EAAE,eAAe,KAAK,QAAQ;YAC1C,CAAC,CAAC,SAAS,EAAE,OAAO,IAAI,wBAAwB,MAAM,CAAC,MAAM,GAAG;YAChE,CAAC,CAAC,OAAO;gBACP,CAAC,CAAC,6DAA6D;gBAC/D,CAAC,CAAC,SAAS,EAAE,OAAO,IAAI,2DAA2D,CAAC;QAC1F,OAAO;YACL,UAAU,EAAE,GAAG;YACf,aAAa,EAAE,KAAK;YACpB,cAAc,EAAE,KAAK;YACrB,UAAU;YACV,aAAa,EAAE,KAAK;SACrB,CAAC;IACJ,CAAC;IAED,MAAM,YAAY,GAAG,cAAc,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAC5D,qBAAqB,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CACzC,CAAC,MAAM,CAAC;IACT,KAAK,CAAC,IAAI,CAAC,sBAAsB,cAAc,CAAC,OAAO,CAAC,MAAM,kBAAkB,CAAC,CAAC;IAClF,KAAK,CAAC,IAAI,CACR,uBAAuB,YAAY,aAAa,cAAc,CAAC,OAAO,CAAC,MAAM,GAAG,YAAY,UAAU,CACvG,CAAC;IACF,oBAAoB,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC;IAE9C,IAAI,cAAc,CAAC,eAAe,KAAK,QAAQ,EAAE,CAAC;QAChD,KAAK,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;QACrC,OAAO;YACL,UAAU,EAAE,GAAG;YACf,aAAa,EAAE,KAAK;YACpB,cAAc,EAAE,IAAI;YACpB,UAAU,EAAE,GAAG,MAAM,CAAC,MAAM,aAAa;YACzC,aAAa,EAAE,KAAK;SACrB,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACtB,OAAO;YACL,UAAU,EAAE,CAAC;YACb,aAAa,EAAE,IAAI;YACnB,cAAc,EAAE,KAAK;YACrB,UAAU,EAAE,mDAAmD;YAC/D,aAAa,EAAE,KAAK;SACrB,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAG,cAAc,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC;QAC7C,CAAC,CAAC,cAAc,CAAC,MAAM;QACvB,CAAC,CAAC,SAAS,EAAE,MAAM,IAAI,EAAE,CAAC;IAC5B,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,KAAK,CAAC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAAC;IAC1C,CAAC;IACD,MAAM,OAAO,GAAG,cAAc,CAAC,OAAO,IAAI,SAAS,EAAE,OAAO,CAAC;IAC7D,IAAI,OAAO,EAAE,CAAC;QACZ,KAAK,CAAC,IAAI,CAAC,uBAAuB,OAAO,EAAE,CAAC,CAAC;IAC/C,CAAC;IAED,IAAI,cAAc,CAAC,eAAe,KAAK,QAAQ,EAAE,CAAC;QAChD,OAAO;YACL,UAAU,EAAE,GAAG;YACf,aAAa,EAAE,KAAK;YACpB,cAAc,EAAE,KAAK;YACrB,UAAU,EAAE,SAAS,EAAE,OAAO,IAAI,wBAAwB,MAAM,CAAC,MAAM,GAAG;YAC1E,aAAa,EAAE,KAAK;SACrB,CAAC;IACJ,CAAC;IAED,OAAO;QACL,UAAU,EAAE,GAAG;QACf,aAAa,EAAE,KAAK;QACpB,cAAc,EAAE,KAAK;QACrB,UAAU,EAAE,OAAO;YACjB,CAAC,CAAC,6DAA6D;YAC/D,CAAC,CAAC,qCAAqC,MAAM,CAAC,MAAM,GAAG;QACzD,aAAa,EAAE,KAAK;KACrB,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,UAA0C,EAC1C,iBAAyB,EACzB,cAAmC,EACO,EAAE;IAC5C,MAAM,cAAc,GAAG,iBAAiB,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAC9D,MAAM,UAAU,GAAG,UAAU,CAAC,MAAM,CAClC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,KAAK,cAAc,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAC7F,CAAC;IACF,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CAAC,2CAA2C,cAAc,EAAE,CAAC,CAAC;IAC/E,CAAC;IACD,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC;AACvB,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAG,KAAK,EAAE,UAAkB,EAAE,SAAsB,EAAiB,EAAE;IAC9F,IAAI,SAAS,CAAC,OAAO;QAAE,OAAO;IAC9B,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;QAClC,MAAM,MAAM,GAAG,GAAG,EAAE;YAClB,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;YACpD,OAAO,EAAE,CAAC;QACZ,CAAC,CAAC;QACF,MAAM,WAAW,GAAG,GAAG,EAAE;YACvB,YAAY,CAAC,SAAS,CAAC,CAAC;YACxB,MAAM,EAAE,CAAC;QACX,CAAC,CAAC;QACF,MAAM,SAAS,GAAG,UAAU,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QACjD,SAAS,CAAC,gBAAgB,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IACnE,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAgBF,MAAM,CAAC,MAAM,qBAAqB,GAAG,KAAK,EACxC,UAAyC,EACU,EAAE;IACrD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC7B,MAAM,cAAc,GAAG,UAAU,CAAC,cAAc,IAAI,CAClD,UAAU,CAAC,kBAAkB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAC7C,CAAC;IACF,MAAM,SAAS,GAAG,UAAU,CAAC,SAAS,IAAI,OAAO,CAAC;IAClD,IAAI,UAA8B,CAAC;IACnC,IAAI,YAAsD,CAAC;IAC3D,IAAI,aAAyD,CAAC;IAC9D,IAAI,YAAsC,CAAC;IAE3C,MAAM,WAAW,GAAG,UAAU,CAAC,kBAAkB,EAAE,CAAC,CAAC,UAAU,EAAE,EAAE;QACjE,aAAa,GAAG,UAAU,CAAC;QAC3B,YAAY,EAAE,EAAE,CAAC;IACnB,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC;QACH,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,GAAG,SAAS,EAAE,CAAC;YACxE,IAAI,CAAC;gBACH,IAAI,MAAuD,CAAC;gBAC5D,IAAI,CAAC,UAAU,EAAE,CAAC;oBAChB,MAAM,cAAc,GAAG,aAAa,IAAI,MAAM,UAAU,CAAC,WAAW,EAAE,CAAC;oBACvE,aAAa,GAAG,SAAS,CAAC;oBAC1B,MAAM,WAAW,GAAG,kBAAkB,CACpC,cAAc,EACd,UAAU,CAAC,cAAc,EACzB,UAAU,CAAC,WAAW,CACvB,CAAC;oBACF,UAAU,GAAG,WAAW,EAAE,EAAE,CAAC;oBAC7B,MAAM,GAAG,WAAW,CAAC;gBACvB,CAAC;qBAAM,IAAI,aAAa,EAAE,CAAC;oBACzB,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,EAAE,KAAK,UAAU,CAAC,CAAC;oBACxE,aAAa,GAAG,SAAS,CAAC;gBAC5B,CAAC;qBAAM,CAAC;oBACN,MAAM,GAAG,MAAM,UAAU,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;gBAClD,CAAC;gBAED,IAAI,UAAU,CAAC,MAAM,CAAC,OAAO;oBAAE,MAAM;gBACrC,IAAI,MAAM,EAAE,CAAC;oBACX,IAAI,MAAM,KAAK,YAAY,EAAE,CAAC;wBAC5B,YAAY,GAAG,MAAM,CAAC;wBACtB,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;oBAC9B,CAAC;oBACD,MAAM,eAAe,GAAG,MAAM,CAAC,cAAc,EAAE,eAAe,CAAC;oBAC/D,IAAI,eAAe,KAAK,QAAQ,IAAI,eAAe,KAAK,QAAQ,EAAE,CAAC;wBACjE,OAAO,MAAM,CAAC;oBAChB,CAAC;gBACH,CAAC;YACH,CAAC;YAAC,OAAO,KAAc,EAAE,CAAC;gBACxB,IAAI,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,4BAA4B,CAAC,EAAE,CAAC;oBACrF,MAAM,KAAK,CAAC;gBACd,CAAC;gBACD,iEAAiE;YACnE,CAAC;YAED,MAAM,aAAa,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;gBAClD,YAAY,GAAG,OAAO,CAAC;YACzB,CAAC,CAAC,CAAC;YACH,IAAI,aAAa,EAAE,CAAC;gBAClB,YAAY,GAAG,SAAS,CAAC;gBACzB,SAAS;YACX,CAAC;YACD,MAAM,OAAO,CAAC,IAAI,CAAC;gBACjB,aAAa;gBACb,mBAAmB,CAAC,cAAc,EAAE,UAAU,CAAC,MAAM,CAAC;aACvD,CAAC,CAAC;YACH,YAAY,GAAG,SAAS,CAAC;QAC3B,CAAC;IACH,CAAC;YAAS,CAAC;QACT,WAAW,EAAE,EAAE,CAAC;QAChB,YAAY,EAAE,EAAE,CAAC;IACnB,CAAC;IAED,OAAO,YAAY,CAAC;AACtB,CAAC,CAAC;AAQF,MAAM,CAAC,MAAM,qBAAqB,GAAG,KAAK,EACxC,UAAsB,EACtB,UAAqC,EACzB,EAAE;IACd,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACxC,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,MAAM,MAAM,GAAG,CAAC,WAAuB,EAAE,EAAE;YACzC,IAAI,OAAO;gBAAE,OAAO;YACpB,OAAO,GAAG,IAAI,CAAC;YACf,YAAY,CAAC,SAAS,CAAC,CAAC;YACxB,UAAU,CAAC,MAAM,EAAE,mBAAmB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;YAC7D,WAAW,EAAE,CAAC;QAChB,CAAC,CAAC;QACF,MAAM,WAAW,GAAG,GAAG,EAAE;YACvB,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC,CAAC,CAAC;QACpF,CAAC,CAAC;QACF,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE;YAChC,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;QAC7D,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC;QAEzB,IAAI,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC;YAC/B,WAAW,EAAE,CAAC;YACd,OAAO;QACT,CAAC;QACD,UAAU,CAAC,MAAM,EAAE,gBAAgB,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QAC1E,UAAU,CAAC,IAAI,CACb,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EACvC,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CACvC,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC"}