links-notation 0.11.2 → 0.13.0

package/src/Parser.js

@@ -2,24 +2,54 @@ import { Link } from './Link.js';
 import * as parserModule from './parser-generated.js';
 
 export class Parser {
-  constructor() {
+  /**
+   * Create a new Parser instance
+   * @param {Object} options - Parser options
+   * @param {number} options.maxInputSize - Maximum input size in bytes (default: 10MB)
+   * @param {number} options.maxDepth - Maximum nesting depth (default: 1000)
+   */
+  constructor(options = {}) {
+    this.maxInputSize = options.maxInputSize || 10 * 1024 * 1024; // 10MB default
+    this.maxDepth = options.maxDepth || 1000;
   }
 
+  /**
+   * Parse Lino notation text into Link objects
+   * @param {string} input - The Lino notation text to parse
+   * @returns {Link[]} Array of parsed Link objects
+   * @throws {Error} If parsing fails
+   */
   parse(input) {
+    // Validate input
+    if (typeof input !== 'string') {
+      throw new TypeError('Input must be a string');
+    }
+
+    if (input.length > this.maxInputSize) {
+      throw new Error(
+        `Input size exceeds maximum allowed size of ${this.maxInputSize} bytes`
+      );
+    }
+
     try {
       const rawResult = parserModule.parse(input);
       return this.transformResult(rawResult);
     } catch (error) {
-      throw new Error(`Parse error: ${error.message}`);
+      // Preserve original error information
+      const parseError = new Error(`Parse error: ${error.message}`);
+      parseError.cause = error;
+      parseError.location = error.location;
+      throw parseError;
     }
   }
 
   transformResult(rawResult) {
     const links = [];
     const items = Array.isArray(rawResult) ? rawResult : [rawResult];
-    
+
     for (const item of items) {
-      if (item) {
+      // Use explicit null/undefined check
+      if (item !== null && item !== undefined) {
         this.collectLinks(item, [], links);
       }
     }
@@ -27,7 +57,8 @@ export class Parser {
   }
 
   collectLinks(item, parentPath, result) {
-    if (!item) return;
+    // Use explicit null/undefined check
+    if (item === null || item === undefined) return;
 
     // For items with children (indented structure)
     if (item.children && item.children.length > 0) {
@@ -43,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 {
@@ -55,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);
         }
@@ -73,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 {
@@ -81,7 +112,7 @@ export class Parser {
       }
     }
   }
-  
+
   combinePathElements(pathElements, current) {
     if (pathElements.length === 0) return current;
     if (pathElements.length === 1) {
@@ -89,25 +120,30 @@ 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
+   * @param {*} item - The item to transform
+   * @returns {Link|null} The transformed Link or null
+   */
   transformLink(item) {
-    if (!item) return null;
-    
+    // Use explicit null/undefined check
+    if (item === null || item === undefined) return null;
+
     if (item instanceof Link) {
       return item;
     }
@@ -121,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

@@ -1,3 +1,5 @@
 export { Link, formatLinks } from './Link.js';
 export { LinksGroup } from './LinksGroup.js';
-export { Parser } from './Parser.js';
+export { Parser } from './Parser.js';
+export { FormatConfig } from './FormatConfig.js';
+export { FormatOptions } from './FormatOptions.js';