@reliverse/relinka 1.1.10 → 1.2.1

package/dist-npm/utils/decoder.js

@@ -1,281 +0,0 @@
-import { Buffer } from "safe-buffer";
-const isEncoding = Buffer.isEncoding || function(encoding) {
-  const enc = String(encoding).toLowerCase();
-  switch (enc) {
-    case "hex":
-    case "utf8":
-    case "utf-8":
-    case "ascii":
-    case "binary":
-    case "base64":
-    case "ucs2":
-    case "ucs-2":
-    case "utf16le":
-    case "utf-16le":
-    case "raw":
-      return true;
-    default:
-      return false;
-  }
-};
-function _normalizeEncoding(enc) {
-  if (!enc) {
-    return "utf8";
-  }
-  let retried = false;
-  let encoding = String(enc);
-  while (true) {
-    switch (encoding) {
-      case "utf8":
-      case "utf-8":
-        return "utf8";
-      case "ucs2":
-      case "ucs-2":
-      case "utf16le":
-      case "utf-16le":
-        return "utf16le";
-      case "latin1":
-      case "binary":
-        return "latin1";
-      case "base64":
-      case "ascii":
-      case "hex":
-        return encoding;
-      default:
-        if (retried) {
-          return void 0;
-        }
-        encoding = encoding.toLowerCase();
-        retried = true;
-    }
-  }
-}
-function normalizeEncoding(enc) {
-  const nenc = _normalizeEncoding(enc);
-  if (typeof nenc !== "string" && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) {
-    throw new Error("Unknown encoding: " + enc);
-  }
-  return nenc || enc;
-}
-export class StringDecoder {
-  encoding;
-  lastNeed;
-  lastTotal;
-  lastChar;
-  fillLast;
-  text;
-  endFn;
-  writeFn;
-  constructor(encoding) {
-    this.encoding = normalizeEncoding(encoding);
-    let nb;
-    switch (this.encoding) {
-      case "utf16le":
-        this.text = utf16Text;
-        this.endFn = utf16End;
-        nb = 4;
-        break;
-      case "utf8":
-        this.fillLast = utf8FillLast;
-        nb = 4;
-        break;
-      case "base64":
-        this.text = base64Text;
-        this.endFn = base64End;
-        nb = 3;
-        break;
-      default:
-        this.writeFn = simpleWrite;
-        this.endFn = simpleEnd;
-        return;
-    }
-    this.lastNeed = 0;
-    this.lastTotal = 0;
-    this.lastChar = Buffer.allocUnsafe(nb);
-    this.writeFn = this.write.bind(this);
-  }
-    write(buf) {
-    if (buf.length === 0) {
-      return "";
-    }
-    let r;
-    let i;
-    if (this.lastNeed) {
-      r = this.fillLast(buf);
-      if (r === void 0) {
-        return "";
-      }
-      i = this.lastNeed;
-      this.lastNeed = 0;
-    } else {
-      i = 0;
-    }
-    if (i < buf.length) {
-      return r ? r + (this.text ? this.text(buf, i) : "") : this.text ? this.text(buf, i) : "";
-    }
-    return r || "";
-  }
-  /**
-   * Ends the decoding and returns any remaining characters.
-   * @param buf - Optional buffer to write before ending.
-   * @returns The final decoded string.
-   */
-  end(buf) {
-    const result = this.endFn?.(buf) ?? "";
-    return result;
-  }
-}
-function utf8FillLast(buf) {
-  const p = this.lastTotal - this.lastNeed;
-  const r = utf8CheckExtraBytes(this, buf, p);
-  if (r !== void 0) {
-    return r;
-  }
-  if (this.lastNeed <= buf.length) {
-    buf.copy(this.lastChar, p, 0, this.lastNeed);
-    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
-  }
-  buf.copy(this.lastChar, p, 0, buf.length);
-  this.lastNeed -= buf.length;
-}
-function utf8Text(buf, i) {
-  const total = utf8CheckIncomplete(this, buf, i);
-  if (!this.lastNeed) {
-    return buf.toString("utf8", i);
-  }
-  this.lastTotal = total;
-  const end = buf.length - (total - this.lastNeed);
-  buf.copy(this.lastChar, 0, end);
-  return buf.toString("utf8", i, end);
-}
-function utf8End(buf) {
-  const r = buf?.length ? this.write(buf) : "";
-  if (this.lastNeed) {
-    return r + "\uFFFD";
-  }
-  return r;
-}
-function utf8CheckByte(byte) {
-  if (byte <= 127) {
-    return 0;
-  } else if (byte >> 5 === 6) {
-    return 2;
-  } else if (byte >> 4 === 14) {
-    return 3;
-  } else if (byte >> 3 === 30) {
-    return 4;
-  }
-  return byte >> 6 === 2 ? -1 : -2;
-}
-function utf8CheckIncomplete(self, buf, i) {
-  let j = buf.length - 1;
-  if (j < i) {
-    return 0;
-  }
-  let nb = utf8CheckByte(buf[j]);
-  if (nb >= 0) {
-    if (nb > 0) {
-      self.lastNeed = nb - 1;
-    }
-    return nb;
-  }
-  if (--j < i || nb === -2) {
-    return 0;
-  }
-  nb = utf8CheckByte(buf[j]);
-  if (nb >= 0) {
-    if (nb > 0) {
-      self.lastNeed = nb - 2;
-    }
-    return nb;
-  }
-  if (--j < i || nb === -2) {
-    return 0;
-  }
-  nb = utf8CheckByte(buf[j]);
-  if (nb >= 0) {
-    if (nb > 0) {
-      if (nb === 2) {
-        nb = 0;
-      } else {
-        self.lastNeed = nb - 3;
-      }
-    }
-    return nb;
-  }
-  return 0;
-}
-function utf8CheckExtraBytes(self, buf, p) {
-  if ((buf[0] & 192) !== 128) {
-    self.lastNeed = 0;
-    return "\uFFFD";
-  }
-  if (self.lastNeed > 1 && buf.length > 1) {
-    if ((buf[1] & 192) !== 128) {
-      self.lastNeed = 1;
-      return "\uFFFD";
-    }
-    if (self.lastNeed > 2 && buf.length > 2) {
-      if ((buf[2] & 192) !== 128) {
-        self.lastNeed = 2;
-        return "\uFFFD";
-      }
-    }
-  }
-}
-function utf16Text(buf, i) {
-  if ((buf.length - i) % 2 === 0) {
-    const r = buf.toString("utf16le", i);
-    if (r) {
-      const c = r.charCodeAt(r.length - 1);
-      if (c >= 55296 && c <= 56319) {
-        this.lastNeed = 2;
-        this.lastTotal = 4;
-        this.lastChar[0] = buf[buf.length - 2];
-        this.lastChar[1] = buf[buf.length - 1];
-        return r.slice(0, -1);
-      }
-    }
-    return r;
-  }
-  this.lastNeed = 1;
-  this.lastTotal = 2;
-  this.lastChar[0] = buf[buf.length - 1];
-  return buf.toString("utf16le", i, buf.length - 1);
-}
-function utf16End(buf) {
-  const r = buf?.length ? this.write(buf) : "";
-  if (this.lastNeed) {
-    const end = this.lastTotal - this.lastNeed;
-    return r + this.lastChar.toString("utf16le", 0, end);
-  }
-  return r;
-}
-function base64Text(buf, i) {
-  const n = (buf.length - i) % 3;
-  if (n === 0) {
-    return buf.toString("base64", i);
-  }
-  this.lastNeed = 3 - n;
-  this.lastTotal = 3;
-  if (n === 1) {
-    this.lastChar[0] = buf[buf.length - 1];
-  } else {
-    this.lastChar[0] = buf[buf.length - 2];
-    this.lastChar[1] = buf[buf.length - 1];
-  }
-  return buf.toString("base64", i, buf.length - n);
-}
-function base64End(buf) {
-  const r = buf?.length ? this.write(buf) : "";
-  if (this.lastNeed) {
-    return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
-  }
-  return r;
-}
-function simpleWrite(buf) {
-  return buf.toString(this.encoding);
-}
-function simpleEnd(buf) {
-  return buf?.length ? this.write(buf) : "";
-}

