@ptolemy2002/rgx 8.0.1 → 8.2.0

package/README.md

@@ -17,10 +17,12 @@ Because there is so much to document, it has been broken up into multiple files.
   - [escapeRegex](./docs/util/escapeRegex.md) - The `escapeRegex` function, which escapes special regex characters in a given string and assures you that the result is valid Regex.
   - [regexMatchAtPosition](./docs/util/regexMatchAtPosition.md) - The `regexMatchAtPosition` function and related functions, which attempt to match a given regular expression at a specific position in a string.
   - [regexWithFlags](./docs/util/regexWithFlags.md) - The `regexWithFlags` function, which creates a new regular expression with the same source as a given regular expression but with different flags.
+  - [createRGXClassGuardFunction](./docs/util/createRGXClassGuardFunction.md) - The `createRGXClassGuardFunction` and `createAssertRGXClassGuardFunction` utilities for creating type guard and assertion functions for class instances.
 - `class` - A directory containing documentation for all classes in the library.
   - [collection](./docs/class/collection.md) - The `RGXTokenCollection` class, which is a collection of tokens.
   - [RGXError](./docs/class/RGXError.md) - Details on all custom error classes and the base `RGXError` class.
   - [walker](./docs/class/walker.md) - Details on both `RGXWalker` and `RGXPart`, which are used for creating custom matchers that can validate partial matches and transform captured values with custom logic.
+  - [lexer](./docs/class/lexer.md) - Details on `RGXLexer`, which tokenizes a source string into structured lexemes using named lexeme definitions grouped by mode.
   - `token` - A directory containing documentation for all token classes in the library, which are classes that represent specific types of tokens that can be used in regular expressions.
     - [base](./docs/class/token/base.md) - The `RGXClassToken` class, which is the base class for all token classes in the library.
     - [group](./docs/class/token/group.md) - The `RGXGroupToken` class, which represents a group of tokens that can be treated as a single unit in a regular expression.

package/dist/class/group.js

@@ -4,6 +4,7 @@ exports.rgxGroup = exports.RGXGroupToken = void 0;
 const collection_1 = require("../collection");
 const base_1 = require("./base");
 const internal_1 = require("../internal");
+const utils_1 = require("../utils");
 const typeGuards_1 = require("../typeGuards");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
 class RGXGroupToken extends base_1.RGXClassToken {
@@ -60,6 +61,6 @@ class RGXGroupToken extends base_1.RGXClassToken {
     }
 }
 exports.RGXGroupToken = RGXGroupToken;
-RGXGroupToken.check = (0, internal_1.createClassGuardFunction)(RGXGroupToken);
-RGXGroupToken.assert = (0, internal_1.createAssertClassGuardFunction)(RGXGroupToken);
+RGXGroupToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXGroupToken);
+RGXGroupToken.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXGroupToken);
 exports.rgxGroup = (0, internal_1.createConstructFunction)(RGXGroupToken);

package/dist/class/lookahead.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rgxLookahead = exports.RGXLookaheadToken = void 0;
 const internal_1 = require("../internal");
+const utils_1 = require("../utils");
 const lookaround_1 = require("./lookaround");
 const lookbehind_1 = require("./lookbehind");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
@@ -27,6 +28,6 @@ class RGXLookaheadToken extends lookaround_1.RGXLookaroundToken {
     }
 }
 exports.RGXLookaheadToken = RGXLookaheadToken;
-RGXLookaheadToken.check = (0, internal_1.createClassGuardFunction)(RGXLookaheadToken);
-RGXLookaheadToken.assert = (0, internal_1.createAssertClassGuardFunction)(RGXLookaheadToken);
+RGXLookaheadToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXLookaheadToken);
+RGXLookaheadToken.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXLookaheadToken);
 exports.rgxLookahead = (0, internal_1.createConstructFunction)(RGXLookaheadToken);

package/dist/class/lookbehind.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rgxLookbehind = exports.RGXLookbehindToken = void 0;
 const internal_1 = require("../internal");
+const utils_1 = require("../utils");
 const lookahead_1 = require("./lookahead");
 const lookaround_1 = require("./lookaround");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
@@ -27,6 +28,6 @@ class RGXLookbehindToken extends lookaround_1.RGXLookaroundToken {
     }
 }
 exports.RGXLookbehindToken = RGXLookbehindToken;
-RGXLookbehindToken.check = (0, internal_1.createClassGuardFunction)(RGXLookbehindToken);
-RGXLookbehindToken.assert = (0, internal_1.createAssertClassGuardFunction)(RGXLookbehindToken);
+RGXLookbehindToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXLookbehindToken);
+RGXLookbehindToken.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXLookbehindToken);
 exports.rgxLookbehind = (0, internal_1.createConstructFunction)(RGXLookbehindToken);

package/dist/class/repeat.js

@@ -7,6 +7,7 @@ const typeGuards_1 = require("../typeGuards");
 const errors_1 = require("../errors");
 const resolve_1 = require("../resolve");
 const internal_1 = require("../internal");
+const utils_1 = require("../utils");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
 const clone_1 = require("../clone");
 class RGXRepeatToken extends base_1.RGXClassToken {
@@ -98,6 +99,6 @@ class RGXRepeatToken extends base_1.RGXClassToken {
     }
 }
 exports.RGXRepeatToken = RGXRepeatToken;
