@techspokes/typescript-wsdl-client 1.1.4 → 1.1.5

package/dist/compiler/schemaIntegerImages.d.ts

@@ -0,0 +1,11 @@
+/** Finite decimal carry products for images of nonnegative integer fields. */
+import type { RegularLanguage } from './schemaRegularLanguage.js';
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+import type { SchemaPatternContext } from './schemaValueContext.js';
+export declare function schemaIntegerImages<Owner>(c: SchemaPatternContext<Owner>, regular: ReturnType<typeof schemaRegularLanguages<Owner>>, expression: (text: string, owner: Owner) => RegularLanguage): {
+    sum: (inputs: readonly {
+        language: RegularLanguage;
+        weight: number;
+    }[], owner: Owner, initialCarry?: number) => RegularLanguage;
+};
+//# sourceMappingURL=schemaIntegerImages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaIntegerImages.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaIntegerImages.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAC,sBAAsB,EAAC,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,yBAAyB,CAAC;AAElE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,CAAC,EAAE,oBAAoB,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,KAAK,CAAC,CAAC,EAClI,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,eAAe;kBACtC,SAAS;QAAC,QAAQ,EAAE,eAAe,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,EAAE,SAAS,KAAK,4BAAqB,eAAe;EA6D9H"}

package/dist/compiler/schemaIntegerImages.js

@@ -0,0 +1,113 @@
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+export function schemaIntegerImages(c, regular, expression) {
+    const sum = (inputs, owner, initialCarry = 0) => {
+        c.step(owner, inputs.length * 2 + 4);
+        c.step(owner, inputs.length + 2);
+        if (!Number.isSafeInteger(initialCarry) || inputs.some(input => !Number.isSafeInteger(input.weight) || input.weight < 0)
+            || !Number.isSafeInteger(inputs.reduce((sum, input) => sum + input.weight * 9, Math.abs(initialCarry))))
+            throw new TypeError('Integer image weights and carry must use exact safe arithmetic');
+        const programs = inputs.map(input => regular.automaton(regular.reverse(input.language, owner), owner));
+        c.step(owner, programs.length * 2 + 3);
+        const productive = programs.map(program => {
+            c.step(owner, program.states.length * 3 + 4);
+            const incoming = program.states.map(() => []), useful = new Set(), pending = [];
+            for (let from = 0; from < program.states.length; from++) {
+                if (program.states[from].accepting) {
+                    c.step(owner, 2);
+                    useful.add(from);
+                    pending.push(from);
+                }
+                for (const edge of program.states[from].transitions)
+                    if (edge.lo <= 57 && edge.hi >= 48) {
+                        c.step(owner);
+                        incoming[edge.to].push(from);
+                    }
+            }
+            while (pending.length) {
+                c.step(owner);
+                const state = pending.pop();
+                for (const from of incoming[state]) {
+                    c.step(owner);
+                    if (!useful.has(from)) {
+                        c.step(owner, 2);
+                        useful.add(from);
+                        pending.push(from);
+                    }
+                }
+            }
+            return useful;
+        });
+        if (programs.some((program, index) => !productive[index].has(program.start)))
+            return regular.union([], owner);
+        c.step(owner, programs.length + 6);
+        const states = [{ positions: programs.map(program => program.start), carry: initialCarry }], edges = [[]];
+        const identity = (state) => { c.step(owner, state.positions.length * 16 + 32); return JSON.stringify(state); };
+        c.step(owner, 3);
+        const seen = new Map([[identity(states[0]), 0]]), accepted = [];
+        for (let cursor = 0; cursor < states.length; cursor++) {
+            c.step(owner, inputs.length + 2);
+            const state = states[cursor];
+            if (state.carry === 0 && state.positions.every((position, index) => position === -1 || programs[index].states[position].accepting))
+                accepted.push(cursor);
+            c.step(owner, inputs.length * 2 + 3);
+            const choices = [];
+            for (let index = 0; index < inputs.length; index++) {
+                const position = state.positions[index];
+                c.step(owner, 2);
+                const row = [];
+                if (position === -1 || programs[index].states[position].accepting) {
+                    c.step(owner, 2);
+                    row.push({ digit: 0, to: -1 });
+                }
+                if (position !== -1)
+                    for (const edge of programs[index].states[position].transitions) {
+                        c.step(owner);
+                        if (!productive[index].has(edge.to))
+                            continue;
+                        for (let cp = Math.max(48, edge.lo); cp <= Math.min(57, edge.hi); cp++) {
+                            c.step(owner, 2);
+                            row.push({ digit: cp - 48, to: edge.to });
+                        }
+                    }
+                choices.push(row);
+            }
+            c.step(owner, 4);
+            const frontier = [{ index: 0, value: state.carry, positions: [] }];
+            while (frontier.length) {
+                c.step(owner);
+                const frame = frontier.pop();
+                if (frame.index !== inputs.length) {
+                    for (const option of choices[frame.index]) {
+                        c.step(owner, frame.positions.length + 5);
+                        frontier.push({ index: frame.index + 1,
+                            value: frame.value + option.digit * inputs[frame.index].weight, positions: [...frame.positions, option.to] });
+                    }
+                    continue;
+                }
+                c.step(owner, 6);
+                const digit = (frame.value % 10 + 10) % 10, next = { positions: frame.positions, carry: Math.floor(frame.value / 10) }, key = identity(next);
+                let to = seen.get(key);
+                if (to === undefined) {
+                    c.step(owner, key.length + 6);
+                    to = states.length;
+                    states.push(next);
+                    edges.push([]);
+                    seen.set(key, to);
+                }
+                c.step(owner, 4);
+                edges[cursor].push({ to, ranges: [[48 + digit, 48 + digit]] });
+            }
+        }
+        c.step(owner, accepted.length * 3 + 3);
+        const end = edges.length;
+        edges.push([]);
+        for (const state of accepted)
+            edges[state].push({ to: end });
+        const raw = regular.reverse(regular.fromNfa({ edges, start: 0, end }, owner), owner), choices = [];
+        if (regular.witness(regular.intersect([raw, expression('0*', owner)], owner), owner) !== undefined)
+            choices.push(expression('0', owner));
+        choices.push(regular.intersect([regular.quotient(raw, expression('0*', owner), expression('', owner), owner), expression('[1-9][0-9]*', owner)], owner));
+        return regular.union(choices, owner);
+    };
+    return { sum };
+}

