@techspokes/typescript-wsdl-client 1.1.4 → 1.1.5

package/dist/compiler/schemaScalarContext.d.ts

@@ -0,0 +1,81 @@
+/** Compatibility adapter for shared pure schema rules; no aggregate assessment. */
+import type { GraphNode, NodeId, Reference } from './canonicalGraph.js';
+import type { SyntaxSource } from '../loader/orderedSyntax.js';
+import type { SemanticContext } from './semanticContext.js';
+export declare class SchemaOperandContextError extends Error {
+    readonly component: string;
+    readonly rule: string;
+    constructor(component: string, rule: string);
+}
+export declare class SchemaAssessmentError extends Error {
+    readonly category: 'invalid-schema' | 'unsupported-capability' | 'scalar-indeterminate' | 'missing-prerequisite';
+    readonly rule: string;
+    readonly node: GraphNode;
+    readonly source: SyntaxSource;
+    readonly related: readonly SyntaxSource[];
+    constructor(category: 'invalid-schema' | 'unsupported-capability' | 'scalar-indeterminate' | 'missing-prerequisite', rule: string, message: string, node: GraphNode, source?: SyntaxSource, related?: readonly SyntaxSource[]);
+}
+export declare function schemaScalarContext(context: SemanticContext): {
+    context: Readonly<{
+        contextId: string;
+        profileVersion: typeof import("./canonicalGraph.js").GRAPH_MODEL;
+        contractVersion: typeof import("./semanticContext.js").SEMANTIC_CONTEXT_CONTRACT;
+        kind: "actual" | "candidate";
+        acceptance: "structural-only";
+        membership: "complete-actual-plus-additions" | "structural-subset";
+        budget: import("./semanticBudget.js").SemanticBudget;
+        members: readonly NodeId[];
+        scalarSlots: readonly import("./semanticTypeReference.js").OriginalGeneratedScalarReference[];
+        scalarSlotMembership: "complete-original" | "structural-subset";
+        lookupScalarSlot(reference: import("./semanticTypeReference.js").OriginalGeneratedScalarReference): import("./semanticContext.js").ContextScalarSlotLookup;
+        notationMembers: readonly import("../loader/orderedSyntax.js").ExpandedName[];
+        notationMembership: "complete-original-plus-additions" | "structural-subset";
+        notationUniverse: "source-bound" | "retained-only";
+        lookupNotation(name: import("../loader/orderedSyntax.js").ExpandedName): import("./semanticContext.js").ContextNotationLookup;
+        originalIdentityConstraints(): import("./schemaIdentityConstraints.js").OriginalIdentityConstraintRegistry;
+        lookup(id: NodeId): import("./semanticContext.js").ContextLookup;
+        ownTypeReference(reference: import("./semanticTypeReference.js").SemanticTypeReference): import("./semanticTypeReference.js").SemanticTypeReference;
+        resolve(reference: Reference): import("./semanticContext.js").ContextResolution;
+        sourceNode(id: NodeId): GraphNode | undefined;
+        originalSourceComponentAbsent(id: NodeId): boolean;
+        originalComplexPropertySource(id: NodeId): import("./canonicalGraph.js").ComplexTypeNode | undefined;
+        originalComplexContentSource(id: NodeId): import("./canonicalGraph.js").ComplexTypeNode | undefined;
+        originalCompositorChildren(id: NodeId): readonly NodeId[] | undefined;
+        originalUrWildcards(): readonly import("./re01TypeProperties.js").OriginalUrWildcardHandle[];
+        originalUrWildcard(id: NodeId): import("./re01TypeProperties.js").OriginalUrWildcardHandle | undefined;
+        originalContext(): SemanticContext;
+        sourceSchemaRetained(): import("./canonicalGraph.js").CanonicalGraph["schemaRetained"];
+        rawTypeProperties(id: NodeId): import("./re01TypeProperties.js").RawComplexTypeProperties | undefined;
+        rawSimpleTypeProperties(id: NodeId): import("./schemaSimpleTypeProperties.js").RawSimpleTypeProperties | undefined;
+        rawElementProperties(id: NodeId): import("./schemaElementProperties.js").RawElementProperties | undefined;
+        rawAttributeProperties(id: NodeId): import("./schemaAttributeProperties.js").RawAttributeProperties | undefined;
+        rawAttributeGroupProperties(id: NodeId): import("./schemaAttributeGroupProperties.js").RawAttributeGroupProperties | undefined;
+        rawParticleWildcardProperties(id: NodeId): import("./schemaParticleWildcardProperties.js").RawParticleWildcardProperties | undefined;
+        references(id: NodeId): readonly import("./semanticContext.js").SemanticReferenceSlot[];
+        owner(id: NodeId): NodeId | undefined;
+        incomingAffiliates(id: NodeId): readonly NodeId[];
+    }>;
+    notation: (namespace: string, local: string, owner: GraphNode) => void;
+    budget: import("./semanticBudget.js").ResolverBudget;
+    step: (_node?: GraphNode | undefined, count?: number) => void;
+    text: (value: string, node?: GraphNode | undefined) => string;
+    get: (id: NodeId) => GraphNode;
+    target: (reference: Reference, owner: GraphNode) => NodeId | undefined;
+    fail: (node: GraphNode, rule: string, message: string, source?: SyntaxSource, related?: readonly SyntaxSource[]) => never;
+    unsupported: (node: GraphNode, rule: string, message: string, source?: SyntaxSource) => never;
+    unresolved: (node: GraphNode, rule: string, message: string, source?: SyntaxSource) => never;
+    indeterminate: (node: GraphNode, rule: string, source?: SyntaxSource) => never;
+    setCurrent(node: GraphNode): void;
+    algebra: {
+        compare: (a: import("./occurrenceAnalysis.js").Bound, b: import("./occurrenceAnalysis.js").Bound) => number;
+        validate: (range: import("./canonicalGraph.js").Occurs) => void;
+        add: (a: import("./occurrenceAnalysis.js").Bound, b: import("./occurrenceAnalysis.js").Bound) => import("./occurrenceAnalysis.js").Bound;
+        multiply: (a: import("./occurrenceAnalysis.js").Bound, b: import("./occurrenceAnalysis.js").Bound) => import("./occurrenceAnalysis.js").Bound;
+        count: (value: string) => bigint;
+        sum: (a: import("./canonicalGraph.js").Occurs, b: import("./canonicalGraph.js").Occurs) => import("./canonicalGraph.js").Occurs;
+        product: (a: import("./canonicalGraph.js").Occurs, b: import("./canonicalGraph.js").Occurs) => import("./canonicalGraph.js").Occurs;
+        alternative: (a: import("./canonicalGraph.js").Occurs, b: import("./canonicalGraph.js").Occurs) => import("./canonicalGraph.js").Occurs;
+    };
+};
+export type AssessmentContext = ReturnType<typeof schemaScalarContext>;
+//# sourceMappingURL=schemaScalarContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaScalarContext.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaScalarContext.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,OAAO,KAAK,EAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAGtE,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,4BAA4B,CAAC;AAE7D,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAE1D,qBAAa,yBAA0B,SAAQ,KAAK;IACtC,QAAQ,CAAC,SAAS,EAAE,MAAM;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM;gBAAxC,SAAS,EAAE,MAAM,EAAW,IAAI,EAAE,MAAM;CAC9D;AACD,qBAAa,qBAAsB,SAAQ,KAAK;IAClC,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,GAAG,wBAAwB,GAAG,sBAAsB,GAAG,sBAAsB;IAC1H,QAAQ,CAAC,IAAI,EAAE,MAAM;IAAmB,QAAQ,CAAC,IAAI,EAAE,SAAS;IAAE,QAAQ,CAAC,MAAM,EAAE,YAAY;IAC/F,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE;gBAFtB,QAAQ,EAAE,gBAAgB,GAAG,wBAAwB,GAAG,sBAAsB,GAAG,sBAAsB,EACjH,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAW,IAAI,EAAE,SAAS,EAAW,MAAM,GAAE,YAAkC,EAC5G,OAAO,GAAE,SAAS,YAAY,EAAO;CACjD;AACD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BA4B7B,MAAM,SAAS,MAAM,SAAS,SAAS,KAAG,IAAI;;6DAzBhC,IAAI;kBAC1B,MAAM,mCAAmB,MAAM;cACnC,MAAM,KAAG,SAAS;wBAiBR,SAAS,SAAS,SAAS,KAAG,MAAM,GAAG,SAAS;iBAZvD,SAAS,QAAQ,MAAM,WAAW,MAAM,WAAW,YAAY,YAAY,SAAS,YAAY,EAAE,KAAG,KAAK;wBAGnG,SAAS,QAAQ,MAAM,WAAW,MAAM,WAAW,YAAY,KAAG,KAAK;uBAGxE,SAAS,QAAQ,MAAM,WAAW,MAAM,WAAW,YAAY,KAAG,KAAK;0BAGpE,SAAS,QAAQ,MAAM,WAAW,YAAY,KAAG,KAAK;qBAsBhE,SAAS;;;;;;;;;;;EAC7B;AACD,MAAM,MAAM,iBAAiB,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/compiler/schemaScalarContext.js

