@plugjs/plug 0.2.4 → 0.2.5

package/dist/utils/diff.cjs

@@ -0,0 +1,292 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// utils/diff.ts
+var diff_exports = {};
+__export(diff_exports, {
+  diff: () => diff,
+  textDiff: () => textDiff
+});
+module.exports = __toCommonJS(diff_exports);
+var import_node_assert = require("node:assert");
+var import_node_util = require("node:util");
+var import_asserts = require("../asserts.cjs");
+var import_logging = require("../logging.cjs");
+var import_types = require("./types.cjs");
+function compareLongestCommonSubsequence(lhsCtx, rhsCtx) {
+  let lhsStart = 0;
+  let rhsStart = 0;
+  let lhsItem = 0;
+  let rhsItem = 0;
+  const changes = [];
+  while (lhsItem < lhsCtx.length || rhsItem < rhsCtx.length) {
+    if (lhsItem < lhsCtx.length && !lhsCtx.modified[lhsItem] && rhsItem < rhsCtx.length && !rhsCtx.modified[rhsItem]) {
+      lhsItem++;
+      rhsItem++;
+      continue;
+    }
+    lhsStart = lhsItem;
+    rhsStart = rhsItem;
+    while (lhsItem < lhsCtx.length && (rhsItem >= rhsCtx.length || lhsCtx.modified[lhsItem])) {
+      lhsItem++;
+    }
+    while (rhsItem < rhsCtx.length && (lhsItem >= lhsCtx.length || rhsCtx.modified[rhsItem])) {
+      rhsItem++;
+    }
+    if (lhsStart < lhsItem || rhsStart < rhsItem) {
+      const lat = Math.min(lhsStart, lhsCtx.length ? lhsCtx.length - 1 : 0);
+      const rat = Math.min(rhsStart, rhsCtx.length ? rhsCtx.length - 1 : 0);
+      changes.push({
+        lhsPos: lat,
+        lhsDel: lhsItem - lhsStart,
+        rhsPos: rat,
+        rhsAdd: rhsItem - rhsStart
+      });
+    }
+  }
+  return changes;
+}
+function getShortestMiddleSnake(lhsCtx, lhsLower, lhsUpper, rhsCtx, rhsLower, rhsUpper, vectorU, vectorD) {
+  const max = lhsCtx.length + rhsCtx.length + 1;
+  const kdown = lhsLower - rhsLower;
+  const kup = lhsUpper - rhsUpper;
+  const delta = lhsUpper - lhsLower - (rhsUpper - rhsLower);
+  const odd = (delta & 1) != 0;
+  const offsetDown = max - kdown;
+  const offsetUp = max - kup;
+  const maxd = (lhsUpper - lhsLower + rhsUpper - rhsLower) / 2 + 1;
+  const ret = { x: 0, y: 0 };
+  let d;
+  let k;
+  let x;
+  let y;
+  vectorD[offsetDown + kdown + 1] = lhsLower;
+  vectorU[offsetUp + kup - 1] = lhsUpper;
+  for (d = 0; d <= maxd; ++d) {
+    for (k = kdown - d; k <= kdown + d; k += 2) {
+      if (k === kdown - d) {
+        x = vectorD[offsetDown + k + 1];
+      } else {
+        x = vectorD[offsetDown + k - 1] + 1;
+        if (k < kdown + d && vectorD[offsetDown + k + 1] >= x) {
+          x = vectorD[offsetDown + k + 1];
+        }
+      }
+      y = x - k;
+      while (x < lhsUpper && y < rhsUpper && lhsCtx.codes[x] === rhsCtx.codes[y]) {
+        x++;
+        y++;
+      }
+      vectorD[offsetDown + k] = x;
+      if (odd && kup - d < k && k < kup + d) {
+        if (vectorU[offsetUp + k] <= vectorD[offsetDown + k]) {
+          ret.x = vectorD[offsetDown + k];
+          ret.y = vectorD[offsetDown + k] - k;
+          return ret;
+        }
+      }
+    }
+    for (k = kup - d; k <= kup + d; k += 2) {
+      if (k === kup + d) {
+        x = vectorU[offsetUp + k - 1];
+      } else {
+        x = vectorU[offsetUp + k + 1] - 1;
+        if (k > kup - d && vectorU[offsetUp + k - 1] < x) {
+          x = vectorU[offsetUp + k - 1];
+        }
+      }
+      y = x - k;
+      while (x > lhsLower && y > rhsLower && lhsCtx.codes[x - 1] === rhsCtx.codes[y - 1]) {
+        x--;
+        y--;
+      }
+      vectorU[offsetUp + k] = x;
+      if (!odd && kdown - d <= k && k <= kdown + d) {
+        if (vectorU[offsetUp + k] <= vectorD[offsetDown + k]) {
+          ret.x = vectorD[offsetDown + k];
+          ret.y = vectorD[offsetDown + k] - k;
+          return ret;
+        }
+      }
+    }
+  }
+  (0, import_node_assert.fail)("Unexpected state computing diff");
+}
+function getLongestCommonSubsequence(lhsCtx, lhsLower, lhsUpper, rhsCtx, rhsLower, rhsUpper, vectorU = [], vectorD = []) {
+  while (lhsLower < lhsUpper && rhsLower < rhsUpper && lhsCtx.codes[lhsLower] === rhsCtx.codes[rhsLower]) {
+    ++lhsLower;
+    ++rhsLower;
+  }
+  while (lhsLower < lhsUpper && rhsLower < rhsUpper && lhsCtx.codes[lhsUpper - 1] === rhsCtx.codes[rhsUpper - 1]) {
+    --lhsUpper;
+    --rhsUpper;
+  }
+  if (lhsLower === lhsUpper) {
+    while (rhsLower < rhsUpper) {
+      rhsCtx.modified[rhsLower++] = true;
+    }
+  } else if (rhsLower === rhsUpper) {
+    while (lhsLower < lhsUpper) {
+      lhsCtx.modified[lhsLower++] = true;
+    }
+  } else {
+    const { x, y } = getShortestMiddleSnake(
+      lhsCtx,
+      lhsLower,
+      lhsUpper,
+      rhsCtx,
+      rhsLower,
+      rhsUpper,
+      vectorU,
+      vectorD
+    );
+    getLongestCommonSubsequence(
+      lhsCtx,
+      lhsLower,
+      x,
+      rhsCtx,
+      rhsLower,
+      y,
+      vectorU,
+      vectorD
+    );
+    getLongestCommonSubsequence(
+      lhsCtx,
+      x,
+      lhsUpper,
+      rhsCtx,
+      y,
+      rhsUpper,
+      vectorU,
+      vectorD
+    );
+  }
+}
+var Context = class {
+  /** Keep a tab on modified items */
+  modified;
+  /** A _code table_ for all the items in this context */
+  codes;
+  /** The number of item held by this context */
+  length;
+  /** Construct with a _code table_ */
+  constructor(codes) {
+    const length = this.length = codes.length;
+    this.modified = new Array(length);
+    this.codes = codes;
+  }
+};
+var Coder = class {
+  _primitives = /* @__PURE__ */ new Map();
+  _objects = [];
+  _index = 1;
+  _getObjectCode(item) {
+    for (const [object, code2] of this._objects) {
+      if ((0, import_node_util.isDeepStrictEqual)(item, object))
+        return code2;
+    }
+    const code = ++this._index;
+    this._objects.push([item, code]);
+    return code;
+  }
+  _getPrimitiveCode(item) {
+    let code = this._primitives.get(item);
+    if (code)
+      return code;
+    code = ++this._index;
+    this._primitives.set(item, code);
+    return code;
+  }
+  /** Get the code table for an {@link Iterable} */
+  getCodes(iterable) {
+    const codes = [];
+    for (const item of iterable) {
+      const type = item === null ? "null" : typeof item;
+      const code = type === "object" ? this._getObjectCode(item) : this._getPrimitiveCode(item);
+      codes.push(code);
+    }
+    return codes;
+  }
+};
+var inspectOptions = {
+  showHidden: false,
+  depth: 10,
+  colors: false,
+  maxArrayLength: 100,
+  maxStringLength: 250,
+  breakLength: Infinity,
+  compact: false,
+  sorted: true,
+  getters: true
+};
+function diff(lhs, rhs) {
+  (0, import_asserts.assert)(lhs !== void 0, "Left-Hand side undefined");
+  (0, import_asserts.assert)(rhs !== void 0, "Right-Hand side undefined");
+  const codec = new Coder();
+  const lhsCtx = new Context(codec.getCodes(lhs));
+  const rhsCtx = new Context(codec.getCodes(rhs));
+  getLongestCommonSubsequence(
+    lhsCtx,
+    0,
+    lhsCtx.length,
+    rhsCtx,
+    0,
+    rhsCtx.length
+  );
+  return compareLongestCommonSubsequence(lhsCtx, rhsCtx);
+}
+function textDiff(lhs, rhs, add, del, not) {
+  const _add = add || (import_logging.logOptions.colors ? import_logging.$grn : (s) => `+ ${s}`);
+  const _del = del || (import_logging.logOptions.colors ? import_logging.$red : (s) => `- ${s}`);
+  const _not = not || (import_logging.logOptions.colors ? (s) => s : (s) => `  ${s}`);
+  let lhsLines;
+  let rhsLines;
+  const lhsType = (0, import_types.getTypeOf)(lhs);
+  const rhsType = (0, import_types.getTypeOf)(rhs);
+  if (lhsType === "string" && rhsType === "string") {
+    lhsLines = lhs.split("\n");
+    rhsLines = rhs.split("\n");
+  } else {
+    lhsLines = (0, import_node_util.inspect)(lhs, inspectOptions).split("\n");
+    rhsLines = (0, import_node_util.inspect)(rhs, inspectOptions).split("\n");
+  }
+  const changes = diff(lhsLines, rhsLines);
+  if (changes.length === 0)
+    return "";
+  let offset = 0;
+  const result = [];
+  changes.forEach(({ lhsPos, lhsDel, rhsPos, rhsAdd }) => {
+    if (offset != lhsPos)
+      result.push(...lhsLines.slice(offset, lhsPos).map(_not));
+    if (lhsDel)
+      result.push(...lhsLines.slice(lhsPos, lhsPos + lhsDel).map(_del));
+    if (rhsAdd)
+      result.push(...rhsLines.slice(rhsPos, rhsPos + rhsAdd).map(_add));
+    offset = lhsPos + lhsDel;
+  });
+  if (offset < lhsLines.length)
+    result.push(...lhsLines.slice(offset).map(_not));
+  return result.join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  diff,
+  textDiff
+});
+//# sourceMappingURL=diff.cjs.map

