js-dev-tool 1.0.0

package/progress/test.js

@@ -0,0 +1,94 @@
+/*!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  Copyright (C) 2022 jeffy-g <hirotom1107@gmail.com>
+  Released under the MIT license
+  https://opensource.org/licenses/mit-license.php
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+/** [usage]
+> node -i
+let t = require("./progress/test");
+let p = t.init();
+p.run();
+p.stop();
+p = t.init();
+p.run();
+p.stop();
+*/
+
+const p = require("./index.js");
+const rndspinner = require("./rnd-spinner.js");
+
+let fired = 0;
+let pending = 0;
+
+/** @type {() => { fired: number; pending: number; errors?: number; }} */
+const cb = () => {
+  return {
+    fired: ++fired,
+    pending: ++pending,
+  };
+};
+
+let tag = "progress test";
+
+/**
+ * progress callback
+ * @type {() => string}
+ */
+const pcb = () => {
+  if (cb) {
+    const { fired, pending, errors } = cb();
+    return `${tag} | error: ${(errors + "").padEnd(3)} | send: ${(fired + "").padStart(3)}, pending: ${(pending + "").padEnd(5)}`;
+  } else {
+    // error
+    return "- - error - -";
+  }
+};
+
+/** @type {ReturnType<typeof p.createProgressObject>} */
+let progress;
+/**
+ * @param {string} frameName
+ */
+const getFormatOpt = (frameName) => {
+  return {
+    fmt: "{frameName}: {msg} | {tick}",
+    payload: { frameName },
+  };
+};
+/**
+ * create progress options as randomly
+ */
+const createRandomlyOptions = () => {
+  const { name, frames } = rndspinner.getRandomFrame();
+  return {
+    frames,
+    formatOpt: getFormatOpt(name.padStart(rndspinner.MAX_PAD)),
+  };
+};
+/**
+ * @param {number} fps
+ */
+const init = (fps = 30) => {
+  /**
+   * @typedef {ReturnType<typeof createRandomlyOptions>} TcreateRandomlyOptionsReturn
+   */
+  // /** @type {string[]} */
+  // let frames;
+  // /** @type {TcreateRandomlyOptionsReturn["formatOpt"]} */
+  // let formatOpt;
+  // // TIP: https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Object_destructuring
+  // (
+  //     { frames, formatOpt } = createRandomlyOptions()
+  // );
+  const { frames, formatOpt } = createRandomlyOptions();
+  progress = p.createProgressObject(frames, formatOpt, pcb);
+  progress.setFPS(fps);
+
+  return progress;
+};
+
+module.exports = {
+  init,
+};

package/regex.d.ts