@@ -0,0 +1,78 @@
+import { occurrenceAlgebra } from './occurrenceAnalysis.js';
+import { checkNotationProperties } from './schemaNotationProperties.js';
+import { assertSemanticContext } from './semanticContext.js';
+export class SchemaOperandContextError extends Error {
+    component;
+    rule;
+    constructor(component, rule) {
+        super('Scalar operand is outside the authenticated context');
+        this.component = component;
+        this.rule = rule;
+    }
+}
+export class SchemaAssessmentError extends Error {
+    category;
+    rule;
+    node;
+    source;
+    related;
+    constructor(category, rule, message, node, source = node.context.source, related = []) {
+        super(message);
+        this.category = category;
+        this.rule = rule;
+        this.node = node;
+        this.source = source;
+        this.related = related;
+        this.name = 'SchemaAssessmentError';
+    }
+}
+export function schemaScalarContext(context) {
+    assertSemanticContext(context);
+    let current;
+    const step = (_node = current, count = 1) => context.budget.chargeWork(count);
+    const text = (value, node = current) => { step(node, 4 * value.length + 1); return value; };
+    const get = (id) => {
+        const result = context.lookup(id);
+        if (result.kind !== 'found')
+            throw new SchemaOperandContextError(id, result.kind);
+        return result.node;
+    };
+    const fail = (node, rule, message, source, related) => {
+        throw new SchemaAssessmentError('invalid-schema', rule, message, node, source, related);
+    };
+    const unsupported = (node, rule, message, source) => {
+        throw new SchemaAssessmentError('unsupported-capability', rule, message, node, source);
+    };
+    const unresolved = (node, rule, message, source) => {
+        throw new SchemaAssessmentError('missing-prerequisite', rule, message, node, source);
+    };
+    const indeterminate = (node, rule, source) => {
+        throw new SchemaAssessmentError('scalar-indeterminate', rule, 'Scalar ordering is indeterminate', node, source);
+    };
+    const target = (reference, owner) => {
+        const result = context.resolve(reference);
+        if (result.kind === 'builtin')
+            return undefined;
+        if (result.kind !== 'found')
+            return unresolved(owner, 'src-resolve', `Reference is ${result.kind}`);
+        return result.node.id;
+    };
+    const notation = (namespace, local, owner) => {
+        text(namespace, owner);
+        text(local, owner);
+        const result = context.lookupNotation({ namespace, local });
+        if (result.kind === 'found') {
+            const properties = checkNotationProperties(result.properties, context.budget);
+            if (properties.kind !== 'checked')
+                return fail(owner, properties.rule, properties.message);
+            return;
+        }
+        if (result.kind === 'unresolved')
+            return unresolved(owner, result.rule, 'NOTATION membership requires complete authenticated component properties');
+        if (result.kind === 'outside-context')
+            return unresolved(owner, 'notation-context-membership', 'NOTATION declaration is outside the active context');
+        return fail(owner, 'cvc-datatype-valid', 'NOTATION operand names no declared notation');
+    };
+    return { context, notation, budget: context.budget, step, text, get, target, fail, unsupported, unresolved, indeterminate,
+        setCurrent(node) { current = node; }, algebra: occurrenceAlgebra(() => step()) };
+}

