@sc-voice/tools 3.33.0 → 3.35.0

package/index.mjs

@@ -1,16 +1,20 @@
 import { Assert } from './src/js/assert.mjs';
-export const JS = {
-  Assert,
+import UUIDV7 from './src/js/uuidv7.mjs';
+export const JS = { Assert, UUIDV7,
 }
 
 import { Activation } from './src/math/activation.mjs';
 import { Fraction } from './src/math/fraction.mjs';
+import { Units } from './src/math/units.mjs';
 import { Interval } from './src/math/interval.mjs';
+import { Hadamard } from './src/math/hadamard.mjs';
 
 export const ScvMath = {
   Activation,
   Fraction,
-  Interval,
+  Hadamard,
+  Interval, 
+  Units,
 };
 
 import { BilaraPath } from './src/text/bilara-path.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sc-voice/tools",
-  "version": "3.33.0",
+  "version": "3.35.0",
   "description": "Utilities for SC-Voice",
   "main": "index.mjs",
   "files": [
@@ -11,29 +11,33 @@
     "src"
   ],
   "scripts": {
-    "test": "mocha --inline-diffs --recursive",
-    "test:test": "mocha --config test/mocha-config.json --recursive"
+    "test": "vitest run --config test/vitest.config.mjs",
+    "test:test": "vitest --config test/vitest.config.mjs"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/sc-voice/tools.git"
+    "url": "git+https://github.com/sc-voice/nx-scv.git"
   },
   "keywords": [
-    "SC-Voice tools",
-    "merkle-json",
+    "SC-Voice",
+    "nx-scv",
+    "Tools",
     "Javascript"
   ],
   "author": "Karl Lew",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/sc-voice/tools/issues"
+    "url": "https://github.com/sc-voice/nx-scv/issues"
   },
-  "homepage": "https://github.com/sc-voice/tools#readme",
+  "homepage": "https://github.com/sc-voice/nx-scv/pkg/tools/#readme",
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
+    "avro-js": "^1.12.0",
     "deepl-node": "^1.15.0",
     "eslint": "^9.17.0",
-    "mocha": "^11.0.1",
-    "should": "^13.2.3"
+    "@sc-voice/vitest": "^4.0.0"
+  },
+  "dependencies": {
+    "uuid": "^11.1.0"
   }
 }

package/src/defines.mjs

@@ -1,20 +1,49 @@
+const COLOR_CONSOLE = {
+  AS_STRING: 0,
+  INSPECT: 0,
+  SRC: 0,
+  TEST: 0,
+  PROPS_NEXT: 0,
+};
+
+const FRACTION = {
+  REDUCE: 0,
+  TEST: 0,
+};
+
 export const DBG = {
+  COLOR_CONSOLE,
+  FRACTION,
+
   ALIGN_ALL: 0,
   ALIGN_LINE: 0,
-  L2T_TO_STRING: 0,
-  COLOR_CONSOLE: 0,
-  C10E_INSPECT: 0,
-  I6L_CONTAINS: 0,
-  I6L_OVERLAPS: 0,
-  ML_DOC_VECTORS: 0, // 'mn8:3.4',
-  MN8_MOHAN: 0,
   DEEPL_ADAPTER: 0,
   DEEPL_MOCK: 0, // use mock-deepl
   DEEPL_MOCK_XLT: 0, // use mock translation
   DEEPL_TEST_API: 0, // test with live DeepL API ($$$)
   DEEPL_XLT: 0, // test live translation
+  I6L_CONTAINS: 0,
+  I6L_OVERLAPS: 0,
+  L2T_TO_STRING: 0,
   L7C_FETCH_LEGACY: 0,
   L7C_FETCH_LEGACY_SC: 0, // ignore test cache and use SC
+  ML_DOC_VECTORS: 0, // 'mn8:3.4'
+  MN8_MOHAN: 0,
+  M2H: {
+    H6D: {
+      FWHT: 0,
+      ENCODE: 0,
+      DECODE: 0,
+    },
+  },
   W7E_BOW_OF_TEXT: 0,
   WORD_MAP_TRANFORMER: 0,
+  S5H: {
+    U3S: {
+      CONVERT_FRACTION: 0,
+    },
+  },
+  T2T: {
+    HADAMARD: 0,
+  },
 };

package/src/js/uuidv7.mjs