@@ -0,0 +1,154 @@
+/*!
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//  Copyright (C) 2025 jeffy-g <hirotom1107@gmail.com>
+//  Released under the MIT license
+//  https://opensource.org/licenses/mit-license.php
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+/**
+ * @file js-dev-scripts/regex.d.ts
+ */
+
+//  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//                                    Basics
+//  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+/**
+ * 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 declare function createRegExp<P extends string>(pattern: P, flags?: string): RegExp & {
+  readonly source: P;
+};
+
+//  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//                             Named Capture Groups
+//  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+type FirstChar<S extends string> = S extends `${infer F}${infer _}` ? F : never;
+// Modified ExtractGroupNames:
+// First, extract the part of S after "(?<" into Rest
+// If the first character of Rest is "=" or "!", it is judged to be Lookbehind and recurses without treating it as a capture
+// Otherwise, split Rest into the group name (GroupName) and the ">" separator and extract it,
+// Apply the same process to the remaining After part
+/**
+ * Recursively extracts parts that match the format (?<GroupName>...) from a string pattern,
+ * without considering nesting, and unions them.
+ * @template S - A string pattern.
+ */
+export type ExtractGroupNames<S extends string> =
+  S extends `${infer _Before}(?<${infer Rest}`
+    ? FirstChar<Rest> extends "=" | "!"
+      ? ExtractGroupNames<Rest>
+      : Rest extends `${infer GroupName}>${infer After}`
+        ? GroupName | ExtractGroupNames<After>
+        : never
+    : never;
+/**
+ * Creates an object type with keys as the extracted group names and values as strings.
+ * If no groups are found, it results in an empty object.
+ * @template R - A RegExp type.
+ */
+export type ReGroups<R extends RegExp> = {
+  [K in ExtractGroupNames<ReSource<R>>]?: string;
+};
+
+//  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//                                Capture Groups
+//  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// CountCaptureGroups type: Get the exact number of capture groups
+/**
+ * Counts the exact number of capture groups in a string pattern.
+ * @template S - A string pattern.
+ * @template Counter - An array used to count the capture groups.
+ * 
+ * @todo FIXME: 多く count してしまう場合あり. 2025/3/18 15:47:57
+ * @deprecated text base の parse には限界があり cost が見合わないので、この type は将来削除予定!
+ */
+export type CountCaptureGroups<S extends string, Counter extends unknown[] = []> =
+  // // まず、エスケープされた左括弧 \(
+  // S extends `${infer _Before}\\(${infer Rest}`
+  //   ? CountCaptureGroups<Rest, Counter> :
+    // 次に、通常の左括弧 ( を検出
+    S extends `${infer _Before}(${infer Rest}`
+      // 非キャプチャグループ (?:...) をスキップ
+      ? Rest extends `?:${infer After}`
+        ? CountCaptureGroups<After, Counter>
+        // Lookahead/Lookbehind (?=...), (?!...), (?<=...), (?<!...) をスキップ
+        : Rest extends `?=${infer After}`
+          | `?!${infer After}`
+          | `?<=${infer After}`
+          | `?<!${infer After}`
+          ? CountCaptureGroups<After, Counter>
+          // それ以外は通常のキャプチャグループとしてカウント
+          : CountCaptureGroups<Rest, [...Counter, unknown]>
+      : Counter['length'];
+
+// Fixed RegExpExecArray type
+/**
+ * Represents a fixed version of RegExpExecArray that includes the matched string,
+ * captures, and optionally named groups.
+ * @template R - A RegExp type.
+ * @template S - The source string of the RegExp.
+ * @template GroupCount - The number of capture groups.
+ */
+export type RegExpExecArrayFixed<
+  R extends RegExp,
+  S extends ReSource<R> = ReSource<R>,
+  GroupCount extends number = CountCaptureGroups<S>
+> = [match: string, ...ExtractCaptures<GroupCount>] & {
+  groups?: ReGroups<R>;
+};
+
+// Helper type: Generates an array according to the number of capture groups
+/**
+ * Generates an array type with a length corresponding to the number of capture groups.
+ * @template Count - The number of capture groups.
+ * @template Result - The resulting array type.
+ */
+export type ExtractCaptures<Count extends number, Result extends unknown[] = []> =
+  Result['length'] extends Count
+    ? Result : ExtractCaptures<Count, [...Result, string]>;
+
+/* ctt
+type Dummy = ExtractCaptures<4>;
+// [string, string, string, string]
+/*/
+//*/
+
+//  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//                                The Examples
+//  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// Example 1: Anonymous capture groups
+const re1 = createRegExp("(test)(group)", "g");
+type ExecResult1 = RegExpExecArrayFixed<typeof re1>;
+// ExecResult1 is [string, string, string] & { groups?: Record<string, string | undefined> };
+
+// Example 2: Named capture groups
+const re2 = createRegExp("(?<name1>test)(?<name2>group)", "g");
+type ExecResult2 = RegExpExecArrayFixed<typeof re2>;
+// ExecResult2 is [string, string, string] & { groups?: { name1: string; name2: string } };
+
+// Verify that the exec result matches the type
+const result = re2.exec("test group") as RegExpExecArrayFixed<typeof re2>;
+if (result) {
+  console.log(result[1]); // "test"
+  console.log(result.groups?.name1); // "test"
+}
+
+export as namespace XRegex;
+/* ctt sample code
+// 補助関数 createRegExp を使って型レベルの情報を保持する RegExp を生成
+function createRegExp<P extends string>(
+  pattern: P,
+  flags?: string
+): RegExp & { readonly source: P } {
+  return new RegExp(pattern, flags) as RegExp & { readonly source: P };
+}
+const re = createRegExp("(?<token>test)", "ig");
+// type a は "token" というグループ名から導出された型になりますが、
+// groups オブジェクトとしては { token: string } になる
+type Groups = ReGroups<typeof re>; // → { token: string }
+const m = re.exec("this is test")!;
+console.log(m, m.groups);
+/*/
+//*/

package/scripts/publish-version.json

@@ -0,0 +1,3 @@
+{
+  "version": "1.0.0"
+}

package/scripts/unzip.js

