@sc-voice/tools 1.1.0

package/src/text/ebt-doc.mjs

@@ -0,0 +1,124 @@
+import { SuttaCentralId } from './sutta-central-id.mjs';
+
+let privateCtor = false;
+
+const INHERITED_KEYS = [
+  'lang', 'author', 'author_uid', 'wordSpace'
+];
+
+const HDR_KEY = '__header__';
+
+export class EbtDoc {
+  constructor(opts) {
+    const msg = 'E4c.ctor:';
+    if (!privateCtor) {
+      throw new Error(`${msg} create()!`);
+    }
+    Object.defineProperty(this, '_scids', {
+      writable: true,
+      value: undefined,
+    });
+    Object.defineProperty(this, 'parent', {
+      writable: true,
+    });
+
+    Object.assign(this, opts);
+  }
+
+  static create(opts = {}) {
+    const msg = 'E4c.create:';
+    let { suid, bilaraPath, segMap = {}, parent = {} } = opts;
+    if (segMap == null) {
+      throw new Error(`${msg} segMap?`);
+    }
+    if (typeof segMap === 'string' || segMap instanceof Buffer) {
+      segMap = JSON.parse(segMap);
+    }
+    let args = INHERITED_KEYS.reduce(
+      (a, k) => {
+        a[k] = opts[k] || parent[k];
+        return a;
+      },
+      { bilaraPath, parent, segMap, suid },
+    );
+
+    privateCtor = true;
+    let ebtDoc = new EbtDoc(args);
+    privateCtor = false;
+
+    return ebtDoc;
+  }
+
+  static fromBilaraString(str, parent) {
+    const msg = 'E4c.fromBilaraString:';
+    let json = JSON.parse(str);
+    let { [HDR_KEY]: header } = json;
+    let { suid, bilaraPath } = header;
+    let scids = Object.keys(json).filter((k) => k !== HDR_KEY);
+    let segMap = scids.reduce((a, scid) => {
+      a[scid] = json[scid];
+      return a;
+    }, {});
+    let args = Object.keys(header).reduce(
+      (a, k) => {
+        a[k] = header[k];
+        return a;
+      },
+      { suid, bilaraPath, scids, segMap, parent },
+    );
+    return EbtDoc.create(args);
+  }
+
+  scids() {
+    let { _scids } = this;
+    if (_scids == null) {
+      _scids = Object.keys(this.segMap);
+      _scids.sort(SuttaCentralId.compareLow);
+      this._scids = _scids;
+    }
+
+    return _scids;
+  }
+
+  segments() {
+    return this.scids().map((scid) => ({
+      scid,
+      [this.lang]: this.segMap[scid] || '',
+    }));
+  }
+
+  toBilaraString() {
+    const msg = 'E4c.toBilaraString:';
+    let { segMap, parent } = this;
+    let scids = this.scids();
+    let keys = Object.keys(this);
+    let headerKeys = keys.filter((k) => {
+      switch (k) {
+        case 'segMap':
+          return false;
+        case 'parent':
+          return false;
+        default:
+          return true;
+      }
+    });
+
+    let header = headerKeys.reduce((a, k) => {
+      let v = this[k];
+      if (parent[k] !== v) {
+        a[k] = v;
+      }
+      return a;
+    }, {});
+
+    let json = scids.reduce(
+      (a, scid) => {
+        a[scid] = segMap[scid];
+        return a;
+      },
+      { [HDR_KEY]: header },
+    );
+
+    return JSON.stringify(json, null, 2);
+  }
+}

package/src/text/legacy-doc.mjs