@@ -0,0 +1,171 @@
+import { randomBytes } from 'crypto';
+
+// ============================================================================
+// MonotonicityState - Ensures successive UUIDs are always strictly increasing
+// ============================================================================
+
+class MonotonicityState {
+  constructor() {
+    this.previousTimestamp = 0n;
+    this.sequence = 0;
+    this.offset = 0n;
+  }
+
+  nextMillisWithSequence(timeIntervalMs) {
+    // Convert to BigInt if needed
+    const currentTime = BigInt(Math.floor(timeIntervalMs));
+    let currentMillis = currentTime + this.offset;
+
+    if (this.previousTimestamp === currentMillis) {
+      // Same millisecond: increment sequence counter
+      this.sequence += 1; // Don't mask yet - check for overflow
+    } else if (currentMillis < this.previousTimestamp) {
+      // Clock went backward: increment sequence and adjust offset
+      this.sequence += 1;
+      this.offset = this.previousTimestamp - currentMillis;
+      currentMillis = this.previousTimestamp;
+    } else {
+      // Time advanced: reset sequence
+      this.offset = 0n;
+      this.sequence = 0;
+    }
+
+    // If sequence overflows 12 bits, increment time and reset sequence
+    if (this.sequence > 0xFFF) {
+      this.sequence = 0;
+      currentMillis += 1n;
+    }
+
+    // Now apply 12-bit mask for the returned value
+    const maskedSequence = this.sequence & 0xFFF;
+
+    this.previousTimestamp = currentMillis;
+    return { millis: currentMillis, sequence: maskedSequence };
+  }
+}
+
+// Global monotonicity state (thread-safe via single JS event loop)
+const monotonicityState = new MonotonicityState();
+
+// ============================================================================
+// UUIDV7 Class
+// ============================================================================
+
+class UUIDV7 {
+  /**
+   * Creates a monotonically increasing UUIDV7.
+   * Two successive calls will always produce different, strictly increasing UUIDs.
+   *
+   * @returns {string} UUID in format: 019cc8b2-e91e-7000-8669-15ac4a704757
+   */
+  static create() {
+    const now = Date.now(); // milliseconds since epoch
+    const { millis, sequence } = monotonicityState.nextMillisWithSequence(now);
+
+    // Generate random bytes for the UUID
+    const randomBuf = randomBytes(16); // Get 16 random bytes
+
+    // Build UUID bytes (16 bytes total)
+    const uuid = Buffer.alloc(16);
+
+    // Bytes 0-5: timestamp in milliseconds (48 bits)
+    // Convert BigInt to bytes in big-endian
+    const millisBigInt = millis;
+    uuid[0] = Number((millisBigInt >> 40n) & 0xFFn);
+    uuid[1] = Number((millisBigInt >> 32n) & 0xFFn);
+    uuid[2] = Number((millisBigInt >> 24n) & 0xFFn);
+    uuid[3] = Number((millisBigInt >> 16n) & 0xFFn);
+    uuid[4] = Number((millisBigInt >> 8n) & 0xFFn);
+    uuid[5] = Number(millisBigInt & 0xFFn);
+
+    // Bytes 6-8: 12-bit sequence counter + version + variant
+    // Place 12-bit sequence as UInt16 big-endian in bytes 6-7, then apply version/variant masks
+    // Sequence is 12 bits: bit11-bit0, represented as 0x0000-0x0FFF
+    // When converted to big-endian bytes:
+    //   bytes[6] = (sequence >> 8) & 0xFF  (contains bits 11-8 in lower nibble, upper bits are 0)
+    //   bytes[7] = sequence & 0xFF         (contains bits 7-0)
+    uuid[6] = ((sequence >> 8) & 0x0F) | 0x70; // Upper 4 bits of sequence + version 0x7
+    uuid[7] = sequence & 0xFF; // Lower 8 bits of sequence
+
+    // Bytes 9-15: random data
+    randomBuf.copy(uuid, 9, 0, 7); // Copy 7 bytes from randomBuf[0:7] to uuid[9:16]
+
+    // Byte 8: variant (2 bits) + remaining random bits
+    uuid[8] = (randomBuf[7] & 0x3F) | 0x80; // Keep lower 6 bits of random + variant 0b10
+
+    return bytesToUuidString(uuid);
+  }
+
+  /**
+   * Compare two UUIDs lexicographically.
+   * Returns: -1 if a < b, 0 if a === b, 1 if a > b
+   *
+   * @param {string} a - UUID
+   * @param {string} b - UUID
+   * @returns {number} -1, 0, or 1
+   */
+  static compare(a, b) {
+    const aBytes = typeof a === 'string' ? uuidStringToBytes(a) : a;
+    const bBytes = typeof b === 'string' ? uuidStringToBytes(b) : b;
+
+    for (let i = 0; i < 16; i++) {
+      if (aBytes[i] < bBytes[i]) return -1;
+      if (aBytes[i] > bBytes[i]) return 1;
+    }
+    return 0;
+  }
+
+  /**
+   * Check if UUID a < UUID b
+   *
+   * @param {string} a - UUID
+   * @param {string} b - UUID
+   * @returns {boolean}
+   */
+  static isLessThan(a, b) {
+    return UUIDV7.compare(a, b) < 0;
+  }
+
+  /**
+   * Check if UUID a > UUID b
+   *
+   * @param {string} a - UUID
+   * @param {string} b - UUID
+   * @returns {boolean}
+   */
+  static isGreaterThan(a, b) {
+    return UUIDV7.compare(a, b) > 0;
+  }
+}
+
+export default UUIDV7;
+
+// ============================================================================
+// UUID String Formatting
+// ============================================================================
+
+/**
+ * Convert UUID bytes to standard string format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+ */
+function bytesToUuidString(bytes) {
+  const hex = bytes.toString('hex');
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20),
+  ].join('-');
+}
+
+/**
+ * Convert UUID string to bytes.
+ *
+ * @param {string} uuidString - UUID in format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+ * @returns {Buffer} 16 bytes
+ */
+function uuidStringToBytes(uuidString) {
+  const hex = uuidString.replace(/-/g, '');
+  return Buffer.from(hex, 'hex');
+}
+

