@ptolemy2002/rgx 13.7.0 → 13.9.0

package/dist/errors/invalidJSONClassKey.js

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

package/dist/errors/invalidJSONToken.d.ts

@@ -0,0 +1,4 @@
+import { ExpectedTokenType, RGXInvalidTokenError } from "./invalidToken";
+export declare class RGXInvalidJSONTokenError extends RGXInvalidTokenError {
+    constructor(message: string, expected?: ExpectedTokenType | null, got?: unknown);
+}

package/dist/errors/invalidJSONToken.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGXInvalidJSONTokenError = void 0;
+const invalidToken_1 = require("./invalidToken");
+class RGXInvalidJSONTokenError extends invalidToken_1.RGXInvalidTokenError {
+    constructor(message, expected = { type: "tokenType", values: ["json"] }, got = undefined) {
+        super(message, expected, got);
+        this.name = 'RGXInvalidJSONTokenError';
+        this.code = 'INVALID_RGX_JSON_TOKEN';
+    }
+}
+exports.RGXInvalidJSONTokenError = RGXInvalidJSONTokenError;

package/dist/errors/invalidToken.js

@@ -10,7 +10,8 @@ const tokenExpectationMap = {
     'native': ['string', 'number', 'boolean', 'null', 'undefined'],
     'convertible': ['object with a toRgx method that returns a valid native/literal token or an array of valid native/literal tokens'],
     'array': ['array of native/literal/convertible tokens'],
-    'class': ['instance of RGXClassToken']
+    'class': ['instance of RGXClassToken'],
+    'json': ['JSON-serializable native token', 'object with $rgx set to true and either a regex source (with optional flags) or a registered class name (with optional args)', 'array of JSON tokens']
 };
 class RGXInvalidTokenError extends errors_1.RGXError {
     setExpected(expected) {
@@ -46,7 +47,19 @@ class RGXInvalidTokenError extends errors_1.RGXError {
         this.setExpected(expected);
     }
     calcMessage(message) {
-        const gotString = class_1.RGXClassToken.check(this.got) ? `instance of ${this.got.constructor.name}` : JSON.stringify(this.got);
+        let gotString;
+        if (class_1.RGXClassToken.check(this.got)) {
+            gotString = `instance of ${this.got.constructor.name}`;
+        }
+        else {
+            try {
+                gotString = JSON.stringify(this.got) ?? String(this.got);
+            }
+            catch {
+                // Values like BigInts and circular structures cannot be stringified as JSON.
+                gotString = String(this.got);
+            }
+        }
         return `${message}; Expected: ${this.expected}; Got: [${gotString}]`;
     }
 }

package/dist/errors/jsonClassArgsValidationFailed.d.ts

@@ -0,0 +1,8 @@
+import { RGXError } from "./base";
+export declare class RGXJSONClassArgsValidationFailedError extends RGXError {
+    className: string;
+    args: unknown[];
+    reason: string | null;
+    constructor(className: string, args: unknown[], reason?: string | null);
+    calcMessage(message: string): string;
+}

package/dist/errors/jsonClassArgsValidationFailed.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGXJSONClassArgsValidationFailedError = void 0;
+const base_1 = require("./base");
+class RGXJSONClassArgsValidationFailedError extends base_1.RGXError {
+    constructor(className, args, reason = null) {
+        super("JSON class argument validation failed", 'JSON_CLASS_ARGS_VALIDATION_FAILED');
+        this.name = 'RGXJSONClassArgsValidationFailedError';
+        this.className = className;
+        this.args = args;
+        this.reason = reason;
+    }
+    calcMessage(message) {
+        let result = `${message}; Class: ${JSON.stringify(this.className)}; Args: ${JSON.stringify(this.args)}`;
+        if (this.reason !== null)
+            result += `; Reason: ${this.reason}`;
+        return result;
+    }
+}
+exports.RGXJSONClassArgsValidationFailedError = RGXJSONClassArgsValidationFailedError;

package/dist/errors/jsonClassConflict.d.ts

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

package/dist/errors/jsonClassConflict.js

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

package/dist/errors/notJSONSerializable.d.ts

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

package/dist/errors/notJSONSerializable.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGXNotJSONSerializableError = void 0;
+const base_1 = require("./base");
+class RGXNotJSONSerializableError extends base_1.RGXError {
+    constructor(message, got, reason = null) {
+        super(message, 'NOT_JSON_SERIALIZABLE');
+        this.name = 'RGXNotJSONSerializableError';
+        this.got = got;
+        this.reason = reason;
+    }
+    calcMessage(message) {
+        let gotString;
+        try {
+            gotString = JSON.stringify(this.got) ?? String(this.got);
+        }
+        catch {
+            gotString = String(this.got);
+        }
+        let result = `${message}; Got: ${gotString}`;
+        if (this.reason !== null)
+            result += `; Reason: ${this.reason}`;
+        return result;
+    }
+}
+exports.RGXNotJSONSerializableError = RGXNotJSONSerializableError;

package/dist/flag-transformer/accentInsensitive.js

@@ -5,11 +5,11 @@ const constants_1 = require("../constants");
 const resolve_1 = require("../resolve");
 const utils_1 = require("../utils");
 const accentPatterns = [
-    "(a|á|à|ä|â|ã)", "(A|Á|À|Ä|Â|Ã)",
-    "(e|é|è|ë|ê)", "(E|É|È|Ë|Ê)",
-    "(i|í|ì|ï|î)", "(I|Í|Ì|Ï|Î)",
-    "(o|ó|ò|ö|ô|õ)", "(O|Ó|Ò|Ö|Ô|Õ)",
-    "(u|ú|ù|ü|û)", "(U|Ú|Ù|Ü|Û)"
+    "(?:a|á|à|ä|â|ã)", "(?:A|Á|À|Ä|Â|Ã)",
+    "(?:e|é|è|ë|ê)", "(?:E|É|È|Ë|Ê)",
+    "(?:i|í|ì|ï|î)", "(?:I|Í|Ì|Ï|Î)",
+    "(?:o|ó|ò|ö|ô|õ)", "(?:O|Ó|Ò|Ö|Ô|Õ)",
+    "(?:u|ú|ù|ü|û)", "(?:U|Ú|Ù|Ü|Û)"
 ];
 const nonEscapeBound = (0, resolve_1.resolveRGXToken)((0, constants_1.rgxConstant)("non-escape-bound"));
 const nonLocalizedFlagBound = (0, resolve_1.resolveRGXToken)({

package/dist/index.d.ts

@@ -11,6 +11,7 @@ export * from "./typeGuards";
 export * from "./collection";
 export * from "./class";
 export * from "./resolve";
+export * from "./json";
 export * from "./concat";
 export * from "./utils";
 export * from "./ExtRegExp";

package/dist/index.js

@@ -58,6 +58,7 @@ __exportStar(require("./typeGuards"), exports);
 __exportStar(require("./collection"), exports);
 __exportStar(require("./class"), exports);
 __exportStar(require("./resolve"), exports);
+__exportStar(require("./json"), exports);
 __exportStar(require("./concat"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./ExtRegExp"), exports);

package/dist/internal/assureAcceptance.js

@@ -4,9 +4,12 @@ exports.assureAcceptance = assureAcceptance;
 const class_1 = require("../class");
 const errors_1 = require("../errors");
 const typeGuards_1 = require("../typeGuards");
+const json_1 = require("../json");
 function assureAcceptance(tokens, flags) {
     for (let i = 0; i < tokens.length; i++) {
-        const token = tokens[i];
+        // JSON class tokens become class tokens, which may have insertion preferences.
+        const rawToken = tokens[i];
+        const token = (0, typeGuards_1.isRGXJSONClassToken)(rawToken, false) ? (0, json_1.rgxTokenFromJSON)(rawToken) : rawToken;
         if ((0, typeGuards_1.isRGXConvertibleToken)(token) && token.rgxAcceptInsertion) {
             const messageOrAccepted = token.rgxAcceptInsertion(tokens, flags);
             if (messageOrAccepted === true)

package/dist/json.d.ts

@@ -0,0 +1,35 @@
+import * as t from "./types";
+import { RGXClassToken } from "./class";
+export type RGXJSONClassArgsValidator = (args: t.RGXJSONValue[]) => boolean | string;
+export type RGXJSONClassConstructor = (args: t.RGXJSONValue[]) => RGXClassToken;
+export type RGXJSONClassRegistryEntry = {
+    validateArgs: RGXJSONClassArgsValidator;
+    construct: RGXJSONClassConstructor;
+};
+export type RGXJSONClassTokenConstructor = {
+    validateJSONArgs: RGXJSONClassArgsValidator;
+    fromJSON: (json: t.RGXJSONClassToken) => RGXClassToken;
+};
+export type RGXJSONBuiltinClassName = "RGXClassWrapperToken" | "RGXClassUnionToken" | "RGXGroupToken" | "RGXRepeatToken" | "RGXLookaheadToken" | "RGXLookbehindToken" | "RGXExclusionToken" | "RGXSubpatternToken";
+export type RGXJSONClassName = RGXJSONBuiltinClassName | (string & {});
+export type RGXTokenToJSONOptions = {
+    resolveConvertible?: boolean;
+};
+export declare function listRGXJSONClasses(): string[];
+export declare function hasRGXJSONClass(name: RGXJSONClassName): boolean;
+export declare function assertHasRGXJSONClass(name: RGXJSONClassName): void;
+export declare function assertNotHasRGXJSONClass(name: RGXJSONClassName): void;
+export declare function registerRGXJSONClass(name: RGXJSONClassName, entry: RGXJSONClassRegistryEntry): RGXJSONClassRegistryEntry;
+export declare function registerRGXJSONClassToken(name: RGXJSONClassName, constructor: RGXJSONClassTokenConstructor): RGXJSONClassRegistryEntry;
+export declare function getRGXJSONClass(name: RGXJSONClassName): RGXJSONClassRegistryEntry;
+export declare function unregisterRGXJSONClass(name: RGXJSONClassName): void;
+export declare function validateRGXJSONClassArgs(name: RGXJSONClassName, args: t.RGXJSONValue[]): true | string;
+export declare function assertValidRGXJSONClassArgs(name: RGXJSONClassName, args: t.RGXJSONValue[]): void;
+export declare function createRGXJSONClassToken(name: RGXJSONClassName, args?: t.RGXJSONValue[]): t.RGXJSONClassToken;
+export declare function createRGXJSONLiteralToken(source: string, flags?: string): t.RGXJSONLiteralToken;
+export declare function assertRGXJSONClassTokenOf(json: unknown, name: RGXJSONClassName): asserts json is t.RGXJSONClassToken;
+export declare function rgxJSONClassArgs(json: unknown, name: RGXJSONClassName, validate: RGXJSONClassArgsValidator): t.RGXJSONValue[];
+export declare function rgxTokenToJSON(token: t.RGXToken, { resolveConvertible }?: RGXTokenToJSONOptions): t.RGXJSONToken;
+export declare function rgxTokenFromJSON(json: t.RGXJSONToken): t.RGXNonJSONToken;
+export declare function rgxTokenToJSONString(token: t.RGXToken, options?: RGXTokenToJSONOptions, space?: string | number): string;
+export declare function rgxTokenFromJSONString(json: string): t.RGXNonJSONToken;

package/dist/json.js

@@ -0,0 +1,208 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listRGXJSONClasses = listRGXJSONClasses;
+exports.hasRGXJSONClass = hasRGXJSONClass;
+exports.assertHasRGXJSONClass = assertHasRGXJSONClass;
+exports.assertNotHasRGXJSONClass = assertNotHasRGXJSONClass;
+exports.registerRGXJSONClass = registerRGXJSONClass;
+exports.registerRGXJSONClassToken = registerRGXJSONClassToken;
+exports.getRGXJSONClass = getRGXJSONClass;
+exports.unregisterRGXJSONClass = unregisterRGXJSONClass;
+exports.validateRGXJSONClassArgs = validateRGXJSONClassArgs;
+exports.assertValidRGXJSONClassArgs = assertValidRGXJSONClassArgs;
+exports.createRGXJSONClassToken = createRGXJSONClassToken;
+exports.createRGXJSONLiteralToken = createRGXJSONLiteralToken;
+exports.assertRGXJSONClassTokenOf = assertRGXJSONClassTokenOf;
+exports.rgxJSONClassArgs = rgxJSONClassArgs;
+exports.rgxTokenToJSON = rgxTokenToJSON;
+exports.rgxTokenFromJSON = rgxTokenFromJSON;
+exports.rgxTokenToJSONString = rgxTokenToJSONString;
+exports.rgxTokenFromJSONString = rgxTokenFromJSONString;
+const t = __importStar(require("./types"));
+const e = __importStar(require("./errors"));
+const tg = __importStar(require("./typeGuards"));
+const class_1 = require("./class");
+const collection_1 = require("./collection");
+const ExtRegExp_1 = require("./ExtRegExp");
+const resolve_1 = require("./resolve");
+const rgxJSONClasses = {};
+// ------------------ Registry ------------------
+function listRGXJSONClasses() {
+    return Object.keys(rgxJSONClasses);
+}
+function hasRGXJSONClass(name) {
+    return name in rgxJSONClasses;
+}
+function assertHasRGXJSONClass(name) {
+    if (!hasRGXJSONClass(name)) {
+        throw new e.RGXInvalidJSONClassKeyError("JSON class with name not registered.", name);
+    }
+}
+function assertNotHasRGXJSONClass(name) {
+    if (hasRGXJSONClass(name)) {
+        throw new e.RGXJSONClassConflictError("JSON class with name already registered.", name);
+    }
+}
+function registerRGXJSONClass(name, entry) {
+    assertNotHasRGXJSONClass(name);
+    rgxJSONClasses[name] = entry;
+    return entry;
+}
+function registerRGXJSONClassToken(name, constructor) {
+    return registerRGXJSONClass(name, {
+        validateArgs: args => constructor.validateJSONArgs(args),
+        construct: args => constructor.fromJSON(createRGXJSONClassToken(name, args))
+    });
+}
+function getRGXJSONClass(name) {
+    assertHasRGXJSONClass(name);
+    return rgxJSONClasses[name];
+}
+function unregisterRGXJSONClass(name) {
+    assertHasRGXJSONClass(name);
+    delete rgxJSONClasses[name];
+}
+function validateRGXJSONClassArgs(name, args) {
+    const result = getRGXJSONClass(name).validateArgs(args);
+    if (result === true)
+        return true;
+    if (result === false)
+        return "Argument validation failed.";
+    return result;
+}
+function assertValidRGXJSONClassArgs(name, args) {
+    const result = validateRGXJSONClassArgs(name, args);
+    if (result !== true)
+        throw new e.RGXJSONClassArgsValidationFailedError(name, args, result);
+}
+// ------------------ Helpers for class token implementations ------------------
+function createRGXJSONClassToken(name, args = []) {
+    return { [t.RGX_JSON_FLAG]: true, class: name, args };
+}
+function createRGXJSONLiteralToken(source, flags = '') {
+    tg.assertValidRegexString(source);
+    if (flags === '')
+        return { [t.RGX_JSON_FLAG]: true, source };
+    return { [t.RGX_JSON_FLAG]: true, source, flags };
+}
+function assertRGXJSONClassTokenOf(json, name) {
+    tg.assertRGXJSONClassToken(json, false);
+    if (json.class !== name) {
+        throw new e.RGXInvalidJSONTokenError("JSON class token is for a different class", { type: "custom", values: [`JSON class token with class ${JSON.stringify(name)}`] }, json);
+    }
+}
+// Extracts the args from a JSON class token after checking that it targets the given class and that
+// its args pass the given validator. Throws RGXJSONClassArgsValidationFailedError if validation fails.
+function rgxJSONClassArgs(json, name, validate) {
+    assertRGXJSONClassTokenOf(json, name);
+    const args = json.args ?? [];
+    const result = validate(args);
+    if (result === true)
+        return args;
+    throw new e.RGXJSONClassArgsValidationFailedError(name, args, result === false ? "Argument validation failed." : result);
+}
+// ------------------ Conversion ------------------
+function rgxTokenToJSON(token, { resolveConvertible = true } = {}) {
+    if (tg.isRGXNoOpToken(token))
+        return null;
+    if (tg.isRGXNativeToken(token)) {
+        if (typeof token === "number" && !Number.isFinite(token)) {
+            throw new e.RGXNotJSONSerializableError("Cannot convert token to JSON", token, "Non-finite numbers are not JSON-serializable.");
+        }
+        return token;
+    }
+    if (tg.isRGXLiteralToken(token)) {
+        // The source of an ExtRegExp already has any custom flag transformations applied,
+        // so only the vanilla flags are kept to avoid applying the transformations twice.
+        return createRGXJSONLiteralToken(token.source, (0, ExtRegExp_1.extractVanillaRegexFlags)(token.flags));
+    }
+    if (tg.isRGXJSONObjectToken(token, false)) {
+        tg.assertRGXJSONObjectToken(token);
+        return token;
+    }
+    if (class_1.RGXClassToken.check(token))
+        return token.toJSON();
+    if (collection_1.RGXTokenCollection.check(token))
+        return (0, class_1.toRGXClassToken)(token).toJSON();
+    if (tg.isRGXConvertibleToken(token, false)) {
+        if (!resolveConvertible) {
+            throw new e.RGXNotJSONSerializableError("Cannot convert token to JSON", token, "Convertible tokens that are not class tokens can only be converted by resolving them, but resolveConvertible is false.");
+        }
+        return createRGXJSONLiteralToken((0, resolve_1.resolveRGXToken)(token, { groupWrap: false }));
+    }
+    if (tg.isRGXArrayToken(token, false)) {
+        return token.map(item => rgxTokenToJSON(item, { resolveConvertible }));
+    }
+    // Ignoring this line since it should be impossible to reach if the types are correct.
+    /* istanbul ignore next */
+    throw new e.RGXInvalidTokenError("Invalid RGX token", null, token);
+}
+function rgxTokenFromJSON(json) {
+    if (tg.isRGXJSONNativeToken(json))
+        return json;
+    if (tg.isRGXJSONLiteralToken(json, false)) {
+        tg.assertRGXJSONLiteralToken(json);
+        return new ExtRegExp_1.ExtRegExp(json.source, json.flags ?? '');
+    }
+    if (tg.isRGXJSONClassToken(json, false)) {
+        const args = json.args ?? [];
+        assertValidRGXJSONClassArgs(json.class, args);
+        return getRGXJSONClass(json.class).construct(args);
+    }
+    if (Array.isArray(json))
+        return json.map(item => rgxTokenFromJSON(item));
+    throw new e.RGXInvalidJSONTokenError("Invalid RGX JSON token", { type: "tokenType", values: ["json"] }, json);
+}
+function rgxTokenToJSONString(token, options = {}, space) {
+    return JSON.stringify(rgxTokenToJSON(token, options), null, space);
+}
+function rgxTokenFromJSONString(json) {
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch (err) {
+        if (err instanceof SyntaxError) {
+            throw new e.RGXInvalidJSONTokenError(`Invalid JSON string: ${err.message}`, { type: "tokenType", values: ["json"] }, json);
+        }
+        // This is ignored because I don't know what kind of
+        // unexpected errors might happen.
+        /* istanbul ignore next */
+        throw err;
+    }
+    tg.assertRGXJSONToken(parsed, false);
+    return rgxTokenFromJSON(parsed);
+}

package/dist/resolve.js

@@ -40,6 +40,7 @@ const e = __importStar(require("./errors"));
 const ExtRegExp_1 = require("./ExtRegExp");
 const tg = __importStar(require("./typeGuards"));
 const internal_1 = require("./internal");
+const json_1 = require("./json");
 function escapeRegex(value) {
     const result = value.replaceAll(/[\-\^\$.*+?^${}()|[\]\\]/g, '\\$&');
     tg.assertValidRegexString(result);
@@ -77,6 +78,9 @@ function hasParenErrors(pattern) {
 }
 function resolveRGXToken(token, { groupWrap = true, topLevel = true, currentFlags = '' } = {}) {
     (0, ExtRegExp_1.assertValidRegexFlags)(currentFlags);
+    // JSON tokens are converted to their runtime equivalents (literal or class tokens) before resolving.
+    if (tg.isRGXJSONObjectToken(token, false))
+        token = (0, json_1.rgxTokenFromJSON)(token);
     let acceptParenErrors = false;
     const innerResolve = () => {
         if (tg.isRGXNoOpToken(token))

package/dist/typeGuards.d.ts

@@ -5,26 +5,43 @@ export declare function isRGXLiteralToken(value: unknown): value is t.RGXLiteral
 export declare function assertRGXLiteralToken(value: unknown): asserts value is t.RGXLiteralToken;
 export declare function isRGXNativeToken(value: unknown): value is t.RGXNativeToken;
 export declare function assertRGXNativeToken(value: unknown): asserts value is t.RGXNativeToken;
-export declare function isRGXConvertibleToken(value: unknown, returnCheck?: boolean): value is t.RGXConvertibleToken;
-export declare function assertRGXConvertibleToken(value: unknown, returnCheck?: boolean): asserts value is t.RGXConvertibleToken;
-export declare function isRGXArrayToken(value: unknown, contentCheck?: boolean): value is t.RGXToken[];
-export declare function assertRGXArrayToken(value: unknown, contentCheck?: boolean): asserts value is t.RGXToken[];
-export declare function rgxTokenTypeFlat(value: unknown, recognizeClass?: boolean): t.RGXTokenTypeFlat;
-export declare function rgxTokenType(value: unknown, recognizeClass?: boolean): t.RGXTokenType;
+export declare function isRGXConvertibleToken(value: unknown, returnCheck?: boolean, acceptJSON?: boolean): value is t.RGXConvertibleToken;
+export declare function assertRGXConvertibleToken(value: unknown, returnCheck?: boolean, acceptJSON?: boolean): asserts value is t.RGXConvertibleToken;
+export declare function isRGXArrayToken(value: unknown, contentCheck?: boolean, acceptJSON?: boolean): value is t.RGXToken[];
+export declare function assertRGXArrayToken(value: unknown, contentCheck?: boolean, acceptJSON?: boolean): asserts value is t.RGXToken[];
+export declare function isRGXJSONValue(value: unknown): value is t.RGXJSONValue;
+export declare function assertRGXJSONValue(value: unknown): asserts value is t.RGXJSONValue;
+export declare function isRGXJSONNativeToken(value: unknown): value is t.RGXJSONNativeToken;
+export declare function assertRGXJSONNativeToken(value: unknown): asserts value is t.RGXJSONNativeToken;
+export declare function isRGXJSONLiteralToken(value: unknown, contentCheck?: boolean): value is t.RGXJSONLiteralToken;
+export declare function assertRGXJSONLiteralToken(value: unknown, contentCheck?: boolean): asserts value is t.RGXJSONLiteralToken;
+export declare function isRGXJSONClassToken(value: unknown, registryCheck?: boolean): value is t.RGXJSONClassToken;
+export declare function assertRGXJSONClassToken(value: unknown, registryCheck?: boolean): asserts value is t.RGXJSONClassToken;
+export declare function isRGXJSONObjectToken(value: unknown, contentCheck?: boolean): value is t.RGXJSONObjectToken;
+export declare function assertRGXJSONObjectToken(value: unknown, contentCheck?: boolean): asserts value is t.RGXJSONObjectToken;
+export declare function isRGXJSONToken(value: unknown, contentCheck?: boolean): value is t.RGXJSONToken;
+export declare function assertRGXJSONToken(value: unknown, contentCheck?: boolean): asserts value is t.RGXJSONToken;
+export declare function rgxTokenTypeFlat(value: unknown, recognizeClass?: boolean, acceptJSON?: boolean): t.RGXTokenTypeFlat;
+export declare function rgxTokenType(value: unknown, recognizeClass?: boolean, acceptJSON?: boolean): t.RGXTokenType;
 export declare function rgxTokenFromType<T extends t.RGXTokenTypeGuardInput>(type: T, value: t.RGXToken): t.RGXTokenFromType<T>;
 export declare function rgxTokenTypeToFlat(type: t.RGXTokenType): t.RGXTokenTypeFlat;
 export declare function rgxTokenTypeGuardInputToFlat(type: t.RGXTokenTypeGuardInput): t.RGXTokenTypeFlat | null;
-export declare function isRGXToken<T extends t.RGXTokenTypeGuardInput = null>(value: unknown, type?: T, matchLength?: boolean): value is t.RGXTokenFromType<T>;
-export declare function assertRGXToken<T extends t.RGXTokenTypeGuardInput = null>(value: unknown, type?: T, matchLength?: boolean): asserts value is t.RGXTokenFromType<T>;
-export declare function isRGXGroupedToken(value: unknown, contentCheck?: boolean): value is t.RGXGroupedToken;
-export declare function assertRGXGroupedToken(value: unknown, contentCheck?: boolean): asserts value is t.RGXGroupedToken;
+export declare function isRGXToken<T extends t.RGXTokenTypeGuardInput = null, J extends boolean = true>(value: unknown, type?: T, matchLength?: boolean, acceptJSON?: J): value is t.RGXTokenFromType<T, J>;
+export declare function assertRGXToken<T extends t.RGXTokenTypeGuardInput = null, J extends boolean = true>(value: unknown, type?: T, matchLength?: boolean, acceptJSON?: J): asserts value is t.RGXTokenFromType<T, J>;
+export declare function isRGXGroupedToken(value: unknown, contentCheck?: boolean, acceptJSON?: boolean): value is t.RGXGroupedToken;
+export declare function assertRGXGroupedToken(value: unknown, contentCheck?: boolean, acceptJSON?: boolean): asserts value is t.RGXGroupedToken;
 export declare function isValidRegexString(value: string): value is t.ValidRegexString;
 export declare function assertValidRegexString(value: string): asserts value is t.ValidRegexString;
+export declare function castValidRegexString(value: string): t.ValidRegexString;
 export declare function isValidVanillaRegexFlags(value: string): value is t.ValidVanillaRegexFlags;
 export declare function assertValidVanillaRegexFlags(value: string): asserts value is t.ValidVanillaRegexFlags;
+export declare function castValidVanillaRegexFlags(value: string): t.ValidVanillaRegexFlags;
 export declare function isValidIdentifier(value: string): value is t.ValidIdentifier;
 export declare function assertValidIdentifier(value: string): asserts value is t.ValidIdentifier;
+export declare function castValidIdentifier(value: string): t.ValidIdentifier;
 export declare function isValidRegexLocalizableFlagDiff(value: string): value is t.ValidRegexLocalizableFlagDiff;
 export declare function assertValidRegexLocalizableFlagDiff(value: string): asserts value is t.ValidRegexLocalizableFlagDiff;
+export declare function castValidRegexLocalizableFlagDiff(value: string): t.ValidRegexLocalizableFlagDiff;
 export declare function isValidRegexLocalizableFlags(value: string): value is t.ValidRegexLocalizableFlags;
 export declare function assertValidRegexLocalizableFlags(value: string): asserts value is t.ValidRegexLocalizableFlags;
+export declare function castValidRegexLocalizableFlags(value: string): t.ValidRegexLocalizableFlags;