clarity-pattern-parser 11.0.6 → 11.0.7

package/dist/patterns/CursorHistory.d.ts

@@ -31,7 +31,7 @@ export declare class CursorHistory {
     get nodes(): Node[];
     get patterns(): Pattern[];
     recordMatch(pattern: Pattern, node: Node): void;
-    recordErrorAt(startIndex: number, endIndex: number, pattern: Pattern): void;
+    recordErrorAt(startIndex: number, lastIndex: number, pattern: Pattern): void;
     startRecording(): void;
     stopRecording(): void;
     resolveError(): void;

package/dist/patterns/Expression.d.ts

@@ -0,0 +1,66 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
+import { Pattern } from "./Pattern";
+export declare class Expression implements Pattern {
+    private _id;
+    private _type;
+    private _name;
+    private _parent;
+    private _firstIndex;
+    private _originalPatterns;
+    private _patterns;
+    private _atomPatterns;
+    private _prefixPatterns;
+    private _prefixNames;
+    private _postfixPatterns;
+    private _postfixNames;
+    private _binaryPatterns;
+    private _binaryNames;
+    private _associationMap;
+    private _precedenceMap;
+    private _shouldStopParsing;
+    private _precedenceTree;
+    get id(): string;
+    get type(): string;
+    get name(): string;
+    get parent(): Pattern | null;
+    set parent(pattern: Pattern | null);
+    get children(): Pattern[];
+    get prefixPatterns(): readonly Pattern[];
+    get atomPatterns(): readonly Pattern[];
+    get postfixPatterns(): readonly Pattern[];
+    get binaryPatterns(): readonly Pattern[];
+    get startedOnIndex(): number;
+    constructor(name: string, patterns: Pattern[]);
+    private _organizePatterns;
+    private _extractName;
+    private _isPrefix;
+    private _extractPrefix;
+    private _isAtom;
+    private _isPostfix;
+    private _extractPostfix;
+    private _isBinary;
+    private _extractBinary;
+    private _unwrapAssociationIfNecessary;
+    private _referenceCount;
+    private _isRecursiveReference;
+    parse(cursor: Cursor): Node | null;
+    private _tryToParse;
+    private _tryToMatchPrefix;
+    private _tryToMatchAtom;
+    private _tryToMatchPostfix;
+    private _tryToMatchBinary;
+    private _isBeyondRecursiveAllowance;
+    test(text: string, record?: boolean): boolean;
+    exec(text: string, record?: boolean): ParseResult;
+    getTokens(): string[];
+    getTokensAfter(childReference: Pattern): string[];
+    getNextTokens(): string[];
+    getPatterns(): Pattern[];
+    getPatternsAfter(childReference: Pattern): Pattern[];
+    getNextPatterns(): Pattern[];
+    find(predicate: (p: Pattern) => boolean): Pattern | null;
+    clone(name?: string): Pattern;
+    isEqual(pattern: Expression): boolean;
+}

package/dist/patterns/Pattern.d.ts

@@ -5,9 +5,9 @@ export interface Pattern {
     id: string;
     type: string;
     name: string;
-    startedOnIndex: number;
     parent: Pattern | null;
     children: Pattern[];
+    startedOnIndex: number;
     parse(cursor: Cursor): Node | null;
     exec(text: string, record?: boolean): ParseResult;
     test(text: string, record?: boolean): boolean;

package/dist/patterns/RightAssociated.d.ts

@@ -0,0 +1,31 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
+import { Pattern } from "./Pattern";
+export declare class RightAssociated implements Pattern {
+    private _id;
+    private _type;
+    private _name;
+    private _parent;
+    private _children;
+    get id(): string;
+    get type(): string;
+    get name(): string;
+    get parent(): Pattern | null;
+    set parent(pattern: Pattern | null);
+    get children(): Pattern[];
+    get startedOnIndex(): number;
+    constructor(pattern: Pattern);
+    parse(cursor: Cursor): Node | null;
+    exec(text: string, record?: boolean | undefined): ParseResult;
+    test(text: string, record?: boolean | undefined): boolean;
+    clone(_name?: string | undefined): Pattern;
+    getTokens(): string[];
+    getTokensAfter(_childReference: Pattern): string[];
+    getNextTokens(): string[];
+    getPatterns(): Pattern[];
+    getPatternsAfter(_childReference: Pattern): Pattern[];
+    getNextPatterns(): Pattern[];
+    find(predicate: (pattern: Pattern) => boolean): Pattern | null;
+    isEqual(pattern: Pattern): boolean;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "11.0.6",
+  "version": "11.0.7",
   "description": "Parsing Library for Typescript and Javascript.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",

package/src/ast/Node.test.ts

@@ -329,12 +329,12 @@ describe("Node", () => {
         expect(result).toEqual(expected);
     });
 
-    test("Reduce", () => {
+    test("Compact", () => {
         const parent = new Node("parent", "parent", 0, 6, [
             new Node("child", "child", 0, 6, undefined, "Content")
         ]);
 
-        parent.reduce();
+        parent.compact();
 
         expect(parent.hasChildren).toBeFalsy();
         expect(parent.value).toBe("Content");

package/src/ast/Node.ts

@@ -28,6 +28,10 @@ export class Node {
     return this._name;
   }
 
+  get value() {
+    return this.toString();
+  }
+
   get firstIndex() {
     return this._firstIndex;
   }
@@ -60,10 +64,6 @@ export class Node {
     return !this.hasChildren;
   }
 
-  get value() {
-    return this.toString();
-  }
-
   constructor(
     type: string,
     name: string,
@@ -185,6 +185,16 @@ export class Node {
     return this.findAll(predicate)[0] || null;
   }
 
+  findAll(predicate: (node: Node) => boolean): Node[] {
+    const matches: Node[] = [];
+
+    this.walkUp(n => {
+      if (predicate(n)) { matches.push(n); }
+    });
+
+    return matches;
+  }
+
   findRoot() {
     let pattern: Node | null = this;
 
@@ -196,16 +206,6 @@ export class Node {
     }
   }
 
-  findAll(predicate: (node: Node) => boolean): Node[] {
-    const matches: Node[] = [];
-
-    this.walkUp(n => {
-      if (predicate(n)) { matches.push(n); }
-    });
-
-    return matches;
-  }
-
   findAncestor(predicate: (node: Node) => boolean) {
     let parent = this._parent;
 
@@ -267,7 +267,7 @@ export class Node {
     return nodes;
   }
 
-  reduce() {
+  compact() {
     const value = this.toString();
     this.removeAllChildren();
     this._value = value;
@@ -310,11 +310,6 @@ export class Node {
     return length;
   }
 
-  compact() {
-    this._value = this.toString();
-    this._children.length = 0;
-  }
-
   toString(): string {
     if (this._children.length === 0) {
       return this._value;

package/src/grammar/Grammar.ts

@@ -11,8 +11,8 @@ import { Repeat, RepeatOptions } from "../patterns/Repeat";
 import { AutoComplete } from "../intellisense/AutoComplete";
 import { Optional } from "../patterns/Optional";
 import { Context } from "../patterns/Context";
-import { ExpressionPattern } from "../patterns/ExpressionPattern";
-import { RightAssociatedPattern } from "../patterns/RightAssociatedPattern";
+import { Expression } from "../patterns/Expression";
+import { RightAssociated } from "../patterns/RightAssociated";
 
 let anonymousIndexId = 0;
 
@@ -88,17 +88,6 @@ export class Grammar {
         return this._buildPatternRecord();
     }
 
-    private _buildPatternRecord() {
-        const patterns: Record<string, Pattern> = {};
-        const allPatterns = Array.from(this._parseContext.patternsByName.values());
-
-        allPatterns.forEach(p => {
-            patterns[p.name] = new Context(p.name, p, allPatterns.filter(o => o !== p));
-        });
-
-        return patterns;
-    }
-
     parseString(expression: string) {
         this._parseContext = new ParseContext(this._params);
         const ast = this._tryToParse(expression);
@@ -112,6 +101,17 @@ export class Grammar {
         return this._buildPatternRecord();
     }
 
+    private _buildPatternRecord() {
+        const patterns: Record<string, Pattern> = {};
+        const allPatterns = Array.from(this._parseContext.patternsByName.values());
+
+        allPatterns.forEach(p => {
+            patterns[p.name] = new Context(p.name, p, allPatterns.filter(o => o !== p));
+        });
+
+        return patterns;
+    }
+
     private _tryToParse(expression: string): Node {
         const { ast, cursor, options, isComplete } = this._autoComplete.suggestFor(expression);
 
@@ -252,23 +252,23 @@ export class Grammar {
         const patterns = patternNodes.map(n => {
             const rightAssociated = n.find(n => n.name === "right-associated");
             if (rightAssociated != null) {
-                return new RightAssociatedPattern(this._buildPattern(n.children[0]));
+                return new RightAssociated(this._buildPattern(n.children[0]));
             } else {
                 return this._buildPattern(n.children[0]);
             }
 
         });
-        
+
         const hasRecursivePattern = patterns.some(p => this._isRecursive(name, p));
         if (hasRecursivePattern && !isGreedy) {
             try {
-                const expression = new ExpressionPattern(name, patterns);
+                const expression = new Expression(name, patterns);
                 return expression;
             } catch { }
         }
 
-        const or = new Options(name, patterns, isGreedy);
-        return or;
+        const options = new Options(name, patterns, isGreedy);
+        return options;
     }
 
     private _isRecursive(name: string, pattern: Pattern) {
@@ -280,7 +280,7 @@ export class Grammar {
     }
 
     private _isRecursivePattern(name: string, pattern: Pattern) {
-        if (pattern.children.length === 0){
+        if (pattern.children.length === 0) {
             return false;
         }
 
@@ -333,7 +333,7 @@ export class Grammar {
     }
 
     private _buildSequence(name: string, node: Node) {
-        const patternNodes = node.children.filter(n => n.name !== "and-divider");
+        const patternNodes = node.children.filter(n => n.name !== "sequence-divider");
 
         const patterns = patternNodes.map(n => {
             const patternNode = n.children[0].name === "not" ? n.children[1] : n.children[0];

package/src/grammar/patterns/sequenceLiteral.ts

@@ -10,15 +10,15 @@ import { Optional } from "../../patterns/Optional";
 const optionalNot = new Optional("optional-not", new Literal("not", "!"));
 const optionalIsOptional = new Optional("optional-is-optional", new Literal("is-optional", "?"));
 const patternName = name.clone("pattern-name");
-const patterns = new Options("and-patterns", [patternName, anonymousPattern]);
+const patterns = new Options("sequence-patterns", [patternName, anonymousPattern]);
 
-export const pattern = new Sequence("and-child-pattern", [
+export const pattern = new Sequence("sequence-child-pattern", [
     optionalNot,
     patterns,
     optionalIsOptional,
 ]);
 
-const divider = new Regex("and-divider", "\\s*[+]\\s*");
+const divider = new Regex("sequence-divider", "\\s*[+]\\s*");
 divider.setTokens([" + "]);
 
 export const sequenceLiteral = new Repeat("sequence-literal", pattern, { divider, min: 2, trimDivider: true });

package/src/index.ts

@@ -21,7 +21,8 @@ import { ParseResult } from "./patterns/ParseResult";
 import { grammar } from "./grammar/patterns/grammar";
 import { patterns } from "./grammar/patterns";
 import { Context } from "./patterns/Context";
-import { ExpressionPattern } from "./patterns/ExpressionPattern";
+import { Expression } from "./patterns/Expression";
+import { RightAssociated } from "./patterns/RightAssociated";
 
 export {
   Node,
@@ -35,7 +36,7 @@ export {
   CursorHistory,
   Match,
   Context,
-  ExpressionPattern,
+  Expression,
   Literal,
   Not,
   Options,
@@ -44,6 +45,7 @@ export {
   ParseResult,
   Pattern,
   Reference,
+  RightAssociated,
   Regex,
   Repeat,
   grammar,

package/src/patterns/CursorHistory.ts

@@ -112,11 +112,11 @@ export class CursorHistory {
     }
   }
 
-  recordErrorAt(startIndex: number, endIndex: number, pattern: Pattern): void {
-    const error = new ParseError(startIndex, endIndex, pattern);
+  recordErrorAt(startIndex: number, lastIndex: number, pattern: Pattern): void {
+    const error = new ParseError(startIndex, lastIndex, pattern);
     this._currentError = error;
 
-    if (this._furthestError === null || endIndex > this._furthestError.lastIndex) {
+    if (this._furthestError === null || lastIndex > this._furthestError.lastIndex) {
       this._furthestError = error;
     }
 

package/src/patterns/{ExpressionPattern.test.ts → Expression.test.ts}

@@ -1,12 +1,12 @@
 import { Options } from "./Options";
 import { Literal } from './Literal';
-import { ExpressionPattern } from './ExpressionPattern';
+import { Expression } from './Expression';
 import { Reference } from "./Reference";
 import { Sequence } from './Sequence';
 import { Regex } from './Regex';
 import { Optional } from "./Optional";
 import { AutoComplete } from "../intellisense/AutoComplete";
-import { RightAssociatedPattern } from "./RightAssociatedPattern";
+import { RightAssociated } from "./RightAssociated";
 
 function createExpressionPattern() {
     const spaces = new Regex("spaces", "\\s+");
@@ -75,11 +75,11 @@ function createExpressionPattern() {
         new Reference("expression"),
     ]);
 
-    const expression = new ExpressionPattern("expression", [
-        new RightAssociatedPattern(multDivExpression),
+    const expression = new Expression("expression", [
+        multDivExpression,
         addSubExpression,
         boolExpression,
-        new RightAssociatedPattern(ternary),
+        new RightAssociated(ternary),
         group,
         variables,
     ]);
@@ -92,8 +92,8 @@ function createOptionsExpression() {
     const b = new Literal("b", "b");
     const c = new Literal("c", "c");
 
-    const expressionPattern = new ExpressionPattern("expression", [a, b, c]);
-    return expressionPattern;
+    const expression = new Expression("expression", [a, b, c]);
+    return expression;
 }
 
 function createTailExpression() {
@@ -115,7 +115,7 @@ function createTailExpression() {
         invocation
     ]);
 
-    const expression = new ExpressionPattern("expression", [
+    const expression = new Expression("expression", [
         refinementExpression,
         invocationExpression,
         variable

package/src/patterns/{ExpressionPattern.ts → Expression.ts}

@@ -10,7 +10,7 @@ import { execPattern } from "./execPattern";
 
 let indexId = 0;
 
-export class ExpressionPattern implements Pattern {
+export class Expression implements Pattern {
     private _id: string;
     private _type: string;
     private _name: string;
@@ -83,7 +83,7 @@ export class ExpressionPattern implements Pattern {
         this._type = "expression";
         this._name = name;
         this._parent = null;
-        this._firstIndex = -1;
+        this._firstIndex = 0;
         this._atomPatterns = [];
         this._prefixPatterns = [];
         this._prefixNames = [];
@@ -135,11 +135,11 @@ export class ExpressionPattern implements Pattern {
                 finalPatterns.push(postfix);
             } else if (this._isBinary(pattern)) {
                 const name = this._extractName(pattern);
-                const clone = this._extractBinary(pattern);
-                clone.parent = this;
+                const binary = this._extractBinary(pattern);
+                binary.parent = this;
 
                 this._precedenceMap[name] = this._binaryPatterns.length;
-                this._binaryPatterns.push(clone);
+                this._binaryPatterns.push(binary);
                 this._binaryNames.push(name);
 
                 if (pattern.type === "right-associated") {
@@ -148,7 +148,7 @@ export class ExpressionPattern implements Pattern {
                     this._associationMap[name] = Association.left;
                 }
 
-                finalPatterns.push(clone);
+                finalPatterns.push(binary);
             }
         });
 
@@ -183,7 +183,7 @@ export class ExpressionPattern implements Pattern {
         pattern = this._unwrapAssociationIfNecessary(pattern);
 
         const firstChild = pattern.children[0];
-        const lastChild = pattern.children[pattern.children.length -1];
+        const lastChild = pattern.children[pattern.children.length - 1];
         const firstChildIsReference = this._isRecursiveReference(firstChild);
         const lastChildIsReference = this._isRecursiveReference(lastChild);
 
@@ -454,7 +454,10 @@ export class ExpressionPattern implements Pattern {
     }
 
     getTokens(): string[] {
-        return this.atomPatterns.map(p => p.getTokens()).flat();
+        const atomTokens = this._atomPatterns.map(p => p.getTokens()).flat();
+        const prefixTokens = this.prefixPatterns.map(p => p.getTokens()).flat();
+
+        return [...prefixTokens, ...atomTokens];
     }
 
     getTokensAfter(childReference: Pattern): string[] {
@@ -468,7 +471,7 @@ export class ExpressionPattern implements Pattern {
         if (this._atomPatterns.includes(childReference)) {
             const postfixTokens = this.prefixPatterns.map(p => p.getTokens()).flat();
 
-            if (postfixTokens.length === 0){
+            if (postfixTokens.length === 0) {
                 return this._binaryPatterns.map(p => p.getTokens()).flat();
             }
 
@@ -494,7 +497,10 @@ export class ExpressionPattern implements Pattern {
     }
 
     getPatterns(): Pattern[] {
-        return this.atomPatterns.map(p => p.getPatterns()).flat();
+        const atomPatterns = this._atomPatterns.map(p => p.getPatterns()).flat();
+        const prefixPatterns = this.prefixPatterns.map(p => p.getPatterns()).flat();
+
+        return [...prefixPatterns, ...atomPatterns];
     }
 
     getPatternsAfter(childReference: Pattern): Pattern[] {
@@ -508,7 +514,7 @@ export class ExpressionPattern implements Pattern {
         if (this._atomPatterns.includes(childReference)) {
             const postfixPatterns = this.prefixPatterns.map(p => p.getPatterns()).flat();
 
-            if (postfixPatterns.length === 0){
+            if (postfixPatterns.length === 0) {
                 return this._binaryPatterns.map(p => p.getPatterns()).flat();
             }
 
@@ -538,12 +544,12 @@ export class ExpressionPattern implements Pattern {
     }
 
     clone(name = this._name): Pattern {
-        const clone = new ExpressionPattern(name, this._originalPatterns);
+        const clone = new Expression(name, this._originalPatterns);
         clone._id = this._id;
         return clone;
     }
 
-    isEqual(pattern: ExpressionPattern): boolean {
+    isEqual(pattern: Expression): boolean {
         return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
     }
 }

package/src/patterns/FiniteRepeat.ts

@@ -93,7 +93,6 @@ export class FiniteRepeat implements Pattern {
     parse(cursor: Cursor): Node | null {
         this._firstIndex = cursor.index;
 
-        const startIndex = cursor.index;
         const nodes: Node[] = [];
         const modulo = this._hasDivider ? 2 : 1;
         let matchCount = 0;
@@ -134,13 +133,13 @@ export class FiniteRepeat implements Pattern {
 
         if (matchCount < this._min) {
             const lastIndex = cursor.index;
-            cursor.moveTo(startIndex);
-            cursor.recordErrorAt(startIndex, lastIndex, this);
+            cursor.moveTo(this._firstIndex);
+            cursor.recordErrorAt(this._firstIndex, lastIndex, this);
             return null;
         }
 
         if (nodes.length === 0 && !cursor.hasError) {
-            cursor.moveTo(startIndex);
+            cursor.moveTo(this._firstIndex);
             return null;
         }
 
@@ -150,7 +149,13 @@ export class FiniteRepeat implements Pattern {
         cursor.resolveError();
         cursor.moveTo(lastIndex);
 
-        const node = new Node(this._type, this.name, firstIndex, lastIndex, nodes);
+        const node = new Node(
+            this._type,
+            this.name,
+            firstIndex,
+            lastIndex,
+            nodes
+        );
 
         return node;
     }

package/src/patterns/InfiniteRepeat.ts

@@ -80,7 +80,7 @@ export class InfiniteRepeat implements Pattern {
     this._children = children;
     this._pattern = children[0];
     this._divider = children[1];
-    this._firstIndex = -1;
+    this._firstIndex = 0;
     this._nodes = [];
     this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
   }
@@ -91,7 +91,6 @@ export class InfiniteRepeat implements Pattern {
     }
   }
 
-
   test(text: string, record = false): boolean {
     return testPattern(this, text, record);
   }
@@ -113,7 +112,6 @@ export class InfiniteRepeat implements Pattern {
       if (node != null) {
         cursor.moveTo(node.lastIndex);
         cursor.recordMatch(this, node);
-
       }
 
       return node;
@@ -314,7 +312,7 @@ export class InfiniteRepeat implements Pattern {
     }
 
     // If there is no divider then suggest the repeating pattern and the next pattern after.
-    if (index === 0 && !this._divider && this._parent) {
+    if (index === 0 && this._divider == null && this._parent) {
       patterns.push(this._children[0]);
       patterns.push(...this._parent.getPatternsAfter(this));
     }
@@ -348,7 +346,6 @@ export class InfiniteRepeat implements Pattern {
     );
 
     clone._id = this._id;
-
     return clone;
   }
 

package/src/patterns/Pattern.ts

@@ -6,9 +6,9 @@ export interface Pattern {
   id: string;
   type: string;
   name: string;
-  startedOnIndex: number;
   parent: Pattern | null;
   children: Pattern[];
+  startedOnIndex: number;
 
   parse(cursor: Cursor): Node | null;
   exec(text: string, record?: boolean): ParseResult;

package/src/patterns/{RightAssociatedPattern.ts → RightAssociated.ts}

@@ -5,7 +5,7 @@ import { Pattern } from "./Pattern";
 
 let indexId = 0;
 
-export class RightAssociatedPattern implements Pattern {
+export class RightAssociated implements Pattern {
     private _id: string;
     private _type: string;
     private _name: string;
@@ -61,7 +61,7 @@ export class RightAssociatedPattern implements Pattern {
     }
 
     clone(_name?: string | undefined): Pattern {
-        const clone = new RightAssociatedPattern(this.children[0]);
+        const clone = new RightAssociated(this.children[0]);
         clone._id = this._id;
         return clone;
     }