reslop 0.2.7 → 0.3.1

package/lib/term/ansi.js

@@ -0,0 +1,396 @@
+'use strict';
+
+const { resource } = require('../common/utilities.js');
+
+const ASCII_RE = /^[\x20-\x7e]*$/;
+// Printable characters that never join a neighbour into one grapheme
+const SOLO_RE = new RegExp(
+  '^[\\x20-\\x7e\\u00a0-\\u017f\\u0400-\\u0482\\u048a-\\u04ff' +
+    '\\u2010-\\u2027\\u2190-\\u21ff\\u2500-\\u25ff\\u2700-\\u27bf' +
+    '\\u2800-\\u28ff]*$',
+);
+
+let segmenter = null;
+
+const segments = (text) => {
+  segmenter ??= new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+  return segmenter.segment(text);
+};
+
+const ESC = String.fromCodePoint(0x1b);
+const CSI_RE = `${ESC}\\[[0-9;?]*[ -/]*[@-~]`;
+const OSC_RE = `${ESC}\\][^\x07\x1b]*(?:\x07|${ESC}\\\\)`;
+const ANSI_RE = new RegExp(`${CSI_RE}|${OSC_RE}`, 'g');
+const RESET = `${ESC}[0m`;
+const BOLD = `${ESC}[1m`;
+const EL = `${ESC}[K`;
+const ST = `${ESC}\\`;
+
+const WIDE_CP = resource(__dirname, 'wide.txt')
+  .split(/[\s-]+/)
+  .filter(Boolean)
+  .map((cp) => parseInt(cp, 16));
+
+const rgbOf = (hex) =>
+  [1, 3, 5].map((at) => parseInt(hex.slice(at, at + 2), 16));
+
+const colorsOf = (map) => {
+  const colors = {};
+  for (const key of Object.keys(map)) colors[key] = rgbOf(map[key]);
+  return colors;
+};
+
+const paletteOf = ({ ui, code, logCols }) => ({
+  ui: colorsOf(ui),
+  code: colorsOf(code),
+  logCols: logCols.map(rgbOf),
+});
+
+const PALETTES = {
+  dark: paletteOf(require('./themes/dark.json')),
+  light: paletteOf(require('./themes/light.json')),
+};
+const THEME_NAMES = Object.keys(PALETTES);
+
+const applyColors = (into, from) => {
+  for (const key of Object.keys(from)) {
+    const src = from[key];
+    const dst = into[key];
+    dst[0] = src[0];
+    dst[1] = src[1];
+    dst[2] = src[2];
+  }
+};
+
+const THEME = structuredClone(PALETTES.dark.ui);
+const CODE_FG = structuredClone(PALETTES.dark.code);
+const LOG_COL_FG = structuredClone(PALETTES.dark.logCols);
+let currentTheme = 'dark';
+
+const setTheme = (name) => {
+  if (!Object.hasOwn(PALETTES, name)) {
+    throw new Error(`unknown theme ${name}`);
+  }
+  const palette = PALETTES[name];
+  applyColors(THEME, palette.ui);
+  applyColors(CODE_FG, palette.code);
+  applyColors(LOG_COL_FG, palette.logCols);
+  currentTheme = name;
+};
+
+const themeName = () => currentTheme;
+
+const codeFg = (style) => {
+  if (typeof style !== 'string') return CODE_FG.plain;
+  if (Object.hasOwn(CODE_FG, style)) return CODE_FG[style];
+  if (style.startsWith('logCol')) {
+    const i = parseInt(style.slice(6), 10);
+    return LOG_COL_FG[i % LOG_COL_FG.length];
+  }
+  return CODE_FG.plain;
+};
+
+const channels = (rgb) => {
+  if (typeof rgb === 'number') return `${rgb};${rgb};${rgb}`;
+  return `${rgb[0]};${rgb[1]};${rgb[2]}`;
+};
+
+const fg = (rgb) => `${ESC}[38;2;${channels(rgb)}m`;
+
+const bg = (rgb) => `${ESC}[48;2;${channels(rgb)}m`;
+
+const seq = (fgRgb, bgRgb) => `${fg(fgRgb)}${bg(bgRgb)}`;
+
+const paint = (text, fgRgb, bgRgb, color, bold) => {
+  if (!color || text === '') return text;
+  const mark = bold ? BOLD : '';
+  return `${mark}${seq(fgRgb, bgRgb)}${text}${RESET}`;
+};
+
+const hyperlink = (href, label) => {
+  const uri = `${href ?? ''}`.replaceAll(ESC, '').replaceAll('\x07', '');
+  const text = `${label ?? ''}`;
+  if (!uri || !text) return text;
+  return `${ESC}]8;;${uri}${ST}${text}${ESC}]8;;${ST}`;
+};
+
+const stripAnsi = (text) => text.replace(ANSI_RE, '');
+
+const graphemes = (text) => {
+  if (SOLO_RE.test(text)) return text.split('');
+  const parts = new Array(text.length);
+  let n = 0;
+  for (const { segment } of segments(text)) parts[n++] = segment;
+  parts.length = n;
+  return parts;
+};
+
+const isWide = (cp) => {
+  let lo = 0;
+  let hi = WIDE_CP.length >> 1;
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1;
+    const start = WIDE_CP[mid << 1];
+    const end = WIDE_CP[(mid << 1) + 1];
+    if (cp < start) hi = mid;
+    else if (cp > end) lo = mid + 1;
+    else return true;
+  }
+  return false;
+};
+
+const graphemeWidth = (ch, col) => {
+  if (ch === '\t') return 8 - (col % 8);
+  if (ch === '\n' || ch === '\r') return 0;
+  const cp = ch.codePointAt(0);
+  if (cp >= 0x20 && cp < 0x7f) return 1;
+  if (cp <= 0x1f || cp === 0x7f) return 0;
+  if (cp === 0x200d) return 0;
+  if (cp >= 0xfe00 && cp <= 0xfe0f) return 0;
+  if (isWide(cp)) return 2;
+  return 1;
+};
+
+const plainText = (text) => (text.includes(ESC) ? stripAnsi(text) : text);
+
+const visibleWidth = (text) => {
+  const plain = plainText(text);
+  if (ASCII_RE.test(plain)) return plain.length;
+  let width = 0;
+  for (const ch of graphemes(plain)) {
+    width += graphemeWidth(ch, width);
+  }
+  return width;
+};
+
+const truncateVisible = (text, width, mark = '') => {
+  if (width <= 0) return '';
+  const plain = plainText(text);
+  if (visibleWidth(plain) <= width) return text;
+  const markW = mark ? visibleWidth(mark) : 0;
+  const fits = markW > 0 && markW <= width;
+  const limit = fits ? width - markW : width;
+  let out = '';
+  if (ASCII_RE.test(plain)) {
+    out = plain.slice(0, limit);
+  } else {
+    let used = 0;
+    for (const ch of graphemes(plain)) {
+      const w = graphemeWidth(ch, used);
+      if (used + w > limit) break;
+      out += ch;
+      used += w;
+    }
+  }
+  return fits ? `${out}${mark}` : out;
+};
+
+const trimVisible = (text, width) => truncateVisible(text, width, '…');
+
+const csiLength = (text, index) => {
+  if (text[index] !== ESC || text[index + 1] !== '[') return 0;
+  let at = index + 2;
+  while (at < text.length) {
+    const code = text.charCodeAt(at);
+    at += 1;
+    if (code >= 64 && code <= 126) return at - index;
+  }
+  return 0;
+};
+
+const oscLength = (text, index) => {
+  if (text[index] !== ESC || text[index + 1] !== ']') return 0;
+  let at = index + 2;
+  while (at < text.length) {
+    if (text[at] === '\x07') return at + 1 - index;
+    if (text[at] === ESC && text[at + 1] === '\\') return at + 2 - index;
+    at += 1;
+  }
+  return 0;
+};
+
+const ansiLength = (text, index) => {
+  const csi = csiLength(text, index);
+  return csi || oscLength(text, index);
+};
+
+const firstGrapheme = (text) => {
+  const next = segments(text)[Symbol.iterator]().next();
+  if (next.done || !next.value) return '';
+  return next.value.segment;
+};
+
+const graphemeAt = (text, index) => {
+  const code = text.charCodeAt(index);
+  const plain = code >= 0x20 && code < 0x7f;
+  if (plain && !(text.charCodeAt(index + 1) >= 0x300)) return text[index];
+  return firstGrapheme(text.slice(index));
+};
+
+const takeVisible = (text, width) => {
+  const raw = `${text ?? ''}`;
+  if (width <= 0) return '';
+  let used = 0;
+  let index = 0;
+  let fits = true;
+  while (fits && index < raw.length && used < width) {
+    const skip = ansiLength(raw, index);
+    if (skip) {
+      index += skip;
+      continue;
+    }
+    const next = raw.indexOf(ESC, index + 1);
+    const run = raw.slice(index, next < 0 ? raw.length : next);
+    for (const { segment } of segments(run)) {
+      const w = graphemeWidth(segment, used);
+      fits = used + w <= width;
+      if (!fits) break;
+      used += w;
+      index += segment.length;
+      if (used >= width) break;
+    }
+  }
+  return raw.slice(0, index);
+};
+
+const clipAnsi = (text, width) => {
+  const raw = `${text ?? ''}`;
+  if (width <= 0) return '';
+  if (visibleWidth(raw) <= width) return raw;
+  let out = takeVisible(raw, width);
+  if (stripAnsi(out) !== stripAnsi(raw)) out += RESET;
+  return out;
+};
+
+const dropVisible = (text, skip) => {
+  const raw = `${text ?? ''}`;
+  if (skip <= 0) return raw;
+  let used = 0;
+  let index = 0;
+  let style = '';
+  while (index < raw.length && used < skip) {
+    const ansi = ansiLength(raw, index);
+    if (ansi) {
+      const seq = raw.slice(index, index + ansi);
+      if (seq[1] === '[' && seq.endsWith('m')) style = seq;
+      index += ansi;
+      continue;
+    }
+    const ch = graphemeAt(raw, index);
+    if (!ch) break;
+    const w = graphemeWidth(ch, used);
+    if (used + w > skip) break;
+    used += w;
+    index += ch.length;
+  }
+  const rest = raw.slice(index);
+  if (!style) return rest;
+  return `${style}${rest}`;
+};
+
+const stampVisible = (line, x, face) => {
+  const raw = `${line ?? ''}`;
+  const mark = `${face ?? ''}`;
+  const at = Math.max(0, x);
+  const left = takeVisible(raw, at);
+  const right = dropVisible(raw, at + visibleWidth(mark));
+  return `${left}${mark}${right}`;
+};
+
+const sgrParams = (seq) => {
+  const inner = seq.slice(2, -1);
+  if (!inner) return [0];
+  return inner.split(';').map((part) => (part === '' ? 0 : Number(part)));
+};
+
+const colorSpan = (params, index) => {
+  const mode = params[index + 1];
+  if (mode === 5) return 2;
+  if (mode === 2) return 4;
+  return 0;
+};
+
+const keepFgParams = (params) => {
+  const kept = [];
+  for (let i = 0; i < params.length; i++) {
+    const code = params[i];
+    if (code === 38 || code === 48) {
+      const extra = colorSpan(params, i);
+      if (code === 38 && extra) {
+        kept.push(code, ...params.slice(i + 1, i + 1 + extra));
+      }
+      i += extra;
+      continue;
+    }
+    if (code >= 40 && code <= 49) continue;
+    if (code >= 100 && code <= 107) continue;
+    if (code === 7 || code === 27) continue;
+    kept.push(code);
+  }
+  return kept;
+};
+
+const foregroundOn = (text, bgRgb) => {
+  const raw = `${text ?? ''}`;
+  const ground = bg(bgRgb);
+  let out = '';
+  let index = 0;
+  while (index < raw.length) {
+    if (raw[index] !== ESC) {
+      const next = raw.indexOf(ESC, index);
+      const end = next < 0 ? raw.length : next;
+      out += raw.slice(index, end);
+      index = end;
+      continue;
+    }
+    const skip = ansiLength(raw, index);
+    if (!skip) {
+      out += raw[index];
+      index += 1;
+      continue;
+    }
+    const seq = raw.slice(index, index + skip);
+    index += skip;
+    if (seq[1] !== '[' || !seq.endsWith('m')) {
+      out += seq;
+      continue;
+    }
+    const kept = keepFgParams(sgrParams(seq));
+    const reset = kept.includes(0);
+    const rest = kept.filter((code) => code !== 0);
+    if (reset) out += RESET;
+    out += ground;
+    if (rest.length) out += `${ESC}[${rest.join(';')}m`;
+  }
+  return out;
+};
+
+module.exports = {
+  ESC,
+  RESET,
+  BOLD,
+  EL,
+  THEME,
+  CODE_FG,
+  PALETTES,
+  THEME_NAMES,
+  setTheme,
+  themeName,
+  codeFg,
+  fg,
+  bg,
+  seq,
+  paint,
+  hyperlink,
+  stripAnsi,
+  graphemes,
+  graphemeWidth,
+  visibleWidth,
+  truncateVisible,
+  trimVisible,
+  firstGrapheme,
+  graphemeAt,
+  clipAnsi,
+  stampVisible,
+  foregroundOn,
+};

