js-dev-tool 1.0.19 → 1.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-dev-tool",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "bin": {
     "jstool": "tools.js"
   },

package/regex.d.ts

@@ -75,6 +75,9 @@ export declare function createRegExp<
   const P extends string,
   const F extends string = ""
 >(pattern: P, flags?: F): TypedRegExp<P, F>;
+type IsEmptyRecord<T> =
+  [T] extends [undefined] ? true :
+  [keyof T] extends [never] ? true : false;
 /*!
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 //                            Named Capture Groups
@@ -91,7 +94,9 @@ export type ExtractGroupNames<S extends unknown> =
     ? FirstChar<Rest> extends "=" | "!"
       ? ExtractGroupNames<Rest>
       : Rest extends `${infer GroupName}>${infer After}`
-        ? GroupName | ExtractGroupNames<After>
+        ? GroupName extends ""
+          ? "ExtractGroupNames: regex pattern error!"
+          : GroupName | ExtractGroupNames<After>
         : never
     : never;
 /**
@@ -100,10 +105,14 @@ export type ExtractGroupNames<S extends unknown> =
  * @template R - A RegExp type.
  * @date 2025/12/24 14:46:30 - It may be possible to extract the group name accurately (?)
  */
-export type RegExpNamedGroups<R extends RegExp> = R extends { readonly source: infer T }
- ? {
-  [K in ExtractGroupNames<T>]?: string;
-} : never;
+export type RegExpNamedGroups<R extends RegExp> =
+  R extends RegExp & { readonly source: infer S extends string }
+    ? ExtractGroupNames<S> extends infer K
+      ? [K] extends [never]
+        ? undefined
+        : { [P in K & string]: string | undefined }
+      : undefined
+    : undefined;
 /*!
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 //                               Capture Groups
@@ -121,7 +130,7 @@ export type RegExpNamedGroups<R extends RegExp> = R extends { readonly source: i
 export type __PreprocessEscapes<S extends string, Result extends string = ""> =
   S extends `\\\\${infer Rest}`
     ? __PreprocessEscapes<Rest, `${Result}__`>
-    : S extends `\\${infer Next}${infer Rest}`
+    : S extends `\\${infer EscapedChar}${infer Rest}`
       ? __PreprocessEscapes<Rest, `${Result}_!`>
       : S extends `${infer Char}${infer Rest}`
         ? __PreprocessEscapes<Rest, `${Result}${Char}`>
@@ -150,9 +159,10 @@ export type CountCaptureGroups<
 export type RegExpExecArrayFixed<
   R extends RegExp,
   S extends RegExpSource<R> = RegExpSource<R>,
-  GroupCount extends number = CountCaptureGroups<S>
+  GroupCount extends number = CountCaptureGroups<S>,
+  NamedGroups = RegExpNamedGroups<R>
 > = [match: string, ...BuildCaptureTuple<GroupCount>] & {
-  groups?: RegExpNamedGroups<R>;
+  groups: IsEmptyRecord<NamedGroups> extends true ? undefined : NamedGroups;
   index: number;
   input: string;
 };
@@ -185,13 +195,19 @@ export type BuildCaptureTuple<
 export type ReplaceCallbackParams<
   R extends RegExp,
   S extends RegExpSource<R> = RegExpSource<R>,
-  GroupCount extends number = CountCaptureGroups<S>
-> = [
+  GroupCount extends number = CountCaptureGroups<S>,
+  NamedGroups = RegExpNamedGroups<R>
+> = IsEmptyRecord<NamedGroups> extends true ? [
   match: string,
   ...captures: BuildCaptureTuple<GroupCount>,
   offset: number,
   input: string,
-  groups: RegExpNamedGroups<R>
+] : [
+  match: string,
+  ...captures: BuildCaptureTuple<GroupCount>,
+  offset: number,
+  input: string,
+  groups: NamedGroups
 ];
 export type ReplacerFunctionSignature<R extends unknown> =
   R extends (
@@ -200,4 +216,139 @@ export type ReplacerFunctionSignature<R extends unknown> =
     ? (...args: ReplaceCallbackParams<R/* , T */>) => string
     : (match: string, ...rest: any[]) => string
   : string;
