docs: function draw(values = [], options = {}) {
    values = normalizeValues(values);
  
    const {
      sort,
      min,
      max,
      length,
      format,
      randomColorOptions,
    } = normalizeOptions(options);
  
    const colors = randomColor(
      Object.assign({}, randomColorOptions, { count: values.length })
    );
  
    const chartLength = typeof length === 'number' ? length : COLUMNS;
  
    const minValue =
      typeof min === 'number'
        ? min
        : Math.min(...values.map(value => value.value));
  
    const maxValue =
      typeof max === 'number'
        ? max
        : Math.max(...values.map(value => value.value));
  
    const valueFormatter =
      typeof format === 'function'
        ? format
        : value => numeral(value).format(format);
  
    const minValueFormatted = valueFormatter(minValue);
  
    const maxValueFormatted = valueFormatter(maxValue);
  
    const normalizeValue = createNormalizeValue(
      minValue,
      maxValue,
      chartLength,
      colors,
      valueFormatter
    );
  
    const normalizedValues = values.map(normalizeValue);
  
    const longestFormattedValue = Math.max(
      ...normalizedValues.map(value => value.formattedValue.length)
    );
  
    const longestLabel = Math.max(
      ...normalizedValues.map(value => value.label.length)
    );
  
    const chart = normalizedValues
      .slice()
      .sort(typeof sort === 'function' ? sort : SORT_METHODS[sort])
      .map(({ coloredChartBar }) => coloredChartBar);
  
    const legend = normalizedValues.map(value => {
      const coloredBlock =
        typeof chalk[value.color] === 'function'
          ? chalk[value.color](SYMBOLS.Full)
          : chalk.hex(value.color)(SYMBOLS.Full);
  
      const lineValue = pad(longestFormattedValue, value.formattedValue);
      const label = pad(value.label, longestLabel);
  
      return `${coloredBlock} - ${label} ${lineValue}`;
    });
  
    let scale = [
      [SYMBOLS.LeftCorner, minValueFormatted].join(SYMBOLS.Space).trim(),
      [maxValueFormatted, SYMBOLS.RightCorner].join(SYMBOLS.Space).trim(),
    ];
  
    const scaleDividerLength =
      chartLength - scale.reduce((acc, s) => acc + s.length, 0);
  
    if (scaleDividerLength > 0) {
      scale = scale.join(SYMBOLS.Space.repeat(scaleDividerLength));
    } else {
      const padLength = Math.max(
        minValueFormatted.length,
        maxValueFormatted.length
      );
  
      scale = [
        `min: ${pad(padLength, minValueFormatted)}`,
        `max: ${pad(padLength, maxValueFormatted)}`,
      ].join(SYMBOLS.EOL);
    }
  
    return {
      chart: chart.join(SYMBOLS.EOL),
      legend: legend.join(SYMBOLS.EOL),
      scale: scale,
      __raw: {
        chartLength,
        minValue,
        minValueFormatted,
        maxValue,
        maxValueFormatted,
        normalizedValues,
      },
    };
  }