js-dev-tool 1.2.10 → 1.2.12

package/extras/cc-map.js

@@ -0,0 +1,140 @@
+/*!
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//  Copyright (C) 2026 jeffy-g <hirotom1107@gmail.com>
+//  Released under the MIT license
+//  https://opensource.org/licenses/mit-license.php
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+/**
+ * @file extras/cc-map.js
+ * @import { TCC_MAP } from "./cc-map";
+ */
+module.exports = /** @type {TCC_MAP}  */({
+  /** `\u0000` */ NULL: 0,
+  /** `\u0001` */ SOH: 1,
+  /** `\u0002` */ STX: 2,
+  /** `\u0003` */ ETX: 3,
+  /** `\u0004` */ EOT: 4,
+  /** `\u0005` */ ENQ: 5,
+  /** `\u0006` */ ACK: 6,
+  /** `\u0007` */ BEL: 7,
+  /** `\u0008` */ BS: 8,
+  /** `\t` */     TAB: 9,
+  /** `\n` */     LF: 10,
+  /** `\u000b` */ VT: 11,
+  /** `\f` */     FF: 12,
+  /** `\r` */     CR: 13,
+  /** `\u000e` */ SO: 14,
+  /** `\u000f` */ SI: 15,
+  /** `\u0010` */ DLE: 16,
+  /** `\u0011` */ DC1: 17,
+  /** `\u0012` */ DC2: 18,
+  /** `\u0013` */ DC3: 19,
+  /** `\u0014` */ DC4: 20,
+  /** `\u0015` */ NAK: 21,
+  /** `\u0016` */ SYN: 22,
+  /** `\u0017` */ ETB: 23,
+  /** `\u0018` */ CAN: 24,
+  /** `\u0019` */ EM: 25,
+  /** `\u001a` */ SUB: 26,
+  /** `\u001b` */ ESC: 27,
+  /** `\u001c` */ FS: 28,
+  /** `\u001d` */ GS: 29,
+  /** `\u001e` */ RS: 30,
+  /** `\u001f` */ US: 31,
+  /** " " */ SPACE: 32,
+  /** `!` */ EXCLAMATION: 33,
+  /** `"` */ DOUBLE_QUOTE: 34,
+  /** `#` */ HASH: 35,
+  /** `$` */ DOLLAR: 36,
+  /** `%` */ PERCENT: 37,
+  /** `&` */ AMPERSAND: 38,
+  /** `'` */ SINGLE_QUOTE: 39,
+  /** `(` */ LEFT_PAREN: 40,
+  /** `)` */ RIGHT_PAREN: 41,
+  /** `*` */ ASTERISK: 42,
+  /** `+` */ PLUS: 43,
+  /** `,` */ COMMA: 44,
+  /** `-` */ MINUS: 45,
+  /** `.` */ PERIOD: 46,
+  /** `/` */ SLASH: 47,
+  /** `0` */ ZERO: 48,
+  /** `1` */ ONE: 49,
+  /** `2` */ TWO: 50,
+  /** `3` */ THREE: 51,
+  /** `4` */ FOUR: 52,
+  /** `5` */ FIVE: 53,
+  /** `6` */ SIX: 54,
+  /** `7` */ SEVEN: 55,
+  /** `8` */ EIGHT: 56,
+  /** `9` */ NINE: 57,
+  /** `:` */ COLON: 58,
+  /** `;` */ SEMICOLON: 59,
+  /** `<` */ LESS_THAN: 60,
+  /** `=` */ EQUAL: 61,
+  /** `>` */ GREATER_THAN: 62,
+  /** `?` */ QUESTION: 63,
+  /** `@` */ AT: 64,
+  /** `A` */ A: 65,
+  /** `B` */ B: 66,
+  /** `C` */ C: 67,
+  /** `D` */ D: 68,
+  /** `E` */ E: 69,
+  /** `F` */ F: 70,
+  /** `G` */ G: 71,
+  /** `H` */ H: 72,
+  /** `I` */ I: 73,
+  /** `J` */ J: 74,
+  /** `K` */ K: 75,
+  /** `L` */ L: 76,
+  /** `M` */ M: 77,
+  /** `N` */ N: 78,
+  /** `O` */ O: 79,
+  /** `P` */ P: 80,
+  /** `Q` */ Q: 81,
+  /** `R` */ R: 82,
+  /** `S` */ S: 83,
+  /** `T` */ T: 84,
+  /** `U` */ U: 85,
+  /** `V` */ V: 86,
+  /** `W` */ W: 87,
+  /** `X` */ X: 88,
+  /** `Y` */ Y: 89,
+  /** `Z` */ Z: 90,
+  /** `[` */ LEFT_BRACKET: 91,
+  /** `\` */ BACKSLASH: 92,
+  /** `]` */ RIGHT_BRACKET: 93,
+  /** `^` */ CARET: 94,
+  /** `_` */ UNDERSCORE: 95,
+  /** __`__ */ GRAVE: 96,
+  /** `a` */ a: 97,
+  /** `b` */ b: 98,
+  /** `c` */ c: 99,
+  /** `d` */ d: 100,
+  /** `e` */ e: 101,
+  /** `f` */ f: 102,
+  /** `g` */ g: 103,
+  /** `h` */ h: 104,
+  /** `i` */ i: 105,
+  /** `j` */ j: 106,
+  /** `k` */ k: 107,
+  /** `l` */ l: 108,
+  /** `m` */ m: 109,
+  /** `n` */ n: 110,
+  /** `o` */ o: 111,
+  /** `p` */ p: 112,
+  /** `q` */ q: 113,
+  /** `r` */ r: 114,
+  /** `s` */ s: 115,
+  /** `t` */ t: 116,
+  /** `u` */ u: 117,
+  /** `v` */ v: 118,
+  /** `w` */ w: 119,
+  /** `x` */ x: 120,
+  /** `y` */ y: 121,
+  /** `z` */ z: 122,
+  /** `{` */ LEFT_BRACE: 123,
+  /** `|` */ PIPE: 124,
+  /** `}` */ RIGHT_BRACE: 125,
+  /** `~` */ TILDE: 126,
+});