package/lib/{clipboard.js → term/clipboard.js}

@@ -1,12 +1,9 @@
 'use strict';
 
-const childProcess = require('node:child_process');
-const { spawnSync } = childProcess;
+const { spawnSync } = require('node:child_process');
 
-const ansi = require('./ansi.js');
-const { ESC } = ansi;
-const utilities = require('./utilities.js');
-const { spawnBase } = utilities;
+const { ESC } = require('./ansi.js');
+const { spawnBase } = require('../common/process.js');
 
 const CLIP_TIMEOUT_MS = 1000;
 

package/lib/{select.js → term/select.js}

@@ -2,7 +2,7 @@
 
 const ansi = require('./ansi.js');
 const { ESC, RESET, THEME, seq, fg, bg, stripAnsi, visibleWidth } = ansi;
-const { graphemes, graphemeWidth, firstGrapheme } = ansi;
+const { graphemes, graphemeWidth, graphemeAt } = ansi;
 
 const CSI_FINAL = /[@-~]/;
 const TRUECOLOR = 2;
@@ -108,7 +108,7 @@ const parseCells = (line) => {
       i += 1;
       continue;
     }
-    const ch = firstGrapheme(line.slice(i));
+    const ch = graphemeAt(line, i);
     if (!ch) break;
     const width = graphemeWidth(ch, col);
     cells.push({ ch, fg: state.fg, bg: state.bg, col, width });