package/dist/compiler/schemaLexicalPredicates.d.ts

@@ -0,0 +1,29 @@
+/** Finite Boolean products of regular syntax and exact numeric input guards. */
+import type { RegularLanguage } from './schemaRegularLanguage.js';
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+import type { NumericImageCondition } from './schemaNumericImageConditions.js';
+import { schemaNumericImageConditions } from './schemaNumericImageConditions.js';
+import type { SchemaPatternContext } from './schemaValueContext.js';
+export type LexicalPredicate = Readonly<{
+    kind: 'regular';
+    language: RegularLanguage;
+}> | Readonly<{
+    kind: 'numeric';
+    condition: NumericImageCondition;
+}> | Readonly<{
+    kind: 'and' | 'or';
+    children: readonly LexicalPredicate[];
+}> | Readonly<{
+    kind: 'not';
+    child: LexicalPredicate;
+}>;
+export type LexicalBranch = Readonly<{
+    language: RegularLanguage;
+    numeric: NumericImageCondition;
+}>;
+export declare function schemaLexicalPredicates<Owner>(c: SchemaPatternContext<Owner>, regular: ReturnType<typeof schemaRegularLanguages<Owner>>, numeric: ReturnType<typeof schemaNumericImageConditions<Owner>>): {
+    branches: (predicate: LexicalPredicate, source: RegularLanguage, owner: Owner) => readonly LexicalBranch[];
+    exists: (predicate: LexicalPredicate, source: RegularLanguage, owner: Owner) => boolean;
+    witness: (predicate: LexicalPredicate, source: RegularLanguage, owner: Owner) => string | undefined;
+};
+//# sourceMappingURL=schemaLexicalPredicates.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaLexicalPredicates.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaLexicalPredicates.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAC,sBAAsB,EAAC,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAAC,4BAA4B,EAAC,MAAM,mCAAmC,CAAC;AAC/E,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,yBAAyB,CAAC;AAElE,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAA;CAAC,CAAC,GACnF,QAAQ,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,qBAAqB,CAAA;CAAC,CAAC,GAC7D,QAAQ,CAAC;IAAC,IAAI,EAAE,KAAK,GAAG,IAAI,CAAC;IAAC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAA;CAAC,CAAC,GACrE,QAAQ,CAAC;IAAC,IAAI,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,gBAAgB,CAAA;CAAC,CAAC,CAAC;AACnD,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAC;IAAC,OAAO,EAAE,qBAAqB,CAAA;CAAC,CAAC,CAAC;AAClG,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,CAAC,EAAE,oBAAoB,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,KAAK,CAAC,CAAC,EACtI,OAAO,EAAE,UAAU,CAAC,OAAO,4BAA4B,CAAC,KAAK,CAAC,CAAC;0BAClC,gBAAgB,UAAU,eAAe,SAAS,KAAK,KAAG,SAAS,aAAa,EAAE;wBA2BpF,gBAAgB,UAAU,eAAe,SAAS,KAAK,KAAG,OAAO;yBAIhE,gBAAgB,UAAU,eAAe,SAAS,KAAK,KAAG,MAAM,GAAG,SAAS;EAOzG"}

