mdld-parse 0.5.5 → 0.6.0

package/src/parse.js

@@ -4,7 +4,7 @@ import {
     expandIRI,
     parseSemanticBlock,
     quadIndexKey,
-    createSlotInfo,
+    createUnifiedSlot,
     createLiteral,
     hash
 } from './utils.js';
@@ -16,7 +16,6 @@ const HEADING_REGEX = /^(#{1,6})\s+(.+?)(?:\s*(\{[^}]+\}))?$/;
 const UNORDERED_LIST_REGEX = /^(\s*)([-*+]|\d+\.)\s+(.+?)(?:\s*(\{[^}]+\}))?\s*$/;
 const BLOCKQUOTE_REGEX = /^>\s+(.+?)(?:\s*(\{[^}]+\}))?$/;
 const STANDALONE_SUBJECT_REGEX = /^\s*\{=(.*?)\}\s*$/;
-const LIST_CONTEXT_REGEX = /^(.+?)\s*\{([^}]+)\}$/;
 const INLINE_CARRIER_PATTERNS = {
     EMPHASIS: /[*__`]+(.+?)[*__`]+\s*\{([^}]+)\}/y,
     CODE_SPAN: /``(.+?)``\s*\{([^}]+)\}/y
@@ -87,13 +86,12 @@ function getCarriers(token) {
     return token._carriers || (token._carriers = extractInlineCarriers(token.text, token.range[0]));
 }
 
