@ptolemy2002/rgx 12.8.0 → 13.0.1

package/README.md

@@ -20,6 +20,7 @@ Because there is so much to document, it has been broken up into multiple files.
   - [regexWithFlags](./docs/util/regexWithFlags.md) - The `regexWithFlags` function, which creates a new regular expression with the same source as a given regular expression but with different flags.
   - [createRegex](./docs/util/createRegex.md) - The `createRegex` function, which safely constructs a `RegExp` or `ExtRegExp` from a pattern string, converting `SyntaxError` into `RGXInvalidRegexStringError`.
   - [createRGXClassGuardFunction](./docs/util/createRGXClassGuardFunction.md) - The `createRGXClassGuardFunction` and `createAssertRGXClassGuardFunction` utilities for creating type guard and assertion functions for class instances.
+  - [createRGXBounds](./docs/util/createRGXBounds.md) - The `createRGXBounds` function, which creates a pair of zero-width boundary tokens representing the start and end of a region delimited by two patterns.
 - `class` - A directory containing documentation for all classes in the library.
   - [collection](./docs/class/collection.md) - The `RGXTokenCollection` class, which is a collection of tokens.
   - [RGXError](./docs/class/RGXError.md) - Details on all custom error classes and the base `RGXError` class.

package/dist/collection.js