package/dist/compiler/schemaLexicalPredicates.js

@@ -0,0 +1,63 @@
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+import { schemaNumericImageConditions } from './schemaNumericImageConditions.js';
+export function schemaLexicalPredicates(c, regular, numeric) {
+    const branches = (predicate, source, owner) => {
+        c.step(owner, 6);
+        const pending = [{ tasks: [{ predicate, negative: false }], branch: { language: source, numeric: numeric.all() } }], result = [];
+        while (pending.length) {
+            c.step(owner);
+            const frame = pending.pop();
+            if (!frame.tasks.length) {
+                c.step(owner);
+                result.push(frame.branch);
+                continue;
+            }
+            c.step(owner, frame.tasks.length + 2);
+            const [task, ...remaining] = frame.tasks, node = task.predicate;
+            if (node.kind === 'not') {
+                c.step(owner, remaining.length + 4);
+                pending.push({ ...frame, tasks: [{ predicate: node.child, negative: !task.negative }, ...remaining] });
+            }
+            else if (node.kind === 'regular') {
+                const language = regular.intersect([frame.branch.language, task.negative ? regular.negate(node.language, owner) : node.language], owner);
+                if (regular.witness(language, owner) !== undefined) {
+                    c.step(owner, 4);
+                    pending.push({ tasks: remaining, branch: { ...frame.branch, language } });
+                }
+            }
+            else if (node.kind === 'numeric') {
+                const condition = task.negative ? numeric.difference(numeric.all(), node.condition, owner) : node.condition;
+                c.step(owner, 4);
+                pending.push({ tasks: remaining, branch: { ...frame.branch, numeric: numeric.intersection(frame.branch.numeric, condition, owner) } });
+            }
+            else {
+                const disjunction = task.negative ? node.kind === 'and' : node.kind === 'or';
+                if (disjunction)
+                    for (const child of node.children) {
+                        c.step(owner, remaining.length + 4);
+                        pending.push({ ...frame, tasks: [{ predicate: child, negative: task.negative }, ...remaining] });
+                    }
+                else {
+                    c.step(owner, node.children.length * 3 + remaining.length + 3);
+                    pending.push({ ...frame, tasks: [...node.children.map(predicate => ({ predicate, negative: task.negative })), ...remaining] });
+                }
+            }
+        }
+        return result;
+    };
+    const exists = (predicate, source, owner) => {
+        for (const branch of branches(predicate, source, owner))
+            if (numeric.exists(branch.language, branch.numeric, owner))
+                return true;
+        return false;
+    };
+    const witness = (predicate, source, owner) => {
+        for (const branch of branches(predicate, source, owner)) {
+            const word = numeric.witness(branch.language, branch.numeric, owner);
+            if (word !== undefined)
+                return word;
+        }
+        return undefined;
+    };
+    return { branches, exists, witness };
+}