package/extras/json-minify.d.ts

@@ -0,0 +1,16 @@
+export type TJsonSourceEnvelop = {
+    src: string;
+};
+export type TBlacketPairCode = [open: number, close: number];
+export type TScannerFunction = (source: string, offset: number, out: TJsonSourceEnvelop) => number;
+/**
+ * Minify JSON or JSONL text by removing JSON whitespace outside double-quoted strings.
+ *
+ * - A single top-level value is returned as minified JSON.
+ * - Multiple top-level values are returned as minified JSONL separated by `"\n"`.
+ *
+ * @param {string} source
+ * @returns {string}
+ * @version 2.0
+ */
+export function jsonMinify(source: string): string;

package/extras/json-minify.js

@@ -0,0 +1,266 @@
+/*!
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//  Copyright (C) 2026 jeffy-g <hirotom1107@gmail.com>
+//  Released under the MIT license
+//  https://opensource.org/licenses/mit-license.php
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+"use strict";
+/**
+ * @file extras/json-minify.js
+ * @version 2.3 2026/04/06 16:11:36
+ */
+const ccMap = require("./cc-map");
+/**
+ * @typedef {{ src: string }} TJsonSourceEnvelop
+ * @typedef {[ open: number, close: number ]} TBlacketPairCode
+ */
+/** @type {TBlacketPairCode} */
+const array = [ ccMap.LEFT_BRACKET, ccMap.RIGHT_BRACKET];
+/** @type {TBlacketPairCode} */
+const object = [ ccMap.LEFT_BRACE, ccMap.RIGHT_BRACE];
+/**
+ * ### (O)thers (M)ap
+ *
+ * @type {(0 | 1)[]} 
+ */
+const om = Array(127).fill(0);
+om[ccMap.DOUBLE_QUOTE] = 1;
+om[ccMap.COMMA] = 1;
+om[ccMap.COLON] = 1;
+om[ccMap.LEFT_BRACKET] = 1;
+om[ccMap.RIGHT_BRACKET] = 1;
+om[ccMap.LEFT_BRACE] = 1;
+om[ccMap.RIGHT_BRACE] = 1;
+/**
+ * @typedef {(source: string, offset: number, out: TJsonSourceEnvelop) => number} TScannerFunction
+ */
+/**
+ * ### (O)thers (M)ap
+ *
+ * @type {TScannerFunction[]} 
+ */
+const scanners = Array(127).fill(0);
+scanners[ccMap.DOUBLE_QUOTE] = (source, offset, out) => {
+  const next = sqs(source, offset);
+  out.src += source.slice(offset, next);
+  return next;
+};
+scanners[ccMap.LEFT_BRACKET] = sjoCode;
+scanners[ccMap.LEFT_BRACE] = sjoCode;
+/**
+ * @param {string} message
+ * @param {number} offset
+ * @returns {never}
+ * @throws {SyntaxError}
+ */
+const throwJsonSyntaxError = (message, offset) => {
+  throw new SyntaxError(`${message}, offset=${offset}`);
+};
+/**
+ * Minify JSON or JSONL text by removing JSON whitespace outside double-quoted strings.
+ *
+ * - A single top-level value is returned as minified JSON.
+ * - Multiple top-level values are returned as minified JSONL separated by `"\n"`.
+ *
+ * @param {string} source
+ * @returns {string}
+ * @version 2.0
+ */
+function v25x(source) {
+  if (typeof source !== "string") {
+    throw new TypeError("jsonMinify(source): source must be a string");
+  }
+  /** @type {TJsonSourceEnvelop} */
+  const out = { src: "" };
+  const sourceLen = source.length;
+  let offset = 0;
+  let count = 0;
+  while (true) {
+    const next = skipWhitespaces(source, offset);
+    if (next >= sourceLen) {
+      break;
+    }
+    if (count > 0) {
+      if (next === offset) {
+        throwJsonSyntaxError("Missing whitespace between top-level JSON values", next);
+      }
+      out.src += "\n";
+    }
+    offset = sjv(source, next, out);
+    count++;
+  }
+  return out.src;
+}
+/**
+ * Minify JSON or JSONL text by removing JSON whitespace outside double-quoted strings.
+ *
+ * - A single top-level value is returned as minified JSON.
+ * - Multiple top-level values are returned as minified JSONL separated by `"\n"`.
+ *
+ * @param {string} source
+ * @returns {string}
+ * @version 2.0
+ */
+function v24x(source) {
+  if (typeof source !== "string") {
+    throw new TypeError("jsonMinify(source): source must be a string");
+  }
+  /** @type {TJsonSourceEnvelop} */
+  const out = { src: "" };
+  const sourceLen = source.length;
+  const scans = scanners;
+  let offset = 0;
+  let count = 0;
+  while (true) {
+    const next = skipWhitespaces(source, offset);
+    if (next >= sourceLen) {
+      break;
+    }
+    if (count > 0) {
+      if (next === offset) {
+        throwJsonSyntaxError("Missing whitespace between top-level JSON values", next);
+      }
+      out.src += "\n";
+    }
+    const scanner = scans[
+      source.charCodeAt(next)
+    ];
+    if (!scanner) {
+      const skiped = skipOthers(source, next);
+      out.src += source.slice(next, skiped);
+      offset = skiped;
+    } else {
+      offset = scanner(source, next, out);
+    }
+    count++;
+  }
+  return out.src;
+}
+/**
+ * @param {string} source
+ * @param {number} offset
+ * @param {TJsonSourceEnvelop} out
+ * @returns {number}
+ * @remarks for node v25.x
+ */
+function sjv(source, offset, out) {
+  switch (source.charCodeAt(offset)) {
+    case ccMap.LEFT_BRACE:
+    case ccMap.LEFT_BRACKET: return sjoCode(source, offset, out);
+    case ccMap.DOUBLE_QUOTE: {
+      const next = sqs(source, offset);
+      out.src += source.slice(offset, next);
+      return next;
+    }
+    default: {
+      const next = skipOthers(source, offset);
+      out.src += source.slice(offset, next);
+      return next;
+    }
+  }
+}
+/**
+ * (S)can (J)son (O)bject
+ * 
+ * @param {string} source
+ * @param {number} offset
+ * @param {TJsonSourceEnvelop} out
+ * @returns {number}
+ * @throws {SyntaxError}
+ * @version 2.2 `charCodeAt` version
+ */
+function sjoCode(source, offset, out) {
+  let sourceRef = out.src, nest = 0;
+  const bracket = source[offset] === "[" ? array : object;
+  const open = bracket[0];
+  const close = bracket[1];
+  const sourceLen = source.length;
+  while (offset < sourceLen) {
+    const code = source.charCodeAt(offset++);
+    if (code <= 32 /* ccMap.SPACE */) continue;
+    if (code === 34 /* ccMap.DOUBLE_QUOTE */) {
+      const next = sqs(source, offset - 1);
+      sourceRef += source.slice(offset - 1, next);
+      offset = next;
+      continue;
+    }
+    sourceRef += source[offset - 1];
+    if (code === open) {
+      nest++;
+    } else if (code === close) {
+      if (--nest === 0) break;
+    }
+  }
+  out.src = sourceRef;
+  return offset;
+}
+/**
+ * @param {string} source
+ * @param {number} offset
+ * @returns {number}
+ */
+function skipOthers(source, offset) {
+  const sourceLen = source.length;
+  let next = offset;
+  while (next < sourceLen) {
+    const code = source.charCodeAt(next++);
+    if (
+      code <= 32 || om[code]
+    ) {
+      next -= 1;
+      break;
+    }
+  }
+  if (next === offset) throwJsonSyntaxError("Invalid JSON primitive", offset);
+  return next;
+}
+/**
+ * ### (S)can (Q)uoted (S)tring
+ * 
+ * Scan a JSON double-quoted string and return the next offset.
+ *
+ * @param {string} source
+ * @param {number} offset
+ * @returns {number} `"` next offset
+ */
+function sqs(source, offset) {
+  const srcLen = source.length;
+  let next = offset + 1;
+  let inEscape = false;
+  while (next < srcLen) {
+    const code = source.charCodeAt(next++);
+    if (code === 92 /* ccMap.BACKSLASH */) {
+      inEscape = !inEscape;
+    } else if (inEscape) {
+      inEscape = false;
+    } else if (code === 34 /* ccMap.DOUBLE_QUOTE */) {
+      return next;
+    }
+  }
+  throwJsonSyntaxError("Incomplete JSON string", offset);
+}
+/**
+ * @param {number} code
+ * @returns {boolean}
+ */
+const isWhitespaceCode = (code) => code <= 32;
+/**
+ * @param {string} source
+ * @param {number} offset
+ * @returns {number}
+ */
+const skipWhitespaces = (source, offset) => {
+  const srcLen = source.length;
+  while (offset < srcLen) {
+    if (!isWhitespaceCode(source.charCodeAt(offset++))) {
+      offset -= 1;
+      break;
+    }
+  }
+  return offset;
+};
+const jsonMinify = process.versions.node.slice(0, 2) <= "24" ? v24x : v25x;
+module.exports = {
+  jsonMinify,
+};

