@ptolemy2002/rgx 13.4.0 → 13.6.0

package/dist/class/group.d.ts

@@ -4,10 +4,12 @@ import { CloneDepth } from "@ptolemy2002/immutability-utils";
 export type RGXGroupTokenArgs = {
     name?: string | null;
     capturing?: boolean;
+    flags?: string;
 };
 export declare class RGXGroupToken extends RGXClassToken {
     tokens: RGXTokenCollection;
     _name: string | null;
+    _flags: string;
     _capturing: boolean;
     static check: (value: unknown) => value is RGXGroupToken;
     static assert: (value: unknown) => asserts value is RGXGroupToken;
@@ -15,9 +17,11 @@ export declare class RGXGroupToken extends RGXClassToken {
     set name(value: string | null);
     get capturing(): boolean;
     set capturing(value: boolean);
+    get flags(): string;
+    set flags(value: string);
     get rgxIsGroup(): true;
     get rgxGroupWrap(): false;
-    constructor({ name, capturing }?: RGXGroupTokenArgs, tokens?: RGXTokenCollectionInput);
+    constructor({ name, capturing, flags }?: RGXGroupTokenArgs, tokens?: RGXTokenCollectionInput);
     toRgx(): RegExp;
     clone(depth?: CloneDepth): RGXGroupToken;
 }

package/dist/class/group.js

@@ -25,6 +25,13 @@ class RGXGroupToken extends base_1.RGXClassToken {
             this.name = null; // Non-capturing groups cannot have names
         this._capturing = value;
     }
+    get flags() {
+        return this._flags;
+    }
+    set flags(value) {
+        (0, typeGuards_1.assertValidRegexLocalizableFlags)(value);
+        this._flags = value;
+    }
     get rgxIsGroup() {
         return true;
     }
@@ -32,12 +39,14 @@ class RGXGroupToken extends base_1.RGXClassToken {
         // When this token is resolved, it will wrap itself in a group, so we don't want the resolver to group wrap it again.
         return false;
     }
-    constructor({ name = null, capturing = true } = {}, tokens = []) {
+    constructor({ name = null, capturing = true, flags = '' } = {}, tokens = []) {
         super();
         this._name = null;
+        this._flags = '';
         this._capturing = true;
         this.name = name;
         this.capturing = capturing;
+        this.flags = flags;
         if (tokens instanceof collection_1.RGXTokenCollection && tokens.mode === 'union')
             this.tokens = new collection_1.RGXTokenCollection(tokens, 'concat');
         else
@@ -46,18 +55,29 @@ class RGXGroupToken extends base_1.RGXClassToken {
     toRgx() {
         // The collection token doesn't group itself, so this is safe.
         let result = this.tokens.toRgx().source;
-        if (this.name !== null)
+        const hasFlags = this.flags.length > 0;
+        // This will return the flags that are not present in the flags variable, preceded by a "-" if there are any.
+        const flagsNotPresent = (0, internal_1.localizableVanillaRegexFlagDiff)("ims", this.flags);
+        if (this.name !== null) {
             result = `(?<${this.name}>${result})`;
-        else if (!this.capturing)
-            result = `(?:${result})`;
-        else
+        }
+        else if (!this.capturing) {
+            if (!hasFlags)
+                result = `(?:${result})`;
+            else
+                result = `(?${this.flags}${flagsNotPresent}:${result})`;
+        }
+        else {
             result = `(${result})`;
+        }
+        if ((this.name !== null || this.capturing) && hasFlags)
+            result = `(?${this.flags}${flagsNotPresent}:${result})`;
         return (0, utils_1.createRegex)(result);
     }
     clone(depth = "max") {
         if (depth === 0)
             return this;
-        return new RGXGroupToken({ name: this.name, capturing: this._capturing }, this.tokens.clone((0, immutability_utils_1.depthDecrement)(depth, 1)));
+        return new RGXGroupToken({ name: this.name, capturing: this._capturing, flags: this.flags }, this.tokens.clone((0, immutability_utils_1.depthDecrement)(depth, 1)));
     }
 }
 exports.RGXGroupToken = RGXGroupToken;

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

package/dist/errors/index.d.ts

@@ -22,3 +22,5 @@ export * from './invalidWalker';
 export * from './invalidPart';
 export * from './notDirectRegexp';
 export * from './currentTokenNotFound';
+export * from './invalidRegexLocalizableFlagDiff';
+export * from './invalidRegexLocalizableFlags';

package/dist/errors/index.js

@@ -38,3 +38,5 @@ __exportStar(require("./invalidWalker"), exports);
 __exportStar(require("./invalidPart"), exports);
 __exportStar(require("./notDirectRegexp"), exports);
 __exportStar(require("./currentTokenNotFound"), exports);
+__exportStar(require("./invalidRegexLocalizableFlagDiff"), exports);
+__exportStar(require("./invalidRegexLocalizableFlags"), exports);

package/dist/errors/invalidRegexLocalizableFlagDiff.d.ts

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

package/dist/errors/invalidRegexLocalizableFlagDiff.js

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

package/dist/errors/invalidRegexLocalizableFlags.d.ts

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

package/dist/errors/invalidRegexLocalizableFlags.js

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

package/dist/internal/index.d.ts

@@ -3,3 +3,4 @@ export * from "./taggedTemplateToArray";
 export * from "./isConstructor";
 export * from "./getProxy";
 export * from "./assureAcceptance";
+export * from "./localizableVanillaRegexFlagDiff";

package/dist/internal/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./taggedTemplateToArray"), exports);
 __exportStar(require("./isConstructor"), exports);
 __exportStar(require("./getProxy"), exports);
 __exportStar(require("./assureAcceptance"), exports);
+__exportStar(require("./localizableVanillaRegexFlagDiff"), exports);

package/dist/internal/localizableVanillaRegexFlagDiff.d.ts

@@ -0,0 +1,2 @@
+import * as t from "../types";
+export declare function localizableVanillaRegexFlagDiff(prev: string, next: string): t.ValidRegexLocalizableFlagDiff;

package/dist/internal/localizableVanillaRegexFlagDiff.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localizableVanillaRegexFlagDiff = localizableVanillaRegexFlagDiff;
+function localizableVanillaRegexFlagDiff(prev, next) {
+    // Remove anything other than the "ims" flags from both strings, as
+    // other flags are not localizable (including our custom flags).
+    prev = prev.replaceAll(/[^ims]/g, '');
+    next = next.replaceAll(/[^ims]/g, '');
+    // Format <added flags>-<removed flags>
+    const added = [...new Set(next.split(''))].filter(flag => !prev.includes(flag)).join('');
+    const removed = [...new Set(prev.split(''))].filter(flag => !next.includes(flag)).join('');
+    if (added === '' && removed === '')
+        return '';
+    if (removed === '')
+        return `${added}`;
+    return `${added}-${removed}`;
+}

package/dist/resolve.js

@@ -39,25 +39,12 @@ const class_1 = require("./class");
 const e = __importStar(require("./errors"));
 const ExtRegExp_1 = require("./ExtRegExp");
 const tg = __importStar(require("./typeGuards"));
+const internal_1 = require("./internal");
 function escapeRegex(value) {
     const result = value.replaceAll(/[\-\^\$.*+?^${}()|[\]\\]/g, '\\$&');
     tg.assertValidRegexString(result);
     return result;
 }
-function localizableVanillaRegexFlagDiff(prev, next) {
-    // Remove anything other than the "ims" flags from both strings, as
-    // other flags are not localizable (including our custom flags).
-    prev = prev.replaceAll(/[^ims]/g, '');
-    next = next.replaceAll(/[^ims]/g, '');
-    // Format <added flags>-<removed flags>
-    const added = [...new Set(next.split(''))].filter(flag => !prev.includes(flag)).join('');
-    const removed = [...new Set(prev.split(''))].filter(flag => !next.includes(flag)).join('');
-    if (added === '' && removed === '')
-        return '';
-    if (removed === '')
-        return `${added}`;
-    return `${added}-${removed}`;
-}
 function hasParenErrors(pattern) {
     let depth = 0;
     let charClassDepth = 0;
@@ -95,7 +82,7 @@ function resolveRGXToken(token, { groupWrap = true, topLevel = true, currentFlag
         if (tg.isRGXNoOpToken(token))
             return '';
         if (tg.isRGXLiteralToken(token)) {
-            const localizableFlagDiff = localizableVanillaRegexFlagDiff(currentFlags, token.flags);
+            const localizableFlagDiff = (0, internal_1.localizableVanillaRegexFlagDiff)(currentFlags, token.flags);
             currentFlags = token.flags;
             if (!localizableFlagDiff) {
                 if (groupWrap)

package/dist/typeGuards.d.ts

@@ -24,3 +24,7 @@ export declare function isValidVanillaRegexFlags(value: string): value is t.Vali
 export declare function assertValidVanillaRegexFlags(value: string): asserts value is 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 isValidRegexLocalizableFlagDiff(value: string): value is t.ValidRegexLocalizableFlagDiff;
+export declare function assertValidRegexLocalizableFlagDiff(value: string): asserts value is t.ValidRegexLocalizableFlagDiff;
+export declare function isValidRegexLocalizableFlags(value: string): value is t.ValidRegexLocalizableFlags;
+export declare function assertValidRegexLocalizableFlags(value: string): asserts value is t.ValidRegexLocalizableFlags;

package/dist/typeGuards.js

@@ -61,6 +61,10 @@ exports.isValidVanillaRegexFlags = isValidVanillaRegexFlags;
 exports.assertValidVanillaRegexFlags = assertValidVanillaRegexFlags;
 exports.isValidIdentifier = isValidIdentifier;
 exports.assertValidIdentifier = assertValidIdentifier;
+exports.isValidRegexLocalizableFlagDiff = isValidRegexLocalizableFlagDiff;
+exports.assertValidRegexLocalizableFlagDiff = assertValidRegexLocalizableFlagDiff;
+exports.isValidRegexLocalizableFlags = isValidRegexLocalizableFlags;
+exports.assertValidRegexLocalizableFlags = assertValidRegexLocalizableFlags;
 const e = __importStar(require("./errors"));
 const is_callable_1 = __importDefault(require("is-callable"));
 const internal_1 = require("./internal");
@@ -295,3 +299,21 @@ function assertValidIdentifier(value) {
         throw new e.RGXInvalidIdentifierError("Invalid identifier", value);
     }
 }
+function isValidRegexLocalizableFlagDiff(value) {
+    if (value === '')
+        return true;
+    return /^[ims]+(-[ims]+)?$/.test(value);
+}
+function assertValidRegexLocalizableFlagDiff(value) {
+    if (!isValidRegexLocalizableFlagDiff(value)) {
+        throw new e.RGXInvalidRegexLocalizableFlagDiffError("Invalid localizable flag diff", value);
+    }
+}
+function isValidRegexLocalizableFlags(value) {
+    return /^[ims]*$/.test(value);
+}
+function assertValidRegexLocalizableFlags(value) {
+    if (!isValidRegexLocalizableFlags(value)) {
+        throw new e.RGXInvalidRegexLocalizableFlagsError("Invalid localizable flags", value);
+    }
+}

package/dist/types.d.ts

@@ -50,6 +50,12 @@ export type ValidRegexFlags = Branded<string, [ValidRegexFlagsBrandSymbol]> | Va
 export declare const validIdentifierSymbol: unique symbol;
 export type ValidIdentifierBrandSymbol = typeof validIdentifierSymbol;
 export type ValidIdentifier = Branded<string, [ValidIdentifierBrandSymbol]>;
+export declare const validRegexLocalizableFlagsSymbol: unique symbol;
+export type ValidRegexLocalizableFlagsBrandSymbol = typeof validRegexLocalizableFlagsSymbol;
+export type ValidRegexLocalizableFlags = Branded<string, [ValidRegexLocalizableFlagsBrandSymbol]>;
+export declare const validRegexLocalizableFlagDiffSymbol: unique symbol;
+export type ValidRegexLocalizableFlagDiffBrandSymbol = typeof validRegexLocalizableFlagDiffSymbol;
+export type ValidRegexLocalizableFlagDiff = Branded<string, [ValidRegexLocalizableFlagDiffBrandSymbol]>;
 export type RGXOptions = {
     multiline?: boolean;
     verbatim?: boolean;

package/dist/types.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validIdentifierSymbol = exports.validRegexFlagsSymbol = exports.validVanillaRegexFlagsSymbol = exports.validRegexSymbol = void 0;
+exports.validRegexLocalizableFlagDiffSymbol = exports.validRegexLocalizableFlagsSymbol = exports.validIdentifierSymbol = exports.validRegexFlagsSymbol = exports.validVanillaRegexFlagsSymbol = exports.validRegexSymbol = void 0;
 exports.validRegexSymbol = Symbol('rgx.ValidRegex');
 exports.validVanillaRegexFlagsSymbol = Symbol('rgx.ValidVanillaRegexFlags');
 exports.validRegexFlagsSymbol = Symbol('rgx.ValidRegexFlags');
 exports.validIdentifierSymbol = Symbol('rgx.ValidIdentifier');
+exports.validRegexLocalizableFlagsSymbol = Symbol('rgx.ValidRegexLocalizableFlags');
+exports.validRegexLocalizableFlagDiffSymbol = Symbol('rgx.ValidRegexLocalizableFlagDiff');

package/dist/utils/createRGXBounds.d.ts

@@ -3,5 +3,6 @@ export type CreateRGXBoundsOptions = {
     flags?: string;
     anchorStart?: boolean;
     anchorEnd?: boolean;
+    inner?: boolean;
 };
 export declare function createRGXBounds(positive: RGXToken, negative: RGXToken, options?: CreateRGXBoundsOptions | string | boolean): [RGXConvertibleToken, RGXConvertibleToken];

package/dist/utils/createRGXBounds.js

@@ -27,10 +27,14 @@ function createRGXBounds(positive, negative, options = {}) {
         options = { flags: options };
     else if (typeof options === "boolean")
         options = { anchorStart: options, anchorEnd: options };
-    const { flags = "", anchorStart = true, anchorEnd = true } = options;
+    const { flags = "", anchorStart = true, anchorEnd = true, inner = true } = options;
     const resolvedPositive = (0, resolve_1.resolveRGXToken)(convertNoGroupWrap(positive), { groupWrap: false, currentFlags: flags });
     const resolvedNegative = (0, resolve_1.resolveRGXToken)(convertNoGroupWrap(negative), { groupWrap: false, currentFlags: flags });
-    const startBound = convertToBound((0, createRegex_1.createRegex)(`(?<=${resolvedNegative}${anchorStart ? "|^" : ""})(?=${resolvedPositive})`, flags, true));
-    const endBound = convertToBound((0, createRegex_1.createRegex)(`(?<=${resolvedPositive})(?=${resolvedNegative}${anchorEnd ? "|$" : ""})`, flags, true));
+    const startLookbehind = `(?<=${resolvedNegative}${anchorStart ? "|^" : ""})`;
+    const startLookahead = inner ? `(?=${resolvedPositive})` : "";
+    const startBound = convertToBound((0, createRegex_1.createRegex)(`${startLookbehind}${startLookahead}`, flags, true));
+    const endLookbehind = inner ? `(?<=${resolvedPositive})` : "";
+    const endLookahead = `(?=${resolvedNegative}${anchorEnd ? "|$" : ""})`;
+    const endBound = convertToBound((0, createRegex_1.createRegex)(`${endLookbehind}${endLookahead}`, flags, true));
     return [startBound, endBound];
 }

package/package.json

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