@ptolemy2002/rgx 13.8.0 → 13.9.0

package/README.md

@@ -12,6 +12,7 @@ Because there is so much to document, it has been broken up into multiple files.
 - [type-guards](./docs/type-guards.md) - Type guards for validating various types of tokens and string values.
 - [ExtRegExp](./docs/ExtRegExp.md) - The `ExtRegExp` class, which extends the built-in `RegExp` class with the ability to create custom flags that transform the source string of the regular expression before it is compiled.
 - [constants](./docs/constants.md) - Constants provided by the library, such as predefined character classes and tokens.
+- [json](./docs/json.md) - JSON tokens, a JSON-serializable form of any token, along with the functions that convert tokens to and from that form and the registry of class names that JSON class tokens can target.
 - `util` - A directory containing documentation for various utility functions provided by the library.
   - [clone](./docs/util/clone.md) - The `cloneRGXToken` function, which creates a clone of a given RGX token to a specified depth.
   - [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.

package/dist/class/base.d.ts

@@ -1,4 +1,4 @@
-import { RGXConvertibleToken, RGXToken, ValidRegexFlags, ValidRegexString } from "../types";
+import { RGXConvertibleToken, RGXJSONClassToken, RGXJSONValue, RGXToken, ValidRegexFlags, ValidRegexString } from "../types";
 import { RGXTokenCollectionInput } from "../collection";
 import { ResolveRGXTokenOptions } from "../resolve";
 import { CloneDepth } from "@ptolemy2002/immutability-utils";
@@ -11,6 +11,9 @@ import type { RGXExclusionToken } from "./exclusion";
 export declare abstract class RGXClassToken implements RGXConvertibleToken {
     abstract toRgx(): RGXToken;
     abstract clone(depth?: CloneDepth): ThisType<this>;
+    toJSON(): RGXJSONClassToken;
+    static validateJSONArgs(args: RGXJSONValue[]): boolean | string;
+    static fromJSON(json: RGXJSONClassToken): RGXClassToken;
     rgxAcceptInsertion(tokens: RGXToken[], flags: ValidRegexFlags): string | boolean;
     static check: (value: unknown) => value is RGXClassToken;
     static assert: (value: unknown) => asserts value is RGXClassToken;

package/dist/class/base.js

@@ -4,6 +4,19 @@ exports.RGXClassToken = void 0;
 const errors_1 = require("../errors");
 const resolve_1 = require("../resolve");
 class RGXClassToken {
+    // Subclasses are expected to override toJSON and both static methods below. They are not marked abstract
+    // (so existing subclasses keep compiling), so they throw RGXNotImplementedError by default.
+    // toJSON must return a JSON class token whose args, when given to the registered constructor for the
+    // class, reconstruct an equivalent token.
+    toJSON() {
+        throw new errors_1.RGXNotImplementedError(`${this.constructor.name}.toJSON()`, 'subclasses must override this method.');
+    }
+    static validateJSONArgs(args) {
+        throw new errors_1.RGXNotImplementedError('RGXClassToken.validateJSONArgs(args)', 'subclasses must override this static method.');
+    }
+    static fromJSON(json) {
+        throw new errors_1.RGXNotImplementedError('RGXClassToken.fromJSON(json)', 'subclasses must override this static method.');
+    }
     rgxAcceptInsertion(tokens, flags) {
         return true;
     }

package/dist/class/exclusion.d.ts

@@ -1,4 +1,4 @@
-import { RGXToken } from "../types";
+import { RGXJSONClassToken, RGXJSONValue, RGXToken } from "../types";
 import { RGXClassToken } from "./base";
 import { RGXClassUnionToken } from "./union";
 import { RGXTokenCollectionInput } from "../collection";
@@ -15,5 +15,8 @@ export declare class RGXExclusionToken extends RGXClassToken {
     constructor(exclusionId: string, token: RGXToken, exclusions?: RGXTokenCollectionInput, terminal?: RGXToken);
     toRgx(): RGXToken;
     clone(depth?: CloneDepth): RGXExclusionToken;
+    static validateJSONArgs(args: RGXJSONValue[]): boolean | string;
+    static fromJSON(json: RGXJSONClassToken): RGXExclusionToken;
+    toJSON(): RGXJSONClassToken;
 }
 export declare const rgxExclusion: (exclusionId: string, token: RGXToken, exclusions?: RGXTokenCollectionInput, terminal?: RGXToken) => RGXExclusionToken;

package/dist/class/exclusion.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rgxExclusion = exports.RGXExclusionToken = void 0;
+const json_1 = require("../json");
 const base_1 = require("./base");
 const union_1 = require("./union");
 const resolve_1 = require("../resolve");
@@ -48,6 +49,32 @@ class RGXExclusionToken extends base_1.RGXClassToken {
             return this;
         return new RGXExclusionToken(this.exclusionId, (0, clone_1.cloneRGXToken)(this.token, (0, immutability_utils_1.depthDecrement)(depth, 1)), this.exclusions.clone((0, immutability_utils_1.depthDecrement)(depth, 1)), (0, clone_1.cloneRGXToken)(this.terminal, (0, immutability_utils_1.depthDecrement)(depth, 1)));
     }
+    static validateJSONArgs(args) {
+        if (args.length < 2 || args.length > 4)
+            return "Expected between 2 and 4 arguments (exclusionId, token, exclusions, terminal).";
+        const [exclusionId, token, exclusions, terminal] = args;
+        if (typeof exclusionId !== "string")
+            return "Argument 0 (exclusionId) must be a string.";
+        if (!(0, typeGuards_1.isRGXJSONToken)(token))
+            return "Argument 1 (token) must be a JSON token.";
+        if (exclusions !== undefined && !(0, typeGuards_1.isRGXJSONToken)(exclusions))
+            return "Argument 2 (exclusions) must be a JSON token, if present.";
+        if (terminal !== undefined && !(0, typeGuards_1.isRGXJSONToken)(terminal))
+            return "Argument 3 (terminal) must be a JSON token, if present.";
+        return true;
+    }
+    static fromJSON(json) {
+        const [exclusionId, token, exclusions, terminal] = (0, json_1.rgxJSONClassArgs)(json, "RGXExclusionToken", RGXExclusionToken.validateJSONArgs);
+        return new RGXExclusionToken(exclusionId, (0, json_1.rgxTokenFromJSON)(token), exclusions === undefined ? [] : (0, json_1.rgxTokenFromJSON)(exclusions), terminal === undefined ? null : (0, json_1.rgxTokenFromJSON)(terminal));
+    }
+    toJSON() {
+        return (0, json_1.createRGXJSONClassToken)("RGXExclusionToken", [
+            this.exclusionId,
+            (0, json_1.rgxTokenToJSON)(this.token),
+            (0, json_1.rgxTokenToJSON)(this.exclusions.tokens.tokens),
+            (0, json_1.rgxTokenToJSON)(this.terminal)
+        ]);
+    }
 }
 exports.RGXExclusionToken = RGXExclusionToken;
 RGXExclusionToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXExclusionToken);

package/dist/class/group.d.ts

@@ -1,6 +1,7 @@
 import { RGXTokenCollection, RGXTokenCollectionInput } from "../collection";
 import { RGXClassToken } from "./base";
 import { CloneDepth } from "@ptolemy2002/immutability-utils";
+import { RGXJSONClassToken, RGXJSONValue } from "../types";
 export type RGXGroupTokenArgs = {
     name?: string | null;
     capturing?: boolean;
@@ -24,5 +25,8 @@ export declare class RGXGroupToken extends RGXClassToken {
     constructor({ name, capturing, flags }?: RGXGroupTokenArgs, tokens?: RGXTokenCollectionInput);
     toRgx(): RegExp;
     clone(depth?: CloneDepth): RGXGroupToken;
+    static validateJSONArgs(args: RGXJSONValue[]): boolean | string;
+    static fromJSON(json: RGXJSONClassToken): RGXGroupToken;
+    toJSON(): RGXJSONClassToken;
 }
 export declare const rgxGroup: (args_0?: RGXGroupTokenArgs | undefined, tokens?: RGXTokenCollectionInput) => RGXGroupToken;

package/dist/class/group.js

@@ -7,6 +7,8 @@ const internal_1 = require("../internal");
 const utils_1 = require("../utils");
 const typeGuards_1 = require("../typeGuards");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
+const json_1 = require("../json");
+const typeGuards_2 = require("../typeGuards");
 class RGXGroupToken extends base_1.RGXClassToken {
     get name() {
         return this._name;
@@ -79,6 +81,34 @@ class RGXGroupToken extends base_1.RGXClassToken {
             return this;
         return new RGXGroupToken({ name: this.name, capturing: this._capturing, flags: this.flags }, this.tokens.clone((0, immutability_utils_1.depthDecrement)(depth, 1)));
     }
+    static validateJSONArgs(args) {
+        if (args.length > 2)
+            return "Expected at most 2 arguments (args, tokens).";
+        const [groupArgs, tokens] = args;
+        if (groupArgs !== undefined) {
+            if (typeof groupArgs !== "object" || groupArgs === null || Array.isArray(groupArgs))
+                return "Argument 0 (args) must be an object.";
+            if (groupArgs.name !== undefined && groupArgs.name !== null && typeof groupArgs.name !== "string")
+                return "Argument 0 (args) must have a string or null name, if present.";
+            if (groupArgs.capturing !== undefined && typeof groupArgs.capturing !== "boolean")
+                return "Argument 0 (args) must have a boolean capturing property, if present.";
+            if (groupArgs.flags !== undefined && typeof groupArgs.flags !== "string")
+                return "Argument 0 (args) must have a string flags property, if present.";
+        }
+        if (tokens !== undefined && !(0, typeGuards_2.isRGXJSONToken)(tokens))
+            return "Argument 1 (tokens) must be a JSON token.";
+        return true;
+    }
+    static fromJSON(json) {
+        const [groupArgs, tokens] = (0, json_1.rgxJSONClassArgs)(json, "RGXGroupToken", RGXGroupToken.validateJSONArgs);
+        return new RGXGroupToken(groupArgs ?? {}, tokens === undefined ? [] : (0, json_1.rgxTokenFromJSON)(tokens));
+    }
+    toJSON() {
+        return (0, json_1.createRGXJSONClassToken)("RGXGroupToken", [
+            { name: this.name, capturing: this._capturing, flags: this.flags },
+            (0, json_1.rgxTokenToJSON)(this.tokens.tokens)
+        ]);
+    }
 }
 exports.RGXGroupToken = RGXGroupToken;
 RGXGroupToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXGroupToken);

package/dist/class/init.d.ts

@@ -1 +1,4 @@
+import { RGXJSONBuiltinClassName, RGXJSONClassTokenConstructor } from "../json";
+export declare const RGX_BUILTIN_JSON_CLASSES: Record<RGXJSONBuiltinClassName, RGXJSONClassTokenConstructor>;
+export declare function registerBuiltinRGXJSONClasses(): void;
 export declare function rgxClassInit(): void;

package/dist/class/init.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGX_BUILTIN_JSON_CLASSES = void 0;
+exports.registerBuiltinRGXJSONClasses = registerBuiltinRGXJSONClasses;
 exports.rgxClassInit = rgxClassInit;
 const base_1 = require("./base");
 const union_1 = require("./union");
@@ -10,7 +12,29 @@ const errors_1 = require("../errors");
 const lookahead_1 = require("./lookahead");
 const lookbehind_1 = require("./lookbehind");
 const exclusion_1 = require("./exclusion");
+const wrapper_1 = require("./wrapper");
+const subpattern_1 = require("./subpattern");
+const json_1 = require("../json");
+exports.RGX_BUILTIN_JSON_CLASSES = {
+    RGXClassWrapperToken: wrapper_1.RGXClassWrapperToken,
+    RGXClassUnionToken: union_1.RGXClassUnionToken,
+    RGXGroupToken: group_1.RGXGroupToken,
+    RGXRepeatToken: repeat_1.RGXRepeatToken,
+    RGXLookaheadToken: lookahead_1.RGXLookaheadToken,
+    RGXLookbehindToken: lookbehind_1.RGXLookbehindToken,
+    RGXExclusionToken: exclusion_1.RGXExclusionToken,
+    RGXSubpatternToken: subpattern_1.RGXSubpatternToken
+};
+function registerBuiltinRGXJSONClasses() {
+    for (const [name, constructor] of Object.entries(exports.RGX_BUILTIN_JSON_CLASSES)) {
+        // Skip classes that are already registered so this function is safe to call more than once.
+        if (!(0, json_1.hasRGXJSONClass)(name))
+            (0, json_1.registerRGXJSONClassToken)(name, constructor);
+    }
+}
 function rgxClassInit() {
+    // Make the built-in class tokens available to rgxTokenFromJSON.
+    registerBuiltinRGXJSONClasses();
     // Patch RGXClassToken here, Since classes like RGXClassUnionToken are instances of RGXClassToken
     // themselves. If we tried to import RGXClassUnionToken in base.ts, it would cause a circular dependency.
     base_1.RGXClassToken.prototype.or = function (...others) {

package/dist/class/lookahead.d.ts

@@ -1,4 +1,4 @@
-import { RGXToken } from "../types";
+import { RGXJSONClassToken, RGXJSONValue, RGXToken } from "../types";
 import { RGXLookaroundToken } from "./lookaround";
 import { RGXLookbehindToken } from "./lookbehind";
 import { CloneDepth } from "@ptolemy2002/immutability-utils";
@@ -9,5 +9,8 @@ export declare class RGXLookaheadToken extends RGXLookaroundToken {
     reverse(): RGXLookbehindToken;
     toRgx(): RGXToken;
     clone(depth?: CloneDepth): RGXLookaheadToken;
+    static validateJSONArgs(args: RGXJSONValue[]): boolean | string;
+    static fromJSON(json: RGXJSONClassToken): RGXLookaheadToken;
+    toJSON(): RGXJSONClassToken;
 }
 export declare const rgxLookahead: (tokens?: import("..").RGXTokenCollectionInput, positive?: boolean | undefined) => RGXLookaheadToken;

package/dist/class/lookahead.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rgxLookahead = exports.RGXLookaheadToken = void 0;
+const json_1 = require("../json");
+const lookaround_1 = require("./lookaround");
 const internal_1 = require("../internal");
 const utils_1 = require("../utils");
-const lookaround_1 = require("./lookaround");
+const lookaround_2 = require("./lookaround");
 const lookbehind_1 = require("./lookbehind");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
-class RGXLookaheadToken extends lookaround_1.RGXLookaroundToken {
+class RGXLookaheadToken extends lookaround_2.RGXLookaroundToken {
     negate() {
         return new RGXLookaheadToken(this.tokens, !this.positive);
     }
@@ -26,6 +28,16 @@ class RGXLookaheadToken extends lookaround_1.RGXLookaroundToken {
             return this;
         return new RGXLookaheadToken(this.tokens.clone((0, immutability_utils_1.depthDecrement)(depth, 1)), this.positive);
     }
+    static validateJSONArgs(args) {
+        return (0, lookaround_1.validateLookaroundJSONArgs)(args);
+    }
+    static fromJSON(json) {
+        const [tokens, positive] = (0, json_1.rgxJSONClassArgs)(json, "RGXLookaheadToken", RGXLookaheadToken.validateJSONArgs);
+        return new RGXLookaheadToken(tokens === undefined ? [] : (0, json_1.rgxTokenFromJSON)(tokens), positive ?? true);
+    }
+    toJSON() {
+        return (0, json_1.createRGXJSONClassToken)("RGXLookaheadToken", [(0, json_1.rgxTokenToJSON)(this.tokens.tokens), this.positive]);
+    }
 }
 exports.RGXLookaheadToken = RGXLookaheadToken;
 RGXLookaheadToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXLookaheadToken);

package/dist/class/lookaround.d.ts

@@ -1,5 +1,6 @@
 import { RGXTokenCollection, RGXTokenCollectionInput } from "../collection";
 import { RGXClassToken } from "./base";
+import { RGXJSONValue } from "../types";
 export declare abstract class RGXLookaroundToken extends RGXClassToken {
     tokens: RGXTokenCollection;
     _negative: boolean;
@@ -16,3 +17,4 @@ export declare abstract class RGXLookaroundToken extends RGXClassToken {
     abstract negate(): RGXLookaroundToken;
     abstract reverse(): RGXLookaroundToken;
 }
+export declare function validateLookaroundJSONArgs(args: RGXJSONValue[]): boolean | string;

package/dist/class/lookaround.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RGXLookaroundToken = void 0;
+exports.validateLookaroundJSONArgs = validateLookaroundJSONArgs;
 const collection_1 = require("../collection");
 const base_1 = require("./base");
 const errors_1 = require("../errors");
+const typeGuards_1 = require("../typeGuards");
 class RGXLookaroundToken extends base_1.RGXClassToken {
     get rgxIsGroup() {
         return true;
@@ -45,3 +47,14 @@ RGXLookaroundToken.assert = (value) => {
         throw new errors_1.RGXInvalidTokenError("Invalid token type", { type: "custom", values: ["instance of RGXLookaroundToken"] }, value);
     }
 };
+// Shared argument validation for the lookahead and lookbehind JSON forms.
+function validateLookaroundJSONArgs(args) {
+    if (args.length > 2)
+        return "Expected at most 2 arguments (tokens, positive).";
+    const [tokens, positive] = args;
+    if (tokens !== undefined && !(0, typeGuards_1.isRGXJSONToken)(tokens))
+        return "Argument 0 (tokens) must be a JSON token.";
+    if (positive !== undefined && typeof positive !== "boolean")
+        return "Argument 1 (positive) must be a boolean, if present.";
+    return true;
+}

package/dist/class/lookbehind.d.ts

@@ -1,4 +1,4 @@
-import { RGXToken } from "../types";
+import { RGXJSONClassToken, RGXJSONValue, RGXToken } from "../types";
 import { RGXLookaheadToken } from "./lookahead";
 import { RGXLookaroundToken } from "./lookaround";
 import { CloneDepth } from "@ptolemy2002/immutability-utils";
@@ -9,5 +9,8 @@ export declare class RGXLookbehindToken extends RGXLookaroundToken {
     reverse(): RGXLookaheadToken;
     toRgx(): RGXToken;
     clone(depth?: CloneDepth): RGXLookbehindToken;
+    static validateJSONArgs(args: RGXJSONValue[]): boolean | string;
+    static fromJSON(json: RGXJSONClassToken): RGXLookbehindToken;
+    toJSON(): RGXJSONClassToken;
 }
 export declare const rgxLookbehind: (tokens?: import("..").RGXTokenCollectionInput, positive?: boolean | undefined) => RGXLookbehindToken;

package/dist/class/lookbehind.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rgxLookbehind = exports.RGXLookbehindToken = void 0;
+const json_1 = require("../json");
+const lookaround_1 = require("./lookaround");
 const internal_1 = require("../internal");
 const utils_1 = require("../utils");
 const lookahead_1 = require("./lookahead");
-const lookaround_1 = require("./lookaround");
+const lookaround_2 = require("./lookaround");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
-class RGXLookbehindToken extends lookaround_1.RGXLookaroundToken {
+class RGXLookbehindToken extends lookaround_2.RGXLookaroundToken {
     negate() {
         return new RGXLookbehindToken(this.tokens, !this.positive);
     }
@@ -26,6 +28,16 @@ class RGXLookbehindToken extends lookaround_1.RGXLookaroundToken {
             return this;
         return new RGXLookbehindToken(this.tokens.clone((0, immutability_utils_1.depthDecrement)(depth, 1)), this.positive);
     }
+    static validateJSONArgs(args) {
+        return (0, lookaround_1.validateLookaroundJSONArgs)(args);
+    }
+    static fromJSON(json) {
+        const [tokens, positive] = (0, json_1.rgxJSONClassArgs)(json, "RGXLookbehindToken", RGXLookbehindToken.validateJSONArgs);
+        return new RGXLookbehindToken(tokens === undefined ? [] : (0, json_1.rgxTokenFromJSON)(tokens), positive ?? true);
+    }
+    toJSON() {
+        return (0, json_1.createRGXJSONClassToken)("RGXLookbehindToken", [(0, json_1.rgxTokenToJSON)(this.tokens.tokens), this.positive]);
+    }
 }
 exports.RGXLookbehindToken = RGXLookbehindToken;
 RGXLookbehindToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXLookbehindToken);

package/dist/class/repeat.d.ts

@@ -1,4 +1,4 @@
-import { RGXGroupedToken, RGXToken } from "../types";
+import { RGXGroupedToken, RGXJSONClassToken, RGXJSONValue, RGXToken } from "../types";
 import { RGXClassToken } from "./base";
 import { CloneDepth } from "@ptolemy2002/immutability-utils";
 export declare class RGXRepeatToken extends RGXClassToken {
@@ -19,5 +19,8 @@ export declare class RGXRepeatToken extends RGXClassToken {
     get repeaterSuffix(): string;
     toRgx(): RGXToken;
     clone(depth?: CloneDepth): RGXRepeatToken;
+    static validateJSONArgs(args: RGXJSONValue[]): boolean | string;
+    static fromJSON(json: RGXJSONClassToken): RGXRepeatToken;
+    toJSON(): RGXJSONClassToken;
 }
 export declare const rgxRepeat: (token: RGXToken, min?: number | undefined, max?: number | null | undefined, lazy?: boolean | undefined) => RGXRepeatToken;

package/dist/class/repeat.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rgxRepeat = exports.RGXRepeatToken = void 0;
+const json_1 = require("../json");
 const base_1 = require("./base");
 const group_1 = require("./group");
 const typeGuards_1 = require("../typeGuards");
@@ -97,6 +98,28 @@ class RGXRepeatToken extends base_1.RGXClassToken {
             return this;
         return new RGXRepeatToken((0, clone_1.cloneRGXToken)(this.token, (0, immutability_utils_1.depthDecrement)(depth, 1)), this.min, this.max);
     }
+    static validateJSONArgs(args) {
+        if (args.length < 1 || args.length > 4)
+            return "Expected between 1 and 4 arguments (token, min, max, lazy).";
+        const [token, min, max, lazy] = args;
+        if (!(0, typeGuards_1.isRGXJSONToken)(token))
+            return "Argument 0 (token) must be a JSON token.";
+        if (min !== undefined && typeof min !== "number")
+            return "Argument 1 (min) must be a number, if present.";
+        if (max !== undefined && max !== null && typeof max !== "number")
+            return "Argument 2 (max) must be a number or null, if present.";
+        if (lazy !== undefined && typeof lazy !== "boolean")
+            return "Argument 3 (lazy) must be a boolean, if present.";
+        return true;
+    }
+    static fromJSON(json) {
+        const [token, min, max, lazy] = (0, json_1.rgxJSONClassArgs)(json, "RGXRepeatToken", RGXRepeatToken.validateJSONArgs);
+        const resolvedMin = min ?? 1;
+        return new RGXRepeatToken((0, json_1.rgxTokenFromJSON)(token), resolvedMin, max === undefined ? resolvedMin : max, lazy ?? false);
+    }
+    toJSON() {
+        return (0, json_1.createRGXJSONClassToken)("RGXRepeatToken", [(0, json_1.rgxTokenToJSON)(this.token), this.min, this.max, this.lazy]);
+    }
 }
 exports.RGXRepeatToken = RGXRepeatToken;
 RGXRepeatToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXRepeatToken);

package/dist/class/subpattern.d.ts

@@ -1,4 +1,5 @@
 import { RGXClassToken } from "./base";
+import { RGXJSONClassToken, RGXJSONValue } from "../types";
 import { CloneDepth } from "@ptolemy2002/immutability-utils";
 export declare class RGXSubpatternToken extends RGXClassToken {
     _pattern: string | number;
@@ -9,5 +10,8 @@ export declare class RGXSubpatternToken extends RGXClassToken {
     constructor(pattern: string | number);
     toRgx(): RegExp;
     clone(depth?: CloneDepth): RGXSubpatternToken;
+    static validateJSONArgs(args: RGXJSONValue[]): boolean | string;
+    static fromJSON(json: RGXJSONClassToken): RGXSubpatternToken;
+    toJSON(): RGXJSONClassToken;
 }
 export declare const rgxSubpattern: (pattern: string | number) => RGXSubpatternToken;

package/dist/class/subpattern.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rgxSubpattern = exports.RGXSubpatternToken = void 0;
 const base_1 = require("./base");
+const json_1 = require("../json");
 const typeGuards_1 = require("../typeGuards");
 const errors_1 = require("../errors");
 const internal_1 = require("../internal");
@@ -37,6 +38,20 @@ class RGXSubpatternToken extends base_1.RGXClassToken {
             return this;
         return new RGXSubpatternToken(this.pattern);
     }
+    static validateJSONArgs(args) {
+        if (args.length !== 1)
+            return "Expected exactly 1 argument (pattern).";
+        if (typeof args[0] !== "string" && typeof args[0] !== "number")
+            return "Argument 0 (pattern) must be a string or number.";
+        return true;
+    }
+    static fromJSON(json) {
+        const [pattern] = (0, json_1.rgxJSONClassArgs)(json, "RGXSubpatternToken", RGXSubpatternToken.validateJSONArgs);
+        return new RGXSubpatternToken(pattern);
+    }
+    toJSON() {
+        return (0, json_1.createRGXJSONClassToken)("RGXSubpatternToken", [this.pattern]);
+    }
 }
 exports.RGXSubpatternToken = RGXSubpatternToken;
 RGXSubpatternToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXSubpatternToken);

package/dist/class/toRGXClassToken.js

@@ -7,7 +7,11 @@ const union_1 = require("./union");
 const collection_1 = require("../collection");
 const group_1 = require("./group");
 const wrapper_1 = require("./wrapper");
+const json_1 = require("../json");
 function toRGXClassToken(token) {
+    // JSON class tokens become class tokens and JSON literal tokens become literal tokens (which get wrapped below).
+    if ((0, typeGuards_1.isRGXJSONObjectToken)(token, false))
+        token = (0, json_1.rgxTokenFromJSON)(token);
     if (base_1.RGXClassToken.check(token))
         return token;
     if ((0, typeGuards_1.isRGXArrayToken)(token))

package/dist/class/union.d.ts

@@ -2,6 +2,7 @@ import { RGXToken } from "../types";
 import { RGXTokenCollection, RGXTokenCollectionInput } from "../collection";
 import { RGXClassToken } from "./base";
 import { CloneDepth } from "@ptolemy2002/immutability-utils";
+import { RGXJSONClassToken, RGXJSONValue } from "../types";
 export type RGXUnionInsertionPosition = 'prefix' | 'suffix';
 export declare class RGXClassUnionToken extends RGXClassToken {
     tokens: RGXTokenCollection;
@@ -13,6 +14,9 @@ export declare class RGXClassUnionToken extends RGXClassToken {
     concat(pos?: RGXUnionInsertionPosition, ...others: RGXTokenCollectionInput[]): this;
     toRgx(): RegExp;
     clone(depth?: CloneDepth): RGXClassUnionToken;
+    static validateJSONArgs(args: RGXJSONValue[]): boolean | string;
+    static fromJSON(json: RGXJSONClassToken): RGXClassUnionToken;
+    toJSON(): RGXJSONClassToken;
 }
 export declare function expandRgxUnionTokens(...tokens: RGXTokenCollectionInput[]): RGXTokenCollection;
 export declare function removeRgxUnionDuplicates(...tokens: RGXTokenCollectionInput[]): RGXTokenCollection;

package/dist/class/union.js

@@ -8,6 +8,8 @@ const collection_1 = require("../collection");
 const base_1 = require("./base");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
 const utils_1 = require("../utils");
+const json_1 = require("../json");
+const typeGuards_1 = require("../typeGuards");
 class RGXClassUnionToken extends base_1.RGXClassToken {
     constructor(tokens = []) {
         super();
@@ -51,6 +53,20 @@ class RGXClassUnionToken extends base_1.RGXClassToken {
             return this;
         return new RGXClassUnionToken(this.tokens.clone((0, immutability_utils_1.depthDecrement)(depth, 1)));
     }
+    static validateJSONArgs(args) {
+        if (args.length > 1)
+            return "Expected at most 1 argument (tokens).";
+        if (args.length === 1 && !(0, typeGuards_1.isRGXJSONToken)(args[0]))
+            return "Argument 0 (tokens) must be a JSON token.";
+        return true;
+    }
+    static fromJSON(json) {
+        const [tokens] = (0, json_1.rgxJSONClassArgs)(json, "RGXClassUnionToken", RGXClassUnionToken.validateJSONArgs);
+        return new RGXClassUnionToken(tokens === undefined ? [] : (0, json_1.rgxTokenFromJSON)(tokens));
+    }
+    toJSON() {
+        return (0, json_1.createRGXJSONClassToken)("RGXClassUnionToken", [(0, json_1.rgxTokenToJSON)(this.tokens.tokens)]);
+    }
 }
 exports.RGXClassUnionToken = RGXClassUnionToken;
 RGXClassUnionToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXClassUnionToken);
@@ -75,8 +91,10 @@ function expandRgxUnionTokens(...tokens) {
 }
 function removeRgxUnionDuplicates(...tokens) {
     let uniqueTokens = [...new Set(tokens)];
-    // Handle RegExp objects separately since they are not considered equal even if they have the same pattern and flags
+    // Handle RegExp objects separately since they are not considered equal even if they have the same pattern and flags.
+    // JSON object tokens get the same treatment, compared by their serialized form.
     const seenRegexes = new Set();
+    const seenJSON = new Set();
     uniqueTokens = uniqueTokens.filter(token => {
         if (token instanceof RegExp) {
             const regexString = token.toString();
@@ -88,6 +106,16 @@ function removeRgxUnionDuplicates(...tokens) {
                 return true;
             }
         }
+        if ((0, typeGuards_1.isRGXJSONObjectToken)(token, false)) {
+            const jsonString = JSON.stringify(token);
+            if (seenJSON.has(jsonString)) {
+                return false;
+            }
+            else {
+                seenJSON.add(jsonString);
+                return true;
+            }
+        }
         return true;
     });
     return new collection_1.RGXTokenCollection(uniqueTokens, 'union');

package/dist/class/wrapper.d.ts

@@ -1,4 +1,4 @@
-import { RGXToken } from "../types";
+import { RGXJSONClassToken, RGXJSONValue, RGXToken } from "../types";
 import { RGXClassToken } from "./base";
 import { CloneDepth } from "@ptolemy2002/immutability-utils";
 export declare class RGXClassWrapperToken extends RGXClassToken {
@@ -11,5 +11,8 @@ export declare class RGXClassWrapperToken extends RGXClassToken {
     unwrap(): RGXToken;
     toRgx(): RGXToken;
     clone(depth?: CloneDepth): RGXClassWrapperToken;
+    static validateJSONArgs(args: RGXJSONValue[]): boolean | string;
+    static fromJSON(json: RGXJSONClassToken): RGXClassWrapperToken;
+    toJSON(): RGXJSONClassToken;
 }
 export declare const rgxClassWrapper: (token: RGXToken) => RGXClassWrapperToken;

package/dist/class/wrapper.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rgxClassWrapper = exports.RGXClassWrapperToken = void 0;
+const json_1 = require("../json");
 const base_1 = require("./base");
 const typeGuards_1 = require("../typeGuards");
 const internal_1 = require("../internal");
@@ -16,8 +17,10 @@ class RGXClassWrapperToken extends base_1.RGXClassToken {
         return (0, typeGuards_1.isRGXGroupedToken)(this.token);
     }
     get rgxIsRepeatable() {
-        if ((0, typeGuards_1.isRGXToken)(this.token, 'convertible'))
-            return this.token.rgxIsRepeatable ?? true;
+        // JSON tokens become literal or class tokens, so check the converted token instead.
+        const token = (0, typeGuards_1.isRGXJSONObjectToken)(this.token, false) ? (0, json_1.rgxTokenFromJSON)(this.token) : this.token;
+        if ((0, typeGuards_1.isRGXToken)(token, 'convertible', true, false))
+            return token.rgxIsRepeatable ?? true;
         // Assume any other token is repeatable, since we don't know its implementation.
         return true;
     }
@@ -32,6 +35,20 @@ class RGXClassWrapperToken extends base_1.RGXClassToken {
             return this;
         return new RGXClassWrapperToken((0, clone_1.cloneRGXToken)(this.token, (0, immutability_utils_1.depthDecrement)(depth, 1)));
     }
+    static validateJSONArgs(args) {
+        if (args.length !== 1)
+            return "Expected exactly 1 argument (token).";
+        if (!(0, typeGuards_1.isRGXJSONToken)(args[0]))
+            return "Argument 0 (token) must be a JSON token.";
+        return true;
+    }
+    static fromJSON(json) {
+        const [token] = (0, json_1.rgxJSONClassArgs)(json, "RGXClassWrapperToken", RGXClassWrapperToken.validateJSONArgs);
+        return new RGXClassWrapperToken((0, json_1.rgxTokenFromJSON)(token));
+    }
+    toJSON() {
+        return (0, json_1.createRGXJSONClassToken)("RGXClassWrapperToken", [(0, json_1.rgxTokenToJSON)(this.token)]);
+    }
 }
 exports.RGXClassWrapperToken = RGXClassWrapperToken;
 RGXClassWrapperToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXClassWrapperToken);

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' | 'REGEX_NOT_MATCHED_AFTER_POSITION' | 'PART_VALIDATION_FAILED' | 'INVALID_LEXER_MODE' | 'LEXEME_NOT_MATCHED_AT_POSITION' | 'INVALID_RGX_LEXER' | 'INVALID_RGX_WALKER' | 'INVALID_RGX_PART' | 'NOT_DIRECT_REGEXP' | 'CURRENT_TOKEN_NOT_FOUND' | 'INVALID_REGEX_LOCALIZABLE_FLAG_DIFF' | 'INVALID_REGEX_LOCALIZABLE_FLAGS';
+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' | 'REGEX_NOT_MATCHED_AFTER_POSITION' | 'PART_VALIDATION_FAILED' | 'INVALID_LEXER_MODE' | 'LEXEME_NOT_MATCHED_AT_POSITION' | 'INVALID_RGX_LEXER' | 'INVALID_RGX_WALKER' | 'INVALID_RGX_PART' | 'NOT_DIRECT_REGEXP' | 'CURRENT_TOKEN_NOT_FOUND' | 'INVALID_REGEX_LOCALIZABLE_FLAG_DIFF' | 'INVALID_REGEX_LOCALIZABLE_FLAGS' | 'INVALID_RGX_JSON_TOKEN' | 'JSON_CLASS_CONFLICT' | 'INVALID_JSON_CLASS_KEY' | 'JSON_CLASS_ARGS_VALIDATION_FAILED' | 'NOT_JSON_SERIALIZABLE';
 export declare class RGXError extends Error {
     _message: string;
     code: RGXErrorCode;

package/dist/errors/index.d.ts

@@ -24,3 +24,8 @@ export * from './notDirectRegexp';
 export * from './currentTokenNotFound';
 export * from './invalidRegexLocalizableFlagDiff';
 export * from './invalidRegexLocalizableFlags';
+export * from './invalidJSONToken';
+export * from './jsonClassConflict';
+export * from './invalidJSONClassKey';
+export * from './jsonClassArgsValidationFailed';
+export * from './notJSONSerializable';

package/dist/errors/index.js

@@ -40,3 +40,8 @@ __exportStar(require("./notDirectRegexp"), exports);
 __exportStar(require("./currentTokenNotFound"), exports);
 __exportStar(require("./invalidRegexLocalizableFlagDiff"), exports);
 __exportStar(require("./invalidRegexLocalizableFlags"), exports);
+__exportStar(require("./invalidJSONToken"), exports);
+__exportStar(require("./jsonClassConflict"), exports);
+__exportStar(require("./invalidJSONClassKey"), exports);
+__exportStar(require("./jsonClassArgsValidationFailed"), exports);
+__exportStar(require("./notJSONSerializable"), exports);

package/dist/errors/invalidJSONClassKey.d.ts

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