package/dist/utils/diff.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/diff.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAAqB;AACrB,uBAA2C;AAE3C,qBAAuB;AACvB,qBAAuC;AACvC,mBAA0B;AAyB1B,SAAS,gCAAgC,QAAiB,QAA2B;AACnF,MAAI,WAAW;AACf,MAAI,WAAW;AACf,MAAI,UAAU;AACd,MAAI,UAAU;AAEd,QAAM,UAAoB,CAAC;AAE3B,SAAO,UAAU,OAAO,UAAU,UAAU,OAAO,QAAQ;AACzD,QACG,UAAU,OAAO,UAAY,CAAC,OAAO,SAAS,OAAO,KACrD,UAAU,OAAO,UAAY,CAAC,OAAO,SAAS,OAAO,GACtD;AAEA;AACA;AACA;AAAA,IACF;AAGA,eAAW;AACX,eAAW;AAEX,WAAQ,UAAU,OAAO,WACtB,WAAW,OAAO,UAAU,OAAO,SAAS,OAAO,IAAI;AACxD;AAAA,IACF;AAEA,WAAQ,UAAU,OAAO,WACtB,WAAW,OAAO,UAAU,OAAO,SAAS,OAAO,IAAI;AACxD;AAAA,IACF;AAEA,QAAK,WAAW,WAAa,WAAW,SAAU;AAChD,YAAM,MAAM,KAAK,IAAI,UAAW,OAAO,SAAU,OAAO,SAAS,IAAI,CAAC;AACtE,YAAM,MAAM,KAAK,IAAI,UAAW,OAAO,SAAU,OAAO,SAAS,IAAI,CAAC;AAEtE,cAAQ,KAAK;AAAA,QACX,QAAQ;AAAA,QACR,QAAQ,UAAU;AAAA,QAClB,QAAQ;AAAA,QACR,QAAQ,UAAU;AAAA,MACpB,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO;AACT;AAEA,SAAS,uBACL,QAAiB,UAAkB,UACnC,QAAiB,UAAkB,UACnC,SAAmB,SACK;AAC1B,QAAM,MAAM,OAAO,SAAS,OAAO,SAAS;AAE5C,QAAM,QAAQ,WAAW;AACzB,QAAM,MAAM,WAAW;AACvB,QAAM,QAAS,WAAW,YAAa,WAAW;AAClD,QAAM,OAAO,QAAQ,MAAM;AAC3B,QAAM,aAAa,MAAM;AACzB,QAAM,WAAW,MAAM;AACvB,QAAM,QAAS,WAAW,WAAW,WAAW,YAAY,IAAK;AACjE,QAAM,MAAM,EAAE,GAAG,GAAG,GAAG,EAAE;AACzB,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AAEJ,UAAQ,aAAa,QAAQ,CAAC,IAAI;AAClC,UAAQ,WAAW,MAAM,CAAC,IAAI;AAC9B,OAAK,IAAI,GAAG,KAAK,MAAM,EAAE,GAAG;AAC1B,SAAK,IAAI,QAAQ,GAAG,KAAK,QAAQ,GAAG,KAAK,GAAG;AAC1C,UAAI,MAAM,QAAQ,GAAG;AACnB,YAAI,QAAQ,aAAa,IAAI,CAAC;AAAA,MAChC,OAAO;AACL,YAAI,QAAQ,aAAa,IAAI,CAAC,IAAK;AACnC,YAAK,IAAK,QAAQ,KAAQ,QAAQ,aAAa,IAAI,CAAC,KAAM,GAAI;AAC5D,cAAI,QAAQ,aAAa,IAAI,CAAC;AAAA,QAChC;AAAA,MACF;AACA,UAAI,IAAI;AAER,aAAQ,IAAI,YACT,IAAI,YACJ,OAAO,MAAM,CAAC,MAAM,OAAO,MAAM,CAAC,GACnC;AACA;AAAK;AAAA,MACP;AACA,cAAQ,aAAa,CAAC,IAAK;AAE3B,UAAI,OAAQ,MAAM,IAAI,KAAO,IAAI,MAAM,GAAI;AACzC,YAAI,QAAQ,WAAW,CAAC,KAAM,QAAQ,aAAa,CAAC,GAAI;AACtD,cAAI,IAAI,QAAQ,aAAa,CAAC;AAC9B,cAAI,IAAI,QAAQ,aAAa,CAAC,IAAK;AACnC,iBAAQ;AAAA,QACV;AAAA,MACF;AAAA,IACF;AAEA,SAAK,IAAI,MAAM,GAAG,KAAK,MAAM,GAAG,KAAK,GAAG;AAEtC,UAAI,MAAM,MAAM,GAAG;AACjB,YAAI,QAAQ,WAAW,IAAI,CAAC;AAAA,MAC9B,OAAO;AACL,YAAI,QAAQ,WAAW,IAAI,CAAC,IAAK;AACjC,YAAK,IAAI,MAAM,KAAO,QAAQ,WAAW,IAAI,CAAC,IAAK,GAAI;AACrD,cAAI,QAAQ,WAAW,IAAI,CAAC;AAAA,QAC9B;AAAA,MACF;AACA,UAAI,IAAI;AACR,aAAQ,IAAI,YACT,IAAI,YACJ,OAAO,MAAM,IAAI,CAAC,MAAM,OAAO,MAAM,IAAI,CAAC,GAC3C;AAEA;AACA;AAAA,MACF;AACA,cAAQ,WAAW,CAAC,IAAI;AAExB,UAAI,CAAC,OAAQ,QAAQ,KAAK,KAAO,KAAK,QAAQ,GAAI;AAChD,YAAI,QAAQ,WAAW,CAAC,KAAM,QAAQ,aAAa,CAAC,GAAI;AACtD,cAAI,IAAI,QAAQ,aAAa,CAAC;AAC9B,cAAI,IAAI,QAAQ,aAAa,CAAC,IAAK;AACnC,iBAAQ;AAAA,QACV;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAGA,+BAAK,iCAAiC;AACxC;AAEA,SAAS,4BACL,QAAiB,UAAkB,UACnC,QAAiB,UAAkB,UACnC,UAAU,CAAC,GAAG,UAAU,CAAC,GACrB;AAEN,SAAS,WAAW,YACjB,WAAW,YACX,OAAO,MAAM,QAAQ,MAAM,OAAO,MAAM,QAAQ,GAAK;AACtD,MAAE;AACF,MAAE;AAAA,EACJ;AAEA,SAAS,WAAW,YACjB,WAAW,YACX,OAAO,MAAM,WAAW,CAAC,MAAM,OAAO,MAAM,WAAW,CAAC,GAAK;AAC9D,MAAE;AACF,MAAE;AAAA,EACJ;AACA,MAAI,aAAa,UAAU;AACzB,WAAO,WAAW,UAAU;AAC1B,aAAO,SAAS,UAAU,IAAI;AAAA,IAChC;AAAA,EACF,WAAW,aAAa,UAAU;AAChC,WAAO,WAAW,UAAU;AAC1B,aAAO,SAAS,UAAU,IAAI;AAAA,IAChC;AAAA,EACF,OAAO;AACL,UAAM,EAAE,GAAG,EAAE,IAAI;AAAA,MACb;AAAA,MAAQ;AAAA,MAAU;AAAA,MAClB;AAAA,MAAQ;AAAA,MAAU;AAAA,MAClB;AAAA,MAAS;AAAA,IAAO;AACpB;AAAA,MACI;AAAA,MAAQ;AAAA,MAAU;AAAA,MAClB;AAAA,MAAQ;AAAA,MAAU;AAAA,MAClB;AAAA,MAAS;AAAA,IAAO;AACpB;AAAA,MACI;AAAA,MAAQ;AAAA,MAAG;AAAA,MACX;AAAA,MAAQ;AAAA,MAAG;AAAA,MACX;AAAA,MAAS;AAAA,IAAO;AAAA,EACtB;AACF;AAOA,IAAM,UAAN,MAAc;AAAA;AAAA,EAEH;AAAA;AAAA,EAEA;AAAA;AAAA,EAEA;AAAA;AAAA,EAGT,YAAY,OAAiB;AAC3B,UAAM,SAAS,KAAK,SAAS,MAAM;AACnC,SAAK,WAAW,IAAI,MAAM,MAAM;AAChC,SAAK,QAAQ;AAAA,EACf;AACF;AAGA,IAAM,QAAN,MAAoD;AAAA,EAC1C,cAAc,oBAAI,IAAe;AAAA,EACjC,WAA4B,CAAC;AAAA,EAC7B,SAAS;AAAA,EAET,eAAe,MAAiB;AACtC,eAAW,CAAE,QAAQA,KAAK,KAAK,KAAK,UAAU;AAC5C,cAAI,oCAAkB,MAAM,MAAM;AAAG,eAAOA;AAAA,IAC9C;AAEA,UAAM,OAAO,EAAG,KAAK;AACrB,SAAK,SAAS,KAAK,CAAE,MAAM,IAAK,CAAC;AACjC,WAAO;AAAA,EACT;AAAA,EAEQ,kBAAkB,MAAiB;AACzC,QAAI,OAAO,KAAK,YAAY,IAAI,IAAI;AACpC,QAAI;AAAM,aAAO;AAEjB,WAAO,EAAG,KAAK;AACf,SAAK,YAAY,IAAI,MAAM,IAAI;AAC/B,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,SAAS,UAAuB;AAC9B,UAAM,QAAkB,CAAC;AACzB,eAAW,QAAQ,UAAU;AAC3B,YAAM,OAAO,SAAS,OAAO,SAAS,OAAO;AAE7C,YAAM,OAAO,SAAS,WACpB,KAAK,eAAe,IAAI,IACxB,KAAK,kBAAkB,IAAI;AAE7B,YAAM,KAAK,IAAI;AAAA,IACjB;AAEA,WAAO;AAAA,EACT;AACF;AAGA,IAAM,iBAAiC;AAAA,EACrC,YAAY;AAAA,EACZ,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,gBAAgB;AAAA,EAChB,iBAAiB;AAAA,EACjB,aAAa;AAAA,EACb,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,SAAS;AACX;AAUO,SAAS,KACZ,KACA,KACQ;AACV,6BAAO,QAAQ,QAAW,0BAA0B;AACpD,6BAAO,QAAQ,QAAW,2BAA2B;AAErD,QAAM,QAAQ,IAAI,MAAS;AAC3B,QAAM,SAAS,IAAI,QAAQ,MAAM,SAAS,GAAG,CAAC;AAC9C,QAAM,SAAS,IAAI,QAAQ,MAAM,SAAS,GAAG,CAAC;AAE9C;AAAA,IACI;AAAA,IAAQ;AAAA,IAAG,OAAO;AAAA,IAClB;AAAA,IAAQ;AAAA,IAAG,OAAO;AAAA,EACtB;AAEA,SAAO,gCAAgC,QAAQ,MAAM;AACvD;AAGO,SAAS,SACZ,KACA,KACA,KACA,KACA,KACM;AAER,QAAM,OAAO,QAAQ,0BAAW,SAAS,sBAAO,CAAC,MAAsB,KAAK;AAC5E,QAAM,OAAO,QAAQ,0BAAW,SAAS,sBAAO,CAAC,MAAsB,KAAK;AAC5E,QAAM,OAAO,QAAQ,0BAAW,SAAS,CAAC,MAAsB,IAAI,CAAC,MAAsB,KAAK;AAGhG,MAAI;AACJ,MAAI;AAGJ,QAAM,cAAU,wBAAU,GAAG;AAC7B,QAAM,cAAU,wBAAU,GAAG;AAI7B,MAAK,YAAY,YAAc,YAAY,UAAW;AACpD,eAAW,IAAI,MAAM,IAAI;AACzB,eAAW,IAAI,MAAM,IAAI;AAAA,EAC3B,OAAO;AACL,mBAAW,0BAAQ,KAAK,cAAc,EAAE,MAAM,IAAI;AAClD,mBAAW,0BAAQ,KAAK,cAAc,EAAE,MAAM,IAAI;AAAA,EACpD;AAGA,QAAM,UAAU,KAAK,UAAU,QAAQ;AACvC,MAAI,QAAQ,WAAW;AAAG,WAAO;AAGjC,MAAI,SAAS;AACb,QAAM,SAAmB,CAAC;AAC1B,UAAQ,QAAQ,CAAC,EAAE,QAAQ,QAAQ,QAAQ,OAAO,MAAM;AACtD,QAAI,UAAU;AAAQ,aAAO,KAAK,GAAG,SAAS,MAAM,QAAQ,MAAM,EAAE,IAAI,IAAI,CAAC;AAC7E,QAAI;AAAQ,aAAO,KAAK,GAAG,SAAS,MAAM,QAAQ,SAAS,MAAM,EAAE,IAAI,IAAI,CAAC;AAC5E,QAAI;AAAQ,aAAO,KAAK,GAAG,SAAS,MAAM,QAAQ,SAAS,MAAM,EAAE,IAAI,IAAI,CAAC;AAC5E,aAAS,SAAS;AAAA,EACpB,CAAC;AACD,MAAI,SAAS,SAAS;AAAQ,WAAO,KAAK,GAAG,SAAS,MAAM,MAAM,EAAE,IAAI,IAAI,CAAC;AAG7E,SAAO,OAAO,KAAK,IAAI;AACzB;",
+  "names": ["code"]
+}

