console-toolkit 1.0.0

package/src/alphanumeric/unicode-numbers.js

@@ -0,0 +1,75 @@
+import {SymbolRange, transcode as internalTranscode} from './utils.js';
+import {minus, multiplication, superscriptPlus, superscriptMinus} from '../symbols.js';
+
+export const transcodeTables = {
+  // Enclosed Alphanumeric
+  circled: new SymbolRange('①', 1, 20),
+  parens: new SymbolRange('⑴', 1, 20),
+  dots: new SymbolRange('⒈', 1, 20),
+  doubleCircled: new SymbolRange('⓵', 1, 10),
+
+  // Mathematical Alphanumeric Symbols
+  bold: new SymbolRange('𝟎'),
+  doubleStruck: new SymbolRange('𝟘'),
+  sansSerif: new SymbolRange('𝟢'),
+  sansSerifBold: new SymbolRange('𝟬'),
+  mono: new SymbolRange('𝟶'),
+
+  // Enclosed Alphanumeric Supplement
+  commas: new SymbolRange('🄁'),
+
+  // Number Forms
+  roman: new SymbolRange('Ⅰ', 1, 12),
+  romanLower: new SymbolRange('ⅰ', 1, 12),
+
+  // Dingbats
+  dingbatsCircledSansSerif: new SymbolRange('➀', 1, 10),
+  dingbatsNegativeCircled: new SymbolRange('❶', 1, 10),
+  dingbatsNegativeCircledSansSerif: new SymbolRange('➊', 1, 10),
+
+  // Superscripts and Subscripts
+  superscript: new SymbolRange('⁰'),
+  subscript: new SymbolRange('₀')
+};
+
+// patches
+
+const circled_21_35 = new SymbolRange('\u{3251}', 21, 35),
+  circled_36_50 = new SymbolRange('\u{32B1}', 36, 50);
+circled_36_50.overlay = {0: '\u{24EA}'};
+circled_21_35.overlay = circled_36_50;
+transcodeTables.circled.overlay = circled_21_35;
+
+transcodeTables.dots.overlay = {0: '🄀'};
+
+const negativeCircled_11_20 = new SymbolRange('\u{24EB}', 11, 20);
+negativeCircled_11_20.overlay = {0: '\u{24FF}'};
+transcodeTables.dingbatsNegativeCircled.overlay = negativeCircled_11_20;
+
+transcodeTables.superscript.overlay = {1: '¹', 2: '²', 3: '³'};
+
+// API
+
+export const transcode = (s, name, options) => {
+  const table = typeof name == 'string' ? transcodeTables[name] : name;
+  if (!table) throw new Error(`There is no transcode table "${name}"`);
+  return internalTranscode(s, table, options);
+};
+
+export const numberPunctuation = (s, {addBefore = '', addAfter = ' '} = {}) =>
+  s.replace(
+    /(\d)([\,\.])/g,
+    (_, d, p) => addBefore + transcodeTables[p === '.' ? 'dots' : 'commas'].transcode(d) + addAfter
+  );
+
+export const numberExponent = (s, {useSpecialMinus} = {}) => {
+  const r = /^([+-]?)([^e]+)e([+-]?)(.+)$/i.exec(s);
+  return r
+    ? (r[1] === '-' && useSpecialMinus ? minus : r[1]) +
+        r[2] +
+        multiplication +
+        '10' +
+        (r[3] === '+' ? superscriptPlus : r[3] === '-' ? superscriptMinus : r[3]) +
+        transcode(r[4], transcodeTables.superscript)
+    : s;
+};

package/src/alphanumeric/utils.js