+/*! [2025/12/31 13:01:03]
+ * ## Support PCRE-style regex source (type-level)
+ *
+ * @remarks
+ * This module provides **type-level normalization** for "PCRE-ish" regex sources:
+ * you can write a readable multi-line regex with indentation and `# ...` comments,
+ * then derive a compact JavaScript `RegExp` source at compile time.
+ *
+ * Why type-level? Because it lets us:
+ * - keep the regex readable in source code (with comments and formatting)
+ * - ensure the normalized output is stable and verifiable (via type assertions)
+ *
+ * ## Supported rules
+ * - `#` starts a comment and consumes the rest of the **current line**
+ * - `\#` escapes `#` as a literal (comment is NOT started) and normalizes to `#`
+ * - whitespace characters are removed during normalization
+ * - newlines are normalized: `\r\n` and `\r` become `\n`
+ *
+ * ## Design note (ts(2589) survival)
+ * Naively scanning the entire string character-by-character (multiple passes)
+ * can hit TypeScript's instantiation depth limit (`ts(2589)`).
+ * This implementation is **line-oriented**:
+ * it strips each line, then concatenates results.
+ * That tends to scale much better for long, commented regex sources.
+ *
+ * ## Non-goals (for now)
+ * 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}";
+/**
+ * Normalize newline sequences for line-based parsing.
+ * 
+ * + Align **`\r\n`** and **`\r`** to **`\n`** (makes splitting easier)
+ *
+ * @template S - Input string literal.
+ * @returns A new string literal with `\r\n` and `\r` normalized to `\n`.
+ *
+ * @example
+ * type X = NormalizeNewlines<"a\r\nb\rc\n">; // "a\nb\nc\n"
+ */
+type NormalizeNewlines<S extends string> =
+  S extends `${infer A}\r\n${infer B}` ? NormalizeNewlines<`${A}\n${B}`> :
+  S extends `${infer A}\r${infer B}` ? NormalizeNewlines<`${A}\n${B}`> :
+  S;
+/**
+ * Strip and normalize a single line of a PCRE-style regex source.
+ *
+ * @remarks
+ * Rules:
+ * - `\#` is treated as a literal `#` (the backslash is dropped)
+ * - an unescaped `#` starts a line comment and truncates the rest
+ * - all whitespace characters are removed
+ * - other escapes like `\s`, `\w`, `\/`, `\*` are preserved as-is
+ *
+ * @template S - One line of source (no `\n`).
+ * @template Acc - Accumulator for the normalized output.
+ *
+ * @example
+ * type A = StripLine<"  \\#\\w+   # comment  ">; // "#\\w+"
+ * type B = StripLine<"  abc  # comment">;        // "abc"
+ *
+ * @internal
+ *
+ * @todo
+ * - Handle `\\#` (a literal backslash + literal #) more strictly.
+ * - Do not treat `#` as a comment starter inside character classes (`[...]`).
+ */
+type StripLine<S extends string, Acc extends string = ""> =
+  S extends `\\#${infer Rest}`
+    ? StripLine<Rest, `${Acc}#`>
+    : S extends `\\${infer C}${infer Rest}`
+      ? StripLine<Rest, `${Acc}\\${C}`>
+      : S extends `#${string}`
+        ? Acc
+        : S extends `${infer C}${infer Rest}`
+          ? C extends Whitespace
+            ? StripLine<Rest, Acc>
+            : StripLine<Rest, `${Acc}${C}`>
+          : Acc;
+/**
+ * Convert a multi-line PCRE-style regex source into a compact JS `RegExp.source`.
+ *
+ * @remarks
+ * This type:
+ * 1) normalizes newlines, 2) splits by line, 3) applies {@link StripLine},
+ * then 4) concatenates the results.
+ *
+ * @template Input - A `const` string literal of the PCRE-ish source.
+ * @template Acc - Accumulator for the result.
+ * @template S - Internal normalized newline buffer (do not pass manually).
+ *
+ * @example
+ * const RE_SOURCE = `
+ * ^              # start
+ * (?:\\#\\w+)     # keep literal "#"
+ * ` as const;
+ *
+ * type Src = PCREStyleToJsRegExpSource<typeof RE_SOURCE>;
+ * // "^(:?##\\w+)" ... (depending on your actual input)
+ */
+export type PCREStyleToJsRegExpSource<
+  Input extends string,
+  Acc extends string = "",
+  S extends string = NormalizeNewlines<Input>,
+> =
+  S extends `${infer Line}\n${infer Rest}`
+    ? PCREStyleToJsRegExpSource<Input, `${Acc}${StripLine<Line>}`, Rest>
+    : `${Acc}${StripLine<S>}`;
 export as namespace XRegex;

package/scripts/publish-version.json

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

package/tool-lib/cjbm.js

@@ -41,8 +41,12 @@ function getReplacer(ext) {
    */
   /** @type {TImportExportDetectRegexReplacer} */
   return (
-    match, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _offset, _input, groups
+    ...args
   ) => {
+    const [
+      match,,,,,,,,,,,,,
+      groups
+    ] = args;
     if (/\s*?\/\*/.test(match)) return match;
     const {
       clause,