package/dist/utils/diff.d.ts

@@ -0,0 +1,18 @@
+/** Identifies a single change */
+export interface Change {
+    /** The position in the Left-Hand side where items were deleted */
+    lhsPos: number;
+    /** The number of items deleted from the Left-Hand side */
+    lhsDel: number;
+    /** The position in the Right-Hand side where items were added */
+    rhsPos: number;
+    /** The number of items added to the Right-Hand side */
+    rhsAdd: number;
+}
+/**
+ * Compare the _Left-Hand side_ {@link Iterable} to _Right-Hand side_ one,
+ * producing an array of {@link Change | Changes} identifying the differences.
+ */
+export declare function diff<T, I extends Iterable<T> = Iterable<T>>(lhs: I, rhs: I): Change[];
+/** Produce a textual diff between two values. */
+export declare function textDiff(lhs: any, rhs: any, add?: (s: string) => string, del?: (s: string) => string, not?: (s: string) => string): string;

package/dist/utils/diff.mjs

@@ -0,0 +1,266 @@
+// utils/diff.ts
+import { fail } from "node:assert";
+import { inspect, isDeepStrictEqual } from "node:util";
+import { assert } from "../asserts.mjs";
+import { $grn, $red, logOptions } from "../logging.mjs";
+import { getTypeOf } from "./types.mjs";
+function compareLongestCommonSubsequence(lhsCtx, rhsCtx) {
+  let lhsStart = 0;
+  let rhsStart = 0;
+  let lhsItem = 0;
+  let rhsItem = 0;
+  const changes = [];
+  while (lhsItem < lhsCtx.length || rhsItem < rhsCtx.length) {
+    if (lhsItem < lhsCtx.length && !lhsCtx.modified[lhsItem] && rhsItem < rhsCtx.length && !rhsCtx.modified[rhsItem]) {
+      lhsItem++;
+      rhsItem++;
+      continue;
+    }
+    lhsStart = lhsItem;
+    rhsStart = rhsItem;
+    while (lhsItem < lhsCtx.length && (rhsItem >= rhsCtx.length || lhsCtx.modified[lhsItem])) {
+      lhsItem++;
+    }
+    while (rhsItem < rhsCtx.length && (lhsItem >= lhsCtx.length || rhsCtx.modified[rhsItem])) {
+      rhsItem++;
+    }
+    if (lhsStart < lhsItem || rhsStart < rhsItem) {
+      const lat = Math.min(lhsStart, lhsCtx.length ? lhsCtx.length - 1 : 0);
+      const rat = Math.min(rhsStart, rhsCtx.length ? rhsCtx.length - 1 : 0);
+      changes.push({
+        lhsPos: lat,
+        lhsDel: lhsItem - lhsStart,
+        rhsPos: rat,
+        rhsAdd: rhsItem - rhsStart
+      });
+    }
+  }
+  return changes;
+}
+function getShortestMiddleSnake(lhsCtx, lhsLower, lhsUpper, rhsCtx, rhsLower, rhsUpper, vectorU, vectorD) {
+  const max = lhsCtx.length + rhsCtx.length + 1;
+  const kdown = lhsLower - rhsLower;
+  const kup = lhsUpper - rhsUpper;
+  const delta = lhsUpper - lhsLower - (rhsUpper - rhsLower);
+  const odd = (delta & 1) != 0;
+  const offsetDown = max - kdown;
+  const offsetUp = max - kup;
+  const maxd = (lhsUpper - lhsLower + rhsUpper - rhsLower) / 2 + 1;
+  const ret = { x: 0, y: 0 };
+  let d;
+  let k;
+  let x;
+  let y;
+  vectorD[offsetDown + kdown + 1] = lhsLower;
+  vectorU[offsetUp + kup - 1] = lhsUpper;
+  for (d = 0; d <= maxd; ++d) {
+    for (k = kdown - d; k <= kdown + d; k += 2) {
+      if (k === kdown - d) {
+        x = vectorD[offsetDown + k + 1];
+      } else {
+        x = vectorD[offsetDown + k - 1] + 1;
+        if (k < kdown + d && vectorD[offsetDown + k + 1] >= x) {
+          x = vectorD[offsetDown + k + 1];
+        }
+      }
+      y = x - k;
+      while (x < lhsUpper && y < rhsUpper && lhsCtx.codes[x] === rhsCtx.codes[y]) {
+        x++;
+        y++;
+      }
+      vectorD[offsetDown + k] = x;
+      if (odd && kup - d < k && k < kup + d) {
+        if (vectorU[offsetUp + k] <= vectorD[offsetDown + k]) {
+          ret.x = vectorD[offsetDown + k];
+          ret.y = vectorD[offsetDown + k] - k;
+          return ret;
+        }
+      }
+    }
+    for (k = kup - d; k <= kup + d; k += 2) {
+      if (k === kup + d) {
+        x = vectorU[offsetUp + k - 1];
+      } else {
+        x = vectorU[offsetUp + k + 1] - 1;
+        if (k > kup - d && vectorU[offsetUp + k - 1] < x) {
+          x = vectorU[offsetUp + k - 1];
+        }
+      }
+      y = x - k;
+      while (x > lhsLower && y > rhsLower && lhsCtx.codes[x - 1] === rhsCtx.codes[y - 1]) {
+        x--;
+        y--;
+      }
+      vectorU[offsetUp + k] = x;
+      if (!odd && kdown - d <= k && k <= kdown + d) {
+        if (vectorU[offsetUp + k] <= vectorD[offsetDown + k]) {
+          ret.x = vectorD[offsetDown + k];
+          ret.y = vectorD[offsetDown + k] - k;
+          return ret;
+        }
+      }
+    }
+  }
+  fail("Unexpected state computing diff");
+}
+function getLongestCommonSubsequence(lhsCtx, lhsLower, lhsUpper, rhsCtx, rhsLower, rhsUpper, vectorU = [], vectorD = []) {
+  while (lhsLower < lhsUpper && rhsLower < rhsUpper && lhsCtx.codes[lhsLower] === rhsCtx.codes[rhsLower]) {
+    ++lhsLower;
+    ++rhsLower;
+  }
+  while (lhsLower < lhsUpper && rhsLower < rhsUpper && lhsCtx.codes[lhsUpper - 1] === rhsCtx.codes[rhsUpper - 1]) {
+    --lhsUpper;
+    --rhsUpper;
+  }
+  if (lhsLower === lhsUpper) {
+    while (rhsLower < rhsUpper) {
+      rhsCtx.modified[rhsLower++] = true;
+    }
+  } else if (rhsLower === rhsUpper) {
+    while (lhsLower < lhsUpper) {
+      lhsCtx.modified[lhsLower++] = true;
+    }
+  } else {
+    const { x, y } = getShortestMiddleSnake(
+      lhsCtx,
+      lhsLower,
+      lhsUpper,
+      rhsCtx,
+      rhsLower,
+      rhsUpper,
+      vectorU,
+      vectorD
+    );
+    getLongestCommonSubsequence(
+      lhsCtx,
+      lhsLower,
+      x,
+      rhsCtx,
+      rhsLower,
+      y,
+      vectorU,
+      vectorD
+    );
+    getLongestCommonSubsequence(
+      lhsCtx,
+      x,
+      lhsUpper,
+      rhsCtx,
+      y,
+      rhsUpper,
+      vectorU,
+      vectorD
+    );
+  }
+}
+var Context = class {
+  /** Keep a tab on modified items */
+  modified;
+  /** A _code table_ for all the items in this context */
+  codes;
+  /** The number of item held by this context */
+  length;
+  /** Construct with a _code table_ */
+  constructor(codes) {
+    const length = this.length = codes.length;
+    this.modified = new Array(length);
+    this.codes = codes;
+  }
+};
+var Coder = class {
+  _primitives = /* @__PURE__ */ new Map();
+  _objects = [];
+  _index = 1;
+  _getObjectCode(item) {
+    for (const [object, code2] of this._objects) {
+      if (isDeepStrictEqual(item, object))
+        return code2;
+    }
+    const code = ++this._index;
+    this._objects.push([item, code]);
+    return code;
+  }
+  _getPrimitiveCode(item) {
+    let code = this._primitives.get(item);
+    if (code)
+      return code;
+    code = ++this._index;
+    this._primitives.set(item, code);
+    return code;
+  }
+  /** Get the code table for an {@link Iterable} */
+  getCodes(iterable) {
+    const codes = [];
+    for (const item of iterable) {
+      const type = item === null ? "null" : typeof item;
+      const code = type === "object" ? this._getObjectCode(item) : this._getPrimitiveCode(item);
+      codes.push(code);
+    }
+    return codes;
+  }
+};
+var inspectOptions = {
+  showHidden: false,
+  depth: 10,
+  colors: false,
+  maxArrayLength: 100,
+  maxStringLength: 250,
+  breakLength: Infinity,
+  compact: false,
+  sorted: true,
+  getters: true
+};
+function diff(lhs, rhs) {
+  assert(lhs !== void 0, "Left-Hand side undefined");
+  assert(rhs !== void 0, "Right-Hand side undefined");
+  const codec = new Coder();
+  const lhsCtx = new Context(codec.getCodes(lhs));
+  const rhsCtx = new Context(codec.getCodes(rhs));
+  getLongestCommonSubsequence(
+    lhsCtx,
+    0,
+    lhsCtx.length,
+    rhsCtx,
+    0,
+    rhsCtx.length
+  );
+  return compareLongestCommonSubsequence(lhsCtx, rhsCtx);
+}
+function textDiff(lhs, rhs, add, del, not) {
+  const _add = add || (logOptions.colors ? $grn : (s) => `+ ${s}`);
+  const _del = del || (logOptions.colors ? $red : (s) => `- ${s}`);
+  const _not = not || (logOptions.colors ? (s) => s : (s) => `  ${s}`);
+  let lhsLines;
+  let rhsLines;
+  const lhsType = getTypeOf(lhs);
+  const rhsType = getTypeOf(rhs);
+  if (lhsType === "string" && rhsType === "string") {
+    lhsLines = lhs.split("\n");
+    rhsLines = rhs.split("\n");
+  } else {
+    lhsLines = inspect(lhs, inspectOptions).split("\n");
+    rhsLines = inspect(rhs, inspectOptions).split("\n");
+  }
+  const changes = diff(lhsLines, rhsLines);
+  if (changes.length === 0)
+    return "";
+  let offset = 0;
+  const result = [];
+  changes.forEach(({ lhsPos, lhsDel, rhsPos, rhsAdd }) => {
+    if (offset != lhsPos)
+      result.push(...lhsLines.slice(offset, lhsPos).map(_not));
+    if (lhsDel)
+      result.push(...lhsLines.slice(lhsPos, lhsPos + lhsDel).map(_del));
+    if (rhsAdd)
+      result.push(...rhsLines.slice(rhsPos, rhsPos + rhsAdd).map(_add));
+    offset = lhsPos + lhsDel;
+  });
+  if (offset < lhsLines.length)
+    result.push(...lhsLines.slice(offset).map(_not));
+  return result.join("\n");
+}
+export {
+  diff,
+  textDiff
+};
+//# sourceMappingURL=diff.mjs.map