@@ -0,0 +1,30 @@
+"use strict";
+const fs = require("fs");
+const fflate = require("fflate");
+const { unzip } = fflate;
+/**
+ * @param {string} fileName
+ */
+const decompress = (fileName) => {
+  fs.readFile(fileName, null, (err, data) => {
+    if (err) {
+      console.error(err);
+    } else {
+      console.time(fileName);
+      unzip(data, (err, unzipped) => {
+        // [2022/5/10 3:05:43] webpack.zip: 159.833ms
+        console.timeEnd(fileName);
+        if (err) {
+          console.error(err);
+          return;
+        }
+        Object.entries(unzipped).forEach(([filename, data]) => {
+          fs.writeFile(filename, data, null, () => {
+            console.log("write:", filename);
+          });
+        });
+      });
+    }
+  });
+};
+module.exports = decompress;

package/scripts/zip.js

@@ -0,0 +1,138 @@
+const fs = require("fs");
+const path = require("path");
+const fflate = require("fflate");
+const { TextEncoder } = require("util");
+// const b = require("node:buffer");
+
+// fflate's ZIP API is asynchronous and parallelized (multithreaded)
+const ALREADY_COMPRESSED = [
+  "zip",
+  "gz",
+  "png",
+  "jpg",
+  "jpeg",
+  "pdf",
+  "doc",
+  "docx",
+  "ppt",
+  "pptx",
+  "xls",
+  "xlsx",
+  "heic",
+  "heif",
+  "7z",
+  "bz2",
+  "rar",
+  "gif",
+  "webp",
+  "webm",
+  "mp4",
+  "mov",
+  "mp3",
+  "aifc",
+];
+
+/**
+ *
+ * @param {string} fileName
+ * @param {(out: Uint8Array | NodeJS.ErrnoException) => void} cb
+ */
+const fileToU8 = (fileName, cb /* : (out: Uint8Array) => void */) => {
+  fs.readFile(fileName, "utf8", (err, data) => {
+    if (err) {
+      cb(err);
+    } else {
+      cb(new TextEncoder().encode(data));
+    }
+  });
+};
+
+// Yet again, this is necessary for parallelization.
+/**
+ * @param {path.ParsedPath} parsedPath
+ * @param {(out: Uint8Array | null) => void} callback
+ * @param {string} [comment]
+ */
+const processFile = function (parsedPath, callback, comment) {
+  const filePath = `${parsedPath.dir}/${parsedPath.base}`;
+  fileToU8(filePath, function (data) {
+    if (data instanceof Uint8Array) {
+      /** @type {fflate.AsyncZippable} */
+      const zipObj = {
+        [parsedPath.base]: [
+          data, {
+            // With fflate, we can choose which files we want to compress
+            level: ALREADY_COMPRESSED.indexOf(parsedPath.ext) === -1 ? 6 : 0,
+            comment,
+          },
+        ],
+      };
+
+      // If we didn't want to specify options:
+      // zipObj[fileName] = buf;
+      console.time(filePath);
+      fflate.zip(
+        zipObj,
+        {
+          // If you want to control options for every file, you can do so here
+          // They are merged with the per-file options (if they exist)
+          // mem: 9
+        },
+        function (err, out) {
+          if (err) {
+            console.log(err);
+            callback(null);
+            console.timeEnd(filePath);
+          } else {
+            // [2022/5/10 3:06:16] webpack.js: 399.832ms
+            console.timeEnd(filePath);
+            // You may want to try downloading to see that fflate actually works:
+            // download(out, 'fflate-demo.zip');
+            callback(out);
+          }
+        },
+      );
+    } else {
+      console.error(data);
+    }
+  });
+};
+
+/**
+ * @param {string} inputPath
+ * @param {string} [comment]
+ * @param {string} [dest]
+ */
+module.exports = function zip(inputPath, comment, dest) {
+  let actualOutput = dest;
+  const pp = path.parse(inputPath);
+  processFile(
+    pp,
+    (out) => {
+      if (out) {
+        if (!actualOutput) {
+          actualOutput = `${pp.dir ? pp.dir + "/" : ""}${pp.name}.zip`;
+        }
+        fs.writeFile(actualOutput, out, "binary", () => {
+          console.log("done!!");
+        });
+      }
+    },
+    comment,
+  );
+};
+/*
+node -i
+const zip = require("js-dev-scripts/scripts/zip");
+const comment = "sha384-XSSUboqeWltJhmqrtg5XP9Svrg5NFArrGX0Nm4+c6NUtaRXOiidVCaWFbSQXdVFC";
+zip("./lib/webpack.js", comment);
+const comment2 = "sha384-Y7FclS+/O1tb8AfLynrvaZRzlgEfzNlqOB2iX/tQ/BQBu6lK3MsxBlDDeqtFd+2X";
+zip("./lib/typeid-map.js", comment2);
+
+[2022/5/11 10:07:34]
+b64=$(echo -n "sha384-XSSUboqeWltJhmqrtg5XP9Svrg5NFArrGX0Nm4+c6NUtaRXOiidVCaWFbSQXdVFC" | base64)
+echo "$b64"
+echo -n "$b64" | base64 -d # OK
+
+echo -n "XSSUboqeWltJhmqrtg5XP9Svrg5NFArrGX0Nm4+c6NUtaRXOiidVCaWFbSQXdVFC" | base64 -d # binary data
+*/

