@oml/owl 0.7.0

package/out/owl/owl-mapper.js

@@ -0,0 +1,1217 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+import { DataFactory } from 'n3';
+import { isAnnotationProperty, isAnonymousConceptInstance, isAnonymousRelationInstance, isAspect, isBooleanLiteral, isBuiltInPredicate, isBuiltIn, isConcept, isConceptInstance, isDecimalLiteral, isDifferentFromPredicate, isDescription, isDescriptionBundle, isDoubleLiteral, isIntegerLiteral, isOntology, isPropertyPredicate, isPropertyCardinalityRestrictionAxiom, isPropertyRangeRestrictionAxiom, isPropertySelfRestrictionAxiom, isPropertyValueRestrictionAxiom, isQuotedLiteral, isRelation, isRelationEntityPredicate, isRelationEntity, isRelationInstance, isReverseRelation, isRule, isSameAsPredicate, isScalar, isScalarProperty, isTypePredicate, isUnreifiedRelation, isVocabulary, isVocabularyBundle, } from '@oml/language';
+export const OWL_ONTOLOGY_IRI = 'http://opencaesar.io/oml';
+export const OWL_ONTOLOGY_NAMESPACE = 'http://opencaesar.io/oml#';
+export const OWL_ONTOLOGY_PREFIX = 'oml';
+const RDF = {
+    type: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type',
+    first: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#first',
+    rest: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#rest',
+    nil: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#nil',
+    langRange: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#langRange',
+    langString: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#langString',
+};
+const RDFS = {
+    Datatype: 'http://www.w3.org/2000/01/rdf-schema#Datatype',
+    label: 'http://www.w3.org/2000/01/rdf-schema#label',
+    subClassOf: 'http://www.w3.org/2000/01/rdf-schema#subClassOf',
+    subPropertyOf: 'http://www.w3.org/2000/01/rdf-schema#subPropertyOf',
+    domain: 'http://www.w3.org/2000/01/rdf-schema#domain',
+    range: 'http://www.w3.org/2000/01/rdf-schema#range',
+};
+const OWL = {
+    Ontology: 'http://www.w3.org/2002/07/owl#Ontology',
+    Class: 'http://www.w3.org/2002/07/owl#Class',
+    ObjectProperty: 'http://www.w3.org/2002/07/owl#ObjectProperty',
+    DatatypeProperty: 'http://www.w3.org/2002/07/owl#DatatypeProperty',
+    AnnotationProperty: 'http://www.w3.org/2002/07/owl#AnnotationProperty',
+    Datatype: 'http://www.w3.org/2002/07/owl#Datatype',
+    FunctionalProperty: 'http://www.w3.org/2002/07/owl#FunctionalProperty',
+    InverseFunctionalProperty: 'http://www.w3.org/2002/07/owl#InverseFunctionalProperty',
+    SymmetricProperty: 'http://www.w3.org/2002/07/owl#SymmetricProperty',
+    AsymmetricProperty: 'http://www.w3.org/2002/07/owl#AsymmetricProperty',
+    ReflexiveProperty: 'http://www.w3.org/2002/07/owl#ReflexiveProperty',
+    IrreflexiveProperty: 'http://www.w3.org/2002/07/owl#IrreflexiveProperty',
+    TransitiveProperty: 'http://www.w3.org/2002/07/owl#TransitiveProperty',
+    Restriction: 'http://www.w3.org/2002/07/owl#Restriction',
+    onProperty: 'http://www.w3.org/2002/07/owl#onProperty',
+    onClass: 'http://www.w3.org/2002/07/owl#onClass',
+    onDataRange: 'http://www.w3.org/2002/07/owl#onDataRange',
+    onDatatype: 'http://www.w3.org/2002/07/owl#onDatatype',
+    withRestrictions: 'http://www.w3.org/2002/07/owl#withRestrictions',
+    someValuesFrom: 'http://www.w3.org/2002/07/owl#someValuesFrom',
+    allValuesFrom: 'http://www.w3.org/2002/07/owl#allValuesFrom',
+    minCardinality: 'http://www.w3.org/2002/07/owl#minCardinality',
+    maxCardinality: 'http://www.w3.org/2002/07/owl#maxCardinality',
+    cardinality: 'http://www.w3.org/2002/07/owl#cardinality',
+    hasValue: 'http://www.w3.org/2002/07/owl#hasValue',
+    hasSelf: 'http://www.w3.org/2002/07/owl#hasSelf',
+    hasKey: 'http://www.w3.org/2002/07/owl#hasKey',
+    inverseOf: 'http://www.w3.org/2002/07/owl#inverseOf',
+    equivalentClass: 'http://www.w3.org/2002/07/owl#equivalentClass',
+    equivalentProperty: 'http://www.w3.org/2002/07/owl#equivalentProperty',
+    subPropertyOf: 'http://www.w3.org/2002/07/owl#subPropertyOf',
+    imports: 'http://www.w3.org/2002/07/owl#imports',
+    NamedIndividual: 'http://www.w3.org/2002/07/owl#NamedIndividual',
+    oneOf: 'http://www.w3.org/2002/07/owl#oneOf',
+};
+const XSD = {
+    boolean: 'http://www.w3.org/2001/XMLSchema#boolean',
+    decimal: 'http://www.w3.org/2001/XMLSchema#decimal',
+    double: 'http://www.w3.org/2001/XMLSchema#double',
+    integer: 'http://www.w3.org/2001/XMLSchema#integer',
+    string: 'http://www.w3.org/2001/XMLSchema#string',
+    length: 'http://www.w3.org/2001/XMLSchema#length',
+    minLength: 'http://www.w3.org/2001/XMLSchema#minLength',
+    maxLength: 'http://www.w3.org/2001/XMLSchema#maxLength',
+    minInclusive: 'http://www.w3.org/2001/XMLSchema#minInclusive',
+    maxInclusive: 'http://www.w3.org/2001/XMLSchema#maxInclusive',
+    minExclusive: 'http://www.w3.org/2001/XMLSchema#minExclusive',
+    maxExclusive: 'http://www.w3.org/2001/XMLSchema#maxExclusive',
+    pattern: 'http://www.w3.org/2001/XMLSchema#pattern',
+};
+const OML = {
+    ns: OWL_ONTOLOGY_NAMESPACE,
+    type: `${OWL_ONTOLOGY_NAMESPACE}type`,
+    name: `${OWL_ONTOLOGY_NAMESPACE}name`,
+    namespace: `${OWL_ONTOLOGY_NAMESPACE}namespace`,
+    prefix: `${OWL_ONTOLOGY_NAMESPACE}prefix`,
+    Aspect: `${OWL_ONTOLOGY_NAMESPACE}Aspect`,
+    Concept: `${OWL_ONTOLOGY_NAMESPACE}Concept`,
+    RelationEntity: `${OWL_ONTOLOGY_NAMESPACE}RelationEntity`,
+    RelationInstance: `${OWL_ONTOLOGY_NAMESPACE}RelationInstance`,
+    ConceptInstance: `${OWL_ONTOLOGY_NAMESPACE}ConceptInstance`,
+    Scalar: `${OWL_ONTOLOGY_NAMESPACE}Scalar`,
+    ForwardRelation: `${OWL_ONTOLOGY_NAMESPACE}ForwardRelation`,
+    UnreifiedRelation: `${OWL_ONTOLOGY_NAMESPACE}UnreifiedRelation`,
+    ReverseRelation: `${OWL_ONTOLOGY_NAMESPACE}ReverseRelation`,
+    relationEntity: `${OWL_ONTOLOGY_NAMESPACE}relationEntity`,
+    relationBase: `${OWL_ONTOLOGY_NAMESPACE}relationBase`,
+    hasSource: `${OWL_ONTOLOGY_NAMESPACE}hasSource`,
+    hasTarget: `${OWL_ONTOLOGY_NAMESPACE}hasTarget`,
+    Rule: `${OWL_ONTOLOGY_NAMESPACE}Rule`,
+    BuiltIn: `${OWL_ONTOLOGY_NAMESPACE}BuiltIn`,
+    Vocabulary: `${OWL_ONTOLOGY_NAMESPACE}Vocabulary`,
+    VocabularyBundle: `${OWL_ONTOLOGY_NAMESPACE}VocabularyBundle`,
+    Description: `${OWL_ONTOLOGY_NAMESPACE}Description`,
+    DescriptionBundle: `${OWL_ONTOLOGY_NAMESPACE}DescriptionBundle`,
+};
+const OML_TERM_TYPES = {
+    annotation: OWL.AnnotationProperty,
+    object: OWL.ObjectProperty,
+    datatype: OWL.DatatypeProperty,
+    class: OWL.Class,
+};
+const OML_TERMS = [
+    { iri: OML.type, rdfType: OML_TERM_TYPES.annotation },
+    { iri: OML.name, rdfType: OML_TERM_TYPES.annotation },
+    { iri: OML.namespace, rdfType: OML_TERM_TYPES.annotation },
+    { iri: OML.prefix, rdfType: OML_TERM_TYPES.annotation },
+    { iri: OML.relationEntity, rdfType: OML_TERM_TYPES.object },
+    { iri: OML.relationBase, rdfType: OML_TERM_TYPES.object },
+    { iri: OML.hasSource, rdfType: OML_TERM_TYPES.object },
+    { iri: OML.hasTarget, rdfType: OML_TERM_TYPES.object },
+    { iri: OML.Aspect, rdfType: OML_TERM_TYPES.class },
+    { iri: OML.Concept, rdfType: OML_TERM_TYPES.class },
+    { iri: OML.RelationEntity, rdfType: OML_TERM_TYPES.class },
+    { iri: OML.RelationInstance, rdfType: OML_TERM_TYPES.class },
+    { iri: OML.ConceptInstance, rdfType: OML_TERM_TYPES.class },
+    { iri: OML.Scalar, rdfType: OML_TERM_TYPES.class },
+    { iri: OML.ForwardRelation, rdfType: OML_TERM_TYPES.class },
+    { iri: OML.UnreifiedRelation, rdfType: OML_TERM_TYPES.class },
+    { iri: OML.ReverseRelation, rdfType: OML_TERM_TYPES.class },
+    { iri: OML.Rule, rdfType: OML_TERM_TYPES.class },
+    { iri: OML.BuiltIn, rdfType: OML_TERM_TYPES.class },
+    { iri: OML.Vocabulary, rdfType: OML_TERM_TYPES.class },
+    { iri: OML.VocabularyBundle, rdfType: OML_TERM_TYPES.class },
+    { iri: OML.Description, rdfType: OML_TERM_TYPES.class },
+    { iri: OML.DescriptionBundle, rdfType: OML_TERM_TYPES.class },
+];
+const SWRL = {
+    Imp: 'http://www.w3.org/2003/11/swrl#Imp',
+    AtomList: 'http://www.w3.org/2003/11/swrl#AtomList',
+    body: 'http://www.w3.org/2003/11/swrl#body',
+    head: 'http://www.w3.org/2003/11/swrl#head',
+    ClassAtom: 'http://www.w3.org/2003/11/swrl#ClassAtom',
+    DataRangeAtom: 'http://www.w3.org/2003/11/swrl#DataRangeAtom',
+    IndividualPropertyAtom: 'http://www.w3.org/2003/11/swrl#IndividualPropertyAtom',
+    DatavaluedPropertyAtom: 'http://www.w3.org/2003/11/swrl#DatavaluedPropertyAtom',
+    SameIndividualAtom: 'http://www.w3.org/2003/11/swrl#SameIndividualAtom',
+    DifferentIndividualsAtom: 'http://www.w3.org/2003/11/swrl#DifferentIndividualsAtom',
+    BuiltinAtom: 'http://www.w3.org/2003/11/swrl#BuiltinAtom',
+    Variable: 'http://www.w3.org/2003/11/swrl#Variable',
+    classPredicate: 'http://www.w3.org/2003/11/swrl#classPredicate',
+    dataRange: 'http://www.w3.org/2003/11/swrl#dataRange',
+    propertyPredicate: 'http://www.w3.org/2003/11/swrl#propertyPredicate',
+    argument1: 'http://www.w3.org/2003/11/swrl#argument1',
+    argument2: 'http://www.w3.org/2003/11/swrl#argument2',
+    builtin: 'http://www.w3.org/2003/11/swrl#builtin',
+    arguments: 'http://www.w3.org/2003/11/swrl#arguments',
+};
+const BUILT_IN_ONTOLOGIES = 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',
+    'http://www.w3.org/2003/11/swrl',
+    'http://www.w3.org/2003/11/swrlb',
+]);
+const { namedNode, literal, quad } = DataFactory;
+function fnv1a(input) {
+    let hash = 2166136261;
+    for (let i = 0; i < input.length; i += 1) {
+        hash ^= input.charCodeAt(i);
+        hash = (hash * 16777619) >>> 0;
+    }
+    return hash.toString(16);
+}
+function skolemize(namespace, ...inputs) {
+    if (inputs.length === 0) {
+        throw new Error('skolemize requires at least one input.');
+    }
+    const [kind, ...semanticInputs] = inputs;
+    const identity = semanticInputs.length > 0 ? semanticInputs.join('|') : kind;
+    const hash = fnv1a(identity);
+    return namedNode(`${namespace}${kind}-${hash}`);
+}
+/**
+ * Maps an OML ontology AST into asserted RDF triples.
+ * This mirrors the high-level structure of the Java Oml2Owl mapping while focusing on asserted triples.
+ */
+export class Oml2OwlMapper {
+    constructor(options = {
+        emitSwrlRules: true,
+        emitRelationEntitySwrlRules: true,
+    }) {
+        this.options = options;
+    }
+    toQuads(ontology) {
+        if (!isOntology(ontology)) {
+            return [];
+        }
+        const ctx = this.createContext(ontology);
+        const triples = [];
+        const ontologyNode = namedNode(ctx.ontologyIri);
+        // Ontology header
+        triples.push(this.quadWithGraph(ontologyNode, namedNode(RDF.type), namedNode(OWL.Ontology)));
+        triples.push(this.quadWithGraph(ontologyNode, namedNode(OML.type), namedNode(this.ontologyTypeIri(ontology))));
+        triples.push(this.quadWithGraph(ontologyNode, namedNode(OML.namespace), namedNode(ctx.namespace)));
+        triples.push(this.quadWithGraph(ontologyNode, namedNode(OML.prefix), literal(ctx.prefix)));
+        this.mapAnnotations(ontologyNode, ontology.ownedAnnotations, ctx, triples);
+        // Imports
+        ontology.ownedImports?.forEach((imp) => {
+            const importedIri = this.importedOntologyIri(imp, ctx);
+            if (importedIri && !BUILT_IN_ONTOLOGIES.has(importedIri)) {
+                triples.push(this.quadWithGraph(ontologyNode, namedNode(OWL.imports), namedNode(importedIri)));
+            }
+        });
+        if (ctx.ontologyIri !== OWL_ONTOLOGY_IRI) {
+            triples.push(this.quadWithGraph(ontologyNode, namedNode(OWL.imports), namedNode(OWL_ONTOLOGY_IRI)));
+        }
+        if (isVocabulary(ontology)) {
+            ontology.ownedStatements?.forEach((stmt) => {
+                this.mapVocabularyStatement(stmt, ctx, triples);
+            });
+        }
+        else if (isDescription(ontology)) {
+            ontology.ownedStatements?.forEach((stmt) => {
+                this.mapDescriptionStatement(stmt, ctx, triples);
+            });
+        }
+        return this.deduplicateQuads(triples);
+    }
+    mapVocabularyStatement(stmt, ctx, triples) {
+        if (isAspect(stmt)) {
+            this.mapAspect(stmt, ctx, triples);
+        }
+        else if (isConcept(stmt)) {
+            this.mapConcept(stmt, ctx, triples);
+        }
+        else if (isRelationEntity(stmt)) {
+            this.mapRelationEntity(stmt, ctx, triples);
+        }
+        else if (isScalar(stmt)) {
+            this.mapScalar(stmt, ctx, triples);
+        }
+        else if (isAnnotationProperty(stmt)) {
+            this.mapAnnotationProperty(stmt, ctx, triples);
+        }
+        else if (isScalarProperty(stmt)) {
+            this.mapScalarProperty(stmt, ctx, triples);
+        }
+        else if (isUnreifiedRelation(stmt)) {
+            this.mapUnreifiedRelation(stmt, ctx, triples);
+        }
+        else if (isRelation(stmt) && isReverseRelation(stmt)) {
+            this.mapReverseRelation(stmt, ctx, triples);
+        }
+        else if (isRule(stmt)) {
+            this.mapRule(stmt, ctx, triples);
+        }
+        else if (isBuiltIn(stmt)) {
+            this.mapBuiltIn(stmt, ctx, triples);
+        }
+    }
+    mapDescriptionStatement(stmt, ctx, triples) {
+        if (isConceptInstance(stmt)) {
+            this.mapConceptInstance(stmt, ctx, triples);
+        }
+        else if (isRelationInstance(stmt)) {
+            this.mapRelationInstance(stmt, ctx, triples);
+        }
+    }
+    mapAspect(aspect, ctx, triples) {
+        const iri = this.elementIri(aspect, ctx);
+        if (!iri)
+            return;
+        const node = namedNode(iri);
+        triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(OWL.Class)));
+        triples.push(this.quadWithGraph(node, namedNode(OML.type), namedNode(OML.Aspect)));
+        this.mapAnnotations(node, aspect.ownedAnnotations, ctx, triples);
+        this.applySpecializations(aspect.ownedSpecializations, node, ctx, triples);
+        this.applyEquivalences(aspect.ownedEquivalences, node, ctx, triples);
+        this.applyKeys(aspect.ownedKeys, node, ctx, triples);
+        this.applyPropertyRestrictions(aspect.ownedPropertyRestrictions, node, ctx, triples);
+    }
+    mapConcept(concept, ctx, triples) {
+        const iri = this.elementIri(concept, ctx);
+        if (!iri)
+            return;
+        const node = namedNode(iri);
+        triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(OWL.Class)));
+        triples.push(this.quadWithGraph(node, namedNode(OML.type), namedNode(OML.Concept)));
+        this.mapAnnotations(node, concept.ownedAnnotations, ctx, triples);
+        this.applySpecializations(concept.ownedSpecializations, node, ctx, triples);
+        this.applyEquivalences(concept.ownedEquivalences, node, ctx, triples);
+        this.applyKeys(concept.ownedKeys, node, ctx, triples);
+        this.applyPropertyRestrictions(concept.ownedPropertyRestrictions, node, ctx, triples);
+        this.applyInstanceEnumeration(concept.ownedEnumeration, node, ctx, triples);
+    }
+    mapRelationEntity(entity, ctx, triples) {
+        const classIri = this.elementIri(entity, ctx);
+        if (!classIri)
+            return;
+        const classNode = namedNode(classIri);
+        const forwardIri = this.getForwardIri(entity, ctx);
+        const forwardNode = namedNode(forwardIri);
+        triples.push(this.quadWithGraph(classNode, namedNode(RDF.type), namedNode(OWL.Class)));
+        triples.push(this.quadWithGraph(classNode, namedNode(OML.type), namedNode(OML.RelationEntity)));
+        this.mapAnnotations(classNode, entity.ownedAnnotations, ctx, triples);
+        // Forward relation object property
+        triples.push(this.quadWithGraph(forwardNode, namedNode(RDF.type), namedNode(OWL.ObjectProperty)));
+        triples.push(this.quadWithGraph(forwardNode, namedNode(OML.type), namedNode(OML.ForwardRelation)));
+        triples.push(this.quadWithGraph(forwardNode, namedNode(OML.relationEntity), classNode));
+        this.mapAnnotations(forwardNode, entity.forwardRelation?.ownedAnnotations, ctx, triples);
+        this.applyDomainRange(forwardNode, entity.sources, entity.targets, ctx, triples);
+        this.applyObjectPropertyCharacteristics(forwardNode, entity, triples);
+        if (entity.reverseRelation) {
+            this.mapReverseRelation(entity.reverseRelation, ctx, triples, entity);
+        }
+        this.applySpecializations(entity.ownedSpecializations, classNode, ctx, triples);
+        this.applyEquivalences(entity.ownedEquivalences, classNode, ctx, triples);
+        this.applyKeys(entity.ownedKeys, classNode, ctx, triples);
+        this.applyPropertyRestrictions(entity.ownedPropertyRestrictions, classNode, ctx, triples);
+        if (this.options.emitSwrlRules !== false || this.options.emitRelationEntitySwrlRules === true) {
+            this.mapRelationEntityForwardRule(classIri, forwardIri, ctx, triples);
+        }
+    }
+    mapUnreifiedRelation(relation, ctx, triples) {
+        const forwardIri = this.elementIri(relation, ctx);
+        if (!forwardIri)
+            return;
+        const forwardNode = namedNode(forwardIri);
+        triples.push(this.quadWithGraph(forwardNode, namedNode(RDF.type), namedNode(OWL.ObjectProperty)));
+        triples.push(this.quadWithGraph(forwardNode, namedNode(OML.type), namedNode(OML.UnreifiedRelation)));
+        this.mapAnnotations(forwardNode, relation.ownedAnnotations, ctx, triples);
+        this.applyDomainRange(forwardNode, relation.sources, relation.targets, ctx, triples);
+        this.applyObjectPropertyCharacteristics(forwardNode, relation, triples);
+        if (relation.reverseRelation) {
+            this.mapReverseRelation(relation.reverseRelation, ctx, triples, relation);
+        }
+        this.applySpecializations(relation.ownedSpecializations, forwardNode, ctx, triples, true);
+        this.applyPropertyEquivalences(relation.ownedEquivalences, forwardNode, ctx, triples);
+    }
+    mapReverseRelation(reverse, ctx, triples, relationBase) {
+        const base = relationBase ?? reverse.$container;
+        const reverseIri = this.elementIri(reverse, ctx);
+        const forwardIri = this.getForwardIri(base, ctx);
+        const baseIri = this.elementIri(base, ctx);
+        if (!reverseIri || !baseIri)
+            return;
+        const reverseNode = namedNode(reverseIri);
+        triples.push(this.quadWithGraph(reverseNode, namedNode(RDF.type), namedNode(OWL.ObjectProperty)));
+        triples.push(this.quadWithGraph(reverseNode, namedNode(OML.type), namedNode(OML.ReverseRelation)));
+        triples.push(this.quadWithGraph(reverseNode, namedNode(OML.relationBase), namedNode(baseIri)));
+        triples.push(this.quadWithGraph(reverseNode, namedNode(OWL.inverseOf), namedNode(forwardIri)));
+        this.mapAnnotations(reverseNode, reverse.ownedAnnotations, ctx, triples);
+    }
+    mapScalar(scalar, ctx, triples) {
+        const iri = this.elementIri(scalar, ctx);
+        if (!iri)
+            return;
+        const node = namedNode(iri);
+        triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(RDFS.Datatype)));
+        triples.push(this.quadWithGraph(node, namedNode(OML.type), namedNode(OML.Scalar)));
+        this.mapAnnotations(node, scalar.ownedAnnotations, ctx, triples);
+        this.applySpecializations(scalar.ownedSpecializations, node, ctx, triples);
+        this.applyScalarEquivalences(scalar.ownedEquivalences, node, ctx, triples);
+        this.applyScalarEnumeration(scalar.ownedEnumeration, node, ctx, triples);
+    }
+    mapAnnotationProperty(property, ctx, triples) {
+        const iri = this.elementIri(property, ctx);
+        if (!iri)
+            return;
+        const node = namedNode(iri);
+        triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(OWL.AnnotationProperty)));
+        this.mapAnnotations(node, property.ownedAnnotations, ctx, triples);
+        this.applySpecializations(property.ownedSpecializations, node, ctx, triples, true);
+        this.applyPropertyEquivalences(property.ownedEquivalences, node, ctx, triples);
+    }
+    mapScalarProperty(property, ctx, triples) {
+        const iri = this.elementIri(property, ctx);
+        if (!iri)
+            return;
+        const node = namedNode(iri);
+        triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(OWL.DatatypeProperty)));
+        this.mapAnnotations(node, property.ownedAnnotations, ctx, triples);
+        this.applyDomains(node, property.domains, ctx, triples);
+        this.applyRanges(node, property.ranges, ctx, triples);
+        if (property.functional) {
+            triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(OWL.FunctionalProperty)));
+        }
+        this.applySpecializations(property.ownedSpecializations, node, ctx, triples, true);
+        this.applyPropertyEquivalences(property.ownedEquivalences, node, ctx, triples);
+    }
+    mapConceptInstance(instance, ctx, triples) {
+        const iri = this.elementIri(instance, ctx);
+        if (!iri)
+            return;
+        const node = namedNode(iri);
+        const isDefinition = !instance.ref;
+        instance.ownedTypes?.forEach((typeAssertion) => this.mapTypeAssertion(node, typeAssertion, ctx, triples));
+        if (isDefinition) {
+            triples.push(this.quadWithGraph(node, namedNode(OML.type), namedNode(OML.ConceptInstance)));
+        }
+        this.mapAnnotations(node, instance.ownedAnnotations, ctx, triples);
+        instance.ownedPropertyValues?.forEach((pv) => this.mapPropertyValueAssertion(node, pv, ctx, triples));
+    }
+    mapRelationInstance(instance, ctx, triples) {
+        const iri = this.elementIri(instance, ctx);
+        if (!iri)
+            return;
+        const node = namedNode(iri);
+        const isDefinition = !instance.ref;
+        instance.ownedTypes?.forEach((typeAssertion) => this.mapTypeAssertion(node, typeAssertion, ctx, triples));
+        if (isDefinition) {
+            triples.push(this.quadWithGraph(node, namedNode(OML.type), namedNode(OML.RelationInstance)));
+        }
+        this.mapAnnotations(node, instance.ownedAnnotations, ctx, triples);
+        instance.sources?.forEach((src) => {
+            const srcIri = this.resolveIri(src, ctx);
+            if (srcIri) {
+                triples.push(this.quadWithGraph(node, namedNode(OML.hasSource), namedNode(srcIri)));
+            }
+        });
+        instance.targets?.forEach((tgt) => {
+            const tgtIri = this.resolveIri(tgt, ctx);
+            if (tgtIri) {
+                triples.push(this.quadWithGraph(node, namedNode(OML.hasTarget), namedNode(tgtIri)));
+            }
+        });
+        instance.ownedPropertyValues?.forEach((pv) => this.mapPropertyValueAssertion(node, pv, ctx, triples));
+    }
+    mapRule(rule, ctx, triples) {
+        if (this.options.emitSwrlRules === false)
+            return;
+        if (rule.ref)
+            return;
+        const iri = this.elementIri(rule, ctx);
+        if (!iri)
+            return;
+        const node = namedNode(iri);
+        triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(SWRL.Imp)));
+        triples.push(this.quadWithGraph(node, namedNode(OML.type), literal(OML.Rule)));
+        triples.push(this.quadWithGraph(node, namedNode(SWRL.body), this.createRdfList(ctx, this.mapRulePredicates(rule.antecedent, ctx, triples, iri, 'body'), triples, `rule-body|${iri}`)));
+        triples.push(this.quadWithGraph(node, namedNode(SWRL.head), this.createRdfList(ctx, this.mapRulePredicates(rule.consequent, ctx, triples, iri, 'head'), triples, `rule-head|${iri}`)));
+        this.mapAnnotations(node, rule.ownedAnnotations, ctx, triples);
+    }
+    mapBuiltIn(builtIn, ctx, triples) {
+        const iri = this.elementIri(builtIn, ctx);
+        if (!iri)
+            return;
+        const node = namedNode(iri);
+        triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(OML.BuiltIn)));
+        this.mapAnnotations(node, builtIn.ownedAnnotations, ctx, triples);
+    }
+    mapRelationEntityForwardRule(relationEntityIri, forwardIri, ctx, triples) {
+        const relationVar = this.toSwrlVariable('r', triples);
+        const sourceVar = this.toSwrlVariable('s', triples);
+        const targetVar = this.toSwrlVariable('t', triples);
+        const classAtom = skolemize(ctx.namespace, 'rule-atom', relationEntityIri, 'relationEntity', 'class');
+        triples.push(this.quadWithGraph(classAtom, namedNode(RDF.type), namedNode(SWRL.ClassAtom)));
+        triples.push(this.quadWithGraph(classAtom, namedNode(SWRL.classPredicate), namedNode(relationEntityIri)));
+        triples.push(this.quadWithGraph(classAtom, namedNode(SWRL.argument1), relationVar));
+        const sourceAtom = skolemize(ctx.namespace, 'rule-atom', relationEntityIri, 'relationEntity', 'source');
+        triples.push(this.quadWithGraph(sourceAtom, namedNode(RDF.type), namedNode(SWRL.IndividualPropertyAtom)));
+        triples.push(this.quadWithGraph(sourceAtom, namedNode(SWRL.propertyPredicate), namedNode(OML.hasSource)));
+        triples.push(this.quadWithGraph(sourceAtom, namedNode(SWRL.argument1), relationVar));
+        triples.push(this.quadWithGraph(sourceAtom, namedNode(SWRL.argument2), sourceVar));
+        const targetAtom = skolemize(ctx.namespace, 'rule-atom', relationEntityIri, 'relationEntity', 'target');
+        triples.push(this.quadWithGraph(targetAtom, namedNode(RDF.type), namedNode(SWRL.IndividualPropertyAtom)));
+        triples.push(this.quadWithGraph(targetAtom, namedNode(SWRL.propertyPredicate), namedNode(OML.hasTarget)));
+        triples.push(this.quadWithGraph(targetAtom, namedNode(SWRL.argument1), relationVar));
+        triples.push(this.quadWithGraph(targetAtom, namedNode(SWRL.argument2), targetVar));
+        const headAtom = skolemize(ctx.namespace, 'rule-atom', relationEntityIri, 'relationEntity', 'forward');
+        triples.push(this.quadWithGraph(headAtom, namedNode(RDF.type), namedNode(SWRL.IndividualPropertyAtom)));
+        triples.push(this.quadWithGraph(headAtom, namedNode(SWRL.propertyPredicate), namedNode(forwardIri)));
+        triples.push(this.quadWithGraph(headAtom, namedNode(SWRL.argument1), sourceVar));
+        triples.push(this.quadWithGraph(headAtom, namedNode(SWRL.argument2), targetVar));
+        const body = this.createSwrlAtomList(ctx, [classAtom, sourceAtom, targetAtom], triples, `relation-entity-rule-body|${relationEntityIri}`);
+        const head = this.createSwrlAtomList(ctx, [headAtom], triples, `relation-entity-rule-head|${relationEntityIri}`);
+        const ruleNode = namedNode(`${forwardIri}__derivation`);
+        triples.push(this.quadWithGraph(ruleNode, namedNode(RDF.type), namedNode(SWRL.Imp)));
+        triples.push(this.quadWithGraph(ruleNode, namedNode(SWRL.body), body));
+        triples.push(this.quadWithGraph(ruleNode, namedNode(SWRL.head), head));
+    }
+    mapRulePredicates(predicates, ctx, triples, ruleIri, side) {
+        return predicates.flatMap((predicate, index) => this.mapRulePredicate(predicate, ctx, triples, ruleIri, side, index));
+    }
+    mapRulePredicate(predicate, ctx, triples, ruleIri, side, index) {
+        const atomSeed = `${ruleIri}|${side}|${index}`;
+        if (isTypePredicate(predicate)) {
+            const typeIri = this.resolveIri(predicate.type, ctx);
+            if (!typeIri)
+                return [];
+            if (predicate.type.ref && isScalar(predicate.type.ref)) {
+                const argument = this.toSwrlDArgument(predicate.argument, ctx, triples);
+                if (!argument)
+                    return [];
+                const atom = skolemize(ctx.namespace, 'rule-atom', atomSeed, 'type', 'dataRange', typeIri, this.termKey(argument));
+                triples.push(this.quadWithGraph(atom, namedNode(RDF.type), namedNode(SWRL.DataRangeAtom)));
+                triples.push(this.quadWithGraph(atom, namedNode(SWRL.dataRange), namedNode(typeIri)));
+                triples.push(this.quadWithGraph(atom, namedNode(SWRL.argument1), argument));
+                return [atom];
+            }
+            const argument = this.toSwrlIArgument(predicate.argument, ctx, triples);
+            if (!argument)
+                return [];
+            const atom = skolemize(ctx.namespace, 'rule-atom', atomSeed, 'type', 'class', typeIri, this.termKey(argument));
+            triples.push(this.quadWithGraph(atom, namedNode(RDF.type), namedNode(SWRL.ClassAtom)));
+            triples.push(this.quadWithGraph(atom, namedNode(SWRL.classPredicate), namedNode(typeIri)));
+            triples.push(this.quadWithGraph(atom, namedNode(SWRL.argument1), argument));
+            return [atom];
+        }
+        if (isRelationEntityPredicate(predicate)) {
+            const typeIri = this.resolveIri(predicate.type, ctx);
+            const argument = this.toSwrlIArgument(predicate.argument, ctx, triples);
+            const argument1 = this.toSwrlIArgument(predicate.argument1, ctx, triples);
+            const argument2 = this.toSwrlIArgument(predicate.argument2, ctx, triples);
+            if (!typeIri || !argument || !argument1 || !argument2)
+                return [];
+            const typeAtom = skolemize(ctx.namespace, 'rule-atom', atomSeed, 'relationEntity', 'type', typeIri, this.termKey(argument));
+            triples.push(this.quadWithGraph(typeAtom, namedNode(RDF.type), namedNode(SWRL.ClassAtom)));
+            triples.push(this.quadWithGraph(typeAtom, namedNode(SWRL.classPredicate), namedNode(typeIri)));
+            triples.push(this.quadWithGraph(typeAtom, namedNode(SWRL.argument1), argument));
+            const sourceAtom = skolemize(ctx.namespace, 'rule-atom', atomSeed, 'relationEntity', 'source', this.termKey(argument), this.termKey(argument1));
+            triples.push(this.quadWithGraph(sourceAtom, namedNode(RDF.type), namedNode(SWRL.IndividualPropertyAtom)));
+            triples.push(this.quadWithGraph(sourceAtom, namedNode(SWRL.propertyPredicate), namedNode(OML.hasSource)));
+            triples.push(this.quadWithGraph(sourceAtom, namedNode(SWRL.argument1), argument));
+            triples.push(this.quadWithGraph(sourceAtom, namedNode(SWRL.argument2), argument1));
+            const targetAtom = skolemize(ctx.namespace, 'rule-atom', atomSeed, 'relationEntity', 'target', this.termKey(argument), this.termKey(argument2));
+            triples.push(this.quadWithGraph(targetAtom, namedNode(RDF.type), namedNode(SWRL.IndividualPropertyAtom)));
+            triples.push(this.quadWithGraph(targetAtom, namedNode(SWRL.propertyPredicate), namedNode(OML.hasTarget)));
+            triples.push(this.quadWithGraph(targetAtom, namedNode(SWRL.argument1), argument));
+            triples.push(this.quadWithGraph(targetAtom, namedNode(SWRL.argument2), argument2));
+            return [typeAtom, sourceAtom, targetAtom];
+        }
+        if (isPropertyPredicate(predicate)) {
+            const propertyIri = this.resolveIri(predicate.property, ctx);
+            const argument1 = this.toSwrlIArgument(predicate.argument1, ctx, triples);
+            if (!propertyIri || !argument1)
+                return [];
+            const isDataPredicate = (predicate.property.ref && isScalarProperty(predicate.property.ref)) ||
+                (predicate.property.ref && isAnnotationProperty(predicate.property.ref) && Boolean(predicate.argument2.literal));
+            const atom = isDataPredicate
+                ? skolemize(ctx.namespace, 'rule-atom', atomSeed, 'property', 'data', propertyIri, this.termKey(argument1))
+                : skolemize(ctx.namespace, 'rule-atom', atomSeed, 'property', 'object', propertyIri, this.termKey(argument1));
+            if (isDataPredicate) {
+                const argument2 = this.toSwrlDArgument(predicate.argument2, ctx, triples);
+                if (!argument2)
+                    return [];
+                triples.push(this.quadWithGraph(atom, namedNode(RDF.type), namedNode(SWRL.DatavaluedPropertyAtom)));
+                triples.push(this.quadWithGraph(atom, namedNode(SWRL.propertyPredicate), namedNode(propertyIri)));
+                triples.push(this.quadWithGraph(atom, namedNode(SWRL.argument1), argument1));
+                triples.push(this.quadWithGraph(atom, namedNode(SWRL.argument2), argument2));
+            }
+            else {
+                const argument2 = this.toSwrlIArgument(predicate.argument2, ctx, triples);
+                if (!argument2)
+                    return [];
+                triples.push(this.quadWithGraph(atom, namedNode(RDF.type), namedNode(SWRL.IndividualPropertyAtom)));
+                triples.push(this.quadWithGraph(atom, namedNode(SWRL.propertyPredicate), namedNode(propertyIri)));
+                triples.push(this.quadWithGraph(atom, namedNode(SWRL.argument1), argument1));
+                triples.push(this.quadWithGraph(atom, namedNode(SWRL.argument2), argument2));
+            }
+            return [atom];
+        }
+        if (isSameAsPredicate(predicate)) {
+            const argument1 = this.toSwrlIArgument(predicate.argument1, ctx, triples);
+            const argument2 = this.toSwrlIArgument(predicate.argument2, ctx, triples);
+            if (!argument1 || !argument2)
+                return [];
+            const atom = skolemize(ctx.namespace, 'rule-atom', atomSeed, 'sameAs', this.termKey(argument1), this.termKey(argument2));
+            triples.push(this.quadWithGraph(atom, namedNode(RDF.type), namedNode(SWRL.SameIndividualAtom)));
+            triples.push(this.quadWithGraph(atom, namedNode(SWRL.argument1), argument1));
+            triples.push(this.quadWithGraph(atom, namedNode(SWRL.argument2), argument2));
+            return [atom];
+        }
+        if (isDifferentFromPredicate(predicate)) {
+            const argument1 = this.toSwrlIArgument(predicate.argument1, ctx, triples);
+            const argument2 = this.toSwrlIArgument(predicate.argument2, ctx, triples);
+            if (!argument1 || !argument2)
+                return [];
+            const atom = skolemize(ctx.namespace, 'rule-atom', atomSeed, 'differentFrom', this.termKey(argument1), this.termKey(argument2));
+            triples.push(this.quadWithGraph(atom, namedNode(RDF.type), namedNode(SWRL.DifferentIndividualsAtom)));
+            triples.push(this.quadWithGraph(atom, namedNode(SWRL.argument1), argument1));
+            triples.push(this.quadWithGraph(atom, namedNode(SWRL.argument2), argument2));
+            return [atom];
+        }
+        if (isBuiltInPredicate(predicate)) {
+            const builtInIri = this.resolveIri(predicate.builtIn, ctx);
+            if (!builtInIri)
+                return [];
+            const argumentsList = predicate.arguments
+                .map((argument) => this.toSwrlDArgument(argument, ctx, triples))
+                .filter((argument) => Boolean(argument));
+            const atom = skolemize(ctx.namespace, 'rule-atom', atomSeed, 'builtin', builtInIri, ...argumentsList.map((argument) => this.termKey(argument)));
+            triples.push(this.quadWithGraph(atom, namedNode(RDF.type), namedNode(SWRL.BuiltinAtom)));
+            triples.push(this.quadWithGraph(atom, namedNode(SWRL.builtin), namedNode(builtInIri)));
+            triples.push(this.quadWithGraph(atom, namedNode(SWRL.arguments), this.createRdfList(ctx, argumentsList, triples, `rule-builtin-args|${atomSeed}|${builtInIri}`)));
+            return [atom];
+        }
+        return [];
+    }
+    toSwrlIArgument(argument, ctx, triples) {
+        if (argument.variable) {
+            return this.toSwrlVariable(argument.variable, triples);
+        }
+        const instanceIri = this.resolveIri(argument.instance, ctx);
+        if (!instanceIri)
+            return undefined;
+        return namedNode(instanceIri);
+    }
+    toSwrlDArgument(argument, ctx, triples) {
+        if (argument.variable) {
+            return this.toSwrlVariable(argument.variable, triples);
+        }
+        if (argument.literal) {
+            return this.toLiteral(argument.literal, ctx);
+        }
+        return undefined;
+    }
+    toSwrlVariable(variable, triples) {
+        const node = namedNode(`urn:swrl:var#${variable}`);
+        triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(SWRL.Variable)));
+        return node;
+    }
+    mapTypeAssertion(subject, assertion, ctx, triples) {
+        const typeIri = this.resolveIri(assertion.type, ctx);
+        if (typeIri) {
+            triples.push(this.quadWithGraph(subject, namedNode(RDF.type), namedNode(typeIri)));
+        }
+    }
+    mapPropertyValueAssertion(subject, assertion, ctx, triples) {
+        const propertyIri = this.resolveIri(assertion.property, ctx);
+        if (!propertyIri)
+            return;
+        const propertyNode = namedNode(propertyIri);
+        assertion.literalValues?.forEach((lit) => {
+            const litNode = this.toLiteral(lit, ctx);
+            if (litNode) {
+                triples.push(this.quadWithGraph(subject, propertyNode, litNode));
+            }
+        });
+        assertion.referencedValues?.forEach((ref) => {
+            const objIri = this.resolveIri(ref, ctx);
+            if (objIri) {
+                triples.push(this.quadWithGraph(subject, propertyNode, namedNode(objIri)));
+            }
+        });
+        assertion.containedValues?.forEach((contained, index) => {
+            const valueNode = skolemize(ctx.namespace, 'anon', this.termKey(subject), propertyIri, String(index));
+            triples.push(this.quadWithGraph(subject, propertyNode, valueNode));
+            this.mapAnonymousInstance(contained, valueNode, ctx, triples, subject);
+        });
+    }
+    mapAnnotations(subject, annotations, ctx, triples) {
+        annotations?.forEach((annotation) => {
+            const propertyIri = this.resolveIri(annotation.property, ctx);
+            if (!propertyIri)
+                return;
+            const propertyNode = namedNode(propertyIri);
+            annotation.literalValues?.forEach((lit) => {
+                const litNode = this.toLiteral(lit, ctx);
+                if (litNode) {
+                    triples.push(this.quadWithGraph(subject, propertyNode, litNode));
+                }
+            });
+            annotation.referencedValues?.forEach((ref) => {
+                const objIri = this.resolveIri(ref, ctx);
+                if (objIri) {
+                    triples.push(this.quadWithGraph(subject, propertyNode, namedNode(objIri)));
+                }
+            });
+        });
+    }
+    mapAnonymousInstance(instance, node, ctx, triples, source) {
+        if (isAnonymousConceptInstance(instance)) {
+            if (instance.type) {
+                const typeIri = this.resolveIri(instance.type, ctx);
+                if (typeIri) {
+                    triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(typeIri)));
+                }
+            }
+            triples.push(this.quadWithGraph(node, namedNode(OML.type), namedNode(OML.ConceptInstance)));
+            instance.ownedPropertyValues?.forEach((pv, index) => this.mapPropertyValueAssertion(node, pv, ctx, triples));
+        }
+        else if (isAnonymousRelationInstance(instance)) {
+            if (source) {
+                triples.push(this.quadWithGraph(node, namedNode(OML.hasSource), source));
+            }
+            const targetIri = this.resolveIri(instance.target, ctx);
+            if (targetIri) {
+                triples.push(this.quadWithGraph(node, namedNode(OML.hasTarget), namedNode(targetIri)));
+            }
+            triples.push(this.quadWithGraph(node, namedNode(OML.type), namedNode(OML.RelationInstance)));
+            instance.ownedPropertyValues?.forEach((pv, index) => this.mapPropertyValueAssertion(node, pv, ctx, triples));
+        }
+    }
+    applySpecializations(axioms, subNode, ctx, triples, isProperty = false) {
+        axioms?.forEach((ax) => {
+            const superIri = this.resolveIri(ax.superTerm, ctx);
+            if (superIri) {
+                triples.push(this.quadWithGraph(subNode, namedNode(isProperty ? RDFS.subPropertyOf : RDFS.subClassOf), namedNode(superIri)));
+            }
+        });
+    }
+    applyEquivalences(axioms, classNode, ctx, triples) {
+        axioms?.forEach((ax) => {
+            ax.superTerms?.forEach((sup) => {
+                const superIri = this.resolveIri(sup, ctx);
+                if (superIri) {
+                    triples.push(this.quadWithGraph(classNode, namedNode(OWL.equivalentClass), namedNode(superIri)));
+                }
+            });
+            this.applyPropertyRestrictions(ax.ownedPropertyRestrictions, classNode, ctx, triples);
+        });
+    }
+    applyKeys(axioms, classNode, ctx, triples) {
+        axioms?.forEach((ax) => {
+            const propertyNodes = ax.properties
+                .map((property) => this.resolveIri(property, ctx))
+                .filter((iri) => Boolean(iri))
+                .map((iri) => namedNode(iri));
+            if (!propertyNodes.length)
+                return;
+            const listHead = this.createRdfList(ctx, propertyNodes, triples, `keys|${classNode.value}|${propertyNodes.map((node) => node.value).join('|')}`);
+            triples.push(this.quadWithGraph(classNode, namedNode(OWL.hasKey), listHead));
+        });
+    }
+    applyScalarEquivalences(axioms, scalarNode, ctx, triples) {
+        axioms?.forEach((ax) => {
+            ax.superTerms?.forEach((sup) => {
+                const superIri = this.resolveIri(sup, ctx);
+                if (superIri) {
+                    triples.push(this.quadWithGraph(scalarNode, namedNode(OWL.equivalentClass), namedNode(superIri)));
+                }
+            });
+            this.createScalarFacetRestrictionNodes(ax, ctx, triples).forEach((restrictionNode) => {
+                triples.push(this.quadWithGraph(scalarNode, namedNode(OWL.equivalentClass), restrictionNode));
+            });
+        });
+    }
+    applyInstanceEnumeration(enumeration, classNode, ctx, triples) {
+        const instances = enumeration?.instances ?? [];
+        if (!instances.length)
+            return;
+        const instanceNodes = instances
+            .map((instance) => this.resolveIri(instance, ctx))
+            .filter((iri) => Boolean(iri))
+            .map((iri) => namedNode(iri));
+        if (!instanceNodes.length)
+            return;
+        const listHead = this.createRdfList(ctx, instanceNodes, triples, `instance-enum|${classNode.value}|${instanceNodes.map((node) => node.value).join('|')}`);
+        triples.push(this.quadWithGraph(classNode, namedNode(OWL.oneOf), listHead));
+    }
+    applyScalarEnumeration(enumeration, scalarNode, ctx, triples) {
+        const literals = enumeration?.literals ?? [];
+        if (!literals.length)
+            return;
+        const literalNodes = literals
+            .map((lit) => this.toLiteral(lit, ctx))
+            .filter((node) => Boolean(node));
+        if (!literalNodes.length)
+            return;
+        const literalSignature = literalNodes.map((node) => this.termKey(node)).join('|');
+        const listHead = this.createRdfList(ctx, literalNodes, triples, `scalar-enum|${scalarNode.value}|${literalSignature}`);
+        const dataRangeNode = skolemize(ctx.namespace, 'datatype-enum', scalarNode.value, literalSignature);
+        triples.push(this.quadWithGraph(dataRangeNode, namedNode(RDF.type), namedNode(RDFS.Datatype)));
+        triples.push(this.quadWithGraph(dataRangeNode, namedNode(OWL.oneOf), listHead));
+        triples.push(this.quadWithGraph(scalarNode, namedNode(OWL.equivalentClass), dataRangeNode));
+    }
+    applyPropertyEquivalences(axioms, propertyNode, ctx, triples) {
+        axioms?.forEach((ax) => {
+            ax.superTerms?.forEach((sup) => {
+                const superIri = this.resolveIri(sup, ctx);
+                if (superIri) {
+                    triples.push(this.quadWithGraph(propertyNode, namedNode(OWL.equivalentProperty), namedNode(superIri)));
+                }
+            });
+        });
+    }
+    applyPropertyRestrictions(axioms, classNode, ctx, triples) {
+        axioms?.forEach((ax) => {
+            const restrictionNode = this.mapRestriction(ax, ctx, triples);
+            if (restrictionNode) {
+                triples.push(this.quadWithGraph(classNode, namedNode(RDFS.subClassOf), restrictionNode));
+            }
+        });
+    }
+    createScalarFacetRestrictionNodes(axiom, ctx, triples) {
+        const facets = [];
+        axiom.length.forEach((value) => {
+            facets.push({ iri: XSD.length, value: literal(String(value), namedNode(XSD.integer)) });
+        });
+        axiom.minLength.forEach((value) => {
+            facets.push({ iri: XSD.minLength, value: literal(String(value), namedNode(XSD.integer)) });
+        });
+        axiom.maxLength.forEach((value) => {
+            facets.push({ iri: XSD.maxLength, value: literal(String(value), namedNode(XSD.integer)) });
+        });
+        axiom.pattern.forEach((value) => {
+            facets.push({ iri: XSD.pattern, value: literal(value) });
+        });
+        axiom.language.forEach((value) => {
+            facets.push({ iri: RDF.langRange, value: literal(value) });
+        });
+        axiom.minInclusive.forEach((value) => {
+            const node = this.toLiteral(value, ctx);
+            if (node)
+                facets.push({ iri: XSD.minInclusive, value: node });
+        });
+        axiom.minExclusive.forEach((value) => {
+            const node = this.toLiteral(value, ctx);
+            if (node)
+                facets.push({ iri: XSD.minExclusive, value: node });
+        });
+        axiom.maxInclusive.forEach((value) => {
+            const node = this.toLiteral(value, ctx);
+            if (node)
+                facets.push({ iri: XSD.maxInclusive, value: node });
+        });
+        axiom.maxExclusive.forEach((value) => {
+            const node = this.toLiteral(value, ctx);
+            if (node)
+                facets.push({ iri: XSD.maxExclusive, value: node });
+        });
+        if (!facets.length)
+            return [];
+        const datatypes = axiom.superTerms
+            .map((sup) => this.resolveIri(sup, ctx))
+            .filter((iri) => Boolean(iri));
+        if (!datatypes.length) {
+            if (axiom.language.length > 0) {
+                datatypes.push(RDF.langString);
+            }
+            else if (axiom.length.length || axiom.minLength.length || axiom.maxLength.length || axiom.pattern.length) {
+                datatypes.push(XSD.string);
+            }
+            else {
+                const lexicalFacet = facets.find((facet) => facet.value.termType === 'Literal');
+                if (lexicalFacet && lexicalFacet.value.termType === 'Literal') {
+                    datatypes.push(lexicalFacet.value.datatype.value);
+                }
+            }
+        }
+        return datatypes.map((datatypeIri) => {
+            const facetSignature = facets.map((facet) => `${facet.iri}=${this.termKey(facet.value)}`).join('|');
+            const restrictionNode = skolemize(ctx.namespace, 'restriction', 'datatype', datatypeIri, facetSignature);
+            triples.push(this.quadWithGraph(restrictionNode, namedNode(OWL.onDatatype), namedNode(datatypeIri)));
+            const restrictionItems = facets.map((facet, index) => {
+                const facetNode = skolemize(ctx.namespace, 'restriction-facet', datatypeIri, String(index), facet.iri, this.termKey(facet.value));
+                triples.push(this.quadWithGraph(facetNode, namedNode(facet.iri), facet.value));
+                return facetNode;
+            });
+            const listHead = this.createRdfList(ctx, restrictionItems, triples, `restriction-facets|${datatypeIri}|${facetSignature}`);
+            triples.push(this.quadWithGraph(restrictionNode, namedNode(OWL.withRestrictions), listHead));
+            return restrictionNode;
+        });
+    }
+    mapRestriction(axiom, ctx, triples) {
+        if (isPropertyRangeRestrictionAxiom(axiom)) {
+            return this.mapRangeRestriction(axiom, ctx, triples);
+        }
+        if (isPropertyCardinalityRestrictionAxiom(axiom)) {
+            return this.mapCardinalityRestriction(axiom, ctx, triples);
+        }
+        if (isPropertyValueRestrictionAxiom(axiom)) {
+            return this.mapValueRestriction(axiom, ctx, triples);
+        }
+        if (isPropertySelfRestrictionAxiom(axiom)) {
+            return this.mapSelfRestriction(axiom, ctx, triples);
+        }
+        return undefined;
+    }
+    mapRangeRestriction(axiom, ctx, triples) {
+        const propertyIri = this.resolveIri(axiom.property, ctx);
+        const rangeIri = this.resolveIri(axiom.range, ctx);
+        if (!propertyIri || !rangeIri)
+            return undefined;
+        const node = skolemize(ctx.namespace, 'restriction', propertyIri, axiom.kind, rangeIri, 'range');
+        triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(OWL.Restriction)));
+        triples.push(this.quadWithGraph(node, namedNode(OWL.onProperty), namedNode(propertyIri)));
+        const predicate = axiom.kind === 'all' ? OWL.allValuesFrom : OWL.someValuesFrom;
+        triples.push(this.quadWithGraph(node, namedNode(predicate), namedNode(rangeIri)));
+        return node;
+    }
+    mapCardinalityRestriction(axiom, ctx, triples) {
+        const propertyIri = this.resolveIri(axiom.property, ctx);
+        if (!propertyIri)
+            return undefined;
+        const resolvedProperty = axiom.property?.ref;
+        const rangeIri = this.resolveIri(axiom.range, ctx) ?? '';
+        const node = skolemize(ctx.namespace, 'restriction', propertyIri, axiom.kind, String(axiom.cardinality), rangeIri);
+        triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(OWL.Restriction)));
+        triples.push(this.quadWithGraph(node, namedNode(OWL.onProperty), namedNode(propertyIri)));
+        if (rangeIri) {
+            const on = resolvedProperty && isScalarProperty(resolvedProperty) ? OWL.onDataRange : OWL.onClass;
+            triples.push(this.quadWithGraph(node, namedNode(on), namedNode(rangeIri)));
+        }
+        const cardPredicate = axiom.kind === 'min'
+            ? OWL.minCardinality
+            : axiom.kind === 'max'
+                ? OWL.maxCardinality
+                : OWL.cardinality;
+        triples.push(this.quadWithGraph(node, namedNode(cardPredicate), literal(String(axiom.cardinality), namedNode(XSD.integer))));
+        return node;
+    }
+    mapValueRestriction(axiom, ctx, triples) {
+        const propertyIri = this.resolveIri(axiom.property, ctx);
+        if (!propertyIri)
+            return undefined;
+        const valueSeed = axiom.literalValue
+            ? this.literalKey(axiom.literalValue, ctx)
+            : axiom.referencedValue
+                ? this.resolveIri(axiom.referencedValue, ctx) ?? ''
+                : 'contained';
+        const node = skolemize(ctx.namespace, 'restriction', propertyIri, 'hasValue', valueSeed);
+        triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(OWL.Restriction)));
+        triples.push(this.quadWithGraph(node, namedNode(OWL.onProperty), namedNode(propertyIri)));
+        if (axiom.literalValue) {
+            const litNode = this.toLiteral(axiom.literalValue, ctx);
+            if (litNode) {
+                triples.push(this.quadWithGraph(node, namedNode(OWL.hasValue), litNode));
+            }
+        }
+        else if (axiom.referencedValue) {
+            const refIri = this.resolveIri(axiom.referencedValue, ctx);
+            if (refIri) {
+                triples.push(this.quadWithGraph(node, namedNode(OWL.hasValue), namedNode(refIri)));
+            }
+        }
+        else if (axiom.containedValue) {
+            const valueNode = skolemize(ctx.namespace, 'anon', propertyIri, 'hasValue');
+            triples.push(this.quadWithGraph(node, namedNode(OWL.hasValue), valueNode));
+            this.mapAnonymousInstance(axiom.containedValue, valueNode, ctx, triples);
+        }
+        return node;
+    }
+    mapSelfRestriction(axiom, ctx, triples) {
+        const propertyIri = this.resolveIri(axiom.property, ctx);
+        if (!propertyIri)
+            return undefined;
+        const node = skolemize(ctx.namespace, 'restriction', propertyIri, 'hasSelf');
+        triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(OWL.Restriction)));
+        triples.push(this.quadWithGraph(node, namedNode(OWL.onProperty), namedNode(propertyIri)));
+        triples.push(this.quadWithGraph(node, namedNode(OWL.hasSelf), literal('true', namedNode(XSD.boolean))));
+        return node;
+    }
+    applyDomainRange(propertyNode, domains, ranges, ctx, triples) {
+        this.applyDomains(propertyNode, domains, ctx, triples);
+        this.applyRanges(propertyNode, ranges, ctx, triples);
+    }
+    applyDomains(propertyNode, domains, ctx, triples) {
+        domains?.forEach((d) => {
+            const iri = this.resolveIri(d, ctx);
+            if (iri) {
+                triples.push(this.quadWithGraph(propertyNode, namedNode(RDFS.domain), namedNode(iri)));
+            }
+        });
+    }
+    applyRanges(propertyNode, ranges, ctx, triples) {
+        ranges?.forEach((r) => {
+            const iri = this.resolveIri(r, ctx);
+            if (iri) {
+                triples.push(this.quadWithGraph(propertyNode, namedNode(RDFS.range), namedNode(iri)));
+            }
+        });
+    }
+    applyObjectPropertyCharacteristics(propertyNode, relation, triples) {
+        if (relation.functional) {
+            triples.push(this.quadWithGraph(propertyNode, namedNode(RDF.type), namedNode(OWL.FunctionalProperty)));
+        }
+        if (relation.inverseFunctional) {
+            triples.push(this.quadWithGraph(propertyNode, namedNode(RDF.type), namedNode(OWL.InverseFunctionalProperty)));
+        }
+        if (relation.symmetric) {
+            triples.push(this.quadWithGraph(propertyNode, namedNode(RDF.type), namedNode(OWL.SymmetricProperty)));
+        }
+        if (relation.asymmetric) {
+            triples.push(this.quadWithGraph(propertyNode, namedNode(RDF.type), namedNode(OWL.AsymmetricProperty)));
+        }
+        if (relation.reflexive) {
+            triples.push(this.quadWithGraph(propertyNode, namedNode(RDF.type), namedNode(OWL.ReflexiveProperty)));
+        }
+        if (relation.irreflexive) {
+            triples.push(this.quadWithGraph(propertyNode, namedNode(RDF.type), namedNode(OWL.IrreflexiveProperty)));
+        }
+        if (relation.transitive) {
+            triples.push(this.quadWithGraph(propertyNode, namedNode(RDF.type), namedNode(OWL.TransitiveProperty)));
+        }
+    }
+    quadWithGraph(subject, predicate, object) {
+        return quad(subject, predicate, object);
+    }
+    createRdfList(ctx, items, triples, listSeed) {
+        if (!items.length) {
+            return namedNode(RDF.nil);
+        }
+        const base = `${listSeed}|${items.map((item) => this.termKey(item)).join('|')}`;
+        const head = skolemize(ctx.namespace, 'list', base, '0');
+        let current = head;
+        items.forEach((item, index) => {
+            triples.push(this.quadWithGraph(current, namedNode(RDF.first), item));
+            if (index === items.length - 1) {
+                triples.push(this.quadWithGraph(current, namedNode(RDF.rest), namedNode(RDF.nil)));
+            }
+            else {
+                const next = skolemize(ctx.namespace, 'list', base, String(index + 1));
+                triples.push(this.quadWithGraph(current, namedNode(RDF.rest), next));
+                current = next;
+            }
+        });
+        return head;
+    }
+    createSwrlAtomList(ctx, items, triples, listSeed) {
+        const head = this.createRdfList(ctx, items, triples, listSeed);
+        if (head.value === RDF.nil) {
+            return head;
+        }
+        let current = head;
+        while (current.value !== RDF.nil) {
+            triples.push(this.quadWithGraph(current, namedNode(RDF.type), namedNode(SWRL.AtomList)));
+            const next = triples.find((quad) => quad.subject.termType === 'NamedNode'
+                && quad.subject.value === current.value
+                && quad.predicate.value === RDF.rest
+                && quad.object.termType === 'NamedNode')?.object;
+            if (!next || next.termType !== 'NamedNode') {
+                break;
+            }
+            current = next;
+        }
+        return head;
+    }
+    createContext(ontology) {
+        const namespace = this.normalizeNamespace(ontology.namespace ?? '');
+        const prefix = ontology.prefix ?? '';
+        return {
+            ontologyIri: namespace.replace(/[\/#]+$/, ''),
+            namespace,
+            prefix,
+            prefixes: this.buildPrefixMap(ontology),
+        };
+    }
+    buildPrefixMap(ontology) {
+        const map = {};
+        const ns = this.normalizeNamespace(ontology.namespace ?? '');
+        const prefix = ontology.prefix;
+        if (prefix) {
+            map[prefix] = ns;
+        }
+        ontology.ownedImports?.forEach((imp) => {
+            const imported = imp.imported?.ref;
+            const importedNs = imported ? this.normalizeNamespace(imported.namespace ?? '') : undefined;
+            const importedPrefix = imp.prefix ?? imported?.prefix;
+            if (importedPrefix && importedNs) {
+                map[importedPrefix] = importedNs;
+            }
+        });
+        return map;
+    }
+    ontologyTypeIri(ontology) {
+        if (isVocabulary(ontology))
+            return OML.Vocabulary;
+        if (isVocabularyBundle(ontology))
+            return OML.VocabularyBundle;
+        if (isDescription(ontology))
+            return OML.Description;
+        if (isDescriptionBundle(ontology))
+            return OML.DescriptionBundle;
+        return OML.Vocabulary;
+    }
+    importedOntologyIri(imp, ctx) {
+        if (imp.imported?.ref && isOntology(imp.imported.ref)) {
+            return this.normalizeNamespace(imp.imported.ref.namespace ?? '').replace(/[\/#]+$/, '');
+        }
+        const refText = imp.imported?.$refText ?? imp.imported?.refText;
+        if (refText) {
+            return this.resolveFromRefText(refText, ctx)?.replace(/[\/#]+$/, '');
+        }
+        return undefined;
+    }
+    getForwardIri(base, ctx) {
+        if (isRelationEntity(base)) {
+            if (base.forwardRelation?.name) {
+                const ont = this.getOntology(base);
+                const ns = this.normalizeNamespace(ont?.namespace ?? ctx.namespace);
+                return `${ns}${base.forwardRelation.name}`;
+            }
+            const name = (base.ref?.name ?? base.name ?? '').replace(/^\^/, '');
+            return `${ctx.namespace}has${this.toFirstUpper(name)}Forward`;
+        }
+        return this.elementIri(base, ctx) ?? '';
+    }
+    elementIri(element, ctx) {
+        if (!element)
+            return undefined;
+        // If this is a ref wrapper, resolve to the referenced element's IRI.
+        if (element.ref?.ref) {
+            return this.elementIri(element.ref.ref, ctx);
+        }
+        const name = element.name ?? element.ref?.name;
+        if (!name)
+            return undefined;
+        const ontology = this.getOntology(element);
+        const namespace = ontology ? this.normalizeNamespace(ontology.namespace ?? ctx.namespace) : ctx.namespace;
+        return `${namespace}${name.replace(/^\^/, '')}`;
+    }
+    getOntology(element) {
+        let current = element;
+        while (current && !isOntology(current)) {
+            current = current.$container;
+        }
+        return current;
+    }
+    resolveIri(ref, ctx) {
+        if (!ref)
+            return undefined;
+        if (typeof ref === 'string') {
+            return this.resolveFromRefText(ref, ctx);
+        }
+        if (ref.ref && ref.ref.name) {
+            return this.elementIri(ref.ref, ctx);
+        }
+        if (ref.name) {
+            return this.elementIri(ref, ctx);
+        }
+        const refText = ref.$refText ?? ref.refText;
+        if (refText) {
+            return this.resolveFromRefText(refText, ctx);
+        }
+        return undefined;
+    }
+    resolveFromRefText(refText, ctx) {
+        if (refText.startsWith('<') && refText.endsWith('>')) {
+            return refText.slice(1, -1);
+        }
+        const parts = refText.split(':');
+        if (parts.length === 2) {
+            const [prefix, local] = parts;
+            const ns = ctx.prefixes[prefix];
+            if (ns) {
+                return `${ns}${local}`;
+            }
+        }
+        return undefined;
+    }
+    normalizeNamespace(ns) {
+        return ns.replace(/^<|>$/g, '');
+    }
+    termKey(term) {
+        if (term.termType === 'NamedNode') {
+            return `iri:${term.value}`;
+        }
+        if (term.termType === 'Literal') {
+            return `lit:${term.value}@${term.language}^^${term.datatype.value}`;
+        }
+        return `${term.termType}:${term.value}`;
+    }
+    literalKey(value, ctx) {
+        const term = this.toLiteral(value, ctx);
+        return term ? this.termKey(term) : '';
+    }
+    toLiteral(value, ctx) {
+        if (isBooleanLiteral(value)) {
+            return literal(String(value.value), namedNode(XSD.boolean));
+        }
+        if (isIntegerLiteral(value)) {
+            return literal(String(value.value), namedNode(XSD.integer));
+        }
+        if (isDecimalLiteral(value)) {
+            return literal(String(value.value), namedNode(XSD.decimal));
+        }
+        if (isDoubleLiteral(value)) {
+            return literal(String(value.value), namedNode(XSD.double));
+        }
+        if (isQuotedLiteral(value)) {
+            if (value.type) {
+                const dt = this.resolveIri(value.type, ctx);
+                return literal(value.value, dt ? namedNode(dt) : undefined);
+            }
+            if (value.langTag) {
+                return literal(value.value, value.langTag);
+            }
+            return literal(value.value);
+        }
+        return undefined;
+    }
+    toFirstUpper(name) {
+        if (!name)
+            return name;
+        if (name.length === 1)
+            return name.toUpperCase();
+        return `${name[0].toUpperCase()}${name.slice(1)}`;
+    }
+    deduplicateQuads(quads) {
+        const unique = new Map();
+        for (const quad of quads) {
+            const key = `${quad.subject.id}|${quad.predicate.id}|${quad.object.id}|${quad.graph.id}`;
+            if (!unique.has(key)) {
+                unique.set(key, quad);
+            }
+        }
+        return [...unique.values()];
+    }
+}
+export function createOwlOntologyQuads() {
+    const triples = [];
+    const ontologyNode = namedNode(OWL_ONTOLOGY_IRI);
+    triples.push(quad(ontologyNode, namedNode(RDF.type), namedNode(OWL.Ontology)));
+    triples.push(quad(ontologyNode, namedNode(OML.type), namedNode(OML.Vocabulary)));
+    triples.push(quad(ontologyNode, namedNode(OML.namespace), namedNode(OWL_ONTOLOGY_NAMESPACE)));
+    triples.push(quad(ontologyNode, namedNode(OML.prefix), literal(OWL_ONTOLOGY_PREFIX)));
+    for (const term of OML_TERMS) {
+        triples.push(quad(namedNode(term.iri), namedNode(RDF.type), namedNode(term.rdfType)));
+    }
+    return triples;
+}
+export function owlOntologyPrefixes() {
+    return {
+        oml: OWL_ONTOLOGY_NAMESPACE,
+        rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+        rdfs: 'http://www.w3.org/2000/01/rdf-schema#',
+        owl: 'http://www.w3.org/2002/07/owl#',
+    };
+}
+//# sourceMappingURL=owl-mapper.js.map