clarity-pattern-parser 11.4.0 → 11.4.2

package/dist/grammar_v2/patterns/Grammar.d.ts

@@ -0,0 +1,23 @@
+import { GrammarFile } from "../../grammar/Grammar";
+import { Pattern } from "../../patterns/Pattern";
+export type Decorator = (pattern: Pattern, arg?: string | boolean | number | null | Record<string, any> | any[]) => void;
+export interface GrammarOptions {
+    resolveImport?: (resource: string, originResource: string | null) => Promise<GrammarFile>;
+    resolveImportSync?: (resource: string, originResource: string | null) => GrammarFile;
+    originResource?: string | null;
+    params?: Pattern[];
+    decorators?: Record<string, Decorator>;
+}
+export declare class Grammar {
+    private _options;
+    private _parseContext;
+    private _resolveImportSync;
+    constructor(options: GrammarOptions);
+    private _resolveImportsSync;
+    private _processImportSync;
+    private _getWithParams;
+    private _processUseParams;
+    private _tryToParse;
+    private _flattenExpressions;
+    private _unwrapNode;
+}

package/dist/grammar_v2/patterns/patterns/grammar.d.ts

@@ -0,0 +1,87 @@
+import { Expression } from "../../../patterns/Expression";
+import { Literal } from "../../../patterns/Literal";
+import { Optional } from "../../../patterns/Optional";
+import { Options } from "../../../patterns/Options";
+import { Regex } from "../../../patterns/Regex";
+import { Repeat } from "../../../patterns/Repeat";
+import { Sequence } from "../../../patterns/Sequence";
+export declare const syntax: Literal;
+export declare const imprt: Literal;
+export declare const useParams: Literal;
+export declare const withParams: Literal;
+export declare const from: Literal;
+export declare const right: Literal;
+export declare const ws: Regex;
+export declare const ls: Regex;
+export declare const assign: Literal;
+export declare const bar: Literal;
+export declare const greedyBar: Literal;
+export declare const concat: Literal;
+export declare const colon: Literal;
+export declare const openParen: Literal;
+export declare const closeParen: Literal;
+export declare const openSquareBracket: Literal;
+export declare const closeSquareBracket: Literal;
+export declare const openBracket: Literal;
+export declare const closeBracket: Literal;
+export declare const comma: Regex;
+export declare const trim: Literal;
+export declare const not: Literal;
+export declare const optional: Literal;
+export declare const newLine: Regex;
+export declare const syntaxVersion: Regex;
+export declare const at: Literal;
+export declare const optionalWS: Optional;
+export declare const optionalLS: Optional;
+export declare const literal: Regex;
+export declare const regex: Regex;
+export declare const integer: Regex;
+export declare const name: Regex;
+export declare const patternName: Regex;
+export declare const patternIdentifier: Regex;
+export declare const resource: Regex;
+export declare const comment: Regex;
+export declare const jsonString: Regex;
+export declare const jsonNumber: Regex;
+export declare const trueLiteral: Literal;
+export declare const falseLiteral: Literal;
+export declare const jsonBoolean: Options;
+export declare const jsonNull: Literal;
+export declare const jsonArrayItems: Repeat;
+export declare const jsonArray: Sequence;
+export declare const jsonObjectPropertyName: Regex;
+export declare const jsonObjectProperty: Sequence;
+export declare const jsonObjectProperties: Repeat;
+export declare const jsonObject: Sequence;
+export declare const jsonValue: Options;
+export declare const syntaxStatement: Sequence;
+export declare const decorationName: Regex;
+export declare const decorationStatement: Sequence;
+export declare const useParamPatterns: Repeat;
+export declare const useParamsStatement: Sequence;
+export declare const withParamStatements: Repeat;
+export declare const withParamsExpr: Sequence;
+export declare const patternNames: Repeat;
+export declare const importedPatterns: Sequence;
+export declare const importStatement: Sequence;
+export declare const notExpr: Sequence;
+export declare const optionalExpr: Sequence;
+export declare const rightAssociationExpr: Sequence;
+export declare const unaryPatternExpr: Expression;
+export declare const repeatBounds: Sequence;
+export declare const oneOrMore: Literal;
+export declare const zeroOrMore: Literal;
+export declare const repeatOptions: Options;
+export declare const delimiter: Sequence;
+export declare const repeatExpr: Sequence;
+export declare const sequenceExpr: Sequence;
+export declare const optionsExpr: Sequence;
+export declare const greedyOptionsExpr: Sequence;
+export declare const patternGroupExpr: Sequence;
+export declare const exportPattern: Regex;
+export declare const patternExpr: Expression;
+export declare const patternAssignment: Sequence;
+export declare const statement: Options;
+export declare const statements: Repeat;
+export declare const cpat: Sequence;
+export declare const grammar: Sequence;

