@ptolemy2002/rgx 5.3.0 → 5.5.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.
@@ -924,11 +950,13 @@ A helper function that resolves an array of RGX tokens and concatenates their re
 
 ### rgx
 ```typescript
-function rgx(flags?: string): (strings: TemplateStringsArray, ...tokens: RGXToken[]) => ExtRegExp
+function rgx(flags?: string, multiline?: boolean): (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 with details about the reason and exactly where the rejection occurred.
 
+When `multiline` is `true` (the default), the literal string parts of the template are processed to strip newlines, trim leading whitespace from each line, and remove empty lines, then joined together. This allows you to write regex patterns across multiple lines in the source code for readability without the newlines and indentation becoming part of the pattern. Only the literal string parts between tokens are affected — interpolated values (tokens) are preserved as-is, including string tokens passed via `${"..."}`. When `multiline` is `false`, all literal string parts are preserved exactly as written, including newlines and whitespace.
+
 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)`.
 
 Example usages:
@@ -945,11 +973,26 @@ const pattern3 = rgx()`${beginning}value: ${[word, optionalDigit]}${end}`; // /^
 
 const caseInsensitiveWord = /hello/i;
 const pattern4 = rgx()`${beginning}${caseInsensitiveWord} world${end}`; // /^(?i:hello) world$/ - "hello" matches case-insensitively via an inline modifier group, while " world" remains case-sensitive
+
+// Multiline template for readability (multiline is true by default):
+const pattern5 = rgx()`
+    ${beginning}
+    testing ${word}
+    ${end}
+`; // /^testing \w+$/ - same as pattern, but written across multiple lines
+
+// Preserving literal newlines with multiline mode:
+const pattern6 = rgx()`
+    foo
+    bar${rgxConstant("newline")}
+    baz
+`; // /foobar\nbaz/ - the constant newline is preserved, but template newlines are stripped
 ```
 
 #### Parameters
 **Direct**
   - `flags` (`string`, optional): The regex flags to apply to the resulting `ExtRegExp` object (e.g., 'g', 'i', 'm', or custom registered flags). If not provided, no flags will be applied. If provided and not valid regex flags (vanilla or registered custom), an `RGXInvalidRegexFlagsError` will be thrown.
+  - `multiline` (`boolean`, optional): Whether to strip newlines and trim leading whitespace from the literal string parts of the template. Defaults to `true`. When `true`, each literal string part is split by newlines, each line has its leading whitespace trimmed, empty lines are removed, and the remaining lines are joined together. Interpolated tokens (including string tokens via `${"..."}`) are not affected. When `false`, literal string parts are preserved exactly as written.
 
 **Template Tag**
   - `strings` (`TemplateStringsArray`): The literal parts of the template string.
@@ -1270,6 +1313,142 @@ 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. If the value is a native token (string, number, boolean, or no-op), it is automatically wrapped in an `RGXClassWrapperToken` before being stored. This ensures that native-valued constants are not stripped by multiline template processing in `rgx`, since only the literal string parts of the template are affected by multiline mode. 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. Native tokens are automatically wrapped in `RGXClassWrapperToken`.
+
+#### Returns
+- `RGXToken`: The stored value (after wrapping, if applicable).
+
+### 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
+Since these are defined as native tokens (strings), they are automatically wrapped in `RGXClassWrapperToken` by `defineRGXConstant`, ensuring they are preserved in multiline mode.
+
+| 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): RegExp | import("./types").RGXConvertibleToken | RGXToken[];
+export declare function rgxConstant(name: string): RGXToken;
+export declare function deleteRGXConstant(name: string): void;

package/dist/constants.js

@@ -0,0 +1,187 @@
+"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 class_1 = require("./class");
+const errors_1 = require("./errors");
+const typeGuards_1 = require("./typeGuards");
+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);
+    // Not strings themselves so that they aren't removed in multiline mode.
+    rgxConstants[name] = (0, typeGuards_1.isRGXNativeToken)(value) ? (0, class_1.rgxClassWrapper)(value) : value;
+    return rgxConstants[name];
+}
+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;
+export default function rgx(flags?: string, multiline?: boolean): (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
@@ -42,9 +43,9 @@ function rgxa(tokens, flags = '') {
     const pattern = (0, concat_1.rgxConcat)(tokens, true, flags);
     return (0, ExtRegExp_1.extRegExp)(pattern, flags);
 }
-function rgx(flags = '') {
+function rgx(flags = '', multiline = true) {
     (0, ExtRegExp_1.assertValidRegexFlags)(flags);
     return (strings, ...tokens) => {
-        return rgxa((0, internal_1.taggedTemplateToArray)(strings, tokens), flags);
+        return rgxa((0, internal_1.taggedTemplateToArray)(strings, tokens, multiline), flags);
     };
 }

package/dist/internal/taggedTemplateToArray.d.ts

@@ -1 +1 @@
-export declare function taggedTemplateToArray<T>(strings: TemplateStringsArray, tokens: T[]): (string | T)[];
+export declare function taggedTemplateToArray<T>(strings: TemplateStringsArray, tokens: T[], multiline: boolean): (string | T)[];

package/dist/internal/taggedTemplateToArray.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.taggedTemplateToArray = taggedTemplateToArray;
-function taggedTemplateToArray(strings, tokens) {
+function taggedTemplateToArray(strings, tokens, multiline) {
     function isNullOrUndefined(value) {
         return value === null || value === undefined;
     }
@@ -10,8 +10,16 @@ function taggedTemplateToArray(strings, tokens) {
         const string = strings[i];
         const token = tokens[i];
         // Strings always come before tokens
-        if (!isNullOrUndefined(string))
-            array.push(string);
+        if (!isNullOrUndefined(string)) {
+            if (!multiline) {
+                array.push(string);
+            }
+            else {
+                // Remove all empty lines and trim whitespace from the start of each line.
+                let lines = string.split("\n").map(line => line.trimStart()).filter(line => line.length > 0).join("");
+                array.push(lines);
+            }
+        }
         if (!isNullOrUndefined(token))
             array.push(token);
     }

package/package.json

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