@@ -0,0 +1,80 @@
+let privateCtor = false;
+
+const HTML_FILTER = (() => {
+  let prefixes = [
+    '<!DOCTYPE',
+    '<html',
+    '<head',
+    '</html',
+    '<meta',
+    '<title',
+    '</head',
+    '<body',
+    '</body',
+    '<article',
+    '</article',
+  ].join('|');
+  let pat = `^(${prefixes}).*> *$`;
+  return new RegExp(pat);
+})();
+
+export class LegacyDoc {
+  constructor(opts = {}) {
+    const msg = 'LegacyDoc.ctor:';
+    if (!privateCtor) {
+      throw new Error(`${msg} use LegacyDoc.create()`);
+    }
+    Object.assign(this, opts);
+  }
+
+  static filterHtml(line) {
+    if (HTML_FILTER.test(line)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  static create(rawDoc) {
+    const msg = 'LegacyDoc.create:';
+    if (typeof legacy === 'string') {
+      legacy = JSON.parse(legacy);
+    }
+
+    let { uid, lang, title, author, author_uid, text } = rawDoc;
+
+    let para;
+    let lines = text.filter((line) => !HTML_FILTER.test(line));
+    lines = lines
+      .join(' ')
+      .replace(/<\/p> */g, '')
+      .replace(/<h.*sutta-title.>(.*)<\/h1> /, '$1')
+      .split('<p>');
+    let footer = [];
+    lines.forEach((line, i) => {
+      if (/<footer>/.test(line)) {
+        let f = line.replace(/.*<footer>(.*)<.footer>.*/, '$1');
+        footer.push(f);
+        lines[i] = line.replace(/<footer>.*<.footer>/, '');
+      }
+      lines[i] = lines[i].trim();
+    });
+    footer = footer.join(' ');
+
+    let opts = {
+      uid,
+      lang,
+      title,
+      author,
+      author_uid,
+      footer,
+      lines,
+    };
+
+    privateCtor = true;
+    let ldoc = new LegacyDoc(opts);
+    privateCtor = false;
+
+    return ldoc;
+  }
+}

package/src/text/merkle-json.mjs

@@ -0,0 +1,264 @@
+// Supercedes NPM package merkle-json
+// BEGIN  http://www.myersdaily.org/joseph/javascript/md5.js
+function md5cycle(x, k) {
+  let a = x[0],
+    b = x[1],
+    c = x[2],
+    d = x[3];
+
+  a = ff(a, b, c, d, k[0], 7, -680876936);
+  d = ff(d, a, b, c, k[1], 12, -389564586);
+  c = ff(c, d, a, b, k[2], 17, 606105819);
+  b = ff(b, c, d, a, k[3], 22, -1044525330);
+  a = ff(a, b, c, d, k[4], 7, -176418897);
+  d = ff(d, a, b, c, k[5], 12, 1200080426);
+  c = ff(c, d, a, b, k[6], 17, -1473231341);
+  b = ff(b, c, d, a, k[7], 22, -45705983);
+  a = ff(a, b, c, d, k[8], 7, 1770035416);
+  d = ff(d, a, b, c, k[9], 12, -1958414417);
+  c = ff(c, d, a, b, k[10], 17, -42063);
+  b = ff(b, c, d, a, k[11], 22, -1990404162);
+  a = ff(a, b, c, d, k[12], 7, 1804603682);
+  d = ff(d, a, b, c, k[13], 12, -40341101);
+  c = ff(c, d, a, b, k[14], 17, -1502002290);
+  b = ff(b, c, d, a, k[15], 22, 1236535329);
+
+  a = gg(a, b, c, d, k[1], 5, -165796510);
+  d = gg(d, a, b, c, k[6], 9, -1069501632);
+  c = gg(c, d, a, b, k[11], 14, 643717713);
+  b = gg(b, c, d, a, k[0], 20, -373897302);
+  a = gg(a, b, c, d, k[5], 5, -701558691);
+  d = gg(d, a, b, c, k[10], 9, 38016083);
+  c = gg(c, d, a, b, k[15], 14, -660478335);
+  b = gg(b, c, d, a, k[4], 20, -405537848);
+  a = gg(a, b, c, d, k[9], 5, 568446438);
+  d = gg(d, a, b, c, k[14], 9, -1019803690);
+  c = gg(c, d, a, b, k[3], 14, -187363961);
+  b = gg(b, c, d, a, k[8], 20, 1163531501);
+  a = gg(a, b, c, d, k[13], 5, -1444681467);
+  d = gg(d, a, b, c, k[2], 9, -51403784);
+  c = gg(c, d, a, b, k[7], 14, 1735328473);
+  b = gg(b, c, d, a, k[12], 20, -1926607734);
+
+  a = hh(a, b, c, d, k[5], 4, -378558);
+  d = hh(d, a, b, c, k[8], 11, -2022574463);
+  c = hh(c, d, a, b, k[11], 16, 1839030562);
+  b = hh(b, c, d, a, k[14], 23, -35309556);
+  a = hh(a, b, c, d, k[1], 4, -1530992060);
+  d = hh(d, a, b, c, k[4], 11, 1272893353);
+  c = hh(c, d, a, b, k[7], 16, -155497632);
+  b = hh(b, c, d, a, k[10], 23, -1094730640);
+  a = hh(a, b, c, d, k[13], 4, 681279174);
+  d = hh(d, a, b, c, k[0], 11, -358537222);
+  c = hh(c, d, a, b, k[3], 16, -722521979);
+  b = hh(b, c, d, a, k[6], 23, 76029189);
+  a = hh(a, b, c, d, k[9], 4, -640364487);
+  d = hh(d, a, b, c, k[12], 11, -421815835);
+  c = hh(c, d, a, b, k[15], 16, 530742520);
+  b = hh(b, c, d, a, k[2], 23, -995338651);
+
+  a = ii(a, b, c, d, k[0], 6, -198630844);
+  d = ii(d, a, b, c, k[7], 10, 1126891415);
+  c = ii(c, d, a, b, k[14], 15, -1416354905);
+  b = ii(b, c, d, a, k[5], 21, -57434055);
+  a = ii(a, b, c, d, k[12], 6, 1700485571);
+  d = ii(d, a, b, c, k[3], 10, -1894986606);
+  c = ii(c, d, a, b, k[10], 15, -1051523);
+  b = ii(b, c, d, a, k[1], 21, -2054922799);
+  a = ii(a, b, c, d, k[8], 6, 1873313359);
+  d = ii(d, a, b, c, k[15], 10, -30611744);
+  c = ii(c, d, a, b, k[6], 15, -1560198380);
+  b = ii(b, c, d, a, k[13], 21, 1309151649);
+  a = ii(a, b, c, d, k[4], 6, -145523070);
+  d = ii(d, a, b, c, k[11], 10, -1120210379);
+  c = ii(c, d, a, b, k[2], 15, 718787259);
+  b = ii(b, c, d, a, k[9], 21, -343485551);
+
+  x[0] = add32(a, x[0]);
+  x[1] = add32(b, x[1]);
+  x[2] = add32(c, x[2]);
+  x[3] = add32(d, x[3]);
+}
+
+function cmn(q, a, b, x, s, t) {
+  a = add32(add32(a, q), add32(x, t));
+  return add32((a << s) | (a >>> (32 - s)), b);
+}
+
+function ff(a, b, c, d, x, s, t) {
+  return cmn((b & c) | (~b & d), a, b, x, s, t);
+}
+
+function gg(a, b, c, d, x, s, t) {
+  return cmn((b & d) | (c & ~d), a, b, x, s, t);
+}
+
+function hh(a, b, c, d, x, s, t) {
+  return cmn(b ^ c ^ d, a, b, x, s, t);
+}
+
+function ii(a, b, c, d, x, s, t) {
+  return cmn(c ^ (b | ~d), a, b, x, s, t);
+}
+
+function md51(s) {
+  //txt = '';
+  let n = s.length,
+    state = [1732584193, -271733879, -1732584194, 271733878],
+    i;
+  for (i = 64; i <= s.length; i += 64) {
+    md5cycle(state, md5blk(s.substring(i - 64, i)));
+  }
+  s = s.substring(i - 64);
+  let tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+  for (i = 0; i < s.length; i++)
+    tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
+  tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+  if (i > 55) {
+    md5cycle(state, tail);
+    for (i = 0; i < 16; i++) tail[i] = 0;
+  }
+  tail[14] = n * 8;
+  md5cycle(state, tail);
+  return state;
+}
+
+/* there needs to be support for Unicode here,
+ * unless we pretend that we can redefine the MD-5
+ * algorithm for multi-byte characters (perhaps
+ * by adding every four 16-bit characters and
+ * shortening the sum to 32 bits). Otherwise
+ * I suggest performing MD-5 as if every character
+ * was two bytes--e.g., 0040 0025 = @%--but then
+ * how will an ordinary MD-5 sum be matched?
+ * There is no way to standardize text to something
+ * like UTF-8 before transformation; speed cost is
+ * utterly prohibitive. The JavaScript standard
+ * itself needs to look at this: it should start
+ * providing access to strings as preformed UTF-8
+ * 8-bit unsigned value arrays.
+ **/
+function md5blk(s) {
+  /* I figured global was faster.   */
+  let md5blks = [],
+    i; /* Andy King said do it this way. */
+  for (i = 0; i < 64; i += 4) {
+    md5blks[i >> 2] =
+      s.charCodeAt(i) +
+      (s.charCodeAt(i + 1) << 8) +
+      (s.charCodeAt(i + 2) << 16) +
+      (s.charCodeAt(i + 3) << 24);
+  }
+  return md5blks;
+}
+
+const hex_chr = '0123456789abcdef'.split('');
+
+function rhex(n) {
+  let s = '',
+    j = 0;
+  for (; j < 4; j++)
+    s +=
+      hex_chr[(n >> (j * 8 + 4)) & 0x0f] +
+      hex_chr[(n >> (j * 8)) & 0x0f];
+  return s;
+}
+
+function hex(x) {
+  for (let i = 0; i < x.length; i++) x[i] = rhex(x[i]);
+  return x.join('');
+}
+
+function md5(s) {
+  return hex(md51(s));
+}
+
+/* this function is much faster,
+ * so if possible we use it. Some IEs
+ * are the only ones I know of that
+ * need the idiotic second function,
+ * generated by an if clause.  */
+
+function add32(a, b) {
+  return (a + b) & 0xffffffff;
+}
+
+if (md5('hello') != '5d41402abc4b2a76b9719d911017c592') {
+  function add32(x, y) {
+    let lsw = (x & 0xffff) + (y & 0xffff),
+      msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+    return (msw << 16) | (lsw & 0xffff);
+  }
+}
+// END  http://www.myersdaily.org/joseph/javascript/md5.js
+
+export class MerkleJson {
+  constructor(opts = {}) {
+    this.hashTag = opts.hashTag || 'merkleHash';
+  }
+
+  hash(value, cached = true) {
+    if (typeof value === 'string') {
+      return md5(value);
+    } else if (value instanceof Array) {
+      let acc = '';
+      acc = value.reduce((a, v) => a + this.hash(v, cached), acc);
+      return this.hash(acc, cached);
+    } else if (typeof value === 'number') {
+      value = value + '';
+      return this.hash(value);
+    } else if (value instanceof Date) {
+      return this.hash(value.toJSON());
+    } else if (value === false) {
+      return this.hash('false');
+    } else if (value === true) {
+      return this.hash('true');
+    } else if (value === null) {
+      return this.hash('null');
+    } else if (value === undefined) {
+      return this.hash('undefined');
+    } else if (typeof value === 'function') {
+      return this.hash(value.toString());
+    } else if (typeof value === 'object') {
+      if (cached && value[this.hashTag]) {
+        return value[this.hashTag];
+      }
+      let keys = Object.keys(value).sort();
+      let acc = keys.reduce((a, k) => {
+        return k === this.hashTag
+          ? a
+          : a + k + ':' + this.hash(value[k]) + ',';
+      }, '');
+      return this.hash(acc);
+    }
+    throw new Error('hash() not supported:' + typeof value);
+  }
+
+  stringify(value) {
+    if (value instanceof Array) {
+      let body = value.reduce((a, v) => {
+        return a
+          ? `${a},${this.stringify(v)}`
+          : `${this.stringify(v)}`;
+      }, '');
+      return `[${body}]`;
+    } else if (value instanceof Date) {
+      return `"${value.toJSON()}"`;
+    } else if (value === null) {
+      return JSON.stringify(value);
+    } else if (typeof value === 'object') {
+      if (typeof value.toJSON === 'function') {
+        value = JSON.parse(JSON.stringify(value));
+      }
+      let keys = Object.keys(value).sort();
+      let body = keys.reduce((a, k) => {
+        return a
+          ? `${a},"${k}":${this.stringify(value[k])}`
+          : `"${k}":${this.stringify(value[k])}`;
+      }, '');
+      return `{${body}}`;
+    }
+
+    return JSON.stringify(value);
+  }
+} // class MerkleJson