mathjs 9.2.0 → 9.4.0

package/examples/node_modules/enquirer/lib/prompts/survey.js

@@ -0,0 +1,163 @@
+'use strict';
+
+const ArrayPrompt = require('../types/array');
+
+class Survey extends ArrayPrompt {
+  constructor(options = {}) {
+    super(options);
+    this.emptyError = options.emptyError || 'No items were selected';
+    this.term = process.env.TERM_PROGRAM;
+
+    if (!this.options.header) {
+      let header = ['', '4 - Strongly Agree', '3 - Agree', '2 - Neutral', '1 - Disagree', '0 - Strongly Disagree', ''];
+      header = header.map(ele => this.styles.muted(ele));
+      this.state.header = header.join('\n   ');
+    }
+  }
+
+  async toChoices(...args) {
+    if (this.createdScales) return false;
+    this.createdScales = true;
+    let choices = await super.toChoices(...args);
+    for (let choice of choices) {
+      choice.scale = createScale(5, this.options);
+      choice.scaleIdx = 2;
+    }
+    return choices;
+  }
+
+  dispatch() {
+    this.alert();
+  }
+
+  space() {
+    let choice = this.focused;
+    let ele = choice.scale[choice.scaleIdx];
+    let selected = ele.selected;
+    choice.scale.forEach(e => (e.selected = false));
+    ele.selected = !selected;
+    return this.render();
+  }
+
+  indicator() {
+    return '';
+  }
+
+  pointer() {
+    return '';
+  }
+
+  separator() {
+    return this.styles.muted(this.symbols.ellipsis);
+  }
+
+  right() {
+    let choice = this.focused;
+    if (choice.scaleIdx >= choice.scale.length - 1) return this.alert();
+    choice.scaleIdx++;
+    return this.render();
+  }
+
+  left() {
+    let choice = this.focused;
+    if (choice.scaleIdx <= 0) return this.alert();
+    choice.scaleIdx--;
+    return this.render();
+  }
+
+  indent() {
+    return '   ';
+  }
+
+  async renderChoice(item, i) {
+    await this.onChoice(item, i);
+    let focused = this.index === i;
+    let isHyper = this.term === 'Hyper';
+    let n = !isHyper ? 8 : 9;
+    let s = !isHyper ? ' ' : '';
+    let ln = this.symbols.line.repeat(n);
+    let sp = ' '.repeat(n + (isHyper ? 0 : 1));
+    let dot = enabled => (enabled ? this.styles.success('◉') : '◯') + s;
+
+    let num = i + 1 + '.';
+    let color = focused ? this.styles.heading : this.styles.noop;
+    let msg = await this.resolve(item.message, this.state, item, i);
+    let indent = this.indent(item);
+    let scale = indent + item.scale.map((e, i) => dot(i === item.scaleIdx)).join(ln);
+    let val = i => i === item.scaleIdx ? color(i) : i;
+    let next = indent + item.scale.map((e, i) => val(i)).join(sp);
+
+    let line = () => [num, msg].filter(Boolean).join(' ');
+    let lines = () => [line(), scale, next, ' '].filter(Boolean).join('\n');
+
+    if (focused) {
+      scale = this.styles.cyan(scale);
+      next = this.styles.cyan(next);
+    }
+
+    return lines();
+  }
+
+  async renderChoices() {
+    if (this.state.submitted) return '';
+    let choices = this.visible.map(async(ch, i) => await this.renderChoice(ch, i));
+    let visible = await Promise.all(choices);
+    if (!visible.length) visible.push(this.styles.danger('No matching choices'));
+    return visible.join('\n');
+  }
+
+  format() {
+    if (this.state.submitted) {
+      let values = this.choices.map(ch => this.styles.info(ch.scaleIdx));
+      return values.join(', ');
+    }
+    return '';
+  }
+
+  async render() {
+    let { submitted, size } = this.state;
+
+    let prefix = await this.prefix();
+    let separator = await this.separator();
+    let message = await this.message();
+
+    let prompt = [prefix, message, separator].filter(Boolean).join(' ');
+    this.state.prompt = prompt;
+
+    let header = await this.header();
+    let output = await this.format();
+    let help = await this.error() || await this.hint();
+    let body = await this.renderChoices();
+    let footer = await this.footer();
+
+    if (output || !help) prompt += ' ' + output;
+    if (help && !prompt.includes(help)) prompt += ' ' + help;
+
+    if (submitted && !output && !body && this.multiple && this.type !== 'form') {
+      prompt += this.styles.danger(this.emptyError);
+    }
+
+    this.clear(size);
+    this.write([prompt, header, body, footer].filter(Boolean).join('\n'));
+    this.restore();
+  }
+
+  submit() {
+    this.value = {};
+    for (let choice of this.choices) {
+      this.value[choice.name] = choice.scaleIdx;
+    }
+    return this.base.submit.call(this);
+  }
+}
+
+function createScale(n, options = {}) {
+  if (Array.isArray(options.scale)) {
+    return options.scale.map(ele => ({ ...ele }));
+  }
+  let scale = [];
+  for (let i = 1; i < n + 1; i++) scale.push({ i, selected: false });
+  return scale;
+}
+
+module.exports = Survey;

