@techspokes/typescript-wsdl-client 1.1.4 → 1.1.5

package/dist/compiler/particleRestriction.js

@@ -0,0 +1,489 @@
+import { particleContentNode } from './complexTypeContent.js';
+import { assertSemanticParticleView } from './particleSemanticView.js';
+import { occurrenceAlgebra } from './occurrenceAnalysis.js';
+import { checkTypeDerivation, declarationMethods, RelationProblem } from './schemaTypeRelations.js';
+import { createSchemaScalarKernel } from './schemaScalarKernel.js';
+import { checkDeclaration } from './schemaDeclarationPrimitives.js';
+import { evaluatePreparedGroupWildcard } from './particleWildcardRelation.js';
+import { SemanticError } from './resolveCanonicalGraph.js';
+import { XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { declaredType } from './schemaTypeIdentity.js';
+import { collectSemanticTypeDependencies } from './semanticTypeDependencies.js';
+import { readElementIdentityConstraints, collectIdentityConstraintDependencies } from './schemaIdentityConstraints.js';
+class Incomplete extends Error {
+    result;
+    constructor(result) {
+        super(result.kind);
+        this.result = result;
+    }
+}
+class NeedOrder extends Error {
+    enumeration;
+    constructor(enumeration) {
+        super('Implicit choice enumeration required');
+        this.enumeration = enumeration;
+    }
+}
+const ONE = Object.freeze({ min: '1', max: '1' });
+export function checkParticleRestriction(context, derived, base, options = {}) {
+    assertSemanticParticleView(context, derived);
+    assertSemanticParticleView(context, base);
+    const budget = context.budget, charge = (n = 1) => budget.chargeWork(n);
+    return budget.guard(() => {
+        const unresolved = (p, message) => {
+            charge(10 + p.source.length + message.length);
+            throw new Incomplete(Object.freeze({ kind: 'unresolved', rule: 'cos-particle-restrict', component: p.source, message }));
+        };
+        try {
+            charge(24);
+            const deferScalarObligations = budget.snapshot(options).deferScalarObligations === true;
+            if (derived.purpose !== 'restriction' || base.purpose !== 'restriction')
+                return unresolved(derived.root, 'Restriction-normalized views required');
+            const typeDependencies = collectSemanticTypeDependencies(context);
+            const identityConstraintDependencies = collectIdentityConstraintDependencies(context);
+            charge(2);
+            const scalarObligations = [], scalarKeys = new Set();
+            const rememberScalar = (pending) => {
+                if (!deferScalarObligations)
+                    return;
+                for (const item of pending) {
+                    const contextId = item.contextId ?? context.contextId;
+                    charge(12 + 6 * (contextId.length + item.rule.length + item.component.length));
+                    const key = JSON.stringify([contextId, item.rule, item.component]);
+                    if (!scalarKeys.has(key)) {
+                        charge(4);
+                        scalarKeys.add(key);
+                        scalarObligations.push({ ...item, contextId });
+                    }
+                }
+            };
+            typeDependencies.add(derived.typeDependencies);
+            typeDependencies.add(base.typeDependencies);
+            const algebra = occurrenceAlgebra(charge), scalar = createSchemaScalarKernel(context);
+            const within = (r, b) => algebra.compare(r.min, b.min) >= 0 && algebra.compare(r.max, b.max) <= 0;
+            const group = (p) => p.kind === 'sequence' || p.kind === 'choice' || p.kind === 'all';
+            // Assignments belong to this root query, never to a context or cached view.
+            // A repeated particle has one ordering even when consumed in different pairs.
+            const assignments = new Map(), variables = new Map();
+            const orderedChildren = (p) => {
+                if (!p.orderUnspecified)
+                    return p.children;
+                charge(2);
+                const ordered = [];
+                for (const block of p.orderBlocks) {
+                    charge(3);
+                    if (block.kind === 'explicit' || block.children.length < 2) {
+                        charge(block.children.length);
+                        ordered.push(...block.children);
+                        continue;
+                    }
+                    charge(10 + block.particle.length * 6 + block.head.length * 6);
+                    const key = JSON.stringify([block.particle, block.head]);
+                    charge(2);
+                    const children = new Map();
+                    for (const child of block.children) {
+                        charge(3 + (child.element?.id.length ?? 0));
+                        if (!child.element || children.has(child.element.id))
+                            return unresolved(p, 'Implicit choice requires distinct effective declarations');
+                        children.set(child.element.id, child);
+                    }
+                    let variable = variables.get(key);
+                    if (!variable) {
+                        charge(5 + children.size);
+                        variable = Object.freeze({ key, members: Object.freeze([...children.keys()]) });
+                        variables.set(key, variable);
+                    }
+                    else {
+                        if (variable.members.length !== children.size)
+                            return unresolved(p, 'Incoherent repeated substitution-choice membership');
+                        for (const member of variable.members) {
+                            charge(2 + member.length);
+                            if (!children.has(member))
+                                return unresolved(p, 'Incoherent repeated substitution-choice membership');
+                        }
+                    }
+                    const selected = assignments.get(key);
+                    if (!selected)
+                        throw new NeedOrder(variable);
+                    for (const member of selected) {
+                        charge(2 + member.length);
+                        ordered.push(children.get(member));
+                    }
+                }
+                return ordered;
+            };
+            // Representation order seeds exhaustive search only; it is not a chosen
+            // semantic ordering. Every emitted permutation is charged before copying.
+            function* permutations(variable) {
+                charge(3 + variable.members.length);
+                const indices = variable.members.map((_, i) => i);
+                while (true) {
+                    charge(2 + indices.length);
+                    yield indices.map(i => variable.members[i]);
+                    let i = indices.length - 2;
+                    while (i >= 0) {
+                        charge(2);
+                        if (indices[i] < indices[i + 1])
+                            break;
+                        i--;
+                    }
+                    if (i < 0)
+                        return;
+                    let j = indices.length - 1;
+                    while (true) {
+                        charge(2);
+                        if (indices[j] > indices[i])
+                            break;
+                        j--;
+                    }
+                    charge(3);
+                    [indices[i], indices[j]] = [indices[j], indices[i]];
+                    for (let a = i + 1, z = indices.length - 1; a < z; a++, z--) {
+                        charge(3);
+                        [indices[a], indices[z]] = [indices[z], indices[a]];
+                    }
+                }
+            }
+            const debt = (value) => {
+                if (typeof value === 'boolean')
+                    return undefined;
+                if (value.kind === 'resource-limit' || value.kind === 'invalid-input' || value.kind === 'invalid-schema')
+                    throw new Incomplete(value);
+                return value;
+            };
+            // For the same mapping state a fully checked path dominates a pending one.
+            const putState = (states, key, pending) => {
+                charge(3);
+                if (!states.has(key) || states.get(key) !== undefined && pending === undefined)
+                    states.set(key, pending);
+            };
+            const fixedEqual = (a, b) => {
+                // One authentic declaration has one constraint; full validity still
+                // owes its value and current TYPE, as for particle identity above.
+                if (a === b)
+                    return true;
+                if (b.value?.kind !== 'fixed')
+                    return true;
+                if (a.value?.kind !== 'fixed')
+                    return false;
+                const left = checkDeclaration(context, a.id), right = checkDeclaration(context, b.id);
+                if (left.kind !== 'checked')
+                    throw new Incomplete(left);
+                if (right.kind !== 'checked')
+                    throw new Incomplete(right);
+                rememberScalar(left.scalarObligations);
+                rememberScalar(right.scalarObligations);
+                typeDependencies.add(left.typeDependencies);
+                typeDependencies.add(right.typeDependencies);
+                identityConstraintDependencies.add(left.identityConstraintDependencies);
+                identityConstraintDependencies.add(right.identityConstraintDependencies);
+                if (!left.constraint || !right.constraint)
+                    return unresolved(derived.root, 'Assessed fixed declaration constraint is unavailable');
+                // Full component validity still owes the declared TYPE and mixed
+                // emptiability; the constraint selects its assessed scalar value type.
+                const result = scalar.equivalent(left.constraint.type, left.constraint.lexical, right.constraint.type, right.constraint.lexical, a.id);
+                if (result.kind !== 'checked')
+                    throw new Incomplete(result);
+                rememberScalar(result.obligations);
+                typeDependencies.add(result.typeDependencies);
+                if (!deferScalarObligations && (left.scalarObligations.length || right.scalarObligations.length || result.obligations.length))
+                    return unresolved(derived.root, 'Fixed value comparison has undischarged scalar prerequisites');
+                return result.value;
+            };
+            const decisions = new Map();
+            const decision = (root) => {
+                charge(2);
+                const stack = [{ p: root, done: false }];
+                while (stack.length) {
+                    charge(3);
+                    const { p, done } = stack.pop();
+                    if (decisions.has(p))
+                        continue;
+                    if (!done) {
+                        charge(2 + p.children.length * 2);
+                        stack.push({ p, done: true });
+                        for (const child of p.children)
+                            stack.push({ p: child, done: false });
+                        continue;
+                    }
+                    charge(18 + p.children.length);
+                    charge(1 + p.source.length);
+                    const source = (particleContentNode(context, derived.content, p.source) ?? particleContentNode(context, base.content, p.source))?.context.source;
+                    if (!source)
+                        return unresolved(p, 'Semantic particle provenance is unavailable');
+                    decisions.set(p, Object.freeze({ owner: Object.freeze({ id: p.source, context: Object.freeze({ source }) }), kind: p.kind, occurs: p.occurs,
+                        total: p.summary.effectiveTotalRange, members: Object.freeze(p.children.map(child => decisions.get(child))), namespace: p.element?.name.namespace,
+                        wildcard: p.wildcard ? Object.freeze({ constraint: p.wildcard.namespace, processContents: p.wildcard.processContents,
+                            lexical: Object.freeze({ value: p.wildcard.lexical.value, effectiveNamespace: p.wildcard.lexical.context.effectiveNamespace }) }) : undefined }));
+                }
+                return decisions.get(root);
+            };
+            function* relationBody([r, b]) {
+                charge(8);
+                if (r === b || r.originalParticle !== undefined && r.originalParticle === b.originalParticle)
+                    return true;
+                if (r.kind === 'element' && b.kind === 'element') {
+                    const x = r.element, y = b.element;
+                    charge(x.name.namespace.length + y.name.namespace.length + x.name.local.length + y.name.local.length);
+                    if (x.name.namespace !== y.name.namespace || x.name.local !== y.name.local || !within(r.occurs, b.occurs))
+                        return false;
+                    if (x.identity.kind === 'global' && y.identity.kind === 'global')
+                        return true;
+                    if (x.nillable && !y.nillable || !fixedEqual(x, y))
+                        return false;
+                    if (x !== y) {
+                        const left = readElementIdentityConstraints(context, x.id), right = readElementIdentityConstraints(context, y.id);
+                        if (left.kind !== 'checked')
+                            throw new Incomplete(left);
+                        if (right.kind !== 'checked')
+                            throw new Incomplete(right);
+                        identityConstraintDependencies.add(left.identityConstraintDependencies);
+                        identityConstraintDependencies.add(right.identityConstraintDependencies);
+                        charge(2 + left.value.length * (right.value.length + 1));
+                        if (!left.value.every(id => right.value.includes(id)))
+                            return false;
+                    }
+                    const required = declarationMethods(context, y, 'block'), actual = declarationMethods(context, x, 'block');
+                    charge(1 + required.length * (actual.length + 1));
+                    if (!required.every(method => actual.includes(method)))
+                        return false;
+                    const result = checkTypeDerivation(context, declaredType(context, x), declaredType(context, y), ['extension', 'list', 'union']);
+                    if (result.kind !== 'checked')
+                        throw new Incomplete(result);
+                    typeDependencies.add(result.typeDependencies);
+                    return result.value;
+                }
+                if (b.kind === 'any')
+                    return evaluatePreparedGroupWildcard(decision(r), decision(b), charge, b.urTypeWildcard);
+                if (!group(b) || r.kind === 'any')
+                    return false;
+                let members = r.children, kind = r.kind, occurs = r.occurs;
+                if (r.kind === 'element') {
+                    charge(2);
+                    members = [r];
+                    kind = b.kind;
+                    occurs = ONE;
+                }
+                if (kind === 'all' && b.kind !== 'all' || kind === 'choice' && b.kind !== 'choice')
+                    return false;
+                if (kind === 'sequence' && b.kind === 'choice') {
+                    charge(8);
+                    const length = String(members.length);
+                    const range = { min: algebra.multiply(occurs.min, length), max: occurs.max === 'unbounded' ? 'unbounded' : algebra.multiply(occurs.max, length) };
+                    if (!within(range, b.occurs))
+                        return false;
+                    let pending;
+                    for (const child of members) {
+                        let found = false, childPending;
+                        for (const target of b.children) {
+                            charge(2);
+                            const value = yield [child, target];
+                            if (value === true) {
+                                found = true;
+                                break;
+                            }
+                            childPending ??= debt(value);
+                        }
+                        if (!found) {
+                            if (!childPending)
+                                return false;
+                            pending ??= childPending;
+                        }
+                    }
+                    return pending ?? true;
+                }
+                if (!within(occurs, b.occurs) || members.length > b.children.length)
+                    return false;
+                if (kind === 'sequence' && b.kind === 'all') {
+                    // Complete injective mappings. State sets retain alternate alignments;
+                    // no greedy choice can suppress a valid later assignment.
+                    charge(3);
+                    let states = new Map([[0n, undefined]]);
+                    for (const child of members) {
+                        charge(2);
+                        const next = new Map();
+                        for (let i = 0; i < b.children.length; i++) {
+                            charge(4 + b.children.length);
+                            const bit = 1n << BigInt(i);
+                            const value = yield [child, b.children[i]];
+                            if (value === false)
+                                continue;
+                            const pairPending = debt(value);
+                            for (const [mask, pathPending] of states) {
+                                charge(3 + b.children.length);
+                                if (!(mask & bit))
+                                    putState(next, mask | bit, pathPending ?? pairPending);
+                            }
+                        }
+                        states = next;
+                        if (!states.size)
+                            return false;
+                    }
+                    let pending;
+                    for (const [mask, pathPending] of states) {
+                        let complete = true;
+                        for (let i = 0; i < b.children.length; i++) {
+                            charge(4 + b.children.length);
+                            if (!(mask & (1n << BigInt(i))) && !b.children[i].summary.schemaEmptiable) {
+                                complete = false;
+                                break;
+                            }
+                        }
+                        if (complete) {
+                            if (!pathPending)
+                                return true;
+                            pending ??= pathPending;
+                        }
+                    }
+                    return pending ?? false;
+                }
+                if (r.kind !== 'element')
+                    members = orderedChildren(r);
+                const targets = orderedChildren(b);
+                charge(3);
+                let states = new Map([[0, undefined]]);
+                for (const child of members) {
+                    charge(2);
+                    const next = new Map();
+                    for (const [start, pathPending] of states)
+                        for (let i = start; i < targets.length; i++) {
+                            charge(3);
+                            const value = yield [child, targets[i]];
+                            if (value !== false)
+                                putState(next, i + 1, pathPending ?? debt(value));
+                            if (b.kind !== 'choice' && !targets[i].summary.schemaEmptiable)
+                                break;
+                        }
+                    states = next;
+                    if (!states.size)
+                        return false;
+                }
+                let pending;
+                for (const [start, pathPending] of states) {
+                    let complete = true;
+                    if (b.kind !== 'choice')
+                        for (let i = start; i < targets.length; i++) {
+                            charge();
+                            if (!targets[i].summary.schemaEmptiable) {
+                                complete = false;
+                                break;
+                            }
+                        }
+                    if (complete) {
+                        if (!pathPending)
+                            return true;
+                        pending ??= pathPending;
+                    }
+                }
+                return pending ?? false;
+            }
+            function* relation(pair) {
+                try {
+                    return yield* relationBody(pair);
+                }
+                catch (error) {
+                    if (error instanceof Incomplete || error instanceof RelationProblem)
+                        return error.result;
+                    if (error instanceof SemanticError) {
+                        charge(10 + error.message.length);
+                        return Object.freeze({ kind: 'invalid-input', rule: 'cos-particle-restrict', component: error.component, message: error.message });
+                    }
+                    throw error;
+                }
+            }
+            const attempt = () => {
+                // Pair facts may depend on the selected order, so no memo crosses attempts.
+                charge(6);
+                const memo = new Map();
+                const root = [derived.root, base.root];
+                const stack = [{ pair: root, iterator: relation(root), reply: false }];
+                while (stack.length) {
+                    charge(4);
+                    const frame = stack[stack.length - 1], result = frame.iterator.next(frame.reply);
+                    if (result.done) {
+                        debt(result.value);
+                        const [r, b] = frame.pair;
+                        let row = memo.get(r);
+                        if (!row) {
+                            charge(2);
+                            row = new Map();
+                            memo.set(r, row);
+                        }
+                        charge(2);
+                        row.set(b, result.value);
+                        stack.pop();
+                        if (!stack.length)
+                            return result.value;
+                        stack[stack.length - 1].reply = result.value;
+                    }
+                    else {
+                        charge(2);
+                        const pair = result.value, known = memo.get(pair[0])?.get(pair[1]);
+                        if (known !== undefined)
+                            frame.reply = known;
+                        else {
+                            charge(5);
+                            stack.push({ pair, iterator: relation(pair), reply: false });
+                        }
+                    }
+                }
+                return false;
+            };
+            charge(2);
+            const choices = [];
+            let value = false, pending;
+            while (true) {
+                try {
+                    const result = attempt();
+                    if (result === true) {
+                        value = true;
+                        break;
+                    }
+                    pending ??= debt(result);
+                }
+                catch (error) {
+                    if (!(error instanceof NeedOrder))
+                        throw error;
+                    charge(5);
+                    const iterator = permutations(error.enumeration), first = iterator.next();
+                    if (first.done)
+                        throw new Error('Implicit enumeration unexpectedly empty');
+                    assignments.set(error.enumeration.key, first.value);
+                    choices.push({ enumeration: error.enumeration, iterator });
+                    continue;
+                }
+                let next = false;
+                while (choices.length) {
+                    charge(3);
+                    const choice = choices[choices.length - 1], permutation = choice.iterator.next();
+                    charge(2 + choice.enumeration.key.length);
+                    if (!permutation.done) {
+                        assignments.set(choice.enumeration.key, permutation.value);
+                        next = true;
+                        break;
+                    }
+                    assignments.delete(choice.enumeration.key);
+                    choices.pop();
+                }
+                if (!next)
+                    break;
+            }
+            if (!value && pending)
+                return pending;
+            charge(10);
+            return Object.freeze({ kind: 'checked', value, rule: 'cos-particle-restrict', contextId: context.contextId,
+                obligations: Object.freeze(['component-validity', 'particle-local-legality']), typeDependencies: typeDependencies.snapshot(),
+                scalarObligations: budget.freeze(budget.snapshot(scalarObligations)),
+                identityConstraintDependencies: identityConstraintDependencies.snapshot() });
+        }
+        catch (error) {
+            if (error instanceof Incomplete || error instanceof RelationProblem)
+                return error.result;
+            if (error instanceof SemanticError) {
+                budget.chargeWork(10 + error.message.length);
+                return Object.freeze({ kind: 'invalid-input', rule: 'cos-particle-restrict', component: error.component, message: error.message });
+            }
+            throw error;
+        }
+    });
+}

package/dist/compiler/particleSemanticView.d.ts

@@ -0,0 +1,50 @@
+/** Authenticated declared/restriction views; all summaries come from the single S06 occurrence owner. */
+import type { ElementNode, NodeId, Occurs } from './canonicalGraph.js';
+import type { SelectedParticleWildcard } from './schemaParticleWildcardProperties.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { ParticleContentView } from './complexTypeContent.js';
+import type { ParticleSummary } from './occurrenceAnalysis.js';
+import type { RelationFailure } from './schemaTypeRelations.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import type { SemanticTypeDependency } from './semanticTypeReference.js';
+type GroupKind = 'sequence' | 'choice' | 'all';
+/** Explicit positions survive flattening; only each implicit block is a set. */
+export type SemanticParticleOrderBlock = Readonly<{
+    kind: 'explicit';
+    children: readonly SemanticParticle[];
+} | {
+    kind: 'implicit';
+    particle: NodeId;
+    head: NodeId;
+    children: readonly SemanticParticle[];
+}>;
+export type SemanticParticle = Readonly<{
+    id: NodeId;
+    source: NodeId;
+    originalParticle?: NodeId;
+    origins: readonly NodeId[];
+    kind: GroupKind | 'element' | 'any';
+    occurs: Occurs;
+    children: readonly SemanticParticle[];
+    orderBlocks: readonly SemanticParticleOrderBlock[];
+    element?: ElementNode;
+    wildcard?: SelectedParticleWildcard;
+    summary: ParticleSummary;
+    urTypeWildcard: boolean;
+    orderUnspecified: boolean;
+}>;
+export type SemanticParticleView = Readonly<{
+    contextId: string;
+    content: ParticleContentView;
+    purpose: 'declared' | 'restriction';
+    root: SemanticParticle;
+    typeDependencies: readonly SemanticTypeDependency[];
+}>;
+export type ParticleViewResult = Readonly<{
+    kind: 'checked';
+    view: SemanticParticleView;
+}> | RelationFailure | ResourceLimitFailure;
+export declare function assertSemanticParticleView(context: SemanticContext, view: SemanticParticleView): void;
+export declare function prepareSemanticParticleView(context: SemanticContext, content: ParticleContentView, purpose: SemanticParticleView['purpose']): ParticleViewResult;
+export {};
+//# sourceMappingURL=particleSemanticView.d.ts.map

package/dist/compiler/particleSemanticView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particleSemanticView.d.ts","sourceRoot":"","sources":["../../src/compiler/particleSemanticView.ts"],"names":[],"mappings":"AAAA,yGAAyG;AACzG,OAAO,KAAK,EAAC,WAAW,EAAa,MAAM,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAE9F,OAAO,KAAK,EAAC,wBAAwB,EAAC,MAAM,uCAAuC,CAAC;AACpF,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAG1D,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,yBAAyB,CAAC;AAEjE,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,0BAA0B,CAAC;AAE9D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,qBAAqB,CAAC;AAG9D,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,4BAA4B,CAAC;AAEvE,KAAK,SAAS,GAAG,UAAU,GAAG,QAAQ,GAAG,KAAK,CAAC;AAC/C,gFAAgF;AAChF,MAAM,MAAM,0BAA0B,GAAG,QAAQ,CAAC;IAChD,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;CACzD,GAAG;IACF,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;CACzF,CAAC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAClF,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IACpD,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAAC,WAAW,EAAE,SAAS,0BAA0B,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,EAAE,wBAAwB,CAAC;IACtJ,OAAO,EAAE,eAAe,CAAC;IAAC,cAAc,EAAE,OAAO,CAAC;IAAC,gBAAgB,EAAE,OAAO,CAAC;CAC9E,CAAC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,mBAAmB,CAAC;IAAC,OAAO,EAAE,UAAU,GAAG,aAAa,CAAC;IAAC,IAAI,EAAE,gBAAgB,CAAC;IAC7G,gBAAgB,EAAE,SAAS,sBAAsB,EAAE,CAAC;CACrD,CAAC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,oBAAoB,CAAA;CAAC,CAAC,GAAG,eAAe,GAAG,oBAAoB,CAAC;AASlI,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAIrG;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,mBAAmB,EAAE,OAAO,EAAE,oBAAoB,CAAC,SAAS,CAAC,GAAG,kBAAkB,CAsKhK"}