package/tool-lib/cjbm.js

@@ -0,0 +1,239 @@
+/*!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  Copyright (C) 2023 jeffy-g <hirotom1107@gmail.com>
+  Released under the MIT license
+  https://opensource.org/licenses/mit-license.php
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+/// <reference path="./tools.d.ts"/>
+/// <reference path="../regex.d.ts"/>
+// @ts-check
+/**
+ * @file (C)onvert (J)S to (B)rowser (M)odule
+ */
+
+/**
+ * @import * as Regex from "../regex.d.ts";
+ */
+
+// [2023-10-30] from https://regex101.com/r/EpuQLT/37
+// CAUTION: PCRE style では、js では使える assertion が使えない場合があるので、適宜書き換えないといけない.
+//   詳細は、 https://regex101.com/r/EpuQLT/38 の regex string と以下を見比べて確認
+// const RE_TEXT = `(?<!\\/\\/\\s*)(?:import|export)           # comments
+// \\s*
+// (?:
+//   "(?=[.\\/]+)|                            # character ["] \\x22 e.g - import "../global/index"
+//   (?:
+//     [\\w_]+\\s+|                           # default import, e.g - import fs from "./file";
+//     (?:[\\w_]+\\s*,\\s*)?\\{[^}]+\\}\\s*|  # e.g - import View, { TitiledSphereMesh } from "./view";
+//     \\*\\s*as\\s+[\\w_]+\\s+|              # e.g - export * as OO from "./rateLimiter";
+//     \\*\\s*                                # e.g - export * from "./rateLimiter";
+//   )from\\s*"(?:[.\\/]+)                    # Positive Lookahead (./|../|../../) ...
+// )
+// (?:[^"]*?)(?:\\.((?:c|m)?js))?             # extenstion replaceable
+// (?="\\s*;?)`;
+
+/* TODO: 2025/2/15 19:39:29 - regex group name を抽出する utility type
+(?<!\\/\\/|\\/\\/\\s)(?:import|export)
+\\s*
+(?:
+  "(?!https?:)(?:
+    (?<globalName>(?:[.\\/]+)?[^"]+?)(?:\\.(?<globalExt>(?:c|m)?jsx?))?
+  )"|
+  \\(\\s*
+    "(?<dynamicName>(?:[.\\/]+)?[^"]+?)(?:\\.(?<dynamicExt>(?:c|m)?jsx?))?"
+  \\s*\\)|
+  (?:(?<clause>.+?|(?:\\w+\\s*,)?\\s*\\{[^}]+\\})\\s*from)\\s*"(?!https?:)
+  (?:
+    (?<moduleName>(?:[.\\/]+)?[^"]+?)(?:\\.(?<moduleExt>(?:c|m)?jsx?))?
+  )"
+)
+\\s*;?
+*/
+// /**
+//  * @date 2025/2/15 20:11:22
+//  * @see https://regex101.com/r/uMMsD4/22
+//  */
+const RE_TEXT = String.raw`
+# NOTE: PCRE での検証時は line comment assertion を (?<!\/\/|\/\/\s) とすること (regex101.com)
+(?<!\/\/+\s*)(?:import|export)
+\s*
+(?:
+  "(?!https?:)(?=[.\/]+)(?:
+    (?<globalName>(?:[.\/]+)?[^"]+?)(?:\.(?<globalExt>(?:c|m)?jsx?))?
+  )"|
+  \(\s*
+    "(?!https?:)(?=[.\/]+)(?<dynamicName>(?:[.\/]+)?[^"]+?)(?:\.(?<dynamicExt>(?:c|m)?jsx?))?"
+  \s*\)|
+  (?:(?<clause>.+?|(?:\w+\s*,)?\s*\{[^}]+\})\s*from)\s*"(?!https?:)(?=[.\/]+)
+  (?:
+    (?<moduleName>(?:[.\/]+)?[^"]+?)(?:\.(?<moduleExt>(?:c|m)?jsx?))?
+  )"
+)
+(?=\s*;)?
+`;
+// const RE_TEXT = `
+// # NOTE: PCRE での検証時は line comment assertion を (?<!\\/\\/|\\/\\/\\s) とすること
+// (?<!\\/\\/+\\s*)(?:import|export)  # line comment でない import/export statement
+// \\s*
+// (?:
+//   "(?!https?:)(?=[.\\/]+)(?:
+//     (?<globalName>(?:[.\\/]+)?[^"]+?)(?:\\.(?<globalExt>(?:c|m)?jsx?))?
+//   )"|
+//   \\(\\s*
+//     "(?!https?:)(?=[.\\/]+)(?<dynamicName>(?:[.\\/]+)?[^"]+?)(?:\\.(?<dynamicExt>(?:c|m)?jsx?))?"
+//   \\s*\\)|
+//   (?:(?<clause>.+?|(?:\\w+\\s*,)?\\s*\\{[^}]+\\})\\s*from)\\s*"(?!https?:)(?=[.\\/]+)
+//   (?:
+//     (?<moduleName>(?:[.\\/]+)?[^"]+?)(?:\\.(?<moduleExt>(?:c|m)?jsx?))?
+//   )"
+// )
+// (?=\\s*;)?
+// `;
+
+/**
+ * @date 2025/2/15 20:11:22
+ * @see https://regex101.com/r/uMMsD4/22
+ */
+/* ctt
+const reImportExportDetection = createRegExp(
+  `(?<!\\/\\/+\\s*)(?:import|export)\\s*(?:"(?!https?:)(?=[.\\/]+)\
+(?:(?<globalName>(?:[.\\/]+)?[^"]+?)(?:\\.(?<globalExt>(?:c|m)?jsx?))?)"|\
+\\(\\s*"(?!https?:)(?=[.\\/]+)(?<dynamicName>(?:[.\\/]+)?[^"]+?)(?:\\.(?<dynamicExt>(?:c|m)?jsx?))?"\\s*\\)|\
+(?:(?<clause>.+?|(?:\\w+\\s*,)?\\s*\\{[^}]+\\})\\s*from)\\s*"(?!https?:)(?=[.\\/]+)(?:(?<moduleName>(?:[.\\/]+)?[^"]+?)\
+(?:\\.(?<moduleExt>(?:c|m)?jsx?))?)")(?=\\s*;)?`, "g"
+);
+/*/
+const reImportExportDetection = new RegExp(
+  RE_TEXT.replace(/\s*\(\?\#.*\)\s*$|(?<!\\)\#\s*.*$|\s+/gm, ""), "g",
+);
+//*/
+
+// /**
+//  * @type {typeof XRegex["createRegExp"]}
+//  */
+// function createRegExp(pattern, flags) {
+//   return /** @type {RegExp & { readonly source: typeof pattern }} */(new RegExp(pattern, flags));
+// }
+/* ctt 2025/3/18 13:46:03 OK, works
+// @ts-expect-error 
+let gg = /** @type {XRegex.RegExpExecArrayFixed<typeof reImportExportDetection>} * /(reImportExportDetection.exec("test"));
+gg.groups?.dynamicExt
+/*/
+//*/
+// function createRegExp<P extends string>(
+//   pattern: P,
+//   flags?: string
+// ): RegExp & { readonly source: P } {
+//   return new RegExp(pattern, flags) as RegExp & { readonly source: P };
+// }
+
+/**
+ * Generates a replacer function to update import/export statements with a new file extension.
+ *
+ * @param {string} ext - The new file extension to use.
+ * @returns {TRegexImportExportDetectorReplacer} A function to update import/export statements with the specified file extension.
+ * @date 2025/2/16 18:38:39
+ */
+function getReplacer(ext) {
+  /**
+   * NOTE: Replacement is only performed with the syntax "$` is $1".
+   * String concatenation is not allowed.
+   */
+  // before match: $` NOTE: "$` is $1" のような使い方でないと置換されない (string concatnation is not allowed)
+  // after match: $'
+  // TIP: debug on chrome, snippet: detect-import-export-regex.js
+  /** @type {TRegexImportExportDetectorReplacer} */
+  const replacer = (
+    $0, _1, _2, _3, _4, _5, _6, _7, _o, _s, { clause, dynamicName, globalName, moduleName }
+    // $0, $1, $2, $3, $4, $5, $6, $7, offset, source, groups
+  ) => {
+    // const {
+    //     clause,     // dynamicExt,
+    //     dynamicName,// globalExt,
+    //     globalName, // moduleExt,
+    //     moduleName,
+    // } = groups;
+    const kw = $0.startsWith("import") ? "import" : "export";
+    let whichName = /** @type {string} */ (
+      globalName || moduleName || dynamicName
+    );
+    if (whichName[whichName.length - 1] === "/") {
+      whichName += "index";
+    }
+    return `${kw}${globalName ? ` "${whichName}.${ext}"` : clause ? ` ${clause} from "${whichName}.${ext}"` : `("${whichName}.${ext}")`}`;
+  };
+  return replacer;
+}
+
+/**
+ * @returns {TJSToolEntry}
+ */
+module.exports = () => {
+  return {
+    taskName: "(C)onvert (J)S to (B)rowser (M)odule",
+    /**
+     * about regex: see [[tools.js] regex - (C)onvert (J)S to (B)rowser (M)odule](https://regex101.com/r/EpuQLT/37)
+     */
+    fn() {
+      // DEVNOTE: 2020/5/27 12:11:11 - https://regex101.com/r/EpuQLT/21
+      // DEVNOTE: 2022/4/19 7:28:28 - https://regex101.com/r/EpuQLT/23
+      // DEVNOTE: 2023/10/30 - https://regex101.com/r/EpuQLT/24
+      //   -> supports [import*as e from"../"] etc
+      // DEVNOTE: 2023/11/06 - https://regex101.com/r/EpuQLT/32
+      //   -> fix unstable detection
+      // const bp = params.basePath;
+      // const bases = Array.isArray(bp)? bp: typeof bp === "string" && bp.length ? [bp] : void 0;
+      const bases = getBasePaths();
+      const ext = params.ext || "js";
+      /** ### regex summary
+       * ```perl
+       * (?:import|export)                    # comments
+       * \s*
+       * (?:
+       *   "(?=[.\/]+)|                       # character ["] \x22 e.g - import "../global/index"
+       *   (?:
+       *     [\w_]+\s+|                       # default import, e.g - import fs from "./file";
+       *     (?:[\w_]+\s*,\s*)?\{[^}]+\}\s*|  # e.g - import View, { TitiledSphereMesh } from "./view";
+       *     \*\s*as\s+[\w_]+\s+|             # e.g - export * as OO from "./rateLimiter";
+       *     \*\s*                            # e.g - export * from "./rateLimiter";
+       *   )from\s*"(?:[.\/]+)                # Positive Lookahead (./|../|../../) ...
+       * )
+       * (?:[^"]*)
+       * (?<!\.js)                            # Negative Lookbehind not(/\.(?:c|m)?js/)
+       * (?="\s*;?)
+       * ```
+       * @see regex details see {@link https://regex101.com/r/EpuQLT/32 regex101.com}
+       */
+      // const replacer = (/** @type {string} */$0, /** @type {string} */$1) => {
+      //     if ($0[$0.length - 1] === "/") {
+      //         return `${$0}index.${ext}`;
+      //     }
+      //     return $1? $0.replace(`.${$1}`, `.${ext}`): `${$0}.${ext}`;
+      // };
+      // const bs = isArray(params.basePath)? params.basePath[0]: params.basePath;
+      processSources(
+        /** @type {string} */ (this.taskName), (data) => {
+          reImportExportDetection.lastIndex = 0;
+          return data.replace(reImportExportDetection, getReplacer(ext));
+        }, {
+          bases,
+          // base: bs || ""
+        },
+      );
+    },
+    get help() {
+      return `${this.taskName}
+  ex - jstool -cmd cjbm [-root ./build | -basePath "./dist/esm,extra-tests/mini-semaphore"] [-ext js] [-targets "['core.js', 'object.js']"]
+  note:
+    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"
+    targets  - specify this if you want to apply it only to a specific file.
+               the file specified here should be directly under \`basePath\`!
+               value must be array type arg, "['<path>', '<path>',...]" or "<path>,<path>,..."
+`;
+    },
+  };
+};