@@ -28,7 +28,7 @@ class RGXTokenCollection {
         if (this.mode === 'union') {
             // The RegExp will already be wrapped with resolveRGXToken,
             // so we don't need to wrap it again here.
-            pattern = (0, resolve_1.resolveRGXToken)(this.tokens, false);
+            pattern = (0, resolve_1.resolveRGXToken)(this.tokens, { groupWrap: false });
         }
         else {
             pattern = (0, concat_1.rgxConcat)(this.tokens);

package/dist/concat.js

@@ -7,7 +7,7 @@ const resolve_1 = require("./resolve");
 // Wrapper for letting an array of tokens be resolved as a concatenation instead of a union.
 function rgxConcat(tokens, groupWrap = true, currentFlags = '') {
     (0, ExtRegExp_1.assertValidRegexFlags)(currentFlags);
-    const result = tokens.map(t => (0, resolve_1.resolveRGXToken)(t, groupWrap, true, currentFlags)).join('');
+    const result = tokens.map(t => (0, resolve_1.resolveRGXToken)(t, { groupWrap, currentFlags })).join('');
     (0, internal_1.assureAcceptance)(tokens, currentFlags);
     return result;
 }

package/dist/constants.d.ts

@@ -1,3 +1,4 @@
+import { RGXClassToken } from "./class";
 import { RGXToken } from "./types";
 export declare const RGX_PREDEFINED_CONSTANTS: {
     readonly newline: "\n";
@@ -103,6 +104,15 @@ export declare const RGX_PREDEFINED_CONSTANTS: {
         readonly rgxGroupWrap: false;
         readonly toRgx: () => RegExp;
     };
+    readonly "non-newline-whitespace": {
+        readonly rgxIsGroup: true;
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "non-newline-whitespace-block": {
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
     readonly "vertical-whitespace": {
         readonly rgxGroupWrap: false;
         readonly toRgx: () => RegExp;
@@ -137,6 +147,6 @@ export declare function listRGXConstants(): string[];
 export declare function hasRGXConstant(name: RGXConstantName): boolean;
 export declare function assertHasRGXConstant(name: RGXConstantName): void;
 export declare function assertNotHasRGXConstant(name: RGXConstantName): void;
-export declare function defineRGXConstant(name: RGXConstantName, value: RGXToken): RegExp | import("./types").RGXConvertibleToken | RGXToken[];
-export declare function rgxConstant(name: RGXConstantName): RGXToken;
+export declare function defineRGXConstant(name: RGXConstantName, value: RGXToken): RGXClassToken;
+export declare function rgxConstant(name: RGXConstantName): RGXClassToken;
 export declare function deleteRGXConstant(name: RGXConstantName): void;

package/dist/constants.js

@@ -10,7 +10,6 @@ exports.rgxConstant = rgxConstant;
 exports.deleteRGXConstant = deleteRGXConstant;
 const class_1 = require("./class");
 const errors_1 = require("./errors");
-const typeGuards_1 = require("./typeGuards");
 const rgxConstants = {};
 exports.RGX_PREDEFINED_CONSTANTS = {
     // Control Characters
@@ -63,7 +62,7 @@ exports.RGX_PREDEFINED_CONSTANTS = {
         rgxIsRepeatable: false,
         toRgx() {
             // Make sure there is a non-word character before and a word character after
-            return /(?<=\W)(?=\w)/;
+            return /(?<=\W|^)(?=\w)/;
         }
     },
     "word-bound-end": {
@@ -71,7 +70,7 @@ exports.RGX_PREDEFINED_CONSTANTS = {
         rgxIsRepeatable: false,
         toRgx() {
             // Make sure there is a word character before and a non-word character after
-            return /(?<=\w)(?=\W)/;
+            return /(?<=\w)(?=\W|$)/;
         }
     },
     // Character Sets
@@ -126,6 +125,15 @@ exports.RGX_PREDEFINED_CONSTANTS = {
         rgxGroupWrap: false,
         toRgx() { return /\S/; }
     },
+    "non-newline-whitespace": {
+        rgxIsGroup: true,
+        rgxGroupWrap: false,
+        toRgx() { return /[^\n\S]/; }
+    },
+    "non-newline-whitespace-block": {
+        rgxGroupWrap: false,
+        toRgx() { return /[^\n\S]+/; }
+    },
     "vertical-whitespace": {
         rgxGroupWrap: false,
         toRgx() { return /\v/; }
@@ -180,8 +188,7 @@ function assertNotHasRGXConstant(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;
+    rgxConstants[name] = class_1.RGXClassToken.check(value) ? value : (0, class_1.rgxClassWrapper)(value);
     return rgxConstants[name];
 }
 function rgxConstant(name) {

package/dist/index.d.ts

@@ -1,6 +1,10 @@
 import * as t from "./types";
 import { ExtRegExp } from "./ExtRegExp";
 import { RGXTokenOrPart, RGXWalker } from "./walker";
+export declare function rgxa(tokens: t.RGXToken[], flags?: string): ExtRegExp;
+export default function rgx(flags?: string, { multiline, verbatim }?: t.RGXOptions): (strings: TemplateStringsArray, ...tokens: t.RGXToken[]) => ExtRegExp;
+export declare function rgxwa<R = unknown, S = unknown, T = unknown>(source: string, tokens: RGXTokenOrPart<R, S, T>[], options?: Omit<t.RGXWOptions<R, S>, "multiline">): RGXWalker<R, S>;
+export declare function rgxw<R = unknown, S = unknown, T = unknown>(source: string, { multiline, verbatim, ...options }?: t.RGXWOptions<R, S>): (strings: TemplateStringsArray, ...tokens: RGXTokenOrPart<R, S, T>[]) => RGXWalker<R, S>;
 export * from "./errors";
 export * from "./types";
 export * from "./typeGuards";
@@ -15,7 +19,3 @@ export * from "./clone";
 export * from "./constants";
 export * from "./walker";
 export * from "./lexer";
-export declare function rgxa(tokens: t.RGXToken[], flags?: string): ExtRegExp;
-export default function rgx(flags?: string, { multiline, verbatim }?: t.RGXOptions): (strings: TemplateStringsArray, ...tokens: t.RGXToken[]) => ExtRegExp;
-export declare function rgxwa<R = unknown, S = unknown, T = unknown>(source: string, tokens: RGXTokenOrPart<R, S, T>[], options?: Omit<t.RGXWOptions<R, S>, "multiline">): RGXWalker<R, S>;
-export declare function rgxw<R = unknown, S = unknown, T = unknown>(source: string, { multiline, verbatim, ...options }?: t.RGXWOptions<R, S>): (strings: TemplateStringsArray, ...tokens: RGXTokenOrPart<R, S, T>[]) => RGXWalker<R, S>;

package/dist/index.js

@@ -21,46 +21,48 @@ exports.rgxw = rgxw;
 const class_1 = require("./class");
 const flag_transformer_1 = require("./flag-transformer");
 const concat_1 = require("./concat");
-const internal_1 = require("./internal");
+const assureAcceptance_1 = require("./internal/assureAcceptance");
+const taggedTemplateToArray_1 = require("./internal/taggedTemplateToArray");
 const ExtRegExp_1 = require("./ExtRegExp");
 const walker_1 = require("./walker");
-const utils_1 = require("./utils");
-__exportStar(require("./errors"), exports);
-__exportStar(require("./types"), exports);
-__exportStar(require("./typeGuards"), exports);
-__exportStar(require("./collection"), exports);
-__exportStar(require("./class"), exports);
-__exportStar(require("./resolve"), exports);
-__exportStar(require("./concat"), exports);
-__exportStar(require("./utils"), exports);
-__exportStar(require("./ExtRegExp"), exports);
-__exportStar(require("./flag-transformer"), exports);
-__exportStar(require("./clone"), exports);
-__exportStar(require("./constants"), exports);
-__exportStar(require("./walker"), exports);
-__exportStar(require("./lexer"), exports);
+const createRegex_1 = require("./utils/createRegex");
 // Call this for certain class methods to work correctly
 (0, class_1.rgxClassInit)();
 // Call this for our custom flags to work correctly
 (0, flag_transformer_1.registerCustomFlagTransformers)();
 function rgxa(tokens, flags = '') {
     (0, ExtRegExp_1.assertValidRegexFlags)(flags);
-    (0, internal_1.assureAcceptance)(tokens, flags);
+    (0, assureAcceptance_1.assureAcceptance)(tokens, flags);
     const pattern = (0, concat_1.rgxConcat)(tokens, true, flags);
-    return (0, utils_1.createRegex)(pattern, flags, true);
+    return (0, createRegex_1.createRegex)(pattern, flags, true);
 }
 function rgx(flags = '', { multiline = true, verbatim = true } = {}) {
     return (strings, ...tokens) => {
         // It is safe to assert the result because we know there will be no parts passed in here.
-        return rgxa((0, internal_1.rgxTaggedTemplateToArray)(strings, tokens, multiline, verbatim), flags);
+        return rgxa((0, taggedTemplateToArray_1.rgxTaggedTemplateToArray)(strings, tokens, multiline, verbatim), flags);
     };
 }
 function rgxwa(source, tokens, options = {}) {
-    (0, internal_1.assureAcceptance)(tokens.map(t => walker_1.RGXPart.check(t) ? t.token : t), '');
+    (0, assureAcceptance_1.assureAcceptance)(tokens.map(t => walker_1.RGXPart.check(t) ? t.token : t), '');
     return new walker_1.RGXWalker(source, tokens, options);
 }
 function rgxw(source, { multiline = true, verbatim = true, ...options } = {}) {
     return (strings, ...tokens) => {
-        return rgxwa(source, (0, internal_1.rgxTaggedTemplateToArray)(strings, tokens, multiline, verbatim), options);
+        return rgxwa(source, (0, taggedTemplateToArray_1.rgxTaggedTemplateToArray)(strings, tokens, multiline, verbatim), options);
     };
 }
+// Do all exports after to avoid circular dependencies issues.
+__exportStar(require("./errors"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./typeGuards"), exports);
+__exportStar(require("./collection"), exports);
+__exportStar(require("./class"), exports);
+__exportStar(require("./resolve"), exports);
+__exportStar(require("./concat"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./ExtRegExp"), exports);
+__exportStar(require("./flag-transformer"), exports);
+__exportStar(require("./clone"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./walker"), exports);
+__exportStar(require("./lexer"), exports);

package/dist/resolve.d.ts

@@ -1,3 +1,8 @@
 import * as t from "./types";
+export type ResolveRGXTokenOptions = {
+    groupWrap?: boolean;
+    topLevel?: boolean;
+    currentFlags?: string;
+};
 export declare function escapeRegex(value: string): t.ValidRegexString;
-export declare function resolveRGXToken(token: t.RGXToken, groupWrap?: boolean, topLevel?: boolean, currentFlags?: string): t.ValidRegexString;
+export declare function resolveRGXToken(token: t.RGXToken, { groupWrap, topLevel, currentFlags }?: ResolveRGXTokenOptions): t.ValidRegexString;

package/dist/resolve.js

@@ -58,7 +58,7 @@ function localizableVanillaRegexFlagDiff(prev, next) {
         return `${added}`;
     return `${added}-${removed}`;
 }
-function resolveRGXToken(token, groupWrap = true, topLevel = true, currentFlags = '') {
+function resolveRGXToken(token, { groupWrap = true, topLevel = true, currentFlags = '' } = {}) {
     (0, ExtRegExp_1.assertValidRegexFlags)(currentFlags);
     const innerResolve = () => {
         if (tg.isRGXNoOpToken(token))
@@ -86,7 +86,7 @@ function resolveRGXToken(token, groupWrap = true, topLevel = true, currentFlags
                 return String(token.toRgx());
             // The top-level group-wrapping preference propogates to a direct convertible token, but after that
             // the preference falls back to true whenever a token doesn't explicitly specify a preference.
-            return resolveRGXToken(token.toRgx(), token.rgxGroupWrap ?? (topLevel ? groupWrap : true), false, currentFlags);
+            return resolveRGXToken(token.toRgx(), { groupWrap: token.rgxGroupWrap ?? (topLevel ? groupWrap : true), topLevel: false, currentFlags });
         }
         // Interpret arrays as unions
         if (tg.isRGXArrayToken(token, false)) {
@@ -97,11 +97,11 @@ function resolveRGXToken(token, groupWrap = true, topLevel = true, currentFlags
                 token = [...(0, class_1.removeRgxUnionDuplicates)(...token)];
                 // Don't preserve group wrapping preference for the recursive calls
                 if (groupWrap)
-                    return '(?:' + token.map(t => resolveRGXToken(t, true, false, currentFlags)).join('|') + ')';
+                    return '(?:' + token.map(t => resolveRGXToken(t, { groupWrap: true, topLevel: false, currentFlags })).join('|') + ')';
                 else
-                    return token.map(t => resolveRGXToken(t, true, false, currentFlags)).join('|');
+                    return token.map(t => resolveRGXToken(t, { groupWrap: true, topLevel: false, currentFlags })).join('|');
             }
-            return resolveRGXToken(token[0], true, false, currentFlags);
+            return resolveRGXToken(token[0], { groupWrap: true, topLevel: false, currentFlags });
         }
         // Ignoring this line since it should be impossible to reach if the types are correct, but we need it to satisfy the return type
         /* istanbul ignore next */

package/dist/utils/createRGXBounds.d.ts

@@ -0,0 +1,2 @@
+import { RGXConvertibleToken, RGXToken } from "../types";
+export declare function createRGXBounds(before: RGXToken, after: RGXToken, flags?: string): [RGXConvertibleToken, RGXConvertibleToken];

package/dist/utils/createRGXBounds.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRGXBounds = createRGXBounds;
+const typeGuards_1 = require("../typeGuards");
+const createRegex_1 = require("./createRegex");
+const resolve_1 = require("../resolve");
+function convertNoGroupWrap(token) {
+    const boundPart = { rgxGroupWrap: false };
+    if ((0, typeGuards_1.isRGXConvertibleToken)(token)) {
+        return { ...token, ...boundPart };
+    }
+    else {
+        return token;
+    }
+}
+function convertToBound(token) {
+    // Bounds are not groups themselves, cannot be repeated (since they don't consume characters)
+    // and should never be group wrapped
+    const boundPart = { rgxGroupWrap: false, rgxIsGroup: false, rgxIsRepeatable: false };
+    return {
+        ...boundPart,
+        toRgx: () => token
+    };
+}
+function createRGXBounds(before, after, flags = "") {
+    const resolvedBefore = (0, resolve_1.resolveRGXToken)(convertNoGroupWrap(before), { groupWrap: false, currentFlags: flags });
+    const resolvedAfter = (0, resolve_1.resolveRGXToken)(convertNoGroupWrap(after), { groupWrap: false, currentFlags: flags });
+    const startBound = convertToBound((0, createRegex_1.createRegex)(`(?<=${resolvedBefore})(?=${resolvedAfter})`, flags, true));
+    const endBound = convertToBound((0, createRegex_1.createRegex)(`(?<=${resolvedAfter})(?=${resolvedBefore})`, flags, true));
+    return [startBound, endBound];
+}

package/dist/utils/index.d.ts

@@ -4,3 +4,4 @@ export * from "./regexWithFlags";
 export * from "./normalizeRegexFlags";
 export * from "./createRGXClassGuardFunction";
 export * from "./createRegex";
+export * from "./createRGXBounds";

package/dist/utils/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./regexWithFlags"), exports);
 __exportStar(require("./normalizeRegexFlags"), exports);
 __exportStar(require("./createRGXClassGuardFunction"), exports);
 __exportStar(require("./createRegex"), exports);
+__exportStar(require("./createRGXBounds"), exports);

package/package.json

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