package/dist/utils/diff.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/diff.ts"],
+  "mappings": "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",
+  "names": ["code"]
+}

package/dist/utils/types.cjs

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// utils/types.ts
+var types_exports = {};
+__export(types_exports, {
+  getTypeOf: () => getTypeOf
+});
+module.exports = __toCommonJS(types_exports);
+function getTypeOf(what) {
+  if (Array.isArray(what))
+    return "array";
+  if (what === null)
+    return "null";
+  return typeof what;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getTypeOf
+});
+//# sourceMappingURL=types.cjs.map

package/dist/utils/types.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/types.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMO,SAAS,UAAU,MAA0B;AAClD,MAAI,MAAM,QAAQ,IAAI;AAAG,WAAO;AAChC,MAAI,SAAS;AAAM,WAAO;AAC1B,SAAO,OAAO;AAChB;",
+  "names": []
+}

package/dist/utils/types.d.ts

@@ -0,0 +1,4 @@
+/** A type adding the values `null` or `array` to the result of `typeof` */
+export type BasicType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | 'null' | 'array';
+/** Get the _real_ type of a value, including `null` or `array` */
+export declare function getTypeOf(what: unknown): BasicType;

package/dist/utils/types.mjs

@@ -0,0 +1,12 @@
+// utils/types.ts
+function getTypeOf(what) {
+  if (Array.isArray(what))
+    return "array";
+  if (what === null)
+    return "null";
+  return typeof what;
+}
+export {
+  getTypeOf
+};
+//# sourceMappingURL=types.mjs.map

