clarity-pattern-parser 11.4.1 → 11.4.2

package/src/patterns/Literal.ts

@@ -13,10 +13,8 @@ export class Literal implements Pattern {
   private _name: string;
   private _parent: Pattern | null;
   private _token: string;
-  private _runes: string[];
   private _firstIndex: number;
   private _lastIndex: number;
-  private _endIndex: number;
 
   get id(): string {
     return this._id;
@@ -59,11 +57,9 @@ export class Literal implements Pattern {
     this._type = "literal";
     this._name = name;
     this._token = value;
-    this._runes = Array.from(value);
     this._parent = null;
     this._firstIndex = 0;
     this._lastIndex = 0;
-    this._endIndex = 0;
   }
 
   test(text: string, record = false): boolean {
@@ -76,6 +72,7 @@ export class Literal implements Pattern {
 
   parse(cursor: Cursor): Node | null {
     this._firstIndex = cursor.index;
+    this._lastIndex = cursor.index;
     const passed = this._tryToParse(cursor);
 
     if (passed) {
@@ -86,38 +83,33 @@ export class Literal implements Pattern {
       return node;
     }
 
-    cursor.recordErrorAt(this._firstIndex, this._endIndex, this);
+    cursor.recordErrorAt(this._firstIndex, this._lastIndex, this);
     return null;
   }
 
   private _tryToParse(cursor: Cursor): boolean {
-    let passed = false;
-    const literalRuneLength = this._runes.length;
-
-    for (let i = 0; i < literalRuneLength; i++) {
-      const literalRune = this._runes[i];
-      const cursorRune = cursor.currentChar;
-
-      if (literalRune !== cursorRune) {
-        this._endIndex = cursor.index;
-        break;
-      }
-
-      if (i + 1 === literalRuneLength) {
-        this._lastIndex = this._firstIndex + this._token.length - 1;
-        passed = true;
-        break;
-      }
-
-      if (!cursor.hasNext()) {
-        this._endIndex = cursor.index + 1;
-        break;
+    const token = this._token;
+    const compareToToken = cursor.text.slice(this._firstIndex, this._firstIndex + this._token.length);
+    const length = Math.min(token.length, compareToToken.length);
+
+    for (let i = 0 ; i < length; i++){
+      if (token[i] !== compareToToken[i]) {
+        this._lastIndex = this._firstIndex + i;
+        cursor.moveTo(this._lastIndex);
+        return false;
       }
+    }
 
-      cursor.next();
+    if (token != compareToToken){
+      this._lastIndex = this._firstIndex + compareToToken.length - 1;
+      cursor.moveTo(this._lastIndex);
+      return false;
     }
 
-    return passed;
+    this._lastIndex = this._firstIndex + this._token.length - 1;
+    cursor.moveTo(this._lastIndex);
+    return true;
+
   }
 
   private _createNode(): Node {

package/src/patterns/Regex.ts

@@ -58,7 +58,7 @@ export class Regex implements Pattern {
     this._name = name;
     this._parent = null;
     this._originalRegexString = regex;
-    this._regex = new RegExp(`^${regex}`, "g");
+    this._regex = new RegExp(`^${regex}`, "gu");
     this.assertArguments();
   }
 
@@ -101,7 +101,7 @@ export class Regex implements Pattern {
   private resetState(cursor: Cursor) {
     this._cursor = cursor;
     this._regex.lastIndex = 0;
-    this._substring = this._cursor.text.substr(this._cursor.index);
+    this._substring = this._cursor.text.slice(this._cursor.index);
     this._node = null;
   }
 
@@ -118,19 +118,19 @@ export class Regex implements Pattern {
   private processResult(cursor: Cursor, result: RegExpExecArray) {
     const currentIndex = cursor.index;
     const match = result[0];
-    const matchLength = [...match].length;
-    const newIndex = currentIndex + matchLength - 1;
+    const lastIndex = cursor.getCharLastIndex(currentIndex + match.length - 1);
+
 
     this._node = new Node(
       "regex",
       this._name,
       currentIndex,
-      newIndex,
+      lastIndex,
       undefined,
       result[0]
     );
 
-    cursor.moveTo(newIndex);
+    cursor.moveTo(lastIndex);
     cursor.recordMatch(this, this._node);
   }
 

package/src/patterns/TakeUntil.ts

@@ -92,7 +92,7 @@ export class TakeUntil implements Pattern {
 
         if (foundMatch) {
             cursor.moveTo(cursorIndex - 1);
-            const value = cursor.getChars(this.startedOnIndex, cursorIndex - 1);
+            const value = cursor.substring(this.startedOnIndex, cursorIndex - 1);
             const node = Node.createValueNode(this._type, this._name, value);
 
             cursor.recordMatch(this, node);

package/src/patterns/generate_error_message.ts

@@ -18,7 +18,7 @@ export function generateErrorMessage(pattern: Pattern, cursor: Cursor) {
 
     const lastPattern = furthestMatch.pattern as Pattern;
     const suggestions = cleanSuggestions(lastPattern.getNextTokens());
-    const strUpToError = cursor.getChars(0, endIndex);
+    const strUpToError = cursor.substring(0, endIndex);
     const lines = strUpToError.split("\n");
     const lastLine = lines[lines.length - 1];
     const line = lines.length;

package/tsconfig.json

@@ -3,7 +3,7 @@
     "moduleResolution": "node",
     "target": "es6",
     "module": "esnext",
-    "lib": ["es2021"],
+    "lib": ["esnext"],
     "strict": true,
     "sourceMap": true,
     "declaration": true,