package/extras/jsonl.d.ts

@@ -113,4 +113,11 @@ export function readJsonlMapByKey<TRow = any, TOut = TRow>(fileName: string, opt
  *
  * Intended for performance-sensitive hot paths where full `JSON.parse` is unnecessary.
  */
-export function fastGetIntFieldCheap(line: string, key: string): number | undefined;
+export function fastGetIntFieldCheap(line: string, key: string): number | undefined;
+/**
+ * Minify JSON or JSONL text by removing JSON whitespace outside strings.
+ *
+ * - A single top-level value is returned as minified JSON.
+ * - Multiple top-level values are returned as minified JSONL separated by `"\n"`.
+ */
+export function jsonMinify(source: string): string;

package/extras/jsonl.js

@@ -11,6 +11,7 @@
  */
 const fs = require("fs");
 const path = require("path");
+const { jsonMinify } = require("./json-minify.js");
 /**
  * @import { TJsonlReadOption, TJsonlReadBaseOption } from "./jsonl.js";
  */
@@ -140,12 +141,12 @@ async function readJsonl(fileName, onRow, options = {}) {
       try {
         const row = jsonParse(line);
         onRow(row, lineNo);
-      } catch (error) {
+      } catch (e) {
         if (onParseError) {
-          onParseError(error, line, lineNo);
+          onParseError(e, line, lineNo);
           return;
         }
-        console.error("jsonl parse error:", fileName, `line=${lineNo}`, error);
+        console.error("jsonl parse error:", fileName, `line=${lineNo}`, e);
       }
     },
     options
@@ -201,4 +202,5 @@ module.exports = {
   readJsonlArray,
   readJsonlMapByKey,
   fastGetIntFieldCheap,
+  jsonMinify,
 };

package/extras/progress-light.d.ts

@@ -0,0 +1,29 @@
+/*!
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//  Copyright (C) 2026 jeffy-g <hirotom1107@gmail.com>
+//  Released under the MIT license
+//  https://opensource.org/licenses/mit-license.php
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+/**
+ * @file progress-light.d.ts
+ */
+export type ProgressFormatOptions = {
+    fmt: string;
+    payload?: Record<string, string>;
+};
+export type TProgressLight = {
+    updateOptions(newFrames?: string[], newOpt?: ProgressFormatOptions): void;
+    deadline(): void;
+    newLine(): void;
+    setFPS(fps: number): void;
+    renderSync(): void;
+    run(): void;
+    stop(): void;
+    isRunning(): boolean;
+};
+/**
+ * @param {number} [fps]
+ * @param {() => string} [messageEmitter]
+ */
+export function create(fps?: number, messageEmitter?: () => string): TProgressLight;

package/extras/progress-light.js

@@ -0,0 +1,207 @@
+/*!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  Copyright (C) 2026 jeffy-g <hirotom1107@gmail.com>
+  Released under the MIT license
+  https://opensource.org/licenses/mit-license.php
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+"use strict";
+/**
+ * [usage]
+ * > node -i
+ * let t = require("./extras/progress-light");
+ * let p = t.create();
+ * p.run();
+ * p.stop();
+ */
+const rl = require("readline");
+/**
+ * @typedef {{ fmt: string, payload?: Record<string, string> }} ProgressFormatOptions
+ */
+/**
+ * @typedef {{
+ *   updateOptions(newFrames?: string[], newOpt?: ProgressFormatOptions): void;
+ *   deadline(): void;
+ *   newLine(): void;
+ *   setFPS(fps: number): void;
+ *   renderSync(): void;
+ *   run(): void;
+ *   stop(): void;
+ *   isRunning(): boolean;
+ * }} TProgressLight
+ */
+/**
+ * @param {boolean} enabled
+ * @param {NodeJS.WriteStream} [output]
+ */
+const cursor = (enabled, output = process.stderr) => {
+  if (enabled) {
+    output.write("\x1B[?25h");
+  } else {
+    output.write("\x1B[?25l");
+  }
+};
+/**
+ * @param {string=} msg
+ * @param {number=} row
+ */
+const renderLine = (msg, row) => {
+  const output = process.stderr || process.stdout;
+  rl.cursorTo(output, 0, row);
+  msg && (output.write(msg), rl.clearLine(output, 1));
+};
+/**
+ * @param {string[]} frames
+ * @param {ProgressFormatOptions} [formatOpt]
+ */
+const createProgressSync = (frames, formatOpt) => {
+  const fsize = frames.length;
+  let index = 0;
+  /** @type {string | undefined} */
+  let fmt;
+  /** @type {Record<string, string>} */
+  let payload = {};
+  /** @type {string[]} */
+  let keys = [];
+  if (formatOpt) {
+    fmt = formatOpt.fmt;
+    payload = formatOpt.payload || {};
+    keys = Object.keys(payload);
+  }
+  /**
+   * @param {string} tick
+   * @param {string} msg
+   */
+  const formatter = (tick, msg) => {
+    if (fmt) {
+      let content = fmt;
+      for (let i = 0, end = keys.length; i < end; ) {
+        const key = keys[i++];
+        content = content.replace("{" + key + "}", payload[key]);
+      }
+      return content.replace("{tick}", tick).replace("{msg}", msg);
+    }
+    return `[${tick}]: ${msg}`;
+  };
+  return /** @type {(msg: string, done?: boolean) => void} */ ((msg, done = false) => {
+    const tick = done ? "-done-" : frames[index++ % fsize];
+    const line = msg ? formatter(tick, msg) : "";
+    renderLine(line);
+  });
+};
+/**
+ * @param {string[]} frames
+ * @param {ProgressFormatOptions} formatOpt
+ * @param {() => string} messageEmitter
+ * @returns {TProgressLight}
+ */
+const createProgressObject = (frames, formatOpt, messageEmitter) => {
+  let done = false;
+  const render = () => {
+    progress(messageEmitter(), done);
+  };
+  let progress = createProgressSync(frames, formatOpt);
+  /** @type {ReturnType<typeof setInterval> | undefined} */
+  let timer;
+  let ms = 33;
+  return {
+    updateOptions(newFrames, newOpt) {
+      if (Array.isArray(newFrames) && typeof newFrames[0] === "string") {
+        frames = newFrames;
+      }
+      if (typeof newOpt === "object" && newOpt && newOpt.fmt) {
+        formatOpt = newOpt;
+      }
+      done = false;
+      progress = createProgressSync(frames, formatOpt);
+    },
+    deadline() {
+      (done = true), render();
+    },
+    newLine() {
+      console.log();
+    },
+    setFPS(fps) {
+      ms = (1000 / fps) | 0;
+      if (timer) {
+        clearInterval(timer);
+        timer = setInterval(render, ms);
+      }
+    },
+    renderSync() {
+      progress(messageEmitter(), done);
+    },
+    run() {
+      cursor(false);
+      done = false;
+      if (timer) {
+        return;
+      }
+      timer = setInterval(render, ms);
+    },
+    stop() {
+      done = true;
+      clearInterval(timer);
+      timer = void 0;
+      cursor(true);
+    },
+    isRunning() {
+      return !!timer;
+    },
+  };
+};
+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 {
+    return "- - error - -";
+  }
+};
+/**
+ * @param {number} [fps]
+ * @param {() => string} [messageEmitter]
+ * @returns {TProgressLight}
+ */
+const create = (fps = 30, messageEmitter) => {
+  const frames = [
+    "⠋",
+    "⠙",
+    "⠹",
+    "⠸",
+    "⠼",
+    "⠴",
+    "⠦",
+    "⠧",
+    "⠇",
+    "⠏",
+  ];
+  !messageEmitter && (messageEmitter = pcb);
+  /** @type {TProgressLight} */
+  const progress = createProgressObject(
+    frames, {
+      fmt: "{tick} - {msg}",
+      payload: {},
+    },
+    messageEmitter,
+  );
+  progress.setFPS(fps);
+  return progress;
+};
+module.exports = {
+  create,
+};

package/lib/unzip.min.js

@@ -1,4 +1,6 @@
-/*! @license zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */ /*! (C) 2022 jeffy-g https://github.com/jeffy-g Released under the MIT license https://opensource.org/licenses/mit-license.php */ (function () {
+/*! @license zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */ /*! (C) 2022 jeffy-g https://github.com/jeffy-g Released under the MIT license https://opensource.org/licenses/mit-license.php */
+// @ts-nocheck
+(function () {
   var m,
     aa = this;
   Math.floor(2147483648 * Math.random()).toString(36);