package/examples/node_modules/enquirer/lib/prompts/text.js

@@ -0,0 +1 @@
+module.exports = require('./input');

package/examples/node_modules/enquirer/lib/prompts/toggle.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const BooleanPrompt = require('../types/boolean');
+
+class TogglePrompt extends BooleanPrompt {
+  async initialize() {
+    await super.initialize();
+    this.value = this.initial = !!this.options.initial;
+    this.disabled = this.options.disabled || 'no';
+    this.enabled = this.options.enabled || 'yes';
+    await this.render();
+  }
+
+  reset() {
+    this.value = this.initial;
+    this.render();
+  }
+
+  delete() {
+    this.alert();
+  }
+
+  toggle() {
+    this.value = !this.value;
+    this.render();
+  }
+
+  enable() {
+    if (this.value === true) return this.alert();
+    this.value = true;
+    this.render();
+  }
+  disable() {
+    if (this.value === false) return this.alert();
+    this.value = false;
+    this.render();
+  }
+
+  up() {
+    this.toggle();
+  }
+  down() {
+    this.toggle();
+  }
+  right() {
+    this.toggle();
+  }
+  left() {
+    this.toggle();
+  }
+  next() {
+    this.toggle();
+  }
+  prev() {
+    this.toggle();
+  }
+
+  dispatch(ch = '', key) {
+    switch (ch.toLowerCase()) {
+      case ' ':
+        return this.toggle();
+      case '1':
+      case 'y':
+      case 't':
+        return this.enable();
+      case '0':
+      case 'n':
+      case 'f':
+        return this.disable();
+      default: {
+        return this.alert();
+      }
+    }
+  }
+
+  format() {
+    let active = str => this.styles.primary.underline(str);
+    let value = [
+      this.value ? this.disabled : active(this.disabled),
+      this.value ? active(this.enabled) : this.enabled
+    ];
+    return value.join(this.styles.muted(' / '));
+  }
+
+  async render() {
+    let { size } = this.state;
+
+    let header = await this.header();
+    let prefix = await this.prefix();
+    let separator = await this.separator();
+    let message = await this.message();
+
+    let output = await this.format();
+    let help = (await this.error()) || (await this.hint());
+    let footer = await this.footer();
+
+    let prompt = [prefix, message, separator, output].join(' ');
+    this.state.prompt = prompt;
+
+    if (help && !prompt.includes(help)) prompt += ' ' + help;
+
+    this.clear(size);
+    this.write([header, prompt, footer].filter(Boolean).join('\n'));
+    this.write(this.margin[2]);
+    this.restore();
+  }
+}
+
+module.exports = TogglePrompt;

package/examples/node_modules/enquirer/lib/render.js