package/dist/compiler/schemaScalarKernel.d.ts

@@ -0,0 +1,182 @@
+import type { SemanticTypeReference as Reference, SemanticTypeDependency, OriginalGeneratedScalarReference } from './semanticTypeReference.js';
+/** Declared-type schema operand facade. Private primitive assessment also forms facets; payload validation remains #184. */
+import type { LexicalValue, NodeId, ValueConstraint } from './canonicalGraph.js';
+import type { SyntaxSource } from '../loader/orderedSyntax.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import type { ScalarObligation, ScalarFacetAnnotationPresence, ScalarContentProperties, RegularBinaryWordView, PrivateAliasEndpointTupleInput, FiniteImageBinaryWordView } from './scalarSchemaAssessment.js';
+import type { SchemaOperand } from './schemaDatatypeValues.js';
+export type ScalarFailure = Readonly<{
+    kind: 'invalid-schema' | 'unsupported-capability' | 'unresolved';
+    rule: string;
+    message: string;
+    component: NodeId;
+    source?: SyntaxSource;
+    contextId?: string;
+}>;
+export type ScalarResult<T> = Readonly<{
+    kind: 'checked';
+    value: T;
+    contextId: string;
+    authority: 'XSD10-schema-scalars-DT01-A-v1';
+    obligations: readonly ScalarObligation[];
+    typeDependencies: readonly SemanticTypeDependency[];
+}> | ScalarFailure | ResourceLimitFailure;
+export type AssessedSchemaOperand = Readonly<{
+    type: Reference;
+    lexical: LexicalValue;
+    owner: NodeId;
+    operand: SchemaOperand;
+    obligations?: readonly ScalarObligation[];
+}>;
+export type ScalarOrder = 'less' | 'equal' | 'greater' | 'indeterminate';
+export type CrossFacetOperand = Readonly<{
+    contextId: string;
+    reference: Reference;
+    owner: NodeId;
+}>;
+export type CrossFacetObligation = ScalarObligation & Readonly<{
+    contextId: string;
+}>;
+type CrossFacetReceipt = Readonly<{
+    operands: Readonly<{
+        left: CrossFacetOperand;
+        right: CrossFacetOperand;
+    }>;
+    obligations: readonly CrossFacetObligation[];
+    typeDependencies: readonly SemanticTypeDependency[];
+}>;
+export type CrossFacetResult = (CrossFacetReceipt & (Readonly<{
+    kind: 'checked';
+    value: boolean;
+    authority: 'XSD10-schema-scalar-facet-properties-v1';
+    annotationCorrespondence: 'equal' | 'different' | 'unresolved';
+    sourceFacetAnnotations: Readonly<{
+        left: ScalarFacetAnnotationPresence;
+        right: ScalarFacetAnnotationPresence;
+    }>;
+}> | (ScalarFailure & Readonly<{
+    side: 'left' | 'right';
+    contextId: string;
+}>) | Readonly<{
+    kind: 'unresolved';
+    side: 'comparison';
+    rule: string;
+    message: string;
+}>)) | ResourceLimitFailure;
+export type GeneratedScalarReceipt = Readonly<{
+    kind: 'checked';
+    slot: OriginalGeneratedScalarReference;
+    contextId: string;
+    authority: 'XSD10-original-generated-scalar-v1';
+    properties: ScalarContentProperties;
+    typeDependencies: readonly SemanticTypeDependency[];
+    obligations: readonly ScalarObligation[];
+}>;
+export type GeneratedScalarResult = GeneratedScalarReceipt | ScalarFailure | ResourceLimitFailure;
+declare function makeKernel(context: SemanticContext): {
+    finiteImageBinaryWordViews: (views: readonly FiniteImageBinaryWordView[], owner: NodeId) => ScalarResult<import("./scalarSchemaAssessment.js").FiniteImageBinaryWordViews>;
+    regularBinaryWordViews: (views: readonly RegularBinaryWordView[], owner: NodeId) => ScalarResult<import("./scalarSchemaAssessment.js").RegularBinaryWordViews>;
+    privateAliasEndpointAdmission: (reference: Reference, owner: NodeId) => ScalarResult<import("./scalarSchemaAssessment.js").PrivateAliasEndpointAdmission>;
+    privateAliasEndpointTuples: (inputTuple: PrivateAliasEndpointTupleInput, owner: NodeId) => ScalarResult<import("./scalarSchemaAssessment.js").PrivateAliasEndpointTuples>;
+    privateAliasEndpointWordCapacity: (reference: Reference, owner: NodeId) => ScalarResult<{
+        inventory: {
+            ordinal: number;
+            kind: string;
+            fixed: readonly boolean[];
+            annotation: ScalarFacetAnnotationPresence;
+        }[];
+        maskAuthority: "current-atomic-admission";
+        kind: "finite-capacity";
+        family: string;
+        roles: number;
+        formulaLeaves: number;
+        maskStates: number;
+        constants: number;
+        equations: number;
+        tracks: number;
+        fieldStates: import("./schemaEndpointWordCapacity.js").EndpointCapacityExpression;
+        jointStates: import("./schemaEndpointWordCapacity.js").EndpointCapacityExpression;
+        encodedTuple: import("./schemaEndpointWordCapacity.js").EndpointCapacityExpression;
+        maximumWordUnits?: undefined;
+        encodedTupleUnits?: undefined;
+    } | {
+        kind: "finite-ieee-capacity";
+        family: string;
+        roles: number;
+        maximumWordUnits: number;
+        encodedTupleUnits: number;
+        inventory: {
+            ordinal: number;
+            kind: string;
+            fixed: readonly boolean[];
+            annotation: ScalarFacetAnnotationPresence;
+        }[];
+        maskAuthority: "current-ieee-spelling-and-finite-inverse";
+    }>;
+    describe: (reference: Reference, owner: NodeId) => ScalarResult<Readonly<{
+        obligations?: readonly ScalarObligation[];
+        id: NodeId;
+        reference: Reference;
+        variety: "atomic" | "list" | "union";
+        primitive?: string;
+        builtin?: string;
+        item?: Reference;
+        members?: readonly Reference[];
+        layers: readonly import("./scalarSchemaAssessment.js").ScalarConstraintLayer[];
+        declaredMembers?: readonly Reference[];
+        unionMapping?: "xsd10-flattened";
+        whitespace: "preserve" | "replace" | "collapse" | "member";
+        enforcement: readonly import("./scalarSchemaAssessment.js").ScalarEnforcement[];
+        runtimeOwner: "#184";
+        consumers: readonly ["#188", "#189", "#198"];
+    }>>;
+    contentIdentity: (reference: Reference, owner: NodeId) => ScalarResult<{
+        definition: string;
+        reference?: Reference;
+    }>;
+    contentProperties: (reference: Reference, owner: NodeId) => ScalarResult<Readonly<{
+        definition: string;
+        name?: import("../loader/orderedSyntax.js").ExpandedName;
+        targetNamespace: string;
+        final: readonly string[];
+        base?: Reference;
+        variety: "atomic" | "list" | "union" | "absent";
+        primitive?: string;
+        item?: Reference;
+        members?: readonly Reference[];
+        generatedPolicy?: "GSC1";
+        annotation: "absent" | "source";
+    }>>;
+    contentDerivation: (derived: Reference, base: Reference, owner: NodeId) => ScalarResult<boolean>;
+    facetPropertiesEquivalent: (a: Reference, b: Reference, owner: NodeId) => ScalarResult<boolean>;
+    assess: (reference: Reference, lexical: LexicalValue, owner: NodeId) => ScalarResult<AssessedSchemaOperand>;
+    assessValue: (reference: Reference, constraint: ValueConstraint, owner: NodeId) => ScalarResult<AssessedSchemaOperand>;
+    checkValue: (reference: Reference, constraint: ValueConstraint, owner: NodeId) => ScalarResult<{
+        enforcement: import("./scalarSchemaAssessment.js").ScalarEnforcement[];
+        obligations?: readonly ScalarObligation[];
+        id: NodeId;
+        reference: Reference;
+        variety: "atomic" | "list" | "union";
+        primitive?: string;
+        builtin?: string;
+        item?: Reference;
+        members?: readonly Reference[];
+        layers: readonly import("./scalarSchemaAssessment.js").ScalarConstraintLayer[];
+        declaredMembers?: readonly Reference[];
+        unionMapping?: "xsd10-flattened";
+        whitespace: "preserve" | "replace" | "collapse" | "member";
+        runtimeOwner: "#184";
+        consumers: readonly ["#188", "#189", "#198"];
+    }>;
+    equivalent: (aType: Reference, a: LexicalValue, bType: Reference, b: LexicalValue, owner: NodeId) => ScalarResult<boolean>;
+    compare: (aType: Reference, a: LexicalValue, bType: Reference, b: LexicalValue, owner: NodeId) => ScalarResult<ScalarOrder>;
+};
+export declare function createSchemaScalarKernel(context: SemanticContext): ReturnType<typeof makeKernel>;
+/** Facet-only equality of two authentic contexts in one request. Annotations
+ * are reported separately; this is not complete component correspondence. */
+export declare function compareSchemaFacetProperties(leftContext: SemanticContext, leftReference: Reference, leftOwner: NodeId, rightContext: SemanticContext, rightReference: Reference, rightOwner: NodeId): CrossFacetResult;
+export declare function checkOriginalGeneratedScalar(context: SemanticContext, slot: OriginalGeneratedScalarReference): GeneratedScalarResult;
+export declare function assertOriginalGeneratedScalarReceipt(context: SemanticContext, receipt: GeneratedScalarReceipt): void;
+export {};
+//# sourceMappingURL=schemaScalarKernel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaScalarKernel.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaScalarKernel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,qBAAqB,IAAI,SAAS,EAAE,sBAAsB,EAAE,gCAAgC,EAAC,MAAM,4BAA4B,CAAC;AAC7I,4HAA4H;AAC5H,OAAO,KAAK,EAAY,YAAY,EAAE,MAAM,EAAE,eAAe,EAAC,MAAM,qBAAqB,CAAC;AAC1F,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,4BAA4B,CAAC;AAE7D,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,qBAAqB,CAAC;AAG9D,OAAO,KAAK,EAAC,gBAAgB,EAAE,6BAA6B,EAAkD,uBAAuB,EAAqB,qBAAqB,EAAE,8BAA8B,EAAE,yBAAyB,EAAC,MAAM,6BAA6B,CAAC;AAC/Q,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,2BAA2B,CAAC;AAI7D,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,gBAAgB,GAAG,wBAAwB,GAAG,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IACnH,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC;AAClF,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,QAAQ,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,CAAC,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,gCAAgC,CAAC;IAAC,WAAW,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAAC,gBAAgB,EAAC,SAAS,sBAAsB,EAAE,CAAA;CAAC,CAAC,GAAG,aAAa,GAAG,oBAAoB,CAAC;AACzQ,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,aAAa,CAAC;IAAC,WAAW,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAA;CAAC,CAAC,CAAC;AACzK,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,eAAe,CAAC;AACzE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC;AACnG,MAAM,MAAM,oBAAoB,GAAG,gBAAgB,GAAG,QAAQ,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC;AACpF,KAAK,iBAAiB,GAAG,QAAQ,CAAC;IAChC,QAAQ,EAAE,QAAQ,CAAC;QAAC,IAAI,EAAE,iBAAiB,CAAC;QAAC,KAAK,EAAE,iBAAiB,CAAA;KAAC,CAAC,CAAC;IACxE,WAAW,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAC7C,gBAAgB,EAAC,SAAS,sBAAsB,EAAE,CAAC;CACpD,CAAC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,iBAAiB,GAAG,CAClD,QAAQ,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,yCAAyC,CAAC;IAC9F,wBAAwB,EAAC,OAAO,GAAC,WAAW,GAAC,YAAY,CAAC;IAC1D,sBAAsB,EAAE,QAAQ,CAAC;QAAC,IAAI,EAAE,6BAA6B,CAAC;QAAC,KAAK,EAAE,6BAA6B,CAAA;KAAC,CAAC,CAAA;CAAC,CAAC,GAC/G,CAAC,aAAa,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC,GACvE,QAAQ,CAAC;IAAC,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC,CACpF,CAAC,GAAG,oBAAoB,CAAC;AAU1B,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAC,SAAS,CAAC;IAAA,IAAI,EAAC,gCAAgC,CAAC;IAAA,SAAS,EAAC,MAAM,CAAC;IAAA,SAAS,EAAC,oCAAoC,CAAC;IAAA,UAAU,EAAC,uBAAuB,CAAC;IAAA,gBAAgB,EAAC,SAAS,sBAAsB,EAAE,CAAC;IAAA,WAAW,EAAC,SAAS,gBAAgB,EAAE,CAAA;CAAC,CAAC,CAAC;AACpS,MAAM,MAAM,qBAAqB,GAAG,sBAAsB,GAAC,aAAa,GAAC,oBAAoB,CAAC;AAI9F,iBAAS,UAAU,CAAC,OAAO,EAAE,eAAe;wCAgLJ,SAAS,yBAAyB,EAAE,SAAS,MAAM;oCASvD,SAAS,qBAAqB,EAAE,SAAS,MAAM;+CASpC,SAAS,SAAS,MAAM;6CAI1B,8BAA8B,SAAS,MAAM;kDASxC,SAAS,SAAS,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAIhD,SAAS,SAAS,MAAM;;;;;;;;;;;;;;;;;iCA3GZ,SAAS,SAAS,MAAM,KAAG,YAAY,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAA,SAAS,CAAC,EAAC,SAAS,CAAA;KAAC,CAAC;mCA6GpF,SAAS,SAAS,MAAM;;;;;;;;;;;;;iCAC1B,SAAS,QAAQ,SAAS,SAAS,MAAM;mCACvC,SAAS,KAAK,SAAS,SAAS,MAAM;wBA1H5C,SAAS,WAAW,YAAY,SAAS,MAAM,KAAG,YAAY,CAAC,qBAAqB,CAAC;6BAKhF,SAAS,cAAc,eAAe,SAAS,MAAM,KAAG,YAAY,CAAC,qBAAqB,CAAC;4BAuHjG,SAAS,cAAc,eAAe,SAAS,MAAM;;;;;;;;;;;;;;;;;wBACzD,SAAS,KAAK,YAAY,SAAS,SAAS,KAAK,YAAY,SAAS,MAAM,KAAG,YAAY,CAAC,OAAO,CAAC;qBAEvG,SAAS,KAAK,YAAY,SAAS,SAAS,KAAK,YAAY,SAAS,MAAM,KAAG,YAAY,CAAC,WAAW,CAAC;EAM5H;AACD,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,eAAe,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAGhG;AAED;6EAC6E;AAC7E,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,eAAe,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EACzE,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,GAC3E,gBAAgB,CA0DlB;AAED,wBAAgB,4BAA4B,CAAC,OAAO,EAAC,eAAe,EAAC,IAAI,EAAC,gCAAgC,GAAE,qBAAqB,CAEhI;AACD,wBAAgB,oCAAoC,CAAC,OAAO,EAAC,eAAe,EAAC,OAAO,EAAC,sBAAsB,GAAE,IAAI,CAEhH"}