@sc-voice/tools 1.1.0

package/src/text/sutta-central-id.mjs

@@ -0,0 +1,362 @@
+import { DBG } from '../defines.mjs';
+import { BilaraPath } from './bilara-path.mjs';
+
+export class SuttaCentralId {
+  constructor(scid = null) {
+    if (scid == null) {
+      throw new Error(`required scid:${scid}`);
+    }
+    this.scid = scid;
+  }
+
+  static basename(fp) {
+    return fp.split('/').pop();
+  }
+
+  static match(scid, pat) {
+    const msg = 'SuttaCentralId.match() ';
+    let id = pat.indexOf(':') >= 0 ? scid : scid.split(':')[0];
+    let pats = pat.split(/, */);
+    if (pats.length > 1) {
+      return pats.reduce(
+        (a, p) => a || SuttaCentralId.match(scid, p),
+        false,
+      );
+    }
+    let scidPat = pat
+      .replace(/\/[^:]*/, '') // remove language and  translator
+      .replace(/ */g, ''); // "thig 1.1" => "thig1.1"
+    let scidLow = SuttaCentralId.rangeLow(id);
+    let scidHigh = SuttaCentralId.rangeHigh(id);
+    let matchLow = SuttaCentralId.rangeLow(scidPat);
+    let matchHigh = SuttaCentralId.rangeHigh(scidPat);
+    let cmpL = SuttaCentralId.compareLow(scidHigh, matchLow);
+    let cmpH = SuttaCentralId.compareHigh(scidLow, matchHigh);
+    let match = 0 <= cmpL && cmpH <= 0;
+    //console.log(msg, {scidLow, scidHigh, matchLow, matchHigh, cmpL, cmpH, match});
+    return match;
+  }
+
+  static rangeHigh(scid) {
+    let slashParts = scid.split('/');
+    let scidMain = slashParts.shift();
+    let suffix = slashParts.join('/');
+    let extRanges = scidMain.split('--');
+    if (extRanges.length > 2) {
+      throw new Error(`Invalid SuttaCentral reference:${scid}`);
+    }
+    let [c0, c1] = extRanges.map((er) => er.split(':'));
+    let result = extRanges.pop();
+    if (c1 && c0.length > 1 && c1.length < 2) {
+      result = `${c0[0]}:${result}`;
+    }
+    result =
+      c0.length > 1
+        ? result.replace(/[0-9]+-/g, '') + '.9999'
+        : result.replace(/[0-9]+-/g, '');
+    return suffix ? `${result}/${suffix}` : result;
+  }
+
+  static rangeLow(scid) {
+    let slashParts = scid.split('/');
+    let scidMain = slashParts.shift();
+    let suffix = slashParts.join('/');
+    let result = scidMain.split('--')[0];
+    result = result.replace(/-[0-9]+/g, '');
+    return suffix ? `${result}/${suffix}` : result;
+  }
+
+  static test(text) {
+    if (typeof text !== 'string') {
+      throw new Error(`Expected string:${text}`);
+    }
+    let commaParts = text
+      .toLowerCase()
+      .split(',')
+      .map((p) => p.trim());
+    return commaParts.reduce((acc, part) => {
+      part = part.replace(/\. */gu, '.');
+      return acc && /^[-a-z]+ ?[0-9]+[-0-9a-z.:\/]*$/i.test(part);
+    }, true);
+  }
+
+  static languages(text) {
+    if (!SuttaCentralId.test(text)) {
+      return [];
+    }
+    let commaParts = text
+      .toLowerCase()
+      .split(',')
+      .map((p) => p.trim());
+    return commaParts.reduce((a, c) => {
+      let cparts = c.split('/');
+      let lang = cparts[1];
+      if (lang && a.indexOf(lang) < 0) {
+        a.push(lang);
+      }
+      return a;
+    }, []);
+  }
+
+  static scidRegExp(pat) {
+    if (!pat) {
+      return /.*/;
+    }
+
+    pat = pat.replace(/\./g, '\\.');
+    pat = pat.replace(/\*/g, '.*');
+    pat = pat.replace(/\?/g, '.');
+    pat = pat.replace(/[$^]/g, '\\$&');
+    return new RegExp(pat);
+  }
+
+  static partNumber(part, id) {
+    const msg = 'SuttaCentralId.partNumber() ';
+    let n = Number(part);
+    let n0;
+    let n1;
+    if (Number.isNaN(n)) {
+      let caretParts = part.split('^');
+      let [c0, c1] = caretParts;
+      if (c1 == null) {
+        let c0dig = c0.replace(/[a-z]*/giu, '');
+        let c0let = c0.replace(/[0-9]*/gu, '').toLowerCase();
+        n0 = Number(c0dig);
+        n1 = c0let.charCodeAt(0) - 'a'.charCodeAt(0) + 1;
+        if (Number.isNaN(n0) || Number.isNaN(n1)) {
+          throw new Error(
+            `partNumber() cannot parse ${part} in ${id}`,
+          );
+        }
+      } else {
+        n0 = Number(c0);
+        n1 = c1.charCodeAt(0) - 'z'.charCodeAt(0) - 1;
+      }
+
+      return [n0, n1];
+    } else {
+      return [n];
+    }
+  }
+
+  static scidNumbersLow(id_or_path) {
+    let scid = BilaraPath.pathParts(id_or_path).suid;
+    let colonParts = scid.replace(/^[-a-z]*/, '').split(':');
+    let dotParts = colonParts.reduce(
+      (a, c) => a.concat(c.split('.')),
+      [],
+    );
+    let nums = dotParts.reduce((a, n) => {
+      let lowPart = n.split('-')[0];
+      return a.concat(SuttaCentralId.partNumber(lowPart, id_or_path));
+    }, []);
+    return nums;
+  }
+
+  static scidNumbersHigh(id_or_path) {
+    let scid = BilaraPath.pathParts(id_or_path).suid;
+    let colonParts = scid.replace(/^[-a-z]*/, '').split(':');
+    let dotParts = colonParts.reduce(
+      (a, c) => a.concat(c.split('.')),
+      [],
+    );
+    let nums = dotParts.reduce((a, n) => {
+      let highPart = n.split('-').pop();
+      return a.concat(
+        SuttaCentralId.partNumber(highPart, id_or_path),
+      );
+    }, []);
+    return nums;
+  }
+
+  static compareHigh(a, b) {
+    const msg = 'SuttaCentralId.compareHigh()';
+    const dbg = DBG.COMPARE;
+    let abase = SuttaCentralId.basename(a);
+    let bbase = SuttaCentralId.basename(b);
+    let aprefix = abase.substring(0, abase.search(/[0-9]/)) || a;
+    let bprefix = bbase.substring(0, bbase.search(/[0-9]/)) || b;
+    let cmp = aprefix.localeCompare(bprefix);
+    dbg &&
+      console.log(msg, '[1]cmp prefix', {
+        cmp,
+        abase,
+        bbase,
+        aprefix,
+        bprefix,
+      });
+    if (cmp === 0) {
+      let adig = SuttaCentralId.scidNumbersHigh(a);
+      let bdig = SuttaCentralId.scidNumbersHigh(b);
+      let n = Math.max(adig.length, bdig.length);
+      for (let i = 0; i < n; i++) {
+        let ai = adig[i];
+        let bi = bdig[i];
+        if (ai === bi) {
+          continue;
+        }
+        if (ai === undefined) {
+          return -bi || -1;
+        }
+        if (bi === undefined) {
+          return ai || 1;
+        }
+        return ai - bi;
+      }
+    }
+    return cmp;
+  }
+
+  static compareLow(a, b) {
+    const msg = 'SuttaCentralId.compareLow()';
+    const dbg = DBG.COMPARE;
+    let abase = SuttaCentralId.basename(a);
+    let bbase = SuttaCentralId.basename(b);
+    let adigit = abase.search(/[0-9]/);
+    let bdigit = bbase.search(/[0-9]/);
+    let aprefix = adigit < 0 ? abase : abase.substring(0, adigit);
+    let bprefix = bdigit < 0 ? bbase : bbase.substring(0, bdigit);
+    let cmp = aprefix.localeCompare(bprefix);
+    dbg &&
+      console.log(msg, '[1]cmp prefix', {
+        cmp,
+        abase,
+        bbase,
+        aprefix,
+        bprefix,
+      });
+    if (cmp === 0) {
+      let adig = SuttaCentralId.scidNumbersLow(abase);
+      let bdig = SuttaCentralId.scidNumbersLow(bbase);
+      let n = Math.max(adig.length, bdig.length);
+      for (let i = 0; i < n; i++) {
+        let ai = adig[i];
+        let bi = bdig[i];
+        if (ai === bi) {
+          continue;
+        }
+        if (ai === undefined) {
+          return -bi || -1;
+        }
+        if (bi === undefined) {
+          return ai || 1;
+        }
+        return ai - bi;
+      }
+    }
+    return cmp;
+  }
+
+  get groups() {
+    let tokens = this.scid?.split(':');
+    return tokens?.[1] ? tokens[1].split('.') : null;
+  }
+
+  get nikaya() {
+    return this.sutta.replace(/[-0-9.]*$/, '');
+  }
+
+  get nikayaFolder() {
+    // DEPRECATED
+    let majorid = this.sutta.split('.')[0];
+    let prefix = majorid.replace(/[0-9-.:]*$/, '');
+    let folder =
+      {
+        bv: `kn/bv`,
+        cnd: `kn/cnd`,
+        cp: `kn/cp`,
+        iti: `kn/iti`,
+        ja: `kn/ja`,
+        kp: `kn/kp`,
+        mil: `kn/mil`,
+        mnd: `kn/mnd`,
+        ne: `kn/ne`,
+        pe: `kn/pe`,
+        ps: `kn/ps`,
+        pv: `kn/pv`,
+        snp: `kn/snp`,
+        'tha-ap': `kn/tha-ap`,
+        thag: `kn/thag`,
+        'thi-ap': `kn/thi-ap`,
+        thig: `kn/thig`,
+        ud: `kn/ud`,
+        vv: `kn/vv`,
+        'pli-tv-bi-vb-sk': `pli-tv-bi-vb/pli-tv-bi-vb-sk`,
+      }[prefix] ||
+      (majorid === this.sutta ? prefix : `${prefix}/${majorid}`);
+    return folder;
+  }
+
+  get sutta() {
+    return this.scid?.split(':')[0];
+  }
+
+  get parent() {
+    let groups = this.groups;
+    if (groups == null) {
+      return null;
+    }
+    !groups.pop() && groups.pop();
+    if (groups.length === 0) {
+      return new SuttaCentralId(`${this.sutta}:`);
+    }
+    return new SuttaCentralId(`${this.sutta}:${groups.join('.')}.`);
+  }
+
+  standardForm() {
+    let std = {
+      sn: 'SN',
+      mn: 'MN',
+      dn: 'DN',
+      an: 'AN',
+      thig: 'Thig',
+      thag: 'Thag',
+    };
+    let result = this.scid;
+    let keys = Object.keys(std);
+    for (let i = 0; i < keys.length; i++) {
+      let k = keys[i];
+      result = result.replace(k, std[k]);
+    }
+    return result;
+  }
+
+  sectionParts() {
+    return this.scid.split(':')[0].split('.');
+  }
+
+  segmentParts() {
+    let segid = this.scid.split(':')[1];
+    return segid.split('.');
+  }
+
+  add(...args) {
+    let prefix = this.nikaya;
+    let id = this.scid.substring(prefix.length);
+    let id2;
+    let colonParts = id.split(':');
+    if (colonParts.length > 1) {
+      // segment id
+      let dotParts = colonParts[1].split('.');
+      for (let i = 0; i < dotParts.length; i++) {
+        let a = Number(args[i]);
+        dotParts[i] = i < args.length ? Number(dotParts[i]) + a : 0;
+      }
+      id2 = `${colonParts[0]}:${dotParts.join('.')}`;
+    } else {
+      // document id
+      let dotParts = colonParts[0].split('.');
+      let n = Math.min(args.length, dotParts.length);
+      for (let i = 0; i < n; i++) {
+        let a = Number(args[i]);
+        dotParts[i] = Number(dotParts[i]) + a;
+      }
+      id2 = `${dotParts.join('.')}`;
+    }
+    return new SuttaCentralId(`${prefix}${id2}`);
+  }
+
+  toString() {
+    return this.scid;
+  }
+} // class SuttaCentralId

