mdld-parse 0.2.10 → 0.3.1

package/LICENCE

@@ -1,6 +1,6 @@
 # MDLD / MD-LD Community License
 
-Version 0.2 — 2025
+Version 0.3 — 2025
 
 Copyright © 2025–present  
 **Denis Starov**  

package/README.md

@@ -1,4 +1,4 @@
-# MD-LD Parse v0.2
+# MD-LD Parse v0.3
 
 **Markdown-Linked Data (MD-LD)** — a deterministic, streaming-friendly RDF authoring format that extends Markdown with explicit `{...}` annotations.
 
@@ -14,10 +14,10 @@ MD-LD allows you to author RDF graphs directly in Markdown using explicit `{...}
 # Apollo 11 {=ex:apollo11 .SpaceMission}
 
 Launch: [1969-07-16] {startDate ^^xsd:date}
-Crew: [Neil Armstrong] {=?ex:armstrong ?crewMember name}
+Crew: [Neil Armstrong] {+ex:armstrong ?crewMember name}
 Description: [First crewed Moon landing] {description}
 
-[Section] {=?#overview ?hasPart}
+[Section] {+#overview ?hasPart}
 Overview: [Mission summary] {description}
 ```
 
@@ -35,8 +35,8 @@ ex:armstrong schema:name "Neil Armstrong" .
 ## Core Features
 
 - **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` (L→S), `^?p` (O→S)
+- **Object IRIs**: `{+IRI}` and `{+#fragment}` for temporary object declarations  
+- **Four predicate forms**: `p` (S→L), `?p` (S→O), `!p` (O→S)
 - **Type declarations**: `.Class` for rdf:type triples
 - **Datatypes & language**: `^^xsd:date` and `@en` support
 - **Lists**: Explicit subject declarations for structured data
@@ -92,8 +92,7 @@ Each predicate form determines the graph edge:
 |-------|---------|------------------------------|------------------|
 | `p`   | S → L   | `[Alice] {name}`             | literal property |
 | `?p`  | S → O   | `[NASA](ex:nasa) {?org}`     | object property  |
-| `^p`  | *(none)*| *(literals can't be subjects)* | reverse literal  |
-| `^?p` | O → S   | `[Parent](ex:p) {^?hasPart}` | reverse object   |
+| `!p` | O → S   | `[Parent](ex:p) {!hasPart}` | reverse object   |
 
 ## Syntax Reference
 
@@ -237,7 +236,7 @@ Reverse the relationship direction:
 ```markdown
 # Part {=ex:part}
 
-Part of: {^?hasPart}
+Part of: {!hasPart}
 
 - Book {=ex:book}
 ```
@@ -416,8 +415,8 @@ Each predicate is partitioned by **direction** and **node kind**:
 | -------------- | -------------- |
 | `p`            | `S ─p→ L`      |
 | `?p`           | `S ─p→ O`      |
-| `^p`           | `L ─p→ S`      |
-| `^?p`          | `O ─p→ S`      |
+| not allowed    | `L ─p→ S`      |
+| `!p`           | `O ─p→ S`      |
 
 This spans all **2 × 2** combinations of:
 
@@ -480,7 +479,7 @@ npm test
 
 Tests validate:
 - Subject declaration and context
-- All predicate forms (p, ?p, ^p, ^?p)
+- All predicate forms (p, ?p, !p)
 - Datatypes and language tags
 - List processing
 - Code blocks and blockquotes

package/index.js

@@ -75,15 +75,15 @@ export function parseSemanticBlock(raw) {
                 continue;
             }
 
-            if (token.startsWith('=?#')) {
-                const fragment = token.substring(3);
+            if (token.startsWith('+#')) {
+                const fragment = token.substring(2);
                 result.object = `#${fragment}`;
                 result.entries.push({ kind: 'softFragment', fragment, relRange: { start: relStart, end: relEnd }, raw: token });
                 continue;
             }
 
-            if (token.startsWith('=?')) {
-                const iri = token.substring(2);
+            if (token.startsWith('+')) {
+                const iri = token.substring(1);
                 result.object = iri;
                 result.entries.push({ kind: 'object', iri, relRange: { start: relStart, end: relEnd }, raw: token });
                 continue;
@@ -118,10 +118,10 @@ export function parseSemanticBlock(raw) {
                 continue;
             }
 
-            if (token.startsWith('^?')) {
-                const iri = token.substring(2);
-                result.predicates.push({ iri, form: '^?', entryIndex });
-                result.entries.push({ kind: 'property', iri, form: '^?', relRange: { start: relStart, end: relEnd }, raw: token });
+            if (token.startsWith('!')) {
+                const iri = token.substring(1);
+                result.predicates.push({ iri, form: '!', entryIndex });
+                result.entries.push({ kind: 'property', iri, form: '!', relRange: { start: relStart, end: relEnd }, raw: token });
                 continue;
             }
 
@@ -224,7 +224,7 @@ function scanTokens(text) {
             continue;
         }
 
-        const listMatch = line.match(/^(\s*)([-*+]|\d+\.)\s+(.+?)(?:\s*(\{[^}]+\}))?$/);
+        const listMatch = line.match(/^(\s*)([-*+]|\d+\.)\s+(.+?)(?:\s*(\{[^}]+\}))?\s*$/);
         if (listMatch) {
             const attrs = listMatch[4] || null;
             const attrsStartInLine = attrs ? line.lastIndexOf(attrs) : -1;
@@ -593,7 +593,7 @@ function processAnnotation(carrier, sem, state) {
             // L —p→ S (use soft IRI object as subject if available, otherwise current subject)
             const subjectIRI = localObject || S;
             emitQuad(state.quads, state.origin.quadIndex, block.id, L, P, subjectIRI, state.df, { kind: 'pred', token, form: pred.form, expandedPredicate: P.value, entryIndex: pred.entryIndex });
-        } else if (pred.form === '^?') {
+        } else if (pred.form === '!') {
             // O —p→ S (use previous subject as object, newSubject as subject)
             const objectIRI = newSubject ? previousSubject : S;
             const subjectIRI = localObject || newSubject || carrierO;
@@ -661,9 +661,9 @@ function processListContext(contextSem, listTokens, state, contextSubject = null
         contextSem.predicates.forEach(pred => {
             const P = state.df.namedNode(expandIRI(pred.iri, state.ctx));
 
-            // According to MD-LD spec: list predicates that connect to item subjects MUST use object predicate forms (?p or ^?p)
-            // Literal predicate forms (p, ^p) in list scope emit no quads
-            if (pred.form === '^?') {
+            // According to MD-LD spec: list predicates that connect to item subjects MUST use object predicate forms (?p or !p)
+            // Literal predicate forms (p) in list scope emit no quads
+            if (pred.form === '!') {
                 // Reverse object property: O —p→ S
                 emitQuad(state.quads, state.origin.quadIndex, 'list-context', itemSubject, P, contextSubject, state.df);
             } else if (pred.form === '?') {
@@ -676,8 +676,44 @@ function processListContext(contextSem, listTokens, state, contextSubject = null
         const prevSubject = state.currentSubject;
         state.currentSubject = itemSubject;
 
+        // Check if item has its own predicates
+        let hasOwnPredicates = false;
+        let itemSem = null;
+
         if (listToken.attrs) {
-            const itemSem = parseSemanticBlock(listToken.attrs);
+            itemSem = parseSemanticBlock(listToken.attrs);
+            if (itemSem.predicates.length > 0) {
+                hasOwnPredicates = true;
+            }
+        }
+
+        if (!hasOwnPredicates) {
+            // Check inline carriers for predicates
+            for (const carrier of carriers) {
+                if (carrier.attrs) {
+                    const carrierSem = parseSemanticBlock(carrier.attrs);
+                    if (carrierSem.predicates.length > 0) {
+                        hasOwnPredicates = true;
+                        break;
+                    }
+                }
+            }
+        }
+
+        // If item has no predicates, inherit literal predicates from context
+        if (!hasOwnPredicates) {
+            const inheritedPredicates = contextSem.predicates.filter(p => p.form === '');
+            if (inheritedPredicates.length > 0 && listToken.text) {
+                // Create inherited annotation block
+                const inheritedTokens = inheritedPredicates.map(p => p.iri).join(' ');
+                const inheritedSem = parseSemanticBlock(`{${inheritedTokens}}`);
+                const carrier = { type: 'list', text: listToken.text, range: listToken.range, attrsRange: listToken.attrsRange || null, valueRange: listToken.valueRange || null };
+                processAnnotation(carrier, inheritedSem, state);
+            }
+        }
+
+        if (listToken.attrs) {
+            if (!itemSem) itemSem = parseSemanticBlock(listToken.attrs);
             const carrier = { type: 'list', text: listToken.text, range: listToken.range, attrsRange: listToken.attrsRange || null, valueRange: listToken.valueRange || null };
             processAnnotation(carrier, itemSem, state);
         }
@@ -797,22 +833,22 @@ function removeOneToken(tokens, matchFn) {
 }
 
 function addObjectToken(tokens, iri) {
-    const objectToken = `=?${iri}`;
+    const objectToken = `+${iri}`;
     return tokens.includes(objectToken) ? tokens : [...tokens, objectToken];
 }
 
 function removeObjectToken(tokens, iri) {
-    const objectToken = `=?${iri}`;
+    const objectToken = `+${iri}`;
     return removeOneToken(tokens, t => t === objectToken);
 }
 
 function addSoftFragmentToken(tokens, fragment) {
-    const fragmentToken = `=?#${fragment}`;
+    const fragmentToken = `+#${fragment}`;
     return tokens.includes(fragmentToken) ? tokens : [...tokens, fragmentToken];
 }
 
 function removeSoftFragmentToken(tokens, fragment) {
-    const fragmentToken = `=?#${fragment}`;
+    const fragmentToken = `+#${fragment}`;
     return removeOneToken(tokens, t => t === fragmentToken);
 }
 
@@ -1203,7 +1239,7 @@ export function serialize({ text, diff, origin, options = {} }) {
                         const full = quad.object.value;
                         const label = shortenIRI(full, ctx);
                         const objectShort = shortenIRI(full, ctx);
-                        edits.push({ start: result.length, end: result.length, text: `\n[${label}] {=?${objectShort} ?${predShort}}` });
+                        edits.push({ start: result.length, end: result.length, text: `\n[${label}] {+${objectShort} ?${predShort}}` });
                     }
                     return;
                 }
@@ -1246,9 +1282,9 @@ export function serialize({ text, diff, origin, options = {} }) {
                         // Create new annotation with object token
                         if (isSoftFragment) {
                             const fragment = full.split('#')[1];
-                            edits.push({ start: result.length, end: result.length, text: `\n[${objectShort}] {=?#${fragment} ?${predShort}}` });
+                            edits.push({ start: result.length, end: result.length, text: `\n[${objectShort}] {+#${fragment} ?${predShort}}` });
                         } else {
-                            edits.push({ start: result.length, end: result.length, text: `\n[${objectShort}] {=?${objectShort} ?${predShort}}` });
+                            edits.push({ start: result.length, end: result.length, text: `\n[${objectShort}] {+${objectShort} ?${predShort}}` });
                         }
                     }
                     return;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mdld-parse",
-	"version": "0.2.10",
+	"version": "0.3.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",