@@ -0,0 +1,33 @@
+'use strict';
+
+module.exports = async(value, prompt, context = {}) => {
+  let { choices, multiple } = prompt.options;
+  let { size, submitted } = prompt.state;
+
+  let prefix = context.prefix || await prompt.prefix();
+  let separator = context.separator || await prompt.separator();
+  let message = context.message || await prompt.message();
+
+  // ? Select your favorite colors >
+  // ^             ^               ^
+  // prefix     message        separator
+  let promptLine = [prefix, message, separator].filter(Boolean).join(' ');
+  prompt.state.prompt = promptLine;
+
+  let header = context.header || await prompt.header();
+  let output = context.format || await prompt.format(value);
+  let help = context.help || await prompt.error() || await prompt.hint();
+  let body = context.body || await prompt.body();
+  let footer = context.footer || await prompt.footer();
+
+  if (output || !help) promptLine += ' ' + output;
+  if (help && !promptLine.includes(help)) promptLine += ' ' + help;
+
+  if (submitted && choices && multiple && !output && !body) {
+    promptLine += prompt.styles.danger('No items were selected');
+  }
+
+  prompt.clear(size);
+  prompt.write([header, promptLine, body, footer].filter(Boolean).join('\n'));
+  prompt.restore();
+};

package/examples/node_modules/enquirer/lib/roles.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const utils = require('./utils');
+const roles = {
+  default(prompt, choice) {
+    return choice;
+  },
+  checkbox(prompt, choice) {
+    throw new Error('checkbox role is not implemented yet');
+  },
+  editable(prompt, choice) {
+    throw new Error('editable role is not implemented yet');
+  },
+  expandable(prompt, choice) {
+    throw new Error('expandable role is not implemented yet');
+  },
+  heading(prompt, choice) {
+    choice.disabled = '';
+    choice.indicator = [choice.indicator, ' '].find(v => v != null);
+    choice.message = choice.message || '';
+    return choice;
+  },
+  input(prompt, choice) {
+    throw new Error('input role is not implemented yet');
+  },
+  option(prompt, choice) {
+    return roles.default(prompt, choice);
+  },
+  radio(prompt, choice) {
+    throw new Error('radio role is not implemented yet');
+  },
+  separator(prompt, choice) {
+    choice.disabled = '';
+    choice.indicator = [choice.indicator, ' '].find(v => v != null);
+    choice.message = choice.message || prompt.symbols.line.repeat(5);
+    return choice;
+  },
+  spacer(prompt, choice) {
+    return choice;
+  }
+};
+
+module.exports = (name, options = {}) => {
+  let role = utils.merge({}, roles, options.roles);
+  return role[name] || role.default;
+};

package/examples/node_modules/enquirer/lib/state.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const { define, width } = require('./utils');
+
+class State {
+  constructor(prompt) {
+    let options = prompt.options;
+    define(this, '_prompt', prompt);
+    this.type = prompt.type;
+    this.name = prompt.name;
+    this.message = '';
+    this.header = '';
+    this.footer = '';
+    this.error = '';
+    this.hint = '';
+    this.input = '';
+    this.cursor = 0;
+    this.index = 0;
+    this.lines = 0;
+    this.tick = 0;
+    this.prompt = '';
+    this.buffer = '';
+    this.width = width(options.stdout || process.stdout);
+    Object.assign(this, options);
+    this.name = this.name || this.message;
+    this.message = this.message || this.name;
+    this.symbols = prompt.symbols;
+    this.styles = prompt.styles;
+    this.required = new Set();
+    this.cancelled = false;
+    this.submitted = false;
+  }
+
+  clone() {
+    let state = { ...this };
+    state.status = this.status;
+    state.buffer = Buffer.from(state.buffer);
+    delete state.clone;
+    return state;
+  }
+
+  set color(val) {
+    this._color = val;
+  }
+  get color() {
+    let styles = this.prompt.styles;
+    if (this.cancelled) return styles.cancelled;
+    if (this.submitted) return styles.submitted;
+    let color = this._color || styles[this.status];
+    return typeof color === 'function' ? color : styles.pending;
+  }
+
+  set loading(value) {
+    this._loading = value;
+  }
+  get loading() {
+    if (typeof this._loading === 'boolean') return this._loading;
+    if (this.loadingChoices) return 'choices';
+    return false;
+  }
+
+  get status() {
+    if (this.cancelled) return 'cancelled';
+    if (this.submitted) return 'submitted';
+    return 'pending';
+  }
+}
+
+module.exports = State;

