@ifc-lite/ids 1.14.11 → 1.15.1

package/dist/audit/coherence/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Restriction & cardinality coherence checks.
+ *
+ * Catches authoring mistakes that aren't strictly XSD violations but
+ * make a specification ill-formed in practice — empty enumerations,
+ * inverted bounds, regex patterns that don't compile, prohibited
+ * cardinality on applicability blocks, etc.
+ */
+import type { IDSDocument } from '../../types.js';
+import type { IDSAuditIssue } from '../types.js';
+export declare function runCoherenceAudit(doc: IDSDocument): IDSAuditIssue[];
+//# sourceMappingURL=index.d.ts.map

package/dist/audit/coherence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/audit/coherence/index.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAEV,WAAW,EAIZ,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,WAAW,GAAG,aAAa,EAAE,CAMnE"}

package/dist/audit/coherence/index.js

@@ -0,0 +1,392 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+import { compileXsdRegex } from './regex.js';
+export function runCoherenceAudit(doc) {
+    const issues = [];
+    doc.specifications.forEach((spec, i) => {
+        auditSpec(spec, `specifications[${i}]`, issues);
+    });
+    return issues;
+}
+function auditSpec(spec, path, issues) {
+    // minOccurs / maxOccurs sanity. Spec parses them as numbers (or
+    // 'unbounded'); both must be >= 0 and the order must hold.
+    const min = spec.minOccurs;
+    const max = spec.maxOccurs;
+    if (min !== undefined && (!Number.isInteger(min) || min < 0)) {
+        issues.push({
+            severity: 'error',
+            code: 'E_CARDINALITY_INVALID',
+            message: `minOccurs must be a non-negative integer; got ${min}`,
+            path: `${path}.minOccurs`,
+            detail: { value: String(min) },
+        });
+    }
+    if (max !== undefined && max !== 'unbounded') {
+        if (!Number.isInteger(max) || max < 0) {
+            issues.push({
+                severity: 'error',
+                code: 'E_CARDINALITY_INVALID',
+                message: `maxOccurs must be a non-negative integer or "unbounded"; got ${max}`,
+                path: `${path}.maxOccurs`,
+                detail: { value: String(max) },
+            });
+        }
+    }
+    if (typeof min === 'number' &&
+        typeof max === 'number' &&
+        min > max) {
+        issues.push({
+            severity: 'error',
+            code: 'E_CARDINALITY_INVALID',
+            message: `minOccurs (${min}) is greater than maxOccurs (${max})`,
+            path: `${path}.minOccurs`,
+            detail: { min: min, max: max },
+        });
+    }
+    // Upstream IDS-Audit-tool flags `cardinality` on `<applicability>` —
+    // it's meaningless there. (Report 202)
+    if (spec.applicability.cardinality) {
+        issues.push({
+            severity: 'warning',
+            code: 'W_CARDINALITY_PROHIBITED_APPLICABILITY',
+            message: `cardinality="${spec.applicability.cardinality}" has no effect on <applicability>`,
+            path: `${path}.applicability.cardinality`,
+        });
+    }
+    spec.applicability.facets.forEach((facet, fi) => {
+        auditFacetConstraints(facet, `${path}.applicability.facets[${fi}]`, issues);
+    });
+    spec.requirements.forEach((req, ri) => {
+        auditFacetConstraints(req.facet, `${path}.requirements[${ri}]`, issues);
+        auditRequirementCardinality(req, `${path}.requirements[${ri}]`, issues);
+    });
+}
+/**
+ * Cardinality coherence on a requirement facet (Report 202 upstream).
+ *
+ * Per upstream IDS-Audit-tool:
+ *  - `cardinality="optional"` on a `<property>` requires `@dataType`.
+ *  - `cardinality="prohibited"` on a `<property>` is incompatible with
+ *    `@dataType` (the property must not exist at all).
+ *  - `cardinality="optional"` on `<material>`, `<classification>` and
+ *    `<partOf>` requires a value/system/entity to be specified — an
+ *    `optional` facet without a constraint is meaningless.
+ */
+function auditRequirementCardinality(req, path, issues) {
+    // The XSD `conditionalCardinality` / `simpleCardinality` enums are
+    // case-sensitive lowercase: `required`, `optional`, `prohibited`. The
+    // parser preserves the raw value when it didn't match exactly so we
+    // can flag mistakes here (`Required`, `Invalid`, empty string, …)
+    // rather than silently defaulting to `required`.
+    if (req.cardinalityRaw !== undefined) {
+        issues.push({
+            severity: 'error',
+            code: 'E_CARDINALITY_INVALID',
+            message: `@cardinality="${req.cardinalityRaw}" is not a valid value; expected one of {required, optional, prohibited}`,
+            path: `${path}.cardinality`,
+            facetType: req.facet.type,
+            detail: { value: req.cardinalityRaw },
+        });
+    }
+    switch (req.facet.type) {
+        case 'property': {
+            const hasDataType = req.facet.dataType !== undefined;
+            if (req.optionality === 'optional' && !hasDataType) {
+                issues.push({
+                    severity: 'error',
+                    code: 'E_CARDINALITY_INVALID',
+                    message: 'optional <property> requirement requires @dataType to be specified',
+                    path: `${path}.cardinality`,
+                    facetType: 'property',
+                });
+            }
+            if (req.optionality === 'prohibited' && hasDataType) {
+                issues.push({
+                    severity: 'error',
+                    code: 'E_CARDINALITY_INVALID',
+                    message: 'prohibited <property> requirement is incompatible with @dataType',
+                    path: `${path}.cardinality`,
+                    facetType: 'property',
+                });
+            }
+            break;
+        }
+        case 'material': {
+            if (req.optionality === 'optional') {
+                const hasValue = req.facet.value !== undefined && !isEmptyConstraint(req.facet.value);
+                if (!hasValue) {
+                    issues.push({
+                        severity: 'error',
+                        code: 'E_CARDINALITY_INVALID',
+                        message: 'optional <material> requirement must specify a non-empty <value> constraint',
+                        path: `${path}.cardinality`,
+                        facetType: 'material',
+                    });
+                }
+            }
+            break;
+        }
+        case 'classification': {
+            if (req.optionality === 'optional') {
+                const hasSystem = req.facet.system !== undefined &&
+                    !isEmptyConstraint(req.facet.system);
+                const hasValue = req.facet.value !== undefined && !isEmptyConstraint(req.facet.value);
+                if (!hasSystem && !hasValue) {
+                    issues.push({
+                        severity: 'error',
+                        code: 'E_CARDINALITY_INVALID',
+                        message: 'optional <classification> requirement must specify <system> or <value>',
+                        path: `${path}.cardinality`,
+                        facetType: 'classification',
+                    });
+                }
+            }
+            break;
+        }
+        case 'attribute':
+        case 'entity':
+        case 'partOf':
+            // Attribute/entity/partOf carry their own intrinsic content;
+            // cardinality on them is just required/optional/prohibited.
+            break;
+    }
+}
+function isEmptyConstraint(c) {
+    switch (c.type) {
+        case 'simpleValue':
+            return c.value === '' || c.value == null;
+        case 'enumeration':
+            return c.values.length === 0;
+        case 'pattern':
+            return c.pattern === '';
+        case 'bounds':
+            return (c.minInclusive === undefined &&
+                c.maxInclusive === undefined &&
+                c.minExclusive === undefined &&
+                c.maxExclusive === undefined &&
+                c.length === undefined &&
+                c.minLength === undefined &&
+                c.maxLength === undefined);
+    }
+}
+function auditFacetConstraints(facet, path, issues) {
+    switch (facet.type) {
+        case 'entity':
+            check(facet.name, `${path}.name`, issues, facet.type);
+            if (facet.predefinedType) {
+                check(facet.predefinedType, `${path}.predefinedType`, issues, facet.type);
+            }
+            break;
+        case 'attribute':
+            check(facet.name, `${path}.name`, issues, facet.type);
+            if (facet.value)
+                check(facet.value, `${path}.value`, issues, facet.type);
+            break;
+        case 'property':
+            check(facet.propertySet, `${path}.propertySet`, issues, facet.type);
+            check(facet.baseName, `${path}.baseName`, issues, facet.type);
+            if (facet.dataType)
+                check(facet.dataType, `${path}.dataType`, issues, facet.type);
+            if (facet.value)
+                check(facet.value, `${path}.value`, issues, facet.type);
+            break;
+        case 'classification':
+            if (facet.system)
+                check(facet.system, `${path}.system`, issues, facet.type);
+            if (facet.value)
+                check(facet.value, `${path}.value`, issues, facet.type);
+            break;
+        case 'material':
+            if (facet.value)
+                check(facet.value, `${path}.value`, issues, facet.type);
+            break;
+        case 'partOf':
+            if (facet.entity) {
+                auditFacetConstraints(facet.entity, `${path}.entity`, issues);
+            }
+            break;
+    }
+}
+function check(c, path, issues, facetType) {
+    switch (c.type) {
+        case 'enumeration':
+            if (c.values.length === 0) {
+                issues.push({
+                    severity: 'error',
+                    code: 'E_RESTRICTION_EMPTY',
+                    message: 'xs:enumeration must have at least one value',
+                    path,
+                    facetType,
+                });
+            }
+            else if (c.values.some((v) => v === '' || v == null)) {
+                issues.push({
+                    severity: 'warning',
+                    code: 'E_RESTRICTION_EMPTY',
+                    message: 'xs:enumeration has an empty entry',
+                    path,
+                    facetType,
+                });
+            }
+            // When the restriction base is a typed primitive
+            // (`xs:double`/`xs:integer`/`xs:boolean`/…), every enumeration
+            // value must match the base's lexical space — upstream's
+            // `Report 305 BadConstraintValue`. Otherwise an `xs:double`
+            // restriction can carry strings like `"12,0"` or `"a"` that
+            // would never compare equal to a real numeric value.
+            if (c.base) {
+                for (const v of c.values) {
+                    if (v == null || v === '')
+                        continue;
+                    if (!isValidLexicalForXsType(v, c.base)) {
+                        issues.push({
+                            severity: 'error',
+                            code: 'E_RESTRICTION_VALUE_MISMATCH',
+                            message: `xs:enumeration value "${v}" is not valid for xs:restriction @base="${c.base}"`,
+                            path,
+                            facetType,
+                            detail: { value: v, base: c.base },
+                        });
+                    }
+                }
+            }
+            break;
+        case 'bounds':
+            checkBounds(c, path, issues, facetType);
+            break;
+        case 'pattern':
+            checkPattern(c.pattern, path, issues, facetType);
+            break;
+        case 'simpleValue':
+            // No coherence check beyond the XSD's required-non-empty check,
+            // which we already do in the XSD audit.
+            break;
+    }
+}
+function checkBounds(c, path, issues, facetType) {
+    const lo = c.minInclusive ?? c.minExclusive;
+    const hi = c.maxInclusive ?? c.maxExclusive;
+    if (typeof lo === 'number' &&
+        typeof hi === 'number' &&
+        lo > hi) {
+        issues.push({
+            severity: 'error',
+            code: 'E_RESTRICTION_RANGE',
+            message: `xs:restriction bounds inverted: lower (${lo}) > upper (${hi})`,
+            path,
+            facetType,
+            detail: { min: lo, max: hi },
+        });
+    }
+    if (typeof c.minLength === 'number' &&
+        typeof c.maxLength === 'number' &&
+        c.minLength > c.maxLength) {
+        issues.push({
+            severity: 'error',
+            code: 'E_RESTRICTION_RANGE',
+            message: `xs:restriction lengths inverted: minLength (${c.minLength}) > maxLength (${c.maxLength})`,
+            path,
+            facetType,
+            detail: { min: c.minLength, max: c.maxLength },
+        });
+    }
+    if (typeof c.length === 'number' &&
+        (typeof c.minLength === 'number' || typeof c.maxLength === 'number')) {
+        issues.push({
+            severity: 'warning',
+            code: 'E_RESTRICTION_RANGE',
+            message: 'xs:length is mutually exclusive with xs:minLength/xs:maxLength',
+            path,
+            facetType,
+        });
+    }
+    const empty = c.minInclusive === undefined &&
+        c.minExclusive === undefined &&
+        c.maxInclusive === undefined &&
+        c.maxExclusive === undefined &&
+        c.length === undefined &&
+        c.minLength === undefined &&
+        c.maxLength === undefined;
+    if (empty) {
+        issues.push({
+            severity: 'error',
+            code: 'E_RESTRICTION_EMPTY',
+            message: 'xs:restriction has no min/max bounds or length facets',
+            path,
+            facetType,
+        });
+    }
+}
+/**
+ * Validate `pattern` against XSD regex semantics by translating XSD-only
+ * escape codes to JS regex equivalents (cf. upstream `XmlRegex.cs`).
+ *
+ * Translation handles `\i`/`\c`/`\d`/`\w` and their negations via
+ * Unicode property escapes (compiled with the `u` flag). Char-class
+ * subtraction (`[a-z-[aeiou]]`) is XSD-only and surfaces as
+ * `W_REGEX_UNVERIFIED`. Any remaining syntactic errors are real
+ * authoring mistakes and surface as `E_RESTRICTION_EMPTY` (upstream
+ * Report 109).
+ */
+function checkPattern(pattern, path, issues, facetType) {
+    const result = compileXsdRegex(pattern);
+    if (result.ok)
+        return;
+    if (result.severity === 'error') {
+        issues.push({
+            severity: 'error',
+            code: pattern === '' ? 'E_RESTRICTION_EMPTY' : 'E_RESTRICTION_EMPTY',
+            message: pattern === ''
+                ? 'xs:pattern @value is empty'
+                : `xs:pattern is not a valid regular expression: ${result.reason}`,
+            path,
+            facetType,
+            detail: pattern === '' ? undefined : { pattern },
+        });
+        return;
+    }
+    issues.push({
+        severity: 'warning',
+        code: 'W_REGEX_UNVERIFIED',
+        message: `xs:pattern uses XSD-specific syntax not verifiable in JS: ${result.reason}`,
+        path,
+        facetType,
+        detail: { pattern },
+    });
+}
+/**
+ * Validate that `value` matches the lexical space of the supplied XSD
+ * primitive base. Mirrors upstream `XsTypes.IsValid` — same regexes,
+ * just expressed in JS. Used by the enumeration coherence check to
+ * flag entries like `<xs:enumeration value="12,0"/>` under a
+ * `<xs:restriction base="xs:double">`.
+ */
+const XS_VALUE_REGEX = {
+    // Lifted from upstream `XmlRegex.cs` static fields.
+    'xs:integer': /^[+-]?(\d+)$/,
+    'xs:double': /^([-+]?[0-9]*\.?[0-9]*([eE][-+]?[0-9]+)?|NaN|\+INF|-INF)$/,
+    'xs:float': /^([-+]?[0-9]*\.?[0-9]*([eE][-+]?[0-9]+)?|NaN|\+INF|-INF)$/,
+    'xs:decimal': /^([-+]?[0-9]*\.?[0-9]*([eE][-+]?[0-9]+)?|NaN|\+INF|-INF)$/,
+    'xs:boolean': /^(true|false|0|1)$/,
+    'xs:date': /^\d{4}-\d{2}-\d{2}(Z|([+-]\d{2}:\d{2}))?$/,
+    'xs:dateTime': /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|([+-]\d{2}:\d{2}))?$/,
+    'xs:time': /^\d{2}:\d{2}:\d{2}(\.\d+)?(Z|([+-]\d{2}:\d{2}))?$/,
+    'xs:duration': /^[-+]?P(\d+Y)?(\d+M)?(\d+D)?(T(\d+H)?(\d+M)?(\d+S)?)?$/,
+};
+function isValidLexicalForXsType(value, base) {
+    const rx = XS_VALUE_REGEX[base];
+    if (!rx)
+        return true; // base we don't recognise → don't fabricate errors
+    // For doubles/floats/decimals, an empty lexeme is technically allowed
+    // by the regex but isn't a meaningful number — reject.
+    if ((base === 'xs:double' ||
+        base === 'xs:float' ||
+        base === 'xs:decimal') &&
+        !/[0-9]/.test(value)) {
+        return false;
+    }
+    return rx.test(value);
+}
+//# sourceMappingURL=index.js.map