-RGXRepeatToken.check = (0, internal_1.createClassGuardFunction)(RGXRepeatToken);
-RGXRepeatToken.assert = (0, internal_1.createAssertClassGuardFunction)(RGXRepeatToken);
+RGXRepeatToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXRepeatToken);
+RGXRepeatToken.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXRepeatToken);
 exports.rgxRepeat = (0, internal_1.createConstructFunction)(RGXRepeatToken);

package/dist/class/subpattern.js

@@ -5,6 +5,7 @@ const base_1 = require("./base");
 const typeGuards_1 = require("../typeGuards");
 const errors_1 = require("../errors");
 const internal_1 = require("../internal");
+const utils_1 = require("../utils");
 class RGXSubpatternToken extends base_1.RGXClassToken {
     get pattern() {
         return this._pattern;
@@ -38,6 +39,6 @@ class RGXSubpatternToken extends base_1.RGXClassToken {
     }
 }
 exports.RGXSubpatternToken = RGXSubpatternToken;
-RGXSubpatternToken.check = (0, internal_1.createClassGuardFunction)(RGXSubpatternToken);
-RGXSubpatternToken.assert = (0, internal_1.createAssertClassGuardFunction)(RGXSubpatternToken);
+RGXSubpatternToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXSubpatternToken);
+RGXSubpatternToken.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXSubpatternToken);
 exports.rgxSubpattern = (0, internal_1.createConstructFunction)(RGXSubpatternToken);

package/dist/class/union.js

@@ -7,6 +7,7 @@ const internal_1 = require("../internal");
 const collection_1 = require("../collection");
 const base_1 = require("./base");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