package/examples/node_modules/enquirer/lib/styles.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const utils = require('./utils');
+const colors = require('ansi-colors');
+
+const styles = {
+  default: colors.noop,
+  noop: colors.noop,
+
+  /**
+   * Modifiers
+   */
+
+  set inverse(custom) {
+    this._inverse = custom;
+  },
+  get inverse() {
+    return this._inverse || utils.inverse(this.primary);
+  },
+
+  set complement(custom) {
+    this._complement = custom;
+  },
+  get complement() {
+    return this._complement || utils.complement(this.primary);
+  },
+
+  /**
+   * Main color
+   */
+
+  primary: colors.cyan,
+
+  /**
+   * Main palette
+   */
+
+  success: colors.green,
+  danger: colors.magenta,
+  strong: colors.bold,
+  warning: colors.yellow,
+  muted: colors.dim,
+  disabled: colors.gray,
+  dark: colors.dim.gray,
+  underline: colors.underline,
+
+  set info(custom) {
+    this._info = custom;
+  },
+  get info() {
+    return this._info || this.primary;
+  },
+
+  set em(custom) {
+    this._em = custom;
+  },
+  get em() {
+    return this._em || this.primary.underline;
+  },
+
+  set heading(custom) {
+    this._heading = custom;
+  },
+  get heading() {
+    return this._heading || this.muted.underline;
+  },
+
+  /**
+   * Statuses
+   */
+
+  set pending(custom) {
+    this._pending = custom;
+  },
+  get pending() {
+    return this._pending || this.primary;
+  },
+
+  set submitted(custom) {
+    this._submitted = custom;
+  },
+  get submitted() {
+    return this._submitted || this.success;
+  },
+
+  set cancelled(custom) {
+    this._cancelled = custom;
+  },
+  get cancelled() {
+    return this._cancelled || this.danger;
+  },
+
+  /**
+   * Special styling
+   */
+
+  set typing(custom) {
+    this._typing = custom;
+  },
+  get typing() {
+    return this._typing || this.dim;
+  },
+
+  set placeholder(custom) {
+    this._placeholder = custom;
+  },
+  get placeholder() {
+    return this._placeholder || this.primary.dim;
+  },
+
+  set highlight(custom) {
+    this._highlight = custom;
+  },
+  get highlight() {
+    return this._highlight || this.inverse;
+  }
+};
+
+styles.merge = (options = {}) => {
+  if (options.styles && typeof options.styles.enabled === 'boolean') {
+    colors.enabled = options.styles.enabled;
+  }
+  if (options.styles && typeof options.styles.visible === 'boolean') {
+    colors.visible = options.styles.visible;
+  }
+
+  let result = utils.merge({}, styles, options.styles);
+  delete result.merge;
+
+  for (let key of Object.keys(colors)) {
+    if (!result.hasOwnProperty(key)) {
+      Reflect.defineProperty(result, key, { get: () => colors[key] });
+    }
+  }
+
+  for (let key of Object.keys(colors.styles)) {
+    if (!result.hasOwnProperty(key)) {
+      Reflect.defineProperty(result, key, { get: () => colors[key] });
+    }
+  }
+  return result;
+};
+
+module.exports = styles;

