js-dev-tool 1.0.16 → 1.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-dev-tool",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "bin": {
     "jstool": "tools.js"
   },
@@ -35,6 +35,7 @@
     "!tool-lib/cjbm-*",
     "!scripts/unzip.ts",
     "!scripts/bin",
+    "!regex-test.ts",
     "!extras/npm",
     "!/**/*.png",
     "!tool.sh",

package/regex.d.ts

@@ -12,15 +12,44 @@ declare global {
   interface RegExp/* extends TypedRegExp<string, string>*/ {
     /**
      * Executes a search on a string using a regular expression pattern, and returns an array containing the results of that search.
-     * @param string The String object or string literal on which to perform the search.
+     * @template {string} P
+     * @template {string} F
+     * @param {TypedRegExp<P, F>} this The regular expression object.
+     * @param {string} str The String object or string literal on which to perform the search.
+     * @returns {RegExpExecArrayFixed< this > | null} An array of results or null if no match is found.
      */
-    exec<const P extends string, const F extends string = "">(this: TypedRegExp<P, F>, string: string): RegExpExecArrayFixed< this > | null;
+    exec<const P extends string, const F extends string = "">(this: TypedRegExp<P, F>, str: string): RegExpExecArrayFixed< this > | null;
+  }
+  interface String {
+    /**
+     * Replaces occurrences of a pattern in the string with a specified replacement.
+     * @template {RegExp | string} SV
+     * @param searchValue A regular expression object.
+     * @param replaceValue A string or a function to create the new substring.
+     */
+    replace<SV extends RegExp | string>(this: string, searchValue: SV, replaceValue: ReplacerFunctionSignature<SV>): string;
   }
   interface RegExpConstructor {
+    /**
+     * Creates a typed RegExp object with literal types for the pattern and flags.
+     * @template {string} P
+     * @template {string} F
+     * @param {P} pattern The regular expression pattern.
+     * @param {F} [flags] The flags for the regular expression.
+     * @returns {RegExp & { readonly source: P; readonly flags: F }} A typed RegExp object.
+     */
     new <const P extends string, const F extends string = "">(pattern: P, flags?: F): RegExp & {
       readonly source: P;
       readonly flags: F;
     };
+    /**
+     * Creates a typed RegExp object with literal types for the pattern and flags.
+     * @template {string} P
+     * @template {string} F
+     * @param {P} pattern The regular expression pattern.
+     * @param {F} [flags] The flags for the regular expression.
+     * @returns {RegExp & { readonly source: P; readonly flags: F }} A typed RegExp object.
+     */
     <const P extends string, const F extends string = "">(pattern: P, flags?: F): RegExp & {
       readonly source: P;
       readonly flags: F;
@@ -33,15 +62,19 @@ declare global {
 //                                   Basics
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 */
+export type Brand<Tag extends string> = {
+  [k in Tag]: true;
+};
+export type TypedRegExpBrand = Brand<"__TypedRegExp">;
+export type TypedRegExp<const P extends string, const F extends string = ""> = RegExp & {
+  readonly source: P;
+  readonly flags: F;
+} & TypedRegExpBrand;
 /**
  * Extracts the literal type from the source property of a RegExp.
  * @template R - A RegExp type.
  */
-export type ReSource<R extends RegExp> = R extends RegExp & { readonly source: infer T } ? T : never;
-export type TypedRegExp<const P extends string, const F extends string = ""> = RegExp & {
-  readonly source: P;
-  readonly flags: F;
-};
+export type RegExpSource<R extends RegExp> = R extends RegExp & { readonly source: infer T } ? T : never;
 export declare function createRegExp<
   const P extends string,
   const F extends string = ""
@@ -71,10 +104,15 @@ export type ExtractGroupNames<S extends string> =
  * @template R - A RegExp type.
  * @date 2025/12/24 14:46:30 - It may be possible to extract the group name accurately (?)
  */
-export type ReGroups<R extends RegExp> = R extends (/*RegExp &*/ { readonly source: infer T })
+export type RegExpNamedGroups<R extends RegExp> = R extends { readonly source: infer T }
  ? {
   [K in ExtractGroupNames<T>]?: string;
 } : never;
+/*!
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//                               Capture Groups
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
 /**
  * Preprocesses escape sequences in a string pattern by replacing escaped backslashes and characters.
  * 
@@ -115,10 +153,10 @@ export type CountCaptureGroups<
  */
 export type RegExpExecArrayFixed<
   R extends RegExp,
-  S extends ReSource<R> = ReSource<R>,
+  S extends RegExpSource<R> = RegExpSource<R>,
   GroupCount extends number = CountCaptureGroups<S>
 > = [match: string, ...BuildCaptureTuple<GroupCount>] & {
-  groups?: ReGroups<R>;
+  groups?: RegExpNamedGroups<R>;
   index: number;
   input: string;
 };
@@ -150,25 +188,20 @@ export type BuildCaptureTuple<
  */
 export type ReplaceCallbackParams<
   R extends RegExp,
-  S extends ReSource<R> = ReSource<R>,
+  S extends RegExpSource<R> = RegExpSource<R>,
   GroupCount extends number = CountCaptureGroups<S>
 > = [
   match: string,
   ...captures: BuildCaptureTuple<GroupCount>,
   offset: number,
   input: string,
-  groups: ReGroups<R>
+  groups: RegExpNamedGroups<R>
 ];
-export type ReplacerFunctionSignature<R extends RegExp> = (...args: ReplaceCallbackParams<R>) => string;
-const re1 = createRegExp("(test)(group)()()()()()()()(22)", "g");
-type TRe1Replacer = ReplacerFunctionSignature<typeof re1>;
-type ExecResult1 = RegExpExecArrayFixed<typeof re1>;
-const re2 = createRegExp("(?<name1>test)(?<name2>group)", "g");
-type TRe2Replacer = ReplacerFunctionSignature<typeof re2>;
-type ExecResult2 = RegExpExecArrayFixed<typeof re2>;
-const result = re2.exec("test group") as RegExpExecArrayFixed<typeof re2>;
-if (result) {
-  console.log(result[1]);
-  console.log(result.groups?.name1);
-}
+export type ReplacerFunctionSignature<R extends unkown> =
+  R extends (
+    RegExp & { readonly source: infer T }
+  ) ? R extends TypedRegExpBrand
+    ? (...args: ReplaceCallbackParams<R, T>) => string
+    : (match: string, ...rest: any[]) => string
+  : string;
 export as namespace XRegex;

package/scripts/publish-version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.0.16"
+  "version": "1.0.18"
 }

package/tool-lib/cjbm.js

@@ -13,10 +13,15 @@
 const fs = require("fs");
 const path = require("path");
 /**
- * @type {typeof XRegex.createRegExp}
+ * Creates a typed RegExp object with literal types for the pattern and flags.
+ * @template {string} P
+ * @template {string} F
+ * @param {P} pattern The regular expression pattern.
+ * @param {F} [flags] The flags for the regular expression.
+ * @returns {XRegex.TypedRegExp<P, F>} A typed RegExp object.
  */
 function createRegExp(pattern, flags) {
-  return new RegExp(pattern, flags);
+  return /** @type {XRegex.TypedRegExp<P, F>} */(new RegExp(pattern, flags));
 }
 const reImportExportDetection = createRegExp(
   `(?<!\\s*\\/\\/+.*?)(?:(?<!@)import|export)\\s*(?:(?<qcGlobal>["'])(?!https?:)(?=[.\\/]+)\
@@ -127,7 +132,7 @@ module.exports = () => {
     root     - Recursively searches for files.
                This option is useful, but if there are directories that need to be avoided, use the 'basePath' option
     basePath - can be "<path>,<path>,..." (array type arg)
-    ext      - specifies the module extension for import clauses. default is "js"
+    ext      - specifies the module extension for import/export clauses. default is "js"
     test     - Any file extension can be specified. (The default is /\\.js$/)
     targets  - specify this if you want to apply it only to a specific file.
                the file specified here should be directly under \`basePath\`!

package/tool-lib/cmt-trick.js

@@ -15,23 +15,11 @@
  * @param {string} code
  */
 function cleanup(code) {
-  const pcreStyle = String.raw`
-\s*\/
-  (?:
-    \s*\/+\*\s+(?:ctt|comment-toggle-trick|https:\/\/coderwall)
-    ([\s\S]+?)
-    (?:\s+)\/\*\/
-    [\s\S]+
-    |
-    \s*\*\s+(?:ctt|comment-toggle-trick|https:\/\/coderwall)
-    [\s\S]+
-    \/\*\/
-    ([\s\S]+?)
-  )
-\s*\/{2,}\*\/
-`;
+  const reCleanUp = new RegExp(
+    "\s*\/(?:\s*\/+\*\s+(?:ctt|comment-toggle-trick|https:\/\/coderwall)([\s\S]+?)(?:\s+)\/\*\/[\s\S]+|\s*\*\s+(?:ctt|comment-toggle-trick|https:\/\/coderwall)[\s\S]+\/\*\/([\s\S]+?))\s*\/{2,}\*\/", "g"
+  );
   return code.replace(
-    new RegExp(pcreStyle.replace(/\s*\(\?#.*\)\s*$|#\s.*$|\s+/gm, ""), "g"), ($0, $1, $2) => $1 || $2,
+    reCleanUp, ($0, $1, $2) => $1 || $2,
   );
 }
 /**