package/dist-npm/utils/errors.d.ts

@@ -1 +0,0 @@
-export declare const errorHandler: (error: Error, customMessage?: string) => never;

package/dist-npm/utils/errors.js

@@ -1,15 +0,0 @@
-export const errorHandler = (error, customMessage) => {
-  const separator = "\u2500".repeat(71);
-  console.error("\u2502" + separator);
-  console.error("\u2502  AN ERROR OCCURRED:\n\u2502 ", error.message);
-  console.error("\u2502" + separator);
-  if (customMessage) {
-    console.error("\u2502  " + customMessage);
-  } else {
-    console.error(
-      "\u2502  If this issue is related to @reliverse/relinka itself, please\n\u2502  report the details at https://github.com/reliverse/prompts/issues"
-    );
-  }
-  console.error("\u2570" + separator);
-  process.exit(1);
-};

package/dist-npm/utils/keypress.d.ts

@@ -1,7 +0,0 @@
-import type { Readable } from "stream";
-import type { Keypress } from "../types/keypress.js";
-declare const listenForKeys: {
-    (stream: Readable, callback: (key: Keypress) => void): (() => void);
-    parse: (s: string | Buffer, enc?: BufferEncoding) => Keypress | Keypress[];
-};
-export default listenForKeys;

package/dist-npm/utils/keypress.js