package/examples/node_modules/enquirer/lib/symbols.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const isWindows = process.platform === 'win32';
+const colors = require('ansi-colors');
+const utils = require('./utils');
+
+const symbols = {
+  ...colors.symbols,
+  upDownDoubleArrow: '⇕',
+  upDownDoubleArrow2: '⬍',
+  upDownArrow: '↕',
+  asterisk: '*',
+  asterism: '⁂',
+  bulletWhite: '◦',
+  electricArrow: '⌁',
+  ellipsisLarge: '⋯',
+  ellipsisSmall: '…',
+  fullBlock: '█',
+  identicalTo: '≡',
+  indicator: colors.symbols.check,
+  leftAngle: '‹',
+  mark: '※',
+  minus: '−',
+  multiplication: '×',
+  obelus: '÷',
+  percent: '%',
+  pilcrow: '¶',
+  pilcrow2: '❡',
+  pencilUpRight: '✐',
+  pencilDownRight: '✎',
+  pencilRight: '✏',
+  plus: '+',
+  plusMinus: '±',
+  pointRight: '☞',
+  rightAngle: '›',
+  section: '§',
+  hexagon: { off: '⬡', on: '⬢', disabled: '⬢' },
+  ballot: { on: '☑', off: '☐', disabled: '☒' },
+  stars: { on: '★', off: '☆', disabled: '☆' },
+  folder: { on: '▼', off: '▶', disabled: '▶' },
+  prefix: {
+    pending: colors.symbols.question,
+    submitted: colors.symbols.check,
+    cancelled: colors.symbols.cross
+  },
+  separator: {
+    pending: colors.symbols.pointerSmall,
+    submitted: colors.symbols.middot,
+    cancelled: colors.symbols.middot
+  },
+  radio: {
+    off: isWindows ? '( )' : '◯',
+    on: isWindows ? '(*)' : '◉',
+    disabled: isWindows ? '(|)' : 'Ⓘ'
+  },
+  numbers: ['⓪', '①', '②', '③', '④', '⑤', '⑥', '⑦', '⑧', '⑨', '⑩', '⑪', '⑫', '⑬', '⑭', '⑮', '⑯', '⑰', '⑱', '⑲', '⑳', '㉑', '㉒', '㉓', '㉔', '㉕', '㉖', '㉗', '㉘', '㉙', '㉚', '㉛', '㉜', '㉝', '㉞', '㉟', '㊱', '㊲', '㊳', '㊴', '㊵', '㊶', '㊷', '㊸', '㊹', '㊺', '㊻', '㊼', '㊽', '㊾', '㊿']
+};
+
+symbols.merge = options => {
+  let result = utils.merge({}, colors.symbols, symbols, options.symbols);
+  delete result.merge;
+  return result;
+};
+
+module.exports = symbols;
+

package/examples/node_modules/enquirer/lib/theme.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const styles = require('./styles');
+const symbols = require('./symbols');
+const utils = require('./utils');
+
+module.exports = prompt => {
+  prompt.options = utils.merge({}, prompt.options.theme, prompt.options);
+  prompt.symbols = symbols.merge(prompt.options);
+  prompt.styles = styles.merge(prompt.options);
+};

package/examples/node_modules/enquirer/lib/timer.js

@@ -0,0 +1,38 @@
+'use strict';
+
+module.exports = prompt => {
+  prompt.timers = prompt.timers || {};
+
+  let timers = prompt.options.timers;
+  if (!timers) return;
+
+  for (let key of Object.keys(timers)) {
+    let opts = timers[key];
+    if (typeof opts === 'number') {
+      opts = { interval: opts };
+    }
+    create(prompt, key, opts);
+  }
+};
+
+function create(prompt, name, options = {}) {
+  let timer = prompt.timers[name] = { name, start: Date.now(), ms: 0, tick: 0 };
+  let ms = options.interval || 120;
+  timer.frames = options.frames || [];
+  timer.loading = true;
+
+  let interval = setInterval(() => {
+    timer.ms = Date.now() - timer.start;
+    timer.tick++;
+    prompt.render();
+  }, ms);
+
+  timer.stop = () => {
+    timer.loading = false;
+    clearInterval(interval);
+  };
+
+  Reflect.defineProperty(timer, 'interval', { value: interval });
+  prompt.once('close', () => timer.stop());
+  return timer.stop;
+}