package/src/text/unicode.mjs

@@ -0,0 +1,370 @@
+let SYMBOLS = {
+  0: {
+    name: 'digit',
+  },
+  1: {
+    name: 'digit',
+  },
+  2: {
+    name: 'digit',
+  },
+  3: {
+    name: 'digit',
+  },
+  4: {
+    name: 'digit',
+  },
+  5: {
+    name: 'digit',
+  },
+  6: {
+    name: 'digit',
+  },
+  7: {
+    name: 'digit',
+  },
+  8: {
+    name: 'digit',
+  },
+  9: {
+    name: 'digit',
+  },
+  '\n': {
+    name: 'end of line',
+    eol: true,
+  },
+  '!': {
+    name: 'exclamation mark',
+    isWordTrim: true,
+    cuddle: 'left',
+    endSegment: true,
+  },
+  '"': {
+    name: 'quotation mark',
+  },
+  '#': {
+    name: 'number sign',
+  },
+  $: {
+    name: 'dollar sign',
+  },
+  '%': {
+    name: 'percent',
+  },
+  '&': {
+    name: 'ampersand',
+  },
+  "'": {
+    name: 'apostrophe',
+    isWordTrim: true,
+    isWord: false,
+  },
+  '(': {
+    name: 'left parenthesis',
+    cuddle: 'right',
+  },
+  ')': {
+    name: 'right parenthesis',
+    cuddle: 'left',
+  },
+  '*': {
+    name: 'asterisk',
+  },
+  '+': {
+    name: 'plus sign',
+  },
+  ',': {
+    name: 'comma',
+    isWordTrim: true,
+    cuddle: 'left',
+  },
+  '-': {
+    name: 'hyphen minus',
+    isWord: true,
+  },
+  '{': {
+    name: 'left brace',
+  },
+  '}': {
+    name: 'right brace',
+  },
+  '.': {
+    name: 'full stop',
+    isWordTrim: true,
+    endSegment: true,
+    cuddle: 'left',
+  },
+  '/': {
+    name: 'solidus',
+  },
+
+  ':': {
+    name: 'colon',
+  },
+  ';': {
+    isWordTrim: true,
+    name: 'semicolon',
+  },
+  '<': {
+    name: 'less-than sign',
+  },
+  '=': {
+    name: 'equals sign',
+  },
+  '>': {
+    name: 'greater-than sign',
+  },
+  '?': {
+    name: 'question mark',
+    isWordTrim: true,
+    endSegment: true,
+    cuddle: 'left',
+  },
+  '@': {
+    name: 'commercial at',
+  },
+
+  '[': {
+    name: 'left square bracket',
+    cuddle: 'right',
+  },
+  ']': {
+    name: 'right square bracket',
+  },
+
+  '\u2014': {
+    name: 'em dash',
+    cuddle: 'both',
+  },
+  '\u2018': {
+    name: 'left single quote',
+    cuddle: 'right',
+  },
+  '\u2019': {
+    name: 'right single quote',
+    isWordTrim: true,
+    cuddle: 'left',
+    isWord: true,
+  },
+  '\u02bc': {
+    name: 'apostrophe',
+    cuddle: 'left',
+    isWord: true,
+  },
+  '\u201C': {
+    name: 'left double quote',
+    cuddle: 'right',
+  },
+  '\u201D': {
+    name: 'right double quote',
+    cuddle: 'left',
+  },
+  '\u2026': {
+    name: 'ellipsis',
+    ellipsisBreak: true,
+    cuddle: 'left',
+  },
+};
+
+let ROMANIZE_MAP = {
+  '\u0101': 'a',
+  '\u1e0d': 'd',
+  '\u1e25': 'h',
+  '\u012b': 'i',
+  '\u1e37': 'l',
+  '\u1e39': 'l',
+  '\u1e41': 'm',
+  '\u1e43': 'm',
+  '\u1e47': 'n',
+  '\u1e45': 'n',
+  '\u00f1': 'n',
+  '\u1e5b': 'r',
+  '\u1e5d': 'r',
+  '\u1e63': 's',
+  '\u015b': 's',
+  '\u1e6d': 't',
+  '\u016b': 'u',
+};
+
+export class Unicode {
+  static get LSQUOTE() {
+    return '\u2018';
+  }
+  static get RSQUOTE() {
+    return '\u2019';
+  }
+  static get LDQUOTE() {
+    return '\u201C';
+  }
+  static get RDQUOTE() {
+    return '\u201D';
+  }
+  static get HYPHEN() {
+    return '\u2010';
+  }
+  static get APOSTROPHE() {
+    return '\u02BC';
+  }
+  static get ENDASH() {
+    return '\u2013';
+  }
+  static get EMDASH() {
+    return '\u2014';
+  }
+  static get ELLIPSIS() {
+    return '\u2026';
+  }
+  static get A_MACRON() {
+    return '\u0100';
+  }
+  static get a_MACRON() {
+    return '\u0101';
+  }
+  static get u_MACRON() {
+    return '\u016d'; /* UTF-8 c5ab */
+  }
+  static get LEFT_ARROW() {
+    return '\u2190';
+  }
+  static get RIGHT_ARROW() {
+    return '\u2192';
+  }
+  static get LEFT_RIGHT_ARROW() {
+    return '\u2194';
+  }
+  static get CHECKMARK() {
+    return '\u2713';
+  }
+  static get WARNING() {
+    return '\u26A0';
+  }
+  static get RED_X() {
+    return '\u274c';
+  }
+  static get GREEN_CHECKBOX() {
+    return '\u2705';
+  }
+  static get LEFT_GUILLEMET() {
+    return '\u00ab';
+  }
+  static get RIGHT_GUILLEMET() {
+    return '\u00bb';
+  }
+
+  static get LINUX_COLOR() {
+    return {
+      BLACK: '\u001b[30m',
+      RED: '\u001b[31m',
+      GREEN: '\u001b[32m',
+      YELLOW: '\u001b[33m',
+      BLUE: '\u001b[34m',
+      MAGENTA: '\u001b[35m',
+      CYAN: '\u001b[36m',
+      WHITE: '\u001b[37m',
+      NO_COLOR: '\u001b[0m',
+    };
+  }
+
+  constructor(opts = {}) {
+    if (opts.romanizeMap == null) {
+      Object.defineProperty(this, 'romanizeMap', {
+        value: Unicode.ROMANIZE_MAP,
+      });
+    } else {
+      this.romanizeMap = opts.romanizeMap;
+    }
+    if (opts.symbols == null) {
+      Object.defineProperty(this, 'symbols', {
+        value: Unicode.SYMBOLS,
+      });
+    } else {
+      this.symbols = opts.symbols; // enumerable
+    }
+    let syms = Object.keys(this.symbols)
+      .sort((a, b) => {
+        if (a === b) {
+          return 0;
+        }
+        if (a === '-') {
+          return -1;
+        }
+        if (b === '-') {
+          return 1;
+        }
+        return a.localeCompare(b);
+      })
+      .join('')
+      .replace(']', '\\]');
+    Object.defineProperty(this, 'reSymbols', {
+      value: new RegExp(`[${syms}]`, 'ugm'),
+    });
+  }
+
+  static get ROMANIZE_MAP() {
+    return ROMANIZE_MAP;
+  }
+
+  static get SYMBOLS() {
+    return SYMBOLS;
+  }
+
+  get LSQUOTE() {
+    return Unicode.LSQUOTE;
+  }
+  get RSQUOTE() {
+    return Unicode.RSQUOTE;
+  }
+  get LDQUOTE() {
+    return Unicode.LDQUOTE;
+  }
+  get RDQUOTE() {
+    return Unicode.RDQUOTE;
+  }
+  get HYPHEN() {
+    return Unicode.HYPHEN;
+  }
+  get APOSTROPHE() {
+    return Unicode.APOSTROPHE;
+  }
+  get ENDASH() {
+    return Unicode.ENDASH;
+  }
+  get EMDASH() {
+    return Unicode.EMDASH;
+  }
+  get ELLIPSIS() {
+    return Unicode.ELLIPSIS;
+  }
+  get A_MACRON() {
+    return Unicode.A_MACRON;
+  }
+  get a_MACRON() {
+    return Unicode.a_MACRON;
+  }
+  get u_MACRON() {
+    return Unicode.u_MACRON;
+  }
+
+  stripSymbols(text) {
+    return text.replace(this.reSymbols, '');
+  }
+
+  romanize(text) {
+    if (this.romanizePats == null) {
+      let srcChars = Object.keys(this.romanizeMap);
+      Object.defineProperty(this, 'romanizePats', {
+        value: srcChars.map((c) => {
+          return {
+            rep: this.romanizeMap[c],
+            pat: new RegExp(c, 'gui'),
+          };
+        }),
+      });
+    }
+    let result = text.toLowerCase();
+    this.romanizePats.forEach((pat, i) => {
+      result = result.replace(pat.pat, pat.rep);
+    });
+    return result;
+  }
+}