package/dist/utils/types.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/types.ts"],
+  "mappings": ";AAMO,SAAS,UAAU,MAA0B;AAClD,MAAI,MAAM,QAAQ,IAAI;AAAG,WAAO;AAChC,MAAI,SAAS;AAAM,WAAO;AAC1B,SAAO,OAAO;AAChB;",
+  "names": []
+}

package/dist/utils.cjs

@@ -17,8 +17,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // utils.ts
 var utils_exports = {};
 module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./utils/diff.cjs"), module.exports);
 __reExport(utils_exports, require("./utils/exec.cjs"), module.exports);
 __reExport(utils_exports, require("./utils/match.cjs"), module.exports);
 __reExport(utils_exports, require("./utils/options.cjs"), module.exports);
+__reExport(utils_exports, require("./utils/types.cjs"), module.exports);
 __reExport(utils_exports, require("./utils/walk.cjs"), module.exports);
 //# sourceMappingURL=utils.cjs.map

package/dist/utils.cjs.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../src/utils.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,6BAAd;AACA,0BAAc,8BADd;AAEA,0BAAc,gCAFd;AAGA,0BAAc,6BAHd;",
+  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,6BAAd;AACA,0BAAc,6BADd;AAEA,0BAAc,8BAFd;AAGA,0BAAc,gCAHd;AAIA,0BAAc,8BAJd;AAKA,0BAAc,6BALd;",
   "names": []
 }