package/dist/grammar_v2/patterns/patterns/grammar.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.browser.js

@@ -433,6 +433,7 @@
         }
     }
 
+    const segmenter = new Intl.Segmenter("und", { granularity: "grapheme" });
     class Cursor {
         get text() {
             return this._text;
@@ -483,33 +484,55 @@
             return this._history.error != null;
         }
         get currentChar() {
-            return this._text[this._index];
+            const index = this.getCharStartIndex(this._index);
+            return this.text.slice(index, index + this._charSize[index]);
         }
         constructor(text) {
             this._text = text;
+            this._length = text.length;
+            this._charSize = [];
+            this._charMap = [];
             this._index = 0;
-            this._length = [...text].length;
             this._history = new CursorHistory();
+            let index = 0;
+            for (const segment of segmenter.segment(text)) {
+                const size = segment.segment.length;
+                for (let i = 0; i < size; i++) {
+                    this._charMap.push(index);
+                    this._charSize.push(size);
+                }
+                index += size;
+            }
         }
         hasNext() {
-            return this._index + 1 < this._length;
+            const index = this._charMap[this._index];
+            const charSize = this._charSize[index];
+            return index + charSize < this._length;
         }
         next() {
             if (this.hasNext()) {
-                this._index++;
+                const index = this._charMap[this._index];
+                const size = this._charSize[index];
+                this.moveTo(index + size);
             }
         }
         hasPrevious() {
-            return this._index - 1 >= 0;
+            var _a;
+            const index = this._charMap[this._index];
+            const previousIndex = (_a = this._charMap[index - 1]) !== null && _a !== void 0 ? _a : -1;
+            return previousIndex >= 0;
         }
         previous() {
+            var _a;
             if (this.hasPrevious()) {
-                this._index--;
+                const index = this._charMap[this._index];
+                const previousIndex = (_a = this._charMap[index - 1]) !== null && _a !== void 0 ? _a : -1;
+                this.moveTo(previousIndex);
             }
         }
         moveTo(position) {
             if (position >= 0 && position < this._length) {
-                this._index = position;
+                this._index = this._charMap[position];
             }
         }
         moveToFirstChar() {
@@ -521,7 +544,7 @@
         getLastIndex() {
             return this._length - 1;
         }
-        getChars(first, last) {
+        substring(first, last) {
             return this._text.slice(first, last + 1);
         }
         recordMatch(pattern, node) {
@@ -539,6 +562,18 @@
         stopRecording() {
             this._history.stopRecording();
         }
+        getCharStartIndex(index) {
+            return this._charMap[index];
+        }
+        getCharEndIndex(index) {
+            var _a;
+            let startIndex = this.getCharStartIndex(index);
+            return (_a = startIndex + this._charSize[startIndex]) !== null && _a !== void 0 ? _a : 1;
+        }
+        getCharLastIndex(index) {
+            var _a;
+            return (_a = this.getCharEndIndex(index) - 1) !== null && _a !== void 0 ? _a : 0;
+        }
     }
 
     function execPattern(pattern, text, record = false) {
@@ -604,11 +639,9 @@
             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, record = false) {
             return testPattern(this, text, record);
@@ -618,6 +651,7 @@
         }
         parse(cursor) {
             this._firstIndex = cursor.index;
+            this._lastIndex = cursor.index;
             const passed = this._tryToParse(cursor);
             if (passed) {
                 cursor.resolveError();
@@ -625,31 +659,28 @@
                 cursor.recordMatch(this, node);
                 return node;
             }
-            cursor.recordErrorAt(this._firstIndex, this._endIndex, this);
+            cursor.recordErrorAt(this._firstIndex, this._lastIndex, this);
             return null;
         }
         _tryToParse(cursor) {
-            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();
             }
-            return passed;
+            if (token != compareToToken) {
+                this._lastIndex = this._firstIndex + compareToToken.length - 1;
+                cursor.moveTo(this._lastIndex);
+                return false;
+            }
+            this._lastIndex = this._firstIndex + this._token.length - 1;
+            cursor.moveTo(this._lastIndex);
+            return true;
         }
         _createNode() {
             return new Node("literal", this._name, this._firstIndex, this._lastIndex, undefined, this._token);
@@ -728,7 +759,7 @@
             this._name = name;
             this._parent = null;
             this._originalRegexString = regex;
-            this._regex = new RegExp(`^${regex}`, "g");
+            this._regex = new RegExp(`^${regex}`, "gu");
             this.assertArguments();
         }
         assertArguments() {
@@ -757,7 +788,7 @@
         resetState(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;
         }
         tryToParse(cursor) {
@@ -771,9 +802,10 @@
         }
         processResult(cursor, result) {
             const currentIndex = cursor.index;
-            const newIndex = currentIndex + result[0].length - 1;
-            this._node = new Node("regex", this._name, currentIndex, newIndex, undefined, result[0]);
-            cursor.moveTo(newIndex);
+            const match = result[0];
+            const lastIndex = cursor.getCharLastIndex(currentIndex + match.length - 1);
+            this._node = new Node("regex", this._name, currentIndex, lastIndex, undefined, result[0]);
+            cursor.moveTo(lastIndex);
             cursor.recordMatch(this, this._node);
         }
         processError(cursor) {
@@ -3301,7 +3333,7 @@
             }
             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);
                 return node;
@@ -3453,7 +3485,7 @@
         }
         const lastPattern = furthestMatch.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;
@@ -4191,9 +4223,9 @@
         }
         _createSuggestionOptionsFromErrors() {
             // These errored because the length of the string.
-            const errors = this._cursor.errors.filter(e => e.lastIndex === this._cursor.length);
+            const errors = this._cursor.errors.filter(e => e.lastIndex === this._cursor.length - 1);
             const errorSuggestionOptions = errors.map(parseError => {
-                const currentText = this._cursor.getChars(parseError.startIndex, parseError.lastIndex);
+                const currentText = this._cursor.substring(parseError.startIndex, parseError.lastIndex);
                 const compositeSuggestions = this._getCompositeSuggestionsForPattern(parseError.pattern);
                 const trimmedErrorCompositeSuggestions = this._trimSuggestionsByExistingText(currentText, compositeSuggestions);
                 return this._createSuggestions(parseError.lastIndex, trimmedErrorCompositeSuggestions);
@@ -4249,7 +4281,7 @@
        * ie. sequence pattern segments ≈ [{look}, {an example}, {phrase}]
        * fullText = "look an"
        * remove {look} segment as its already been completed by the existing text.
-     */
+      */
         _filterCompletedSubSegments(currentText, compositeSuggestion) {
             let elementsToRemove = [];
             let workingText = currentText;
@@ -4352,7 +4384,7 @@
             return unique;
         }
         _createSuggestions(lastIndex, compositeSuggestionList) {
-            let textToIndex = lastIndex === -1 ? "" : this._cursor.getChars(0, lastIndex);
+            let textToIndex = lastIndex === -1 ? "" : this._cursor.substring(0, lastIndex);
             const options = [];
             for (const compositeSuggestion of compositeSuggestionList) {
                 // concatenated for start index identification inside createSuggestion