package/src/math/activation.mjs

@@ -59,8 +59,7 @@ export class Activation {
   }
 
   static createRareN(a = 100, b = 1) {
-    let fEval = (x, a) =>
-      x < 1 ? 1 : 1 - Math.exp(((x - a) / x) * b);
+    let fEval = (x, a) => (x < 1 ? 1 : 1 - Math.exp(((x - a) / x) * b));
     let dEval = (x, a) =>
       x < 1 ? 0 : -(a * b * fEval(x, a, b)) / (x * x);
     return new Activation({ a, b, fEval, dEval });

package/src/math/fraction.mjs

@@ -1,17 +1,41 @@
+import { DBG } from '../defines.mjs';
+import { ColorConsole } from '../text/color-console.mjs';
+import { Unicode } from '../text/unicode.mjs';
+const { CHECKMARK: UOK } = Unicode;
+const { FRACTION: F6N } = DBG;
+const { cc } = ColorConsole;
+
 export class Fraction {
+  #isNull;
   constructor(...args) {
-    //constructor(numerator, denominator = 1, units = undefined) {
     const msg = 'Fraction.ctor:';
-    if (args[0] instanceof Fraction) {
-      let { numerator: n, denominator: d, units: u } = args[0];
-      args = [n, d, u];
+    let cfg = args[0];
+    let numerator;
+    let denominator;
+    let units;
+    let isNull;
+
+    if (cfg && typeof cfg === 'object') {
+      let { isNull: i4l, numerator: n, denominator: d, units: u } = cfg;
+      isNull = i4l;
+      numerator = n;
+      denominator = d;
+      units = u;
+    } else {
+      let [n, d = 1, u = ''] = args;
+      isNull = false;
+      numerator = n;
+      denominator = d;
+      units = u;
     }
-    let [numerator, denominator = 1, units = undefined] = args;
 
-    Object.assign(this, {
-      numerator,
-      denominator,
-      units,
+    this.put({ isNull, numerator, denominator, units });
+
+    Object.defineProperty(this, 'isNull', {
+      enumerable: true,
+      get() {
+        return this.#isNull;
+      },
     });
   }
 
@@ -22,6 +46,29 @@ export class Fraction {
     return Fraction.gcd(b, a % b);
   }
 
+  put(json = {}) {
+    let { isNull, numerator, denominator = 1, units = '' } = json;
+
+    if (isNull || numerator == null) {
+      this.#isNull = true;
+      numerator = 0;
+      denominator = 1;
+    } else {
+      this.#isNull = false;
+    }
+    Object.assign(this, { numerator, denominator, units });
+  }
+
+  patch(json = {}) {
+    let {
+      numerator = this.n,
+      denominator = this.d,
+      units = this.units,
+    } = json;
+
+    this.put({ numerator, denominator, units });
+  }
+
   get remainder() {
     let { n, d } = this;
 
@@ -54,8 +101,8 @@ export class Fraction {
   }
 
   get value() {
-    let { numerator, denominator } = this;
-    return numerator / denominator;
+    let { isNull, numerator, denominator } = this;
+    return isNull ? null : numerator / denominator;
   }
 
   increment(delta = 1) {
@@ -64,6 +111,8 @@ export class Fraction {
   }
 
   reduce() {
+    const msg = 'f6n.reduce';
+    const dbg = F6N.REDUCE;
     let { numerator: n, denominator: d, units } = this;
     if (Number.isInteger(n) && Number.isInteger(d)) {
       let g = Fraction.gcd(n, d);
@@ -71,22 +120,46 @@ export class Fraction {
         this.numerator /= g;
         this.denominator /= g;
       }
+      dbg && cc.ok1(msg + UOK, this.n, '/', this.d);
+    } else {
+      // Is this useful?
+      for (let i = 0; i < 20; i++) {
+        n *= 10;
+        d *= 10;
+        if (Number.isInteger(n) && Number.isInteger(d)) {
+          this.n = n;
+          this.d = d;
+          this.reduce();
+          dbg && cc.ok1(msg + UOK, n, '/', d);
+          return this;
+        }
+      }
+      throw new Error(
+        `${msg} Why are you reducing non-integers? ${n}/${d}`,
+      );
     }
     return this;
   }
 
-  toString() {
-    let { units, numerator: n, denominator: d, value } = this;
-    if (n == null || d == null) {
-      return `${n}/${d}`;
-    }
-    if (d < 0) {
-      d = -d;
-      n = -n;
+  toString(cfg = {}) {
+    let { isNull, units, numerator: n, denominator: d, value } = this;
+    let s;
+    if (isNull) {
+      s = '?';
+    } else {
+      let { asRange, fixed = 2 } = cfg;
+      if (asRange == null) {
+        let sFraction = `${n}/${d}`;
+        let sValue = value.toString();
+        let sFixed = value.toFixed(fixed);
+        s = sValue.length < sFixed.length ? sValue : sFixed;
+        s = s.length < sFraction.length ? s : sFraction;
+      } else {
+        let sRange = `${n}${asRange}${d}`;
+        s = sRange;
+      }
     }
-    let s = d === 1 ? `${n}` : `${n}/${d}`;
-
-    return units ? `${s} ${units}` : s;
+    return units ? `${s}${units}` : s;
   }
 
   add(f) {
@@ -94,9 +167,9 @@ export class Fraction {
     let { numerator: n1, denominator: d1, units: u1 } = this;
     let { numerator: n2, denominator: d2, units: u2 } = f;
     if (this.units !== f.units) {
-      throw new Error(`${msg} units? ${u1}? ${u2}?`);
+      throw new Error(`${msg} units? "${u1}" vs. "${u2}"`);
     }
 
-    return new Fraction(n1 * d2 + n2 * d1, d1 * d2).reduce();
+    return new this.constructor(n1 * d2 + n2 * d1, d1 * d2).reduce();
   }
 }

package/src/math/hadamard.mjs

@@ -0,0 +1,81 @@
+import { DBG } from '../defines.mjs';
+import { ColorConsole } from '../text/color-console.mjs';
+import { Unicode } from '../text/unicode.mjs';
+const { CHECKMARK: UOK } = Unicode;
+const { H6D } = DBG.M2H;
+const { cc } = ColorConsole;
+
+const SQRT2 = Math.sqrt(2);
+
+export class Hadamard {
+  static #ctor = false;
+  constructor(cfg = {}) {
+    const msg = 'h6d.ctor:';
+    if (!Hadamard.#ctor) {
+      throw new Error(`${msg} try: encode(signal)`);
+    }
+
+    Object.assign(this, cfg);
+  }
+
+  static fwht(input) {
+    // Fast Walsh-Hadamard Transform
+    const msg = 'h6d.fwht';
+    const dbg = H6D.FWHT;
+    const length = input.length;
+    let h = 1;
+    let scale = 1;
+    let output = [...input];
+    dbg && cc.ok(msg, 'input:', ...input);
+    while (h < length) {
+      let hNext = h * 2;
+      for (let i = 0; i < length; i += hNext) {
+        for (let j = i; j < i + h; j++) {
+          let x = output[j];
+          let y = output[j + h];
+          output[j] = x + y;
+          output[j + h] = x - y;
+          dbg > 2 &&
+            cc.fyi(msg, { h, length, i, j, ih: i + h, jh: j + h });
+        }
+      }
+      dbg > 1 && cc.ok(msg, 'h:', h, 'output:', ...output);
+      output = output.map((v) => v / SQRT2);
+      h = hNext;
+    }
+    dbg && cc.ok1(msg + UOK, 'output:', ...output);
+
+    return output;
+  }
+
+  static encode(signal) {
+    const msg = 'h6d.encode';
+    const dbg = H6D.ENCODE;
+    let length = signal.length;
+    let n = Math.ceil(Math.log2(length));
+    let fullLength = Math.pow(2, n);
+    let zeros = new Array(fullLength - length).fill(0);
+    let input = [...signal, ...zeros];
+    let output = Hadamard.fwht(input);
+
+    let h6d;
+    try {
+      Hadamard.#ctor = true;
+      h6d = new Hadamard({ length, signal: output });
+    } finally {
+      Hadamard.#ctor = false;
+    }
+    dbg > 1 && cc.ok(msg, 'output:', ...output);
+    dbg && cc.ok1(msg, { length, n, fullLength });
+    return h6d;
+  }
+
+  decode() {
+    const msg = 'h6d.decode';
+    const dbg = H6D.DECODE;
+    let { length, signal } = this;
+    let output = Hadamard.fwht(signal).slice(0, length);
+    dbg && cc.ok1(msg + UOK, ...output);
+    return output;
+  }
+}

package/src/math/interval.mjs

@@ -170,18 +170,8 @@ export class Interval {
   overlaps(iv2) {
     const msg = 'i6l.overlaps';
     const dbg = DBG.I6L_OVERLAPS;
-    let {
-      lo: lo1,
-      hi: hi1,
-      leftOpen: lOpen1,
-      rightOpen: rOpen1,
-    } = this;
-    let {
-      lo: lo2,
-      hi: hi2,
-      leftOpen: lOpen2,
-      rightOpen: rOpen2,
-    } = iv2;
+    let { lo: lo1, hi: hi1, leftOpen: lOpen1, rightOpen: rOpen1 } = this;
+    let { lo: lo2, hi: hi2, leftOpen: lOpen2, rightOpen: rOpen2 } = iv2;
 
     //console.log(msg, {lo1, lo2, hi1, hi2});
     if (!lOpen1 && iv2.contains(lo1)) {

package/src/math/units.mjs

@@ -0,0 +1,230 @@
+import { DBG } from '../../src/defines.mjs';
+const { U3S } = DBG.S5H;
+import { Unicode } from '../text/unicode.mjs';
+import { Fraction } from './fraction.mjs';
+const { CHECKMARK: UOK, RIGHT_ARROW: URA } = Unicode;
+import { ColorConsole } from '../text/color-console.mjs';
+const { cc } = ColorConsole;
+
+const DEFAULT_LENGTH = {
+  in: {
+    aliases: ['inch'],
+    from: {
+      ft: [12, 0, 0, 1],
+      mm: [10, 0, 0, 254],
+      cm: [100, 0, 0, 254],
+      m: [100 * 100, 0, 0, 254],
+    },
+  },
+  ft: {
+    aliases: ['foot', 'feet'],
+    from: {
+      in: [1, 0, 0, 12],
+      mm: [100, 0, 0, 10 * 254 * 12],
+      cm: [100, 0, 0, 254 * 12],
+      m: [100 * 100, 0, 0, 254 * 12],
+    },
+  },
+  m: {
+    aliases: ['meter', 'metre'],
+    from: {
+      mm: [1, 0, 0, 1000],
+      cm: [1, 0, 0, 100],
+      ft: [12 * 254, 0, 0, 100 * 100],
+      in: [254, 0, 0, 100 * 100],
+    },
+  },
+  cm: {
+    aliases: ['centimeter', 'centimetre'],
+    from: {
+      in: [254, 0, 0, 100],
+      ft: [12 * 254, 0, 0, 100],
+      mm: [1, 0, 0, 10],
+      m: [1, 0, 0, 100],
+    },
+  },
+  mm: {
+    aliases: ['millimeter', 'millimetre'],
+  },
+}; // DEFAULT_LENGTH
+
+const DEFAULT_TEMPERATURE = {
+  F: {
+    aliases: ['Fahrenheit'],
+    from: {
+      C: [9, 160, 0, 5],
+    },
+  },
+  C: {
+    aliases: ['Centigrade'],
+    from: {
+      F: [5, -5 * 32, 0, 9],
+    },
+  },
+};
+
+const DEFAULT_TIME = {
+  ms: {
+    aliases: ['millisecond', 'milliseconds'],
+    from: {
+      s: [1000, 0, 0, 1],
+      min: [60 * 1000, 0, 0, 1],
+      h: [60 * 60 * 1000, 0, 0, 1],
+      d: [24 * 60 * 60 * 1000, 0, 0, 1],
+    },
+  },
+  s: {
+    aliases: ['seconds'],
+    from: {
+      ms: [1, 0, 0, 1000],
+      min: [60, 0, 0, 1],
+      h: [60 * 60, 0, 0, 1],
+      d: [24 * 60 * 60, 0, 0, 1],
+    },
+  },
+  min: {
+    aliases: ['minutes'],
+    from: {
+      ms: [1, 0, 0, 60 * 1000],
+      s: [1, 0, 0, 60],
+      h: [60, 0, 0, 1],
+      d: [24 * 60, 0, 0, 1],
+    },
+  },
+  h: {
+    aliases: ['hour', 'hours', 'hr'],
+    from: {
+      ms: [1, 0, 0, 60 * 60 * 1000],
+      s: [1, 0, 0, 60 * 60],
+      min: [1, 0, 0, 60],
+      d: [24, 0, 0, 1],
+    },
+  },
+  d: {
+    aliases: ['day', 'days'],
+    from: {
+      ms: [1, 0, 0, 24 * 60 * 60 * 1000],
+      s: [1, 0, 0, 24 * 60 * 60],
+      min: [1, 0, 0, 24 * 60],
+      h: [1, 0, 0, 24],
+    },
+  },
+}; // DEFAULT_TIME
+
+const G_OZ = new Fraction(10000000000, 352739619);
+
+const DEFAULT_WEIGHT = {
+  mg: {
+    aliases: ['milligram', 'milligrams'],
+    from: {
+      kg: [1000 * 1000, 0, 0, 1],
+      g: [1000, 0, 0, 1],
+      oz: [G_OZ.n * 1000, 0, 0, G_OZ.d],
+      lb: [16 * G_OZ.n * 1000, 0, 0, G_OZ.d],
+    },
+  },
+  g: {
+    aliases: ['gram', 'grams'],
+    from: {
+      kg: [1000, 0, 0, 1],
+      mg: [1, 0, 0, 1000],
+      oz: [G_OZ.n, 0, 0, G_OZ.d],
+      lb: [16 * G_OZ.n, 0, 0, G_OZ.d],
+    },
+  },
+  kg: {
+    aliases: ['kilogram', 'kilograms'],
+    from: {
+      g: [1, 0, 0, 1000],
+      mg: [1, 0, 0, 1000 * 1000],
+      oz: [G_OZ.n, 0, 0, 1000 * G_OZ.d],
+      lb: [16 * G_OZ.n, 0, 0, 1000 * G_OZ.d],
+    },
+  },
+  oz: {
+    aliases: ['ounce', 'ounces'],
+    from: {
+      g: [G_OZ.d, 0, 0, G_OZ.n],
+      kg: [G_OZ.d * 1000, 0, 0, G_OZ.n],
+      lb: [16, 0, 0, 1],
+    },
+  },
+  lb: {
+    aliases: ['pound', 'pounds', 'lbs'],
+    from: {
+      oz: [1, 0, 0, 16],
+      g: [G_OZ.d, 0, 0, 16 * G_OZ.n],
+      kg: [1000 * G_OZ.d, 0, 0, 16 * G_OZ.n],
+    },
+  },
+};
+
+const DEFAULT_UNITS = Object.assign(
+  {},
+  DEFAULT_LENGTH,
+  DEFAULT_TEMPERATURE,
+  DEFAULT_TIME,
+  DEFAULT_WEIGHT,
+);
+
+export class Units {
+  #abbrMap;
+  #unitMap;
+  constructor(cfg = {}) {
+    let { unitMap = DEFAULT_UNITS } = cfg;
+    this.#unitMap = unitMap;
+    this.#abbrMap = Object.entries(unitMap).reduce((a, entry) => {
+      const [abbr, def] = entry;
+      const { aliases } = def;
+      a[abbr] = abbr;
+      aliases.forEach((n) => {
+        a[n] = abbr;
+      });
+      return a;
+    }, {});
+  }
+
+  abbreviation(unit) {
+    let d9t = this.#abbrMap[unit];
+    return d9t == null ? unit : d9t;
+  }
+
+  convertFraction(vSrc) {
+    const msg = 'u3s.convertFraction';
+    const dbg = U3S.CONVERT_FRACTION;
+    let { n, d, units: uSrc } = vSrc;
+    let srcAbbr = this.abbreviation(uSrc);
+    let convertTo = (uDst) => {
+      let dstAbbr = this.abbreviation(uDst);
+      let vDst;
+      if (dstAbbr === srcAbbr) {
+        vDst = new Fraction(n, d, uDst);
+        dbg && cc.ok1(msg + 1 + UOK, vSrc, URA, vDst);
+      } else {
+        let dstBase = this.#unitMap[dstAbbr];
+        let srcMatrix = dstBase?.from?.[srcAbbr];
+        if (srcMatrix) {
+          let nDst = srcMatrix[0] * n + srcMatrix[1] * d;
+          let dDst = srcMatrix[2] * n + srcMatrix[3] * d;
+          vDst = new Fraction(nDst, dDst, uDst).reduce();
+          dbg && cc.ok1(msg + 2 + UOK, vSrc, URA, vDst);
+        } // srcMatrix
+      } // dstAbbr !== srcAbbr
+      if (vDst == null) {
+        vDst = vSrc;
+        dbg && cc.ok1(msg + 3 + UOK, vSrc, URA, vDst);
+      }
+      return vDst;
+    };
+
+    return { to: convertTo };
+  } // convertFraction
+
+  convert(value) {
+    if (value instanceof Fraction) {
+      return this.convertFraction(value);
+    }
+
+    throw new Error(`value?${value}`);
+  } // convert
+} // Units

package/src/text/bilara-path.mjs

@@ -6,9 +6,7 @@ export class BilaraPath {
   static htmlPath(mid) {
     let lang = 'pli';
     let auth = 'ms';
-    return ['html', lang, `${auth}/sutta`, `${mid}_html.json`].join(
-      '/',
-    );
+    return ['html', lang, `${auth}/sutta`, `${mid}_html.json`].join('/');
   }
 
   static variantPath(mid) {

package/src/text/color-console.mjs

@@ -1,5 +1,9 @@
 import util from 'node:util';
+import { DBG } from '../defines.mjs';
 import { Unicode } from './unicode.mjs';
+const { COLOR_CONSOLE: C10E } = DBG;
+
+const { RED_X: URX, CHECKMARK: UOK } = Unicode;
 
 const {
   BLACK,
@@ -23,6 +27,74 @@ const {
 
 let CC;
 
+class Props {
+  constructor(obj) {
+    let entries = Object.entries(obj);
+
+    Object.assign(this, {
+      obj,
+      entries,
+      i: 0,
+      done: false,
+      value: undefined,
+      key: undefined,
+      emitKey: true,
+    });
+  }
+
+  [Symbol.iterator]() {
+    return this;
+  }
+
+  next() {
+    const msg = 'p3s.next';
+    const dbg = C10E.PROPS_NEXT;
+    let { entries, i, emitKey, done } = this;
+    let value;
+    let entry = entries[i];
+    if (i < entries.length) {
+      if (emitKey) {
+        value = entry[0] + ':';
+      } else {
+        value = entry[1];
+        dbg > 1 && CC.ok(msg, 'emitKey', value);
+        switch (typeof value) {
+          case 'object': {
+            if (value instanceof Array) {
+              dbg > 1 && CC.ok(msg, 'Array', value);
+              value = value === null ? null : JSON.stringify(value);
+            } else if (value && value.toString !== {}.toString) {
+              dbg > 1 && CC.ok(msg, 'toString', value);
+              value = value.toString();
+            } else {
+              dbg > 1 && CC.ok(msg, 'object', value);
+              value = value === null ? null : JSON.stringify(value);
+            }
+            break;
+          }
+          case 'function':
+            dbg > 1 && CC.ok(msg, 'function', value);
+            value = `[Function ${value.name}]`;
+            break;
+          default:
+            dbg > 1 && CC.ok(msg, 'default', value);
+            break;
+        }
+      }
+      if (!emitKey) {
+        this.i++;
+      }
+      this.emitKey = !this.emitKey;
+    } else {
+      done = true;
+    }
+    this.value = value;
+    dbg && CC.ok1(msg + UOK, { done, value });
+
+    return { done, value };
+  }
+} // Props
+
 export class ColorConsole {
   constructor(opts = {}) {
     let {
@@ -58,6 +130,14 @@ export class ColorConsole {
     });
   }
 
+  static get URX() {
+    return URX;
+  }
+
+  static get UOK() {
+    return UOK;
+  }
+
   static get cc() {
     CC = CC || new ColorConsole();
     return CC;
@@ -102,6 +182,10 @@ export class ColorConsole {
     }
   }
 
+  props(obj) {
+    return new Props(obj);
+  }
+
   writeColor(color, rest) {
     let { styles, defaultOptions } = util?.inspect || {};
     if (styles) {
@@ -136,31 +220,60 @@ export class ColorConsole {
       tf = thing;
     }
 
-    let v = this.valueOf(thing);
+    let v = this.asString(thing);
     let color = tf ? this.okColor2 : this.badColor2;
     return color + v;
   }
 
-  valueOf(thing) {
-    const msg = 'c10e.valueOf';
-    let { precision } = this;
+  asString(thing) {
+    const msg = 'c10e.asString';
+    const dbg = C10E.AS_STRING;
+    let { okColor1, okColor2, precision } = this;
+    dbg > 2 && console.log(okColor2, msg, 'thing:', thing);
     switch (typeof thing) {
       case 'undefined':
         return 'undefined';
       case 'object': {
         if (thing == null) {
+          dbg > 1 && console.log(okColor2, msg, 'null');
           return '' + thing;
         }
         if (thing instanceof Date) {
           return this.dateFormat.format(thing);
         }
-        if (
-          thing.constructor !== Object &&
-          typeof thing.toString === 'function'
-        ) {
+        let ownToString =
+          typeof thing.toString === 'function' &&
+          thing.toString !== Array.prototype.toString &&
+          thing.toString !== Object.prototype.toString;
+        dbg > 1 && this.ok(okColor2, msg, 'ownToString:', ownToString);
+        if (ownToString) {
+          let s = thing.toString();
+          dbg > 1 && this.ok(okColor2, msg, 'ownToString1:', s);
           return thing.toString();
         }
-        return thing;
+        if (thing instanceof Array) {
+          let s =
+            '[' +
+            thing.map((item) => this.asString(item)).join(', ') +
+            ']';
+          dbg > 1 && this.ok(okColor2, msg, 'array:', s);
+          return s;
+        }
+
+        // Generic Object
+        let sEntries = Object.entries(thing)
+          .map((kv) => kv[0] + ':' + this.asString(kv[1]))
+          .join(', ');
+        let cname = thing.constructor?.name;
+        if (cname === 'Object') {
+          cname = '';
+        } else if (cname === 'anonymous') {
+          cname = Unicode.INVERSE_BULLET;
+        }
+        let s = cname + '{' + sEntries + '}';
+        dbg > 1 &&
+          console.log(okColor2, msg, { ownToString }, 'object:', s);
+        return s;
       }
       case 'string':
         return thing;
@@ -171,10 +284,13 @@ export class ColorConsole {
         }
         return v;
       }
+      case 'function': {
+        return thing.name;
+      }
       default:
         return JSON.stringify(thing);
     }
-  } // valueOf
+  } // asString
 
   color(textColor, ...things) {
     let { valueColor } = this;
@@ -184,20 +300,15 @@ export class ColorConsole {
     let eol;
     return things.reduce((a, thing) => {
       let newLabel = '';
-      let v = this.valueOf(thing);
+      let v = this.asString(thing);
       let aLast = a.at(-1);
-      if (
-        typeof aLast === 'string' &&
-        aLast.endsWith('\n' + endColor)
-      ) {
+      if (typeof aLast === 'string' && aLast.endsWith('\n' + endColor)) {
         if (aLast === textColor + '\n' + endColor) {
           a.pop();
         } else {
           const iLast = aLast.lastIndexOf('\n');
           a.pop();
-          a.push(
-            aLast.substring(0, iLast) + aLast.substring(iLast + 1),
-          );
+          a.push(aLast.substring(0, iLast) + aLast.substring(iLast + 1));
         }
         v = '\n' + v;
       }

package/src/text/list.mjs

@@ -180,8 +180,7 @@ export class ListFactory {
       separator: rowSeparator,
       precision,
     });
-    let newRow = (separator) =>
-      this.createRow({ separator, precision });
+    let newRow = (separator) => this.createRow({ separator, precision });
     name = name || singleList.name;
     switch (order) {
       case 'col-major':

package/src/text/merkle-json.mjs

@@ -159,8 +159,7 @@ function rhex(n) {
     j = 0;
   for (; j < 4; j++)
     s +=
-      hex_chr[(n >> (j * 8 + 4)) & 0x0f] +
-      hex_chr[(n >> (j * 8)) & 0x0f];
+      hex_chr[(n >> (j * 8 + 4)) & 0x0f] + hex_chr[(n >> (j * 8)) & 0x0f];
   return s;
 }
 
@@ -237,9 +236,7 @@ export class MerkleJson {
   stringify(value) {
     if (value instanceof Array) {
       let body = value.reduce((a, v) => {
-        return a
-          ? `${a},${this.stringify(v)}`
-          : `${this.stringify(v)}`;
+        return a ? `${a},${this.stringify(v)}` : `${this.stringify(v)}`;
       }, '');
       return `[${body}]`;
     } else if (value instanceof Date) {

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

@@ -124,9 +124,7 @@ export class SuttaCentralId {
         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}`,
-          );
+          throw new Error(`partNumber() cannot parse ${part} in ${id}`);
         }
       } else {
         n0 = Number(c0);
@@ -142,10 +140,7 @@ export class SuttaCentralId {
   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 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));
@@ -156,15 +151,10 @@ export class SuttaCentralId {
   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 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 a.concat(SuttaCentralId.partNumber(highPart, id_or_path));
     }, []);
     return nums;
   }

package/src/text/tfidf-space.mjs

@@ -1,7 +1,7 @@
 import { DBG } from '../defines.mjs';
+import { ColorConsole } from './color-console.mjs';
 import { Corpus } from './corpus.mjs';
 import { WordVector } from './word-vector.mjs';
-import { ColorConsole } from './color-console.mjs';
 const { cc } = ColorConsole;
 
 // The golden ratio is pretty.
@@ -52,17 +52,17 @@ export class TfidfSpace {
 
   // Create wordWeight function that weighs the first words
   // of a document more than the remainder
-  static wordWeightFromPrefix(prefixLength, prefixBias=0.5) {
+  static wordWeightFromPrefix(prefixLength, prefixBias = 0.5) {
     const msg = 't8e.wordWeightFromPrefix';
 
-    let wordWeight = (w,i,nWords) => {
+    let wordWeight = (w, i, nWords) => {
       const nWeighted = Math.min(nWords, prefixLength);
       const nUnweighted = nWords - nWeighted;
       const wf = nUnweighted ? prefixBias : 1;
-      return i < nWeighted 
-        ? wf * nWords / nWeighted 
-        : (1 - wf) * nWords / nUnweighted;
-      }
+      return i < nWeighted
+        ? (wf * nWords) / nWeighted
+        : ((1 - wf) * nWords) / nUnweighted;
+    };
     return wordWeight;
   }
 
@@ -110,9 +110,7 @@ export class TfidfSpace {
     const msg = 'w7e.idfTunable:';
     // NOTE: This is NOT the usual formula
     // Map to [0:ignore..1:important]
-    return nDocs
-      ? 1 - Math.exp(((wdc - nDocs) / wdc) * idfWeight)
-      : 1;
+    return nDocs ? 1 - Math.exp(((wdc - nDocs) / wdc) * idfWeight) : 1;
   }
 
   idf(word, idfWeight = this.idfWeight) {
@@ -208,22 +206,20 @@ export class TfidfSpace {
     return { bow, words };
   }
 
-  bowOfText(text, opts={}) {
+  bowOfText(text, opts = {}) {
     const msg = 'w7e.bowOfText:';
     let dbg = DBG.W7E_BOW_OF_TEXT;
     if (text == null) {
       throw new Error(`${msg} text?`);
     }
-    let {
-      wordWeight = (word,i,n) => 1,
-    } = opts;
+    let { wordWeight = (word, i, n) => 1 } = opts;
     let sNorm = this.normalizeText(text);
     let words = sNorm.split(' ');
     let nWords = words.length;
     let bow = words.reduce((a, word, i) => {
       let ww = wordWeight(word, i, nWords);
       a[word] = (a[word] || 0) + ww;
-      dbg && cc.fyi1(msg+0.1, {i, word, ww, sum:a[word]});
+      dbg && cc.fyi1(msg + 0.1, { i, word, ww, sum: a[word] });
       return a;
     }, new WordVector());
 

package/src/text/unicode.mjs

@@ -235,6 +235,24 @@ export class Unicode {
   static get u_MACRON() {
     return '\u016d'; /* UTF-8 c5ab */
   }
+  static get WHITE_CIRCLE() {
+    return '\u25CB';
+  }
+  static get INVERSE_BULLET() {
+    return '\u25D8';
+  }
+  static get CIRCLED_BULLET() {
+    return '\u29BF';
+  }
+  static get FISHEYE() {
+    return '\u25C9';
+  }
+  static get WHITE_BULLET() {
+    return '\u25E6';
+  }
+  static get BULLET() {
+    return '\u2022';
+  }
   static get LEFT_ARROW() {
     return '\u2190';
   }

package/src/text/word-vector.mjs

@@ -1,8 +1,6 @@
 import { DBG } from '../defines.mjs';
 import { Unicode } from './unicode.mjs';
-const {
-  ELLIPSIS,
-} = Unicode;
+const { ELLIPSIS } = Unicode;
 
 // The golden ratio is pretty.
 // 1.6180339887498948482045868343656381177203091798057628621354;
@@ -106,6 +104,7 @@ export class WordVector extends Object {
   }
 
   multiply(vec2) {
+    // Hadabard product: multipy element by element
     const msg = 'w8r.multiply:';
     let keys = Object.keys(vec2);
     return keys.reduce((a, k) => {