@visulima/tui 0.0.1 → 1.0.0-alpha.2

package/dist/packem_shared/ansi-tokenizer-LHq2LUWA.js

@@ -0,0 +1,307 @@
+const bellCharacter = "\x07";
+const escapeCharacter = "\x1B";
+const stringTerminatorCharacter = "œ";
+const csiCharacter = "›";
+const oscCharacter = "";
+const dcsCharacter = "";
+const pmCharacter = "ž";
+const apcCharacter = "Ÿ";
+const sosCharacter = "˜";
+const isCsiParameterCharacter = (character) => {
+  const codePoint = character.codePointAt(0);
+  return codePoint !== void 0 && codePoint >= 48 && codePoint <= 63;
+};
+const isCsiIntermediateCharacter = (character) => {
+  const codePoint = character.codePointAt(0);
+  return codePoint !== void 0 && codePoint >= 32 && codePoint <= 47;
+};
+const isCsiFinalCharacter = (character) => {
+  const codePoint = character.codePointAt(0);
+  return codePoint !== void 0 && codePoint >= 64 && codePoint <= 126;
+};
+const isEscapeIntermediateCharacter = (character) => {
+  const codePoint = character.codePointAt(0);
+  return codePoint !== void 0 && codePoint >= 32 && codePoint <= 47;
+};
+const isEscapeFinalCharacter = (character) => {
+  const codePoint = character.codePointAt(0);
+  return codePoint !== void 0 && codePoint >= 48 && codePoint <= 126;
+};
+const isC1ControlCharacter = (character) => {
+  const codePoint = character.codePointAt(0);
+  return codePoint !== void 0 && codePoint >= 128 && codePoint <= 159;
+};
+const readCsiSequence = (text, fromIndex) => {
+  let index = fromIndex;
+  while (index < text.length) {
+    const character = text[index];
+    if (!isCsiParameterCharacter(character)) {
+      break;
+    }
+    index++;
+  }
+  const parameterString = text.slice(fromIndex, index);
+  const intermediateStartIndex = index;
+  while (index < text.length) {
+    const character = text[index];
+    if (!isCsiIntermediateCharacter(character)) {
+      break;
+    }
+    index++;
+  }
+  const intermediateString = text.slice(intermediateStartIndex, index);
+  const finalCharacter = text[index];
+  if (finalCharacter === void 0 || !isCsiFinalCharacter(finalCharacter)) {
+    return void 0;
+  }
+  return {
+    endIndex: index + 1,
+    finalCharacter,
+    intermediateString,
+    parameterString
+  };
+};
+const findControlStringTerminatorIndex = (text, fromIndex, allowBellTerminator) => {
+  for (let index = fromIndex; index < text.length; index++) {
+    const character = text[index];
+    if (allowBellTerminator && character === bellCharacter) {
+      return index + 1;
+    }
+    if (character === stringTerminatorCharacter) {
+      return index + 1;
+    }
+    if (character === escapeCharacter) {
+      const followingCharacter = text[index + 1];
+      if (followingCharacter === escapeCharacter) {
+        index++;
+        continue;
+      }
+      if (followingCharacter === "\\") {
+        return index + 2;
+      }
+    }
+  }
+  return void 0;
+};
+const readEscapeSequence = (text, fromIndex) => {
+  let index = fromIndex;
+  while (index < text.length) {
+    const character = text[index];
+    if (!isEscapeIntermediateCharacter(character)) {
+      break;
+    }
+    index++;
+  }
+  const intermediateString = text.slice(fromIndex, index);
+  const finalCharacter = text[index];
+  if (finalCharacter === void 0 || !isEscapeFinalCharacter(finalCharacter)) {
+    return void 0;
+  }
+  return {
+    endIndex: index + 1,
+    finalCharacter,
+    intermediateString
+  };
+};
+const getControlStringFromEscapeIntroducer = (character) => {
+  switch (character) {
+    case "]": {
+      return { allowBellTerminator: true, type: "osc" };
+    }
+    case "^": {
+      return { allowBellTerminator: false, type: "pm" };
+    }
+    case "_": {
+      return { allowBellTerminator: false, type: "apc" };
+    }
+    case "P": {
+      return { allowBellTerminator: false, type: "dcs" };
+    }
+    case "X": {
+      return { allowBellTerminator: false, type: "sos" };
+    }
+    default: {
+      return void 0;
+    }
+  }
+};
+const getControlStringFromC1Introducer = (character) => {
+  switch (character) {
+    case apcCharacter: {
+      return { allowBellTerminator: false, type: "apc" };
+    }
+    case dcsCharacter: {
+      return { allowBellTerminator: false, type: "dcs" };
+    }
+    case oscCharacter: {
+      return { allowBellTerminator: true, type: "osc" };
+    }
+    case pmCharacter: {
+      return { allowBellTerminator: false, type: "pm" };
+    }
+    case sosCharacter: {
+      return { allowBellTerminator: false, type: "sos" };
+    }
+    default: {
+      return void 0;
+    }
+  }
+};
+const hasAnsiControlCharacters = (text) => {
+  if (text.includes(escapeCharacter)) {
+    return true;
+  }
+  for (const character of text) {
+    if (isC1ControlCharacter(character)) {
+      return true;
+    }
+  }
+  return false;
+};
+const malformedFromIndex = (tokens, text, textStartIndex, fromIndex) => {
+  if (fromIndex > textStartIndex) {
+    tokens.push({ type: "text", value: text.slice(textStartIndex, fromIndex) });
+  }
+  tokens.push({ type: "invalid", value: text.slice(fromIndex) });
+  return tokens;
+};
+const tokenizeAnsi = (text) => {
+  if (!hasAnsiControlCharacters(text)) {
+    return [{ type: "text", value: text }];
+  }
+  const tokens = [];
+  let textStartIndex = 0;
+  for (let index = 0; index < text.length; ) {
+    const character = text[index];
+    if (character === void 0) {
+      break;
+    }
+    if (character === escapeCharacter) {
+      const followingCharacter = text[index + 1];
+      if (followingCharacter === void 0) {
+        return malformedFromIndex(tokens, text, textStartIndex, index);
+      }
+      if (followingCharacter === "[") {
+        const csiSequence = readCsiSequence(text, index + 2);
+        if (csiSequence === void 0) {
+          return malformedFromIndex(tokens, text, textStartIndex, index);
+        }
+        if (index > textStartIndex) {
+          tokens.push({ type: "text", value: text.slice(textStartIndex, index) });
+        }
+        tokens.push({
+          finalCharacter: csiSequence.finalCharacter,
+          intermediateString: csiSequence.intermediateString,
+          parameterString: csiSequence.parameterString,
+          type: "csi",
+          value: text.slice(index, csiSequence.endIndex)
+        });
+        index = csiSequence.endIndex;
+        textStartIndex = index;
+        continue;
+      }
+      const escapeControlString = getControlStringFromEscapeIntroducer(followingCharacter);
+      if (escapeControlString !== void 0) {
+        const controlStringTerminatorIndex = findControlStringTerminatorIndex(text, index + 2, escapeControlString.allowBellTerminator);
+        if (controlStringTerminatorIndex === void 0) {
+          return malformedFromIndex(tokens, text, textStartIndex, index);
+        }
+        if (index > textStartIndex) {
+          tokens.push({ type: "text", value: text.slice(textStartIndex, index) });
+        }
+        tokens.push({
+          type: escapeControlString.type,
+          value: text.slice(index, controlStringTerminatorIndex)
+        });
+        index = controlStringTerminatorIndex;
+        textStartIndex = index;
+        continue;
+      }
+      const escapeSequence = readEscapeSequence(text, index + 1);
+      if (escapeSequence === void 0) {
+        if (isEscapeIntermediateCharacter(followingCharacter)) {
+          return malformedFromIndex(tokens, text, textStartIndex, index);
+        }
+        if (index > textStartIndex) {
+          tokens.push({ type: "text", value: text.slice(textStartIndex, index) });
+        }
+        index++;
+        textStartIndex = index;
+        continue;
+      }
+      if (index > textStartIndex) {
+        tokens.push({ type: "text", value: text.slice(textStartIndex, index) });
+      }
+      tokens.push({
+        finalCharacter: escapeSequence.finalCharacter,
+        intermediateString: escapeSequence.intermediateString,
+        type: "esc",
+        value: text.slice(index, escapeSequence.endIndex)
+      });
+      index = escapeSequence.endIndex;
+      textStartIndex = index;
+      continue;
+    }
+    if (character === csiCharacter) {
+      const csiSequence = readCsiSequence(text, index + 1);
+      if (csiSequence === void 0) {
+        return malformedFromIndex(tokens, text, textStartIndex, index);
+      }
+      if (index > textStartIndex) {
+        tokens.push({ type: "text", value: text.slice(textStartIndex, index) });
+      }
+      tokens.push({
+        finalCharacter: csiSequence.finalCharacter,
+        intermediateString: csiSequence.intermediateString,
+        parameterString: csiSequence.parameterString,
+        type: "csi",
+        value: text.slice(index, csiSequence.endIndex)
+      });
+      index = csiSequence.endIndex;
+      textStartIndex = index;
+      continue;
+    }
+    const c1ControlString = getControlStringFromC1Introducer(character);
+    if (c1ControlString !== void 0) {
+      const controlStringTerminatorIndex = findControlStringTerminatorIndex(text, index + 1, c1ControlString.allowBellTerminator);
+      if (controlStringTerminatorIndex === void 0) {
+        return malformedFromIndex(tokens, text, textStartIndex, index);
+      }
+      if (index > textStartIndex) {
+        tokens.push({ type: "text", value: text.slice(textStartIndex, index) });
+      }
+      tokens.push({
+        type: c1ControlString.type,
+        value: text.slice(index, controlStringTerminatorIndex)
+      });
+      index = controlStringTerminatorIndex;
+      textStartIndex = index;
+      continue;
+    }
+    if (character === stringTerminatorCharacter) {
+      if (index > textStartIndex) {
+        tokens.push({ type: "text", value: text.slice(textStartIndex, index) });
+      }
+      tokens.push({ type: "st", value: character });
+      index++;
+      textStartIndex = index;
+      continue;
+    }
+    if (isC1ControlCharacter(character)) {
+      if (index > textStartIndex) {
+        tokens.push({ type: "text", value: text.slice(textStartIndex, index) });
+      }
+      tokens.push({ type: "c1", value: character });
+      index++;
+      textStartIndex = index;
+      continue;
+    }
+    index++;
+  }
+  if (textStartIndex < text.length) {
+    tokens.push({ type: "text", value: text.slice(textStartIndex) });
+  }
+  return tokens;
+};
+
+export { hasAnsiControlCharacters as h, tokenizeAnsi as t };