-const createListToken = (type, line, lineStart, pos, match, indent = null) => {
+const createListToken = (type, line, lineStart, pos, match) => {
     const attrs = match[4] || null;
     const prefix = match[1].length + (match[2] ? match[2].length : 0);
     const rangeInfo = calcRangeInfo(line, attrs, lineStart, prefix, match[3].length);
-    const extra = indent !== null ? { indent } : { indent: match[1].length };
     return createToken(type, [lineStart, pos - 1], match[3].trim(), attrs,
-        rangeInfo.attrsRange, rangeInfo.valueRange, extra);
+        rangeInfo.attrsRange, rangeInfo.valueRange, { indent: match[1].length });
 };
 
 function scanTokens(text) {
@@ -173,7 +171,7 @@ function scanTokens(text) {
 
     function handleList(line, lineStart, pos) {
         const match = UNORDERED_LIST_REGEX.exec(line);
-        tokens.push(createListToken('list', line, lineStart, pos, match, match[1].length));
+        tokens.push(createListToken('list', line, lineStart, pos, match));
         return true;
     }
 
@@ -277,14 +275,14 @@ function extractInlineCarriers(text, baseOffset = 0) {
 }
 
 function calcCarrierRanges(match, baseOffset, matchStart) {
-    const valueStart = baseOffset + matchStart;
+    const valueStart = baseOffset + matchStart + match[0].indexOf(match[1]);
     const valueEnd = valueStart + match[1].length;
     const attrsStart = baseOffset + matchStart + match[0].indexOf('{');
     const attrsEnd = attrsStart + match[2].length + 2; // +2 for { and }
     return {
         valueRange: [valueStart, valueEnd],
         attrsRange: [attrsStart + 1, attrsEnd - 1], // Exclude braces
-        range: [valueStart, attrsEnd],
+        range: [baseOffset + matchStart, attrsEnd],
         pos: matchStart + match[0].length // pos should be relative to current text, not document
     };
 }
@@ -345,7 +343,7 @@ function determineCarrierType(url) {
     return { carrierType: 'span', resourceIRI: null };
 }
 
-function createBlock(subject, types, predicates, entries, range, attrsRange, valueRange, carrierType, ctx) {
+function createBlock(subject, types, predicates, range, attrsRange, valueRange, carrierType, ctx) {
     const expanded = {
         subject,
         types: types.map(t => expandIRI(typeof t === 'string' ? t : t.iri, ctx)),
@@ -364,23 +362,26 @@ function createBlock(subject, types, predicates, entries, range, attrsRange, val
         subject,
         types: expanded.types,
         predicates: expanded.predicates,
-        entries: entries || [],
-        context: { ...ctx }
+        context: ctx
     };
 }
 
-function emitQuad(quads, quadIndex, blockId, subject, predicate, object, dataFactory, meta = null) {
+function emitQuad(quads, quadMap, block, subject, predicate, object, dataFactory, meta = null) {
     if (!subject || !predicate || !object) return;
+
     const quad = dataFactory.quad(subject, predicate, object);
     quads.push(quad);
 
-    const slotInfo = createSlotInfo(blockId, meta?.entryIndex, {
+    const unifiedSlot = createUnifiedSlot(block, meta?.entryIndex, {
         ...meta,
-        subject, predicate, object
+        subject,
+        predicate,
+        object
     });
 
-    quadIndex.set(quadIndexKey(quad.subject, quad.predicate, quad.object), slotInfo);
+    quadMap.set(quadIndexKey(quad.subject, quad.predicate, quad.object), unifiedSlot);
 }
+
 const resolveFragment = (fragment, state) => {
     if (!state.currentSubject) return null;
     const baseIRI = state.currentSubject.value.split('#')[0];
@@ -403,10 +404,10 @@ function resolveObject(sem, state) {
     return state.df.namedNode(expandIRI(sem.object, state.ctx));
 }
 
-const createTypeQuad = (typeIRI, subject, state, blockId, entryIndex = null) => {
+const createTypeQuad = (typeIRI, subject, state, block, entryIndex = null) => {
     const expandedType = expandIRI(typeIRI, state.ctx);
     emitQuad(
-        state.quads, state.origin.quadIndex, blockId,
+        state.quads, state.origin.quadMap, block,
         subject,
         state.df.namedNode(expandIRI('rdf:type', state.ctx)),
         state.df.namedNode(expandedType),
@@ -419,9 +420,9 @@ function processTypeAnnotations(sem, newSubject, localObject, carrierO, S, block
     sem.types.forEach(t => {
         const typeIRI = typeof t === 'string' ? t : t.iri;
         const entryIndex = typeof t === 'string' ? null : t.entryIndex;
-        // Type subject priority: explicit subject > soft object > URL > current subject
+        // Type subject priority: explicit subject > soft object > carrier URL > current subject
         let typeSubject = newSubject || localObject || carrierO || S;
-        createTypeQuad(typeIRI, typeSubject, state, block.id, entryIndex);
+        createTypeQuad(typeIRI, typeSubject, state, block, entryIndex);
     });
 }
 
@@ -452,7 +453,7 @@ function processPredicateAnnotations(sem, newSubject, previousSubject, localObje
         const role = determinePredicateRole(pred, carrier, newSubject, previousSubject, localObject, newSubjectOrCarrierO, S, L);
         if (role) {
             const P = state.df.namedNode(expandIRI(pred.iri, state.ctx));
-            emitQuad(state.quads, state.origin.quadIndex, block.id,
+            emitQuad(state.quads, state.origin.quadMap, block,
                 role.subject, P, role.object, state.df,
                 { kind: 'pred', token: `${pred.form}${pred.iri}`, form: pred.form, expandedPredicate: P.value, entryIndex: pred.entryIndex }
             );
@@ -480,11 +481,10 @@ function processAnnotation(carrier, sem, state, options = {}) {
     if (!S) return;
 
     const block = createBlock(
-        S.value, sem.types, sem.predicates, sem.entries,
+        S.value, sem.types, sem.predicates,
         carrier.range, carrier.attrsRange || null, carrier.valueRange || null,
         carrier.type || null, state.ctx
     );
-    state.origin.blocks.set(block.id, block);
 
     const L = createLiteral(carrier.text, sem.datatype, sem.language, state.ctx, state.df);
     const carrierO = carrier.url ? state.df.namedNode(expandIRI(carrier.url, state.ctx)) : null;
@@ -494,171 +494,12 @@ function processAnnotation(carrier, sem, state, options = {}) {
     processPredicateAnnotations(sem, newSubject, previousSubject, localObject, newSubjectOrCarrierO, S, L, block, state, carrier);
 }
 
-export function findItemSubject(listToken, carriers, state) {
-    const sem = parseSemCached(listToken.attrs);
-    if (sem.subject && sem.subject !== 'RESET') {
-        const subject = resolveSubject(sem, state);
-        if (subject) {
-            return {
-                subject,
-                carrier: { type: 'list', text: listToken.text, attrs: listToken.attrs, range: listToken.range }
-            };
-        }
-    }
 
-    for (const carrier of carriers) {
-        const carrierSem = parseSemCached(carrier.attrs);
-        if (carrierSem.subject && carrierSem.subject !== 'RESET') {
-            const subject = resolveSubject(carrierSem, state);
-            if (subject) {
-                return { subject, carrier };
-            }
-        }
-    }
 
-    return null;
-}
 
-const processContextSem = ({ sem, itemSubject, contextSubject, inheritLiterals = false, state, blockId = 'list-context' }) => {
-    sem.types.forEach(t => {
-        const typeIRI = typeof t === 'string' ? t : t.iri;
-        emitQuad(
-            state.quads, state.origin.quadIndex, blockId,
-            itemSubject,
-            state.df.namedNode(expandIRI('rdf:type', state.ctx)),
-            state.df.namedNode(expandIRI(typeIRI, state.ctx)),
-            state.df
-        );
-    });
 
-    sem.predicates.forEach(pred => {
-        const P = state.df.namedNode(expandIRI(pred.iri, state.ctx));
-        if (pred.form === '!') {
-            emitQuad(state.quads, state.origin.quadIndex, blockId, itemSubject, P, contextSubject, state.df);
-        } else if (pred.form === '?') {
-            emitQuad(state.quads, state.origin.quadIndex, blockId, contextSubject, P, itemSubject, state.df);
-        }
-    });
 
-    if (inheritLiterals) {
-        const literalPredicates = sem.predicates.filter(p => p.form === '');
-        if (literalPredicates.length > 0) {
-            return {
-                subject: null, object: null, types: [],
-                predicates: literalPredicates.map(p => ({ iri: p.iri, form: p.form, entryIndex: p.entryIndex })),
-                datatype: null, language: null, entries: []
-            };
-        }
-    }
-    return null;
-};
 
-const manageListStack = (token, state) => {
-    while (state.listStack.length && token.indent < state.listStack[state.listStack.length - 1].indent) {
-        state.listStack.pop();
-    }
-
-    if (state.pendingListContext) {
-        state.listStack.push({
-            indent: token.indent,
-            anchorSubject: state.pendingListContext.subject,
-            contextSubject: state.pendingListContext.subject,
-            contextSem: state.pendingListContext.sem,
-            contextText: state.pendingListContext.contextText,
-            contextToken: state.pendingListContext.contextToken // Store context token for origins
-        });
-        state.pendingListContext = null;
-    } else if (state.listStack.length === 0 || token.indent > state.listStack[state.listStack.length - 1].indent) {
-        const parentFrame = state.listStack.length > 0 ? state.listStack[state.listStack.length - 1] : null;
-        state.listStack.push({
-            indent: token.indent,
-            anchorSubject: parentFrame?.anchorSubject || null,
-            contextSubject: parentFrame?.anchorSubject || null,
-            contextSem: null
-        });
-    }
-};
-
-const combineSemanticInfo = (token, carriers, listFrame, state, itemSubject) => {
-    const combinedSem = { subject: null, object: null, types: [], predicates: [], datatype: null, language: null, entries: [] };
-    const addSem = (sem) => {
-        const entryIndex = combinedSem.entries.length;
-        combinedSem.types.push(...sem.types);
-        combinedSem.predicates.push(...sem.predicates);
-        combinedSem.entries.push(...sem.entries.map(entry => ({ ...entry, entryIndex })));
-    };
-
-    if (listFrame?.contextSem) {
-        const inheritedSem = processContextSem({ sem: listFrame.contextSem, itemSubject, contextSubject: listFrame.contextSubject, inheritLiterals: true, state });
-        if (inheritedSem) addSem(inheritedSem);
-    }
-
-    if (token.attrs) addSem(parseSemCached(token.attrs));
-    carriers.forEach(carrier => { if (carrier.attrs) addSem(parseSemCached(carrier.attrs)); });
-
-    return combinedSem;
-};
-
-const processListItem = (token, state) => {
-    const carriers = getCarriers(token);
-    const itemInfo = findItemSubject(token, carriers, state);
-    if (!itemInfo) return;
-
-    const { subject: itemSubject } = itemInfo;
-    if (state.listStack.length > 0) state.listStack[state.listStack.length - 1].anchorSubject = itemSubject;
-
-    const listFrame = state.listStack[state.listStack.length - 1];
-    const combinedSem = combineSemanticInfo(token, carriers, listFrame, state, itemSubject);
-
-    if (combinedSem.entries.length > 0) {
-        const prevSubject = state.currentSubject;
-        state.currentSubject = itemSubject;
-
-        processAnnotation({ type: 'list', text: token.text, range: token.range, attrsRange: token.attrsRange || null, valueRange: token.valueRange || null }, combinedSem, state, { preserveGlobalSubject: !state.listStack.length, implicitSubject: itemSubject });
-
-        state.currentSubject = prevSubject;
-    }
-};
-
-
-function processListContextFromParagraph(token, state) {
-    const contextMatch = LIST_CONTEXT_REGEX.exec(token.text);
-    if (!contextMatch) return;
-
-    const contextSem = parseSemCached(`{${contextMatch[2]}}`);
-    let contextSubject = state.currentSubject || state.documentSubject;
-
-    if (!contextSubject && state.tokens) {
-        for (let i = state.currentTokenIndex - 1; i >= 0; i--) {
-            const prevToken = state.tokens[i];
-            if (prevToken.type === 'heading' && prevToken.attrs) {
-                const prevSem = parseSemCached(prevToken.attrs);
-                if (prevSem.subject) {
-                    const resolvedSubject = resolveSubject(prevSem, state);
-                    if (resolvedSubject) {
-                        contextSubject = resolvedSubject.value;
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    const nextToken = state.tokens?.[state.currentTokenIndex + 1];
-    if (state.listStack.length > 0 && nextToken && nextToken.type === 'list') {
-        const currentFrame = state.listStack[state.listStack.length - 1];
-        if (currentFrame.anchorSubject && nextToken.indent > currentFrame.indent) {
-            contextSubject = currentFrame.anchorSubject;
-        }
-    }
-
-    state.pendingListContext = {
-        sem: contextSem,
-        subject: contextSubject,
-        contextText: contextMatch[1].replace(':', '').trim(),
-        contextToken: token // Store the context token for origin ranges
-    };
-}
 
 function processTokenAnnotations(token, state, tokenType) {
     if (token.attrs) {
@@ -692,13 +533,6 @@ function processStandaloneSubject(token, state) {
 
 const TOKEN_PROCESSORS = {
     heading: (token, state) => {
-        if (token.attrs) {
-            const headingSem = parseSemCached(token.attrs);
-            if (headingSem.subject) {
-                const subject = resolveSubject(headingSem, state);
-                if (subject) state.documentSubject = subject;
-            }
-        }
         processTokenAnnotations(token, state, token.type);
     },
     code: (token, state) => {
@@ -709,12 +543,10 @@ const TOKEN_PROCESSORS = {
     },
     para: (token, state) => {
         processStandaloneSubject(token, state);
-        processListContextFromParagraph(token, state);
         processTokenAnnotations(token, state, token.type);
     },
     list: (token, state) => {
-        manageListStack(token, state);
-        processListItem(token, state);
+        processTokenAnnotations(token, state, token.type);
     },
 };
 
@@ -723,11 +555,8 @@ export function parse(text, options = {}) {
         ctx: { ...DEFAULT_CONTEXT, ...(options.context || {}) },
         df: options.dataFactory || DataFactory,
         quads: [],
-        origin: { blocks: new Map(), quadIndex: new Map() },
+        origin: { quadMap: new Map() },
         currentSubject: null,
-        documentSubject: null,
-        listStack: [],
-        pendingListContext: null,
         tokens: null,
         currentTokenIndex: -1
     };

package/src/utils.js

@@ -7,16 +7,235 @@ export const DEFAULT_CONTEXT = {
     prov: 'http://www.w3.org/ns/prov#'
 };
 
+// Base Term class for RDF/JS compatibility
+export class Term {
+    constructor(id) {
+        this.id = id;
+    }
+
+    equals(other) {
+        return !!other && this.termType === other.termType && this.value === other.value;
+    }
+}
+
+// NamedNode implementation
+export class NamedNode extends Term {
+    constructor(iri) {
+        super(iri);
+        this.termType = 'NamedNode';
+        this.value = iri;
+    }
+}
+
+// Literal implementation with language/direction support
+export class Literal extends Term {
+    constructor(id) {
+        super(id);
+        this.termType = 'Literal';
+        this.value = '';
+        this.language = '';
+        this.datatype = null;
+
+        // Parse the literal ID - handle escaped quotes properly
+        const dtMatch = id.match(/^"([^"\\]*(?:\\.[^"\\]*)*)"(\^\^([^"]+))?(@([^-]+)(--(.+))?)?$/);
+        if (dtMatch) {
+            // Unescape the value
+            this.value = dtMatch[1].replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+            if (dtMatch[5]) {
+                this.language = dtMatch[5];
+                this.datatype = new NamedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#langString');
+            } else if (dtMatch[3]) {
+                this.datatype = new NamedNode(dtMatch[3]);
+            } else {
+                this.datatype = new NamedNode('http://www.w3.org/2001/XMLSchema#string');
+            }
+        } else {
+            // Fallback for simple literals without complex parsing
+            this.value = id.replace(/^"|"$/g, '');
+            this.datatype = new NamedNode('http://www.w3.org/2001/XMLSchema#string');
+        }
+    }
+
+    equals(other) {
+        return !!other &&
+            this.termType === other.termType &&
+            this.value === other.value &&
+            this.language === other.language &&
+            this.datatype?.value === other.datatype?.value;
+    }
+}
+
+// BlankNode implementation
+export class BlankNode extends Term {
+    constructor(name) {
+        super(name || `b${Math.random().toString(36).slice(2, 11)}`);
+        this.termType = 'BlankNode';
+        this.value = this.id;
+    }
+}
+
+// Variable implementation
+export class Variable extends Term {
+    constructor(name) {
+        super(name);
+        this.termType = 'Variable';
+        this.value = name;
+    }
+}
+
+// DefaultGraph implementation
+export class DefaultGraph extends Term {
+    constructor() {
+        super('');
+        this.termType = 'DefaultGraph';
+        this.value = '';
+    }
+
+    equals(other) {
+        return !!other && this.termType === other.termType;
+    }
+}
+
+// Default graph singleton
+const DEFAULTGRAPH = new DefaultGraph();
+
+// Quad implementation
+export class Quad extends Term {
+    constructor(subject, predicate, object, graph = DEFAULTGRAPH) {
+        super(`${subject.id}|${predicate.id}|${object.id}|${graph.id}`);
+        this.termType = 'Quad';
+        this.subject = subject;
+        this.predicate = predicate;
+        this.object = object;
+        this.graph = graph;
+    }
+
+    equals(other) {
+        return !!other &&
+            this.termType === other.termType &&
+            this.subject.equals(other.subject) &&
+            this.predicate.equals(other.predicate) &&
+            this.object.equals(other.object) &&
+            this.graph.equals(other.graph);
+    }
+
+    toJSON() {
+        return {
+            termType: this.termType,
+            subject: this.subject.toJSON ? this.subject.toJSON() : { termType: this.subject.termType, value: this.subject.value },
+            predicate: this.predicate.toJSON ? this.predicate.toJSON() : { termType: this.predicate.termType, value: this.predicate.value },
+            object: this.object.toJSON ? this.object.toJSON() : { termType: this.object.termType, value: this.object.value },
+            graph: this.graph.toJSON ? this.graph.toJSON() : { termType: this.graph.termType, value: this.graph.value }
+        };
+    }
+}
+
+// XSD constants
+const xsd = {
+    boolean: 'http://www.w3.org/2001/XMLSchema#boolean',
+    integer: 'http://www.w3.org/2001/XMLSchema#integer',
+    double: 'http://www.w3.org/2001/XMLSchema#double',
+    string: 'http://www.w3.org/2001/XMLSchema#string'
+};
+
+// DataFactory singleton matching N3.js interface
 export const DataFactory = {
-    namedNode: (v) => ({ termType: 'NamedNode', value: v }),
-    blankNode: (v = `b${Math.random().toString(36).slice(2, 11)}`) => ({ termType: 'BlankNode', value: v }),
-    literal: (v, lang) => {
-        if (typeof lang === 'string') {
-            return { termType: 'Literal', value: v, language: lang, datatype: DataFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#langString') };
+    namedNode: (iri) => new NamedNode(iri),
+    blankNode: (name) => new BlankNode(name),
+    literal: (value, languageOrDataType) => {
+        // Convert non-string values to string for proper serialization
+        const stringValue = String(value);
+        // Escape quotes in the value for proper serialization
+        const escapedValue = stringValue.replace(/"/g, '\\"');
+
+        // Create a language-tagged string
+        if (typeof languageOrDataType === 'string') {
+            return new Literal(`"${escapedValue}"@${languageOrDataType.toLowerCase()}`);
+        }
+
+        // Create a language-tagged string with base direction
+        if (languageOrDataType !== undefined && !('termType' in languageOrDataType)) {
+            const direction = languageOrDataType.direction ? `--${languageOrDataType.direction.toLowerCase()}` : '';
+            return new Literal(`"${escapedValue}"@${languageOrDataType.language.toLowerCase()}${direction}`);
         }
-        return { termType: 'Literal', value: v, language: '', datatype: lang || DataFactory.namedNode('http://www.w3.org/2001/XMLSchema#string') };
+
+        // Automatically determine datatype for booleans and numbers
+        let datatype = languageOrDataType ? languageOrDataType.value : '';
+        if (datatype === '') {
+            // Convert a boolean
+            if (typeof value === 'boolean') {
+                datatype = xsd.boolean;
+            }
+            // Convert an integer or double
+            else if (typeof value === 'number') {
+                if (Number.isFinite(value)) {
+                    datatype = Number.isInteger(value) ? xsd.integer : xsd.double;
+                } else {
+                    datatype = xsd.double;
+                    if (!Number.isNaN(value)) {
+                        value = value > 0 ? 'INF' : '-INF';
+                    }
+                }
+            }
+        }
+
+        // Create a datatyped literal
+        return (datatype === '' || datatype === xsd.string)
+            ? new Literal(`"${escapedValue}"`)
+            : new Literal(`"${escapedValue}"^^${datatype}`);
     },
-    quad: (s, p, o, g) => ({ subject: s, predicate: p, object: o, graph: g || DataFactory.namedNode('') })
+    variable: (name) => new Variable(name),
+    defaultGraph: () => DEFAULTGRAPH,
+    quad: (subject, predicate, object, graph) => new Quad(subject, predicate, object, graph),
+    triple: (subject, predicate, object, graph) => new Quad(subject, predicate, object, graph), // Alias for quad
+    fromTerm: (term) => {
+        if (term instanceof Term) return term;
+
+        // Term instantiated with another library
+        switch (term.termType) {
+            case 'NamedNode':
+                return new NamedNode(term.value);
+            case 'BlankNode':
+                return new BlankNode(term.value);
+            case 'Variable':
+                return new Variable(term.value);
+            case 'DefaultGraph':
+                return DEFAULTGRAPH;
+            case 'Literal':
+                if (term.language) {
+                    return new Literal(`"${term.value}"@${term.language}`);
+                } else if (term.datatype) {
+                    return new Literal(`"${term.value}"^^${term.datatype.value || term.datatype}`);
+                } else {
+                    return new Literal(`"${term.value}"`);
+                }
+            case 'Quad':
+                return DataFactory.fromQuad(term);
+            default:
+                throw new Error(`Unexpected termType: ${term.termType}`);
+        }
+    },
+    fromQuad: (inQuad) => {
+        if (inQuad instanceof Quad) return inQuad;
+        if (inQuad.termType !== 'Quad') {
+            // Handle plain object quads by treating them as quads
+            if (inQuad.subject && inQuad.predicate && inQuad.object) {
+                return new Quad(
+                    DataFactory.fromTerm(inQuad.subject),
+                    DataFactory.fromTerm(inQuad.predicate),
+                    DataFactory.fromTerm(inQuad.object),
+                    DataFactory.fromTerm(inQuad.graph || DataFactory.defaultGraph())
+                );
+            }
+            throw new Error(`Unexpected termType: ${inQuad.termType}`);
+        }
+        return new Quad(
+            DataFactory.fromTerm(inQuad.subject),
+            DataFactory.fromTerm(inQuad.predicate),
+            DataFactory.fromTerm(inQuad.object),
+            DataFactory.fromTerm(inQuad.graph)
+        );
+    }
 };
 
 export function hash(str) {
@@ -55,9 +274,18 @@ export function expandIRI(term, ctx) {
 export function shortenIRI(iri, ctx) {
     if (!iri || !iri.startsWith('http')) return iri;
     if (ctx['@vocab'] && iri.startsWith(ctx['@vocab'])) return iri.substring(ctx['@vocab'].length);
+
+    // Find the best matching prefix - more precise matching
     for (const [prefix, namespace] of Object.entries(ctx)) {
         if (prefix !== '@vocab' && iri.startsWith(namespace)) {
-            return prefix + ':' + iri.substring(namespace.length);
+            // Check if this is the best match (longest namespace)
+            const isBestMatch = Object.entries(ctx)
+                .filter(([p, ns]) => p !== '@vocab' && iri.startsWith(ns))
+                .every(([p, ns]) => namespace.length >= ns.length || (p === prefix && ns.length === namespace.length));
+
+            if (isBestMatch) {
+                return prefix + ':' + iri.substring(namespace.length);
+            }
         }
     }
     return iri;
@@ -197,16 +425,29 @@ export function parseQuadIndexKey(key) {
     }
 }
 
-// Direct slot management functions - no factory needed
-export function createSlotInfo(blockId, entryIndex, meta = {}) {
+// Direct slot management functions - unified with block data
+export function createUnifiedSlot(block, entryIndex, meta = {}) {
     const slotId = meta.subject && meta.predicate ? hash(`${meta.subject.value}|${meta.predicate.value}`) : null;
     return {
-        blockId,
+        // Block metadata
+        id: block.id,
+        range: block.range,
+        attrsRange: block.attrsRange,
+        valueRange: block.valueRange,
+        carrierType: block.carrierType,
+        subject: block.subject,
+        types: block.types,
+        predicates: block.predicates,
+        context: block.context,
+
+        // Slot metadata
         entryIndex,
         slotId,
         isVacant: false,
         lastValue: null,
         vacantSince: null,
+
+        // Quad metadata
         ...meta
     };
 }
@@ -220,9 +461,9 @@ export function markSlotAsVacant(slotInfo, deletedValue) {
     } : null;
 }
 
-export function findVacantSlot(quadIndex, subject, predicate) {
+export function findVacantSlot(quadMap, subject, predicate) {
     const targetSlotId = hash(`${subject.value}|${predicate.value}`);
-    return Array.from(quadIndex.values())
+    return Array.from(quadMap.values())
         .find(slot => slot.slotId === targetSlotId && slot.isVacant);
 }