ansimax 1.2.3 → 1.2.5

package/dist/index.js

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ASCII_RAMPS: () => ASCII_RAMPS,
   BEL: () => BEL,
   BG: () => BG,
   CONFIG_DEFAULTS: () => DEFAULTS,
@@ -80,11 +81,13 @@ __export(index_exports, {
   escapeRegex: () => escapeRegex,
   fg256: () => fg256,
   fgRgb: () => fgRgb,
+  figletText: () => figletText,
   filterTree: () => filterTree,
   findInTree: () => findInTree,
   flipHorizontal: () => flipHorizontal,
   flipVertical: () => flipVertical,
   frames: () => frames,
+  fromImage: () => fromImage,
   getConfig: () => getConfig,
   getConfigValue: () => getConfigValue,
   getRenderCacheSize: () => getRenderCacheSize,
@@ -118,8 +121,10 @@ __export(index_exports, {
   padBoth: () => padBoth,
   padEnd: () => padEnd,
   padStart: () => padStart,
+  parseFiglet: () => parseFiglet,
   pauseListeners: () => pauseListeners,
   presetNames: () => presetNames,
+  presets: () => presets,
   rainbow: () => rainbow,
   registerFont: () => registerFont,
   registerPreset: () => registerPreset,
@@ -136,6 +141,7 @@ __export(index_exports, {
   resetLoaderCursorCount: () => resetLoaderCursorCount,
   resetNoColor: () => resetNoColor,
   resumeListeners: () => resumeListeners,
+  reverseGradient: () => reverseGradient,
   rgbTo256: () => rgbTo256,
   rgbToHex: () => rgbToHex,
   rotate90: () => rotate90,
@@ -1167,10 +1173,11 @@ var gradient = (text, stops, opts = {}) => {
   return _gradientAnsiAware(s, colors, easingFn, phaseN);
 };
 var createGradient = (stops, defaultOpts = {}) => {
-  const colors = Array.isArray(stops) ? stops.map(safeHex).filter((c) => c !== null) : [];
+  const originalStops = Array.isArray(stops) ? [...stops] : [];
+  const colors = originalStops.map(safeHex).filter((c) => c !== null);
   const defaultEasingFn = resolveEasing(defaultOpts.easing);
   const defaultPreserveAnsi = defaultOpts.preserveAnsi ?? false;
-  return (text, opts = {}) => {
+  const fn = ((text, opts = {}) => {
     const s = coerceText(text);
     if (!s || isNoColor()) return s;
     if (colors.length === 0) return s;
@@ -1186,8 +1193,31 @@ var createGradient = (stops, defaultOpts = {}) => {
       return _gradientPlain(s, colors, easingFn, phaseN);
     }
     return _gradientAnsiAware(s, colors, easingFn, phaseN);
-  };
+  });
+  Object.defineProperty(fn, "stops", {
+    value: Object.freeze(originalStops),
+    enumerable: true,
+    writable: false
+  });
+  Object.defineProperty(fn, "resolvedStops", {
+    value: Object.freeze(colors.map((c) => Object.freeze({ ...c }))),
+    enumerable: true,
+    writable: false
+  });
+  Object.defineProperty(fn, "defaultOptions", {
+    value: Object.freeze({ ...defaultOpts }),
+    enumerable: true,
+    writable: false
+  });
+  return fn;
 };
+function reverseGradient(input) {
+  if (Array.isArray(input)) {
+    return [...input].reverse();
+  }
+  const reversedStops = [...input.stops].reverse();
+  return createGradient(reversedStops, input.defaultOptions);
+}
 var _gradientPlain = (text, colors, easingFn, phase) => {
   const chars = [...text];
   const visible = chars.filter((c) => c !== " ").length;
@@ -2489,6 +2519,251 @@ var stream = async function* (text, opts = {}) {
     yield i === lines.length - 1 ? line : line + "\n";
   }
 };
+var ASCII_RAMPS = {
+  standard: " .:-=+*#%@",
+  detailed: " .'`^\",:;Il!i><~+_-?][}{1)(|/tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$",
+  blocks: " \u2591\u2592\u2593\u2588",
+  simple: " .+#"
+};
+var _resolveRamp = (r) => {
+  if (typeof r === "string" && r.length > 0) {
+    if (r in ASCII_RAMPS) return ASCII_RAMPS[r];
+    return r;
+  }
+  return ASCII_RAMPS.standard;
+};
+var _luminance = (p) => {
+  if (!p) return 0;
+  return 0.2126 * p.r + 0.7152 * p.g + 0.0722 * p.b;
+};
+var _sobelEdges = (pixels) => {
+  const h = pixels.length;
+  const w = h > 0 ? pixels[0].length : 0;
+  const out = Array.from({ length: h }, () => new Array(w).fill(0));
+  for (let y = 1; y < h - 1; y++) {
+    const rowPrev = pixels[y - 1];
+    const row = pixels[y];
+    const rowNext = pixels[y + 1];
+    const outRow = out[y];
+    for (let x = 1; x < w - 1; x++) {
+      const tl = _luminance(rowPrev[x - 1]);
+      const t = _luminance(rowPrev[x]);
+      const tr = _luminance(rowPrev[x + 1]);
+      const l = _luminance(row[x - 1]);
+      const r = _luminance(row[x + 1]);
+      const bl = _luminance(rowNext[x - 1]);
+      const b = _luminance(rowNext[x]);
+      const br = _luminance(rowNext[x + 1]);
+      const gx = -tl + tr - 2 * l + 2 * r - bl + br;
+      const gy = -tl - 2 * t - tr + bl + 2 * b + br;
+      const mag = Math.sqrt(gx * gx + gy * gy);
+      outRow[x] = Math.min(255, mag);
+    }
+  }
+  return out;
+};
+var _floydSteinberg = (lum, levels) => {
+  const h = lum.length;
+  if (h === 0) return lum;
+  const w = lum[0].length;
+  if (w === 0) return lum;
+  const out = lum.map((row) => [...row]);
+  const step = 255 / Math.max(1, levels - 1);
+  for (let y = 0; y < h; y++) {
+    const row = out[y];
+    for (let x = 0; x < w; x++) {
+      const oldPixel = row[x];
+      const quantLevel = Math.round(oldPixel / step);
+      const newPixel = quantLevel * step;
+      row[x] = newPixel;
+      const err = oldPixel - newPixel;
+      if (x + 1 < w) {
+        row[x + 1] = row[x + 1] + err * 7 / 16;
+      }
+      if (y + 1 < h) {
+        const next = out[y + 1];
+        if (x > 0) next[x - 1] = next[x - 1] + err * 3 / 16;
+        next[x] = next[x] + err * 5 / 16;
+        if (x + 1 < w) next[x + 1] = next[x + 1] + err * 1 / 16;
+      }
+    }
+  }
+  return out;
+};
+var _resizePixels = (pixels, targetW, targetH) => {
+  const srcH = pixels.length;
+  if (srcH === 0) return [];
+  const srcW = pixels[0].length;
+  if (srcW === 0) return [];
+  const out = [];
+  for (let y = 0; y < targetH; y++) {
+    const sy = Math.min(srcH - 1, Math.floor(y / targetH * srcH));
+    const srcRow = pixels[sy];
+    const newRow = new Array(targetW);
+    for (let x = 0; x < targetW; x++) {
+      const sx = Math.min(srcW - 1, Math.floor(x / targetW * srcW));
+      newRow[x] = srcRow[sx];
+    }
+    out.push(newRow);
+  }
+  return out;
+};
+var _toLuminanceGrid = (pixels) => {
+  return pixels.map((row) => row.map((p) => _luminance(p)));
+};
+var _enhanceForFace = (lum) => {
+  const flat = [];
+  for (const row of lum) for (const v of row) flat.push(v);
+  if (flat.length === 0) return lum;
+  flat.sort((a, b) => a - b);
+  const lo = flat[Math.floor(flat.length * 0.1)];
+  const hi = flat[Math.floor(flat.length * 0.9)];
+  const range = Math.max(1, hi - lo);
+  return lum.map(
+    (row) => row.map((v) => {
+      const stretched = (v - lo) / range * 255;
+      return Math.max(0, Math.min(255, stretched));
+    })
+  );
+};
+var fromImage = (pixels, opts = {}) => {
+  if (!Array.isArray(pixels) || pixels.length === 0) return "";
+  const firstRow = pixels[0];
+  if (!Array.isArray(firstRow) || firstRow.length === 0) return "";
+  const {
+    width = 80,
+    ramp = "standard",
+    invert = false,
+    dither = "none",
+    edgeDetect = "none",
+    edgeThreshold = 40,
+    color: color2 = false,
+    faceMode = false
+  } = opts;
+  const srcH = pixels.length;
+  const srcW = pixels[0].length;
+  const safeW = Math.max(1, Math.floor(width));
+  const computedH = Math.max(1, Math.round(srcH / srcW * safeW * 0.5));
+  const safeH = opts.height != null ? Math.max(1, Math.floor(opts.height)) : computedH;
+  const resized = _resizePixels(pixels, safeW, safeH);
+  let lum = _toLuminanceGrid(resized);
+  if (faceMode) lum = _enhanceForFace(lum);
+  let edgeGrid = null;
+  if (edgeDetect === "sobel") {
+    edgeGrid = _sobelEdges(resized);
+  }
+  const rampStr = _resolveRamp(ramp);
+  const rampLen = rampStr.length;
+  if (dither === "floyd-steinberg" && !edgeGrid) {
+    lum = _floydSteinberg(lum, rampLen);
+  }
+  const useColor = color2 && !isNoColor();
+  const lines = [];
+  for (let y = 0; y < safeH; y++) {
+    const lumRow = lum[y];
+    const pxRow = resized[y];
+    const edgeRow = edgeGrid ? edgeGrid[y] : null;
+    let line = "";
+    for (let x = 0; x < safeW; x++) {
+      let charIdx;
+      if (edgeRow) {
+        const edge = edgeRow[x];
+        const t = edge >= edgeThreshold ? Math.min(1, edge / 255) : 0;
+        charIdx = invert ? Math.round((1 - t) * (rampLen - 1)) : Math.round(t * (rampLen - 1));
+      } else {
+        const l = lumRow[x] / 255;
+        const tNorm = invert ? 1 - l : l;
+        charIdx = Math.min(rampLen - 1, Math.max(0, Math.round(tNorm * (rampLen - 1))));
+      }
+      const ch = rampStr[charIdx];
+      if (useColor) {
+        const p = pxRow[x];
+        if (p) {
+          line += fgRgb(p.r, p.g, p.b) + ch;
+        } else {
+          line += ch;
+        }
+      } else {
+        line += ch;
+      }
+    }
+    if (useColor) line += reset();
+    lines.push(line);
+  }
+  return lines.join("\n");
+};
+var parseFiglet = (flfContent) => {
+  if (typeof flfContent !== "string" || flfContent.length === 0) {
+    throw new TypeError("parseFiglet: input must be a non-empty string");
+  }
+  const lines = flfContent.split(/\r?\n/);
+  if (lines.length === 0) {
+    throw new TypeError("parseFiglet: empty content");
+  }
+  const header = lines[0];
+  const m = /^flf2.\s*(\S)\s+(-?\d+)\s+(-?\d+)\s+(-?\d+)\s+(-?\d+)\s+(\d+)/.exec(header);
+  if (!m) {
+    throw new TypeError('parseFiglet: invalid FIGfont header (expected "flf2a$..." line)');
+  }
+  const hardblank = m[1];
+  const height = parseInt(m[2], 10);
+  const commentLines = parseInt(m[6], 10);
+  if (!Number.isFinite(height) || height <= 0) {
+    throw new TypeError(`parseFiglet: invalid height ${m[2]}`);
+  }
+  let cursor2 = 1 + Math.max(0, commentLines);
+  const glyphs = /* @__PURE__ */ new Map();
+  for (let code = 32; code <= 126; code++) {
+    if (cursor2 + height > lines.length) break;
+    const rows = [];
+    for (let r = 0; r < height; r++) {
+      const raw = lines[cursor2 + r];
+      const endmark = raw.charAt(raw.length - 1);
+      let stripped = raw;
+      while (stripped.length > 0 && stripped.charAt(stripped.length - 1) === endmark) {
+        stripped = stripped.slice(0, -1);
+      }
+      rows.push(stripped);
+    }
+    glyphs.set(code, rows);
+    cursor2 += height;
+  }
+  return { hardblank, height, glyphs };
+};
+var figletText = (text, font, opts = {}) => {
+  if (typeof text !== "string") return "";
+  if (!font || !font.glyphs || font.height <= 0) return "";
+  const { trim = true, colorFn = null } = opts;
+  const glyphsForText = [];
+  for (const ch of text) {
+    const code = ch.codePointAt(0) ?? 32;
+    const glyph = font.glyphs.get(code);
+    if (glyph) {
+      glyphsForText.push(glyph);
+    } else {
+      const fallback = font.glyphs.get(32);
+      glyphsForText.push(fallback ?? new Array(font.height).fill(""));
+    }
+  }
+  const hardblankRe = new RegExp(_escapeRe(font.hardblank), "g");
+  const rows = [];
+  for (let r = 0; r < font.height; r++) {
+    let row = "";
+    for (const g of glyphsForText) {
+      row += g[r] ?? "";
+    }
+    row = row.replace(hardblankRe, " ");
+    rows.push(row);
+  }
+  let result = rows.join("\n");
+  if (trim) {
+    const trimmed = rows.filter((row) => row.trim().length > 0);
+    result = trimmed.length > 0 ? trimmed.join("\n") : rows.join("\n");
+  }
+  if (colorFn) result = colorFn(result);
+  return result;
+};
+var _escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 var ascii = {
   big,
   small,
@@ -2499,6 +2774,10 @@ var ascii = {
   logo,
   stream,
   measure,
+  // v1.2.5 — Phase 3 closure
+  fromImage,
+  figletText,
+  parseFiglet,
   // Pipeline stages — exposed for custom compositions
   stageRender,
   stageAlign,
@@ -5471,6 +5750,7 @@ var ansimax = { color, animate, ascii, loader, frames, components, trees, themes
 var index_default = ansimax;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ASCII_RAMPS,
   BEL,
   BG,
   CONFIG_DEFAULTS,
@@ -5520,11 +5800,13 @@ var index_default = ansimax;
   escapeRegex,
   fg256,
   fgRgb,
+  figletText,
   filterTree,
   findInTree,
   flipHorizontal,
   flipVertical,
   frames,
+  fromImage,
   getConfig,
   getConfigValue,
   getRenderCacheSize,
@@ -5558,8 +5840,10 @@ var index_default = ansimax;
   padBoth,
   padEnd,
   padStart,
+  parseFiglet,
   pauseListeners,
   presetNames,
+  presets,
   rainbow,
   registerFont,
   registerPreset,
@@ -5576,6 +5860,7 @@ var index_default = ansimax;
   resetLoaderCursorCount,
   resetNoColor,
   resumeListeners,
+  reverseGradient,
   rgbTo256,
   rgbToHex,
   rotate90,