package/dist/packem_shared/boxes-oi3WUbyR.js

@@ -0,0 +1,92 @@
+var single = {
+	topLeft: "┌",
+	top: "─",
+	topRight: "┐",
+	right: "│",
+	bottomRight: "┘",
+	bottom: "─",
+	bottomLeft: "└",
+	left: "│"
+};
+var double = {
+	topLeft: "╔",
+	top: "═",
+	topRight: "╗",
+	right: "║",
+	bottomRight: "╝",
+	bottom: "═",
+	bottomLeft: "╚",
+	left: "║"
+};
+var round = {
+	topLeft: "╭",
+	top: "─",
+	topRight: "╮",
+	right: "│",
+	bottomRight: "╯",
+	bottom: "─",
+	bottomLeft: "╰",
+	left: "│"
+};
+var bold = {
+	topLeft: "┏",
+	top: "━",
+	topRight: "┓",
+	right: "┃",
+	bottomRight: "┛",
+	bottom: "━",
+	bottomLeft: "┗",
+	left: "┃"
+};
+var singleDouble = {
+	topLeft: "╓",
+	top: "─",
+	topRight: "╖",
+	right: "║",
+	bottomRight: "╜",
+	bottom: "─",
+	bottomLeft: "╙",
+	left: "║"
+};
+var doubleSingle = {
+	topLeft: "╒",
+	top: "═",
+	topRight: "╕",
+	right: "│",
+	bottomRight: "╛",
+	bottom: "═",
+	bottomLeft: "╘",
+	left: "│"
+};
+var classic = {
+	topLeft: "+",
+	top: "-",
+	topRight: "+",
+	right: "|",
+	bottomRight: "+",
+	bottom: "-",
+	bottomLeft: "+",
+	left: "|"
+};
+var arrow = {
+	topLeft: "↘",
+	top: "↓",
+	topRight: "↙",
+	right: "←",
+	bottomRight: "↖",
+	bottom: "↑",
+	bottomLeft: "↗",
+	left: "→"
+};
+const cliBoxes = {
+	single: single,
+	double: double,
+	round: round,
+	bold: bold,
+	singleDouble: singleDouble,
+	doubleSingle: doubleSingle,
+	classic: classic,
+	arrow: arrow
+};
+
+export { cliBoxes as c };