@@ -0,0 +1,44 @@
+export class SymbolRange {
+  constructor(fromSymbol, from = 0, to = 9, inputBase = '0') {
+    this.from = from;
+    this.to = to;
+    this.base = fromSymbol.codePointAt(0) - from;
+    this.inputBase = inputBase.codePointAt(0);
+    this.overlay = null;
+  }
+  get(i) {
+    if (this.overlay) {
+      const result =
+        typeof this.overlay.get == 'function'
+          ? this.overlay.get(i)
+          : this.overlay[typeof i !== 'number' ? i : String.fromCodePoint(this.inputBase + i)];
+      if (result) return result;
+    }
+    if (typeof i !== 'number') {
+      i = String(i).codePointAt(0) - this.inputBase;
+    }
+    return this.from <= i && i <= this.to && String.fromCodePoint(this.base + i);
+  }
+  transcode(s, {missing} = {}) {
+    return s.replace(/./g, missing ? m => this.get(m) || missing : m => this.get(m) || m);
+  }
+}
+
+export const transcode = (s, tables, {missing} = {}) => {
+  let fn;
+  if (typeof tables == 'function') {
+    fn = tables;
+  } else if (!Array.isArray(tables)) {
+    if (typeof tables.transcode == 'function') return tables.transcode(s, {missing});
+    fn = m => tables[m];
+  } else {
+    fn = m => {
+      for (const table of tables) {
+        const result = typeof table.get == 'function' ? table.get(m) : table[m];
+        if (result) return result;
+      }
+      // return undefined;
+    };
+  }
+  return s.replace(/./g, missing ? m => fn(m) || missing : m => fn(m) || m);
+};

package/src/ansi/csi.js

@@ -0,0 +1,67 @@
+// CSI (Control Sequence Introducer) commands definitions and helpers.
+// CSI is a part of Fe Escape sequences.
+// Type Fe is supported by C1 control codes.
+// See https://en.wikipedia.org/wiki/ANSI_escape_code for more details.
+// SGR is in a separate file. See sgr.js.
+
+export * from './sgr.js';
+
+// matcher
+export const matchCsi = /\x1B\[([\x30-\x3F]*)([\x20-\x2F]*)([\x40-\x7E])/g;
+
+const CSI = '\x1B[';
+
+export const CURSOR_UP1 = CSI + 'A';
+export const CURSOR_DOWN1 = CSI + 'B';
+export const CURSOR_FORWARD1 = CSI + 'C';
+export const CURSOR_BACK1 = CSI + 'D';
+export const CURSOR_NEXT_LINE1 = CSI + 'E';
+export const CURSOR_PREV_LINE1 = CSI + 'F';
+export const CURSOR_COLUMN1 = CSI + 'G';
+export const CURSOR_HOME = CSI + 'H';
+
+export const CURSOR_GET_POS = CSI + '6n';
+export const CURSOR_SAVE_POS = CSI + 's';
+export const CURSOR_RESTORE_POS = CSI + 'u';
+export const CURSOR_NORMAL = CSI + '?25h';
+export const CURSOR_INVISIBLE = CSI + '?25l';
+
+export const cursorUp = (n = 1) => CSI + (n > 1 ? n.toFixed() : '') + 'A';
+export const cursorDown = (n = 1) => CSI + (n > 1 ? n.toFixed() : '') + 'B';
+export const cursorForward = (n = 1) => CSI + (n > 1 ? n.toFixed() : '') + 'C';
+export const cursorBack = (n = 1) => CSI + (n > 1 ? n.toFixed() : '') + 'D';
+export const cursorNextLine = (n = 1) => CSI + (n > 1 ? n.toFixed() : '') + 'E';
+export const cursorPrevLine = (n = 1) => CSI + (n > 1 ? n.toFixed() : '') + 'F';
+export const cursorColumn = (n = 1) => CSI + (n > 1 ? n.toFixed() : '') + 'G';
+export const cursorSetPos = (n, m) => CSI + (n > 1 ? n.toFixed() : '') + ';' + (m > 1 ? m.toFixed() : '') + 'H';
+export const cursorSetPosAlt = (n, m) => CSI + (n > 1 ? n.toFixed() : '') + ';' + (m > 1 ? m.toFixed() : '') + 'f'; // HVP
+
+export const CURSOR_RIGHT1 = CURSOR_FORWARD1;
+export const CURSOR_LEFT1 = CURSOR_BACK1;
+export const cursorRight = cursorForward;
+export const cursorLeft = cursorBack;
+
+export const CLEAR_EOS = CSI + 'J';
+export const CLEAR_BOS = CSI + '1J';
+export const CLEAR_SCREEN = CSI + '2J';
+export const CLEAR_SCREEN_ALL = CSI + '3J'; // includes the scrollback buffer
+export const CLEAR_EOL = CSI + 'K';
+export const CLEAR_BOL = CSI + '1K';
+export const CLEAR_LINE = CSI + '2K';
+
+export const SCREEN_SAVE = CSI + '?47h';
+export const SCREEN_RESTORE = CSI + '?47l';
+export const SCREEN_ALT_ON = CSI + '?1049h'; // alternative screen buffer
+export const SCREEN_ALT_OFF = CSI + '?1049l';
+export const SCREEN_SCROLL_UP1 = CSI + 'S'
+export const SCREEN_SCROLL_DOWN1 = CSI + 'T'
+export const SCREEN_REPORT_FOCUS_ON = CSI + '?1004h';
+export const SCREEN_REPORT_FOCUS_OFF = CSI + '?1004l';
+
+export const screenScrollUp = (n = 1) => CSI + (n > 1 ? n.toFixed() : '') + 'S';
+export const screenScrollDown = (n = 1) => CSI + (n > 1 ? n.toFixed() : '') + 'T';
+
+export const WRAPPING_ON = CSI + '=7h';
+export const WRAPPING_OFF = CSI + '=7l';
+export const BRACKETED_PASTE_ON = CSI + '?2004h';
+export const BRACKETED_PASTE_OFF = CSI + '?2004l';

package/src/ansi/index.js

@@ -0,0 +1,20 @@
+// ANSI escape code. See https://en.wikipedia.org/wiki/ANSI_escape_code for more details.
+// This is a collection of escape sequences that are not part of other files (e.g., CSI, SGR).
+
+export * from './csi.js';
+
+export const ESC = '\x1B';
+
+export const CURSOR_DELETE = '\x7F';
+
+export const CURSOR_GO_UP1 = ESC + 'M';
+
+export const CURSOR_SAVE = ESC + '7';
+export const CURSOR_RESTORE = ESC + '8';
+
+// matchers
+export const matchFe = /\x1B([\x40-\x5F])/g;
+export const matchFs = /\x1B([\x60-\x7E])/g;
+export const matchFp = /\x1B([\x30-\x3F])/g;
+export const matchNf = /\x1B([\x20-\x2F]+)([\x30-\x7E])/g;
+export const matchOsc = /\x1B\]([\x20-\x7E]*)([\x07\x9C]|\x1B\x5C)/g;