+const utils_1 = require("../utils");
 class RGXClassUnionToken extends base_1.RGXClassToken {
     constructor(tokens = []) {
         super();
@@ -52,8 +53,8 @@ class RGXClassUnionToken extends base_1.RGXClassToken {
     }
 }
 exports.RGXClassUnionToken = RGXClassUnionToken;
-RGXClassUnionToken.check = (0, internal_1.createClassGuardFunction)(RGXClassUnionToken);
-RGXClassUnionToken.assert = (0, internal_1.createAssertClassGuardFunction)(RGXClassUnionToken);
+RGXClassUnionToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXClassUnionToken);
+RGXClassUnionToken.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXClassUnionToken);
 function expandRgxUnionTokens(...tokens) {
     const result = new collection_1.RGXTokenCollection();
     for (const token of tokens) {

package/dist/class/wrapper.js

@@ -6,6 +6,7 @@ const typeGuards_1 = require("../typeGuards");
 const internal_1 = require("../internal");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
 const clone_1 = require("../clone");
+const utils_1 = require("../utils");
 class RGXClassWrapperToken extends base_1.RGXClassToken {
     constructor(token) {
         super();
@@ -33,6 +34,6 @@ class RGXClassWrapperToken extends base_1.RGXClassToken {
     }
 }
 exports.RGXClassWrapperToken = RGXClassWrapperToken;
-RGXClassWrapperToken.check = (0, internal_1.createClassGuardFunction)(RGXClassWrapperToken);
-RGXClassWrapperToken.assert = (0, internal_1.createAssertClassGuardFunction)(RGXClassWrapperToken);
+RGXClassWrapperToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXClassWrapperToken);
+RGXClassWrapperToken.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXClassWrapperToken);
 exports.rgxClassWrapper = (0, internal_1.createConstructFunction)(RGXClassWrapperToken);

package/dist/collection.js

@@ -5,6 +5,7 @@ const resolve_1 = require("./resolve");
 const concat_1 = require("./concat");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
 const internal_1 = require("./internal");
+const utils_1 = require("./utils");
 class RGXTokenCollection {
     constructor(tokens = [], mode = 'concat') {
         this.tokens = [];
@@ -167,6 +168,6 @@ class RGXTokenCollection {
     }
 }
 exports.RGXTokenCollection = RGXTokenCollection;
-RGXTokenCollection.check = (0, internal_1.createClassGuardFunction)(RGXTokenCollection);
-RGXTokenCollection.assert = (0, internal_1.createAssertClassGuardFunction)(RGXTokenCollection);
+RGXTokenCollection.check = (0, utils_1.createRGXClassGuardFunction)(RGXTokenCollection);
+RGXTokenCollection.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXTokenCollection);
 exports.rgxTokenCollection = (0, internal_1.createConstructFunction)(RGXTokenCollection);

package/dist/constants.d.ts

@@ -95,6 +95,10 @@ export declare const RGX_PREDEFINED_CONSTANTS: {
         readonly rgxGroupWrap: false;
         readonly toRgx: () => RegExp;
     };
+    readonly "whitespace-block": {
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
     readonly "non-whitespace": {
         readonly rgxGroupWrap: false;
         readonly toRgx: () => RegExp;

package/dist/constants.js

@@ -118,6 +118,10 @@ exports.RGX_PREDEFINED_CONSTANTS = {
         rgxGroupWrap: false,
         toRgx() { return /\s/; }
     },
+    "whitespace-block": {
+        rgxGroupWrap: false,
+        toRgx() { return /\s+/; }
+    },
     "non-whitespace": {
         rgxGroupWrap: false,
         toRgx() { return /\S/; }

package/dist/errors/base.d.ts

@@ -1,4 +1,4 @@
-export type RGXErrorCode = 'UNKNOWN' | 'INVALID_RGX_TOKEN' | 'INVALID_REGEX_STRING' | 'INVALID_REGEX_FLAGS' | 'INVALID_VANILLA_REGEX_FLAGS' | 'NOT_IMPLEMENTED' | 'NOT_SUPPORTED' | 'INVALID_IDENTIFIER' | 'OUT_OF_BOUNDS' | 'INVALID_FLAG_TRANSFORMER_KEY' | 'FLAG_TRANSFORMER_CONFLICT' | 'CONSTANT_CONFLICT' | 'INVALID_CONSTANT_KEY' | 'INSERTION_REJECTED' | 'REGEX_NOT_MATCHED_AT_POSITION' | 'PART_VALIDATION_FAILED';
+export type RGXErrorCode = 'UNKNOWN' | 'INVALID_RGX_TOKEN' | 'INVALID_REGEX_STRING' | 'INVALID_REGEX_FLAGS' | 'INVALID_VANILLA_REGEX_FLAGS' | 'NOT_IMPLEMENTED' | 'NOT_SUPPORTED' | 'INVALID_IDENTIFIER' | 'OUT_OF_BOUNDS' | 'INVALID_FLAG_TRANSFORMER_KEY' | 'FLAG_TRANSFORMER_CONFLICT' | 'CONSTANT_CONFLICT' | 'INVALID_CONSTANT_KEY' | 'INSERTION_REJECTED' | 'REGEX_NOT_MATCHED_AT_POSITION' | 'PART_VALIDATION_FAILED' | 'INVALID_LEXER_MODE' | 'LEXEME_NOT_MATCHED_AT_POSITION' | 'INVALID_RGX_LEXER' | 'INVALID_RGX_WALKER' | 'INVALID_RGX_PART';
 export declare class RGXError extends Error {
     _message: string;
     code: RGXErrorCode;

package/dist/errors/index.d.ts

@@ -14,3 +14,8 @@ export * from './constantConflict';
 export * from './invalidConstantKey';
 export * from './regexNotMatchedAtPosition';
 export * from './partValidationFailed';
+export * from './invalidLexerMode';
+export * from './lexemeNotMatchedAtPosition';
+export * from './invalidLexer';
+export * from './invalidWalker';
+export * from './invalidPart';

package/dist/errors/index.js

@@ -30,3 +30,8 @@ __exportStar(require("./constantConflict"), exports);
 __exportStar(require("./invalidConstantKey"), exports);
 __exportStar(require("./regexNotMatchedAtPosition"), exports);
 __exportStar(require("./partValidationFailed"), exports);
+__exportStar(require("./invalidLexerMode"), exports);
+__exportStar(require("./lexemeNotMatchedAtPosition"), exports);
+__exportStar(require("./invalidLexer"), exports);
+__exportStar(require("./invalidWalker"), exports);
+__exportStar(require("./invalidPart"), exports);

package/dist/errors/invalidLexer.d.ts

@@ -0,0 +1,7 @@
+import { RGXError } from "./";
+export declare class RGXInvalidLexerError extends RGXError {
+    constructorName: string;
+    got: unknown;
+    constructor(message: string, got: unknown, constructorName?: string);
+    calcMessage(message: string): string;
+}

package/dist/errors/invalidLexer.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGXInvalidLexerError = void 0;
+const errors_1 = require("./");
+const class_1 = require("../class");
+class RGXInvalidLexerError extends errors_1.RGXError {
+    constructor(message, got, constructorName = "RGXLexer") {
+        super(message, 'INVALID_RGX_LEXER');
+        this.name = 'RGXInvalidLexerError';
+        this.got = got;
+        this.constructorName = constructorName;
+    }
+    calcMessage(message) {
+        const gotString = class_1.RGXClassToken.check(this.got) ? `instance of ${this.got.constructor.name}` : JSON.stringify(this.got);
+        return `${message}; Expected: [instance of ${this.constructorName}]; Got: [${gotString}]`;
+    }
+}
+exports.RGXInvalidLexerError = RGXInvalidLexerError;

package/dist/errors/invalidLexerMode.d.ts

@@ -0,0 +1,6 @@
+import { RGXError } from "./";
+export declare class RGXInvalidLexerModeError extends RGXError {
+    got: string;
+    constructor(message: string, got: string);
+    calcMessage(message: string): string;
+}

package/dist/errors/invalidLexerMode.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGXInvalidLexerModeError = void 0;
+const errors_1 = require("./");
+class RGXInvalidLexerModeError extends errors_1.RGXError {
+    constructor(message, got) {
+        super(message, 'INVALID_LEXER_MODE');
+        this.name = 'RGXInvalidLexerModeError';
+        this.got = got;
+    }
+    calcMessage(message) {
+        return `${message}; Got: ${JSON.stringify(this.got)}`;
+    }
+}
+exports.RGXInvalidLexerModeError = RGXInvalidLexerModeError;

package/dist/errors/invalidPart.d.ts

@@ -0,0 +1,7 @@
+import { RGXError } from "./";
+export declare class RGXInvalidPartError extends RGXError {
+    constructorName: string;
+    got: unknown;
+    constructor(message: string, got: unknown, constructorName?: string);
+    calcMessage(message: string): string;
+}

package/dist/errors/invalidPart.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGXInvalidPartError = void 0;
+const errors_1 = require("./");
+const class_1 = require("../class");
+class RGXInvalidPartError extends errors_1.RGXError {
+    constructor(message, got, constructorName = "RGXPart") {
+        super(message, 'INVALID_RGX_PART');
+        this.name = 'RGXInvalidPartError';
+        this.got = got;
+        this.constructorName = constructorName;
+    }
+    calcMessage(message) {
+        const gotString = class_1.RGXClassToken.check(this.got) ? `instance of ${this.got.constructor.name}` : JSON.stringify(this.got);
+        return `${message}; Expected: [instance of ${this.constructorName}]; Got: [${gotString}]`;
+    }
+}
+exports.RGXInvalidPartError = RGXInvalidPartError;

package/dist/errors/invalidWalker.d.ts

@@ -0,0 +1,7 @@
+import { RGXError } from "./";
+export declare class RGXInvalidWalkerError extends RGXError {
+    constructorName: string;
+    got: unknown;
+    constructor(message: string, got: unknown, constructorName?: string);
+    calcMessage(message: string): string;
+}

package/dist/errors/invalidWalker.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGXInvalidWalkerError = void 0;
+const errors_1 = require("./");
+const class_1 = require("../class");
+class RGXInvalidWalkerError extends errors_1.RGXError {
+    constructor(message, got, constructorName = "RGXWalker") {
+        super(message, 'INVALID_RGX_WALKER');
+        this.name = 'RGXInvalidWalkerError';
+        this.got = got;
+        this.constructorName = constructorName;
+    }
+    calcMessage(message) {
+        const gotString = class_1.RGXClassToken.check(this.got) ? `instance of ${this.got.constructor.name}` : JSON.stringify(this.got);
+        return `${message}; Expected: [instance of ${this.constructorName}]; Got: [${gotString}]`;
+    }
+}
+exports.RGXInvalidWalkerError = RGXInvalidWalkerError;

package/dist/errors/lexemeNotMatchedAtPosition.d.ts

@@ -0,0 +1,22 @@
+import { RGXError, RGXPartValidationFailedError, RGXRegexNotMatchedAtPositionError } from "./";
+export type LexemeNotMatchedCauseError = RGXRegexNotMatchedAtPositionError | RGXPartValidationFailedError;
+export type LexemeNotMatchedCause = {
+    id: string;
+    error: LexemeNotMatchedCauseError;
+};
+export declare function isLexemeNotMatchedCauseError(error: unknown): error is LexemeNotMatchedCauseError;
+export declare class RGXLexemeNotMatchedAtPositionError extends RGXError {
+    source: string;
+    mode: string;
+    _position: number;
+    contextSize: number | null;
+    causes: LexemeNotMatchedCause[];
+    get position(): number;
+    set position(value: number);
+    constructor(message: string, source: string, mode: string, position: number, causes?: LexemeNotMatchedCause[], contextSize?: number | null);
+    sourceContext(): string;
+    hasLeftContext(): boolean;
+    hasRightContext(): boolean;
+    hasFullContext(): boolean;
+    calcMessage(message: string): string;
+}

package/dist/errors/lexemeNotMatchedAtPosition.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGXLexemeNotMatchedAtPositionError = void 0;
+exports.isLexemeNotMatchedCauseError = isLexemeNotMatchedCauseError;
+const errors_1 = require("./");
+function isLexemeNotMatchedCauseError(error) {
+    return error instanceof errors_1.RGXRegexNotMatchedAtPositionError || error instanceof errors_1.RGXPartValidationFailedError;
+}
+class RGXLexemeNotMatchedAtPositionError extends errors_1.RGXError {
+    get position() {
+        return this._position;
+    }
+    set position(value) {
+        (0, errors_1.assertInRange)(value, { min: 0, max: this.source.length }, "position is outside the bounds of the source string");
+        this._position = value;
+    }
+    constructor(message, source, mode, position, causes = [], contextSize = null) {
+        super(message, 'LEXEME_NOT_MATCHED_AT_POSITION');
+        this.name = 'RGXLexemeNotMatchedAtPositionError';
+        this.source = source;
+        this.mode = mode;
+        this.position = position;
+        this.causes = causes;
+        this.contextSize = contextSize;
+    }
+    sourceContext() {
+        if (this.hasFullContext())
+            return this.source;
+        const start = Math.max(0, this.position - this.contextSize);
+        const end = Math.min(this.source.length, this.position + this.contextSize);
+        return this.source.slice(start, end);
+    }
+    hasLeftContext() {
+        if (this.contextSize === null)
+            return false;
+        return this.position - this.contextSize >= 0;
+    }
+    hasRightContext() {
+        if (this.contextSize === null)
+            return false;
+        return this.position + this.contextSize <= this.source.length;
+    }
+    hasFullContext() {
+        return !this.hasLeftContext() && !this.hasRightContext();
+    }
+    calcMessage(message) {
+        let context = this.sourceContext();
+        if (this.contextSize !== null) {
+            if (this.hasLeftContext())
+                context = `...${context}`;
+            if (this.hasRightContext())
+                context = `${context}...`;
+        }
+        return `${message}; Mode: ${this.mode}, Position: ${this.position}, Context: ${context}`;
+    }
+}
+exports.RGXLexemeNotMatchedAtPositionError = RGXLexemeNotMatchedAtPositionError;

package/dist/errors/regexNotMatchedAtPosition.js

@@ -5,7 +5,7 @@ const base_1 = require("./base");
 const outOfBounds_1 = require("./outOfBounds");
 class RGXRegexNotMatchedAtPositionError extends base_1.RGXError {
     set position(value) {
-        (0, outOfBounds_1.assertInRange)(value, { min: 0, max: this.source.length, inclusiveRight: false }, "position is outside the bounds of the source string");
+        (0, outOfBounds_1.assertInRange)(value, { min: 0, max: this.source.length }, "position is outside the bounds of the source string");
         this._position = value;
     }
     get position() {

package/dist/index.d.ts

@@ -14,6 +14,7 @@ export * from "./flag-transformer";
 export * from "./clone";
 export * from "./constants";
 export * from "./walker";
+export * from "./lexer";
 export declare function rgxa(tokens: t.RGXToken[], flags?: string): ExtRegExp;
 export default function rgx(flags?: string, multiline?: boolean): (strings: TemplateStringsArray, ...tokens: t.RGXToken[]) => ExtRegExp;
 export declare function rgxwa<R = unknown, T = unknown>(source: string, tokens: RGXTokenOrPart<R, T>[], options?: Omit<t.RGXWOptions<R>, "multiline">): RGXWalker<R>;

package/dist/index.js

@@ -37,6 +37,7 @@ __exportStar(require("./flag-transformer"), exports);
 __exportStar(require("./clone"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./walker"), exports);
+__exportStar(require("./lexer"), exports);
 // Call this for certain class methods to work correctly
 (0, class_1.rgxClassInit)();
 // Call this for our custom flags to work correctly

package/dist/internal/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./createConstructFunction";
-export * from "./createClassGuardFunction";
 export * from "./taggedTemplateToArray";
 export * from "./isConstructor";
 export * from "./getProxy";

package/dist/internal/index.js

@@ -15,7 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./createConstructFunction"), exports);
-__exportStar(require("./createClassGuardFunction"), exports);
 __exportStar(require("./taggedTemplateToArray"), exports);
 __exportStar(require("./isConstructor"), exports);
 __exportStar(require("./getProxy"), exports);

package/dist/lexer/base.d.ts

@@ -0,0 +1,59 @@
+import { RGXToken } from "../types";
+import { RGXTokenOrPart, RGXWalkerOptions } from "../walker";
+export type RGXLexemeDefinition<Data> = Readonly<({
+    type: "resolve";
+    token: RGXToken;
+} | {
+    type: "walk";
+    tokens: RGXTokenOrPart<Data>[];
+    options?: Omit<RGXWalkerOptions<Data>, "startingSourcePosition" | "reduced"> & {
+        reduced?: (() => Data) | null;
+    };
+}) & {
+    id: string;
+    priority?: number;
+}>;
+export type RGXLexeme<Data> = {
+    id: string;
+    raw: string;
+    start: RGXLexemeLocation;
+    end: RGXLexemeLocation;
+    data?: Data;
+};
+export type RGXLexemeDefinitions<Data> = Readonly<Record<string, ReadonlyArray<RGXLexemeDefinition<Data>>>>;
+export type RGXLexemeLocation = {
+    index: number;
+    line: number;
+    column: number;
+};
+export declare function rgxLexemeLocationFromIndex(source: string, index: number): RGXLexemeLocation;
+export declare class RGXLexer<Data> {
+    readonly source: string;
+    _position: number;
+    readonly lexemeDefinitions: RGXLexemeDefinitions<Data>;
+    readonly matched: RGXLexeme<Data>[];
+    static check: (value: unknown) => value is RGXLexer<unknown>;
+    static assert: (value: unknown) => asserts value is RGXLexer<unknown>;
+    get position(): number;
+    set position(value: number);
+    constructor(source: string, lexemeDefinitions?: RGXLexemeDefinitions<Data>, startingPosition?: number);
+    private matchDefinition;
+    private next;
+    private expect;
+    validateMode(value: string): void;
+    lastMatched(): RGXLexeme<Data> | null;
+    hasNext(): boolean;
+    isAtEnd(): boolean;
+    remaining(): string;
+    backtrack(tokens?: number): void;
+    consume(mode?: string, log?: boolean): RGXLexeme<Data> | null;
+    peek(mode?: string): RGXLexeme<Data> | null;
+    expectConsume(id: string, mode?: string, log?: boolean): RGXLexeme<Data>;
+    expectPeek(id: string, mode?: string): RGXLexeme<Data>;
+    skip(count?: number, mode?: string): void;
+    skipWhitespace(): void;
+    consumeAll(mode?: string, skipWhitespace?: boolean): RGXLexeme<Data>[];
+    consumeWhile(predicate: (lexeme: RGXLexeme<Data>) => boolean, mode?: string, skipWhitespace?: boolean): RGXLexeme<Data>[];
+    consumeUntil(predicate: (lexeme: RGXLexeme<Data>) => boolean, mode?: string, skipWhitespace?: boolean): RGXLexeme<Data>[];
+}
+export declare const rgxLexer: <Data>(...args: ConstructorParameters<typeof RGXLexer<Data>>) => RGXLexer<Data>;

package/dist/lexer/base.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rgxLexer = exports.RGXLexer = void 0;
+exports.rgxLexemeLocationFromIndex = rgxLexemeLocationFromIndex;
+const resolve_1 = require("../resolve");
+const errors_1 = require("../errors");
+const walker_1 = require("../walker");
+const utils_1 = require("../utils");
+const utils_2 = require("../utils");
+const constants_1 = require("../constants");
+function rgxLexemeLocationFromIndex(source, index) {
+    (0, errors_1.assertInRange)(index, { min: 0, max: source.length }, "index is outside the bounds of the source string");
+    const lines = source.slice(0, index).split("\n");
+    const line = lines.length;
+    const column = lines[lines.length - 1].length + 1;
+    return { index, line, column };
+}
+class RGXLexer {
+    get position() {
+        return this._position;
+    }
+    set position(value) {
+        (0, errors_1.assertInRange)(value, { min: 0, max: this.source.length }, "position is outside the bounds of the source string");
+        this._position = Math.floor(value);
+    }
+    constructor(source, lexemeDefinitions = {}, startingPosition = 0) {
+        this.matched = [];
+        // Copy to ensure we don't modify the original, which will be used across constructions.
+        const lexemeDefinitionsCopy = { ...lexemeDefinitions };
+        lexemeDefinitionsCopy["default"] ??= [];
+        this.source = source;
+        this.lexemeDefinitions = Object.fromEntries(Object.entries(lexemeDefinitionsCopy).map(([mode, defs]) => [
+            mode, [...defs].sort(
+            // Sort by priority, with higher priority first. If no priority is specified, it defaults to 0.
+            (a, b) => (b.priority ?? 0) - (a.priority ?? 0))
+        ]));
+        this.position = startingPosition;
+    }
+    matchDefinition(lexemeDefinition, advance) {
+        const id = lexemeDefinition.id;
+        const startPosition = this.position;
+        let endPosition;
+        let raw;
+        let dataPart = {};
+        if (lexemeDefinition.type === "resolve") {
+            const { token } = lexemeDefinition;
+            const regex = new RegExp((0, resolve_1.resolveRGXToken)(token));
+            // Since the assertion will throw an error if there is no match, this is safe.
+            const match = (0, utils_1.assertRegexMatchesAtPosition)(regex, this.source, startPosition, 10, true);
+            raw = match[0];
+            endPosition = startPosition + raw.length;
+            // No data part for token lexemes.
+        }
+        else {
+            const { tokens, options: { reduced, ...options } = {} } = lexemeDefinition;
+            const walker = new walker_1.RGXWalker(this.source, tokens, {
+                ...options,
+                reduced: reduced?.() ?? undefined,
+                startingSourcePosition: startPosition
+            });
+            // Since the walker will throw an error if it fails to match to the end of its tokens (assuming it isn't stopped before then), this is safe.
+            walker.walk();
+            raw = this.source.slice(startPosition, walker.sourcePosition);
+            endPosition = walker.sourcePosition;
+            dataPart.data = walker.reduced;
+        }
+        if (advance) {
+            this.position = endPosition;
+        }
+        return {
+            id,
+            raw,
+            start: rgxLexemeLocationFromIndex(this.source, startPosition),
+            end: rgxLexemeLocationFromIndex(this.source, endPosition),
+            ...dataPart
+        };
+    }
+    next(mode, advance, log) {
+        if (this.isAtEnd())
+            return null;
+        this.validateMode(mode);
+        const lexemeDefs = this.lexemeDefinitions[mode];
+        const causes = [];
+        for (const lexemeDef of lexemeDefs) {
+            try {
+                const lexeme = this.matchDefinition(lexemeDef, advance);
+                if (advance && log)
+                    this.matched.push(lexeme);
+                return lexeme;
+            }
+            catch (e) {
+                if ((0, errors_1.isLexemeNotMatchedCauseError)(e)) {
+                    // Log the error as a cause and continue trying other lexeme definitions.
+                    causes.push({ id: lexemeDef.id, error: e });
+                }
+                else {
+                    // If it's an unexpected error, rethrow it.
+                    throw e;
+                }
+            }
+        }
+        // If no lexeme definitions matched, throw an error.
+        throw new errors_1.RGXLexemeNotMatchedAtPositionError("No lexeme definition matched", this.source, mode, this.position, causes);
+    }
+    expect(id, mode, consume, log) {
+        const lexeme = consume ? this.consume(mode, log) : this.peek(mode);
+        if (!lexeme || lexeme.id !== id) {
+            throw new errors_1.RGXLexemeNotMatchedAtPositionError(`Expected lexeme "${id}" but got ${lexeme?.id ? `lexeme "${lexeme.id}"` : "source end"}`, this.source, mode, this.position);
+        }
+        return lexeme;
+    }
+    validateMode(value) {
+        if (!(value in this.lexemeDefinitions)) {
+            throw new errors_1.RGXInvalidLexerModeError("Lexer mode does not exist in this lexer", value);
+        }
+    }
+    lastMatched() {
+        if (this.matched.length === 0)
+            return null;
+        return this.matched[this.matched.length - 1];
+    }
+    hasNext() {
+        return this.position < this.source.length;
+    }
+    isAtEnd() {
+        return !this.hasNext();
+    }
+    remaining() {
+        return this.source.slice(this.position);
+    }
+    backtrack(tokens = 1) {
+        if (tokens <= 0)
+            return;
+        (0, errors_1.assertInRange)(tokens, { max: this.matched.length }, "Cannot backtrack more tokens than have been matched");
+        const targetLexeme = this.matched[this.matched.length - tokens];
+        this.position = targetLexeme.start.index;
+        this.matched.splice(this.matched.length - tokens, tokens);
+    }
+    consume(mode = "default", log = true) {
+        return this.next(mode, true, log);
+    }
+    peek(mode = "default") {
+        return this.next(mode, false, false);
+    }
+    expectConsume(id, mode = "default", log = true) {
+        return this.expect(id, mode, true, log);
+    }
+    expectPeek(id, mode = "default") {
+        return this.expect(id, mode, false, false);
+    }
+    skip(count = 1, mode = "default") {
+        for (let i = 0; i < count; i++) {
+            if (!this.hasNext())
+                break;
+            this.consume(mode, false);
+        }
+    }
+    skipWhitespace() {
+        if (this.isAtEnd())
+            return;
+        const regex = new RegExp((0, resolve_1.resolveRGXToken)((0, constants_1.rgxConstant)("whitespace-block")));
+        const match = (0, utils_1.regexMatchAtPosition)(regex, this.source, this.position, true);
+        if (match !== null) {
+            this.position += match[0].length;
+        }
+    }
+    consumeAll(mode = "default", skipWhitespace = true) {
+        const lexemes = [];
+        while (this.hasNext()) {
+            if (skipWhitespace)
+                this.skipWhitespace();
+            const lexeme = this.consume(mode);
+            if (lexeme)
+                lexemes.push(lexeme);
+        }
+        return lexemes;
+    }
+    consumeWhile(predicate, mode = "default", skipWhitespace = true) {
+        const lexemes = [];
+        while (this.hasNext()) {
+            if (skipWhitespace)
+                this.skipWhitespace();
+            const next = this.consume(mode);
+            if (!next || !predicate(next))
+                break;
+            lexemes.push(next);
+        }
+        return lexemes;
+    }
+    consumeUntil(predicate, mode = "default", skipWhitespace = true) {
+        return this.consumeWhile(lexeme => !predicate(lexeme), mode, skipWhitespace);
+    }
+}
+exports.RGXLexer = RGXLexer;
+RGXLexer.check = (0, utils_2.createRGXClassGuardFunction)(RGXLexer);
+RGXLexer.assert = (0, utils_2.createAssertRGXClassGuardFunction)(RGXLexer, (value, c) => new errors_1.RGXInvalidLexerError("Invalid Lexer", value, c.name));
+const rgxLexer = (...args) => new RGXLexer(...args);
+exports.rgxLexer = rgxLexer;

package/dist/lexer/index.d.ts

@@ -0,0 +1 @@
+export * from "./base";

package/dist/lexer/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base"), exports);

package/dist/utils/createRGXClassGuardFunction.d.ts

@@ -0,0 +1,3 @@
+import { RGXError } from "../errors";
+export declare function createRGXClassGuardFunction<T extends new (...args: unknown[]) => unknown>(constructor: T): (value: unknown) => value is InstanceType<T>;
+export declare function createAssertRGXClassGuardFunction<T extends new (...args: unknown[]) => unknown>(constructor: T, constructError?: (value: unknown, constructor: T) => RGXError): (value: unknown) => asserts value is InstanceType<T>;

package/dist/utils/createRGXClassGuardFunction.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRGXClassGuardFunction = createRGXClassGuardFunction;
+exports.createAssertRGXClassGuardFunction = createAssertRGXClassGuardFunction;
+const errors_1 = require("../errors");
+function createRGXClassGuardFunction(constructor) {
+    return (value) => value instanceof constructor;
+}
+function createAssertRGXClassGuardFunction(constructor, constructError = (value, constructor) => new errors_1.RGXInvalidTokenError("Invalid token type", { type: "custom", values: [`instance of ${constructor.name}`] }, value)) {
+    return (value) => {
+        if (!(value instanceof constructor)) {
+            throw constructError(value, constructor);
+        }
+    };
+}

package/dist/utils/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./regexMatchAtPosition";
 export * from "./regexWithFlags";
 export * from "./normalizeRegexFlags";
+export * from "./createRGXClassGuardFunction";

package/dist/utils/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./regexMatchAtPosition"), exports);
 __exportStar(require("./regexWithFlags"), exports);
 __exportStar(require("./normalizeRegexFlags"), exports);
+__exportStar(require("./createRGXClassGuardFunction"), exports);

package/dist/walker/base.js

@@ -6,17 +6,20 @@ const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
 const collection_1 = require("../collection");
 const errors_1 = require("../errors");
 const part_1 = require("./part");
-const index_1 = require("../index");
-const internal_1 = require("../internal");
+const resolve_1 = require("../resolve");
+const utils_1 = require("../utils");
+const typeGuards_1 = require("../typeGuards");
+const class_1 = require("../class");
+const utils_2 = require("../utils");
 function createBranchGroups(tokens) {
     if ((tokens instanceof collection_1.RGXTokenCollection && tokens.mode === "union") ||
-        index_1.RGXClassUnionToken.check(tokens))
+        class_1.RGXClassUnionToken.check(tokens))
         return createBranchGroups(tokens.tokens);
-    if ((0, index_1.isRGXArrayToken)(tokens)) {
+    if ((0, typeGuards_1.isRGXArrayToken)(tokens)) {
         const newTokens = tokens.map((token, i) => {
-            return new index_1.RGXGroupToken({ name: `rgx_branch_${i}` }, [token]);
+            return new class_1.RGXGroupToken({ name: `rgx_branch_${i}` }, [token]);
         });
-        return new index_1.RGXClassUnionToken(newTokens);
+        return new class_1.RGXClassUnionToken(newTokens);
     }
     else {
         return tokens;
@@ -28,14 +31,14 @@ class RGXWalker {
     }
     set sourcePosition(value) {
         (0, errors_1.assertInRange)(value, { min: 0, max: this.source.length }, "sourcePosition is outside the bounds of the source string");
-        this._sourcePosition = value;
+        this._sourcePosition = Math.floor(value);
     }
     get tokenPosition() {
         return this._tokenPosition;
     }
     set tokenPosition(value) {
         (0, errors_1.assertInRange)(value, { min: 0, max: this.tokens.length }, "tokenPosition is outside the bounds of the token collection");
-        this._tokenPosition = value;
+        this._tokenPosition = Math.floor(value);
     }
     get stopped() {
         return this._stopped;
@@ -84,8 +87,8 @@ class RGXWalker {
         return this.source.slice(this.sourcePosition);
     }
     capture(token, includeMatch = false) {
-        const regex = (0, index_1.rgxa)([part_1.RGXPart.check(token) ? token.token : token]);
-        const match = (0, index_1.assertRegexMatchesAtPosition)(regex, this.source, this.sourcePosition, 10, true);
+        const regex = new RegExp((0, resolve_1.resolveRGXToken)(part_1.RGXPart.check(token) ? token.token : token));
+        const match = (0, utils_1.assertRegexMatchesAtPosition)(regex, this.source, this.sourcePosition, 10, true);
         this.sourcePosition += match[0].length;
         return includeMatch ? match : match[0];
     }
@@ -211,8 +214,8 @@ class RGXWalker {
     }
 }
 exports.RGXWalker = RGXWalker;
-RGXWalker.check = (0, internal_1.createClassGuardFunction)(RGXWalker);
-RGXWalker.assert = (0, internal_1.createAssertClassGuardFunction)(RGXWalker);
+RGXWalker.check = (0, utils_2.createRGXClassGuardFunction)(RGXWalker);
+RGXWalker.assert = (0, utils_2.createAssertRGXClassGuardFunction)(RGXWalker, (value, constructor) => new errors_1.RGXInvalidWalkerError("Invalid Walker", value, constructor.name));
 function rgxWalker(...args) {
     return new RGXWalker(...args);
 }

package/dist/walker/part.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RGXPart = void 0;
 exports.rgxPart = rgxPart;
-const internal_1 = require("../internal");
+const utils_1 = require("../utils");
 const clone_1 = require("../clone");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
 const errors_1 = require("../errors");
@@ -40,8 +40,8 @@ class RGXPart {
     }
 }
 exports.RGXPart = RGXPart;
-RGXPart.check = (0, internal_1.createClassGuardFunction)(RGXPart);
-RGXPart.assert = (0, internal_1.createAssertClassGuardFunction)(RGXPart);
+RGXPart.check = (0, utils_1.createRGXClassGuardFunction)(RGXPart);
+RGXPart.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXPart, (value, constructor) => new errors_1.RGXInvalidPartError("Invalid Part", value, constructor.name));
 function rgxPart(...args) {
     return new RGXPart(...args);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ptolemy2002/rgx",
-    "version": "8.0.1",
+    "version": "8.2.0",
     "private": false,
     "main": "dist/index.js",
     "types": "dist/index.d.ts",

package/dist/internal/createClassGuardFunction.d.ts

@@ -1,2 +0,0 @@
-export declare function createClassGuardFunction<T extends new (...args: unknown[]) => unknown>(constructor: T): (value: unknown) => value is InstanceType<T>;
-export declare function createAssertClassGuardFunction<T extends new (...args: unknown[]) => unknown>(constructor: T): (value: unknown) => asserts value is InstanceType<T>;

package/dist/internal/createClassGuardFunction.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createClassGuardFunction = createClassGuardFunction;
-exports.createAssertClassGuardFunction = createAssertClassGuardFunction;
-const errors_1 = require("../errors");
-function createClassGuardFunction(constructor) {
-    return (value) => value instanceof constructor;
-}
-function createAssertClassGuardFunction(constructor) {
-    return (value) => {
-        if (!(value instanceof constructor)) {
-            throw new errors_1.RGXInvalidTokenError("Invalid token type", { type: "custom", values: [`instance of ${constructor.name}`] }, value);
-        }
-    };
-}