@ptolemy2002/rgx 5.2.0 → 5.4.0

package/README.md

@@ -54,7 +54,7 @@ type RGXTokenFromType<T extends RGXTokenTypeGuardInput> =
     // ... see source for full definition
 ;
 
-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' | 'INSERTION_REJECTED';
+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';
 
 type RangeObject = {
     min?: number | null;
@@ -218,6 +218,32 @@ constructor(message: string, got: string)
 #### Properties
 - `got` (`string`): The conflicting key string.
 
+### RGXInvalidConstantKeyError extends RGXError
+A specific error class for invalid constant keys. This error is thrown when attempting to access or assert an RGX constant with a name that does not exist. The error code is set to `INVALID_CONSTANT_KEY` on instantiation.
+
+#### Constructor
+```typescript
+constructor(message: string, got: string)
+```
+- `message` (`string`): The error message.
+- `got` (`string`): The constant name that was not found.
+
+#### Properties
+- `got` (`string`): The constant name that was not found.
+
+### RGXConstantConflictError extends RGXError
+A specific error class for constant name conflicts. This error is thrown when attempting to define an RGX constant with a name that is already in use. The error code is set to `CONSTANT_CONFLICT` on instantiation.
+
+#### Constructor
+```typescript
+constructor(message: string, got: string)
+```
+- `message` (`string`): The error message.
+- `got` (`string`): The conflicting constant name.
+
+#### Properties
+- `got` (`string`): The conflicting constant name.
+
 ### RGXInsertionRejectedError extends RGXError
 A specific error class for token insertion rejection. This error is thrown when a convertible token's `rgxAcceptInsertion` method returns `false` or a string (rejection reason) during pattern construction via `rgx`, `rgxa`, or `rgxConcat`. The error code is set to `INSERTION_REJECTED` on instantiation.
 
@@ -305,7 +331,7 @@ An abstract base class for creating custom RGX token classes. Subclasses must im
 #### Methods
 - `rgxAcceptInsertion(tokens: RGXToken[], flags: ValidRegexFlags) => string | boolean`: Called during pattern construction (via `rgx`, `rgxa`, or `rgxConcat`) to allow the token to reject its own insertion based on the surrounding tokens and the pattern's flags. Returns `true` to accept insertion (the default), `false` to reject with no reason, or a string to reject with a reason message. When a token rejects insertion, an `RGXInsertionRejectedError` is thrown. Subclasses can override this to enforce constraints such as requiring certain flags to be present.
 - `or(...others: RGXTokenCollectionInput[]) => RGXClassUnionToken`: Creates an `RGXClassUnionToken` that represents a union (alternation) of this token with the provided others. If any of the `others` are `RGXClassUnionToken` instances, their tokens are flattened into the union rather than nested. If `this` is already an `RGXClassUnionToken`, its existing tokens are preserved and the others are appended.
-- `group(args?: RGXGroupTokenArgs) => RGXGroupToken`: Wraps this token in an `RGXGroupToken` with the provided arguments. The `args` parameter defaults to `{}`, which creates a capturing group with no name. This is a convenience method that creates a new `RGXGroupToken` with `this` as the sole token.
+- `group(args?: RGXGroupTokenArgs, ...others: RGXTokenCollectionInput[]) => RGXGroupToken`: Wraps this token in an `RGXGroupToken` with the provided arguments. The `args` parameter defaults to `{}`, which creates a capturing group with no name. Any additional `others` are included in the group alongside `this`. This is a convenience method that creates a new `RGXGroupToken` with `this` and the `others` as the tokens.
 - `repeat(min?: number, max?: number | null, lazy?: boolean) => RGXRepeatToken`: Wraps this token in an `RGXRepeatToken` with the given repetition bounds. `min` defaults to `1`, `max` defaults to `min`, `lazy` defaults to `false`. Pass `null` for `max` to allow unlimited repetitions. When `lazy` is `true`, the resulting quantifier will be non-greedy. This is a convenience method that creates a new `RGXRepeatToken` with `this` as the token. Throws `RGXNotSupportedError` if called on a token with `rgxIsRepeatable` set to `false` (e.g., `RGXLookaroundToken`).
 - `optional(lazy?: boolean) => RGXRepeatToken`: Shorthand for `repeat(0, 1, lazy)`. Wraps this token in an `RGXRepeatToken` that matches the token zero or one times. `lazy` defaults to `false`. Throws `RGXNotSupportedError` if called on a token with `rgxIsRepeatable` set to `false` (e.g., `RGXLookaroundToken`).
 - `asLookahead(positive?: boolean) => RGXLookaheadToken`: Wraps this token in an `RGXLookaheadToken`. `positive` defaults to `true`. If this token is already an `RGXLookaheadToken`, it is returned as-is without re-wrapping.
@@ -912,7 +938,7 @@ For convertible tokens, if the token has an `rgxGroupWrap` property, that value
 function rgxConcat(tokens: RGXToken[], groupWrap?: boolean, currentFlags?: string): ValidRegexString
 ```
 
-A helper function that resolves an array of RGX tokens and concatenates their resolved string representations together. This is useful for cases where you want to concatenate multiple tokens without creating a union between them. Before returning, any convertible token in the array that defines `rgxAcceptInsertion` is checked; if it returns `false` or a string, an `RGXInsertionRejectedError` is thrown.
+A helper function that resolves an array of RGX tokens and concatenates their resolved string representations together. This is useful for cases where you want to concatenate multiple tokens without creating a union between them. Before returning, any convertible token in the array that defines `rgxAcceptInsertion` is checked; if it returns `false` or a string, an `RGXInsertionRejectedError` is thrown with details about the reason and exactly where the rejection occurred.
 
 #### Parameters
   - `tokens` (`RGXToken[]`): The array of RGX tokens to resolve and concatenate.
@@ -927,7 +953,7 @@ A helper function that resolves an array of RGX tokens and concatenates their re
 function rgx(flags?: string): (strings: TemplateStringsArray, ...tokens: RGXToken[]) => ExtRegExp
 ```
 
-Creates and returns a template tag function that constructs an `ExtRegExp` object from the provided template literal with the provided flags. The template literal can contain RGX tokens, which will be resolved and concatenated with the literal parts to form the final regex pattern. Before constructing the pattern, any convertible token that defines `rgxAcceptInsertion` is checked; if it returns `false` or a string, an `RGXInsertionRejectedError` is thrown.
+Creates and returns a template tag function that constructs an `ExtRegExp` object from the provided template literal with the provided flags. The template literal can contain RGX tokens, which will be resolved and concatenated with the literal parts to form the final regex pattern. Before constructing the pattern, any convertible token that defines `rgxAcceptInsertion` is checked; if it returns `false` or a string, an `RGXInsertionRejectedError` is thrown with details about the reason and exactly where the rejection occurred.
 
 The provided `flags` are passed as `currentFlags` to the resolver, enabling inline modifier groups for any `RegExp` literal tokens whose localizable flags (`i`, `m`, `s`) differ from the parent flags. For example, embedding `/foo/i` in a no-flag context produces `(?i:foo)`, while embedding `/bar/` in an `i`-flag context produces `(?-i:bar)`.
 
@@ -962,7 +988,7 @@ const pattern4 = rgx()`${beginning}${caseInsensitiveWord} world${end}`; // /^(?i
 ```typescript
 function rgxa(tokens: RGXToken[], flags?: string): ExtRegExp
 ```
-As an alternative to using the `rgx` template tag, you can directly call `rgxa` with an array of RGX tokens and optional flags to get an `ExtRegExp` object. This is useful in cases where you don't want to use a template literal. Like `rgx`, the provided `flags` are passed as `currentFlags` to the resolver, enabling inline modifier groups for `RegExp` literal tokens whose localizable flags differ. Before constructing the pattern, any convertible token in the array that defines `rgxAcceptInsertion` is checked; if it returns `false` or a string, an `RGXInsertionRejectedError` is thrown.
+As an alternative to using the `rgx` template tag, you can directly call `rgxa` with an array of RGX tokens and optional flags to get an `ExtRegExp` object. This is useful in cases where you don't want to use a template literal. Like `rgx`, the provided `flags` are passed as `currentFlags` to the resolver, enabling inline modifier groups for `RegExp` literal tokens whose localizable flags differ. Before constructing the pattern, any convertible token in the array that defines `rgxAcceptInsertion` is checked; if it returns `false` or a string, an `RGXInsertionRejectedError` is thrown with details about the reason and exactly where the rejection occurred.
 
 #### Parameters
   - `tokens` (`RGXToken[]`): The RGX tokens to be resolved and concatenated to form the regex pattern.
@@ -1270,6 +1296,140 @@ Creates a clone of the given RGX token to the given depth, provided that the tok
 #### Returns
 - `T`: The cloned token.
 
+### listRGXConstants
+```typescript
+function listRGXConstants(): string[]
+```
+
+Returns the names of all currently defined RGX constants.
+
+#### Returns
+- `string[]`: An array of constant names.
+
+### hasRGXConstant
+```typescript
+function hasRGXConstant(name: string): boolean
+```
+
+Checks if an RGX constant with the given name exists.
+
+#### Parameters
+  - `name` (`string`): The constant name to check.
+
+#### Returns
+- `boolean`: `true` if the constant exists, otherwise `false`.
+
+### assertHasRGXConstant
+```typescript
+function assertHasRGXConstant(name: string): void
+```
+
+Asserts that an RGX constant with the given name exists. If the assertion fails, an `RGXInvalidConstantKeyError` will be thrown.
+
+#### Parameters
+  - `name` (`string`): The constant name to assert.
+
+#### Returns
+- `void`: This function does not return a value, but will throw an error if the assertion fails.
+
+### assertNotHasRGXConstant
+```typescript
+function assertNotHasRGXConstant(name: string): void
+```
+
+Asserts that an RGX constant with the given name does not exist. If the assertion fails, an `RGXConstantConflictError` will be thrown.
+
+#### Parameters
+  - `name` (`string`): The constant name to assert.
+
+#### Returns
+- `void`: This function does not return a value, but will throw an error if the assertion fails.
+
+### defineRGXConstant
+```typescript
+function defineRGXConstant(name: string, value: RGXToken): RGXToken
+```
+
+Defines a new RGX constant with the given name and value. Throws an `RGXConstantConflictError` if a constant with the same name already exists.
+
+#### Parameters
+  - `name` (`string`): The name for the constant.
+  - `value` (`RGXToken`): The token value to associate with the name.
+
+#### Returns
+- `RGXToken`: The value that was defined.
+
+### rgxConstant
+```typescript
+function rgxConstant(name: string): RGXToken
+```
+
+Retrieves the value of an RGX constant by name. Throws an `RGXInvalidConstantKeyError` if no constant with the given name exists.
+
+#### Parameters
+  - `name` (`string`): The constant name to retrieve.
+
+#### Returns
+- `RGXToken`: The token value associated with the constant name.
+
+### deleteRGXConstant
+```typescript
+function deleteRGXConstant(name: string): void
+```
+
+Deletes an existing RGX constant by name. Throws an `RGXInvalidConstantKeyError` if no constant with the given name exists.
+
+#### Parameters
+  - `name` (`string`): The constant name to delete.
+
+#### Returns
+- `void`: This function does not return a value, but will throw an error if the constant does not exist.
+
+## Built-in Constants
+The library defines the following built-in constants, which are available immediately after import. Each can be retrieved via `rgxConstant(name)`.
+
+### Control Characters
+| Name | Resolves To | Description |
+| --- | --- | --- |
+| `"newline"` | `\n` | Newline character |
+| `"carriage-return"` | `\r` | Carriage return character |
+| `"tab"` | `\t` | Tab character |
+| `"null"` | `\0` | Null character |
+| `"form-feed"` | `\f` | Form feed character |
+
+### Special Characters
+| Name | Resolves To | Description |
+| --- | --- | --- |
+| `"any"` | `.` | Matches any single character (except newline by default) |
+| `"start"` | `^` | Start of string anchor |
+| `"end"` | `$` | End of string anchor |
+| `"word-bound"` | `\b` | Word boundary |
+| `"non-word-bound"` | `\B` | Non-word boundary |
+| `"word-bound-start"` | `(?<=\W)(?=\w)` | Start of a word |
+| `"word-bound-end"` | `(?<=\w)(?=\W)` | End of a word |
+
+### Character Sets
+| Name | Resolves To | Description |
+| --- | --- | --- |
+| `"letter"` | `[a-zA-Z]` | Any letter (uppercase or lowercase) |
+| `"lowercase-letter"` | `[a-z]` | Any lowercase letter |
+| `"uppercase-letter"` | `[A-Z]` | Any uppercase letter |
+| `"non-letter"` | `[^a-zA-Z]` | Any character that is not a letter |
+| `"alphanumeric"` | `[a-zA-Z0-9]` | Any letter or digit |
+| `"non-alphanumeric"` | `[^a-zA-Z0-9]` | Any character that is not a letter or digit |
+
+### Predefined Character Sets
+| Name | Resolves To | Description |
+| --- | --- | --- |
+| `"digit"` | `\d` | Any digit |
+| `"non-digit"` | `\D` | Any non-digit |
+| `"whitespace"` | `\s` | Any whitespace character |
+| `"non-whitespace"` | `\S` | Any non-whitespace character |
+| `"vertical-whitespace"` | `\v` | Vertical whitespace character |
+| `"word-char"` | `\w` | Any word character (letter, digit, or underscore) |
+| `"non-word-char"` | `\W` | Any non-word character |
+| `"backspace"` | `[\b]` | Backspace character |
+
 ## Peer Dependencies
 - `@ptolemy2002/immutability-utils` ^2.0.0
 - `@ptolemy2002/js-utils` ^3.2.2

package/dist/class/base.d.ts

@@ -16,7 +16,7 @@ export declare abstract class RGXClassToken implements RGXConvertibleToken {
     get rgxIsRepeatable(): boolean;
     get rgxGroupWrap(): boolean;
     or(...others: RGXTokenCollectionInput[]): RGXClassUnionToken;
-    group(args?: RGXGroupTokenArgs): RGXGroupToken;
+    group(args?: RGXGroupTokenArgs, ...others: RGXTokenCollectionInput[]): RGXGroupToken;
     repeat(min?: number, max?: number | null, lazy?: boolean): RGXRepeatToken;
     optional(lazy?: boolean): RGXRepeatToken;
     asLookahead(positive?: boolean): RGXLookaheadToken;

package/dist/class/base.js

@@ -19,7 +19,7 @@ class RGXClassToken {
     or(...others) {
         throw new errors_1.RGXNotImplementedError('RGXClassToken.or(...others)', 'call rgxClassInit() first.');
     }
-    group(args = {}) {
+    group(args = {}, ...others) {
         throw new errors_1.RGXNotImplementedError('RGXClassToken.group(args)', 'call rgxClassInit() first.');
     }
     repeat(min = 1, max = min, lazy = false) {

package/dist/class/init.js

@@ -25,8 +25,8 @@ function rgxClassInit() {
             return new union_1.RGXClassUnionToken([this, ...filteredOthers]);
         }
     };
-    base_1.RGXClassToken.prototype.group = function (args = {}) {
-        return new group_1.RGXGroupToken(args, [this]);
+    base_1.RGXClassToken.prototype.group = function (args = {}, ...others) {
+        return new group_1.RGXGroupToken(args, [this, ...others]);
     };
     base_1.RGXClassToken.prototype.repeat = function (min = 1, max = min, lazy = false) {
         if (lookaround_1.RGXLookaroundToken.check(this))

package/dist/constants.d.ts

@@ -0,0 +1,8 @@
+import { RGXToken } from "./types";
+export declare function listRGXConstants(): string[];
+export declare function hasRGXConstant(name: string): boolean;
+export declare function assertHasRGXConstant(name: string): void;
+export declare function assertNotHasRGXConstant(name: string): void;
+export declare function defineRGXConstant(name: string, value: RGXToken): RGXToken;
+export declare function rgxConstant(name: string): RGXToken;
+export declare function deleteRGXConstant(name: string): void;

package/dist/constants.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listRGXConstants = listRGXConstants;
+exports.hasRGXConstant = hasRGXConstant;
+exports.assertHasRGXConstant = assertHasRGXConstant;
+exports.assertNotHasRGXConstant = assertNotHasRGXConstant;
+exports.defineRGXConstant = defineRGXConstant;
+exports.rgxConstant = rgxConstant;
+exports.deleteRGXConstant = deleteRGXConstant;
+const errors_1 = require("./errors");
+const rgxConstants = {};
+function listRGXConstants() {
+    return Object.keys(rgxConstants);
+}
+function hasRGXConstant(name) {
+    return name in rgxConstants;
+}
+function assertHasRGXConstant(name) {
+    if (!hasRGXConstant(name)) {
+        throw new errors_1.RGXInvalidConstantKeyError("Constant with name not found.", name);
+    }
+}
+function assertNotHasRGXConstant(name) {
+    if (hasRGXConstant(name)) {
+        throw new errors_1.RGXConstantConflictError("Constant with name already defined.", name);
+    }
+}
+function defineRGXConstant(name, value) {
+    assertNotHasRGXConstant(name);
+    rgxConstants[name] = value;
+    return value;
+}
+function rgxConstant(name) {
+    assertHasRGXConstant(name);
+    return rgxConstants[name];
+}
+function deleteRGXConstant(name) {
+    assertHasRGXConstant(name);
+    delete rgxConstants[name];
+}
+// Control Characters
+defineRGXConstant("newline", "\n");
+defineRGXConstant("carriage-return", "\r");
+defineRGXConstant("tab", "\t");
+defineRGXConstant("null", "\0");
+defineRGXConstant("form-feed", "\f");
+// Special Characters
+defineRGXConstant("any", {
+    rgxGroupWrap: false,
+    toRgx() {
+        return /./;
+    }
+});
+defineRGXConstant("start", {
+    rgxGroupWrap: false,
+    toRgx() {
+        return /^/;
+    }
+});
+defineRGXConstant("end", {
+    rgxGroupWrap: false,
+    toRgx() {
+        return /$/;
+    }
+});
+defineRGXConstant("word-bound", {
+    rgxGroupWrap: false,
+    toRgx() {
+        return /\b/;
+    }
+});
+defineRGXConstant("non-word-bound", {
+    rgxGroupWrap: false,
+    toRgx() {
+        return /\B/;
+    }
+});
+defineRGXConstant("word-bound-start", {
+    rgxGroupWrap: false,
+    toRgx() {
+        // Make sure there is a non-word character before and a word character after
+        return /(?<=\W)(?=\w)/;
+    }
+});
+defineRGXConstant("word-bound-end", {
+    rgxGroupWrap: false,
+    toRgx() {
+        // Make sure there is a word character before and a non-word character after
+        return /(?<=\w)(?=\W)/;
+    }
+});
+// Character Sets
+defineRGXConstant("letter", {
+    rgxIsGroup: true,
+    rgxGroupWrap: false,
+    toRgx() {
+        return /[a-zA-Z]/;
+    }
+});
+defineRGXConstant("lowercase-letter", {
+    rgxIsGroup: true,
+    rgxGroupWrap: false,
+    toRgx() {
+        return /[a-z]/;
+    }
+});
+defineRGXConstant("uppercase-letter", {
+    rgxIsGroup: true,
+    rgxGroupWrap: false,
+    toRgx() {
+        return /[A-Z]/;
+    }
+});
+defineRGXConstant("non-letter", {
+    rgxIsGroup: true,
+    rgxGroupWrap: false,
+    toRgx() {
+        return /[^a-zA-Z]/;
+    }
+});
+defineRGXConstant("alphanumeric", {
+    rgxIsGroup: true,
+    rgxGroupWrap: false,
+    toRgx() {
+        return /[a-zA-Z0-9]/;
+    }
+});
+defineRGXConstant("non-alphanumeric", {
+    rgxIsGroup: true,
+    rgxGroupWrap: false,
+    toRgx() {
+        return /[^a-zA-Z0-9]/;
+    }
+});
+// Predefined Character Sets
+defineRGXConstant("digit", {
+    rgxGroupWrap: false,
+    toRgx() {
+        return /\d/;
+    }
+});
+defineRGXConstant("non-digit", {
+    rgxGroupWrap: false,
+    toRgx() {
+        return /\D/;
+    }
+});
+defineRGXConstant("whitespace", {
+    rgxGroupWrap: false,
+    toRgx() {
+        return /\s/;
+    }
+});
+defineRGXConstant("non-whitespace", {
+    rgxGroupWrap: false,
+    toRgx() {
+        return /\S/;
+    }
+});
+defineRGXConstant("vertical-whitespace", {
+    rgxGroupWrap: false,
+    toRgx() {
+        return /\v/;
+    }
+});
+defineRGXConstant("word-char", {
+    rgxGroupWrap: false,
+    toRgx() {
+        return /\w/;
+    }
+});
+defineRGXConstant("non-word-char", {
+    rgxGroupWrap: false,
+    toRgx() {
+        return /\W/;
+    }
+});
+defineRGXConstant("backspace", {
+    rgxIsGroup: true,
+    rgxGroupWrap: false,
+    toRgx() {
+        return /[\b]/;
+    }
+});

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' | 'INSERTION_REJECTED';
+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';
 export declare class RGXError extends Error {
     _message: string;
     code: RGXErrorCode;

package/dist/errors/constantConflict.d.ts

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

package/dist/errors/constantConflict.js

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

package/dist/errors/index.d.ts

@@ -10,3 +10,5 @@ export * from './invalidFlagTransformerKey';
 export * from './flagTransformerConflict';
 export * from './notSupported';
 export * from './insertionRejected';
+export * from './constantConflict';
+export * from './invalidConstantKey';

package/dist/errors/index.js

@@ -26,3 +26,5 @@ __exportStar(require("./invalidFlagTransformerKey"), exports);
 __exportStar(require("./flagTransformerConflict"), exports);
 __exportStar(require("./notSupported"), exports);
 __exportStar(require("./insertionRejected"), exports);
+__exportStar(require("./constantConflict"), exports);
+__exportStar(require("./invalidConstantKey"), exports);

package/dist/errors/invalidConstantKey.d.ts

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

package/dist/errors/invalidConstantKey.js

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

package/dist/index.d.ts

@@ -11,5 +11,6 @@ export * from "./utils";
 export * from "./ExtRegExp";
 export * from "./flag-transformer";
 export * from "./clone";
+export * from "./constants";
 export declare function rgxa(tokens: t.RGXToken[], flags?: string): ExtRegExp;
 export default function rgx(flags?: string): (strings: TemplateStringsArray, ...tokens: t.RGXToken[]) => ExtRegExp;

package/dist/index.js

@@ -32,6 +32,7 @@ __exportStar(require("./utils"), exports);
 __exportStar(require("./ExtRegExp"), exports);
 __exportStar(require("./flag-transformer"), exports);
 __exportStar(require("./clone"), exports);
+__exportStar(require("./constants"), 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/assureAcceptance.js

@@ -1,17 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assureAcceptance = assureAcceptance;
+const class_1 = require("../class");
 const errors_1 = require("../errors");
 const typeGuards_1 = require("../typeGuards");
 function assureAcceptance(tokens, flags) {
-    for (const token of tokens) {
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
         if ((0, typeGuards_1.isRGXConvertibleToken)(token) && token.rgxAcceptInsertion) {
             const messageOrAccepted = token.rgxAcceptInsertion(tokens, flags);
             if (messageOrAccepted === true)
                 continue;
+            const extraMessage = `index ${i}, token type ${class_1.RGXClassToken.check(token) ? token.constructor.name : "unknown"}`;
             if (messageOrAccepted === false)
-                throw new errors_1.RGXInsertionRejectedError();
-            throw new errors_1.RGXInsertionRejectedError(messageOrAccepted);
+                throw new errors_1.RGXInsertionRejectedError(null, extraMessage);
+            throw new errors_1.RGXInsertionRejectedError(messageOrAccepted, extraMessage);
         }
     }
 }

package/package.json

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