@oml/language 0.7.0

package/out/oml/oml-validator.js

@@ -0,0 +1,668 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+import { AstUtils } from 'langium';
+import { getOntologyModelIndex } from './oml-index.js';
+import { collectOntologyMembers, findOwningOntology, findOwningOntologyNode, getMemberName, getNamedElementName, } from './oml-utils.js';
+/**
+ * Register custom validation checks.
+ */
+export function registerValidationChecks(services) {
+    const registry = services.validation.ValidationRegistry;
+    const validator = services.validation.OmlValidator;
+    const checks = {
+        // Abstact types
+        Element: [validator.checkDeprecatedReferences],
+        IdentifiedElement: [],
+        Member: [validator.checkDuplicateMemberNames],
+        VocabularyMember: [],
+        DescriptionMember: [],
+        Statement: [],
+        VocabularyStatement: [],
+        DescriptionStatement: [],
+        Term: [],
+        SpecializableTerm: [],
+        // Annotation types
+        Annotation: [],
+        // Import types
+        Import: [
+            validator.checkInvalidImport,
+            validator.checkUnusedImport,
+            validator.checkDuplicateImport,
+            validator.checkDuplicateImportPrefix,
+        ],
+        // Axiom types
+        Axiom: [],
+        KeyAxiom: [],
+        SpecializationAxiom: [validator.checkInvalidSpecialization],
+        EquivalenceAxiom: [],
+        EntityEquivalenceAxiom: [validator.checkInvalidEntityEquivalence],
+        ScalarEquivalenceAxiom: [validator.checkInvalidScalarEquivalence],
+        PropertyEquivalenceAxiom: [validator.checkInvalidPropertyEquivalence],
+        InstanceEnumerationAxiom: [],
+        LiteralEnumerationAxiom: [],
+        PropertyRestrictionAxiom: [],
+        PropertyRangeRestrictionAxiom: [],
+        PropertyCardinalityRestrictionAxiom: [],
+        PropertyValueRestrictionAxiom: [],
+        PropertySelfRestrictionAxiom: [],
+        // Instance types
+        Instance: [],
+        NamedInstance: [],
+        AnonymousInstance: [],
+        ConceptInstance: [],
+        RelationInstance: [validator.checkInvalidRelationInstance],
+        AnonymousConceptInstance: [],
+        AnonymousRelationInstance: [],
+        // Assertion types
+        Assertion: [],
+        TypeAssertion: [validator.checkInvalidInstanceType],
+        PropertyValueAssertion: [],
+        // Literal types
+        Literal: [],
+        IntegerLiteral: [],
+        DecimalLiteral: [],
+        DoubleLiteral: [],
+        BooleanLiteral: [],
+        QuotedLiteral: [validator.checkQuotedLiteralNonStandardType],
+        // Rule types
+        Rule: [validator.checkInvalidRule],
+        Argument: [],
+        BuiltIn: [],
+        Predicate: [],
+        UnaryPredicate: [],
+        BinaryPredicate: [],
+        BuiltInPredicate: [],
+        TypePredicate: [],
+        RelationEntityPredicate: [],
+        PropertyPredicate: [],
+        SameAsPredicate: [],
+        DifferentFromPredicate: [],
+        //Ontology types
+        Ontology: [validator.checkOntologyNamespace],
+        VocabularyBox: [],
+        DescriptionBox: [],
+        Vocabulary: [],
+        VocabularyBundle: [],
+        Description: [],
+        DescriptionBundle: [],
+        // Property types
+        Property: [],
+        RelationBase: [],
+        SpecializableProperty: [],
+        AnnotationProperty: [],
+        SemanticProperty: [],
+        ScalarProperty: [],
+        Relation: [],
+        ForwardRelation: [validator.checkInvalidForwardRelation],
+        ReverseRelation: [validator.checkInvalidReverseRelation],
+        UnreifiedRelation: [],
+        // Type types
+        Type: [],
+        Scalar: [validator.checkInvalidScalarSpecialization],
+        Entity: [],
+        Aspect: [],
+        Concept: [],
+        RelationEntity: [validator.checkInvalidRelationEntity],
+    };
+    registry.register(checks, validator);
+}
+/**
+ * Implementation of custom validations.
+ */
+export class OmlValidator {
+    constructor(services) {
+        this.services = services;
+        this.ontologyContextCache = new Map();
+        this.deprecatedMemberCache = new WeakMap();
+        this.annotationPropertyIriCache = new WeakMap();
+    }
+    checkInvalidImport(ownedImport, accept) {
+        const ontology = ownedImport.$container;
+        // If unresolved, let linker/scope handle
+        if (!ownedImport.imported?.ref)
+            return;
+        const imported = ownedImport.imported.ref;
+        const kind = ownedImport.kind;
+        const type = ontology?.$type;
+        const importedType = imported?.$type;
+        const err = (msg) => accept('error', msg, { node: ownedImport });
+        if (kind === 'extends') {
+            if (type !== importedType) {
+                return err(`${type}s can extend other ${type}s (extending ${importedType})`);
+            }
+        }
+        else if (kind === 'includes') {
+            if (type === 'VocabularyBundle') {
+                if (importedType !== 'Vocabulary') {
+                    return err(`Vocabulary Bundles can include Vocabularies (including ${importedType})`);
+                }
+            }
+            else if (type === 'DescriptionBundle') {
+                if (importedType !== 'Description') {
+                    return err(`Description bundles can include Descriptions (including ${importedType})`);
+                }
+            }
+            else {
+                return err('Only Vocabulary Bundles and Description Bundles can include other ontologies');
+            }
+        }
+        else if (kind === 'uses') {
+            if (type === 'Vocabulary') {
+                if (importedType !== 'Description') {
+                    return err(`Vocabularies use Descriptions (using ${importedType})`);
+                }
+            }
+            else if (type === 'DescriptionBundle') {
+                if (importedType !== 'Vocabulary' && importedType !== 'VocabularyBundle') {
+                    return err(`Description bundles can use Vocabularies or Vocabulary Bundles (using ${importedType})`);
+                }
+            }
+            else if (type === 'Description') {
+                if (importedType !== 'Vocabulary') {
+                    return err(`Descriptions can use Vocabularies (using ${importedType})`);
+                }
+            }
+            else {
+                return err('Only Vocabularies, Descriptions, and Description Bundles can use other ontologies');
+            }
+        }
+        else {
+            return err(`Unknown import kind: ${kind}`);
+        }
+    }
+    checkUnusedImport(ownedImport, accept) {
+        let ontology = ownedImport.$container;
+        const prefix = ownedImport.prefix;
+        if (!ontology || !prefix)
+            return;
+        const context = this.getOntologyValidationContext(ontology);
+        if (!context?.usedPrefixes.has(prefix)) {
+            accept('warning', `Could not find a reference to prefix '${ownedImport.prefix}'`, {
+                node: ownedImport
+            });
+        }
+    }
+    checkDuplicateImport(ownedImport, accept) {
+        const ontology = ownedImport.$container;
+        const context = this.getOntologyValidationContext(ontology);
+        if (!context)
+            return;
+        const key = this.getImportKey(ownedImport);
+        if (!key)
+            return;
+        const hasDuplicate = (context.importKeyCounts.get(key) ?? 0) > 1;
+        if (hasDuplicate) {
+            const target = this.getImportTarget(ownedImport) ?? 'ontology';
+            const prefix = ownedImport.prefix ? ` as ${ownedImport.prefix}` : '';
+            accept('warning', `Duplicate import: ${ownedImport.kind} ${target}${prefix}`, {
+                node: ownedImport
+            });
+        }
+    }
+    checkDuplicateImportPrefix(ownedImport, accept) {
+        const ontology = ownedImport.$container;
+        const context = this.getOntologyValidationContext(ontology);
+        if (!context)
+            return;
+        const prefix = ownedImport.prefix?.trim();
+        if (!prefix)
+            return;
+        if (context.ontologyPrefix && context.ontologyPrefix === prefix) {
+            accept('error', `Import prefix '${prefix}' duplicates the owning ontology prefix`, {
+                node: ownedImport,
+                property: 'prefix'
+            });
+            return;
+        }
+        const hasDuplicateImportPrefix = (context.importPrefixCounts.get(prefix) ?? 0) > 1;
+        if (hasDuplicateImportPrefix) {
+            accept('error', `Duplicate import prefix '${prefix}'`, {
+                node: ownedImport,
+                property: 'prefix'
+            });
+        }
+    }
+    checkDeprecatedReferences(element, accept) {
+        for (const refInfo of AstUtils.streamReferences(element)) {
+            const target = refInfo.reference?.ref;
+            if (!target || !this.isDeprecatedMember(target)) {
+                continue;
+            }
+            accept('warning', `Reference to deprecated member ${this.getAbbreviatedIri(target)}`, {
+                node: refInfo.container,
+                property: refInfo.property,
+                index: refInfo.index
+            });
+        }
+    }
+    checkOntologyNamespace(ontology, accept) {
+        const rawNamespace = typeof ontology?.namespace === 'string' ? ontology.namespace.trim() : '';
+        if (!rawNamespace)
+            return;
+        const namespace = rawNamespace.replace(/^<|>$/g, '');
+        const iri = namespace.replace(/[#/]?$/, '');
+        const docUri = ontology?.$document?.uri?.toString?.() ?? '';
+        const duplicateModelUris = getOntologyModelIndex(this.services.shared).getDuplicateWorkspaceModelUris(iri);
+        const conflictingModelUris = duplicateModelUris.filter((modelUri) => modelUri !== docUri);
+        if (conflictingModelUris.length > 0) {
+            accept('error', `Ontology IRI '${iri}' is also declared by '${conflictingModelUris[0]}'`, {
+                node: ontology,
+                property: 'namespace'
+            });
+        }
+        let nsUrl;
+        try {
+            nsUrl = new URL(iri);
+        }
+        catch {
+            return;
+        }
+        const expectedHost = nsUrl.hostname;
+        const expectedPath = nsUrl.pathname.replace(/\/+$/, '');
+        if (!expectedHost || !expectedPath) {
+            return;
+        }
+        const expectedSuffix = `/${expectedHost}${expectedPath}.oml`;
+        let documentPath = '';
+        try {
+            documentPath = decodeURIComponent(new URL(docUri).pathname).replace(/\\/g, '/');
+        }
+        catch {
+            return;
+        }
+        if (!documentPath.toLowerCase().endsWith('.oml')) {
+            return;
+        }
+        if (!documentPath.endsWith(expectedSuffix)) {
+            accept('error', `Ontology namespace '${namespace}' does not match document path '${documentPath}'`, {
+                node: ontology,
+                property: 'namespace'
+            });
+        }
+    }
+    checkQuotedLiteralNonStandardType(literal, accept) {
+        const scalar = literal.type?.ref;
+        if (!scalar) {
+            return;
+        }
+        const ontology = findOwningOntologyNode(scalar);
+        const namespace = typeof ontology?.namespace === 'string' ? ontology.namespace : '';
+        if (!namespace || !OmlValidator.StandardScalarNamespaces.has(namespace)) {
+            accept('error', `Quoted Literal "${literal.value}" is not typed by a standard scalar`, {
+                node: literal,
+                property: 'type'
+            });
+        }
+    }
+    checkInvalidEntityEquivalence(axiom, accept) {
+        const container = axiom.$container;
+        const subType = container?.$type;
+        if (subType !== 'Aspect' && subType !== 'Concept' && subType !== 'RelationEntity') {
+            return;
+        }
+        for (const superTerm of axiom.superTerms ?? []) {
+            const superType = superTerm?.ref?.$type;
+            if (!superType || superType === subType) {
+                continue;
+            }
+            accept('error', `An ${subType} can only be equivalent to ${subType} (not ${superType})`, {
+                node: axiom,
+                property: 'superTerms'
+            });
+            return;
+        }
+    }
+    checkInvalidPropertyEquivalence(axiom, accept) {
+        const subKind = this.getPropertyKind(axiom.$container);
+        if (!subKind) {
+            return;
+        }
+        for (const superTerm of axiom.superTerms ?? []) {
+            const superKind = this.getPropertyKind(superTerm?.ref);
+            if (!superKind || superKind === subKind) {
+                continue;
+            }
+            accept('error', `A ${subKind} can only be equivalent to ${subKind} (not ${superKind})`, {
+                node: axiom,
+                property: 'superTerms'
+            });
+            return;
+        }
+    }
+    checkInvalidScalarEquivalence(axiom, accept) {
+        const hasFacets = (axiom.length?.length ?? 0) > 0
+            || (axiom.minLength?.length ?? 0) > 0
+            || (axiom.maxLength?.length ?? 0) > 0
+            || (axiom.pattern?.length ?? 0) > 0
+            || (axiom.language?.length ?? 0) > 0
+            || (axiom.minInclusive?.length ?? 0) > 0
+            || (axiom.minExclusive?.length ?? 0) > 0
+            || (axiom.maxInclusive?.length ?? 0) > 0
+            || (axiom.maxExclusive?.length ?? 0) > 0;
+        if (!hasFacets) {
+            return;
+        }
+        const resolvedSupers = (axiom.superTerms ?? [])
+            .map((superTerm) => superTerm?.ref)
+            .filter(Boolean);
+        if (resolvedSupers.length === 0) {
+            return;
+        }
+        const hasStandardSuper = resolvedSupers.some((scalar) => this.isStandardScalar(scalar));
+        if (!hasStandardSuper) {
+            accept('error', 'Facets can only restrict standard super scalars', {
+                node: axiom,
+                property: 'superTerms'
+            });
+        }
+    }
+    checkInvalidScalarSpecialization(scalar, accept) {
+        const isStandardType = this.isStandardScalar(scalar);
+        const hasSpecializations = (scalar.ownedSpecializations?.length ?? 0) > 0;
+        if (!isStandardType && hasSpecializations) {
+            accept('error', `Non-standard Scalar ${this.getAbbreviatedIri(scalar)} cannot have specializations`, {
+                node: scalar,
+                property: 'ownedSpecializations'
+            });
+            return;
+        }
+        const superScalars = (scalar.ownedSpecializations ?? [])
+            .map((specialization) => specialization.superTerm?.ref)
+            .filter((term) => Boolean(term) && term.$type === 'Scalar');
+        const hasAllStandardSupers = superScalars.every((superScalar) => this.isStandardScalar(superScalar));
+        if (!hasAllStandardSupers) {
+            accept('error', `Standard scalar ${this.getAbbreviatedIri(scalar)} can only specialize standard scalars`, {
+                node: scalar,
+                property: 'ownedSpecializations'
+            });
+        }
+    }
+    checkInvalidInstanceType(assertion, accept) {
+        const instance = assertion.$container;
+        const type = assertion.type?.ref;
+        if (!type || !instance) {
+            return;
+        }
+        const instanceType = instance.$type;
+        const typeType = type.$type;
+        const invalidConceptInstanceType = instanceType === 'ConceptInstance' && typeType !== 'Concept' && typeType !== 'Aspect';
+        const invalidRelationInstanceType = instanceType === 'RelationInstance' && typeType !== 'RelationEntity' && typeType !== 'Aspect';
+        if (invalidConceptInstanceType || invalidRelationInstanceType) {
+            accept('error', `Type ${this.getAbbreviatedIri(type)} cannot be a type for instance ${this.getAbbreviatedIri(instance)}`, {
+                node: assertion,
+                property: 'type'
+            });
+        }
+    }
+    checkInvalidReverseRelation(relation, accept) {
+        const relationBase = relation.$container;
+        if (relationBase?.ref) {
+            accept('error', `Cannot name a reverse relation on a ref to ${this.getAbbreviatedIri(relationBase.ref)}`, {
+                node: relation,
+                property: 'name'
+            });
+        }
+    }
+    checkInvalidForwardRelation(relation, accept) {
+        const relationEntity = relation.$container;
+        if (relationEntity?.ref) {
+            accept('error', `Cannot name a forward relation on a ref to ${this.getAbbreviatedIri(relationEntity.ref)}`, {
+                node: relation,
+                property: 'name'
+            });
+        }
+    }
+    checkInvalidRelationEntity(entity, accept) {
+        if (!entity.ref && !entity.forwardRelation) {
+            accept('error', `Must name a forward relation on ${this.getAbbreviatedIri(entity)}`, {
+                node: entity,
+                property: 'forwardRelation'
+            });
+        }
+    }
+    checkInvalidRule(rule, accept) {
+        const hasAntecedent = (rule.antecedent?.length ?? 0) > 0;
+        const hasConsequent = (rule.consequent?.length ?? 0) > 0;
+        if (rule.name) {
+            if (!hasAntecedent) {
+                accept('error', `Rule ${this.getAbbreviatedIri(rule)} needs to specify some predicates as antecedent`, {
+                    node: rule,
+                    property: 'name'
+                });
+                return;
+            }
+            if (!hasConsequent) {
+                accept('error', `Rule ${this.getAbbreviatedIri(rule)} needs to specify some predicates as consequent`, {
+                    node: rule,
+                    property: 'name'
+                });
+            }
+            return;
+        }
+        if (hasAntecedent) {
+            accept('error', `Rule ${this.getAbbreviatedIri(rule)} cannot respecify a predeicate as antecedent`, {
+                node: rule,
+                property: 'antecedent'
+            });
+        }
+        if (hasConsequent) {
+            accept('error', `Rule ${this.getAbbreviatedIri(rule)} cannot respecify a predicate as consequent`, {
+                node: rule,
+                property: 'consequent'
+            });
+        }
+    }
+    checkInvalidRelationInstance(instance, accept) {
+        if (!instance.name) {
+            return;
+        }
+        if ((instance.sources?.length ?? 0) === 0) {
+            accept('error', `Relation instance ${this.getAbbreviatedIri(instance)} needs to specify at least one source`, {
+                node: instance,
+                property: 'name'
+            });
+            return;
+        }
+        if ((instance.targets?.length ?? 0) === 0) {
+            accept('error', `Relation instance ${this.getAbbreviatedIri(instance)} needs to specify at least one target`, {
+                node: instance,
+                property: 'name'
+            });
+        }
+    }
+    getPropertyKind(property) {
+        const type = property?.$type;
+        if (type === 'AnnotationProperty') {
+            return 'annotation property';
+        }
+        if (type === 'ScalarProperty') {
+            return 'scalar property';
+        }
+        if (type === 'UnreifiedRelation' || type === 'ForwardRelation' || type === 'ReverseRelation') {
+            return 'relation';
+        }
+        return undefined;
+    }
+    isStandardScalar(scalar) {
+        const ontology = findOwningOntologyNode(scalar);
+        const namespace = typeof ontology?.namespace === 'string' ? ontology.namespace : '';
+        return Boolean(namespace) && OmlValidator.StandardScalarNamespaces.has(namespace);
+    }
+    isDeprecatedMember(member) {
+        if (!member || typeof member !== 'object') {
+            return false;
+        }
+        const cached = this.deprecatedMemberCache.get(member);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const annotations = Array.isArray(member.ownedAnnotations) ? member.ownedAnnotations : [];
+        const deprecated = annotations.some((annotation) => {
+            const property = annotation?.property?.ref;
+            const iri = this.getAnnotationPropertyIri(property);
+            return iri === OmlValidator.DeprecatedAnnotationPropertyIri;
+        });
+        this.deprecatedMemberCache.set(member, deprecated);
+        return deprecated;
+    }
+    getAnnotationPropertyIri(property) {
+        if (!property || typeof property !== 'object') {
+            return undefined;
+        }
+        const cached = this.annotationPropertyIriCache.get(property);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const name = typeof property.name === 'string' ? property.name.trim() : '';
+        const ontology = findOwningOntologyNode(property);
+        const namespace = typeof ontology?.namespace === 'string' ? ontology.namespace.replace(/^<|>$/g, '') : '';
+        let iri;
+        if (namespace && name) {
+            const separator = namespace.endsWith('#') || namespace.endsWith('/') ? '' : '#';
+            iri = `${namespace}${separator}${name}`;
+        }
+        this.annotationPropertyIriCache.set(property, iri);
+        return iri;
+    }
+    getAbbreviatedIri(node) {
+        const ontology = findOwningOntologyNode(node);
+        const prefix = typeof ontology?.prefix === 'string' ? ontology.prefix : '';
+        const name = typeof node?.name === 'string' ? node.name : '';
+        if (prefix && name) {
+            return `${prefix}:${name}`;
+        }
+        return name || '<unknown>';
+    }
+    checkInvalidSpecialization(specializationAxiom, accept) {
+        const subTerm = specializationAxiom?.$container;
+        const superTerm = specializationAxiom?.superTerm?.ref;
+        if (!subTerm || !superTerm)
+            return;
+        const subType = subTerm.$type;
+        const superType = superTerm.$type;
+        const err = (msg) => accept('error', msg, { node: specializationAxiom });
+        const validSpecializations = {
+            'Concept': ['Concept', 'Aspect'],
+            'Aspect': ['Aspect'],
+            'RelationEntity': ['RelationEntity', 'Aspect'],
+            'AnnotationProperty': ['AnnotationProperty'],
+            'Scalar': ['Scalar'],
+            'ScalarProperty': ['ScalarProperty'],
+            'UnreifiedRelation': ['UnreifiedRelation', 'ForwardRelation', 'ReverseRelation'],
+        };
+        const allowedSupers = validSpecializations[subType];
+        if (!allowedSupers) {
+            return err(`Invalid subTerm type '${subType}' in SpecializationAxiom`);
+        }
+        if (!allowedSupers.includes(superType)) {
+            return err(`A ${subType} can only specialize ${allowedSupers.join(' or ')} (not ${superType})`);
+        }
+    }
+    checkDuplicateMemberNames(member, accept) {
+        const memberName = getMemberName(member);
+        if (!memberName) {
+            return;
+        }
+        const ontology = findOwningOntology(member);
+        if (!ontology) {
+            return;
+        }
+        const context = this.getOntologyValidationContext(ontology);
+        const hasDuplicate = (context?.memberNameCounts.get(memberName) ?? 0) > 1;
+        if (!hasDuplicate) {
+            return;
+        }
+        accept('error', `An element named '${memberName}' already exists in this ontology`, {
+            node: member,
+            property: 'name',
+        });
+    }
+    getImportTarget(ownedImport) {
+        return ownedImport.imported?.$refText;
+    }
+    getImportKey(ownedImport) {
+        const target = this.getImportTarget(ownedImport);
+        if (!target)
+            return undefined;
+        const prefix = ownedImport.prefix ?? '';
+        const kind = ownedImport.kind ?? '';
+        return `${kind}|${target}|${prefix}`;
+    }
+    getOntologyValidationContext(ontology) {
+        const uri = ontology?.$document?.uri?.toString?.();
+        if (!uri) {
+            return undefined;
+        }
+        const version = ontology?.$document?.textDocument?.version ?? 0;
+        const cached = this.ontologyContextCache.get(uri);
+        if (cached && cached.version === version) {
+            return cached;
+        }
+        const text = ontology?.$document?.textDocument?.getText?.() ?? '';
+        const usedPrefixes = this.collectUsedPrefixes(text);
+        const memberNameCounts = new Map();
+        const importKeyCounts = new Map();
+        const importPrefixCounts = new Map();
+        for (const candidate of collectOntologyMembers(ontology)) {
+            const name = getNamedElementName(candidate);
+            if (name) {
+                memberNameCounts.set(name, (memberNameCounts.get(name) ?? 0) + 1);
+            }
+        }
+        const imports = ontology?.ownedImports ?? [];
+        for (const ownedImport of imports) {
+            const key = this.getImportKey(ownedImport);
+            if (key) {
+                importKeyCounts.set(key, (importKeyCounts.get(key) ?? 0) + 1);
+            }
+            const prefix = typeof ownedImport?.prefix === 'string' ? ownedImport.prefix.trim() : '';
+            if (prefix) {
+                importPrefixCounts.set(prefix, (importPrefixCounts.get(prefix) ?? 0) + 1);
+            }
+        }
+        const context = {
+            version,
+            usedPrefixes,
+            memberNameCounts,
+            importKeyCounts,
+            importPrefixCounts,
+            ontologyPrefix: typeof ontology?.prefix === 'string' ? ontology.prefix.trim() : ''
+        };
+        this.ontologyContextCache.set(uri, context);
+        this.pruneOntologyContextCache();
+        return context;
+    }
+    collectUsedPrefixes(text) {
+        // Mask quoted literals and comments so prefix scanning only sees code tokens.
+        const stripped = text.replace(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\/\*[\s\S]*?\*\/|\/\/[^\n\r]*/g, ' ');
+        const usedPrefixes = new Set();
+        const pattern = /\b([A-Za-z_][A-Za-z0-9_-]*):\S/g;
+        let match;
+        while ((match = pattern.exec(stripped)) !== null) {
+            usedPrefixes.add(match[1]);
+        }
+        return usedPrefixes;
+    }
+    pruneOntologyContextCache() {
+        if (this.ontologyContextCache.size <= OmlValidator.MaxOntologyContexts) {
+            return;
+        }
+        const overflow = this.ontologyContextCache.size - OmlValidator.MaxOntologyContexts;
+        const keys = this.ontologyContextCache.keys();
+        for (let i = 0; i < overflow; i += 1) {
+            const next = keys.next();
+            if (next.done) {
+                break;
+            }
+            this.ontologyContextCache.delete(next.value);
+        }
+    }
+}
+OmlValidator.MaxOntologyContexts = 512;
+OmlValidator.StandardScalarNamespaces = new Set([
+    'http://www.w3.org/2001/XMLSchema#',
+    'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+    'http://www.w3.org/2000/01/rdf-schema#',
+    'http://www.w3.org/2002/07/owl#'
+]);
+OmlValidator.DeprecatedAnnotationPropertyIri = 'http://www.w3.org/2002/07/owl#deprecated';
+//# sourceMappingURL=oml-validator.js.map