links-notation 0.12.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "links-notation",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Links Notation parser for JavaScript",
   "main": "dist/index.js",
   "type": "module",
@@ -8,7 +8,9 @@
     "build": "bun run build:grammar && bun build src/index.js --outdir=dist --target=node",
     "build:grammar": "peggy --format es -o src/parser-generated.js src/grammar.pegjs",
     "test": "bun test",
-    "test:watch": "bun test --watch"
+    "test:watch": "bun test --watch",
+    "lint": "eslint src/ tests/",
+    "lint:fix": "eslint src/ tests/ --fix"
   },
   "keywords": [
     "lino",
@@ -20,7 +22,8 @@
   "license": "Unlicense",
   "devDependencies": {
     "bun-types": "^1.2.19",
+    "eslint": "^8.56.0",
     "peggy": "^5.0.6"
   },
   "dependencies": {}
-}
+}

package/src/FormatOptions.js

@@ -21,7 +21,7 @@ export class FormatOptions {
     this.indentLongLines = options.indentLongLines ?? false;
     this.maxInlineRefs = options.maxInlineRefs ?? null;
     this.groupConsecutive = options.groupConsecutive ?? false;
-    this.indentString = options.indentString ?? "  ";
+    this.indentString = options.indentString ?? '  ';
     this.preferInline = options.preferInline ?? true;
   }
 

package/src/Link.js

