@ptolemy2002/rgx 8.0.0 → 8.1.0

package/README.md

@@ -21,6 +21,7 @@ Because there is so much to document, it has been broken up into multiple files.
   - [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/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';
 export declare class RGXError extends Error {
     _message: string;
     code: RGXErrorCode;

package/dist/errors/index.d.ts

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

package/dist/errors/index.js

@@ -30,3 +30,6 @@ __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);

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/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/createClassGuardFunction.d.ts

@@ -1,2 +1,3 @@
+import { RGXError } from "../errors";
 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>;
+export declare function createAssertClassGuardFunction<T extends new (...args: unknown[]) => unknown>(constructor: T, constructError?: (value: unknown, constructor: T) => RGXError): (value: unknown) => asserts value is InstanceType<T>;

package/dist/internal/createClassGuardFunction.js

@@ -6,10 +6,10 @@ const errors_1 = require("../errors");
 function createClassGuardFunction(constructor) {
     return (value) => value instanceof constructor;
 }
-function createAssertClassGuardFunction(constructor) {
+function createAssertClassGuardFunction(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 new errors_1.RGXInvalidTokenError("Invalid token type", { type: "custom", values: [`instance of ${constructor.name}`] }, value);
+            throw constructError(value, constructor);
         }
     };
 }

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 internal_1 = require("../internal");
+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, internal_1.createClassGuardFunction)(RGXLexer);
+RGXLexer.assert = (0, internal_1.createAssertClassGuardFunction)(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/types.d.ts

@@ -3,7 +3,6 @@ import type { RGXClassToken } from "./class";
 import type { ExtRegExp } from "./ExtRegExp";
 import type { RGXTokenCollection } from "./collection";
 import type { RGXWalkerOptions } from "./walker";
-import type { RGXPart, RGXWalker } from "./walker";
 export type RGXNoOpToken = null | undefined;
 export type RGXLiteralToken = RegExp;
 export type RGXNativeToken = string | number | boolean | RGXNoOpToken;
@@ -28,7 +27,7 @@ export type RGXRepeatableConvertibleToken = RGXConvertibleToken & {
 };
 export type RGXTokenType = 'no-op' | 'literal' | 'native' | 'convertible' | 'class' | RGXTokenType[];
 export type RGXTokenTypeFlat = Exclude<RGXTokenType, RGXTokenType[]> | "array";
-export type RGXTokenTypeGuardInput = "repeatable" | RGXTokenTypeFlat | null | RGXClassTokenConstructor | typeof RegExp | typeof ExtRegExp | typeof RGXTokenCollection | typeof RGXWalker | typeof RGXPart | RGXTokenTypeGuardInput[];
+export type RGXTokenTypeGuardInput = "repeatable" | RGXTokenTypeFlat | null | RGXClassTokenConstructor | typeof RegExp | typeof ExtRegExp | typeof RGXTokenCollection | RGXTokenTypeGuardInput[];
 export type RGXTokenFromType<T extends RGXTokenTypeGuardInput> = T extends null ? RGXToken : T extends 'no-op' ? RGXNoOpToken : T extends 'literal' ? RGXLiteralToken : T extends 'native' ? RGXNativeToken : T extends 'convertible' ? RGXConvertibleToken : T extends 'class' ? RGXClassToken : T extends 'array' ? RGXToken[] : T extends 'repeatable' ? Exclude<RGXToken, RGXConvertibleToken> | RGXRepeatableConvertibleToken : T extends new (...args: unknown[]) => infer R ? R : T extends RGXTokenTypeGuardInput[] ? {
     [K in keyof T]: T[K] extends RGXTokenTypeGuardInput ? RGXTokenFromType<T[K]> : never;
 } : never;

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 resolve_1 = require("../resolve");
+const utils_1 = require("../utils");
+const typeGuards_1 = require("../typeGuards");
+const class_1 = require("../class");
 const internal_1 = require("../internal");
 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];
     }

package/package.json

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