package/dist/compiler/schemaNotationProperties.d.ts

@@ -0,0 +1,32 @@
+/** Shared notation property mapping and rules; never source/context authority. */
+import type { ExpandedName, SyntaxElement } from '../loader/orderedSyntax.js';
+import type { SchemaInterpretation } from '../loader/schemaInput.js';
+import type { SemanticBudget } from './semanticBudget.js';
+export type SchemaNotationProperties = Readonly<{
+    name: ExpandedName;
+    publicIdentifier: string | undefined;
+    systemIdentifier: string | undefined;
+}>;
+export type NotationPropertyFailure = Readonly<{
+    kind: 'invalid-schema';
+    rule: 'n-props-correct';
+    message: string;
+}>;
+export type SourceNotationProperties = Readonly<{
+    kind: 'properties';
+    properties: SchemaNotationProperties;
+}> | NotationPropertyFailure;
+declare const checked: Readonly<{
+    kind: "checked";
+}>;
+/** Source target-namespace mapping, including chameleon include interpretation. */
+export declare function sourceNotationNamespace(schema: SchemaInterpretation, budget: SemanticBudget): string;
+/** XML source mapping only. Invalid named tuples remain available for reservation. */
+export declare function readSourceNotationProperties(syntax: SyntaxElement, effectiveNamespace: string, budget: SemanticBudget): SourceNotationProperties;
+/** Abstract values are checked as supplied, without source normalization/repair. */
+export declare function checkNotationProperties(properties: SchemaNotationProperties, budget: SemanticBudget): typeof checked | NotationPropertyFailure;
+export declare function notationNameKey(name: ExpandedName, budget: SemanticBudget): string;
+/** Complete property equality: absent identifiers never fill from another tuple. */
+export declare function equalNotationProperties(left: SchemaNotationProperties, right: SchemaNotationProperties, budget: SemanticBudget): boolean;
+export {};
+//# sourceMappingURL=schemaNotationProperties.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaNotationProperties.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaNotationProperties.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,OAAO,KAAK,EAAC,YAAY,EAAE,aAAa,EAAC,MAAM,4BAA4B,CAAC;AAC5E,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,0BAA0B,CAAC;AAInE,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAExD,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC9C,IAAI,EAAE,YAAY,CAAC;IACnB,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC,CAAC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAC7C,IAAI,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;CAClE,CAAC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,YAAY,CAAC;IAAC,UAAU,EAAE,wBAAwB,CAAA;CAAC,CAAC,GAAG,uBAAuB,CAAC;AACtI,QAAA,MAAM,OAAO;;EAA4C,CAAC;AAM1D,mFAAmF;AACnF,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,cAAc,GAAG,MAAM,CAYpG;AAED,sFAAsF;AACtF,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,GAAG,wBAAwB,CAoBhJ;AAED,oFAAoF;AACpF,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,wBAAwB,EAAE,MAAM,EAAE,cAAc,GAAG,OAAO,OAAO,GAAG,uBAAuB,CAa9I;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,cAAc,GAAG,MAAM,CAGlF;AAED,oFAAoF;AACpF,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,wBAAwB,EAAE,KAAK,EAAE,wBAAwB,EAAE,MAAM,EAAE,cAAc,GAAG,OAAO,CAMxI"}

package/dist/compiler/schemaNotationProperties.js

