@serve.zone/dcrouter 17.0.0 → 17.1.1

package/dist_ts/email/mail-dns-txt-policy.js

@@ -0,0 +1,466 @@
+import * as plugins from '../plugins.js';
+import { decodeTxtRecordContent } from '../dns/txt-record-presentation.js';
+function intentKind(intent) {
+    const desired = intent.value.trim().toLowerCase();
+    if (desired.startsWith('v=spf1'))
+        return 'spf';
+    if (desired.startsWith('v=dmarc1'))
+        return 'dmarc';
+    if (desired.startsWith('v=dkim1'))
+        return 'dkim';
+    return 'exact';
+}
+function markerForKind(kind) {
+    if (kind === 'spf')
+        return 'v=spf1';
+    if (kind === 'dmarc')
+        return 'v=dmarc1';
+    if (kind === 'dkim')
+        return 'v=dkim1';
+    return undefined;
+}
+export function classifyMailTxtRecord(intent, rawValue) {
+    const kind = intentKind(intent);
+    const decoded = decodeTxtRecordContent(rawValue);
+    if (!decoded.ok) {
+        const marker = markerForKind(kind);
+        const rawNormalized = rawValue.trim().toLowerCase();
+        const plausiblyRelevant = kind === 'dkim'
+            ? rawNormalized.length > 0
+            : kind === 'dmarc'
+                ? /(?:^|;)\s*v=dmarc1(?:;|$)/.test(rawNormalized.replace(/^"/, ''))
+                : marker
+                    ? rawNormalized.slice(0, marker.length + 4).includes(marker)
+                    : rawValue.trim().startsWith('"');
+        return plausiblyRelevant
+            ? { relevant: true, malformed: decoded.error }
+            : { relevant: false };
+    }
+    const canonicalValue = decoded.value.trim();
+    const marker = markerForKind(kind);
+    const normalizedValue = canonicalValue.toLowerCase();
+    return {
+        relevant: kind === 'dkim'
+            ? canonicalValue.length > 0
+            : kind === 'dmarc'
+                ? /(?:^|;)\s*v=dmarc1(?:;|$)/.test(normalizedValue)
+                : marker
+                    ? normalizedValue.startsWith(marker)
+                    : canonicalValue === intent.value.trim(),
+        canonicalValue,
+    };
+}
+function ipv4Bytes(address) {
+    const parts = address.split('.');
+    if (parts.length !== 4)
+        return undefined;
+    const bytes = parts.map((part) => Number(part));
+    return bytes.every((part) => Number.isInteger(part) && part >= 0 && part <= 255)
+        ? bytes
+        : undefined;
+}
+function ipv6Bytes(address) {
+    let normalized = address.toLowerCase();
+    if (normalized.includes('.')) {
+        const lastColon = normalized.lastIndexOf(':');
+        const ipv4 = ipv4Bytes(normalized.slice(lastColon + 1));
+        if (lastColon < 0 || !ipv4)
+            return undefined;
+        normalized = `${normalized.slice(0, lastColon)}:${((ipv4[0] << 8) | ipv4[1]).toString(16)}:${((ipv4[2] << 8) | ipv4[3]).toString(16)}`;
+    }
+    const halves = normalized.split('::');
+    if (halves.length > 2)
+        return undefined;
+    const left = halves[0] ? halves[0].split(':') : [];
+    const right = halves[1] ? halves[1].split(':') : [];
+    const missing = 8 - left.length - right.length;
+    if ((halves.length === 1 && missing !== 0) || missing < 0)
+        return undefined;
+    const groups = [...left, ...Array.from({ length: missing }, () => '0'), ...right];
+    if (groups.length !== 8 || groups.some((group) => !/^[0-9a-f]{1,4}$/.test(group))) {
+        return undefined;
+    }
+    return groups.flatMap((group) => {
+        const value = Number.parseInt(group, 16);
+        return [value >> 8, value & 0xff];
+    });
+}
+function parseIpNetwork(value, family) {
+    const slashIndex = value.lastIndexOf('/');
+    const address = slashIndex >= 0 ? value.slice(0, slashIndex) : value;
+    const maximumPrefix = family === 4 ? 32 : 128;
+    const rawPrefix = slashIndex >= 0 ? value.slice(slashIndex + 1) : String(maximumPrefix);
+    if (!/^\d{1,3}$/.test(rawPrefix))
+        return undefined;
+    const prefixLength = Number.parseInt(rawPrefix, 10);
+    if (prefixLength < 0 || prefixLength > maximumPrefix)
+        return undefined;
+    const bytes = family === 4 ? ipv4Bytes(address) : ipv6Bytes(address);
+    return bytes ? { family, bytes, prefixLength } : undefined;
+}
+function networkContains(network, address) {
+    if (network.family !== address.family)
+        return false;
+    const wholeBytes = Math.floor(network.prefixLength / 8);
+    const remainingBits = network.prefixLength % 8;
+    for (let index = 0; index < wholeBytes; index++) {
+        if (network.bytes[index] !== address.bytes[index])
+            return false;
+    }
+    if (remainingBits === 0)
+        return true;
+    const mask = (0xff << (8 - remainingBits)) & 0xff;
+    return (network.bytes[wholeBytes] & mask) === (address.bytes[wholeBytes] & mask);
+}
+function parseAMechanism(body) {
+    let remaining = body.slice(1);
+    let ipv6PrefixLength = 128;
+    const doubleSlashIndex = remaining.lastIndexOf('//');
+    if (doubleSlashIndex >= 0) {
+        const value = remaining.slice(doubleSlashIndex + 2);
+        if (!/^\d{1,3}$/.test(value))
+            return undefined;
+        ipv6PrefixLength = Number.parseInt(value, 10);
+        remaining = remaining.slice(0, doubleSlashIndex);
+    }
+    let ipv4PrefixLength = 32;
+    const slashIndex = remaining.lastIndexOf('/');
+    if (slashIndex >= 0) {
+        const value = remaining.slice(slashIndex + 1);
+        if (!/^\d{1,2}$/.test(value))
+            return undefined;
+        ipv4PrefixLength = Number.parseInt(value, 10);
+        remaining = remaining.slice(0, slashIndex);
+    }
+    if (ipv4PrefixLength > 32 || ipv6PrefixLength > 128)
+        return undefined;
+    if (remaining && !remaining.startsWith(':'))
+        return undefined;
+    const domain = remaining.slice(1).trim().toLowerCase().replace(/\.$/, '');
+    if (domain.includes('%') || (domain && !/^[a-z0-9_.-]+$/.test(domain)))
+        return undefined;
+    return {
+        ...(domain ? { domain } : {}),
+        ipv4PrefixLength,
+        ipv6PrefixLength,
+    };
+}
+function parseSpfRecord(value) {
+    const terms = value.trim().split(/\s+/);
+    if (terms.shift()?.toLowerCase() !== 'v=spf1') {
+        return { error: 'SPF record must start with v=spf1' };
+    }
+    const parsed = { mechanisms: [], hasRedirect: false };
+    const modifiers = new Set();
+    for (const rawTerm of terms) {
+        if (!rawTerm)
+            continue;
+        let term = rawTerm;
+        let qualifier = '+';
+        let hadQualifier = false;
+        if (/^[+\-~?]/.test(term)) {
+            qualifier = term[0];
+            term = term.slice(1);
+            hadQualifier = true;
+        }
+        if (!term)
+            return { error: 'SPF contains an empty mechanism' };
+        const normalized = term.toLowerCase();
+        if (normalized.includes('=')) {
+            const match = term.match(/^([a-z][a-z0-9_.-]*)=(\S+)$/i);
+            if (hadQualifier || !match)
+                return { error: `SPF contains an invalid modifier: ${rawTerm}` };
+            const name = match[1].toLowerCase();
+            if (modifiers.has(name))
+                return { error: `SPF contains duplicate ${name} modifiers` };
+            modifiers.add(name);
+            if (name === 'redirect')
+                parsed.hasRedirect = true;
+            continue;
+        }
+        if (normalized.startsWith('ip4:') || normalized.startsWith('ip6:')) {
+            const family = normalized.startsWith('ip4:') ? 4 : 6;
+            const network = parseIpNetwork(term.slice(4), family);
+            if (!network)
+                return { error: `SPF contains an invalid ${family === 4 ? 'ip4' : 'ip6'} mechanism: ${rawTerm}` };
+            parsed.mechanisms.push({ kind: 'ip', qualifier, network });
+            continue;
+        }
+        if (normalized === 'a' || normalized.startsWith('a:') || normalized.startsWith('a/')) {
+            const mechanism = parseAMechanism(term);
+            if (!mechanism)
+                return { error: `SPF contains an invalid a mechanism: ${rawTerm}` };
+            parsed.mechanisms.push({ kind: 'a', qualifier, mechanism });
+            continue;
+        }
+        if (normalized === 'all') {
+            parsed.mechanisms.push({ kind: 'all', qualifier });
+            continue;
+        }
+        if (normalized === 'mx'
+            || normalized.startsWith('mx:')
+            || normalized.startsWith('mx/')
+            || normalized.startsWith('include:')
+            || normalized.startsWith('exists:')
+            || normalized === 'ptr'
+            || normalized.startsWith('ptr:')) {
+            parsed.mechanisms.push({ kind: 'unsupported', name: rawTerm });
+            continue;
+        }
+        return { error: `SPF contains an unknown mechanism: ${rawTerm}` };
+    }
+    return { parsed };
+}
+function desiredSpfAddresses(value) {
+    const parsed = parseSpfRecord(value);
+    if (!parsed.parsed)
+        return { error: parsed.error };
+    const addresses = [];
+    for (const mechanism of parsed.parsed.mechanisms) {
+        if (mechanism.kind === 'all' && mechanism.qualifier === '-')
+            continue;
+        if (mechanism.kind !== 'ip'
+            || mechanism.qualifier !== '+'
+            || mechanism.network.prefixLength !== (mechanism.network.family === 4 ? 32 : 128)) {
+            return { error: 'Desired SPF intent does not contain only concrete sender addresses' };
+        }
+        addresses.push(mechanism.network);
+    }
+    return addresses.length > 0
+        ? { addresses }
+        : { error: 'Desired SPF intent does not contain concrete sender addresses' };
+}
+async function withTimeout(promise, timeoutMs) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error(`DNS lookup timed out after ${timeoutMs}ms`)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+async function evaluateSpf(intent, actualValue, options) {
+    const desired = desiredSpfAddresses(intent.value);
+    if (!desired.addresses)
+        return { outcome: 'invalid', reason: desired.error };
+    const actual = parseSpfRecord(actualValue);
+    if (!actual.parsed)
+        return { outcome: 'invalid', reason: actual.error };
+    const timeoutMs = Math.max(1, options.lookupTimeoutMs ?? 2_000);
+    const maxDnsLookups = Math.max(1, options.maxDnsLookups ?? 10);
+    let lookupCount = 0;
+    const cache = new Map();
+    const resolveBounded = async (name, type) => {
+        const key = `${type}:${name}`;
+        const cached = cache.get(key);
+        if (cached)
+            return await cached;
+        if (!options.resolveDns)
+            throw new Error('SPF a mechanism requires a DNS resolver');
+        if (lookupCount >= maxDnsLookups) {
+            throw new Error(`SPF DNS lookup budget of ${maxDnsLookups} was exceeded`);
+        }
+        lookupCount++;
+        const lookup = withTimeout(options.resolveDns(name, type), timeoutMs);
+        cache.set(key, lookup);
+        return await lookup;
+    };
+    try {
+        for (const address of desired.addresses) {
+            let authorized = false;
+            for (const mechanism of actual.parsed.mechanisms) {
+                if (mechanism.kind === 'unsupported') {
+                    return {
+                        outcome: 'conflict',
+                        reason: `SPF authorization is indeterminate before a proven match: ${mechanism.name}`,
+                    };
+                }
+                let matches = false;
+                if (mechanism.kind === 'ip') {
+                    matches = networkContains(mechanism.network, address);
+                }
+                else if (mechanism.kind === 'a') {
+                    const domain = mechanism.mechanism.domain || intent.name.toLowerCase().replace(/\.$/, '');
+                    const type = address.family === 4 ? 'A' : 'AAAA';
+                    const prefixLength = address.family === 4
+                        ? mechanism.mechanism.ipv4PrefixLength
+                        : mechanism.mechanism.ipv6PrefixLength;
+                    for (const answer of await resolveBounded(domain, type)) {
+                        const network = parseIpNetwork(`${answer}/${prefixLength}`, address.family);
+                        if (network && networkContains(network, address)) {
+                            matches = true;
+                            break;
+                        }
+                    }
+                }
+                else {
+                    matches = true;
+                }
+                if (!matches)
+                    continue;
+                if (mechanism.qualifier !== '+') {
+                    return {
+                        outcome: 'conflict',
+                        reason: `SPF first match for a desired edge has qualifier ${mechanism.qualifier}`,
+                    };
+                }
+                authorized = true;
+                break;
+            }
+            if (!authorized) {
+                return {
+                    outcome: 'conflict',
+                    reason: actual.parsed.hasRedirect
+                        ? 'SPF redirect is unsupported and authorization cannot be proven'
+                        : 'SPF record does not authorize every desired mail edge address',
+                };
+            }
+        }
+    }
+    catch (error) {
+        return { outcome: 'lookup-error', reason: `SPF DNS lookup failed: ${error.message}` };
+    }
+    return { outcome: 'valid', effectiveValue: actualValue };
+}
+function parseDmarc(value) {
+    const orderedTags = [];
+    const seen = new Set();
+    for (const segment of value.split(';')) {
+        const trimmed = segment.trim();
+        if (!trimmed)
+            continue;
+        const equalsIndex = trimmed.indexOf('=');
+        if (equalsIndex <= 0)
+            return { error: `Malformed DMARC tag: ${trimmed}` };
+        const key = trimmed.slice(0, equalsIndex).trim().toLowerCase();
+        const tagValue = trimmed.slice(equalsIndex + 1).trim();
+        if (!key || !tagValue || seen.has(key))
+            return { error: `Invalid or duplicate DMARC tag: ${key}` };
+        seen.add(key);
+        orderedTags.push({ key, value: tagValue });
+    }
+    if (orderedTags[0]?.key !== 'v' || orderedTags[0].value !== 'DMARC1') {
+        return { error: 'DMARC v=DMARC1 must be the first tag' };
+    }
+    const tags = new Map(orderedTags.map((tag) => [tag.key, tag.value]));
+    const rawPolicy = tags.get('p')?.toLowerCase();
+    // Malformed optional tag values are ignored and locally defaulted. A missing
+    // or malformed p therefore has effective policy "none". pct and unknown
+    // extension tags do not change the policy-strength comparison.
+    const policy = rawPolicy === 'quarantine' || rawPolicy === 'reject' || rawPolicy === 'none'
+        ? rawPolicy
+        : 'none';
+    return { policy: { policy } };
+}
+function evaluateDmarc(intent, actualValue) {
+    const desired = parseDmarc(intent.value);
+    const actual = parseDmarc(actualValue);
+    if (!desired.policy)
+        return { outcome: 'invalid', reason: desired.error };
+    if (!actual.policy)
+        return { outcome: 'invalid', reason: actual.error };
+    const strength = { none: 0, quarantine: 1, reject: 2 };
+    if (strength[actual.policy.policy] < strength[desired.policy.policy]) {
+        return { outcome: 'conflict', reason: 'Operator DMARC policy is weaker than the desired policy' };
+    }
+    return { outcome: 'valid', effectiveValue: actualValue };
+}
+function decodeDkimPublicKey(value) {
+    const normalized = value.replace(/\s+/g, '');
+    if (!normalized || !/^[A-Za-z0-9+/]+={0,2}$/.test(normalized) || normalized.length % 4 !== 0) {
+        return undefined;
+    }
+    const decoded = plugins.buffer.Buffer.from(normalized, 'base64');
+    return decoded.toString('base64').replace(/=+$/, '') === normalized.replace(/=+$/, '')
+        ? decoded
+        : undefined;
+}
+function parseDkim(value) {
+    const tags = new Map();
+    for (const segment of value.split(';')) {
+        const trimmed = segment.trim();
+        if (!trimmed)
+            continue;
+        const equalsIndex = trimmed.indexOf('=');
+        if (equalsIndex <= 0)
+            return { error: `Malformed DKIM tag: ${trimmed}` };
+        const key = trimmed.slice(0, equalsIndex).trim().toLowerCase();
+        const tagValue = trimmed.slice(equalsIndex + 1).trim();
+        if (!/^[a-z][a-z0-9]*$/.test(key) || tags.has(key)) {
+            return { error: `Invalid or duplicate DKIM tag: ${key}` };
+        }
+        tags.set(key, tagValue);
+    }
+    if (tags.has('v') && tags.get('v') !== 'DKIM1') {
+        return { error: 'DKIM v must be DKIM1 when present' };
+    }
+    const publicKey = decodeDkimPublicKey(tags.get('p') || '');
+    if (!publicKey)
+        return { error: 'DKIM p must contain a valid non-empty base64 public key' };
+    const keyType = (tags.get('k') || 'rsa').toLowerCase();
+    const hashes = (tags.get('h') || 'sha256')
+        .split(':').map((entry) => entry.trim().toLowerCase()).filter(Boolean);
+    const services = (tags.get('s') || '*')
+        .split(':').map((entry) => entry.trim().toLowerCase()).filter(Boolean);
+    return { policy: { publicKey, keyType, hashes, services } };
+}
+function equalBytes(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function evaluateDkim(intent, actualValue) {
+    const desired = parseDkim(intent.value);
+    const actual = parseDkim(actualValue);
+    if (!desired.policy)
+        return { outcome: 'invalid', reason: desired.error };
+    if (!actual.policy)
+        return { outcome: 'invalid', reason: actual.error };
+    if (actual.policy.keyType !== 'rsa') {
+        return { outcome: 'conflict', reason: 'DKIM k does not permit the required RSA key' };
+    }
+    if (!actual.policy.hashes.includes('sha256')) {
+        return { outcome: 'conflict', reason: 'DKIM h does not permit sha256' };
+    }
+    if (!actual.policy.services.some((service) => service === '*' || service === 'email')) {
+        return { outcome: 'conflict', reason: 'DKIM s does not permit email service' };
+    }
+    if (!equalBytes(actual.policy.publicKey, desired.policy.publicKey)) {
+        return { outcome: 'conflict', reason: `DKIM record at ${intent.name} contains a different public key` };
+    }
+    return { outcome: 'valid', effectiveValue: actualValue };
+}
+export async function evaluateMailTxtIntent(intent, rawValues, options = {}) {
+    const classified = rawValues
+        .map((value) => classifyMailTxtRecord(intent, value))
+        .filter((entry) => entry.relevant);
+    if (classified.length === 0) {
+        return { outcome: 'missing', reason: `${intent.type} ${intent.name} is missing` };
+    }
+    if (classified.length > 1) {
+        return { outcome: 'duplicate', reason: `${intent.name} has multiple relevant TXT records` };
+    }
+    const record = classified[0];
+    if (record.malformed || record.canonicalValue === undefined) {
+        return { outcome: 'invalid', reason: record.malformed || 'TXT record is malformed' };
+    }
+    const kind = intentKind(intent);
+    if (kind === 'spf')
+        return await evaluateSpf(intent, record.canonicalValue, options);
+    if (kind === 'dmarc')
+        return evaluateDmarc(intent, record.canonicalValue);
+    if (kind === 'dkim')
+        return evaluateDkim(intent, record.canonicalValue);
+    if (record.canonicalValue === intent.value.trim()) {
+        return { outcome: 'valid', effectiveValue: record.canonicalValue };
+    }
+    return {
+        outcome: 'conflict',
+        reason: `TXT record at ${intent.name} does not exactly match the desired value`,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mail-dns-txt-policy.js","sourceRoot":"","sources":["../../../ts/email/mail-dns-txt-policy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AA8C3E,SAAS,UAAU,CAAC,MAA6B;IAC/C,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAClD,IAAI,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC;QAAE,OAAO,KAAK,CAAC;IAC/C,IAAI,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC;QAAE,OAAO,OAAO,CAAC;IACnD,IAAI,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC;QAAE,OAAO,MAAM,CAAC;IACjD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAS,aAAa,CAAC,IAAkB;IACvC,IAAI,IAAI,KAAK,KAAK;QAAE,OAAO,QAAQ,CAAC;IACpC,IAAI,IAAI,KAAK,OAAO;QAAE,OAAO,UAAU,CAAC;IACxC,IAAI,IAAI,KAAK,MAAM;QAAE,OAAO,SAAS,CAAC;IACtC,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,MAAM,UAAU,qBAAqB,CACnC,MAA6B,EAC7B,QAAgB;IAEhB,MAAM,IAAI,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;IAChC,MAAM,OAAO,GAAG,sBAAsB,CAAC,QAAQ,CAAC,CAAC;IACjD,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC;QAChB,MAAM,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;QACnC,MAAM,aAAa,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QACpD,MAAM,iBAAiB,GAAG,IAAI,KAAK,MAAM;YACvC,CAAC,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC;YAC1B,CAAC,CAAC,IAAI,KAAK,OAAO;gBAChB,CAAC,CAAC,2BAA2B,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;gBACnE,CAAC,CAAC,MAAM;oBACR,CAAC,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;oBAC5D,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;QACtC,OAAO,iBAAiB;YACtB,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,KAAK,EAAE;YAC9C,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;IAC1B,CAAC;IACD,MAAM,cAAc,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;IAC5C,MAAM,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;IACnC,MAAM,eAAe,GAAG,cAAc,CAAC,WAAW,EAAE,CAAC;IACrD,OAAO;QACL,QAAQ,EAAE,IAAI,KAAK,MAAM;YACvB,CAAC,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC;YAC3B,CAAC,CAAC,IAAI,KAAK,OAAO;gBAChB,CAAC,CAAC,2BAA2B,CAAC,IAAI,CAAC,eAAe,CAAC;gBACnD,CAAC,CAAC,MAAM;oBACR,CAAC,CAAC,eAAe,CAAC,UAAU,CAAC,MAAM,CAAC;oBACpC,CAAC,CAAC,cAAc,KAAK,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE;QAC5C,cAAc;KACf,CAAC;AACJ,CAAC;AAED,SAAS,SAAS,CAAC,OAAe;IAChC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACjC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IACzC,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IAChD,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,GAAG,CAAC;QAC9E,CAAC,CAAC,KAAK;QACP,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC;AAED,SAAS,SAAS,CAAC,OAAe;IAChC,IAAI,UAAU,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IACvC,IAAI,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QAC7B,MAAM,SAAS,GAAG,UAAU,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QAC9C,MAAM,IAAI,GAAG,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC;QACxD,IAAI,SAAS,GAAG,CAAC,IAAI,CAAC,IAAI;YAAE,OAAO,SAAS,CAAC;QAC7C,UAAU,GAAG,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;IACzI,CAAC;IACD,MAAM,MAAM,GAAG,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACtC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC;IACxC,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACnD,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACpD,MAAM,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;IAC/C,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,OAAO,KAAK,CAAC,CAAC,IAAI,OAAO,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC;IAC5E,MAAM,MAAM,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC;IAClF,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;QAClF,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;QAC9B,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACzC,OAAO,CAAC,KAAK,IAAI,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,CAAC;IACpC,CAAC,CAAC,CAAC;AACL,CAAC;AAED,SAAS,cAAc,CAAC,KAAa,EAAE,MAAa;IAClD,MAAM,UAAU,GAAG,KAAK,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAC1C,MAAM,OAAO,GAAG,UAAU,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IACrE,MAAM,aAAa,GAAG,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;IAC9C,MAAM,SAAS,GAAG,UAAU,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;IACxF,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC;QAAE,OAAO,SAAS,CAAC;IACnD,MAAM,YAAY,GAAG,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;IACpD,IAAI,YAAY,GAAG,CAAC,IAAI,YAAY,GAAG,aAAa;QAAE,OAAO,SAAS,CAAC;IACvE,MAAM,KAAK,GAAG,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IACrE,OAAO,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;AAC7D,CAAC;AAED,SAAS,eAAe,CAAC,OAAmB,EAAE,OAAmB;IAC/D,IAAI,OAAO,CAAC,MAAM,KAAK,OAAO,CAAC,MAAM;QAAE,OAAO,KAAK,CAAC;IACpD,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC;IACxD,MAAM,aAAa,GAAG,OAAO,CAAC,YAAY,GAAG,CAAC,CAAC;IAC/C,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,UAAU,EAAE,KAAK,EAAE,EAAE,CAAC;QAChD,IAAI,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;IAClE,CAAC;IACD,IAAI,aAAa,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACrC,MAAM,IAAI,GAAG,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,GAAG,IAAI,CAAC;IAClD,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,CAAC;AACnF,CAAC;AAED,SAAS,eAAe,CAAC,IAAY;IACnC,IAAI,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC9B,IAAI,gBAAgB,GAAG,GAAG,CAAC;IAC3B,MAAM,gBAAgB,GAAG,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACrD,IAAI,gBAAgB,IAAI,CAAC,EAAE,CAAC;QAC1B,MAAM,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,gBAAgB,GAAG,CAAC,CAAC,CAAC;QACpD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAC/C,gBAAgB,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAC9C,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACnD,CAAC;IACD,IAAI,gBAAgB,GAAG,EAAE,CAAC;IAC1B,MAAM,UAAU,GAAG,SAAS,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAC9C,IAAI,UAAU,IAAI,CAAC,EAAE,CAAC;QACpB,MAAM,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC;QAC9C,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAC/C,gBAAgB,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAC9C,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;IAC7C,CAAC;IACD,IAAI,gBAAgB,GAAG,EAAE,IAAI,gBAAgB,GAAG,GAAG;QAAE,OAAO,SAAS,CAAC;IACtE,IAAI,SAAS,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC;IAC9D,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAC1E,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAAE,OAAO,SAAS,CAAC;IACzF,OAAO;QACL,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7B,gBAAgB;QAChB,gBAAgB;KACjB,CAAC;AACJ,CAAC;AAED,SAAS,cAAc,CAAC,KAAa;IACnC,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACxC,IAAI,KAAK,CAAC,KAAK,EAAE,EAAE,WAAW,EAAE,KAAK,QAAQ,EAAE,CAAC;QAC9C,OAAO,EAAE,KAAK,EAAE,mCAAmC,EAAE,CAAC;IACxD,CAAC;IACD,MAAM,MAAM,GAAqB,EAAE,UAAU,EAAE,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;IACxE,MAAM,SAAS,GAAG,IAAI,GAAG,EAAU,CAAC;IACpC,KAAK,MAAM,OAAO,IAAI,KAAK,EAAE,CAAC;QAC5B,IAAI,CAAC,OAAO;YAAE,SAAS;QACvB,IAAI,IAAI,GAAG,OAAO,CAAC;QACnB,IAAI,SAAS,GAAkB,GAAG,CAAC;QACnC,IAAI,YAAY,GAAG,KAAK,CAAC;QACzB,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YAC1B,SAAS,GAAG,IAAI,CAAC,CAAC,CAAkB,CAAC;YACrC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACrB,YAAY,GAAG,IAAI,CAAC;QACtB,CAAC;QACD,IAAI,CAAC,IAAI;YAAE,OAAO,EAAE,KAAK,EAAE,iCAAiC,EAAE,CAAC;QAC/D,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QACtC,IAAI,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC7B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,8BAA8B,CAAC,CAAC;YACzD,IAAI,YAAY,IAAI,CAAC,KAAK;gBAAE,OAAO,EAAE,KAAK,EAAE,qCAAqC,OAAO,EAAE,EAAE,CAAC;YAC7F,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;YACpC,IAAI,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC;gBAAE,OAAO,EAAE,KAAK,EAAE,0BAA0B,IAAI,YAAY,EAAE,CAAC;YACtF,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACpB,IAAI,IAAI,KAAK,UAAU;gBAAE,MAAM,CAAC,WAAW,GAAG,IAAI,CAAC;YACnD,SAAS;QACX,CAAC;QACD,IAAI,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YACnE,MAAM,MAAM,GAAG,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACrD,MAAM,OAAO,GAAG,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;YACtD,IAAI,CAAC,OAAO;gBAAE,OAAO,EAAE,KAAK,EAAE,2BAA2B,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,eAAe,OAAO,EAAE,EAAE,CAAC;YAChH,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC;YAC3D,SAAS;QACX,CAAC;QACD,IAAI,UAAU,KAAK,GAAG,IAAI,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;YACrF,MAAM,SAAS,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;YACxC,IAAI,CAAC,SAAS;gBAAE,OAAO,EAAE,KAAK,EAAE,wCAAwC,OAAO,EAAE,EAAE,CAAC;YACpF,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC,CAAC;YAC5D,SAAS;QACX,CAAC;QACD,IAAI,UAAU,KAAK,KAAK,EAAE,CAAC;YACzB,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;YACnD,SAAS;QACX,CAAC;QACD,IACE,UAAU,KAAK,IAAI;eAChB,UAAU,CAAC,UAAU,CAAC,KAAK,CAAC;eAC5B,UAAU,CAAC,UAAU,CAAC,KAAK,CAAC;eAC5B,UAAU,CAAC,UAAU,CAAC,UAAU,CAAC;eACjC,UAAU,CAAC,UAAU,CAAC,SAAS,CAAC;eAChC,UAAU,KAAK,KAAK;eACpB,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,EAChC,CAAC;YACD,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;YAC/D,SAAS;QACX,CAAC;QACD,OAAO,EAAE,KAAK,EAAE,sCAAsC,OAAO,EAAE,EAAE,CAAC;IACpE,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,CAAC;AACpB,CAAC;AAED,SAAS,mBAAmB,CAAC,KAAa;IACxC,MAAM,MAAM,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;IACrC,IAAI,CAAC,MAAM,CAAC,MAAM;QAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;IACnD,MAAM,SAAS,GAAiB,EAAE,CAAC;IACnC,KAAK,MAAM,SAAS,IAAI,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QACjD,IAAI,SAAS,CAAC,IAAI,KAAK,KAAK,IAAI,SAAS,CAAC,SAAS,KAAK,GAAG;YAAE,SAAS;QACtE,IACE,SAAS,CAAC,IAAI,KAAK,IAAI;eACpB,SAAS,CAAC,SAAS,KAAK,GAAG;eAC3B,SAAS,CAAC,OAAO,CAAC,YAAY,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,EACjF,CAAC;YACD,OAAO,EAAE,KAAK,EAAE,oEAAoE,EAAE,CAAC;QACzF,CAAC;QACD,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IACpC,CAAC;IACD,OAAO,SAAS,CAAC,MAAM,GAAG,CAAC;QACzB,CAAC,CAAC,EAAE,SAAS,EAAE;QACf,CAAC,CAAC,EAAE,KAAK,EAAE,+DAA+D,EAAE,CAAC;AACjF,CAAC;AAED,KAAK,UAAU,WAAW,CAAI,OAAmB,EAAE,SAAiB;IAClE,IAAI,KAAgD,CAAC;IACrD,IAAI,CAAC;QACH,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC;YACxB,OAAO;YACP,IAAI,OAAO,CAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE;gBAClC,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,8BAA8B,SAAS,IAAI,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;YACtG,CAAC,CAAC;SACH,CAAC,CAAC;IACL,CAAC;YAAS,CAAC;QACT,IAAI,KAAK;YAAE,YAAY,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;AACH,CAAC;AAED,KAAK,UAAU,WAAW,CACxB,MAA6B,EAC7B,WAAmB,EACnB,OAAiC;IAEjC,MAAM,OAAO,GAAG,mBAAmB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAClD,IAAI,CAAC,OAAO,CAAC,SAAS;QAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC;IAC7E,MAAM,MAAM,GAAG,cAAc,CAAC,WAAW,CAAC,CAAC;IAC3C,IAAI,CAAC,MAAM,CAAC,MAAM;QAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;IAExE,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,eAAe,IAAI,KAAK,CAAC,CAAC;IAChE,MAAM,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC;IAC/D,IAAI,WAAW,GAAG,CAAC,CAAC;IACpB,MAAM,KAAK,GAAG,IAAI,GAAG,EAA6B,CAAC;IACnD,MAAM,cAAc,GAAG,KAAK,EAAE,IAAY,EAAE,IAAkB,EAAqB,EAAE;QACnF,MAAM,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC;QAC9B,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC9B,IAAI,MAAM;YAAE,OAAO,MAAM,MAAM,CAAC;QAChC,IAAI,CAAC,OAAO,CAAC,UAAU;YAAE,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;QACpF,IAAI,WAAW,IAAI,aAAa,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CAAC,4BAA4B,aAAa,eAAe,CAAC,CAAC;QAC5E,CAAC;QACD,WAAW,EAAE,CAAC;QACd,MAAM,MAAM,GAAG,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,SAAS,CAAC,CAAC;QACtE,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QACvB,OAAO,MAAM,MAAM,CAAC;IACtB,CAAC,CAAC;IAEF,IAAI,CAAC;QACH,KAAK,MAAM,OAAO,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;YACxC,IAAI,UAAU,GAAG,KAAK,CAAC;YACvB,KAAK,MAAM,SAAS,IAAI,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;gBACjD,IAAI,SAAS,CAAC,IAAI,KAAK,aAAa,EAAE,CAAC;oBACrC,OAAO;wBACL,OAAO,EAAE,UAAU;wBACnB,MAAM,EAAE,6DAA6D,SAAS,CAAC,IAAI,EAAE;qBACtF,CAAC;gBACJ,CAAC;gBACD,IAAI,OAAO,GAAG,KAAK,CAAC;gBACpB,IAAI,SAAS,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;oBAC5B,OAAO,GAAG,eAAe,CAAC,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;gBACxD,CAAC;qBAAM,IAAI,SAAS,CAAC,IAAI,KAAK,GAAG,EAAE,CAAC;oBAClC,MAAM,MAAM,GAAG,SAAS,CAAC,SAAS,CAAC,MAAM,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;oBAC1F,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC;oBACjD,MAAM,YAAY,GAAG,OAAO,CAAC,MAAM,KAAK,CAAC;wBACvC,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,gBAAgB;wBACtC,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,gBAAgB,CAAC;oBACzC,KAAK,MAAM,MAAM,IAAI,MAAM,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC;wBACxD,MAAM,OAAO,GAAG,cAAc,CAAC,GAAG,MAAM,IAAI,YAAY,EAAE,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;wBAC5E,IAAI,OAAO,IAAI,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC;4BACjD,OAAO,GAAG,IAAI,CAAC;4BACf,MAAM;wBACR,CAAC;oBACH,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,OAAO,GAAG,IAAI,CAAC;gBACjB,CAAC;gBACD,IAAI,CAAC,OAAO;oBAAE,SAAS;gBACvB,IAAI,SAAS,CAAC,SAAS,KAAK,GAAG,EAAE,CAAC;oBAChC,OAAO;wBACL,OAAO,EAAE,UAAU;wBACnB,MAAM,EAAE,oDAAoD,SAAS,CAAC,SAAS,EAAE;qBAClF,CAAC;gBACJ,CAAC;gBACD,UAAU,GAAG,IAAI,CAAC;gBAClB,MAAM;YACR,CAAC;YACD,IAAI,CAAC,UAAU,EAAE,CAAC;gBAChB,OAAO;oBACL,OAAO,EAAE,UAAU;oBACnB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,WAAW;wBAC/B,CAAC,CAAC,gEAAgE;wBAClE,CAAC,CAAC,+DAA+D;iBACpE,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;IAAC,OAAO,KAAc,EAAE,CAAC;QACxB,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,0BAA2B,KAAe,CAAC,OAAO,EAAE,EAAE,CAAC;IACnG,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,CAAC;AAC3D,CAAC;AAMD,SAAS,UAAU,CAAC,KAAa;IAC/B,MAAM,WAAW,GAA0C,EAAE,CAAC;IAC9D,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QACvC,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;QAC/B,IAAI,CAAC,OAAO;YAAE,SAAS;QACvB,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACzC,IAAI,WAAW,IAAI,CAAC;YAAE,OAAO,EAAE,KAAK,EAAE,wBAAwB,OAAO,EAAE,EAAE,CAAC;QAC1E,MAAM,GAAG,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAC/D,MAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACvD,IAAI,CAAC,GAAG,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,OAAO,EAAE,KAAK,EAAE,mCAAmC,GAAG,EAAE,EAAE,CAAC;QACnG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACd,WAAW,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC7C,CAAC;IACD,IAAI,WAAW,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;QACrE,OAAO,EAAE,KAAK,EAAE,sCAAsC,EAAE,CAAC;IAC3D,CAAC;IACD,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACrE,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE,CAAC;IAC/C,6EAA6E;IAC7E,wEAAwE;IACxE,+DAA+D;IAC/D,MAAM,MAAM,GAAG,SAAS,KAAK,YAAY,IAAI,SAAS,KAAK,QAAQ,IAAI,SAAS,KAAK,MAAM;QACzF,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC;AAChC,CAAC;AAED,SAAS,aAAa,CAAC,MAA6B,EAAE,WAAmB;IACvE,MAAM,OAAO,GAAG,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACzC,MAAM,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,CAAC;IACvC,IAAI,CAAC,OAAO,CAAC,MAAM;QAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC;IAC1E,IAAI,CAAC,MAAM,CAAC,MAAM;QAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;IACxE,MAAM,QAAQ,GAA2C,EAAE,IAAI,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;IAC/F,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;QACrE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,yDAAyD,EAAE,CAAC;IACpG,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,CAAC;AAC3D,CAAC;AASD,SAAS,mBAAmB,CAAC,KAAa;IACxC,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAC7C,IAAI,CAAC,UAAU,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7F,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;IACjE,OAAO,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;QACpF,CAAC,CAAC,OAAO;QACT,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC;AAED,SAAS,SAAS,CAAC,KAAa;IAC9B,MAAM,IAAI,GAAG,IAAI,GAAG,EAAkB,CAAC;IACvC,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QACvC,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;QAC/B,IAAI,CAAC,OAAO;YAAE,SAAS;QACvB,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACzC,IAAI,WAAW,IAAI,CAAC;YAAE,OAAO,EAAE,KAAK,EAAE,uBAAuB,OAAO,EAAE,EAAE,CAAC;QACzE,MAAM,GAAG,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAC/D,MAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACvD,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACnD,OAAO,EAAE,KAAK,EAAE,kCAAkC,GAAG,EAAE,EAAE,CAAC;QAC5D,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;IAC1B,CAAC;IACD,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,OAAO,EAAE,CAAC;QAC/C,OAAO,EAAE,KAAK,EAAE,mCAAmC,EAAE,CAAC;IACxD,CAAC;IACD,MAAM,SAAS,GAAG,mBAAmB,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;IAC3D,IAAI,CAAC,SAAS;QAAE,OAAO,EAAE,KAAK,EAAE,yDAAyD,EAAE,CAAC;IAC5F,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;IACvD,MAAM,MAAM,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,QAAQ,CAAC;SACvC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACzE,MAAM,QAAQ,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC;SACpC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACzE,OAAO,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC;AAC9D,CAAC;AAED,SAAS,UAAU,CAAC,IAAgB,EAAE,KAAiB;IACrD,OAAO,IAAI,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;AAC9F,CAAC;AAED,SAAS,YAAY,CAAC,MAA6B,EAAE,WAAmB;IACtE,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACxC,MAAM,MAAM,GAAG,SAAS,CAAC,WAAW,CAAC,CAAC;IACtC,IAAI,CAAC,OAAO,CAAC,MAAM;QAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC;IAC1E,IAAI,CAAC,MAAM,CAAC,MAAM;QAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;IACxE,IAAI,MAAM,CAAC,MAAM,CAAC,OAAO,KAAK,KAAK,EAAE,CAAC;QACpC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,6CAA6C,EAAE,CAAC;IACxF,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC7C,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,+BAA+B,EAAE,CAAC;IAC1E,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,KAAK,GAAG,IAAI,OAAO,KAAK,OAAO,CAAC,EAAE,CAAC;QACtF,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,sCAAsC,EAAE,CAAC;IACjF,CAAC;IACD,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;QACnE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,kBAAkB,MAAM,CAAC,IAAI,kCAAkC,EAAE,CAAC;IAC1G,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,CAAC;AAC3D,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,MAA6B,EAC7B,SAAmB,EACnB,UAAoC,EAAE;IAEtC,MAAM,UAAU,GAAG,SAAS;SACzB,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,qBAAqB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;SACpD,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACrC,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC5B,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,aAAa,EAAE,CAAC;IACpF,CAAC;IACD,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC1B,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,oCAAoC,EAAE,CAAC;IAC9F,CAAC;IACD,MAAM,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;IAC7B,IAAI,MAAM,CAAC,SAAS,IAAI,MAAM,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;QAC5D,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,SAAS,IAAI,yBAAyB,EAAE,CAAC;IACvF,CAAC;IACD,MAAM,IAAI,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;IAChC,IAAI,IAAI,KAAK,KAAK;QAAE,OAAO,MAAM,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;IACrF,IAAI,IAAI,KAAK,OAAO;QAAE,OAAO,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC,CAAC;IAC1E,IAAI,IAAI,KAAK,MAAM;QAAE,OAAO,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC,CAAC;IACxE,IAAI,MAAM,CAAC,cAAc,KAAK,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC;QAClD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,CAAC,cAAc,EAAE,CAAC;IACrE,CAAC;IACD,OAAO;QACL,OAAO,EAAE,UAAU;QACnB,MAAM,EAAE,iBAAiB,MAAM,CAAC,IAAI,2CAA2C;KAChF,CAAC;AACJ,CAAC"}

package/dist_ts/email/reconcile-mail-dns-singleton.d.ts

@@ -0,0 +1,47 @@
+import { DnsRecordDoc } from '../db/documents/classes.dns-record.doc.js';
+import type { IEmailDnsRecordIntent } from '../../dist_ts_interfaces/data/email-domain.js';
+import { type IMailDnsTxtPolicyResult } from './mail-dns-txt-policy.js';
+export interface IMailDnsMutationClient {
+    createRecord(args: {
+        domainId: string;
+        name: string;
+        type: 'MX' | 'TXT' | 'A' | 'AAAA';
+        value: string;
+        ttl: number;
+        createdBy: string;
+        managedBy: string;
+        managedOwnerId: string;
+        managedRecordKey: string;
+    }): Promise<{
+        success: boolean;
+        id?: string;
+        message?: string;
+    }>;
+    updateRecord(args: {
+        id: string;
+        name?: string;
+        value?: string;
+        ttl?: number;
+    }): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    deleteRecord(id: string): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+}
+export interface IReconcileMailDnsSingletonOptions {
+    intent: IEmailDnsRecordIntent;
+    rrset: DnsRecordDoc[];
+    dnsManager: IMailDnsMutationClient;
+    managedBy: string;
+    createdBy: string;
+    evaluate: (intent: IEmailDnsRecordIntent, values: string[]) => Promise<IMailDnsTxtPolicyResult>;
+}
+export declare function applyMailDnsVerificationResult(intent: IEmailDnsRecordIntent, result: IMailDnsTxtPolicyResult, phase: 'reconcile' | 'verify'): void;
+/**
+ * Reconcile SPF, DMARC, and DKIM singleton TXT records without adopting or
+ * mutating operator policy. Returns false for non-singleton intents.
+ */
+export declare function reconcileMailDnsSingleton(options: IReconcileMailDnsSingletonOptions): Promise<boolean>;