package/dist/audit/coherence/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/audit/coherence/index.ts"],"names":[],"mappings":"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"}

package/dist/audit/coherence/regex.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Translate an XSD regex pattern into JavaScript regex syntax.
+ *
+ * Ported from `IdsLib/IdsSchema/XsNodes/XmlRegex.cs` (MIT) which itself
+ * mirrors Microsoft's reference XSD facet checker. XSD regex extends
+ * the JS dialect with:
+ *
+ *  - `\i`  — XML name start char (letter, `_`, `:` plus a swathe of
+ *            Unicode letters)
+ *  - `\c`  — XML name char (`\i` plus digits, `.`, `-`, U+00B7, etc.)
+ *  - `\d`  — Unicode digit (broader than JS `[0-9]`)
+ *  - `\w`  — Unicode word char (letters + digits, no `_`)
+ *  - `\D`, `\C`, `\I`, `\W` — negations
+ *  - char-class subtraction `[a-z-[aeiou]]` — the JS dialect doesn't
+ *    support this; we fall back to a marker so the auditor can warn.
+ *
+ * The translation maps to JS Unicode property escapes (require `u` flag).
+ * `\d` and `\w` already exist in JS and map close enough that we leave
+ * them alone — same applies to `\D`/`\W`. The XML name char escapes are
+ * the only ones that genuinely need translation.
+ */
+interface TranslateResult {
+    /** The pattern usable with the JS `RegExp` constructor. */
+    pattern: string;
+    /** Whether translation produced a faithful JS-compatible regex. */
+    supported: boolean;
+    /**
+     * Human-readable reason when `supported === false`. Empty string when
+     * fully supported.
+     */
+    reason: string;
+}
+/**
+ * Translate the XSD pattern. Returns the JS-compatible pattern plus a
+ * `supported` flag — when `false`, the auditor should warn rather than
+ * compile-test the result (the unsupported construct may produce
+ * spurious failures).
+ */
+export declare function translateXsdRegex(pattern: string): TranslateResult;
+/**
+ * Try to compile `pattern` as XSD regex semantics. Returns:
+ *  - `{ ok: true }` when the pattern is valid (after translation).
+ *  - `{ ok: false, severity: 'error', reason }` for syntactic errors
+ *    that JS *and* XSD agree on (e.g. unclosed `[`).
+ *  - `{ ok: false, severity: 'warning', reason }` when the pattern uses
+ *    XSD-only syntax we can't translate (char-class subtraction).
+ */
+export declare function compileXsdRegex(pattern: string): {
+    ok: true;
+    jsPattern: string;
+} | {
+    ok: false;
+    severity: 'error' | 'warning';
+    reason: string;
+};
+export {};
+//# sourceMappingURL=regex.d.ts.map