@@ -32,8 +32,9 @@ export class Link {
    * @returns {string} Space-separated string of values
    */
   getValuesString() {
-    return (!this.values || this.values.length === 0) ?
-      '' : this.values.map(v => Link.getValueString(v)).join(' ');
+    return !this.values || this.values.length === 0
+      ? ''
+      : this.values.map((v) => Link.getValueString(v)).join(' ');
   }
 
   /**
@@ -46,7 +47,7 @@ export class Link {
     } else if (this.values.length === 1) {
       return this.values[0];
     } else {
-      const newValues = this.values.map(v => {
+      const newValues = this.values.map((v) => {
         // Check if value has simplify method (defensive programming)
         return v && typeof v.simplify === 'function' ? v.simplify() : v;
       });
@@ -70,7 +71,9 @@ export class Link {
    */
   static getValueString(value) {
     // Defensive check for method existence
-    return value && typeof value.toLinkOrIdString === 'function' ? value.toLinkOrIdString() : String(value);
+    return value && typeof value.toLinkOrIdString === 'function'
+      ? value.toLinkOrIdString()
+      : String(value);
   }
 
   /**
@@ -164,7 +167,6 @@ export class Link {
     return true;
   }
 
-
   /**
    * Format the link as a string
    * @param {boolean|FormatOptions} lessParentheses - If true, omit parentheses where safe; or a FormatOptions object
@@ -174,8 +176,12 @@ export class Link {
   format(lessParentheses = false, isCompoundValue = false) {
     // Support FormatOptions/FormatConfig as first parameter
     // Check if it's an object with formatting properties (FormatOptions or FormatConfig)
-    if (lessParentheses && typeof lessParentheses === 'object' &&
-        (lessParentheses.constructor.name === 'FormatOptions' || lessParentheses.constructor.name === 'FormatConfig')) {
+    if (
+      lessParentheses &&
+      typeof lessParentheses === 'object' &&
+      (lessParentheses.constructor.name === 'FormatOptions' ||
+        lessParentheses.constructor.name === 'FormatConfig')
+    ) {
       return this._formatWithOptions(lessParentheses, isCompoundValue);
     }
 
@@ -184,7 +190,7 @@ export class Link {
     if (this.id === null && (!this.values || this.values.length === 0)) {
       return lessParentheses ? '' : '()';
     }
-    
+
     // Link with only ID, no values
     if (!this.values || this.values.length === 0) {
       const escapedId = Link.escapeReference(this.id);
@@ -192,21 +198,27 @@ export class Link {
       if (isCompoundValue) {
         return `(${escapedId})`;
       }
-      return lessParentheses && !this.needsParentheses(this.id) ? escapedId : `(${escapedId})`;
+      return lessParentheses && !this.needsParentheses(this.id)
+        ? escapedId
+        : `(${escapedId})`;
     }
-    
-    // Format values recursively  
-    const valuesStr = this.values.map(v => this.formatValue(v)).join(' ');
-    
+
+    // Format values recursively
+    const valuesStr = this.values.map((v) => this.formatValue(v)).join(' ');
+
     // Link with values only (null id)
     if (this.id === null) {
       // For lessParentheses mode with simple values, don't wrap the whole thing
       if (lessParentheses) {
         // Check if all values are simple (no nested values)
-        const allSimple = this.values.every(v => !v.values || v.values.length === 0);
+        const allSimple = this.values.every(
+          (v) => !v.values || v.values.length === 0
+        );
         if (allSimple) {
           // Format each value without extra wrapping
-          const simpleValuesStr = this.values.map(v => Link.escapeReference(v.id)).join(' ');
+          const simpleValuesStr = this.values
+            .map((v) => Link.escapeReference(v.id))
+            .join(' ');
           return simpleValuesStr;
         }
         // For mixed or complex values in lessParentheses mode, still avoid outer wrapper
@@ -216,13 +228,15 @@ export class Link {
       // For normal mode, wrap in parentheses
       return `(${valuesStr})`;
     }
-    
+
     // Link with ID and values
     const idStr = Link.escapeReference(this.id);
     const withColon = `${idStr}: ${valuesStr}`;
-    return lessParentheses && !this.needsParentheses(this.id) ? withColon : `(${withColon})`;
+    return lessParentheses && !this.needsParentheses(this.id)
+      ? withColon
+      : `(${withColon})`;
   }
-  
+
   /**
    * Format a value within this link
    * @param {Link} value - The value to format
@@ -257,7 +271,13 @@ export class Link {
    * @returns {boolean} True if parentheses are needed
    */
   needsParentheses(str) {
-    return str && (str.includes(' ') || str.includes(':') || str.includes('(') || str.includes(')'));
+    return (
+      str &&
+      (str.includes(' ') ||
+        str.includes(':') ||
+        str.includes('(') ||
+        str.includes(')'))
+    );
   }
 
   /**
@@ -278,7 +298,9 @@ export class Link {
       if (isCompoundValue) {
         return `(${escapedId})`;
       }
-      return options.lessParentheses && !this.needsParentheses(this.id) ? escapedId : `(${escapedId})`;
+      return options.lessParentheses && !this.needsParentheses(this.id)
+        ? escapedId
+        : `(${escapedId})`;
     }
 
     // Check if we should use indented format
@@ -287,11 +309,13 @@ export class Link {
       shouldIndent = true;
     } else {
       // Try inline format first
-      const valuesStr = this.values.map(v => this.formatValue(v)).join(' ');
+      const valuesStr = this.values.map((v) => this.formatValue(v)).join(' ');
       let testLine;
       if (this.id !== null) {
         const idStr = Link.escapeReference(this.id);
-        testLine = options.lessParentheses ? `${idStr}: ${valuesStr}` : `(${idStr}: ${valuesStr})`;
+        testLine = options.lessParentheses
+          ? `${idStr}: ${valuesStr}`
+          : `(${idStr}: ${valuesStr})`;
       } else {
         testLine = options.lessParentheses ? valuesStr : `(${valuesStr})`;
       }
@@ -307,14 +331,16 @@ export class Link {
     }
 
     // Standard inline formatting
-    const valuesStr = this.values.map(v => this.formatValue(v)).join(' ');
+    const valuesStr = this.values.map((v) => this.formatValue(v)).join(' ');
 
     // Link with values only (null id)
     if (this.id === null) {
       if (options.lessParentheses) {
-        const allSimple = this.values.every(v => !v.values || v.values.length === 0);
+        const allSimple = this.values.every(
+          (v) => !v.values || v.values.length === 0
+        );
         if (allSimple) {
-          return this.values.map(v => Link.escapeReference(v.id)).join(' ');
+          return this.values.map((v) => Link.escapeReference(v.id)).join(' ');
         }
         return valuesStr;
       }
@@ -324,7 +350,9 @@ export class Link {
     // Link with ID and values
     const idStr = Link.escapeReference(this.id);
     const withColon = `${idStr}: ${valuesStr}`;
-    return options.lessParentheses && !this.needsParentheses(this.id) ? withColon : `(${withColon})`;
+    return options.lessParentheses && !this.needsParentheses(this.id)
+      ? withColon
+      : `(${withColon})`;
   }
 
   /**
@@ -335,7 +363,9 @@ export class Link {
   _formatIndented(options) {
     if (this.id === null) {
       // Values only - format each on separate line
-      const lines = this.values.map(v => options.indentString + this.formatValue(v));
+      const lines = this.values.map(
+        (v) => options.indentString + this.formatValue(v)
+      );
       return lines.join('\n');
     }
 
@@ -373,7 +403,11 @@ function _groupConsecutiveLinks(links) {
 
       while (j < links.length) {
         const nextLink = links[j];
-        if (nextLink.id === current.id && nextLink.values && nextLink.values.length > 0) {
+        if (
+          nextLink.id === current.id &&
+          nextLink.values &&
+          nextLink.values.length > 0
+        ) {
           sameIdValues.push(...nextLink.values);
           j++;
         } else {
@@ -401,17 +435,21 @@ export function formatLinks(links, lessParentheses = false) {
   if (!links || links.length === 0) return '';
 
   // Support FormatOptions/FormatConfig as parameter
-  if (lessParentheses && typeof lessParentheses === 'object' &&
-      (lessParentheses.constructor.name === 'FormatOptions' || lessParentheses.constructor.name === 'FormatConfig')) {
+  if (
+    lessParentheses &&
+    typeof lessParentheses === 'object' &&
+    (lessParentheses.constructor.name === 'FormatOptions' ||
+      lessParentheses.constructor.name === 'FormatConfig')
+  ) {
     const options = lessParentheses;
     // Apply consecutive link grouping if enabled
     let linksToFormat = links;
     if (options.groupConsecutive) {
       linksToFormat = _groupConsecutiveLinks(links);
     }
-    return linksToFormat.map(link => link.format(options)).join('\n');
+    return linksToFormat.map((link) => link.format(options)).join('\n');
   }
 
   // Backward compatibility with boolean parameter
-  return links.map(link => link.format(lessParentheses)).join('\n');
-}
+  return links.map((link) => link.format(lessParentheses)).join('\n');
+}

package/src/LinksGroup.js

@@ -25,6 +25,6 @@ export class LinksGroup {
 
   toString() {
     const list = this.toList();
-    return list.map(item => `(${item.id || item})`).join(' ');
+    return list.map((item) => `(${item.id || item})`).join(' ');
   }
-}
+}

package/src/Parser.js

@@ -26,7 +26,9 @@ export class Parser {
     }
 
     if (input.length > this.maxInputSize) {
-      throw new Error(`Input size exceeds maximum allowed size of ${this.maxInputSize} bytes`);
+      throw new Error(
+        `Input size exceeds maximum allowed size of ${this.maxInputSize} bytes`
+      );
     }
 
     try {
@@ -72,10 +74,10 @@ export class Parser {
         });
         const linkWithChildren = {
           id: item.id,
-          values: childValues
+          values: childValues,
         };
         const currentLink = this.transformLink(linkWithChildren);
-        
+
         if (parentPath.length === 0) {
           result.push(currentLink);
         } else {
@@ -84,17 +86,17 @@ export class Parser {
       } else {
         // Regular indented structure - process as before
         const currentLink = this.transformLink(item);
-        
+
         // Add the link combined with parent path
         if (parentPath.length === 0) {
           result.push(currentLink);
         } else {
           result.push(this.combinePathElements(parentPath, currentLink));
         }
-        
+
         // Process each child with this item in the path
         const newPath = [...parentPath, currentLink];
-        
+
         for (const child of item.children) {
           this.collectLinks(child, newPath, result);
         }
@@ -102,7 +104,7 @@ export class Parser {
     } else {
       // Leaf item or item with inline values
       const currentLink = this.transformLink(item);
-      
+
       if (parentPath.length === 0) {
         result.push(currentLink);
       } else {
@@ -110,7 +112,7 @@ export class Parser {
       }
     }
   }
-  
+
   combinePathElements(pathElements, current) {
     if (pathElements.length === 0) return current;
     if (pathElements.length === 1) {
@@ -118,21 +120,20 @@ export class Parser {
       combined._isFromPathCombination = true;
       return combined;
     }
-    
+
     // For multiple path elements, we need to build proper nesting
     // The last element in the path should be combined with its parent
     const parentPath = pathElements.slice(0, -1);
     const lastElement = pathElements[pathElements.length - 1];
-    
+
     // Build the parent structure
     let parent = this.combinePathElements(parentPath, lastElement);
-    
+
     // Add current element to the built structure
     const combined = new Link(null, [parent, current]);
     combined._isFromPathCombination = true;
     return combined;
   }
-  
 
   /**
    * Transform a parsed item into a Link object
@@ -156,12 +157,11 @@ export class Parser {
     if (item.values && Array.isArray(item.values)) {
       // Create a link with id (if present) and transformed values
       const link = new Link(item.id || null, []);
-      link.values = item.values.map(v => this.transformLink(v));
+      link.values = item.values.map((v) => this.transformLink(v));
       return link;
     }
 
     // Default case
     return new Link(item.id || null, []);
   }
-
-}
+}

package/src/grammar.pegjs

@@ -34,6 +34,59 @@
   function getCurrentIndentation() {
     return indentationStack[indentationStack.length - 1];
   }
+
+  // Universal procedural parser for N-quote strings (any N >= 1)
+  // Parses from the given position in the input string
+  // Returns { value, length } or null
+  function parseQuotedStringAt(inputStr, startPos, quoteChar) {
+    if (startPos >= inputStr.length || inputStr[startPos] !== quoteChar) {
+      return null;
+    }
+
+    // Count opening quotes
+    let quoteCount = 0;
+    let pos = startPos;
+    while (pos < inputStr.length && inputStr[pos] === quoteChar) {
+      quoteCount++;
+      pos++;
+    }
+
+    const closeSeq = quoteChar.repeat(quoteCount);
+    const escapeSeq = quoteChar.repeat(quoteCount * 2);
+
+    let content = '';
+    while (pos < inputStr.length) {
+      // Check for escape sequence (2*N quotes)
+      if (inputStr.substr(pos, escapeSeq.length) === escapeSeq) {
+        content += closeSeq; // 2*N quotes become N quotes
+        pos += escapeSeq.length;
+        continue;
+      }
+
+      // Check for closing sequence (exactly N quotes)
+      if (inputStr.substr(pos, quoteCount) === closeSeq) {
+        // Verify it's exactly N quotes (not followed by more of same char)
+        const afterClose = pos + quoteCount;
+        if (afterClose >= inputStr.length || inputStr[afterClose] !== quoteChar) {
+          // Found valid closing
+          return {
+            value: content,
+            length: afterClose - startPos
+          };
+        }
+      }
+
+      // Add character to content
+      content += inputStr[pos];
+      pos++;
+    }
+
+    return null; // No valid closing found
+  }
+
+  // Global state for passing parsed values between predicate and action
+  let parsedValue = null;
+  let parsedLength = 0;
 }
 
 document = &{ indentationStack = [0]; baseIndentation = null; return true; } skipEmptyLines links:links _ eof { return links; }
@@ -79,13 +132,61 @@ multiLineValueLink = "(" v:multiLineValues _ ")" { return { values: v }; }
 
 indentedIdLink = id:reference __ ":" eol { return { id: id, values: [] }; }
 
-reference = doubleQuotedReference / singleQuotedReference / simpleReference 
+// Reference can be quoted (with any number of quotes N >= 1) or simple unquoted
+// Universal approach: use procedural parsing for all quote types and counts
+reference = quotedReference / simpleReference
 
 simpleReference = chars:referenceSymbol+ { return chars.join(''); }
 
-doubleQuotedReference = '"' r:[^"]+ '"' { return r.join(''); }
+// Universal quoted reference - handles any N quotes for all quote types
+// Uses procedural parsing with input/offset() for clean, simple logic
+quotedReference = doubleQuotedUniversal / singleQuotedUniversal / backtickQuotedUniversal
+
+// Double quotes: peek at input, parse procedurally, consume exact chars
+doubleQuotedUniversal = &'"' &{
+  const pos = offset();
+  const result = parseQuotedStringAt(input, pos, '"');
+  if (result) {
+    parsedValue = result.value;
+    parsedLength = result.length;
+    return true;
+  }
+  return false;
+} chars:consumeDouble { return parsedValue; }
+
+// Consume exactly parsedLength characters for double quotes
+consumeDouble = c:. cs:consumeDoubleMore* { return [c].concat(cs).join(''); }
+consumeDoubleMore = &{ return parsedLength > 1 && (parsedLength--, true); } c:. { return c; }
+
+// Single quotes
+singleQuotedUniversal = &"'" &{
+  const pos = offset();
+  const result = parseQuotedStringAt(input, pos, "'");
+  if (result) {
+    parsedValue = result.value;
+    parsedLength = result.length;
+    return true;
+  }
+  return false;
+} chars:consumeSingle { return parsedValue; }
+
+consumeSingle = c:. cs:consumeSingleMore* { return [c].concat(cs).join(''); }
+consumeSingleMore = &{ return parsedLength > 1 && (parsedLength--, true); } c:. { return c; }
+
+// Backticks
+backtickQuotedUniversal = &'`' &{
+  const pos = offset();
+  const result = parseQuotedStringAt(input, pos, '`');
+  if (result) {
+    parsedValue = result.value;
+    parsedLength = result.length;
+    return true;
+  }
+  return false;
+} chars:consumeBacktick { return parsedValue; }
 
-singleQuotedReference = "'" r:[^']+ "'" { return r.join(''); }
+consumeBacktick = c:. cs:consumeBacktickMore* { return [c].concat(cs).join(''); }
+consumeBacktickMore = &{ return parsedLength > 1 && (parsedLength--, true); } c:. { return c; }
 
 SET_BASE_INDENTATION = spaces:" "* { setBaseIndentation(spaces); }
 
@@ -103,4 +204,4 @@ _ = whiteSpaceSymbol*
 
 whiteSpaceSymbol = [ \t\n\r]
 
-referenceSymbol = [^ \t\n\r(:)]
+referenceSymbol = [^ \t\n\r(:)]

package/src/index.js

@@ -2,4 +2,4 @@ export { Link, formatLinks } from './Link.js';
 export { LinksGroup } from './LinksGroup.js';
 export { Parser } from './Parser.js';
 export { FormatConfig } from './FormatConfig.js';
-export { FormatOptions } from './FormatOptions.js';
+export { FormatOptions } from './FormatOptions.js';