package/dist/packem_shared/colorize-88_Vk8cn.js

@@ -0,0 +1,48 @@
+import colorizeDefault from '@visulima/colorize';
+
+const rgbRegex = /^rgb\(\s?(\d+),\s?(\d+),\s?(\d+)\s?\)$/;
+const ansiRegex = /^ansi256\(\s?(\d+)\s?\)$/;
+const isNamedColor = (color) => color in colorizeDefault;
+const colorize = (string_, color, type) => {
+  if (!color) {
+    return string_;
+  }
+  if (isNamedColor(color)) {
+    if (type === "foreground") {
+      return colorizeDefault[color](string_);
+    }
+    const methodName = `bg${color[0].toUpperCase() + color.slice(1)}`;
+    return colorizeDefault[methodName](string_);
+  }
+  if (color.startsWith("#")) {
+    return type === "foreground" ? colorizeDefault.hex(color)(string_) : colorizeDefault.bgHex(color)(string_);
+  }
+  if (color.startsWith("ansi256")) {
+    const matches = ansiRegex.exec(color);
+    if (!matches) {
+      return string_;
+    }
+    const value = Number(matches[1]);
+    return type === "foreground" ? colorizeDefault.ansi256(value)(string_) : colorizeDefault.bgAnsi256(value)(string_);
+  }
+  if (color.startsWith("rgb")) {
+    const matches = rgbRegex.exec(color);
+    if (!matches) {
+      return string_;
+    }
+    const firstValue = Number(matches[1]);
+    const secondValue = Number(matches[2]);
+    const thirdValue = Number(matches[3]);
+    return type === "foreground" ? colorizeDefault.rgb(firstValue, secondValue, thirdValue)(string_) : colorizeDefault.bgRgb(firstValue, secondValue, thirdValue)(string_);
+  }
+  return string_;
+};
+const getBackgroundColorEscape = (color) => {
+  const colorized = colorize("x", color, "background");
+  if (colorized !== "x") {
+    return colorized.split("x")[0];
+  }
+  return void 0;
+};
+
+export { colorize as c, getBackgroundColorEscape as g };