@@ -0,0 +1,84 @@
+import { isXmlNCName } from '../loader/orderedSyntax.js';
+import { normalizeWhitespace } from '../util/xmlWhitespace.js';
+import { schemaUri } from './schemaUri.js';
+const checked = Object.freeze({ kind: 'checked' });
+function failure(message, budget) {
+    budget.chargeWork(64 + message.length);
+    return Object.freeze({ kind: 'invalid-schema', rule: 'n-props-correct', message });
+}
+/** Source target-namespace mapping, including chameleon include interpretation. */
+export function sourceNotationNamespace(schema, budget) {
+    for (const attribute of schema.syntax.attributes) {
+        budget.chargeWork(6 + attribute.name.namespace.length + attribute.name.local.length);
+        if (attribute.name.namespace === '' && attribute.name.local === 'targetNamespace') {
+            budget.chargeWork(2 + 4 * attribute.value.length);
+            return normalizeWhitespace(attribute.value, 'collapse');
+        }
+    }
+    budget.chargeWork(2);
+    if (schema.context.kind !== 'include')
+        return '';
+    budget.chargeWork(2 + 4 * schema.context.namespace.length);
+    return normalizeWhitespace(schema.context.namespace, 'collapse');
+}
+/** XML source mapping only. Invalid named tuples remain available for reservation. */
+export function readSourceNotationProperties(syntax, effectiveNamespace, budget) {
+    let local, publicIdentifier, systemIdentifier;
+    for (const attribute of syntax.attributes) {
+        budget.chargeWork(8 + attribute.name.namespace.length + attribute.name.local.length);
+        if (attribute.name.namespace !== '')
+            continue;
+        const field = attribute.name.local;
+        if (field !== 'name' && field !== 'public' && field !== 'system')
+            continue;
+        budget.chargeWork(2 + 4 * attribute.value.length);
+        const value = normalizeWhitespace(attribute.value, 'collapse');
+        if (field === 'name' && local === undefined)
+            local = value;
+        else if (field === 'public' && publicIdentifier === undefined)
+            publicIdentifier = value;
+        else if (field === 'system' && systemIdentifier === undefined)
+            systemIdentifier = value;
+    }
+    if (local === undefined)
+        return failure('Notation requires a name property', budget);
+    budget.chargeWork(2 + 4 * effectiveNamespace.length);
+    const namespace = normalizeWhitespace(effectiveNamespace, 'collapse');
+    budget.chargeWork(96); // Mapped QName, complete tuple, result and their frozen fields.
+    return Object.freeze({ kind: 'properties', properties: Object.freeze({
+            name: Object.freeze({ namespace, local }), publicIdentifier, systemIdentifier,
+        }) });
+}
+/** Abstract values are checked as supplied, without source normalization/repair. */
+export function checkNotationProperties(properties, budget) {
+    const { name, publicIdentifier, systemIdentifier } = properties;
+    budget.chargeWork(12 + name.local.length * 4);
+    if (!isXmlNCName(name.local))
+        return failure('Notation name must be an XML NCName', budget);
+    const step = (_owner, count = 1) => budget.chargeWork(count);
+    if (name.namespace !== '' && !schemaUri(name.namespace, properties, { step }))
+        return failure('Notation namespace must be a URI reference or absent', budget);
+    if (publicIdentifier === undefined && systemIdentifier === undefined)
+        return failure('Notation requires a public or system identifier', budget);
+    if (publicIdentifier !== undefined) {
+        budget.chargeWork(2 + 4 * publicIdentifier.length);
+        if (!/^[\r\na-zA-Z0-9 \-'()+,.\/:=?;!*#@$_%]*$/.test(publicIdentifier))
+            return failure('Notation public identifier has an invalid XML PubidChar', budget);
+    }
+    if (systemIdentifier !== undefined && !schemaUri(systemIdentifier, properties, { step }))
+        return failure('Notation system identifier must be a URI reference', budget);
+    budget.chargeWork();
+    return checked;
+}
+export function notationNameKey(name, budget) {
+    budget.chargeWork(30 + 6 * (name.namespace.length + name.local.length));
+    return JSON.stringify([name.namespace, name.local]);
+}
+/** Complete property equality: absent identifiers never fill from another tuple. */
+export function equalNotationProperties(left, right, budget) {
+    budget.chargeWork(16 + left.name.namespace.length + right.name.namespace.length + left.name.local.length + right.name.local.length +
+        (left.publicIdentifier?.length ?? 0) + (right.publicIdentifier?.length ?? 0) +
+        (left.systemIdentifier?.length ?? 0) + (right.systemIdentifier?.length ?? 0));
+    return left.name.namespace === right.name.namespace && left.name.local === right.name.local &&
+        left.publicIdentifier === right.publicIdentifier && left.systemIdentifier === right.systemIdentifier;
+}

package/dist/compiler/schemaNumericImageConditions.d.ts

@@ -0,0 +1,24 @@
+/** Boolean numeric guards carried through value-invariant lexical images. */
+import type { IeeeInputInterval } from './schemaIeeeLanguage.js';
+import { schemaIeeeLanguages } from './schemaIeeeLanguage.js';
+import type { RegularLanguage } from './schemaRegularLanguage.js';
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+import type { SchemaPatternContext } from './schemaValueContext.js';
+export type NumericImageCondition = Readonly<{
+    intervals: readonly IeeeInputInterval[];
+    literals: readonly string[];
+    nonNumeric: boolean;
+}>;
+export declare function schemaNumericImageConditions<Owner>(c: SchemaPatternContext<Owner>, regular: ReturnType<typeof schemaRegularLanguages<Owner>>, ieee: ReturnType<typeof schemaIeeeLanguages<Owner>>, expression: (text: string, owner: Owner) => RegularLanguage): {
+    all: () => NumericImageCondition;
+    difference: (a: NumericImageCondition, b: NumericImageCondition, owner: Owner) => NumericImageCondition;
+    intersection: (a: NumericImageCondition, b: NumericImageCondition, owner: Owner) => Readonly<{
+        intervals: readonly IeeeInputInterval[];
+        literals: readonly string[];
+        nonNumeric: boolean;
+    }>;
+    exists: (language: RegularLanguage, condition: NumericImageCondition, owner: Owner) => boolean;
+    numericWitness: (language: RegularLanguage, condition: NumericImageCondition, owner: Owner) => string | undefined;
+    witness: (language: RegularLanguage, condition: NumericImageCondition, owner: Owner) => string | undefined;
+};
+//# sourceMappingURL=schemaNumericImageConditions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaNumericImageConditions.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaNumericImageConditions.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,yBAAyB,CAAC;AAC/D,OAAO,EAAC,mBAAmB,EAAC,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAC,sBAAsB,EAAC,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,yBAAyB,CAAC;AAElE,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAAC,SAAS,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAC,CAAC,CAAC;AAC1I,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,CAAC,EAAE,oBAAoB,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,KAAK,CAAC,CAAC,EAC3I,IAAI,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,eAAe;eAChG,qBAAqB;oBACd,qBAAqB,KAAK,qBAAqB,SAAS,KAAK,KAAG,qBAAqB;sBAInF,qBAAqB,KAAK,qBAAqB,SAAS,KAAK;mBAR/B,SAAS,iBAAiB,EAAE;kBAAY,SAAS,MAAM,EAAE;oBAAc,OAAO;;uBAU3G,eAAe,aAAa,qBAAqB,SAAS,KAAK,KAAG,OAAO;+BAejE,eAAe,aAAa,qBAAqB,SAAS,KAAK,KAAG,MAAM,GAAG,SAAS;wBAS3F,eAAe,aAAa,qBAAqB,SAAS,KAAK,KAAG,MAAM,GAAG,SAAS;EAiBhH"}

package/dist/compiler/schemaNumericImageConditions.js

@@ -0,0 +1,66 @@
+import { schemaIeeeLanguages } from './schemaIeeeLanguage.js';
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+export function schemaNumericImageConditions(c, regular, ieee, expression) {
+    const all = () => ({ intervals: [{ negative: false }, { negative: true }], literals: ['INF', '-INF', 'NaN'], nonNumeric: true });
+    const difference = (a, b, owner) => {
+        c.step(owner, a.literals.length + b.literals.length + 4);
+        return { intervals: ieee.subtractIntervals(a.intervals, b.intervals, owner), literals: a.literals.filter(value => !b.literals.includes(value)), nonNumeric: a.nonNumeric && !b.nonNumeric };
+    };
+    const intersection = (a, b, owner) => difference(a, difference(all(), b, owner), owner);
+    const grammar = (owner) => expression('INF|\\-INF|NaN|[+\\-]?([0-9]+([.][0-9]*)?|[.][0-9]+)([eE][+\\-]?[0-9]+)?', owner);
+    const exists = (language, condition, owner) => {
+        c.step(owner, condition.intervals.length + condition.literals.length + 4);
+        if (condition.nonNumeric && ['INF', '-INF', 'NaN'].every(value => condition.literals.includes(value))
+            && [false, true].every(negative => condition.intervals.some(interval => interval.negative === negative && !interval.lower && !interval.upper)))
+            return regular.witness(language, owner) !== undefined;
+        if (condition.nonNumeric && regular.witness(regular.intersect([language,
+            regular.negate(regular.whitespacePreimage(grammar(owner), 'collapse', owner), owner)], owner), owner) !== undefined)
+            return true;
+        for (const literal of condition.literals) {
+            const inverse = regular.whitespacePreimage(expression(literal === '-INF' ? '\\-INF' : literal, owner), 'collapse', owner);
+            if (regular.witness(regular.intersect([language, inverse], owner), owner) !== undefined)
+                return true;
+        }
+        const normalized = regular.whitespaceImage(language, 'collapse', owner);
+        for (const interval of condition.intervals)
+            if (ieee.intervalWitness(normalized, interval, owner) !== undefined)
+                return true;
+        return false;
+    };
+    const numericWitness = (language, condition, owner) => {
+        const normalized = regular.whitespaceImage(language, 'collapse', owner);
+        for (const literal of condition.literals) {
+            const word = regular.witness(regular.intersect([normalized, expression(literal === '-INF' ? '\\-INF' : literal, owner)], owner), owner);
+            if (word !== undefined)
+                return word;
+        }
+        for (const interval of condition.intervals) {
+            const word = ieee.intervalWitness(normalized, interval, owner);
+            if (word !== undefined)
+                return word;
+        }
+        return undefined;
+    };
+    const witness = (language, condition, owner) => {
+        c.step(owner, condition.intervals.length + condition.literals.length + 4);
+        if (condition.nonNumeric && ['INF', '-INF', 'NaN'].every(value => condition.literals.includes(value))
+            && [false, true].every(negative => condition.intervals.some(interval => interval.negative === negative && !interval.lower && !interval.upper)))
+            return regular.witness(language, owner);
+        if (condition.nonNumeric) {
+            const word = regular.witness(regular.intersect([language, regular.negate(regular.whitespacePreimage(grammar(owner), 'collapse', owner), owner)], owner), owner);
+            if (word !== undefined)
+                return word;
+        }
+        const normalized = numericWitness(language, condition, owner);
+        if (normalized === undefined)
+            return undefined;
+        c.text(normalized, owner);
+        c.step(owner, normalized.length * 3 + 4);
+        const quoted = normalized.replace(/[\\.\-^?*+{}()\[\]|]/g, '\\$&');
+        const raw = regular.witness(regular.intersect([language, regular.whitespacePreimage(expression(quoted, owner), 'collapse', owner)], owner), owner);
+        if (raw === undefined)
+            throw new TypeError('A normalized numeric witness must have a raw preimage');
+        return raw;
+    };
+    return { all, difference, intersection, exists, numericWitness, witness };
+}

package/dist/compiler/schemaParticleWildcardProperties.d.ts

@@ -0,0 +1,20 @@
+/** Fresh abstract particle properties, distinct from canonical XML wildcard spelling and native origin. */
+import type { LexicalValue, NodeId, ParticleNode } from './canonicalGraph.js';
+import type { SemanticBudget } from './semanticBudget.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { NamespaceConstraint, WildcardProcess } from './wildcardAlgebra.js';
+export type RawParticleWildcardProperties = Readonly<{
+    particle: NodeId;
+    namespace: NamespaceConstraint;
+    processContents: WildcardProcess;
+}>;
+export type SelectedParticleWildcard = Readonly<{
+    namespace: NamespaceConstraint;
+    processContents: WildcardProcess;
+    /** Source spelling is diagnostic data, never the selected abstract namespace property. */
+    lexical: LexicalValue;
+}>;
+export declare function prepareRawParticleWildcardProperties(input: unknown, budget: SemanticBudget): RawParticleWildcardProperties;
+/** All semantic particle owners select the same tuple; source-private inputs stay lexical. */
+export declare function readParticleWildcard(context: SemanticContext, particle: ParticleNode): SelectedParticleWildcard;
+//# sourceMappingURL=schemaParticleWildcardProperties.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaParticleWildcardProperties.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaParticleWildcardProperties.ts"],"names":[],"mappings":"AAAA,2GAA2G;AAC3G,OAAO,KAAK,EAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAC,MAAM,qBAAqB,CAAC;AAC5E,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAC,mBAAmB,EAAE,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAE/E,MAAM,MAAM,6BAA6B,GAAG,QAAQ,CAAC;IACnD,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,mBAAmB,CAAC;IAAC,eAAe,EAAE,eAAe,CAAC;CACpF,CAAC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC9C,SAAS,EAAE,mBAAmB,CAAC;IAAC,eAAe,EAAE,eAAe,CAAC;IACjE,0FAA0F;IAC1F,OAAO,EAAE,YAAY,CAAC;CACvB,CAAC,CAAC;AAEH,wBAAgB,oCAAoC,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,cAAc,GAAG,6BAA6B,CAqB1H;AAED,8FAA8F;AAC9F,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,YAAY,GAAG,wBAAwB,CAQ/G"}

package/dist/compiler/schemaParticleWildcardProperties.js

@@ -0,0 +1,43 @@
+import { canonicalNamespaceConstraint, wildcardNamespaces } from './wildcardAlgebra.js';
+export function prepareRawParticleWildcardProperties(input, budget) {
+    const value = budget.snapshot(input);
+    const object = (item) => !!item && typeof item === 'object' && !Array.isArray(item);
+    const fields = (item, names) => {
+        budget.chargeWork(3);
+        let count = 0;
+        for (const key in item) {
+            budget.chargeWork(1 + key.length);
+            if (!names.includes(key))
+                return false;
+            count++;
+        }
+        return count === names.length;
+    };
+    budget.chargeWork(12);
+    if (!object(value) || !fields(value, ['particle', 'namespace', 'processContents']) || typeof value.particle !== 'string'
+        || !object(value.namespace) || !fields(value.namespace, ['kind', 'namespaces'])
+        || value.namespace.kind !== 'set' && value.namespace.kind !== 'not' || !Array.isArray(value.namespace.namespaces)
+        || !['strict', 'lax', 'skip'].includes(value.processContents))
+        throw new TypeError('Invalid particle wildcard properties');
+    budget.chargeWork(value.particle.length + value.namespace.namespaces.length + 3);
+    for (const namespace of value.namespace.namespaces) {
+        budget.chargeWork();
+        if (typeof namespace !== 'string')
+            throw new TypeError('Invalid namespace property');
+        budget.chargeWork(namespace.length);
+    }
+    const namespace = canonicalNamespaceConstraint(value.namespace, budget.chargeWork);
+    budget.chargeWork(5);
+    return budget.freeze({ particle: value.particle, namespace, processContents: value.processContents });
+}
+/** All semantic particle owners select the same tuple; source-private inputs stay lexical. */
+export function readParticleWildcard(context, particle) {
+    if (particle.term.kind !== 'any')
+        throw new TypeError('An ANY particle is required');
+    const budget = context.budget, found = context.lookup(particle.id);
+    const raw = found.kind === 'found' && found.node === particle ? context.rawParticleWildcardProperties(particle.id) : undefined;
+    const namespace = raw?.namespace ?? wildcardNamespaces(particle.term.wildcard, budget.chargeWork);
+    budget.chargeWork(5);
+    return Object.freeze({ namespace, processContents: raw?.processContents ?? particle.term.wildcard.processContents,
+        lexical: particle.term.wildcard.namespace });
+}