package/src/ansi/sgr-constants.js

@@ -0,0 +1,99 @@
+// SGR commands as constants: some people prefer it this way
+
+import {Commands, Colors, setCommands, getColor, getBrightColor, getBgColor, getBgBrightColor} from './sgr.js';
+
+// Commands
+
+export const BOLD = setCommands(Commands.BOLD);
+export const DIM = setCommands(Commands.DIM);
+export const ITALIC = setCommands(Commands.ITALIC);
+export const UNDERLINE = setCommands(Commands.UNDERLINE);
+export const BLINK = setCommands(Commands.BLINK);
+export const RAPID_BLINK = setCommands(Commands.RAPID_BLINK);
+export const INVERSE = setCommands(Commands.INVERSE);
+export const HIDDEN = setCommands(Commands.HIDDEN);
+export const STRIKETHROUGH = setCommands(Commands.STRIKETHROUGH);
+export const OVERLINE = setCommands(Commands.OVERLINE);
+
+// Reset commands
+
+export const RESET_ALL = setCommands('');
+export const RESET = RESET_ALL;
+
+export const RESET_BOLD = setCommands(Commands.RESET_BOLD);
+export const RESET_DIM = setCommands(Commands.RESET_DIM);
+export const RESET_ITALIC = setCommands(Commands.RESET_ITALIC);
+export const RESET_UNDERLINE = setCommands(Commands.RESET_UNDERLINE);
+export const RESET_BLINK = setCommands(Commands.RESET_BLINK);
+export const RESET_RAPID_BLINK = setCommands(Commands.RESET_RAPID_BLINK);
+export const RESET_INVERSE = setCommands(Commands.RESET_INVERSE);
+export const RESET_HIDDEN = setCommands(Commands.RESET_HIDDEN);
+export const RESET_STRIKETHROUGH = setCommands(Commands.RESET_STRIKETHROUGH);
+export const RESET_OVERLINE = setCommands(Commands.RESET_OVERLINE);
+
+export const RESET_COLOR = setCommands(Commands.RESET_COLOR);
+export const RESET_BG_COLOR = setCommands(Commands.RESET_BG_COLOR);
+export const RESET_FONT = setCommands(Commands.RESET_FONT);
+
+// Colors
+
+export const BLACK = setCommands(getColor(Colors.BLACK));
+export const RED = setCommands(getColor(Colors.RED));
+export const GREEN = setCommands(getColor(Colors.GREEN));
+export const YELLOW = setCommands(getColor(Colors.YELLOW));
+export const BLUE = setCommands(getColor(Colors.BLUE));
+export const MAGENTA = setCommands(getColor(Colors.MAGENTA));
+export const CYAN = setCommands(getColor(Colors.CYAN));
+export const WHITE = setCommands(getColor(Colors.WHITE));
+
+export const BRIGHT_BLACK = setCommands(getBrightColor(Colors.BLACK));
+export const BRIGHT_RED = setCommands(getBrightColor(Colors.RED));
+export const BRIGHT_GREEN = setCommands(getBrightColor(Colors.GREEN));
+export const BRIGHT_YELLOW = setCommands(getBrightColor(Colors.YELLOW));
+export const BRIGHT_BLUE = setCommands(getBrightColor(Colors.BLUE));
+export const BRIGHT_MAGENTA = setCommands(getBrightColor(Colors.MAGENTA));
+export const BRIGHT_CYAN = setCommands(getBrightColor(Colors.CYAN));
+export const BRIGHT_WHITE = setCommands(getBrightColor(Colors.WHITE));
+
+export const BG_BLACK = setCommands(getBgColor(Colors.BLACK));
+export const BG_RED = setCommands(getBgColor(Colors.RED));
+export const BG_GREEN = setCommands(getBgColor(Colors.GREEN));
+export const BG_YELLOW = setCommands(getBgColor(Colors.YELLOW));
+export const BG_BLUE = setCommands(getBgColor(Colors.BLUE));
+export const BG_MAGENTA = setCommands(getBgColor(Colors.MAGENTA));
+export const BG_CYAN = setCommands(getBgColor(Colors.CYAN));
+export const BG_WHITE = setCommands(getBgColor(Colors.WHITE));
+
+export const BG_BRIGHT_BLACK = setCommands(getBgBrightColor(Colors.BLACK));
+export const BG_BRIGHT_RED = setCommands(getBgBrightColor(Colors.RED));
+export const BG_BRIGHT_GREEN = setCommands(getBgBrightColor(Colors.GREEN));
+export const BG_BRIGHT_YELLOW = setCommands(getBgBrightColor(Colors.YELLOW));
+export const BG_BRIGHT_BLUE = setCommands(getBgBrightColor(Colors.BLUE));
+export const BG_BRIGHT_MAGENTA = setCommands(getBgBrightColor(Colors.MAGENTA));
+export const BG_BRIGHT_CYAN = setCommands(getBgBrightColor(Colors.CYAN));
+export const BG_BRIGHT_WHITE = setCommands(getBgBrightColor(Colors.WHITE));
+
+export const FG_BLACK = BLACK;
+export const FG_RED = RED;
+export const FG_GREEN = GREEN;
+export const FG_YELLOW = YELLOW;
+export const FG_BLUE = BLUE;
+export const FG_MAGENTA = MAGENTA;
+export const FG_CYAN = CYAN;
+export const FG_WHITE = WHITE;
+
+export const FG_BRIGHT_BLACK = BRIGHT_BLACK;
+export const FG_BRIGHT_RED = BRIGHT_RED;
+export const FG_BRIGHT_GREEN = BRIGHT_GREEN;
+export const FG_BRIGHT_YELLOW = BRIGHT_YELLOW;
+export const FG_BRIGHT_BLUE = BRIGHT_BLUE;
+export const FG_BRIGHT_MAGENTA = BRIGHT_MAGENTA;
+export const FG_BRIGHT_CYAN = BRIGHT_CYAN;
+export const FG_BRIGHT_WHITE = BRIGHT_WHITE;
+
+export const GRAY = BRIGHT_BLACK;
+export const GREY = GRAY;
+export const BG_GRAY = BG_BRIGHT_BLACK;
+export const BG_GREY = BG_GRAY;
+export const FG_GRAY = FG_BRIGHT_BLACK;
+export const FG_GREY = FG_GRAY;

