@oml/owl 0.7.0

package/src/owl/owl-mapper.ts

@@ -0,0 +1,1510 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { DataFactory, Quad } from 'n3';
+import type { Quad_Object, Quad_Predicate, Quad_Subject } from 'n3';
+import type {
+    Argument,
+    Annotation,
+    AnnotationProperty,
+    AnonymousInstance,
+    Aspect,
+    BuiltIn,
+    Concept,
+    ConceptInstance,
+    EntityEquivalenceAxiom,
+    Import,
+    InstanceEnumerationAxiom,
+    KeyAxiom,
+    Literal,
+    LiteralEnumerationAxiom,
+    Ontology,
+    PropertyCardinalityRestrictionAxiom,
+    PropertyEquivalenceAxiom,
+    PropertyRangeRestrictionAxiom,
+    PropertyRestrictionAxiom,
+    PropertySelfRestrictionAxiom,
+    PropertyValueAssertion,
+    PropertyValueRestrictionAxiom,
+    Predicate,
+    RelationBase,
+    RelationEntity,
+    RelationInstance,
+    ReverseRelation,
+    Rule,
+    Scalar,
+    ScalarEquivalenceAxiom,
+    ScalarProperty,
+    SemanticProperty,
+    SpecializationAxiom,
+    TypeAssertion,
+    UnreifiedRelation,
+} from '@oml/language';
+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';
+
+type PrefixMap = Record<string, string>;
+
+interface MappingContext {
+    ontologyIri: string;
+    namespace: string;
+    prefix: string;
+    prefixes: PrefixMap;
+}
+
+export interface Oml2OwlMapperOptions {
+    emitSwrlRules?: boolean;
+    emitRelationEntitySwrlRules?: boolean;
+}
+
+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,
+} as const;
+
+const OML_TERMS: Array<{ iri: string; rdfType: string }> = [
+    { 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;
+type TermNode = ReturnType<typeof namedNode>;
+
+function fnv1a(input: string): string {
+    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: string, ...inputs: string[]): ReturnType<typeof namedNode> {
+    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(private readonly options: Oml2OwlMapperOptions = {
+        emitSwrlRules: true,
+        emitRelationEntitySwrlRules: true,
+    }) {}
+
+    toQuads(ontology: Ontology): Quad[] {
+        if (!isOntology(ontology)) {
+            return [];
+        }
+
+        const ctx = this.createContext(ontology);
+        const triples: Quad[] = [];
+        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 as any).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);
+    }
+
+  private mapVocabularyStatement(stmt: unknown, ctx: MappingContext, triples: Quad[]): void {
+    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);
+    }
+  }
+
+  private mapDescriptionStatement(stmt: unknown, ctx: MappingContext, triples: Quad[]): void {
+    if (isConceptInstance(stmt)) {
+      this.mapConceptInstance(stmt, ctx, triples);
+    } else if (isRelationInstance(stmt)) {
+      this.mapRelationInstance(stmt, ctx, triples);
+    }
+  }
+
+  private mapAspect(aspect: Aspect, ctx: MappingContext, triples: Quad[]): void {
+    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);
+  }
+
+  private mapConcept(concept: Concept, ctx: MappingContext, triples: Quad[]): void {
+    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);
+  }
+
+  private mapRelationEntity(entity: RelationEntity, ctx: MappingContext, triples: Quad[]): void {
+    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);
+    }
+  }
+
+  private mapUnreifiedRelation(relation: UnreifiedRelation, ctx: MappingContext, triples: Quad[]): void {
+    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);
+  }
+
+  private mapReverseRelation(
+    reverse: ReverseRelation,
+    ctx: MappingContext,
+    triples: Quad[],
+    relationBase?: RelationBase,
+  ): void {
+    const base = relationBase ?? (reverse.$container as RelationBase);
+    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);
+  }
+
+  private mapScalar(scalar: Scalar, ctx: MappingContext, triples: Quad[]): void {
+    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);
+  }
+
+  private mapAnnotationProperty(property: AnnotationProperty, ctx: MappingContext, triples: Quad[]): void {
+    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);
+  }
+
+  private mapScalarProperty(property: ScalarProperty, ctx: MappingContext, triples: Quad[]): void {
+    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);
+  }
+
+  private mapConceptInstance(instance: ConceptInstance, ctx: MappingContext, triples: Quad[]): void {
+    const iri = this.elementIri(instance, ctx);
+    if (!iri) return;
+    const node = namedNode(iri);
+    const isDefinition = !(instance as any).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));
+  }
+
+  private mapRelationInstance(instance: RelationInstance, ctx: MappingContext, triples: Quad[]): void {
+    const iri = this.elementIri(instance, ctx);
+    if (!iri) return;
+    const node = namedNode(iri);
+    const isDefinition = !(instance as any).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));
+  }
+
+  private mapRule(rule: Rule, ctx: MappingContext, triples: Quad[]): void {
+    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);
+  }
+
+  private mapBuiltIn(builtIn: BuiltIn, ctx: MappingContext, triples: Quad[]): void {
+    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);
+  }
+
+  private mapRelationEntityForwardRule(
+    relationEntityIri: string,
+    forwardIri: string,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): void {
+    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));
+  }
+
+  private mapRulePredicates(
+    predicates: Predicate[],
+    ctx: MappingContext,
+    triples: Quad[],
+    ruleIri: string,
+    side: 'body' | 'head',
+  ): Quad_Object[] {
+    return predicates.flatMap((predicate, index) => this.mapRulePredicate(predicate, ctx, triples, ruleIri, side, index));
+  }
+
+  private mapRulePredicate(
+    predicate: Predicate,
+    ctx: MappingContext,
+    triples: Quad[],
+    ruleIri: string,
+    side: 'body' | 'head',
+    index: number,
+  ): Quad_Object[] {
+    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): argument is Quad_Object => 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 [];
+  }
+
+  private toSwrlIArgument(argument: Argument, ctx: MappingContext, triples: Quad[]): Quad_Object | undefined {
+    if (argument.variable) {
+      return this.toSwrlVariable(argument.variable, triples);
+    }
+    const instanceIri = this.resolveIri(argument.instance, ctx);
+    if (!instanceIri) return undefined;
+    return namedNode(instanceIri);
+  }
+
+  private toSwrlDArgument(argument: Argument, ctx: MappingContext, triples: Quad[]): Quad_Object | undefined {
+    if (argument.variable) {
+      return this.toSwrlVariable(argument.variable, triples);
+    }
+    if (argument.literal) {
+      return this.toLiteral(argument.literal, ctx);
+    }
+    return undefined;
+  }
+
+  private toSwrlVariable(variable: string, triples: Quad[]): Quad_Object {
+    const node = namedNode(`urn:swrl:var#${variable}`);
+    triples.push(this.quadWithGraph(node, namedNode(RDF.type), namedNode(SWRL.Variable)));
+    return node;
+  }
+
+  private mapTypeAssertion(subject: ReturnType<typeof namedNode>, assertion: TypeAssertion, ctx: MappingContext, triples: Quad[]): void {
+    const typeIri = this.resolveIri(assertion.type, ctx);
+    if (typeIri) {
+      triples.push(this.quadWithGraph(subject, namedNode(RDF.type), namedNode(typeIri)));
+    }
+  }
+
+  private mapPropertyValueAssertion(
+    subject: TermNode,
+    assertion: PropertyValueAssertion,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): void {
+    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);
+    });
+
+  }
+
+  private mapAnnotations(
+    subject: TermNode,
+    annotations: Annotation[] | undefined,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): void {
+    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)));
+        }
+      });
+    });
+  }
+
+  private mapAnonymousInstance(
+    instance: AnonymousInstance,
+    node: ReturnType<typeof namedNode>,
+    ctx: MappingContext,
+    triples: Quad[],
+    source?: TermNode,
+  ): void {
+    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));
+    }
+  }
+
+  private applySpecializations(
+    axioms: SpecializationAxiom[] | undefined,
+    subNode: ReturnType<typeof namedNode>,
+    ctx: MappingContext,
+    triples: Quad[],
+    isProperty = false,
+  ): void {
+    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)),
+        );
+      }
+    });
+  }
+
+  private applyEquivalences(
+    axioms: EntityEquivalenceAxiom[] | undefined,
+    classNode: ReturnType<typeof namedNode>,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): void {
+    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);
+    });
+  }
+
+  private applyKeys(
+    axioms: KeyAxiom[] | undefined,
+    classNode: ReturnType<typeof namedNode>,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): void {
+    axioms?.forEach((ax) => {
+      const propertyNodes = ax.properties
+        .map((property) => this.resolveIri(property, ctx))
+        .filter((iri): iri is string => 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));
+    });
+  }
+
+  private applyScalarEquivalences(
+    axioms: ScalarEquivalenceAxiom[] | undefined,
+    scalarNode: ReturnType<typeof namedNode>,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): void {
+    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));
+      });
+    });
+  }
+
+  private applyInstanceEnumeration(
+    enumeration: InstanceEnumerationAxiom | undefined,
+    classNode: ReturnType<typeof namedNode>,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): void {
+    const instances = enumeration?.instances ?? [];
+    if (!instances.length) return;
+    const instanceNodes = instances
+      .map((instance) => this.resolveIri(instance, ctx))
+      .filter((iri): iri is string => 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));
+  }
+
+  private applyScalarEnumeration(
+    enumeration: LiteralEnumerationAxiom | undefined,
+    scalarNode: ReturnType<typeof namedNode>,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): void {
+    const literals = enumeration?.literals ?? [];
+    if (!literals.length) return;
+    const literalNodes = literals
+      .map((lit) => this.toLiteral(lit, ctx))
+      .filter((node): node is Quad_Object => 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));
+  }
+
+  private applyPropertyEquivalences(
+    axioms: PropertyEquivalenceAxiom[] | undefined,
+    propertyNode: ReturnType<typeof namedNode>,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): void {
+    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)));
+        }
+      });
+    });
+  }
+
+  private applyPropertyRestrictions(
+    axioms: PropertyRestrictionAxiom[] | undefined,
+    classNode: ReturnType<typeof namedNode>,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): void {
+    axioms?.forEach((ax) => {
+      const restrictionNode = this.mapRestriction(ax, ctx, triples);
+      if (restrictionNode) {
+        triples.push(this.quadWithGraph(classNode, namedNode(RDFS.subClassOf), restrictionNode));
+      }
+    });
+  }
+
+  private createScalarFacetRestrictionNodes(
+    axiom: ScalarEquivalenceAxiom,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): Array<ReturnType<typeof namedNode>> {
+    const facets: Array<{ iri: string; value: Quad_Object }> = [];
+
+    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): iri is string => 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;
+    });
+  }
+
+  private mapRestriction(
+    axiom: PropertyRestrictionAxiom,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): ReturnType<typeof namedNode> | undefined {
+    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;
+  }
+
+  private mapRangeRestriction(
+    axiom: PropertyRangeRestrictionAxiom,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): ReturnType<typeof namedNode> | undefined {
+    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;
+  }
+
+  private mapCardinalityRestriction(
+    axiom: PropertyCardinalityRestrictionAxiom,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): ReturnType<typeof namedNode> | undefined {
+    const propertyIri = this.resolveIri(axiom.property, ctx);
+    if (!propertyIri) return undefined;
+    const resolvedProperty = (axiom.property as any)?.ref as SemanticProperty | undefined;
+    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;
+  }
+
+  private mapValueRestriction(
+    axiom: PropertyValueRestrictionAxiom,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): ReturnType<typeof namedNode> | undefined {
+    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;
+  }
+
+  private mapSelfRestriction(
+    axiom: PropertySelfRestrictionAxiom,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): ReturnType<typeof namedNode> | undefined {
+    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;
+  }
+
+  private applyDomainRange(
+    propertyNode: ReturnType<typeof namedNode>,
+    domains: Array<unknown> | undefined,
+    ranges: Array<unknown> | undefined,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): void {
+    this.applyDomains(propertyNode, domains, ctx, triples);
+    this.applyRanges(propertyNode, ranges, ctx, triples);
+  }
+
+  private applyDomains(
+    propertyNode: ReturnType<typeof namedNode>,
+    domains: Array<unknown> | undefined,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): void {
+    domains?.forEach((d) => {
+      const iri = this.resolveIri(d, ctx);
+      if (iri) {
+        triples.push(this.quadWithGraph(propertyNode, namedNode(RDFS.domain), namedNode(iri)));
+      }
+    });
+  }
+
+  private applyRanges(
+    propertyNode: ReturnType<typeof namedNode>,
+    ranges: Array<unknown> | undefined,
+    ctx: MappingContext,
+    triples: Quad[],
+  ): void {
+    ranges?.forEach((r) => {
+      const iri = this.resolveIri(r, ctx);
+      if (iri) {
+        triples.push(this.quadWithGraph(propertyNode, namedNode(RDFS.range), namedNode(iri)));
+      }
+    });
+  }
+
+  private applyObjectPropertyCharacteristics(
+    propertyNode: ReturnType<typeof namedNode>,
+    relation: RelationBase,
+    triples: Quad[],
+  ): void {
+    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)));
+    }
+  }
+
+  private quadWithGraph(subject: Quad_Subject, predicate: Quad_Predicate, object: Quad_Object): Quad {
+    return quad(subject, predicate, object);
+  }
+
+  private createRdfList(
+    ctx: MappingContext,
+    items: Quad_Object[],
+    triples: Quad[],
+    listSeed: string,
+  ): ReturnType<typeof namedNode> {
+    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;
+  }
+
+  private createSwrlAtomList(
+    ctx: MappingContext,
+    items: Quad_Object[],
+    triples: Quad[],
+    listSeed: string,
+  ): ReturnType<typeof namedNode> {
+    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;
+  }
+
+  private createContext(ontology: Ontology): MappingContext {
+    const namespace = this.normalizeNamespace((ontology as any).namespace ?? '');
+    const prefix = (ontology as any).prefix ?? '';
+    return {
+      ontologyIri: namespace.replace(/[\/#]+$/, ''),
+      namespace,
+      prefix,
+      prefixes: this.buildPrefixMap(ontology),
+    };
+  }
+
+  private buildPrefixMap(ontology: Ontology): PrefixMap {
+    const map: PrefixMap = {};
+    const ns = this.normalizeNamespace((ontology as any).namespace ?? '');
+    const prefix = (ontology as any).prefix;
+    if (prefix) {
+      map[prefix] = ns;
+    }
+    ontology.ownedImports?.forEach((imp: Import) => {
+      const imported = imp.imported?.ref as Ontology | undefined;
+      const importedNs = imported ? this.normalizeNamespace((imported as any).namespace ?? '') : undefined;
+      const importedPrefix = imp.prefix ?? (imported as any)?.prefix;
+      if (importedPrefix && importedNs) {
+        map[importedPrefix] = importedNs;
+      }
+    });
+    return map;
+  }
+
+  private ontologyTypeIri(ontology: Ontology): string {
+    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;
+  }
+
+  private importedOntologyIri(imp: Import, ctx: MappingContext): string | undefined {
+    if (imp.imported?.ref && isOntology(imp.imported.ref)) {
+      return this.normalizeNamespace((imp.imported.ref as any).namespace ?? '').replace(/[\/#]+$/, '');
+    }
+    const refText = (imp.imported as any)?.$refText ?? (imp.imported as any)?.refText;
+    if (refText) {
+      return this.resolveFromRefText(refText, ctx)?.replace(/[\/#]+$/, '');
+    }
+    return undefined;
+  }
+
+  private getForwardIri(base: RelationBase, ctx: MappingContext): string {
+    if (isRelationEntity(base)) {
+      if (base.forwardRelation?.name) {
+        const ont = this.getOntology(base);
+        const ns = this.normalizeNamespace((ont as any)?.namespace ?? ctx.namespace);
+        return `${ns}${base.forwardRelation.name}`;
+      }
+      const name = ((base.ref as any)?.name ?? base.name ?? '').replace(/^\^/, '');
+      return `${ctx.namespace}has${this.toFirstUpper(name)}Forward`;
+    }
+    return this.elementIri(base, ctx) ?? '';
+  }
+
+  private elementIri(element: { name?: string; namespace?: string; $container?: any; ref?: any }, ctx: MappingContext): string | undefined {
+    if (!element) return undefined;
+    // If this is a ref wrapper, resolve to the referenced element's IRI.
+    if ((element as any).ref?.ref) {
+      return this.elementIri((element as any).ref.ref as any, ctx);
+    }
+    const name = (element as any).name ?? (element as any).ref?.name;
+    if (!name) return undefined;
+    const ontology = this.getOntology(element);
+    const namespace = ontology ? this.normalizeNamespace((ontology as any).namespace ?? ctx.namespace) : ctx.namespace;
+    return `${namespace}${name.replace(/^\^/, '')}`;
+  }
+
+  private getOntology(element: any): Ontology | undefined {
+    let current: any = element;
+    while (current && !isOntology(current)) {
+      current = current.$container;
+    }
+    return current as Ontology | undefined;
+  }
+
+  private resolveIri(ref: any, ctx: MappingContext): string | undefined {
+    if (!ref) return undefined;
+    if (typeof ref === 'string') {
+      return this.resolveFromRefText(ref, ctx);
+    }
+    if (ref.ref && (ref.ref as any).name) {
+      return this.elementIri(ref.ref as any, ctx);
+    }
+    if (ref.name) {
+      return this.elementIri(ref, ctx);
+    }
+    const refText = ref.$refText ?? ref.refText;
+    if (refText) {
+      return this.resolveFromRefText(refText, ctx);
+    }
+    return undefined;
+  }
+
+  private resolveFromRefText(refText: string, ctx: MappingContext): string | undefined {
+    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;
+  }
+
+  private normalizeNamespace(ns: string): string {
+    return ns.replace(/^<|>$/g, '');
+  }
+
+  private termKey(term: Quad_Object): string {
+    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}`;
+  }
+
+  private literalKey(value: Literal, ctx: MappingContext): string {
+    const term = this.toLiteral(value, ctx);
+    return term ? this.termKey(term) : '';
+  }
+
+  private toLiteral(value: Literal, ctx: MappingContext): Quad_Object | undefined {
+    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;
+  }
+
+  private toFirstUpper(name: string): string {
+    if (!name) return name;
+    if (name.length === 1) return name.toUpperCase();
+    return `${name[0].toUpperCase()}${name.slice(1)}`;
+  }
+
+  private deduplicateQuads(quads: ReadonlyArray<Quad>): Quad[] {
+    const unique = new Map<string, Quad>();
+    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(): Quad[] {
+    const triples: Quad[] = [];
+    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(): Record<string, string> {
+    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#',
+    };
+}