console-toolkit 1.0.0

package/LICENSE

@@ -0,0 +1,34 @@
+This library is available under the terms of the modified BSD license. No external contributions
+are allowed under licenses which are fundamentally incompatible with the BSD license that this library is distributed under.
+
+The text of the BSD license is reproduced below.
+
+-------------------------------------------------------------------------------
+The "New" BSD License:
+**********************
+
+Copyright (c) 2005-2024, Eugene Lazutkin
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+  * Neither the name of Eugene Lazutkin nor the names of other contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,92 @@
+# console-toolkit [![NPM version][npm-img]][npm-url]
+
+[npm-img]:      https://img.shields.io/npm/v/console-toolkit.svg
+[npm-url]:      https://npmjs.org/package/console-toolkit
+
+`console-toolkit` is a set of tools to create rich CLI-based applications. It provides:
+
+* Styles based on [ANSI escape sequences](https://en.wikipedia.org/wiki/ANSI_escape_code):
+  * [SGR](https://en.wikipedia.org/wiki/ANSI_escape_code#SGR): colors and text styles
+  * [CSI](https://en.wikipedia.org/wiki/ANSI_escape_code#CSIsection): cursor and screen control
+* Bitmap graphics
+* Vector graphics based on [Turtle graphics](https://en.wikipedia.org/wiki/Turtle_graphics)
+* Curated sets of Unicode symbols
+* Tables with themes
+* Bar and column charts with themes
+* Various helpers and examples
+
+## Visual examples
+
+### Memory watcher
+
+![Memory watcher](https://github.com/uhop/console-toolkit/wiki/images/example-memory.png)
+
+### Waveform
+
+![Waveform](https://github.com/uhop/console-toolkit/wiki/images/example-waveform.png)
+
+### Table + chart
+
+![Table + chart](https://github.com/uhop/console-toolkit/wiki/images/example-table-chart.png)
+
+### Turtle graphics
+
+![Turtle graphics](https://github.com/uhop/console-toolkit/wiki/images/example-turtle.png)
+
+## Code example
+
+```js
+import style, {c} from 'console-toolkit/style.js';
+import drawChart from 'console-toolkit/charts/bars/plain.js';
+import lineTheme from 'console-toolkit/themes/lines/unicode-rounded.js';
+import makeTable from 'console-toolkit/table';
+
+// styles
+
+console.log(style.bold + 'Hello, ' + style.bright.cyan + 'world!' + style.reset.all);
+
+console.log(style.bold.text('Hello, ') + style.bright.cyan.bold.text('world!'));
+
+const redBg = style.bg.red;
+console.log(redBg.bold.text('Hello, ') + redBg.bright.cyan.bold.text('world!'));
+
+console.log(c`{{bold}}Hello, {{bright.cyan}}world!`);
+
+// chart
+
+const chart = drawChart([[2, 1, 2], [5, 1, 4], [1, 1], [3, 1, 3]], 50);
+for (const line of chart) console.log(line);
+
+// table
+
+const tableData = [
+  ['Name', 'Value'],
+  ['Bill', 33],
+  ['Jill', 42]
+];
+
+const table = makeTable(tableData, lineTheme);
+for (const line of table.toStrings()) console.log(line);
+```
+
+The output of the code is:
+
+![Code example](https://github.com/uhop/console-toolkit/wiki/images/example-code.png)
+
+## Installation
+
+```bash
+npm install --save console-toolkit
+```
+
+## Documentation
+
+See [wiki](https://github.com/uhop/console-toolkit/wiki) for more details.
+
+## License
+
+BSD 3-Clause License
+
+## Release history
+
+- 1.0.0: *Initial release.*

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "console-toolkit",
+  "version": "1.0.0",
+  "description": "Toolkit to produce a fancy console output (boxes, tables, charts, colors).",
+  "type": "module",
+  "main": "src/index.js",
+  "module": "src/index.js",
+  "exports": {
+    "./*": "./src/*",
+    "./ansi": "./src/ansi/index.js",
+    "./plot": "./src/plot/index.js",
+    "./spinner": "./src/spinner/index.js",
+    "./table": "./src/table/index.js",
+    "./turtle": "./src/turtle/index.js",
+    "./box": "./src/box.js",
+    "./panel": "./src/panel.js",
+    "./strings": "./src/strings.js",
+    "./style": "./src/style.js"
+  },
+  "scripts": {
+    "test": "tape6 --flags FO"
+  },
+  "github": "http://github.com/uhop/console-toolkit",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/uhop/console-toolkit.git"
+  },
+  "keywords": [
+    "console",
+    "color",
+    "colors",
+    "box",
+    "boxes",
+    "table",
+    "tables",
+    "chart",
+    "charts",
+    "turtle",
+    "CLI",
+    "TUI"
+  ],
+  "author": "Eugene Lazutkin <eugene.lazutkin@gmail.com> (https://www.lazutkin.com/)",
+  "license": "BSD-3-Clause",
+  "bugs": {
+    "url": "https://github.com/uhop/console-toolkit/issues"
+  },
+  "homepage": "https://github.com/uhop/console-toolkit#readme",
+  "files": [
+    "./src"
+  ],
+  "tape6": {
+    "tests": [
+      "/tests/test-*.*js"
+    ]
+  },
+  "devDependencies": {
+    "tape-six": "^0.9.3"
+  }
+}

package/src/alphanumeric/arrows.js

@@ -0,0 +1,31 @@
+export const LEFT = 0,
+  UP = 1,
+  RIGHT = 2,
+  DOWN = 3;
+
+const toSymbol = (...args) => args.map(x => (typeof x == 'number' ? String.fromCodePoint(x) : x));
+const makeArrows = codePoint => toSymbol(codePoint, codePoint + 1, codePoint + 2, codePoint + 3);
+const makeArrowsH = codePoint => toSymbol(codePoint, ' ', codePoint + 1, ' ');
+
+// Arrows
+
+export const simple = makeArrows(0x2190);
+export const withStroke = makeArrowsH(0x219a);
+export const wave = makeArrowsH(0x219c);
+export const twoHeaded = makeArrows(0x219e);
+export const withTail = makeArrowsH(0x21a2);
+export const fromBar = makeArrows(0x21a4);
+export const withLoop = makeArrowsH(0x21ab);
+export const double = makeArrows(0x21d0);
+export const triple = makeArrowsH(0x21da);
+export const squiggle = makeArrowsH(0x21dc);
+export const dashed = makeArrows(0x21e0);
+export const toBar = makeArrowsH(0x21e4);
+export const white = makeArrows(0x21e6);
+export const withVStroke = makeArrowsH(0x21f7);
+export const withDoubleVStroke = makeArrowsH(0x21fa);
+export const openHeaded = makeArrowsH(0x21fd);
+
+export const withBarbUp = toSymbol(0x21bc, 0x21be, 0x21c1, 0x21c3);
+export const withBarbDown = toSymbol(0x21bd, 0x21bf, 0x21c0, 0x21c2);
+export const doubleWithStroke = toSymbol(0x21cd, ' ', 0x21cf, ' ');

package/src/alphanumeric/fractions.js

@@ -0,0 +1,82 @@
+export const fractions = [
+  [1, 7, '\u2150'],
+  [1, 9, '\u2151'],
+  [1, 10, '\u2152'],
+  [1, 3, '\u2153'],
+  [2, 3, '\u2154'],
+  [1, 5, '\u2155'],
+  [2, 5, '\u2156'],
+  [3, 5, '\u2157'],
+  [4, 5, '\u2158'],
+  [1, 6, '\u2159'],
+  [5, 6, '\u215A'],
+  [1, 8, '\u215B'],
+  [3, 8, '\u215C'],
+  [5, 8, '\u215D'],
+  [7, 8, '\u215E'],
+  [0, 3, '\u2189'],
+  [1, 4, '\u00BC'],
+  [1, 2, '\u00BD'],
+  [3, 4, '\u00BE']
+]
+  .map(x => ({numerator: x[0], denominator: x[1], symbol: x[2], value: x[0] / x[1]}))
+  .sort((a, b) => a.value - b.value);
+
+const pick = denominator => fractions.filter(x => !(denominator % x.denominator));
+
+export const thirds = pick(3);
+export const quarters = [{numerator: 0, denominator: 4, symbol: '0', value: 0}, ...pick(4)];
+export const fifths = [{numerator: 0, denominator: 5, symbol: '0', value: 0}, ...pick(5)];
+export const sixths = pick(6);
+export const eighths = [{numerator: 0, denominator: 8, symbol: '0', value: 0}, ...pick(8)];
+
+export {quarters as fourths};
+
+const binarySearch = (sortedArray, lessFn, from = 0, to = sortedArray.length) => {
+  let i = from,
+    j = to;
+  while (j - i > 0) {
+    const m = (i + j) >> 1;
+    if (lessFn(sortedArray[m])) i = m + 1;
+    else j = m;
+  }
+  return j;
+};
+
+const one = {value: 1, symbol: '1'};
+
+const findSymbol = (fractions, value, useFractionForZero) => {
+  if (value < 0) return '';
+  let int = Math.floor(value);
+  value -= int;
+
+  let index = binarySearch(fractions, x => x.value < value);
+
+  let chosen = fractions[0];
+  if (index === 0) return useFractionForZero && chosen.symbol !== '0' ? (int || '') + chosen.symbol : String(int);
+
+  const upper = index === fractions.length ? one : fractions[index],
+    lower = fractions[index - 1];
+
+  if (upper.value - value < value - lower.value) {
+    chosen = upper;
+  } else {
+    chosen = lower;
+    --index;
+  }
+
+  if (index === 0) return useFractionForZero && chosen.symbol !== '0' ? (int || '') + chosen.symbol : String(int);
+  if (chosen.symbol === '1') return String(int + 1);
+  if (chosen.symbol === '0') return String(int);
+
+  return (int || '') + chosen.symbol;
+};
+
+export const getFraction = (value, useFractionForZero) => findSymbol(fractions, value, useFractionForZero);
+export const getThirds = (value, useFractionForZero) => findSymbol(thirds, value, useFractionForZero);
+export const getQuarters = (value, useFractionForZero) => findSymbol(quarters, value, useFractionForZero);
+export const getFifths = (value, useFractionForZero) => findSymbol(fifths, value, useFractionForZero);
+export const getSixths = (value, useFractionForZero) => findSymbol(sixths, value, useFractionForZero);
+export const getEighths = (value, useFractionForZero) => findSymbol(eighths, value, useFractionForZero);
+
+export {getQuarters as getFourths};

package/src/alphanumeric/number-formatters.js

@@ -0,0 +1,131 @@
+// Initially copied from https://github.com/uhop/nano-bench
+
+const units = ['s', 'ms', 'μs', 'ns', 'ps'],
+  unicodeUnits = ['s', '㎳', '㎲', '㎱', '㎰'];
+
+export const prepareTimeFormat = (values, scale = 1, useUnicode) => {
+  let mx = -1000,
+    mn = 1000;
+  for (let i = 0; i < values.length; ++i) {
+    const p = Math.floor(Math.log(values[i] / scale) / Math.LN10);
+    if (isFinite(p)) {
+      if (mx < p) mx = p;
+      if (mn > p) mn = p;
+    }
+  }
+  if (mx < mn) mn = mx = -6;
+  const digits = Math.max(mx - mn + 1, 2);
+  scale = 1 / scale;
+  // TODO: get rid of the loop below
+  let i = 0;
+  for (; mx < 0 && i < units.length - 1; ++i, mx += 3, scale *= 1000);
+  return {scale, precision: digits - mx, unit: (useUnicode ? unicodeUnits : units)[i]};
+};
+
+export const formatTime = (value, format) => {
+  let result = (value * format.scale).toFixed(format.precision);
+  if (format.precision > 0) result = result.replace(/\.0+$/, '');
+  return result + format.unit;
+};
+
+const putCommasIn = (s, options) => {
+  if (s.length < 4) return s;
+  const comma = options?.comma || ',',
+    r = s.length % 3;
+  return (
+    (r ? s.slice(0, r) + comma : '') +
+    s
+      .slice(r)
+      .replace(/(\d{3})/g, '$1' + comma)
+      .slice(0, -1)
+  );
+};
+
+export const formatInteger = (value, options) =>
+  isNaN(value)
+    ? ''
+    : (value < 0 ? '-' : options?.keepSign ? '+' : '') + putCommasIn(Math.abs(value).toFixed(0), options);
+
+export const formatNumber = (value, options) => {
+  if (isNaN(value)) return '';
+  const decimals = options?.decimals ?? 0;
+  let sign = options?.keepSign ? '+' : '';
+  if (value < 0) {
+    value = -value;
+    sign = '-';
+  }
+  const s = value.toFixed(decimals);
+  if (decimals < 1) return sign + putCommasIn(s, options);
+  let fraction = s.slice(-decimals);
+  if (!options?.keepFractionAsIs) fraction = fraction.replace(/0+$/, '');
+  const dot = options?.dot ?? '.';
+  return sign + putCommasIn(s.slice(0, -decimals - 1), options) + (fraction ? dot + fraction : '');
+};
+
+const exp = [0, 0, 0, 0, 3, 3, 6, 6, 6, 9, 9, 9, 12];
+const abbr = '***k**M**G**T';
+
+export const abbrNumber = (value, options) => {
+  if (isNaN(value)) return '';
+  const decimals = options?.decimals ?? 0;
+  let sign = options?.keepSign ? '+' : '';
+  if (value < 0) {
+    value = -value;
+    sign = '-';
+  }
+  if (value <= 1) {
+    let t1 = value.toString(),
+      t2 = value.toFixed(decimals);
+    return sign + (t1.length < t2.length ? t1 : t2);
+  }
+  const digits = Math.min(Math.floor(Math.log(value) / Math.LN10), exp.length - 1),
+    e = exp[digits],
+    s = Math.round(value / Math.pow(10, e - decimals)).toFixed(0);
+  if (decimals < 1) return sign + putCommasIn(s, options) + ((e && abbr.charAt(e)) || '');
+  let fraction = s.slice(-decimals);
+  if (!options?.keepFractionAsIs) fraction = fraction.replace(/0+$/, '');
+  const dot = options?.dot ?? '.';
+  return (
+    sign +
+    putCommasIn(s.slice(0, -decimals), options) +
+    (fraction ? dot + fraction : '') +
+    ((e && abbr.charAt(e)) || '')
+  );
+};
+
+export const simplifyExponent = (s, {keepExpPlus} = {}) =>
+  String(s).replace(new RegExp('\\.?0*e' + (keepExpPlus ? '' : '\\+?'), 'i'), 'e');
+
+export const compareDifference = (a, b) => {
+  // works only on positive numbers
+  a = Math.abs(a);
+  b = Math.abs(b);
+
+  const less = a < b;
+  if (!less) [a, b] = [b, a];
+
+  if (a === b) return {less, equality: true};
+
+  const absDiff = b - a,
+    diff = absDiff / a;
+  if (diff === Infinity) return {less, infinity: true};
+
+  if (diff < 2) {
+    const percentage = diff * 100;
+    if (percentage < 0.001) return {less, equality: true};
+    if (percentage < 1) return {less, percentage: formatNumber(percentage, {decimals: 3})};
+    if (percentage < 10) return {less, percentage: formatNumber(percentage, {decimals: 2})};
+    if (percentage < 100) return {less, percentage: formatNumber(percentage, {decimals: 1})};
+    return {less, percentage: formatNumber(percentage, {decimals: 0})};
+  }
+
+  const ratio = b / a;
+
+  if (ratio < 10000) {
+    if (ratio < 10) return {less, ratio: formatNumber(ratio, {decimals: 2})};
+    if (ratio < 100) return {less, ratio: formatNumber(ratio, {decimals: 1})};
+    return {less, ratio: formatNumber(ratio, {decimals: 0})};
+  }
+
+  return {less, ratio: simplifyExponent(ratio.toPrecision(2))};
+};

package/src/alphanumeric/roman.js

@@ -0,0 +1,86 @@
+import {transcodeTables} from './unicode-numbers.js';
+
+const {roman, romanLower} = transcodeTables;
+
+const indexL = 12,
+  indexC = 13,
+  indexD = 14,
+  indexM = 15,
+  upperICodePoint = roman.get(1).codePointAt(0),
+  upperL = String.fromCodePoint(upperICodePoint + indexL),
+  upperC = String.fromCodePoint(upperICodePoint + indexC),
+  upperD = String.fromCodePoint(upperICodePoint + indexD),
+  upperM = String.fromCodePoint(upperICodePoint + indexM),
+  lowerICodePoint = romanLower.get(1).codePointAt(0),
+  lowerL = String.fromCodePoint(lowerICodePoint + indexL),
+  lowerC = String.fromCodePoint(lowerICodePoint + indexC),
+  lowerD = String.fromCodePoint(lowerICodePoint + indexD),
+  lowerM = String.fromCodePoint(lowerICodePoint + indexM);
+
+const romanGroup = (value, one, five, ten) => {
+  if (value <= 3) return one.repeat(value);
+  if (value == 4) return one + five;
+  if (value <= 8) return five + one.repeat(value - 5);
+  return one + ten;
+};
+
+export const toRoman = value => {
+  value = Math.round(value);
+  if (value < 1 || value > 3999)
+    throw new Error(`Should be a positive integer not exceeding 3999 instead of "${value}"`);
+
+  const result = [romanGroup(value % 10, 'I', 'V', 'X')];
+  value = Math.floor(value / 10);
+
+  while (value) {
+    result.push(romanGroup(value % 10, 'X', 'L', 'C'));
+    value = Math.floor(value / 10);
+    if (!value) break;
+
+    result.push(romanGroup(value % 10, 'C', 'D', 'M'));
+    value = Math.floor(value / 10);
+    if (!value) break;
+
+    result.push(romanGroup(value % 10, 'M'));
+    break;
+  }
+
+  return result.reverse().join('');
+};
+
+const toRomanUnicodeFn = (roman, L, C, D, M) => value => {
+  value = Math.round(value);
+  if (value < 1 || value > 3999)
+    throw new Error(`Should be a positive integer not exceeding 3999 instead of "${value}"`);
+
+  const result = [];
+
+  while (value) {
+    const last2 = value % 100;
+    if (last2 <= 12) {
+      if (last2) result.push(roman.get(last2));
+      value = Math.floor(value / 100);
+    } else {
+      const digit = value % 10;
+      if (digit) result.push(roman.get(digit));
+      value = Math.floor(value / 10);
+      if (!value) break;
+
+      result.push(romanGroup(value % 10, roman.get(10), L, C));
+      value = Math.floor(value / 10);
+    }
+    if (!value) break;
+
+    result.push(romanGroup(value % 10, C, D, M));
+    value = Math.floor(value / 10);
+    if (!value) break;
+
+    result.push(romanGroup(value % 10, M));
+    break;
+  }
+
+  return result.reverse().join('');
+};
+
+export const toRomanUnicode = toRomanUnicodeFn(roman, upperL, upperC, upperD, upperM);
+export const toRomanLowerUnicode = toRomanUnicodeFn(romanLower, lowerL, lowerC, lowerD, lowerM);

package/src/alphanumeric/unicode-cultural-numbers.js

@@ -0,0 +1,68 @@
+import {SymbolRange} from './utils.js';
+
+export const transcodeTables = {
+  arabicIndic: new SymbolRange('٠'),
+  arabicIndicExtended: new SymbolRange('۰'),
+  tamil: new SymbolRange('௦', 0, 10),
+  nko: new SymbolRange('߀'),
+  devanagari: new SymbolRange('०'),
+  bengali: new SymbolRange('০'),
+  gurmukhi: new SymbolRange('੦'),
+  gujarati: new SymbolRange('૦'),
+  oriya: new SymbolRange('୦'),
+  telugu: new SymbolRange('౦'),
+  kannada: new SymbolRange('೦'),
+  malayalam: new SymbolRange('൦', 0, 10),
+  thai: new SymbolRange('๐'),
+  lao: new SymbolRange('໐'),
+  myanmar: new SymbolRange('၀'),
+  myanmarShan: new SymbolRange('႐'),
+  ethiopic: new SymbolRange('፩', 1, 10),
+  khmer: new SymbolRange('០'),
+  mongolian: new SymbolRange('᠐'),
+  limbu: new SymbolRange('᥆'),
+  balinese: new SymbolRange('᭐'),
+  sundanese: new SymbolRange('᮰'),
+  lepcha: new SymbolRange('᱀'),
+  vai: new SymbolRange('꘠'),
+  saurashtra: new SymbolRange('꣐'),
+  javanese: new SymbolRange('꧐'),
+  cham: new SymbolRange('꩐'),
+  osmanya: new SymbolRange('𐒠'),
+  kharoshthi: new SymbolRange('𐩀', 1, 4),
+  rumi: new SymbolRange('𐹠', 1, 10),
+  brahmi: new SymbolRange('𑁦'),
+  brahmiNumbers: new SymbolRange('𑁒', 1, 10),
+  chakma: new SymbolRange('𑄶'),
+  sharada: new SymbolRange('𑇐'),
+  khudawadi: new SymbolRange('𑋰'),
+  newa: new SymbolRange('𑑐'),
+  tirhuta: new SymbolRange('𑓐'),
+  modi: new SymbolRange('𑙐'),
+  takri: new SymbolRange('𑛀'),
+  ahom: new SymbolRange('𑜰', 0, 10),
+  bhaiksuki: new SymbolRange('𑱐'),
+  bhaiksukiNumbers: new SymbolRange('𑱚', 1, 10),
+  // kawi: new SymbolRange('𑽐'),
+  mro: new SymbolRange('𖩠'),
+  // tangsa: new SymbolRange('𖫀'),
+  medefaidrin: new SymbolRange('𖺀', 0, 19),
+  wancho: new SymbolRange('𞋰'),
+  adlam: new SymbolRange('𞥐'),
+  aegean: new SymbolRange('𐄇', 1, 10),
+  palmyren: new SymbolRange('𐡹', 1, 5),
+  nabataean: new SymbolRange('𐢧', 1, 4),
+  oldPersian: new SymbolRange('𐏑', 1, 2),
+  imperialAramaic: new SymbolRange('𐡘', 1, 3),
+  meroiticCursive: new SymbolRange('𐧀', 1, 10),
+  inscriptionalParthian: new SymbolRange('𐭘', 1, 4),
+  inscriptionalPahlavi: new SymbolRange('𐭸', 1, 4),
+  psalterPahlavi: new SymbolRange('𐮩', 1, 4),
+  oldSogdian: new SymbolRange('𐼝', 1, 5),
+  indicSiyaq: new SymbolRange('𞱱', 1, 10),
+  indicSiyaqPrefixed: new SymbolRange('𞲣', 1, 9),
+  indicSiyaqAlternate: new SymbolRange('𞲱', 1, 2),
+  // ottomanSiyaq: new SymbolRange('𞴁', 1, 10),
+  // ottomanSiyaqAlternative: new SymbolRange('𞴯', 2, 10),
+  copticEpact: new SymbolRange('𐋡', 1, 10)
+};

package/src/alphanumeric/unicode-letters.js

@@ -0,0 +1,63 @@
+import {SymbolRange, transcode as internalTranscode} from './utils.js';
+
+const range = (fromCapital, fromSmall) =>
+  [fromCapital && new SymbolRange(fromCapital, 0, 25, 'A'), fromSmall && new SymbolRange(fromSmall, 0, 25, 'a')].filter(
+    x => x
+  );
+
+export const transcodeTables = {
+  bold: range('\u{1D400}', '\u{1D41A}'),
+  italic: range('\u{1D434}', '\u{1D44E}'),
+  boldItalic: range('\u{1D468}', '\u{1D482}'),
+  sansSerif: range('\u{1D5A0}', '\u{1D5BA}'),
+  sansSerifBold: range('\u{1D5D4}', '\u{1D5EE}'),
+  sansSerifItalic: range('\u{1D608}', '\u{1D622}'),
+  sansSerifBoldItalic: range('\u{1D63C}', '\u{1D656}'),
+  script: range('\u{1D49C}', '\u{1D4B6}'),
+  scriptBold: range('\u{1D4D0}', '\u{1D4EA}'),
+  fraktur: range('\u{1D504}', '\u{1D51E}'),
+  frakturBold: range('\u{1D56C}', '\u{1D586}'),
+  mono: range('\u{1D670}', '\u{1D68A}'),
+  doubleStruck: range('\u{1D538}', '\u{1D552}'),
+  // embellishments
+  parens: range('\u{1F110}', '\u{249C}'),
+  circled: range('\u{24B6}', '\u{24D0}'),
+  squared: range('\u{1F130}', ''),
+  negativeCircled: range('\u{1F150}', ''),
+  negativeSquared: range('\u{1F170}', ''),
+  regionalIndicators: range('\u{1F1E6}', '')
+};
+
+// patches as suggested in https://en.wikipedia.org/wiki/Mathematical_Alphanumeric_Symbols
+
+transcodeTables.script[0].overlay = {
+  B: '\u{212C}',
+  E: '\u{2130}',
+  F: '\u{2131}',
+  H: '\u{210B}',
+  I: '\u{2110}',
+  L: '\u{2112}',
+  M: '\u{2133}',
+  R: '\u{211B}'
+};
+transcodeTables.fraktur[0].overlay = {C: '\u{212D}', H: '\u{210C}', I: '\u{2111}', R: '\u{211C}', Z: '\u{2128}'};
+transcodeTables.doubleStruck[0].overlay = {
+  C: '\u{2102}',
+  H: '\u{210D}',
+  N: '\u{2115}',
+  P: '\u{2119}',
+  Q: '\u{211A}',
+  R: '\u{211D}',
+  Z: '\u{2124}'
+};
+
+transcodeTables.italic[1].overlay = {h: '\u{210E}'};
+transcodeTables.script[1].overlay = {e: '\u{212F}', g: '\u{210A}', o: '\u{2134}'};
+
+// API
+
+export const transcode = (s, name, options) => {
+  let tables = typeof name == 'string' ? transcodeTables[name] : name;
+  if (!tables) throw new Error(`There is no transcode table "${name}"`);
+  return internalTranscode(s, tables, options);
+};