@@ -151,7 +151,8 @@ const overlayRange = (line, fromCol, toCol) => {
 };
 
 const editorSelection = (view) => {
-  const source = view?.compose || view?.codeOverlay;
+  const taskEdit = view?.pane === 'tasks' ? view.taskEdit : null;
+  const source = view?.compose || view?.codeOverlay || taskEdit;
   if (!source || typeof source.anchor !== 'number') return null;
   const cursor = source.cursor ?? 0;
   if (source.anchor === cursor) return null;

package/lib/term/themes/dark.json

@@ -0,0 +1,122 @@
+{
+  "ui": {
+    "delLineFg": "#cc7a7a",
+    "delLineBg": "#3a1a1a",
+    "delCharFg": "#ffffff",
+    "delCharBg": "#752222",
+    "addLineFg": "#7acc8a",
+    "addLineBg": "#142814",
+    "addCharFg": "#ffffff",
+    "addCharBg": "#1a4c26",
+    "ctxFg": "#8a8a8a",
+    "ctxBg": "#121218",
+    "lineNoFg": "#8a8a96",
+    "lineNoBg": "#0e0e14",
+    "splitGutterFg": "#181824",
+    "splitGutterBg": "#181824",
+    "headerFg": "#3a3a3a",
+    "headerBg": "#e6e6ee",
+    "headerChromeFg": "#5a5a5a",
+    "headerRepoFg": "#3a3a3a",
+    "headerDirFg": "#6e6e6e",
+    "headerSlashFg": "#8a8a8a",
+    "headerFileFg": "#4e4e4e",
+    "chromeFg": "#d0d0e0",
+    "chromeBg": "#181824",
+    "noteBg": "#242436",
+    "buttonFg": "#6a6a7e",
+    "buttonBg": "#2a2a40",
+    "buttonHotFg": "#ffffff",
+    "currentBg": "#a8ccb4",
+    "checkFg": "#f4f4fc",
+    "checkBg": "#525274",
+    "checkDoneFg": "#f0fff4",
+    "checkDoneBg": "#225834",
+    "errorFg": "#ff8080",
+    "warnFg": "#e8c84a",
+    "mutedFg": "#7a7a8a",
+    "shaFg": "#569cd6",
+    "pkgDepFg": "#afe0b9",
+    "pkgDevFg": "#9ac4e6",
+    "pkgFg": "#c8c8d2",
+    "pkgChainFg": "#555562",
+    "shaDarkFg": "#154a8c",
+    "stagedDelLineFg": "#a0a0a8",
+    "stagedDelLineBg": "#202026",
+    "stagedDelCharFg": "#f0f0f4",
+    "stagedDelCharBg": "#44444e",
+    "stagedAddLineFg": "#b0b0b8",
+    "stagedAddLineBg": "#26262e",
+    "stagedAddCharFg": "#ffffff",
+    "stagedAddCharBg": "#4e4e58",
+    "dashBg": "#000000",
+    "dashTileBg": "#26262a",
+    "dashRowBg": "#1c1c1f",
+    "dashHeadBg": "#70707c",
+    "dashDimHeadBg": "#303038",
+    "dashDimTileBg": "#121214",
+    "dashDimRowBg": "#0c0c0e",
+    "dashHeadMuted": "#f2f2fa",
+    "dashCaptionFg": "#a0a0ac",
+    "dashDelFg": "#ffd2d2",
+    "heatTrack": "#3a3c48",
+    "heat1": "#1c3a32",
+    "heat2": "#2a5a38",
+    "heat3": "#8a6a18",
+    "heat4": "#a03a28",
+    "heatFg": "#f4f4f8",
+    "heatBlink": "#f2e28a",
+    "heatBlinkFg": "#1a1608",
+    "dashKeyFg": "#ffffff",
+    "taskHeadFg": "#ffffff",
+    "taskHeadBg": "#3c3c48",
+    "searchFg": "#1a1608",
+    "searchBg": "#8a6a18",
+    "searchOnFg": "#1a1608",
+    "searchOnBg": "#f2e28a"
+  },
+  "code": {
+    "keyword": "#c586c0",
+    "control": "#c586c0",
+    "storage": "#569cd6",
+    "literal": "#569cd6",
+    "string": "#ce9178",
+    "template": "#ce9178",
+    "escape": "#d16969",
+    "interpolation": "#9cdcfe",
+    "number": "#b5cea8",
+    "comment": "#6a9955",
+    "function": "#dcdcaa",
+    "method": "#dcdcaa",
+    "className": "#4ec9b0",
+    "type": "#4ec9b0",
+    "interface": "#4ec9b0",
+    "property": "#9cdcfe",
+    "variable": "#9cdcfe",
+    "parameter": "#9cdcfe",
+    "constant": "#4fc1ff",
+    "operator": "#d4d4d4",
+    "punct": "#d4d4d4",
+    "regex": "#d16969",
+    "decorator": "#dcdcaa",
+    "tag": "#569cd6",
+    "attr": "#9cdcfe",
+    "plain": "#d4d4d4",
+    "punctDim": "#808080",
+    "logDate": "#d2d2dc",
+    "logError": "#e65a5a",
+    "logWarn": "#e6b450",
+    "logInfo": "#64aae6",
+    "logDebug": "#8ca0b4"
+  },
+  "logCols": [
+    "#d2d2dc",
+    "#78b4dc",
+    "#b4a0dc",
+    "#8cc8a0",
+    "#dcb478",
+    "#dc8ca0",
+    "#a0c8c8",
+    "#c8aa8c"
+  ]
+}

package/lib/term/themes/light.json

@@ -0,0 +1,122 @@
+{
+  "ui": {
+    "delLineFg": "#b31d28",
+    "delLineBg": "#ffebe9",
+    "delCharFg": "#1f2328",
+    "delCharBg": "#ffc1c0",
+    "addLineFg": "#1a7f37",
+    "addLineBg": "#e6ffec",
+    "addCharFg": "#1f2328",
+    "addCharBg": "#abf2bc",
+    "ctxFg": "#57606a",
+    "ctxBg": "#f2f4f8",
+    "lineNoFg": "#6e7781",
+    "lineNoBg": "#eef0f4",
+    "splitGutterFg": "#eaeef2",
+    "splitGutterBg": "#eaeef2",
+    "headerFg": "#24292f",
+    "headerBg": "#ffffff",
+    "headerChromeFg": "#424a53",
+    "headerRepoFg": "#24292f",
+    "headerDirFg": "#57606a",
+    "headerSlashFg": "#8c959f",
+    "headerFileFg": "#1f2328",
+    "chromeFg": "#24292f",
+    "chromeBg": "#f2f4f8",
+    "noteBg": "#f8fbff",
+    "buttonFg": "#57606a",
+    "buttonBg": "#f7f9fc",
+    "buttonHotFg": "#0f1419",
+    "currentBg": "#ace1c2",
+    "checkFg": "#1f2328",
+    "checkBg": "#c8cfd8",
+    "checkDoneFg": "#0f3d1f",
+    "checkDoneBg": "#abf2bc",
+    "errorFg": "#cf222e",
+    "warnFg": "#9a6700",
+    "mutedFg": "#6e7781",
+    "shaFg": "#0550ae",
+    "pkgDepFg": "#3ca85a",
+    "pkgDevFg": "#3d7ec8",
+    "pkgFg": "#9aa2ac",
+    "pkgChainFg": "#3a424c",
+    "shaDarkFg": "#0b3d70",
+    "stagedDelLineFg": "#57606a",
+    "stagedDelLineBg": "#f3f4f6",
+    "stagedDelCharFg": "#1f2328",
+    "stagedDelCharBg": "#d8dce1",
+    "stagedAddLineFg": "#424a53",
+    "stagedAddLineBg": "#eaecef",
+    "stagedAddCharFg": "#0f1419",
+    "stagedAddCharBg": "#ccd1d7",
+    "dashBg": "#f2f4f8",
+    "dashTileBg": "#f8fafe",
+    "dashRowBg": "#f5f7fb",
+    "dashHeadBg": "#ffffff",
+    "dashDimHeadBg": "#d5dae1",
+    "dashDimTileBg": "#e6eaf0",
+    "dashDimRowBg": "#d8dde4",
+    "dashHeadMuted": "#3e4652",
+    "dashCaptionFg": "#6e7781",
+    "dashDelFg": "#d03a44",
+    "heatTrack": "#c5cad3",
+    "heat1": "#c8e6d4",
+    "heat2": "#7dc896",
+    "heat3": "#e6b43c",
+    "heat4": "#e07868",
+    "heatFg": "#1f2328",
+    "heatBlink": "#fff3b0",
+    "heatBlinkFg": "#1a1608",
+    "dashKeyFg": "#000000",
+    "taskHeadFg": "#ffffff",
+    "taskHeadBg": "#ffffff",
+    "searchFg": "#1a1608",
+    "searchBg": "#f0c86a",
+    "searchOnFg": "#1a1608",
+    "searchOnBg": "#ffe14a"
+  },
+  "code": {
+    "keyword": "#af00db",
+    "control": "#af00db",
+    "storage": "#0000ff",
+    "literal": "#0000ff",
+    "string": "#a31515",
+    "template": "#a31515",
+    "escape": "#ee0000",
+    "interpolation": "#001080",
+    "number": "#098658",
+    "comment": "#008000",
+    "function": "#795e26",
+    "method": "#795e26",
+    "className": "#267f99",
+    "type": "#267f99",
+    "interface": "#267f99",
+    "property": "#001080",
+    "variable": "#001080",
+    "parameter": "#001080",
+    "constant": "#0070c1",
+    "operator": "#3c3c3c",
+    "punct": "#3c3c3c",
+    "regex": "#811f3f",
+    "decorator": "#795e26",
+    "tag": "#800000",
+    "attr": "#e50000",
+    "plain": "#1f1f1f",
+    "punctDim": "#8c8c8c",
+    "logDate": "#3c3c46",
+    "logError": "#cd3131",
+    "logWarn": "#a06e00",
+    "logInfo": "#005ab4",
+    "logDebug": "#646e7d"
+  },
+  "logCols": [
+    "#3c3c46",
+    "#005f96",
+    "#6e46aa",
+    "#1e783c",
+    "#965f14",
+    "#aa325a",
+    "#147878",
+    "#825a32"
+  ]
+}

package/lib/term/wide.txt

@@ -0,0 +1,21 @@
+1100-115f 231a-231b 2329-232a 23e9-23ec 23f0-23f0 23f3-23f3
+25fd-25fe 2614-2615 2630-2637 2648-2653 267f-267f 268a-268f
+2693-2693 26a1-26a1 26aa-26ab 26bd-26be 26c4-26c5 26ce-26ce
+26d4-26d4 26ea-26ea 26f2-26f3 26f5-26f5 26fa-26fa 26fd-26fd
+2705-2705 270a-270b 2728-2728 274c-274c 274e-274e 2753-2755
+2757-2757 2795-2797 27b0-27b0 27bf-27bf 2b1b-2b1c 2b50-2b50
+2b55-2b55 2e80-2e99 2e9b-2ef3 2f00-2fd5 2ff0-303e 3041-3096
+3099-30ff 3105-312f 3131-318e 3190-31e5 31ef-321e 3220-3247
+3250-a48c a490-a4c6 a960-a97c ac00-d7a3 f900-faff fe10-fe19
+fe30-fe52 fe54-fe66 fe68-fe6b ff01-ff60 ffe0-ffe6 16fe0-16fe4
+16ff0-16ff1 17000-187f7 18800-18cd5 18cff-18d08 1aff0-1aff3 1aff5-1affb
+1affd-1affe 1b000-1b122 1b132-1b132 1b150-1b152 1b155-1b155 1b164-1b167
+1b170-1b2fb 1d300-1d356 1d360-1d376 1f004-1f004 1f0cf-1f0cf 1f18e-1f18e
+1f191-1f19a 1f200-1f202 1f210-1f23b 1f240-1f248 1f250-1f251 1f260-1f265
+1f300-1f320 1f32d-1f335 1f337-1f37c 1f37e-1f393 1f3a0-1f3ca 1f3cf-1f3d3
+1f3e0-1f3f0 1f3f4-1f3f4 1f3f8-1f43e 1f440-1f440 1f442-1f4fc 1f4ff-1f53d
+1f54b-1f54e 1f550-1f567 1f57a-1f57a 1f595-1f596 1f5a4-1f5a4 1f5fb-1f64f
+1f680-1f6c5 1f6cc-1f6cc 1f6d0-1f6d2 1f6d5-1f6d7 1f6dc-1f6df 1f6eb-1f6ec
+1f6f4-1f6fc 1f7e0-1f7eb 1f7f0-1f7f0 1f90c-1f93a 1f93c-1f945 1f947-1f9ff
+1fa70-1fa7c 1fa80-1fa89 1fa8f-1fac6 1face-1fadc 1fadf-1fae9 1faf0-1faf8
+20000-2fffd 30000-3fffd