@@ -1,327 +0,0 @@
-import { StringDecoder } from "./decoder.js";
-const metaKeyCodeRe = /^(?:\u001b)([a-zA-Z0-9])$/;
-const functionKeyCodeRe = (
-  
-  /^(?:\u001b+)(O|N|\[|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/
-);
-const parse = (s, enc) => {
-  let parts;
-  const key = {
-    name: void 0,
-    ctrl: false,
-    meta: false,
-    shift: false,
-    sequence: s.toString(enc || "utf-8"),
-    raw: ""
-  };
-  if (Buffer.isBuffer(s)) {
-    if (s[0] > 127 && s[1] === void 0) {
-      s[0] -= 128;
-      s = Buffer.from("\x1B" + s.toString(enc || "utf-8"));
-    } else {
-      s = s.toString(enc || "utf-8");
-    }
-  }
-  const input = typeof s === "string" ? s : s.toString(enc || "utf-8");
-  if (input === "\r") {
-    key.name = "return";
-  } else if (input === "\n") {
-    key.name = "enter";
-  } else if (input === "	") {
-    key.name = "tab";
-  } else if (input === "\b" || input === "\x7F" || input === "\x1B\x7F" || input === "\x1B\b") {
-    key.name = "backspace";
-    key.meta = input.startsWith("\x1B");
-  } else if (input === "\x1B" || input === "\x1B\x1B") {
-    key.name = "escape";
-    key.meta = input.length === 2;
-  } else if (input === " " || input === "\x1B ") {
-    key.name = "space";
-    key.meta = input.length === 2;
-  } else if (input <= "") {
-    key.name = String.fromCharCode(input.charCodeAt(0) + "a".charCodeAt(0) - 1);
-    key.ctrl = true;
-  } else if (input.length === 1 && input >= "a" && input <= "z") {
-    key.name = input;
-  } else if (input.length === 1 && input >= "A" && input <= "Z") {
-    key.name = input.toLowerCase();
-    key.shift = true;
-  } else if (parts = metaKeyCodeRe.exec(input)) {
-    key.name = parts[1].toLowerCase();
-    key.meta = true;
-    key.shift = /^[A-Z]$/.test(parts[1]);
-  } else if (parts = functionKeyCodeRe.exec(input)) {
-    const code = (parts[1] || "") + (parts[2] || "") + (parts[4] || "") + (parts[6] || "");
-    const modifier = parseInt(parts[3] || parts[5] || "1", 10) - 1 || 0;
-    key.ctrl = !!(modifier & 4);
-    key.meta = !!(modifier & 10);
-    key.shift = !!(modifier & 1);
-    key.code = code;
-    switch (code) {
-            case "OP":
-        key.name = "f1";
-        break;
-      case "OQ":
-        key.name = "f2";
-        break;
-      case "OR":
-        key.name = "f3";
-        break;
-      case "OS":
-        key.name = "f4";
-        break;
-            case "[11~":
-        key.name = "f1";
-        break;
-      case "[12~":
-        key.name = "f2";
-        break;
-      case "[13~":
-        key.name = "f3";
-        break;
-      case "[14~":
-        key.name = "f4";
-        break;
-            case "[[A":
-        key.name = "f1";
-        break;
-      case "[[B":
-        key.name = "f2";
-        break;
-      case "[[C":
-        key.name = "f3";
-        break;
-      case "[[D":
-        key.name = "f4";
-        break;
-      case "[[E":
-        key.name = "f5";
-        break;
-            case "[15~":
-        key.name = "f5";
-        break;
-      case "[17~":
-        key.name = "f6";
-        break;
-      case "[18~":
-        key.name = "f7";
-        break;
-      case "[19~":
-        key.name = "f8";
-        break;
-      case "[20~":
-        key.name = "f9";
-        break;
-      case "[21~":
-        key.name = "f10";
-        break;
-      case "[23~":
-        key.name = "f11";
-        break;
-      case "[24~":
-        key.name = "f12";
-        break;
-            case "[A":
-        key.name = "up";
-        break;
-      case "[B":
-        key.name = "down";
-        break;
-      case "[C":
-        key.name = "right";
-        break;
-      case "[D":
-        key.name = "left";
-        break;
-      case "[E":
-        key.name = "clear";
-        break;
-      case "[F":
-        key.name = "end";
-        break;
-      case "[H":
-        key.name = "home";
-        break;
-            case "OA":
-        key.name = "up";
-        break;
-      case "OB":
-        key.name = "down";
-        break;
-      case "OC":
-        key.name = "right";
-        break;
-      case "OD":
-        key.name = "left";
-        break;
-      case "OE":
-        key.name = "clear";
-        break;
-      case "OF":
-        key.name = "end";
-        break;
-      case "OH":
-        key.name = "home";
-        break;
-            case "[1~":
-        key.name = "home";
-        break;
-      case "[2~":
-        key.name = "insert";
-        break;
-      case "[3~":
-        key.name = "delete";
-        break;
-      case "[4~":
-        key.name = "end";
-        break;
-      case "[5~":
-        key.name = "pageup";
-        break;
-      case "[6~":
-        key.name = "pagedown";
-        break;
-            case "[[5~":
-        key.name = "pageup";
-        break;
-      case "[[6~":
-        key.name = "pagedown";
-        break;
-            case "[7~":
-        key.name = "home";
-        break;
-      case "[8~":
-        key.name = "end";
-        break;
-            case "[a":
-        key.name = "up";
-        key.shift = true;
-        break;
-      case "[b":
-        key.name = "down";
-        key.shift = true;
-        break;
-      case "[c":
-        key.name = "right";
-        key.shift = true;
-        break;
-      case "[d":
-        key.name = "left";
-        key.shift = true;
-        break;
-      case "[e":
-        key.name = "clear";
-        key.shift = true;
-        break;
-      case "[2$":
-        key.name = "insert";
-        key.shift = true;
-        break;
-      case "[3$":
-        key.name = "delete";
-        key.shift = true;
-        break;
-      case "[5$":
-        key.name = "pageup";
-        key.shift = true;
-        break;
-      case "[6$":
-        key.name = "pagedown";
-        key.shift = true;
-        break;
-      case "[7$":
-        key.name = "home";
-        key.shift = true;
-        break;
-      case "[8$":
-        key.name = "end";
-        key.shift = true;
-        break;
-      case "Oa":
-        key.name = "up";
-        key.ctrl = true;
-        break;
-      case "Ob":
-        key.name = "down";
-        key.ctrl = true;
-        break;
-      case "Oc":
-        key.name = "right";
-        key.ctrl = true;
-        break;
-      case "Od":
-        key.name = "left";
-        key.ctrl = true;
-        break;
-      case "Oe":
-        key.name = "clear";
-        key.ctrl = true;
-        break;
-      case "[2^":
-        key.name = "insert";
-        key.ctrl = true;
-        break;
-      case "[3^":
-        key.name = "delete";
-        key.ctrl = true;
-        break;
-      case "[5^":
-        key.name = "pageup";
-        key.ctrl = true;
-        break;
-      case "[6^":
-        key.name = "pagedown";
-        key.ctrl = true;
-        break;
-      case "[7^":
-        key.name = "home";
-        key.ctrl = true;
-        break;
-      case "[8^":
-        key.name = "end";
-        key.ctrl = true;
-        break;
-            case "[Z":
-        key.name = "tab";
-        key.shift = true;
-        break;
-      default:
-        key.name = "undefined";
-        break;
-    }
-  } else if (input.length > 1 && !input.startsWith("\x1B")) {
-    return Array.from(input).map((c) => parse(c, enc)).flat();
-  }
-  key.raw = input;
-  return key;
-};
-const listenForKeys = (stream, callback) => {
-  if (!stream || typeof stream.isRaw !== "boolean") {
-    throw new Error("Invalid stream passed.");
-  }
-  if (typeof callback !== "function") {
-    throw new Error("Invalid callback passed.");
-  }
-  const decoder = new StringDecoder("utf8");
-  const onData = (raw) => {
-    const data = decoder.write(raw);
-    const keys = parse(data, "utf8");
-    if (Array.isArray(keys)) {
-      keys.forEach((key) => callback(key));
-    } else {
-      callback(keys);
-    }
-  };
-  const oldRawMode = stream.isRaw;
-  stream.setRawMode(true);
-  stream.on("data", onData);
-  stream.resume();
-  const stopListening = () => {
-    stream.setRawMode(oldRawMode);
-    stream.pause();
-    stream.removeListener("data", onData);
-  };
-  return stopListening;
-};
-listenForKeys.parse = parse;
-export default listenForKeys;

package/dist-npm/utils/mapping.d.ts

@@ -1,4 +0,0 @@
-import type { TypographyName } from "../types/general.js";
-import type { ColorName } from "../types/general.js";
-export declare const colorMap: Record<ColorName, (text: string) => string>;
-export declare const typographyMap: Record<TypographyName, (text: string) => string>;

package/dist-npm/utils/mapping.js

@@ -1,49 +0,0 @@
-import chalk from "chalk";
-import gradient, { cristal, mind, passion, retro, vice } from "gradient-string";
-import { rainbow } from "gradient-string";
-import colors from "picocolors";
-export const colorMap = {
-  none: colors.reset,
-  inverse: colors.inverse,
-  black: colors.black,
-  blue: colors.blue,
-  blueBright: colors.blueBright,
-  cyan: colors.cyan,
-  cyanBright: colors.cyanBright,
-  bgCyan: colors.bgCyan,
-  bgCyanBright: colors.bgCyanBright,
-  dim: colors.dim,
-  gray: colors.gray,
-  green: colors.green,
-  greenBright: colors.greenBright,
-  bgGreen: colors.bgGreen,
-  bgGreenBright: colors.bgGreenBright,
-  magenta: colors.magenta,
-  red: colors.red,
-  redBright: colors.redBright,
-  bgRed: colors.bgRed,
-  bgRedBright: colors.bgRedBright,
-  white: colors.white,
-  yellow: colors.yellow,
-  yellowBright: colors.yellowBright,
-  cristalGradient: cristal,
-  mindGradient: mind,
-  passionGradient: passion,
-  rainbowGradient: rainbow,
-  retroGradient: retro,
-  viceGradient: vice,
-  gradientGradient: gradient([
-    "red",
-    "yellow",
-    "green",
-    "cyan",
-    "blue",
-    "magenta"
-  ])
-};
-export const typographyMap = {
-  bold: chalk.bold,
-  italic: chalk.italic,
-  underline: chalk.underline,
-  strikethrough: chalk.strikethrough
-};

package/dist-npm/utils/messages.d.ts

@@ -1,17 +0,0 @@
-import type { ColorName, FmtMsgOptions } from "../types/general.js";
-export declare const symbols: {
-    pointer: string;
-    start: string;
-    middle: string;
-    end: string;
-    line: string;
-    corner_top_right: string;
-    step_active: string;
-    step_error: string;
-    info: string;
-};
-export declare const bar: ({ borderColor, }: {
-    borderColor?: ColorName;
-}) => string;
-export declare function fmt(opts: FmtMsgOptions): string;
-export declare function msg(opts: FmtMsgOptions): void;