package/src/ansi/sgr-state.js

@@ -0,0 +1,398 @@
+// Support for states based on SGR commands. See https://en.wikipedia.org/wiki/ANSI_escape_code for more details.
+
+import {
+  Commands,
+  ColorFormatSize,
+  isFgColorCommand,
+  isBgColorCommand,
+  isFontCommand,
+  setCommands,
+  matchSgr
+} from './sgr.js';
+
+export const RESET_STATE = {
+  bold: null,
+  dim: null,
+  italic: null,
+  underline: null,
+  blink: null,
+  inverse: null,
+  hidden: null,
+  strikethrough: null,
+  overline: null,
+  foreground: null,
+  background: null,
+  decoration: null,
+  font: null
+};
+
+const defaultState = Symbol('defaultState');
+
+let toState;
+
+export const extractState = (s, initState = defaultState) => {
+  let state = toState(initState);
+  matchSgr.lastIndex = 0;
+  for (const match of s.matchAll(matchSgr)) state = addCommandsToState(state, match[1].split(';'));
+  return state;
+};
+
+toState = value => {
+  switch (typeof value) {
+    case 'object':
+      if (!value) return RESET_STATE;
+      if (typeof value.getState == 'function') return value.getState();
+      return value;
+    case 'string':
+      if (!value) break;
+      return extractState(value);
+  }
+  return {};
+};
+export {toState};
+
+const TOTAL_RESETS = Array.from(Object.keys(RESET_STATE)).length;
+
+const getStateResets = state => {
+  let resetCount = 0;
+
+  for (const name of Object.keys(RESET_STATE)) {
+    if (state[name] === null) ++resetCount;
+  }
+
+  return resetCount;
+};
+
+export const combineStates = (...states) => {
+  let state = {};
+  for (const s of states) {
+    const currentState = toState(s);
+    for (const [name, value] of Object.entries(currentState)) {
+      if (value !== undefined) state[name] = value;
+    }
+  }
+  return state;
+};
+
+export const commandsToState = commands => {
+  let state = {};
+  for (let i = 0; i < commands.length; ++i) {
+    const currentCommand = commands[i];
+    switch (currentCommand) {
+      case '': // reset
+      case Commands.RESET_ALL:
+        state = RESET_STATE;
+        continue;
+      case Commands.BOLD:
+        state.bold = currentCommand;
+        continue;
+      case Commands.DIM:
+        state.dim = currentCommand;
+        continue;
+      case Commands.ITALIC:
+        state.italic = currentCommand;
+        continue;
+      case Commands.UNDERLINE:
+      case Commands.DOUBLE_UNDERLINE:
+      case Commands.CURLY_UNDERLINE:
+        state.underline = currentCommand;
+        continue;
+      case Commands.BLINK:
+      case Commands.RAPID_BLINK:
+        state.blink = currentCommand;
+        continue;
+      case Commands.INVERSE:
+        state.inverse = currentCommand;
+        continue;
+      case Commands.HIDDEN:
+        state.hidden = currentCommand;
+        continue;
+      case Commands.STRIKETHROUGH:
+        state.strikethrough = currentCommand;
+        continue;
+      case Commands.OVERLINE:
+        state.overline = currentCommand;
+        continue;
+      case Commands.RESET_BOLD:
+        // case Commands.RESET_DIM:
+        state.bold = state.dim = null;
+        continue;
+      case Commands.RESET_ITALIC:
+        state.italic = null;
+        continue;
+      case Commands.RESET_UNDERLINE:
+        // case Commands.RESET_DOUBLE_UNDERLINE:
+        // case Commands.RESET_CURLY_UNDERLINE:
+        state.underline = null;
+        continue;
+      case Commands.RESET_BLINK:
+        // case RESET_RAPID_BLINK:
+        state.blink = null;
+        continue;
+      case Commands.RESET_INVERSE:
+        state.inverse = null;
+        continue;
+      case Commands.RESET_HIDDEN:
+        state.hidden = null;
+        continue;
+      case Commands.RESET_STRIKETHROUGH:
+        state.strikethrough = null;
+        continue;
+      case Commands.RESET_OVERLINE:
+        state.overline = null;
+        continue;
+      case Commands.RESET_DECORATION_COLOR:
+        state.decoration = null;
+        continue;
+      case Commands.EXTENDED_COLOR: {
+        const next = ColorFormatSize[commands[i + 1]],
+          color = commands.slice(i, i + next);
+        i += next - 1;
+        state.foreground = color;
+        continue;
+      }
+      case Commands.BG_EXTENDED_COLOR: {
+        const next = ColorFormatSize[commands[i + 1]],
+          color = commands.slice(i, i + next);
+        i += next - 1;
+        state.background = color;
+        continue;
+      }
+      case Commands.DECORATION_COLOR: {
+        const next = ColorFormatSize[commands[i + 1]],
+          color = commands.slice(i, i + next);
+        i += next - 1;
+        state.decoration = color;
+        continue;
+      }
+      case Commands.DEFAULT_COLOR:
+        state.foreground = null;
+        continue;
+      case Commands.BG_DEFAULT_COLOR:
+        state.background = null;
+        continue;
+      case Commands.DEFAULT_FONT:
+        state.font = null;
+        continue;
+    }
+    if (isFgColorCommand(currentCommand)) {
+      state.foreground = currentCommand;
+      continue;
+    }
+    if (isBgColorCommand(currentCommand)) {
+      state.background = currentCommand;
+      continue;
+    }
+    if (isFontCommand(currentCommand)) {
+      state.font = currentCommand;
+      continue;
+    }
+  }
+  return state;
+};
+
+export const addCommandsToState = (state, commands) => combineStates(state, commandsToState(commands));
+
+const equalColors = (a, b) => {
+  if (a === b) return true;
+  if (Array.isArray(a) && Array.isArray(b))
+    return a.length === b.length && a.every((value, index) => value === b[index]);
+  return false;
+};
+
+const pushColor = (commands, color) => {
+  if (Array.isArray(color)) {
+    commands.push(...color);
+  } else {
+    commands.push(color);
+  }
+  return commands;
+};
+
+const resetColorProperties = {
+  foreground: Commands.RESET_COLOR,
+  background: Commands.RESET_BG_COLOR,
+  decoration: Commands.RESET_DECORATION_COLOR
+};
+
+const chainedStates = {bold: 1, dim: 1};
+
+export const stateToCommands = state => {
+  state = toState(state);
+  const commands = [];
+  let resetCount = 0;
+
+  // process chained states separately
+  if (state.bold === null) {
+    commands.push(Commands.RESET_BOLD);
+    ++resetCount;
+  }
+  if (state.dim === null) {
+    commands.push(Commands.RESET_DIM);
+    ++resetCount;
+  }
+  state.bold && commands.push(state.bold);
+  state.dim && commands.push(state.dim);
+
+  for (const [name, value] of Object.entries(state)) {
+    if (chainedStates[name] === 1) continue; // skip chained states
+    if (resetColorProperties.hasOwnProperty(name)) {
+      // colors
+      if (value === null) {
+        commands.push(resetColorProperties[name]);
+        ++resetCount;
+        continue;
+      }
+      value && pushColor(commands, value);
+      continue;
+    }
+    if (value === null) {
+      commands.push(Commands['RESET_' + name.toUpperCase()]);
+      ++resetCount;
+      continue;
+    }
+    value && commands.push(value);
+  }
+
+  return resetCount === TOTAL_RESETS ? [''] : commands;
+};
+
+export const stateTransition = (prev, next) => {
+  prev = toState(prev);
+  next = toState(next);
+  const commands = [];
+  let resetCount = 0;
+
+  // process chained states separately
+  if (prev.bold !== next.bold) {
+    if (next.bold === null) {
+      commands.push(Commands.RESET_BOLD);
+    } else if (next.bold) {
+      if (next.dim === null && prev.dim !== null) commands.push(Commands.RESET_DIM);
+      commands.push(next.bold);
+    }
+    next.dim && commands.push(next.dim);
+  } else {
+    if (prev.dim !== next.dim) {
+      if (next.dim === null) {
+        commands.push(Commands.RESET_DIM);
+        next.bold && commands.push(next.bold);
+      } else {
+        next.dim && commands.push(next.dim);
+      }
+    }
+  }
+  if (next.bold === null) ++resetCount;
+  if (next.dim === null) ++resetCount;
+
+  for (const name of Object.keys(RESET_STATE)) {
+    if (chainedStates[name] === 1) continue; // skip chained states
+    const value = next[name];
+    if (resetColorProperties.hasOwnProperty(name)) {
+      // color
+      if (value === null) {
+        if (prev[name] !== null) commands.push(resetColorProperties[name]);
+        ++resetCount;
+        continue;
+      }
+      if (value) {
+        if (!equalColors(prev[name], value)) pushColor(commands, value);
+      }
+      continue;
+    }
+    if (value === null) {
+      if (prev[name] !== null) commands.push(Commands['RESET_' + name.toUpperCase()]);
+      ++resetCount;
+      continue;
+    }
+    if (value) {
+      if (prev[name] !== value) commands.push(value);
+    }
+  }
+
+  if (resetCount === TOTAL_RESETS) {
+    const prevResets = getStateResets(prev);
+    return prevResets === TOTAL_RESETS ? [] : [''];
+  }
+
+  return commands;
+};
+
+export const stateReverseTransition = (prev, next) => {
+  prev = toState(prev);
+  next = toState(next);
+  const commands = [];
+  let resetCount = 0;
+
+  // process chained states separately
+  if (next.bold !== prev.bold) {
+    if (!prev.bold) {
+      commands.push(Commands.RESET_BOLD);
+    } else {
+      if (!prev.dim && next.dim) commands.push(Commands.RESET_DIM);
+      commands.push(prev.bold);
+    }
+    prev.dim && commands.push(prev.dim);
+  } else {
+    if (next.dim !== prev.dim) {
+      if (!prev.dim) {
+        commands.push(Commands.RESET_DIM);
+        prev.bold && commands.push(prev.bold);
+      } else {
+        prev.dim && commands.push(prev.dim);
+      }
+    }
+  }
+  if (prev.bold === null) ++resetCount;
+  if (prev.dim === null) ++resetCount;
+
+  for (const name of Object.keys(RESET_STATE)) {
+    const value = prev[name];
+    if (resetColorProperties.hasOwnProperty(name)) {
+      // color
+      if (!value) {
+        if (next[name]) commands.push(resetColorProperties[name]);
+        if (value === null) ++resetCount;
+        continue;
+      }
+      if (!equalColors(next[name], value)) pushColor(commands, value);
+      continue;
+    }
+    if (!value) {
+      if (next[name]) commands.push(Commands['RESET_' + name.toUpperCase()]);
+      if (value === null) ++resetCount;
+      continue;
+    }
+    if (next[name] !== value) commands.push(value);
+  }
+
+  if (resetCount === TOTAL_RESETS) {
+    const nextResets = getStateResets(next);
+    return nextResets === TOTAL_RESETS ? [] : [''];
+  }
+
+  return commands;
+};
+
+export const stringifyCommands = commands => (commands?.length ? setCommands(commands) : '');
+
+export const optimize = (s, initState = defaultState) => {
+  let state = toState(initState),
+    result = '',
+    start = 0;
+  matchSgr.lastIndex = 0;
+  for (const match of s.matchAll(matchSgr)) {
+    if (start < match.index) {
+      const commands = initState !== state ? stateTransition(initState, state) : [];
+      result += stringifyCommands(commands);
+      initState = state;
+      result += s.substring(start, match.index);
+    }
+    state = addCommandsToState(state, match[1].split(';'));
+    start = match.index + match[0].length;
+  }
+  const commands = initState !== state ? stateTransition(initState, state) : [];
+  result += stringifyCommands(commands);
+  if (start < s.length) result += s.substring(start);
+  return result;
+};