mdld-parse 0.4.0 → 0.4.1

package/README.md

@@ -1,4 +1,4 @@
-# MD-LD Parse v0.3
+# MD-LD Parse v0.4.1
 
 **Markdown-Linked Data (MD-LD)** — a deterministic, streaming-friendly RDF authoring format that extends Markdown with explicit `{...}` annotations.
 
@@ -34,6 +34,7 @@ ex:armstrong schema:name "Neil Armstrong" .
 
 ## Core Features
 
+- **Prefix folding**: Build hierarchical namespaces with lightweight IRI authoring
 - **Subject declarations**: `{=IRI}` and `{=#fragment}` for context setting
 - **Object IRIs**: `{+IRI}` and `{+#fragment}` for temporary object declarations  
 - **Four predicate forms**: `p` (S→L), `?p` (S→O), `!p` (O→S)
@@ -255,6 +256,38 @@ ex:book schema:hasPart ex:part .
 # Person {=ex:alice .foaf:Person}
 ```
 
+### Prefix Folding: Lightweight IRI Authoring
+
+Build hierarchical namespaces by referencing previously defined prefixes:
+
+```markdown
+# Create your domain authority
+[my] <tag:mymail@domain.com,2026:>
+
+# Build namespace hierarchy
+[j] <my:journal:>
+[p] <my:property:>
+[c] <my:class:>
+[person] <my:people:>
+
+# Use in content
+# 2026-01-27 {=j:2026-01-27 .c:Event p:date ^^xsd:date}
+
+## Harry {=person:harry p:name}
+```
+
+**Resolves to absolute IRIs:**
+- `j:2026-01-27` → `tag:mymail@domain.com,2026:journal:2026-01-27`
+- `c:Event` → `tag:mymail@domain.com,2026:class:Event`
+- `p:date` → `tag:mymail@domain.com,2026:property:date`
+- `person:harry` → `tag:mymail@domain.com,2026:people:harry`
+
+**Benefits:**
+- **Lightweight**: No external ontology dependencies
+- **Domain authority**: Use `tag:` URIs for personal namespaces
+- **Hierarchical**: Build deep namespace structures
+- **Streaming-safe**: Forward-reference only, single-pass parsing
+
 ## API Reference
 
 ### `parse(markdown, options)`

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mdld-parse",
-	"version": "0.4.0",
+	"version": "0.4.1",
 	"description": "A standards-compliant parser for **MD-LD (Markdown-Linked Data)** — a human-friendly RDF authoring format that extends Markdown with semantic annotations.",
 	"type": "module",
 	"main": "index.js",
@@ -24,7 +24,10 @@
 		"rdfjs",
 		"browser",
 		"web-worker",
-		"parser"
+		"parser",
+		"prefix-folding",
+		"curie",
+		"iri-authoring"
 	],
 	"author": "davay42",
 	"repository": {

package/src/parse.js

@@ -182,6 +182,13 @@ function extractInlineCarriers(text, baseOffset = 0) {
             continue;
         }
 
+        const angleBracketCarrier = tryExtractAngleBracketCarrier(text, pos, baseOffset);
+        if (angleBracketCarrier) {
+            carriers.push(angleBracketCarrier);
+            pos = angleBracketCarrier.pos;
+            continue;
+        }
+
         const bracketCarrier = tryExtractBracketCarrier(text, pos, baseOffset);
         if (bracketCarrier) {
             if (bracketCarrier.skip) {
@@ -232,6 +239,31 @@ function tryExtractCodeCarrier(text, pos, baseOffset) {
         ranges.attrsRange, ranges.valueRange, ranges.range, ranges.pos);
 }
 
+function tryExtractAngleBracketCarrier(text, pos, baseOffset) {
+    const angleStart = text.indexOf('<', pos);
+    if (angleStart === -1 || angleStart !== pos) return null;
+
+    // Look for closing angle bracket
+    const angleEnd = text.indexOf('>', angleStart);
+    if (angleEnd === -1) return null;
+
+    const url = text.substring(angleStart + 1, angleEnd);
+
+    // Basic URL validation - should contain at least a scheme and colon
+    if (!url.match(/^[a-zA-Z][a-zA-Z0-9+.-]*:/)) {
+        return null;
+    }
+
+    const { attrs, attrsRange, finalSpanEnd } = extractAttributesFromText(text, angleEnd + 1, baseOffset);
+
+    // For angle-bracket URLs, always provide the URL as text content
+    // The processing logic will handle whether to use it for literals or not
+    return createCarrier('link', url, attrs, attrsRange,
+        [baseOffset + angleStart + 1, baseOffset + angleEnd],
+        [baseOffset + angleStart, baseOffset + finalSpanEnd],
+        finalSpanEnd, { url: url });
+}
+
 function tryExtractBracketCarrier(text, pos, baseOffset) {
     const bracketStart = text.indexOf('[', pos);
     if (bracketStart === -1 || bracketStart !== pos) return null;
@@ -391,11 +423,18 @@ function resolveObject(sem, state) {
     }
 }
 
-function processTypeAnnotations(sem, newSubject, localObject, carrierO, S, block, state) {
+function processTypeAnnotations(sem, newSubject, localObject, carrierO, S, block, state, carrier) {
     sem.types.forEach(t => {
         const typeIRI = typeof t === 'string' ? t : t.iri;
         const entryIndex = typeof t === 'string' ? null : t.entryIndex;
-        const typeSubject = newSubject ? newSubject : (localObject || carrierO || S);
+
+        // For angle-bracket URLs, use the URL as the subject for type declarations ONLY when
+        // there's no explicit subject declaration. This implements {+URL} behavior.
+        let typeSubject = newSubject ? newSubject : (localObject || carrierO || S);
+        if (carrier?.type === 'link' && carrier?.url && carrier.text === carrier.url && !newSubject) {
+            typeSubject = carrierO; // Use URL as subject for type declarations only if no explicit subject
+        }
+
         const expandedType = expandIRI(typeIRI, state.ctx);
 
         emitQuad(
@@ -409,10 +448,15 @@ function processTypeAnnotations(sem, newSubject, localObject, carrierO, S, block
     });
 }
 
-function processPredicateAnnotations(sem, newSubject, previousSubject, localObject, newSubjectOrCarrierO, S, L, block, state) {
+function processPredicateAnnotations(sem, newSubject, previousSubject, localObject, newSubjectOrCarrierO, S, L, block, state, carrier) {
     sem.predicates.forEach(pred => {
         const P = state.df.namedNode(expandIRI(pred.iri, state.ctx));
 
+        // Skip literal predicates for angle-bracket URLs - they only support ? and ! predicates
+        if (pred.form === '' && carrier?.type === 'link' && carrier?.url && carrier.text === carrier.url) {
+            return; // Angle-bracket URLs don't support literal predicates
+        }
+
         // Pre-bind subject/object roles for clarity
         const roles = {
             '': { subject: localObject || S, object: L },
@@ -462,8 +506,8 @@ function processAnnotation(carrier, sem, state, options = {}) {
     const carrierO = carrier.url ? state.df.namedNode(expandIRI(carrier.url, state.ctx)) : null;
     const newSubjectOrCarrierO = newSubject || carrierO;
 
-    processTypeAnnotations(sem, newSubject, localObject, carrierO, S, block, state);
-    processPredicateAnnotations(sem, newSubject, previousSubject, localObject, newSubjectOrCarrierO, S, L, block, state);
+    processTypeAnnotations(sem, newSubject, localObject, carrierO, S, block, state, carrier);
+    processPredicateAnnotations(sem, newSubject, previousSubject, localObject, newSubjectOrCarrierO, S, L, block, state, carrier);
 }
 
 // Helper functions for list item processing
@@ -744,8 +788,20 @@ export function parse(text, options = {}) {
 
     state.tokens = scanTokens(text);
 
-    // Process prefix declarations first
-    state.tokens.filter(t => t.type === 'prefix').forEach(t => state.ctx[t.prefix] = t.iri);
+    // Process prefix declarations first with prefix folding support
+    state.tokens.filter(t => t.type === 'prefix').forEach(t => {
+        // Check if the IRI value contains a CURIE that references a previously defined prefix
+        let resolvedIri = t.iri;
+        if (t.iri.includes(':')) {
+            const [potentialPrefix, ...referenceParts] = t.iri.split(':');
+            const reference = referenceParts.join(':'); // Preserve any additional colons in reference
+            if (state.ctx[potentialPrefix] && potentialPrefix !== '@vocab') {
+                // This is a CURIE referencing an existing prefix - resolve it
+                resolvedIri = state.ctx[potentialPrefix] + reference;
+            }
+        }
+        state.ctx[t.prefix] = resolvedIri;
+    });
 
     // Process all other tokens
     for (let i = 0; i < state.tokens.length; i++) {