package/dist/utils.d.ts

@@ -1,4 +1,6 @@
+export * from './utils/diff';
 export * from './utils/exec';
 export * from './utils/match';
 export * from './utils/options';
+export * from './utils/types';
 export * from './utils/walk';

package/dist/utils.mjs

@@ -1,6 +1,8 @@
 // utils.ts
+export * from "./utils/diff.mjs";
 export * from "./utils/exec.mjs";
 export * from "./utils/match.mjs";
 export * from "./utils/options.mjs";
+export * from "./utils/types.mjs";
 export * from "./utils/walk.mjs";
 //# sourceMappingURL=utils.mjs.map

package/dist/utils.mjs.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../src/utils.ts"],
-  "mappings": ";AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;",
+  "mappings": ";AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plugjs/plug",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "type": "commonjs",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",

package/src/utils/diff.ts

@@ -0,0 +1,360 @@
+import { fail } from 'node:assert'
+import { inspect, isDeepStrictEqual } from 'node:util'
+
+import { assert } from '../asserts'
+import { $grn, $red, logOptions } from '../logging'
+import { getTypeOf } from './types'
+
+import type { InspectOptions } from 'node:util'
+
+/* ========================================================================== *
+ * EXPORTED INTERFACES                                                        *
+ * ========================================================================== */
+
+/** Identifies a single change */
+export interface Change {
+  /** The position in the Left-Hand side where items were deleted */
+  lhsPos: number;
+  /** The number of items deleted from the Left-Hand side */
+  lhsDel: number;
+  /** The position in the Right-Hand side where items were added */
+  rhsPos: number;
+  /** The number of items added to the Right-Hand side */
+  rhsAdd: number;
+}
+
+/* ========================================================================== *
+ * MYERS IMPLEMENTATION                                                       *
+ * Lifted from https://github.com/wickedest/myers-diff/ (Apache 2.0)          *
+ * ========================================================================== */
+
+function compareLongestCommonSubsequence(lhsCtx: Context, rhsCtx: Context): Change[] {
+  let lhsStart = 0
+  let rhsStart = 0
+  let lhsItem = 0
+  let rhsItem = 0
+
+  const changes: Change[] = []
+
+  while (lhsItem < lhsCtx.length || rhsItem < rhsCtx.length) {
+    if (
+      (lhsItem < lhsCtx.length) && (!lhsCtx.modified[lhsItem]) &&
+      (rhsItem < rhsCtx.length) && (!rhsCtx.modified[rhsItem])
+    ) {
+      // equal lines
+      lhsItem++
+      rhsItem++
+      continue
+    }
+
+    // maybe deleted and/or inserted lines
+    lhsStart = lhsItem
+    rhsStart = rhsItem
+
+    while ((lhsItem < lhsCtx.length) &&
+      (rhsItem >= rhsCtx.length || lhsCtx.modified[lhsItem])) {
+      lhsItem++
+    }
+
+    while ((rhsItem < rhsCtx.length) &&
+      (lhsItem >= lhsCtx.length || rhsCtx.modified[rhsItem])) {
+      rhsItem++
+    }
+
+    if ((lhsStart < lhsItem) || (rhsStart < rhsItem)) {
+      const lat = Math.min(lhsStart, (lhsCtx.length) ? lhsCtx.length - 1 : 0)
+      const rat = Math.min(rhsStart, (rhsCtx.length) ? rhsCtx.length - 1 : 0)
+
+      changes.push({
+        lhsPos: lat,
+        lhsDel: lhsItem - lhsStart,
+        rhsPos: rat,
+        rhsAdd: rhsItem - rhsStart,
+      })
+    }
+  }
+
+  return changes
+}
+
+function getShortestMiddleSnake(
+    lhsCtx: Context, lhsLower: number, lhsUpper: number,
+    rhsCtx: Context, rhsLower: number, rhsUpper: number,
+    vectorU: number[], vectorD: number[],
+): { x: number, y: number } {
+  const max = lhsCtx.length + rhsCtx.length + 1
+
+  const kdown = lhsLower - rhsLower
+  const kup = lhsUpper - rhsUpper
+  const delta = (lhsUpper - lhsLower) - (rhsUpper - rhsLower)
+  const odd = (delta & 1) != 0
+  const offsetDown = max - kdown
+  const offsetUp = max - kup
+  const maxd = ((lhsUpper - lhsLower + rhsUpper - rhsLower) / 2) + 1
+  const ret = { x: 0, y: 0 }
+  let d: number
+  let k: number
+  let x: number
+  let y: number
+
+  vectorD[offsetDown + kdown + 1] = lhsLower
+  vectorU[offsetUp + kup - 1] = lhsUpper
+  for (d = 0; d <= maxd; ++d) {
+    for (k = kdown - d; k <= kdown + d; k += 2) {
+      if (k === kdown - d) {
+        x = vectorD[offsetDown + k + 1]! // down
+      } else {
+        x = vectorD[offsetDown + k - 1]! + 1 // right
+        if ((k < (kdown + d)) && (vectorD[offsetDown + k + 1]! >= x)) {
+          x = vectorD[offsetDown + k + 1]! // down
+        }
+      }
+      y = x - k
+      // find the end of the furthest reaching forward D-path in diagonal k.
+      while ((x < lhsUpper) &&
+        (y < rhsUpper) &&
+        (lhsCtx.codes[x] === rhsCtx.codes[y])
+      ) {
+        x++; y++
+      }
+      vectorD[offsetDown + k]! = x
+      // overlap ?
+      if (odd && (kup - d < k) && (k < kup + d)) {
+        if (vectorU[offsetUp + k]! <= vectorD[offsetDown + k]!) {
+          ret.x = vectorD[offsetDown + k]!
+          ret.y = vectorD[offsetDown + k]! - k
+          return (ret)
+        }
+      }
+    }
+    // Extend the reverse path.
+    for (k = kup - d; k <= kup + d; k += 2) {
+      // find the only or better starting point
+      if (k === kup + d) {
+        x = vectorU[offsetUp + k - 1]! // up
+      } else {
+        x = vectorU[offsetUp + k + 1]! - 1 // left
+        if ((k > kup - d) && (vectorU[offsetUp + k - 1]! < x)) {
+          x = vectorU[offsetUp + k - 1]!
+        } // up
+      }
+      y = x - k
+      while ((x > lhsLower) &&
+        (y > rhsLower) &&
+        (lhsCtx.codes[x - 1] === rhsCtx.codes[y - 1])
+      ) {
+        // diagonal
+        x--
+        y--
+      }
+      vectorU[offsetUp + k] = x
+      // overlap ?
+      if (!odd && (kdown - d <= k) && (k <= kdown + d)) {
+        if (vectorU[offsetUp + k]! <= vectorD[offsetDown + k]!) {
+          ret.x = vectorD[offsetDown + k]!
+          ret.y = vectorD[offsetDown + k]! - k
+          return (ret)
+        }
+      }
+    }
+  }
+
+  // coverage ignore next // we should never get here
+  fail('Unexpected state computing diff')
+}
+
+function getLongestCommonSubsequence(
+    lhsCtx: Context, lhsLower: number, lhsUpper: number,
+    rhsCtx: Context, rhsLower: number, rhsUpper: number,
+    vectorU = [], vectorD = [],
+): void {
+  // trim off the matching items at the beginning
+  while ( (lhsLower < lhsUpper) &&
+    (rhsLower < rhsUpper) &&
+    (lhsCtx.codes[lhsLower] === rhsCtx.codes[rhsLower]) ) {
+    ++lhsLower
+    ++rhsLower
+  }
+  // trim off the matching items at the end
+  while ( (lhsLower < lhsUpper) &&
+    (rhsLower < rhsUpper) &&
+    (lhsCtx.codes[lhsUpper - 1] === rhsCtx.codes[rhsUpper - 1]) ) {
+    --lhsUpper
+    --rhsUpper
+  }
+  if (lhsLower === lhsUpper) {
+    while (rhsLower < rhsUpper) {
+      rhsCtx.modified[rhsLower++] = true
+    }
+  } else if (rhsLower === rhsUpper) {
+    while (lhsLower < lhsUpper) {
+      lhsCtx.modified[lhsLower++] = true
+    }
+  } else {
+    const { x, y } = getShortestMiddleSnake(
+        lhsCtx, lhsLower, lhsUpper,
+        rhsCtx, rhsLower, rhsUpper,
+        vectorU, vectorD)
+    getLongestCommonSubsequence(
+        lhsCtx, lhsLower, x,
+        rhsCtx, rhsLower, y,
+        vectorU, vectorD)
+    getLongestCommonSubsequence(
+        lhsCtx, x, lhsUpper,
+        rhsCtx, y, rhsUpper,
+        vectorU, vectorD)
+  }
+}
+
+/* ========================================================================== *
+ * INTERNAL CLASSES                                                           *
+ * ========================================================================== */
+
+/** The context to use while executing the diff */
+class Context {
+  /** Keep a tab on modified items */
+  readonly modified: (true | undefined)[]
+  /** A _code table_ for all the items in this context */
+  readonly codes: readonly number[]
+  /** The number of item held by this context */
+  readonly length: number
+
+  /** Construct with a _code table_ */
+  constructor(codes: number[]) {
+    const length = this.length = codes.length
+    this.modified = new Array(length)
+    this.codes = codes
+  }
+}
+
+/** A codec producing _code tables_ */
+class Coder<T, I extends Iterable<T> = Iterable<T>> {
+  private _primitives = new Map<T, number>()
+  private _objects: [ T, number ][] = []
+  private _index = 1
+
+  private _getObjectCode(item: T): number {
+    for (const [ object, code ] of this._objects) {
+      if (isDeepStrictEqual(item, object)) return code
+    }
+
+    const code = ++ this._index
+    this._objects.push([ item, code ])
+    return code
+  }
+
+  private _getPrimitiveCode(item: T): number {
+    let code = this._primitives.get(item)
+    if (code) return code
+
+    code = ++ this._index
+    this._primitives.set(item, code)
+    return code
+  }
+
+  /** Get the code table for an {@link Iterable} */
+  getCodes(iterable: I): number[] {
+    const codes: number[] = []
+    for (const item of iterable) {
+      const type = item === null ? 'null' : typeof item
+
+      const code = type === 'object' ?
+        this._getObjectCode(item) :
+        this._getPrimitiveCode(item)
+
+      codes.push(code)
+    }
+
+    return codes
+  }
+}
+
+/** Shared constant for inspect options */
+const inspectOptions: InspectOptions = {
+  showHidden: false,
+  depth: 10,
+  colors: false,
+  maxArrayLength: 100,
+  maxStringLength: 250,
+  breakLength: Infinity,
+  compact: false,
+  sorted: true,
+  getters: true,
+}
+
+/* ========================================================================== *
+ * EXPORTED FUNCTIONS                                                         *
+ * ========================================================================== */
+
+/**
+ * Compare the _Left-Hand side_ {@link Iterable} to _Right-Hand side_ one,
+ * producing an array of {@link Change | Changes} identifying the differences.
+ */
+export function diff<T, I extends Iterable<T> = Iterable<T>>(
+    lhs: I,
+    rhs: I,
+): Change[] {
+  assert(lhs !== undefined, 'Left-Hand side undefined')
+  assert(rhs !== undefined, 'Right-Hand side undefined')
+
+  const codec = new Coder<T>()
+  const lhsCtx = new Context(codec.getCodes(lhs))
+  const rhsCtx = new Context(codec.getCodes(rhs))
+
+  getLongestCommonSubsequence(
+      lhsCtx, 0, lhsCtx.length,
+      rhsCtx, 0, rhsCtx.length,
+  )
+
+  return compareLongestCommonSubsequence(lhsCtx, rhsCtx)
+}
+
+/** Produce a textual diff between two values. */
+export function textDiff(
+    lhs: any,
+    rhs: any,
+    add?: (s: string) => string,
+    del?: (s: string) => string,
+    not?: (s: string) => string,
+): string {
+  // Defaults for our "add" "del" and "not" functions (depending on colorization)
+  const _add = add || (logOptions.colors ? $grn : (s: string): string => `+ ${s}`)
+  const _del = del || (logOptions.colors ? $red : (s: string): string => `- ${s}`)
+  const _not = not || (logOptions.colors ? (s: string): string => s : (s: string): string => `  ${s}`)
+
+  // We'll need two array of string lines to compare...
+  let lhsLines: string[]
+  let rhsLines: string[]
+
+  // Get the _real_ types of both arguments
+  const lhsType = getTypeOf(lhs)
+  const rhsType = getTypeOf(rhs)
+
+  // If _both_ arguments are strings, then just split and compare, otherwise
+  // we nuse NodeJS' inspect to prep their string version
+  if ((lhsType === 'string') && (rhsType === 'string')) {
+    lhsLines = lhs.split('\n')
+    rhsLines = rhs.split('\n')
+  } else {
+    lhsLines = inspect(lhs, inspectOptions).split('\n')
+    rhsLines = inspect(rhs, inspectOptions).split('\n')
+  }
+
+  // Calculate the difference between the two arrays of strings
+  const changes = diff(lhsLines, rhsLines)
+  if (changes.length === 0) return ''
+
+  // Go through changes and highlight
+  let offset = 0
+  const result: string[] = []
+  changes.forEach(({ lhsPos, lhsDel, rhsPos, rhsAdd }) => {
+    if (offset != lhsPos) result.push(...lhsLines.slice(offset, lhsPos).map(_not))
+    if (lhsDel) result.push(...lhsLines.slice(lhsPos, lhsPos + lhsDel).map(_del))
+    if (rhsAdd) result.push(...rhsLines.slice(rhsPos, rhsPos + rhsAdd).map(_add))
+    offset = lhsPos + lhsDel
+  })
+  if (offset < lhsLines.length) result.push(...lhsLines.slice(offset).map(_not))
+
+  // Join our results and return
+  return result.join('\n')
+}

package/src/utils/types.ts

@@ -0,0 +1,11 @@
+/** A type adding the values `null` or `array` to the result of `typeof` */
+export type BasicType =
+  | 'string' | 'number' | 'bigint' | 'boolean' | 'symbol'
+  | 'undefined' | 'object' | 'function' | 'null' | 'array'
+
+/** Get the _real_ type of a value, including `null` or `array` */
+export function getTypeOf(what: unknown): BasicType {
+  if (Array.isArray(what)) return 'array'
+  if (what === null) return 'null'
+  return typeof what
+}

package/src/utils.ts

@@ -1,4 +1,6 @@
+export * from './utils/diff'
 export * from './utils/exec'
 export * from './utils/match'
 export * from './utils/options'
+export * from './utils/types'
 export * from './utils/walk'