package/dist/audit/coherence/regex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex.d.ts","sourceRoot":"","sources":["../../../src/audit/coherence/regex.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,UAAU,eAAe;IACvB,2DAA2D;IAC3D,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,SAAS,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CAiClE;AA2CD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,GAEb;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAkB/D"}

package/dist/audit/coherence/regex.js

@@ -0,0 +1,111 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * Translate the XSD pattern. Returns the JS-compatible pattern plus a
+ * `supported` flag — when `false`, the auditor should warn rather than
+ * compile-test the result (the unsupported construct may produce
+ * spurious failures).
+ */
+export function translateXsdRegex(pattern) {
+    // Char-class subtraction is only safely expressible via lookarounds in
+    // simple cases; in general it requires set algebra. Surface it as
+    // unsupported so the auditor warns.
+    if (/\[[^\]]*-\[/.test(pattern)) {
+        return {
+            pattern,
+            supported: false,
+            reason: 'XSD character-class subtraction is not supported in JS regex',
+        };
+    }
+    let translated = '';
+    let i = 0;
+    while (i < pattern.length) {
+        const ch = pattern.charAt(i);
+        if (ch === '\\' && i + 1 < pattern.length) {
+            const next = pattern.charAt(i + 1);
+            const replacement = mapEscape(next);
+            if (replacement) {
+                translated += replacement;
+                i += 2;
+                continue;
+            }
+            // Pass through any other escape (`\n`, `\.`, `\\`, …).
+            translated += ch + next;
+            i += 2;
+            continue;
+        }
+        translated += ch;
+        i++;
+    }
+    return { pattern: translated, supported: true, reason: '' };
+}
+/**
+ * Map an XSD-specific escape character to its JS regex Unicode-property
+ * equivalent. Returns `undefined` when the escape is identical in both
+ * dialects (and thus needs no translation).
+ *
+ * The XML production rules these escape codes implement live in the
+ * W3C XML 1.0 spec § 2.3 (NameStartChar / NameChar) and § 2.5 (Digit /
+ * Letter). We use JS Unicode property escapes (`\p{L}`, `\p{Nd}`) which
+ * are equivalent for our purposes when the pattern is compiled with the
+ * `u` flag.
+ */
+function mapEscape(ch) {
+    switch (ch) {
+        case 'i':
+            // NameStartChar: letters + `_` + `:` + extended Unicode letters.
+            return '[\\p{L}_:]';
+        case 'I':
+            return '[^\\p{L}_:]';
+        case 'c':
+            // NameChar: NameStartChar + digits + `.` + `-` + U+00B7 + combining marks.
+            return '[\\p{L}\\p{Nd}_:.\\-\\u00B7\\u0300-\\u036F\\u203F-\\u2040]';
+        case 'C':
+            return '[^\\p{L}\\p{Nd}_:.\\-\\u00B7\\u0300-\\u036F\\u203F-\\u2040]';
+        case 'd':
+            // JS \d matches `[0-9]`; XSD \d matches all Unicode digits. Use
+            // \p{Nd} for full fidelity.
+            return '\\p{Nd}';
+        case 'D':
+            return '\\P{Nd}';
+        case 'w':
+            // JS \w matches `[A-Za-z0-9_]`; XSD \w matches Unicode letters +
+            // digits without underscore. Use a Unicode class that mirrors the
+            // XSD definition.
+            return '[\\p{L}\\p{Nd}]';
+        case 'W':
+            return '[^\\p{L}\\p{Nd}]';
+        default:
+            return undefined;
+    }
+}
+/**
+ * Try to compile `pattern` as XSD regex semantics. Returns:
+ *  - `{ ok: true }` when the pattern is valid (after translation).
+ *  - `{ ok: false, severity: 'error', reason }` for syntactic errors
+ *    that JS *and* XSD agree on (e.g. unclosed `[`).
+ *  - `{ ok: false, severity: 'warning', reason }` when the pattern uses
+ *    XSD-only syntax we can't translate (char-class subtraction).
+ */
+export function compileXsdRegex(pattern) {
+    if (pattern === '') {
+        return { ok: false, severity: 'error', reason: 'pattern is empty' };
+    }
+    const translated = translateXsdRegex(pattern);
+    if (!translated.supported) {
+        return { ok: false, severity: 'warning', reason: translated.reason };
+    }
+    try {
+        new RegExp(translated.pattern, 'u');
+        return { ok: true, jsPattern: translated.pattern };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            severity: 'error',
+            reason: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+//# sourceMappingURL=regex.js.map

package/dist/audit/coherence/regex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex.js","sourceRoot":"","sources":["../../../src/audit/coherence/regex.ts"],"names":[],"mappings":"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"}

package/dist/audit/ifc-schema/index.d.ts

@@ -0,0 +1,4 @@
+import type { IDSDocument } from '../../types.js';
+import type { IDSAuditIssue, IDSAuditOptions } from '../types.js';
+export declare function runIfcSchemaAudit(doc: IDSDocument, options: Pick<IDSAuditOptions, 'ifcVersion'>): Promise<IDSAuditIssue[]>;
+//# sourceMappingURL=index.d.ts.map

package/dist/audit/ifc-schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/audit/ifc-schema/index.ts"],"names":[],"mappings":"AAiCA,OAAO,KAAK,EACV,WAAW,EAKZ,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAElE,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,YAAY,CAAC,GAC3C,OAAO,CAAC,aAAa,EAAE,CAAC,CAwB1B"}