js-dev-tool 1.0.21 → 1.1.1

package/literate-regex/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Modifications Copyright 2025 jeffy-g
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/literate-regex/README.md

@@ -0,0 +1,195 @@
+
+# literate-regex
+
+Write readable (literate) regex sources with `#` comments, and normalize them into a compact JavaScript `RegExp.source` **at the type level**.
+
+This package is built for the real world where regexes are often:
+- long,
+- unreadable,
+- and fragile.
+
+With `literate-regex`, you can keep them readable (multi-line + comments) while still getting a normalized, single-line `RegExp.source` type that stays stable.
+
+---
+
+## ✨ Features
+
+- **PCRE-ish style regex source**:
+  - multi-line formatting
+  - `# ...` line comments
+  - `\#` escape for literal `#`
+- **Type-level normalization**:
+  - derive normalized JS `RegExp.source` as a string literal type
+- **Optional global augmentation**:
+  - opt-in only (`import "literate-regex/global"`)
+- Designed to reduce TypeScript instantiation pain:
+  - line-oriented normalization (helps avoid `ts(2589)` compared to naive full-string scanning)
+
+---
+
+## 📦 Install
+
+```bash
+npm i literate-regex
+# or
+pnpm add literate-regex
+# or
+yarn add literate-regex
+```
+
+---
+
+## 🚀 Quick Start
+
+```ts
+import { PCREStyleToJsRegExpSource } from "literate-regex";
+
+// Only those who want to expand globally
+import "literate-regex/global";
+```
+
+---
+
+## 🧠 Type-level normalization
+
+### 1) Write a readable PCRE-style source
+
+* `#` starts a line comment (unless escaped)
+* `\#` is kept as a literal `#`
+* whitespace characters are stripped during normalization
+
+```ts
+import type { PCREStyleToJsRegExpSource } from "./literate-regex";
+
+// sample 1
+const RE_SOURCE = `
+^           # start
+(?:\\#\\w+) # literal "#"
+\\s+        # whitespace
+` as const;
+
+// type JsSource = "^(?:#\\w+)\\s+" 
+type JsSource = PCREStyleToJsRegExpSource<typeof RE_SOURCE>;
+```
+
+> Tip: You must use `as const` to preserve the source as a string literal type.
+
+---
+
+## 🔧 Runtime normalization (optional)
+
+`PCREStyleToJsRegExpSource<...>` is purely type-level.
+If you also normalize at runtime, mirror the same rules:
+
+```ts
+import { normalizePCREStyleSource } from "literate-regex";
+// import type { PCREStyleToJsRegExpSource } from "literate-regex";
+
+// sample 2
+const src = `
+^        # start
+\\#\\w+  # literal
+` as const;
+
+// '^#\\w+'
+// const normalized: "^#\\w+"
+const normalized = normalizePCREStyleSource(src);
+```
+
+## helper function compilePCREStyleRegExpLiteral
+
+
+```ts
+import {
+  TypedRegExp,
+  normalizePCREStyleSource,
+  compilePCREStyleRegExpLiteral,
+  extractJsRegexPartsFromPCREStyleRegExpLiteral
+} from "literate-regex";
+import type {
+  RegExpLiteralParts,
+  PCREStyleToJsRegExpSource,
+  RegExpExecArrayFixedPretty,
+  ReplacerFunctionSignature,
+} from "literate-regex";
+
+//
+// sample of compilePCREStyleRegExpLiteral
+//
+const pcreStyledRegex = `/
+(\\(\\?\#[\\s\\S]*?(?<!\\\\)\\)(?=\\s*$|.))         # multi line comment
+|
+(?:^(?:\\s+|))?(?<![\\\\])(\\#(?:\\s|[\\s\\S])*?$)  # single line comment
+|
+(?<regexFragment>
+  (?:^\\s+)?(?:[^\\s]+)
+)+                                                  # regex flagment
+|
+([\\r|\\r\\n|\\n]+|[\\x20\\t]+(?=$)?)               # whitespaces
+/gm`;
+
+const jsRegex = compilePCREStyleRegExpLiteral(pcreStyledRegex);
+
+type TPcreStyledRegex = typeof pcreStyledRegex;
+type TJsRegexSource = PCREStyleToJsRegExpSource<TPcreStyledRegex>;
+type TJsRegexLiteralParts = RegExpLiteralParts<TJsRegexSource>;
+
+type TJsRegexExecArray = RegExpExecArrayFixedPretty<
+  TypedRegExp<TJsRegexLiteralParts["pattern"]>
+>;
+type TJsRegexStringReplacer = ReplacerFunctionSignature<
+  TypedRegExp<TJsRegexLiteralParts["pattern"]>
+>;
+let m = jsRegex.exec(pcreStyledRegex);
+type Test0 = TJsRegexExecArray extends typeof m ? true : false;
+type Test1 = typeof m extends TJsRegexExecArray ? true : false;
+
+const replacer: TJsRegexStringReplacer = (...args) => "";
+pcreStyledRegex.replace(jsRegex, replacer);
+pcreStyledRegex.replace(jsRegex, "");
+```
+
+---
+
+## 🌍 Global augmentation (opt-in)
+
+This package provides an optional global augmentation entry:
+
+```ts
+import "literate-regex/global";
+```
+
+This is intentionally **opt-in** to avoid unexpected type pollution across projects.
+
+---
+
+## ⚠️ Notes & limitations
+
+* This is **not a full PCRE parser**. It focuses on:
+
+  * line comments (`# ...`)
+  * escaping `\#`
+  * whitespace stripping
+* Very large type-level inputs may still hit TS limits depending on your environment.
+  If that happens, split your regex source into smaller pieces.
+
+---
+
+## 📚 References
+
+This library’s whitespace set is based on the ECMAScript definition used by RegExp `\s`
+(WhiteSpace ∪ LineTerminator).
+
+- ECMA-262: White Space (Table 33)
+  https://tc39.es/ecma262/#sec-white-space
+- ECMA-262: Line Terminators (Table 34)
+  https://tc39.es/ecma262/#sec-line-terminators
+- MDN: RegExp character classes (`\s` equivalence)
+  https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions/Character_classes
+
+---
+
+## 📜 License
+
+Released under the `Apache-2.0` License.  
+See [LICENSE](./LICENSE) for details.

package/literate-regex/dist/cjs/index.d.ts

@@ -0,0 +1,16 @@
+/*!
+// Copyright jeffy-g 2025
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+export * from "./util";

package/literate-regex/dist/cjs/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/*!
+// Copyright jeffy-g 2025
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./util"), exports);

package/literate-regex/dist/cjs/util.d.ts

@@ -0,0 +1,22 @@
+/*!
+// Copyright jeffy-g 2025
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+import type { TypedRegExp, PCREStyleRegExpFlags, PCREStyleRegExpParts, PCREStyleRegExpPattern, PCREStyleToJsRegExpSource } from "../";
+export declare const normalizePCREStyleSource: <const S extends string>(src: S) => PCREStyleToJsRegExpSource<S>;
+export declare const extractJsRegexPartsFromPCREStyleRegExpLiteral: <const S extends string, const TRegexParts extends PCREStyleRegExpParts<S>>(src: S) => {
+    pattern: TRegexParts["pattern"];
+    flags: TRegexParts["flags"];
+};
+export declare const compilePCREStyleRegExpLiteral: <const S extends string>(src: S) => TypedRegExp<PCREStyleRegExpPattern<S>, PCREStyleRegExpFlags<S>>;

package/literate-regex/dist/cjs/util.js

@@ -0,0 +1,50 @@
+"use strict";
+/*!
+// Copyright jeffy-g 2025
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compilePCREStyleRegExpLiteral = exports.extractJsRegexPartsFromPCREStyleRegExpLiteral = exports.normalizePCREStyleSource = void 0;
+const NORMALIZE_PCRE_STYLE_REGEX = /(?<!\\)\#\s*.*$|\s+/gm;
+const normalizePCREStyleSource = (src) => {
+    return src
+        .replace(/\\#/g, "\x00#")
+        .replace(NORMALIZE_PCRE_STYLE_REGEX, "")
+        .replace(/\x00#/g, "#");
+};
+exports.normalizePCREStyleSource = normalizePCREStyleSource;
+const extractJsRegexPartsFromPCREStyleRegExpLiteral = (src) => {
+    const normalized = (0, exports.normalizePCREStyleSource)(src);
+    if (normalized[0] !== "/")
+        throw new Error("Expected regex literal to start with '/'");
+    const lastSlash = normalized.lastIndexOf("/");
+    if (lastSlash <= 0)
+        throw new Error("Invalid regex literal: missing trailing '/'");
+    const pattern = normalized.slice(1, lastSlash);
+    const flags = normalized.slice(lastSlash + 1);
+    return { pattern, flags };
+};
+exports.extractJsRegexPartsFromPCREStyleRegExpLiteral = extractJsRegexPartsFromPCREStyleRegExpLiteral;
+const compilePCREStyleRegExpLiteral = (src) => {
+    const normalized = (0, exports.normalizePCREStyleSource)(src);
+    if (normalized[0] !== "/")
+        throw new Error("Expected regex literal to start with '/'");
+    const lastSlash = normalized.lastIndexOf("/");
+    if (lastSlash <= 0)
+        throw new Error("Invalid regex literal: missing trailing '/'");
+    const pattern = normalized.slice(1, lastSlash);
+    const flags = normalized.slice(lastSlash + 1);
+    return new RegExp(pattern, flags);
+};
+exports.compilePCREStyleRegExpLiteral = compilePCREStyleRegExpLiteral;

package/literate-regex/dist/esm/index.d.ts

@@ -0,0 +1,16 @@
+/*!
+// Copyright jeffy-g 2025
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+export * from "./util";

package/literate-regex/dist/esm/index.mjs

@@ -0,0 +1,16 @@
+/*!
+// Copyright jeffy-g 2025
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+export * from "./util.mjs";

package/literate-regex/dist/esm/util.d.mts

@@ -0,0 +1,22 @@
+/*!
+// Copyright jeffy-g 2025
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+import type { TypedRegExp, PCREStyleRegExpFlags, PCREStyleRegExpParts, PCREStyleRegExpPattern, PCREStyleToJsRegExpSource } from "../";
+export declare const normalizePCREStyleSource: <const S extends string>(src: S) => PCREStyleToJsRegExpSource<S>;
+export declare const extractJsRegexPartsFromPCREStyleRegExpLiteral: <const S extends string, const TRegexParts extends PCREStyleRegExpParts<S>>(src: S) => {
+    pattern: TRegexParts["pattern"];
+    flags: TRegexParts["flags"];
+};
+export declare const compilePCREStyleRegExpLiteral: <const S extends string>(src: S) => TypedRegExp<PCREStyleRegExpPattern<S>, PCREStyleRegExpFlags<S>>;

package/literate-regex/dist/esm/util.mjs

@@ -0,0 +1,44 @@
+/*!
+// Copyright jeffy-g 2025
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+const NORMALIZE_PCRE_STYLE_REGEX = /(?<!\\)\#\s*.*$|\s+/gm;
+export const normalizePCREStyleSource = (src) => {
+    return src
+        .replace(/\\#/g, "\x00#")
+        .replace(NORMALIZE_PCRE_STYLE_REGEX, "")
+        .replace(/\x00#/g, "#");
+};
+export const extractJsRegexPartsFromPCREStyleRegExpLiteral = (src) => {
+    const normalized = normalizePCREStyleSource(src);
+    if (normalized[0] !== "/")
+        throw new Error("Expected regex literal to start with '/'");
+    const lastSlash = normalized.lastIndexOf("/");
+    if (lastSlash <= 0)
+        throw new Error("Invalid regex literal: missing trailing '/'");
+    const pattern = normalized.slice(1, lastSlash);
+    const flags = normalized.slice(lastSlash + 1);
+    return { pattern, flags };
+};
+export const compilePCREStyleRegExpLiteral = (src) => {
+    const normalized = normalizePCREStyleSource(src);
+    if (normalized[0] !== "/")
+        throw new Error("Expected regex literal to start with '/'");
+    const lastSlash = normalized.lastIndexOf("/");
+    if (lastSlash <= 0)
+        throw new Error("Invalid regex literal: missing trailing '/'");
+    const pattern = normalized.slice(1, lastSlash);
+    const flags = normalized.slice(lastSlash + 1);
+    return new RegExp(pattern, flags);
+};

package/literate-regex/dist/global.d.ts

@@ -0,0 +1,67 @@
+/*!
+// Copyright jeffy-g 2025
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+/**
+ * @file literate-regex/global.d.ts
+ */
+import type {
+  TypedRegExp,
+  ReplacerFunctionSignature,
+  RegExpExecArrayFixedPretty,
+} from "./index.d.ts";
+declare global {
+  interface RegExp {
+    /**
+     * Executes a search on a string using a regular expression pattern, and returns an array containing the results of that 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 {RegExpExecArrayFixedPretty< 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>, str: string): RegExpExecArrayFixedPretty< 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 {TypedRegExp<P, F>} A typed RegExp object.
+     */
+    new <const P extends string, const F extends string = "">(pattern: P, flags?: F): TypedRegExp<P, 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 {TypedRegExp<P, F>} A typed RegExp object.
+     */
+    <const P extends string, const F extends string = "">(pattern: P, flags?: F): TypedRegExp<P, F>;
+    readonly prototype: RegExp;
+  }
+}
+export {};

package/{regex.d.ts → literate-regex/dist/index.d.ts}

@@ -1,58 +1,24 @@
 /*!
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-//  Copyright (C) 2025 jeffy-g <hirotom1107@gmail.com>
-//  Released under the MIT license
-//  https://opensource.org/licenses/mit-license.php
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// Copyright jeffy-g 2025
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 */
 /**
- * @file js-dev-scripts/regex.d.ts
+ * @file literate-regex/index.d.ts
  * @desc It is recommended to add `"skipLibCheck": true` to your tsconfig.
- * @todo publish as "annotate-regex"
+ * @todo publish as "literate-regex"
+ * @todo implement runtime utility function for `/<source>/<flags>`
  */
-declare global {
-  interface RegExp {
-    /**
-     * Executes a search on a string using a regular expression pattern, and returns an array containing the results of that 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>, 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): TypedRegExp<P, 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): TypedRegExp<P, F>;
-    readonly "prototype": RegExp;
-  }
-}
 /*!
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 //                                   Basics
@@ -161,7 +127,36 @@ export type RegExpExecArrayFixed<
   S extends RegExpSource<R> = RegExpSource<R>,
   GroupCount extends number = CountCaptureGroups<S>,
   NamedGroups = RegExpNamedGroups<R>
-> = [match: string, ...BuildCaptureTuple<GroupCount>] & {
+> = [match: string, ...BuildCaptureTuple<GroupCount, string | undefined>] & {
+  groups: IsEmptyRecord<NamedGroups> extends true ? undefined : NamedGroups;
+  index: number;
+  input: string;
+};
+type CaptureOptTuple<N extends number, T = string | undefined> =
+  N extends 0 ? [] :
+  N extends 1 ? [$1: T] :
+  N extends 2 ? [$1: T, $2: T] :
+  N extends 3 ? [$1: T, $2: T, $3: T] :
+  N extends 4 ? [$1: T, $2: T, $3: T, $4: T] :
+  N extends 5 ? [$1: T, $2: T, $3: T, $4: T, $5: T] :
+  N extends 6 ? [$1: T, $2: T, $3: T, $4: T, $5: T, $6: T] :
+  N extends 7 ? [$1: T, $2: T, $3: T, $4: T, $5: T, $6: T, $7: T] :
+  N extends 8 ? [$1: T, $2: T, $3: T, $4: T, $5: T, $6: T, $7: T, $8: T] :
+  N extends 9 ? [$1: T, $2: T, $3: T, $4: T, $5: T, $6: T, $7: T, $8: T, $9: T] :
+  N extends 10 ? [$1: T, $2: T, $3: T, $4: T, $5: T, $6: T, $7: T, $8: T, $9: T, $10: T] :
+  N extends 11 ? [$1: T, $2: T, $3: T, $4: T, $5: T, $6: T, $7: T, $8: T, $9: T, $10: T, $11: T] :
+  N extends 12 ? [$1: T, $2: T, $3: T, $4: T, $5: T, $6: T, $7: T, $8: T, $9: T, $10: T, $11: T, $12: T] :
+  N extends 13 ? [$1: T, $2: T, $3: T, $4: T, $5: T, $6: T, $7: T, $8: T, $9: T, $10: T, $11: T, $12: T, $13: T] :
+  N extends 14 ? [$1: T, $2: T, $3: T, $4: T, $5: T, $6: T, $7: T, $8: T, $9: T, $10: T, $11: T, $12: T, $13: T, $14: T] :
+  N extends 15 ? [$1: T, $2: T, $3: T, $4: T, $5: T, $6: T, $7: T, $8: T, $9: T, $10: T, $11: T, $12: T, $13: T, $14: T, $15: T] :
+  N extends 16 ? [$1: T, $2: T, $3: T, $4: T, $5: T, $6: T, $7: T, $8: T, $9: T, $10: T, $11: T, $12: T, $13: T, $14: T, $15: T, $16: T] :
+  BuildCaptureTuple<N, T>;
+export type RegExpExecArrayFixedPretty<
+  R extends RegExp,
+  S extends RegExpSource<R> = RegExpSource<R>,
+  GroupCount extends number = CountCaptureGroups<S>,
+  NamedGroups = RegExpNamedGroups<R>
+> = [match: string, ...CaptureOptTuple<GroupCount>] & {
   groups: IsEmptyRecord<NamedGroups> extends true ? undefined : NamedGroups;
   index: number;
   input: string;
@@ -199,12 +194,12 @@ export type ReplaceCallbackParams<
   NamedGroups = RegExpNamedGroups<R>
 > = IsEmptyRecord<NamedGroups> extends true ? [
   match: string,
-  ...captures: BuildCaptureTuple<GroupCount>,
+  ...captures: CaptureOptTuple<GroupCount>,
   offset: number,
   input: string,
 ] : [
   match: string,
-  ...captures: BuildCaptureTuple<GroupCount>,
+  ...captures: CaptureOptTuple<GroupCount>,
   offset: number,
   input: string,
   groups: NamedGroups
@@ -245,33 +240,36 @@ export type ReplacerFunctionSignature<R extends unknown> =
  * This is not a full PCRE parser. It intentionally focuses on comment + whitespace
  * normalization for readability and DX.
  */
-export type Whitespace =
-  | "\u{9}"
-  | "\u{A}"
-  | "\u{B}"
-  | "\u{C}"
-  | "\u{D}"
-  | "\u{20}"
-  | "\u{85}"
-  | "\u{A0}"
-  | "\u{1680}"
-  | "\u{2000}"
-  | "\u{2001}"
-  | "\u{2002}"
-  | "\u{2003}"
-  | "\u{2004}"
-  | "\u{2005}"
-  | "\u{2006}"
-  | "\u{2007}"
-  | "\u{2008}"
-  | "\u{2009}"
-  | "\u{200A}"
-  | "\u{2028}"
-  | "\u{2029}"
-  | "\u{202F}"
-  | "\u{205F}"
-  | "\u{3000}"
-  | "\u{FEFF}";
+/**
+ * Union of whitespace characters used by this library.
+ * 
+ * + A set aligned with ECMAScript RegExp **`\s`** (WhiteSpace ∪ LineTerminator)
+ * 
+ * The union is used to normalize "PCRE-style" regex sources at the type level.
+ */
+export type TWhiteSpace =
+  | "\x09"
+  | "\x0A"
+  | "\x0B"
+  | "\x0C"
+  | "\x0D"
+  | "\x20"
+  | "\u00A0"
+  | "\u1680"
+  | "\u2000"
+  | "\u2001"
+  | "\u2002"
+  | "\u2003"
+  | "\u2004"
+  | "\u2005"
+  | "\u2006"
+  | "\u2007"
+  | "\u2008"
+  | "\u2009"
+  | "\u200A"
+  | "\u2028" | "\u2029"
+  | "\u202F" | "\u205F" | "\u3000"
+  | "\uFEFF";
 /**
  * Normalize newline sequences for line-based parsing.
  * 
@@ -318,7 +316,7 @@ type StripLine<S extends string, Acc extends string = ""> =
       : S extends `#${string}`
         ? Acc
         : S extends `${infer C}${infer Rest}`
-          ? C extends Whitespace
+          ? C extends TWhiteSpace
             ? StripLine<Rest, Acc>
             : StripLine<Rest, `${Acc}${C}`>
           : Acc;
@@ -351,4 +349,37 @@ export type PCREStyleToJsRegExpSource<
   S extends `${infer Line}\n${infer Rest}`
     ? PCREStyleToJsRegExpSource<Input, `${Acc}${StripLine<Line>}`, Rest>
     : `${Acc}${StripLine<S>}`;
+/*!
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//                    Parse PCRE Style Regex Literal
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+type AllowedRegExpFlag = "d" | "g" | "i" | "m" | "s" | "u" | "v" | "y";
+type StripFlagsFromEnd<S extends string, Acc extends string = ""> =
+  S extends `${infer Rest}y` ? StripFlagsFromEnd<Rest, `y${Acc}`> :
+  S extends `${infer Rest}v` ? StripFlagsFromEnd<Rest, `v${Acc}`> :
+  S extends `${infer Rest}u` ? StripFlagsFromEnd<Rest, `u${Acc}`> :
+  S extends `${infer Rest}s` ? StripFlagsFromEnd<Rest, `s${Acc}`> :
+  S extends `${infer Rest}m` ? StripFlagsFromEnd<Rest, `m${Acc}`> :
+  S extends `${infer Rest}i` ? StripFlagsFromEnd<Rest, `i${Acc}`> :
+  S extends `${infer Rest}g` ? StripFlagsFromEnd<Rest, `g${Acc}`> :
+  S extends `${infer Rest}d` ? StripFlagsFromEnd<Rest, `d${Acc}`> :
+  { body: S; flags: Acc };
+export type RegExpLiteralParts<L extends string> =
+  StripFlagsFromEnd<L> extends { body: infer B extends string; flags: infer F extends string }
+    ? B extends `/${infer AfterStart}`
+      ? AfterStart extends `${infer Pattern}/`
+        ? { pattern: Pattern; flags: F }
+        : never
+      : never
+    : never;
+export type PCREStyleRegExpParts<S extends string> = RegExpLiteralParts<PCREStyleToJsRegExpSource<S>>;
+export type PCREStyleRegExpPattern<S extends string> = PCREStyleRegExpParts<S>["pattern"];
+export type PCREStyleRegExpFlags<S extends string> = PCREStyleRegExpParts<S>["flags"];
+export declare const normalizePCREStyleSource: <S extends string>(src: S) => PCREStyleToJsRegExpSource<S>;
+export declare const extractJsRegexPartsFromPCREStyleRegExpLiteral: <const S extends string>(src: S) => PCREStyleRegExpParts<S>;
+export declare const compilePCREStyleRegExpLiteral: <const S extends string>(src: S) => TypedRegExp<
+  PCREStyleRegExpPattern<S>,
+  PCREStyleRegExpFlags<S>
+>;
 export as namespace XRegex;

package/literate-regex/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "literate-regex",
+  "version": "0.1.0",
+  "description": "Write readable (literate) regex sources with # comments, then normalize them to JS RegExp.source at the type level.",
+  "license": "Apache-2.0",
+  "sideEffects": false,
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.js"
+    },
+    "./global": {
+      "types": "./dist/global.d.ts"
+    }
+  },
+  "scripts": {
+    "clean": "rimraf -g ./dist/*",
+    "build": "tsc & tsc -p ./tsconfig-esm.json",
+    "postbuild": "cpx ./*.d.ts dist -v & yarn run:extras && jstool -cmd rmc -rmc4ts -basePath ./dist -test \"/\\.(m?js|d\\.m?ts)$/\"",
+    "run:extras": "jstool -cmd cjbm -root ./dist/esm -ext mjs && mv ./dist/esm/util.d.ts ./dist/esm/util.d.mts"
+  },
+  "files": [
+    "README.md",
+    "LICENSE",
+    "dist"
+  ],
+  "keywords": [
+    "regex",
+    "regexp",
+    "literate",
+    "types",
+    "typescript",
+    "pcre",
+    "jsdoc"
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-dev-tool",
-  "version": "1.0.21",
+  "version": "1.1.1",
   "bin": {
     "jstool": "tools.js"
   },
@@ -22,24 +22,31 @@
     "version"
   ],
   "files": [
+    "*.d.ts",
     "common",
     "extras",
     "lib",
     "progress",
     "scripts",
+    "literate-regex/package.json",
+    "literate-regex/README.md",
+    "literate-regex/LICENSE",
+    "literate-regex/dist",
     "tool-lib",
-    "index.js",
-    "tools.js",
-    "utils.js",
-    "tsconfig.json",
+    "./index.js",
+    "./tools.js",
+    "./utils.js",
+    "./tsconfig.json",
     "!tool-lib/cjbm-*",
-    "!scripts/unzip.ts",
+    "!unzip.ts",
     "!scripts/bin",
+    "!publish-version.json",
+    "!literate-regex/*.d.ts",
+    "!normalize-commit-msg.mjs",
     "!regex-test.ts",
     "!extras/npm",
     "!/**/*.png",
-    "!tool.sh",
-    "*.d.ts"
+    "!tool.sh"
   ],
   "peerDependencies": {
     "archiver": "^4.0.1",

package/tool-lib/cjbm.js

@@ -12,17 +12,52 @@
  */
 const fs = require("fs");
 const path = require("path");
+const {
+  compilePCREStyleRegExpLiteral,
+} = require("../literate-regex");
+const RE_TEXT = `/
+# DEVNOTE: [.\/] において、js では "/" に escape は必要ないが、pcre の場合 pattern error になる都合上 escape している
+# NOTE: PCRE(regex101.com) での検証時は pattern error 回避のため line comment assertion を (?<!\/\/|\/\/\s)(?:(?<!@)import|export) とすること
+# line comment の import("...") を正しく除外するには: (?<!\s*\/\/+.*?)(?:(?<!@)import|export)
+# NOTE: multiline comment の import statement 誤検出を回避するため、multiline comment の検出を行うようにした. (match count 45, 内 5 は multiline comment[non capture group])
+# regex101.com　では、line comment assertion (?<!\/\/|\/\/\s) により、48 (3 つは意図しない検出)
+(?:
+  (?:^\\s*?\\/\\*+?[\\s\\S]*?\\*\\/)|
+  (?<!\\s*\\/\\/+.*?)(?:(?<!@)import|export)
+  \\s*
+  (?:
+    # 2025/12/22 14:57:44 - support quote character detection ["']
+    # global import, import "./"; import './global.mjs';
+    (?<qcGlobal>["'])(?!https?:)(?=(?:\\.\\.?\\/)+)(?:
+      (?<globalName>(?:(?:\\.\\.?\\/)+)?[^'"]+?)(?:\\.(?<globalExt>(?:c|m)?jsx?))?
+    )\\k<qcGlobal>|
+    # dynamic import, import("...") import('...')
+    \\(\\s*
+      (?<qcDynamic>["'])(?!https?:)(?=(?:\\.\\.?\\/)+)(?<dynamicName>(?:(?:\\.\\.?\\/)+)?[^'"]+?)(?:\\.(?<dynamicExt>(?:c|m)?jsx?))?\\k<qcDynamic>
+    \\s*\\)|
+    # esm import/export
+    (?:(?<clause>.+?|(?:\\w+\\s*,)?\\s*\\{[^}]+})\\s*from)\\s*
+      (?<qcEsm>["'])(?!https?:)(?=(?:\\.\\.?\\/)+)
+      (?:
+        (?<moduleName>(?:(?:\\.\\.?\\/)+)?[^'"]+?)(?:\\.(?<moduleExt>(?:c|m)?jsx?))?
+      )\\k<qcEsm>
+  )
+  (?=\\s*;)?
+)/gm
+`;
 /**
- * DEVNOTE: Improved `RegExpConstructor` interface makes `createRegExp` unnecessary
- * @date 2025/12/25 22:10:17
+ * @typedef {XRegex.PCREStyleToJsRegExpSource<typeof RE_TEXT>} TCjbmRegexLiteral remove line comment and whitespaces from `RE_TEXT` (type-level)
+ * @typedef {XRegex.RegExpLiteralParts<TCjbmRegexLiteral>} TCjbmRegexLiteralParts parts of `pattern` and `flags` (PCREStyleToJsRegExpSource)
+ * ```
+ * type TCjbmRegexLiteralParts = {
+ *   pattern: "...";
+ *   flags: "gm";
+ * }
+ * ```
+ * @typedef {XRegex.PCREStyleRegExpPattern<TCjbmRegexLiteral>} TCjbmRegexLiteralPattern
+ * @typedef {XRegex.PCREStyleRegExpFlags<TCjbmRegexLiteral>} TCjbmRegexLiteralFlags
  */
-const reImportExportDetection = new RegExp(
-  `(?:(?:^\\s*?\\/\\*+?[\\s\\S]*?\\*\\/)|(?<!\\s*\\/\\/+.*?)(?:(?<!@)import|export)\\s*\
-(?:(?<qcGlobal>["'])(?!https?:)(?=(?:\\.\\.?\\/)+)(?:(?<globalName>(?:(?:\\.\\.?\\/)+)?[^'"]+?)(?:\\.(?<globalExt>(?:c|m)?jsx?))?)\\k<qcGlobal>|\
-\\(\\s*(?<qcDynamic>["'])(?!https?:)(?=(?:\\.\\.?\\/)+)(?<dynamicName>(?:(?:\\.\\.?\\/)+)?[^'"]+?)(?:\\.(?<dynamicExt>(?:c|m)?jsx?))?\\k<qcDynamic>\\s*\\)|\
-(?:(?<clause>.+?|(?:\\w+\\s*,)?\\s*\\{[^}]+})\\s*from)\\s*(?<qcEsm>["'])(?!https?:)(?=(?:\\.\\.?\\/)+)(?:(?<moduleName>(?:(?:\\.\\.?\\/)+)?[^'"]+?)(?:\\.(?<moduleExt>(?:c|m)?jsx?))?)\\k<qcEsm>)\
-(?=\\s*;)?)`, "gm"
-);
+const reImportExportDetection = compilePCREStyleRegExpLiteral(RE_TEXT);
 /**
  * @typedef {XRegex.ReplacerFunctionSignature<typeof reImportExportDetection>} TImportExportDetectRegexReplacer
  */
@@ -113,9 +148,13 @@ module.exports = () => {
     fn() {
       const bases = getBasePaths();
       const ext = params.ext || "js";
+      /**
+       * @typedef {XRegex.RegExpExecArrayFixedPretty<typeof reImportExportDetection>} TImportExportDetectRegexExecResultPretty
+       */
       /* const sourceFiles = await */
       processSources(
         /** @type {string} */ (this.taskName), (data) => {
+          /** @type {TImportExportDetectRegexExecResultPretty | null} */
           reImportExportDetection.lastIndex = 0;
           return data.replace(reImportExportDetection, getReplacer(ext));
         }, {

package/tool-lib/cmt-trick.js

@@ -19,7 +19,7 @@ function cleanup(code) {
     "\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(
-    reCleanUp, ($0, $1, $2) => $1 || $2,
+    reCleanUp, ($0, $1, $2) => $1 || $2 || $0,
   );
 }
 /**

package/tool-lib/tools.d.ts

@@ -5,7 +5,7 @@
   https://opensource.org/licenses/mit-license.php
  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 */
-/// <reference path="../regex.d.ts"/>
+/// <reference types="../literate-regex"/>
 /**
  * @date 2023-10-25
  */

package/tsconfig.json

@@ -27,7 +27,8 @@
     "tools.js",
     "*.d.ts",
     "./**/*.js",
-    "./**/*.d.ts"
+    "./**/*.d.ts",
+    "./literate-regex/*.d.ts",
   ],
   "exclude": [
     "./**/npm-outdated*.js",

package/scripts/normalize-commit-msg.mjs

@@ -1,22 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const commitMsgPath = path.resolve(__dirname, "..", ".codex", "commit_msg.txt");
-
-if (!fs.existsSync(commitMsgPath)) {
-  process.exit(0);
-}
-
-let msg = fs.readFileSync(commitMsgPath, "utf8");
-
-msg = msg.replace(/\r\n/g, "\n");
-msg = msg
-  .split("\n")
-  .map(line => line.replace(/\s+$/u, ""))
-  .join("\n");
-msg = msg.replace(/\n+$/u, "\n");
-
-fs.writeFileSync(commitMsgPath, msg, "utf8");

package/scripts/publish-version.json

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