@forsakringskassan/docs-generator 2.27.1 → 2.28.0

package/dist/{vendor-DiqWVUfS.mjs → vendor-DxEOke6B.mjs}

@@ -16325,11 +16325,11 @@ function requireRegisterTs () {
 
 requireRegisterTs();
 
-function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty$1(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-function _defineProperty$1(obj, key, value) { key = _toPropertyKey$1(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey$1(arg) { var key = _toPrimitive$1(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive$1(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 const dedent = createDedent({});
 function createDedent(options) {
   dedent.withOptions = newOptions => createDedent(_objectSpread(_objectSpread({}, options), newOptions));
@@ -24468,13 +24468,14 @@ class Translator extends EventEmitter {
     if (lng) this.language = lng;
   }
   exists(key) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+    let o = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
       interpolation: {}
     };
-    if (key == null) {
-      return false;
-    }
-    const resolved = this.resolve(key, options);
+    const opt = {
+      ...o
+    };
+    if (key == null) return false;
+    const resolved = this.resolve(key, opt);
     return resolved?.res !== undefined;
   }
   extractFromKey(key, opt) {
@@ -24501,7 +24502,10 @@ class Translator extends EventEmitter {
       namespaces: isString(namespaces) ? [namespaces] : namespaces
     };
   }
-  translate(keys, opt, lastKey) {
+  translate(keys, o, lastKey) {
+    let opt = typeof o === 'object' ? {
+      ...o
+    } : o;
     if (typeof opt !== 'object' && this.options.overloadTranslationOptionHandler) {
       opt = this.options.overloadTranslationOptionHandler(arguments);
     }
@@ -24679,7 +24683,7 @@ class Translator extends EventEmitter {
       res = this.extendTranslation(res, keys, opt, resolved, lastKey);
       if (usedKey && res === key && this.options.appendNamespaceToMissingKey) res = `${namespace}:${key}`;
       if ((usedKey || usedDefault) && this.options.parseMissingKeyHandler) {
-        res = this.options.parseMissingKeyHandler(this.options.appendNamespaceToMissingKey ? `${namespace}:${key}` : key, usedDefault ? res : undefined);
+        res = this.options.parseMissingKeyHandler(this.options.appendNamespaceToMissingKey ? `${namespace}:${key}` : key, usedDefault ? res : undefined, opt);
       }
     }
     if (returnDetails) {
@@ -28554,366 +28558,425 @@ function deflist_plugin (md) {
   md.block.ruler.before('paragraph', 'deflist', deflist, { alt: ['paragraph', 'reference', 'blockquote'] });
 }
 
-function Diff() {}
-Diff.prototype = {
-  diff: function diff(oldString, newString) {
-    var _options$timeout;
-    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    var callback = options.callback;
-    if (typeof options === 'function') {
-      callback = options;
-      options = {};
-    }
-    var self = this;
-    function done(value) {
-      value = self.postProcess(value, options);
-      if (callback) {
-        setTimeout(function () {
-          callback(value);
-        }, 0);
-        return true;
-      } else {
-        return value;
-      }
+var Diff = /** @class */ (function () {
+    function Diff() {
     }
-
-    // Allow subclasses to massage the input prior to running
-    oldString = this.castInput(oldString, options);
-    newString = this.castInput(newString, options);
-    oldString = this.removeEmpty(this.tokenize(oldString, options));
-    newString = this.removeEmpty(this.tokenize(newString, options));
-    var newLen = newString.length,
-      oldLen = oldString.length;
-    var editLength = 1;
-    var maxEditLength = newLen + oldLen;
-    if (options.maxEditLength != null) {
-      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
-    }
-    var maxExecutionTime = (_options$timeout = options.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : Infinity;
-    var abortAfterTimestamp = Date.now() + maxExecutionTime;
-    var bestPath = [{
-      oldPos: -1,
-      lastComponent: undefined
-    }];
-
-    // Seed editLength = 0, i.e. the content starts with the same values
-    var newPos = this.extractCommon(bestPath[0], newString, oldString, 0, options);
-    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-      // Identity per the equality and tokenizer
-      return done(buildValues(self, bestPath[0].lastComponent, newString, oldString, self.useLongestToken));
-    }
-
-    // Once we hit the right edge of the edit graph on some diagonal k, we can
-    // definitely reach the end of the edit graph in no more than k edits, so
-    // there's no point in considering any moves to diagonal k+1 any more (from
-    // which we're guaranteed to need at least k+1 more edits).
-    // Similarly, once we've reached the bottom of the edit graph, there's no
-    // point considering moves to lower diagonals.
-    // We record this fact by setting minDiagonalToConsider and
-    // maxDiagonalToConsider to some finite value once we've hit the edge of
-    // the edit graph.
-    // This optimization is not faithful to the original algorithm presented in
-    // Myers's paper, which instead pointlessly extends D-paths off the end of
-    // the edit graph - see page 7 of Myers's paper which notes this point
-    // explicitly and illustrates it with a diagram. This has major performance
-    // implications for some common scenarios. For instance, to compute a diff
-    // where the new text simply appends d characters on the end of the
-    // original text of length n, the true Myers algorithm will take O(n+d^2)
-    // time while this optimization needs only O(n+d) time.
-    var minDiagonalToConsider = -Infinity,
-      maxDiagonalToConsider = Infinity;
-
-    // Main worker method. checks all permutations of a given edit length for acceptance.
-    function execEditLength() {
-      for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
-        var basePath = void 0;
-        var removePath = bestPath[diagonalPath - 1],
-          addPath = bestPath[diagonalPath + 1];
-        if (removePath) {
-          // No one else is going to attempt to use this value, clear it
-          bestPath[diagonalPath - 1] = undefined;
-        }
-        var canAdd = false;
-        if (addPath) {
-          // what newPos will be after we do an insertion:
-          var addPathNewPos = addPath.oldPos - diagonalPath;
-          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
-        }
-        var canRemove = removePath && removePath.oldPos + 1 < oldLen;
-        if (!canAdd && !canRemove) {
-          // If this path is a terminal then prune
-          bestPath[diagonalPath] = undefined;
-          continue;
+    Diff.prototype.diff = function (oldString, newString, 
+    // Type below is not accurate/complete - see above for full possibilities - but it compiles
+    options) {
+        if (options === void 0) { options = {}; }
+        var callback;
+        if (typeof options === 'function') {
+            callback = options;
+            options = {};
         }
-
-        // Select the diagonal that we want to branch from. We select the prior
-        // path whose position in the old string is the farthest from the origin
-        // and does not pass the bounds of the diff graph
-        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
-          basePath = self.addToPath(addPath, true, false, 0, options);
-        } else {
-          basePath = self.addToPath(removePath, false, true, 1, options);
+        else if ('callback' in options) {
+            callback = options.callback;
         }
-        newPos = self.extractCommon(basePath, newString, oldString, diagonalPath, options);
-        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-          // If we have hit the end of both strings, then we are done
-          return done(buildValues(self, basePath.lastComponent, newString, oldString, self.useLongestToken));
-        } else {
-          bestPath[diagonalPath] = basePath;
-          if (basePath.oldPos + 1 >= oldLen) {
-            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
-          }
-          if (newPos + 1 >= newLen) {
-            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
-          }
+        // Allow subclasses to massage the input prior to running
+        oldString = this.castInput(oldString, options);
+        newString = this.castInput(newString, options);
+        var oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+        var newTokens = this.removeEmpty(this.tokenize(newString, options));
+        return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+    };
+    Diff.prototype.diffWithOptionsObj = function (oldTokens, newTokens, options, callback) {
+        var _this = this;
+        var _a;
+        var done = function (value) {
+            value = _this.postProcess(value, options);
+            if (callback) {
+                setTimeout(function () { callback(value); }, 0);
+                return undefined;
+            }
+            else {
+                return value;
+            }
+        };
+        var newLen = newTokens.length, oldLen = oldTokens.length;
+        var editLength = 1;
+        var maxEditLength = newLen + oldLen;
+        if (options.maxEditLength != null) {
+            maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+        }
+        var maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
+        var abortAfterTimestamp = Date.now() + maxExecutionTime;
+        var bestPath = [{ oldPos: -1, lastComponent: undefined }];
+        // Seed editLength = 0, i.e. the content starts with the same values
+        var newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+        if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+            // Identity per the equality and tokenizer
+            return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+        }
+        // Once we hit the right edge of the edit graph on some diagonal k, we can
+        // definitely reach the end of the edit graph in no more than k edits, so
+        // there's no point in considering any moves to diagonal k+1 any more (from
+        // which we're guaranteed to need at least k+1 more edits).
+        // Similarly, once we've reached the bottom of the edit graph, there's no
+        // point considering moves to lower diagonals.
+        // We record this fact by setting minDiagonalToConsider and
+        // maxDiagonalToConsider to some finite value once we've hit the edge of
+        // the edit graph.
+        // This optimization is not faithful to the original algorithm presented in
+        // Myers's paper, which instead pointlessly extends D-paths off the end of
+        // the edit graph - see page 7 of Myers's paper which notes this point
+        // explicitly and illustrates it with a diagram. This has major performance
+        // implications for some common scenarios. For instance, to compute a diff
+        // where the new text simply appends d characters on the end of the
+        // original text of length n, the true Myers algorithm will take O(n+d^2)
+        // time while this optimization needs only O(n+d) time.
+        var minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+        // Main worker method. checks all permutations of a given edit length for acceptance.
+        var execEditLength = function () {
+            for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+                var basePath = void 0;
+                var removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+                if (removePath) {
+                    // No one else is going to attempt to use this value, clear it
+                    // @ts-expect-error - perf optimisation. This type-violating value will never be read.
+                    bestPath[diagonalPath - 1] = undefined;
+                }
+                var canAdd = false;
+                if (addPath) {
+                    // what newPos will be after we do an insertion:
+                    var addPathNewPos = addPath.oldPos - diagonalPath;
+                    canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+                }
+                var canRemove = removePath && removePath.oldPos + 1 < oldLen;
+                if (!canAdd && !canRemove) {
+                    // If this path is a terminal then prune
+                    // @ts-expect-error - perf optimisation. This type-violating value will never be read.
+                    bestPath[diagonalPath] = undefined;
+                    continue;
+                }
+                // Select the diagonal that we want to branch from. We select the prior
+                // path whose position in the old string is the farthest from the origin
+                // and does not pass the bounds of the diff graph
+                if (!canRemove || (canAdd && removePath.oldPos < addPath.oldPos)) {
+                    basePath = _this.addToPath(addPath, true, false, 0, options);
+                }
+                else {
+                    basePath = _this.addToPath(removePath, false, true, 1, options);
+                }
+                newPos = _this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+                if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+                    // If we have hit the end of both strings, then we are done
+                    return done(_this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+                }
+                else {
+                    bestPath[diagonalPath] = basePath;
+                    if (basePath.oldPos + 1 >= oldLen) {
+                        maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+                    }
+                    if (newPos + 1 >= newLen) {
+                        minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+                    }
+                }
+            }
+            editLength++;
+        };
+        // Performs the length of edit iteration. Is a bit fugly as this has to support the
+        // sync and async mode which is never fun. Loops over execEditLength until a value
+        // is produced, or until the edit length exceeds options.maxEditLength (if given),
+        // in which case it will return undefined.
+        if (callback) {
+            (function exec() {
+                setTimeout(function () {
+                    if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+                        return callback(undefined);
+                    }
+                    if (!execEditLength()) {
+                        exec();
+                    }
+                }, 0);
+            }());
         }
-      }
-      editLength++;
-    }
-
-    // Performs the length of edit iteration. Is a bit fugly as this has to support the
-    // sync and async mode which is never fun. Loops over execEditLength until a value
-    // is produced, or until the edit length exceeds options.maxEditLength (if given),
-    // in which case it will return undefined.
-    if (callback) {
-      (function exec() {
-        setTimeout(function () {
-          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
-            return callback();
-          }
-          if (!execEditLength()) {
-            exec();
-          }
-        }, 0);
-      })();
-    } else {
-      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
-        var ret = execEditLength();
-        if (ret) {
-          return ret;
+        else {
+            while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+                var ret = execEditLength();
+                if (ret) {
+                    return ret;
+                }
+            }
         }
-      }
-    }
-  },
-  addToPath: function addToPath(path, added, removed, oldPosInc, options) {
-    var last = path.lastComponent;
-    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
-      return {
-        oldPos: path.oldPos + oldPosInc,
-        lastComponent: {
-          count: last.count + 1,
-          added: added,
-          removed: removed,
-          previousComponent: last.previousComponent
+    };
+    Diff.prototype.addToPath = function (path, added, removed, oldPosInc, options) {
+        var last = path.lastComponent;
+        if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+            return {
+                oldPos: path.oldPos + oldPosInc,
+                lastComponent: { count: last.count + 1, added: added, removed: removed, previousComponent: last.previousComponent }
+            };
         }
-      };
-    } else {
-      return {
-        oldPos: path.oldPos + oldPosInc,
-        lastComponent: {
-          count: 1,
-          added: added,
-          removed: removed,
-          previousComponent: last
+        else {
+            return {
+                oldPos: path.oldPos + oldPosInc,
+                lastComponent: { count: 1, added: added, removed: removed, previousComponent: last }
+            };
         }
-      };
-    }
-  },
-  extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath, options) {
-    var newLen = newString.length,
-      oldLen = oldString.length,
-      oldPos = basePath.oldPos,
-      newPos = oldPos - diagonalPath,
-      commonCount = 0;
-    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldString[oldPos + 1], newString[newPos + 1], options)) {
-      newPos++;
-      oldPos++;
-      commonCount++;
-      if (options.oneChangePerToken) {
-        basePath.lastComponent = {
-          count: 1,
-          previousComponent: basePath.lastComponent,
-          added: false,
-          removed: false
-        };
-      }
-    }
-    if (commonCount && !options.oneChangePerToken) {
-      basePath.lastComponent = {
-        count: commonCount,
-        previousComponent: basePath.lastComponent,
-        added: false,
-        removed: false
-      };
-    }
-    basePath.oldPos = oldPos;
-    return newPos;
-  },
-  equals: function equals(left, right, options) {
-    if (options.comparator) {
-      return options.comparator(left, right);
-    } else {
-      return left === right || options.ignoreCase && left.toLowerCase() === right.toLowerCase();
-    }
-  },
-  removeEmpty: function removeEmpty(array) {
-    var ret = [];
-    for (var i = 0; i < array.length; i++) {
-      if (array[i]) {
-        ret.push(array[i]);
-      }
-    }
-    return ret;
-  },
-  castInput: function castInput(value) {
-    return value;
-  },
-  tokenize: function tokenize(value) {
-    return Array.from(value);
-  },
-  join: function join(chars) {
-    return chars.join('');
-  },
-  postProcess: function postProcess(changeObjects) {
-    return changeObjects;
-  }
-};
-function buildValues(diff, lastComponent, newString, oldString, useLongestToken) {
-  // First we convert our linked list of components in reverse order to an
-  // array in the right order:
-  var components = [];
-  var nextComponent;
-  while (lastComponent) {
-    components.push(lastComponent);
-    nextComponent = lastComponent.previousComponent;
-    delete lastComponent.previousComponent;
-    lastComponent = nextComponent;
-  }
-  components.reverse();
-  var componentPos = 0,
-    componentLen = components.length,
-    newPos = 0,
-    oldPos = 0;
-  for (; componentPos < componentLen; componentPos++) {
-    var component = components[componentPos];
-    if (!component.removed) {
-      if (!component.added && useLongestToken) {
-        var value = newString.slice(newPos, newPos + component.count);
-        value = value.map(function (value, i) {
-          var oldValue = oldString[oldPos + i];
-          return oldValue.length > value.length ? oldValue : value;
-        });
-        component.value = diff.join(value);
-      } else {
-        component.value = diff.join(newString.slice(newPos, newPos + component.count));
-      }
-      newPos += component.count;
-
-      // Common case
-      if (!component.added) {
-        oldPos += component.count;
-      }
-    } else {
-      component.value = diff.join(oldString.slice(oldPos, oldPos + component.count));
-      oldPos += component.count;
+    };
+    Diff.prototype.extractCommon = function (basePath, newTokens, oldTokens, diagonalPath, options) {
+        var newLen = newTokens.length, oldLen = oldTokens.length;
+        var oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+        while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+            newPos++;
+            oldPos++;
+            commonCount++;
+            if (options.oneChangePerToken) {
+                basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+            }
+        }
+        if (commonCount && !options.oneChangePerToken) {
+            basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+        }
+        basePath.oldPos = oldPos;
+        return newPos;
+    };
+    Diff.prototype.equals = function (left, right, options) {
+        if (options.comparator) {
+            return options.comparator(left, right);
+        }
+        else {
+            return left === right
+                || (!!options.ignoreCase && left.toLowerCase() === right.toLowerCase());
+        }
+    };
+    Diff.prototype.removeEmpty = function (array) {
+        var ret = [];
+        for (var i = 0; i < array.length; i++) {
+            if (array[i]) {
+                ret.push(array[i]);
+            }
+        }
+        return ret;
+    };
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    Diff.prototype.castInput = function (value, options) {
+        return value;
+    };
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    Diff.prototype.tokenize = function (value, options) {
+        return Array.from(value);
+    };
+    Diff.prototype.join = function (chars) {
+        // Assumes ValueT is string, which is the case for most subclasses.
+        // When it's false, e.g. in diffArrays, this method needs to be overridden (e.g. with a no-op)
+        // Yes, the casts are verbose and ugly, because this pattern - of having the base class SORT OF
+        // assume tokens and values are strings, but not completely - is weird and janky.
+        return chars.join('');
+    };
+    Diff.prototype.postProcess = function (changeObjects, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    options) {
+        return changeObjects;
+    };
+    Object.defineProperty(Diff.prototype, "useLongestToken", {
+        get: function () {
+            return false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Diff.prototype.buildValues = function (lastComponent, newTokens, oldTokens) {
+        // First we convert our linked list of components in reverse order to an
+        // array in the right order:
+        var components = [];
+        var nextComponent;
+        while (lastComponent) {
+            components.push(lastComponent);
+            nextComponent = lastComponent.previousComponent;
+            delete lastComponent.previousComponent;
+            lastComponent = nextComponent;
+        }
+        components.reverse();
+        var componentLen = components.length;
+        var componentPos = 0, newPos = 0, oldPos = 0;
+        for (; componentPos < componentLen; componentPos++) {
+            var component = components[componentPos];
+            if (!component.removed) {
+                if (!component.added && this.useLongestToken) {
+                    var value = newTokens.slice(newPos, newPos + component.count);
+                    value = value.map(function (value, i) {
+                        var oldValue = oldTokens[oldPos + i];
+                        return oldValue.length > value.length ? oldValue : value;
+                    });
+                    component.value = this.join(value);
+                }
+                else {
+                    component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+                }
+                newPos += component.count;
+                // Common case
+                if (!component.added) {
+                    oldPos += component.count;
+                }
+            }
+            else {
+                component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+                oldPos += component.count;
+            }
+        }
+        return components;
+    };
+    return Diff;
+}());
+
+var __extends$6 = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var CharacterDiff = /** @class */ (function (_super) {
+    __extends$6(CharacterDiff, _super);
+    function CharacterDiff() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-  }
-  return components;
-}
+    return CharacterDiff;
+}(Diff));
+new CharacterDiff();
 
 function longestCommonPrefix(str1, str2) {
-  var i;
-  for (i = 0; i < str1.length && i < str2.length; i++) {
-    if (str1[i] != str2[i]) {
-      return str1.slice(0, i);
+    var i;
+    for (i = 0; i < str1.length && i < str2.length; i++) {
+        if (str1[i] != str2[i]) {
+            return str1.slice(0, i);
+        }
     }
-  }
-  return str1.slice(0, i);
+    return str1.slice(0, i);
 }
 function longestCommonSuffix(str1, str2) {
-  var i;
-
-  // Unlike longestCommonPrefix, we need a special case to handle all scenarios
-  // where we return the empty string since str1.slice(-0) will return the
-  // entire string.
-  if (!str1 || !str2 || str1[str1.length - 1] != str2[str2.length - 1]) {
-    return '';
-  }
-  for (i = 0; i < str1.length && i < str2.length; i++) {
-    if (str1[str1.length - (i + 1)] != str2[str2.length - (i + 1)]) {
-      return str1.slice(-i);
+    var i;
+    // Unlike longestCommonPrefix, we need a special case to handle all scenarios
+    // where we return the empty string since str1.slice(-0) will return the
+    // entire string.
+    if (!str1 || !str2 || str1[str1.length - 1] != str2[str2.length - 1]) {
+        return '';
     }
-  }
-  return str1.slice(-i);
+    for (i = 0; i < str1.length && i < str2.length; i++) {
+        if (str1[str1.length - (i + 1)] != str2[str2.length - (i + 1)]) {
+            return str1.slice(-i);
+        }
+    }
+    return str1.slice(-i);
 }
 function replacePrefix(string, oldPrefix, newPrefix) {
-  if (string.slice(0, oldPrefix.length) != oldPrefix) {
-    throw Error("string ".concat(JSON.stringify(string), " doesn't start with prefix ").concat(JSON.stringify(oldPrefix), "; this is a bug"));
-  }
-  return newPrefix + string.slice(oldPrefix.length);
+    if (string.slice(0, oldPrefix.length) != oldPrefix) {
+        throw Error("string ".concat(JSON.stringify(string), " doesn't start with prefix ").concat(JSON.stringify(oldPrefix), "; this is a bug"));
+    }
+    return newPrefix + string.slice(oldPrefix.length);
 }
 function replaceSuffix(string, oldSuffix, newSuffix) {
-  if (!oldSuffix) {
-    return string + newSuffix;
-  }
-  if (string.slice(-oldSuffix.length) != oldSuffix) {
-    throw Error("string ".concat(JSON.stringify(string), " doesn't end with suffix ").concat(JSON.stringify(oldSuffix), "; this is a bug"));
-  }
-  return string.slice(0, -oldSuffix.length) + newSuffix;
+    if (!oldSuffix) {
+        return string + newSuffix;
+    }
+    if (string.slice(-oldSuffix.length) != oldSuffix) {
+        throw Error("string ".concat(JSON.stringify(string), " doesn't end with suffix ").concat(JSON.stringify(oldSuffix), "; this is a bug"));
+    }
+    return string.slice(0, -oldSuffix.length) + newSuffix;
 }
 function removePrefix(string, oldPrefix) {
-  return replacePrefix(string, oldPrefix, '');
+    return replacePrefix(string, oldPrefix, '');
 }
 function removeSuffix(string, oldSuffix) {
-  return replaceSuffix(string, oldSuffix, '');
+    return replaceSuffix(string, oldSuffix, '');
 }
 function maximumOverlap(string1, string2) {
-  return string2.slice(0, overlapCount(string1, string2));
+    return string2.slice(0, overlapCount(string1, string2));
 }
-
 // Nicked from https://stackoverflow.com/a/60422853/1709587
 function overlapCount(a, b) {
-  // Deal with cases where the strings differ in length
-  var startA = 0;
-  if (a.length > b.length) {
-    startA = a.length - b.length;
-  }
-  var endB = b.length;
-  if (a.length < b.length) {
-    endB = a.length;
-  }
-  // Create a back-reference for each index
-  //   that should be followed in case of a mismatch.
-  //   We only need B to make these references:
-  var map = Array(endB);
-  var k = 0; // Index that lags behind j
-  map[0] = 0;
-  for (var j = 1; j < endB; j++) {
-    if (b[j] == b[k]) {
-      map[j] = map[k]; // skip over the same character (optional optimisation)
-    } else {
-      map[j] = k;
+    // Deal with cases where the strings differ in length
+    var startA = 0;
+    if (a.length > b.length) {
+        startA = a.length - b.length;
     }
-    while (k > 0 && b[j] != b[k]) {
-      k = map[k];
-    }
-    if (b[j] == b[k]) {
-      k++;
-    }
-  }
-  // Phase 2: use these references while iterating over A
-  k = 0;
-  for (var i = startA; i < a.length; i++) {
-    while (k > 0 && a[i] != b[k]) {
-      k = map[k];
-    }
-    if (a[i] == b[k]) {
-      k++;
+    var endB = b.length;
+    if (a.length < b.length) {
+        endB = a.length;
+    }
+    // Create a back-reference for each index
+    //   that should be followed in case of a mismatch.
+    //   We only need B to make these references:
+    var map = Array(endB);
+    var k = 0; // Index that lags behind j
+    map[0] = 0;
+    for (var j = 1; j < endB; j++) {
+        if (b[j] == b[k]) {
+            map[j] = map[k]; // skip over the same character (optional optimisation)
+        }
+        else {
+            map[j] = k;
+        }
+        while (k > 0 && b[j] != b[k]) {
+            k = map[k];
+        }
+        if (b[j] == b[k]) {
+            k++;
+        }
+    }
+    // Phase 2: use these references while iterating over A
+    k = 0;
+    for (var i = startA; i < a.length; i++) {
+        while (k > 0 && a[i] != b[k]) {
+            k = map[k];
+        }
+        if (a[i] == b[k]) {
+            k++;
+        }
+    }
+    return k;
+}
+function trailingWs(string) {
+    // Yes, this looks overcomplicated and dumb - why not replace the whole function with
+    //     return string match(/\s*$/)[0]
+    // you ask? Because:
+    // 1. the trap described at https://markamery.com/blog/quadratic-time-regexes/ would mean doing
+    //    this would cause this function to take O(n²) time in the worst case (specifically when
+    //    there is a massive run of NON-TRAILING whitespace in `string`), and
+    // 2. the fix proposed in the same blog post, of using a negative lookbehind, is incompatible
+    //    with old Safari versions that we'd like to not break if possible (see
+    //    https://github.com/kpdecker/jsdiff/pull/550)
+    // It feels absurd to do this with an explicit loop instead of a regex, but I really can't see a
+    // better way that doesn't result in broken behaviour.
+    var i;
+    for (i = string.length - 1; i >= 0; i--) {
+        if (!string[i].match(/\s/)) {
+            break;
+        }
     }
-  }
-  return k;
+    return string.substring(i + 1);
+}
+function leadingWs(string) {
+    // Thankfully the annoying considerations described in trailingWs don't apply here:
+    var match = string.match(/^\s*/);
+    return match ? match[0] : '';
 }
 
+var __extends$5 = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 // Based on https://en.wikipedia.org/wiki/Latin_script_in_Unicode
 //
 // Ranges and exceptions:
@@ -28932,8 +28995,7 @@ function overlapCount(a, b) {
 //  - U+02DC  ˜ &#732;  Small Tilde
 //  - U+02DD  ˝ &#733;  Double Acute Accent
 // Latin Extended Additional, 1E00–1EFF
-var extendedWordChars = "a-zA-Z0-9_\\u{C0}-\\u{FF}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}";
-
+var extendedWordChars = 'a-zA-Z0-9_\\u{C0}-\\u{FF}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}';
 // Each token is one of the following:
 // - A punctuation mark plus the surrounding whitespace
 // - A word plus the surrounding whitespace
@@ -28954,652 +29016,737 @@ var extendedWordChars = "a-zA-Z0-9_\\u{C0}-\\u{FF}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6
 //
 // Keeping the surrounding whitespace of course has implications for .equals
 // and .join, not just .tokenize.
-
 // This regex does NOT fully implement the tokenization rules described above.
 // Instead, it gives runs of whitespace their own "token". The tokenize method
 // then handles stitching whitespace tokens onto adjacent word or punctuation
 // tokens.
 var tokenizeIncludingWhitespace = new RegExp("[".concat(extendedWordChars, "]+|\\s+|[^").concat(extendedWordChars, "]"), 'ug');
-var wordDiff = new Diff();
-wordDiff.equals = function (left, right, options) {
-  if (options.ignoreCase) {
-    left = left.toLowerCase();
-    right = right.toLowerCase();
-  }
-  return left.trim() === right.trim();
-};
-wordDiff.tokenize = function (value) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var parts;
-  if (options.intlSegmenter) {
-    if (options.intlSegmenter.resolvedOptions().granularity != 'word') {
-      throw new Error('The segmenter passed must have a granularity of "word"');
-    }
-    parts = Array.from(options.intlSegmenter.segment(value), function (segment) {
-      return segment.segment;
-    });
-  } else {
-    parts = value.match(tokenizeIncludingWhitespace) || [];
-  }
-  var tokens = [];
-  var prevPart = null;
-  parts.forEach(function (part) {
-    if (/\s/.test(part)) {
-      if (prevPart == null) {
-        tokens.push(part);
-      } else {
-        tokens.push(tokens.pop() + part);
-      }
-    } else if (/\s/.test(prevPart)) {
-      if (tokens[tokens.length - 1] == prevPart) {
-        tokens.push(tokens.pop() + part);
-      } else {
-        tokens.push(prevPart + part);
-      }
-    } else {
-      tokens.push(part);
+var WordDiff = /** @class */ (function (_super) {
+    __extends$5(WordDiff, _super);
+    function WordDiff() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-    prevPart = part;
-  });
-  return tokens;
-};
-wordDiff.join = function (tokens) {
-  // Tokens being joined here will always have appeared consecutively in the
-  // same text, so we can simply strip off the leading whitespace from all the
-  // tokens except the first (and except any whitespace-only tokens - but such
-  // a token will always be the first and only token anyway) and then join them
-  // and the whitespace around words and punctuation will end up correct.
-  return tokens.map(function (token, i) {
-    if (i == 0) {
-      return token;
-    } else {
-      return token.replace(/^\s+/, '');
-    }
-  }).join('');
-};
-wordDiff.postProcess = function (changes, options) {
-  if (!changes || options.oneChangePerToken) {
-    return changes;
-  }
-  var lastKeep = null;
-  // Change objects representing any insertion or deletion since the last
-  // "keep" change object. There can be at most one of each.
-  var insertion = null;
-  var deletion = null;
-  changes.forEach(function (change) {
-    if (change.added) {
-      insertion = change;
-    } else if (change.removed) {
-      deletion = change;
-    } else {
-      if (insertion || deletion) {
-        // May be false at start of text
-        dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);
-      }
-      lastKeep = change;
-      insertion = null;
-      deletion = null;
-    }
-  });
-  if (insertion || deletion) {
-    dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);
-  }
-  return changes;
-};
+    WordDiff.prototype.equals = function (left, right, options) {
+        if (options.ignoreCase) {
+            left = left.toLowerCase();
+            right = right.toLowerCase();
+        }
+        return left.trim() === right.trim();
+    };
+    WordDiff.prototype.tokenize = function (value, options) {
+        if (options === void 0) { options = {}; }
+        var parts;
+        if (options.intlSegmenter) {
+            var segmenter = options.intlSegmenter;
+            if (segmenter.resolvedOptions().granularity != 'word') {
+                throw new Error('The segmenter passed must have a granularity of "word"');
+            }
+            parts = Array.from(segmenter.segment(value), function (segment) { return segment.segment; });
+        }
+        else {
+            parts = value.match(tokenizeIncludingWhitespace) || [];
+        }
+        var tokens = [];
+        var prevPart = null;
+        parts.forEach(function (part) {
+            if ((/\s/).test(part)) {
+                if (prevPart == null) {
+                    tokens.push(part);
+                }
+                else {
+                    tokens.push(tokens.pop() + part);
+                }
+            }
+            else if (prevPart != null && (/\s/).test(prevPart)) {
+                if (tokens[tokens.length - 1] == prevPart) {
+                    tokens.push(tokens.pop() + part);
+                }
+                else {
+                    tokens.push(prevPart + part);
+                }
+            }
+            else {
+                tokens.push(part);
+            }
+            prevPart = part;
+        });
+        return tokens;
+    };
+    WordDiff.prototype.join = function (tokens) {
+        // Tokens being joined here will always have appeared consecutively in the
+        // same text, so we can simply strip off the leading whitespace from all the
+        // tokens except the first (and except any whitespace-only tokens - but such
+        // a token will always be the first and only token anyway) and then join them
+        // and the whitespace around words and punctuation will end up correct.
+        return tokens.map(function (token, i) {
+            if (i == 0) {
+                return token;
+            }
+            else {
+                return token.replace((/^\s+/), '');
+            }
+        }).join('');
+    };
+    WordDiff.prototype.postProcess = function (changes, options) {
+        if (!changes || options.oneChangePerToken) {
+            return changes;
+        }
+        var lastKeep = null;
+        // Change objects representing any insertion or deletion since the last
+        // "keep" change object. There can be at most one of each.
+        var insertion = null;
+        var deletion = null;
+        changes.forEach(function (change) {
+            if (change.added) {
+                insertion = change;
+            }
+            else if (change.removed) {
+                deletion = change;
+            }
+            else {
+                if (insertion || deletion) { // May be false at start of text
+                    dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);
+                }
+                lastKeep = change;
+                insertion = null;
+                deletion = null;
+            }
+        });
+        if (insertion || deletion) {
+            dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);
+        }
+        return changes;
+    };
+    return WordDiff;
+}(Diff));
+new WordDiff();
 function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep) {
-  // Before returning, we tidy up the leading and trailing whitespace of the
-  // change objects to eliminate cases where trailing whitespace in one object
-  // is repeated as leading whitespace in the next.
-  // Below are examples of the outcomes we want here to explain the code.
-  // I=insert, K=keep, D=delete
-  // 1. diffing 'foo bar baz' vs 'foo baz'
-  //    Prior to cleanup, we have K:'foo ' D:' bar ' K:' baz'
-  //    After cleanup, we want:   K:'foo ' D:'bar ' K:'baz'
-  //
-  // 2. Diffing 'foo bar baz' vs 'foo qux baz'
-  //    Prior to cleanup, we have K:'foo ' D:' bar ' I:' qux ' K:' baz'
-  //    After cleanup, we want K:'foo ' D:'bar' I:'qux' K:' baz'
-  //
-  // 3. Diffing 'foo\nbar baz' vs 'foo baz'
-  //    Prior to cleanup, we have K:'foo ' D:'\nbar ' K:' baz'
-  //    After cleanup, we want K'foo' D:'\nbar' K:' baz'
-  //
-  // 4. Diffing 'foo baz' vs 'foo\nbar baz'
-  //    Prior to cleanup, we have K:'foo\n' I:'\nbar ' K:' baz'
-  //    After cleanup, we ideally want K'foo' I:'\nbar' K:' baz'
-  //    but don't actually manage this currently (the pre-cleanup change
-  //    objects don't contain enough information to make it possible).
-  //
-  // 5. Diffing 'foo   bar baz' vs 'foo  baz'
-  //    Prior to cleanup, we have K:'foo  ' D:'   bar ' K:'  baz'
-  //    After cleanup, we want K:'foo  ' D:' bar ' K:'baz'
-  //
-  // Our handling is unavoidably imperfect in the case where there's a single
-  // indel between keeps and the whitespace has changed. For instance, consider
-  // diffing 'foo\tbar\nbaz' vs 'foo baz'. Unless we create an extra change
-  // object to represent the insertion of the space character (which isn't even
-  // a token), we have no way to avoid losing information about the texts'
-  // original whitespace in the result we return. Still, we do our best to
-  // output something that will look sensible if we e.g. print it with
-  // insertions in green and deletions in red.
-
-  // Between two "keep" change objects (or before the first or after the last
-  // change object), we can have either:
-  // * A "delete" followed by an "insert"
-  // * Just an "insert"
-  // * Just a "delete"
-  // We handle the three cases separately.
-  if (deletion && insertion) {
-    var oldWsPrefix = deletion.value.match(/^\s*/)[0];
-    var oldWsSuffix = deletion.value.match(/\s*$/)[0];
-    var newWsPrefix = insertion.value.match(/^\s*/)[0];
-    var newWsSuffix = insertion.value.match(/\s*$/)[0];
-    if (startKeep) {
-      var commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
-      startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
-      deletion.value = removePrefix(deletion.value, commonWsPrefix);
-      insertion.value = removePrefix(insertion.value, commonWsPrefix);
-    }
-    if (endKeep) {
-      var commonWsSuffix = longestCommonSuffix(oldWsSuffix, newWsSuffix);
-      endKeep.value = replacePrefix(endKeep.value, newWsSuffix, commonWsSuffix);
-      deletion.value = removeSuffix(deletion.value, commonWsSuffix);
-      insertion.value = removeSuffix(insertion.value, commonWsSuffix);
-    }
-  } else if (insertion) {
-    // The whitespaces all reflect what was in the new text rather than
-    // the old, so we essentially have no information about whitespace
-    // insertion or deletion. We just want to dedupe the whitespace.
-    // We do that by having each change object keep its trailing
-    // whitespace and deleting duplicate leading whitespace where
-    // present.
-    if (startKeep) {
-      insertion.value = insertion.value.replace(/^\s*/, '');
-    }
-    if (endKeep) {
-      endKeep.value = endKeep.value.replace(/^\s*/, '');
-    }
-    // otherwise we've got a deletion and no insertion
-  } else if (startKeep && endKeep) {
-    var newWsFull = endKeep.value.match(/^\s*/)[0],
-      delWsStart = deletion.value.match(/^\s*/)[0],
-      delWsEnd = deletion.value.match(/\s*$/)[0];
-
-    // Any whitespace that comes straight after startKeep in both the old and
-    // new texts, assign to startKeep and remove from the deletion.
-    var newWsStart = longestCommonPrefix(newWsFull, delWsStart);
-    deletion.value = removePrefix(deletion.value, newWsStart);
-
-    // Any whitespace that comes straight before endKeep in both the old and
-    // new texts, and hasn't already been assigned to startKeep, assign to
-    // endKeep and remove from the deletion.
-    var newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
-    deletion.value = removeSuffix(deletion.value, newWsEnd);
-    endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd);
-
-    // If there's any whitespace from the new text that HASN'T already been
-    // assigned, assign it to the start:
-    startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
-  } else if (endKeep) {
-    // We are at the start of the text. Preserve all the whitespace on
-    // endKeep, and just remove whitespace from the end of deletion to the
-    // extent that it overlaps with the start of endKeep.
-    var endKeepWsPrefix = endKeep.value.match(/^\s*/)[0];
-    var deletionWsSuffix = deletion.value.match(/\s*$/)[0];
-    var overlap = maximumOverlap(deletionWsSuffix, endKeepWsPrefix);
-    deletion.value = removeSuffix(deletion.value, overlap);
-  } else if (startKeep) {
-    // We are at the END of the text. Preserve all the whitespace on
-    // startKeep, and just remove whitespace from the start of deletion to
-    // the extent that it overlaps with the end of startKeep.
-    var startKeepWsSuffix = startKeep.value.match(/\s*$/)[0];
-    var deletionWsPrefix = deletion.value.match(/^\s*/)[0];
-    var _overlap = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
-    deletion.value = removePrefix(deletion.value, _overlap);
-  }
-}
-var wordWithSpaceDiff = new Diff();
-wordWithSpaceDiff.tokenize = function (value) {
-  // Slightly different to the tokenizeIncludingWhitespace regex used above in
-  // that this one treats each individual newline as a distinct tokens, rather
-  // than merging them into other surrounding whitespace. This was requested
-  // in https://github.com/kpdecker/jsdiff/issues/180 &
-  //    https://github.com/kpdecker/jsdiff/issues/211
-  var regex = new RegExp("(\\r?\\n)|[".concat(extendedWordChars, "]+|[^\\S\\n\\r]+|[^").concat(extendedWordChars, "]"), 'ug');
-  return value.match(regex) || [];
-};
-
-var lineDiff = new Diff();
-lineDiff.tokenize = function (value, options) {
-  if (options.stripTrailingCr) {
-    // remove one \r before \n to match GNU diff's --strip-trailing-cr behavior
-    value = value.replace(/\r\n/g, '\n');
-  }
-  var retLines = [],
-    linesAndNewlines = value.split(/(\n|\r\n)/);
-
-  // Ignore the final empty token that occurs if the string ends with a new line
-  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
-    linesAndNewlines.pop();
-  }
-
-  // Merge the content and line separators into single tokens
-  for (var i = 0; i < linesAndNewlines.length; i++) {
-    var line = linesAndNewlines[i];
-    if (i % 2 && !options.newlineIsToken) {
-      retLines[retLines.length - 1] += line;
-    } else {
-      retLines.push(line);
+    // Before returning, we tidy up the leading and trailing whitespace of the
+    // change objects to eliminate cases where trailing whitespace in one object
+    // is repeated as leading whitespace in the next.
+    // Below are examples of the outcomes we want here to explain the code.
+    // I=insert, K=keep, D=delete
+    // 1. diffing 'foo bar baz' vs 'foo baz'
+    //    Prior to cleanup, we have K:'foo ' D:' bar ' K:' baz'
+    //    After cleanup, we want:   K:'foo ' D:'bar ' K:'baz'
+    //
+    // 2. Diffing 'foo bar baz' vs 'foo qux baz'
+    //    Prior to cleanup, we have K:'foo ' D:' bar ' I:' qux ' K:' baz'
+    //    After cleanup, we want K:'foo ' D:'bar' I:'qux' K:' baz'
+    //
+    // 3. Diffing 'foo\nbar baz' vs 'foo baz'
+    //    Prior to cleanup, we have K:'foo ' D:'\nbar ' K:' baz'
+    //    After cleanup, we want K'foo' D:'\nbar' K:' baz'
+    //
+    // 4. Diffing 'foo baz' vs 'foo\nbar baz'
+    //    Prior to cleanup, we have K:'foo\n' I:'\nbar ' K:' baz'
+    //    After cleanup, we ideally want K'foo' I:'\nbar' K:' baz'
+    //    but don't actually manage this currently (the pre-cleanup change
+    //    objects don't contain enough information to make it possible).
+    //
+    // 5. Diffing 'foo   bar baz' vs 'foo  baz'
+    //    Prior to cleanup, we have K:'foo  ' D:'   bar ' K:'  baz'
+    //    After cleanup, we want K:'foo  ' D:' bar ' K:'baz'
+    //
+    // Our handling is unavoidably imperfect in the case where there's a single
+    // indel between keeps and the whitespace has changed. For instance, consider
+    // diffing 'foo\tbar\nbaz' vs 'foo baz'. Unless we create an extra change
+    // object to represent the insertion of the space character (which isn't even
+    // a token), we have no way to avoid losing information about the texts'
+    // original whitespace in the result we return. Still, we do our best to
+    // output something that will look sensible if we e.g. print it with
+    // insertions in green and deletions in red.
+    // Between two "keep" change objects (or before the first or after the last
+    // change object), we can have either:
+    // * A "delete" followed by an "insert"
+    // * Just an "insert"
+    // * Just a "delete"
+    // We handle the three cases separately.
+    if (deletion && insertion) {
+        var oldWsPrefix = leadingWs(deletion.value);
+        var oldWsSuffix = trailingWs(deletion.value);
+        var newWsPrefix = leadingWs(insertion.value);
+        var newWsSuffix = trailingWs(insertion.value);
+        if (startKeep) {
+            var commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
+            startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
+            deletion.value = removePrefix(deletion.value, commonWsPrefix);
+            insertion.value = removePrefix(insertion.value, commonWsPrefix);
+        }
+        if (endKeep) {
+            var commonWsSuffix = longestCommonSuffix(oldWsSuffix, newWsSuffix);
+            endKeep.value = replacePrefix(endKeep.value, newWsSuffix, commonWsSuffix);
+            deletion.value = removeSuffix(deletion.value, commonWsSuffix);
+            insertion.value = removeSuffix(insertion.value, commonWsSuffix);
+        }
+    }
+    else if (insertion) {
+        // The whitespaces all reflect what was in the new text rather than
+        // the old, so we essentially have no information about whitespace
+        // insertion or deletion. We just want to dedupe the whitespace.
+        // We do that by having each change object keep its trailing
+        // whitespace and deleting duplicate leading whitespace where
+        // present.
+        if (startKeep) {
+            var ws = leadingWs(insertion.value);
+            insertion.value = insertion.value.substring(ws.length);
+        }
+        if (endKeep) {
+            var ws = leadingWs(endKeep.value);
+            endKeep.value = endKeep.value.substring(ws.length);
+        }
+        // otherwise we've got a deletion and no insertion
+    }
+    else if (startKeep && endKeep) {
+        var newWsFull = leadingWs(endKeep.value), delWsStart = leadingWs(deletion.value), delWsEnd = trailingWs(deletion.value);
+        // Any whitespace that comes straight after startKeep in both the old and
+        // new texts, assign to startKeep and remove from the deletion.
+        var newWsStart = longestCommonPrefix(newWsFull, delWsStart);
+        deletion.value = removePrefix(deletion.value, newWsStart);
+        // Any whitespace that comes straight before endKeep in both the old and
+        // new texts, and hasn't already been assigned to startKeep, assign to
+        // endKeep and remove from the deletion.
+        var newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
+        deletion.value = removeSuffix(deletion.value, newWsEnd);
+        endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd);
+        // If there's any whitespace from the new text that HASN'T already been
+        // assigned, assign it to the start:
+        startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
+    }
+    else if (endKeep) {
+        // We are at the start of the text. Preserve all the whitespace on
+        // endKeep, and just remove whitespace from the end of deletion to the
+        // extent that it overlaps with the start of endKeep.
+        var endKeepWsPrefix = leadingWs(endKeep.value);
+        var deletionWsSuffix = trailingWs(deletion.value);
+        var overlap = maximumOverlap(deletionWsSuffix, endKeepWsPrefix);
+        deletion.value = removeSuffix(deletion.value, overlap);
+    }
+    else if (startKeep) {
+        // We are at the END of the text. Preserve all the whitespace on
+        // startKeep, and just remove whitespace from the start of deletion to
+        // the extent that it overlaps with the end of startKeep.
+        var startKeepWsSuffix = trailingWs(startKeep.value);
+        var deletionWsPrefix = leadingWs(deletion.value);
+        var overlap = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
+        deletion.value = removePrefix(deletion.value, overlap);
+    }
+}
+var WordsWithSpaceDiff = /** @class */ (function (_super) {
+    __extends$5(WordsWithSpaceDiff, _super);
+    function WordsWithSpaceDiff() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    WordsWithSpaceDiff.prototype.tokenize = function (value) {
+        // Slightly different to the tokenizeIncludingWhitespace regex used above in
+        // that this one treats each individual newline as a distinct tokens, rather
+        // than merging them into other surrounding whitespace. This was requested
+        // in https://github.com/kpdecker/jsdiff/issues/180 &
+        //    https://github.com/kpdecker/jsdiff/issues/211
+        var regex = new RegExp("(\\r?\\n)|[".concat(extendedWordChars, "]+|[^\\S\\n\\r]+|[^").concat(extendedWordChars, "]"), 'ug');
+        return value.match(regex) || [];
+    };
+    return WordsWithSpaceDiff;
+}(Diff));
+new WordsWithSpaceDiff();
+
+var __extends$4 = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var LineDiff = /** @class */ (function (_super) {
+    __extends$4(LineDiff, _super);
+    function LineDiff() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.tokenize = tokenize;
+        return _this;
     }
-  }
-  return retLines;
-};
-lineDiff.equals = function (left, right, options) {
-  // If we're ignoring whitespace, we need to normalise lines by stripping
-  // whitespace before checking equality. (This has an annoying interaction
-  // with newlineIsToken that requires special handling: if newlines get their
-  // own token, then we DON'T want to trim the *newline* tokens down to empty
-  // strings, since this would cause us to treat whitespace-only line content
-  // as equal to a separator between lines, which would be weird and
-  // inconsistent with the documented behavior of the options.)
-  if (options.ignoreWhitespace) {
-    if (!options.newlineIsToken || !left.includes('\n')) {
-      left = left.trim();
-    }
-    if (!options.newlineIsToken || !right.includes('\n')) {
-      right = right.trim();
-    }
-  } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
-    if (left.endsWith('\n')) {
-      left = left.slice(0, -1);
-    }
-    if (right.endsWith('\n')) {
-      right = right.slice(0, -1);
-    }
-  }
-  return Diff.prototype.equals.call(this, left, right, options);
-};
-function diffLines(oldStr, newStr, callback) {
-  return lineDiff.diff(oldStr, newStr, callback);
+    LineDiff.prototype.equals = function (left, right, options) {
+        // If we're ignoring whitespace, we need to normalise lines by stripping
+        // whitespace before checking equality. (This has an annoying interaction
+        // with newlineIsToken that requires special handling: if newlines get their
+        // own token, then we DON'T want to trim the *newline* tokens down to empty
+        // strings, since this would cause us to treat whitespace-only line content
+        // as equal to a separator between lines, which would be weird and
+        // inconsistent with the documented behavior of the options.)
+        if (options.ignoreWhitespace) {
+            if (!options.newlineIsToken || !left.includes('\n')) {
+                left = left.trim();
+            }
+            if (!options.newlineIsToken || !right.includes('\n')) {
+                right = right.trim();
+            }
+        }
+        else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+            if (left.endsWith('\n')) {
+                left = left.slice(0, -1);
+            }
+            if (right.endsWith('\n')) {
+                right = right.slice(0, -1);
+            }
+        }
+        return _super.prototype.equals.call(this, left, right, options);
+    };
+    return LineDiff;
+}(Diff));
+var lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options) {
+    return lineDiff.diff(oldStr, newStr, options);
+}
+// Exported standalone so it can be used from jsonDiff too.
+function tokenize(value, options) {
+    if (options.stripTrailingCr) {
+        // remove one \r before \n to match GNU diff's --strip-trailing-cr behavior
+        value = value.replace(/\r\n/g, '\n');
+    }
+    var retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+    // Ignore the final empty token that occurs if the string ends with a new line
+    if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+        linesAndNewlines.pop();
+    }
+    // Merge the content and line separators into single tokens
+    for (var i = 0; i < linesAndNewlines.length; i++) {
+        var line = linesAndNewlines[i];
+        if (i % 2 && !options.newlineIsToken) {
+            retLines[retLines.length - 1] += line;
+        }
+        else {
+            retLines.push(line);
+        }
+    }
+    return retLines;
 }
 
-var sentenceDiff = new Diff();
-sentenceDiff.tokenize = function (value) {
-  return value.split(/(\S.+?[.!?])(?=\s+|$)/);
-};
-
-var cssDiff = new Diff();
-cssDiff.tokenize = function (value) {
-  return value.split(/([{}:;,]|\s+)/);
-};
-
-function ownKeys(e, r) {
-  var t = Object.keys(e);
-  if (Object.getOwnPropertySymbols) {
-    var o = Object.getOwnPropertySymbols(e);
-    r && (o = o.filter(function (r) {
-      return Object.getOwnPropertyDescriptor(e, r).enumerable;
-    })), t.push.apply(t, o);
-  }
-  return t;
-}
-function _objectSpread2(e) {
-  for (var r = 1; r < arguments.length; r++) {
-    var t = null != arguments[r] ? arguments[r] : {};
-    r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
-      _defineProperty(e, r, t[r]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
-      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
-    });
-  }
-  return e;
-}
-function _toPrimitive(t, r) {
-  if ("object" != typeof t || !t) return t;
-  var e = t[Symbol.toPrimitive];
-  if (void 0 !== e) {
-    var i = e.call(t, r);
-    if ("object" != typeof i) return i;
-    throw new TypeError("@@toPrimitive must return a primitive value.");
-  }
-  return ("string" === r ? String : Number)(t);
-}
-function _toPropertyKey(t) {
-  var i = _toPrimitive(t, "string");
-  return "symbol" == typeof i ? i : i + "";
-}
-function _typeof(o) {
-  "@babel/helpers - typeof";
-
-  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
-    return typeof o;
-  } : function (o) {
-    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-  }, _typeof(o);
-}
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
+var __extends$3 = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var SentenceDiff = /** @class */ (function (_super) {
+    __extends$3(SentenceDiff, _super);
+    function SentenceDiff() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SentenceDiff.prototype.tokenize = function (value) {
+        return value.split(/(?<=[.!?])(\s+|$)/);
+    };
+    return SentenceDiff;
+}(Diff));
+new SentenceDiff();
+
+var __extends$2 = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var CssDiff = /** @class */ (function (_super) {
+    __extends$2(CssDiff, _super);
+    function CssDiff() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CssDiff.prototype.tokenize = function (value) {
+        return value.split(/([{}:;,]|\s+)/);
+    };
+    return CssDiff;
+}(Diff));
+new CssDiff();
+
+var __extends$1 = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var JsonDiff = /** @class */ (function (_super) {
+    __extends$1(JsonDiff, _super);
+    function JsonDiff() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.tokenize = tokenize;
+        return _this;
+    }
+    Object.defineProperty(JsonDiff.prototype, "useLongestToken", {
+        get: function () {
+            // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a
+            // dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output:
+            return true;
+        },
+        enumerable: false,
+        configurable: true
     });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-function _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-}
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-}
-function _iterableToArray(iter) {
-  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-  return arr2;
-}
-function _nonIterableSpread() {
-  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-
-var jsonDiff = new Diff();
-// Discriminate between two lines of pretty-printed, serialized JSON where one of them has a
-// dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output:
-jsonDiff.useLongestToken = true;
-jsonDiff.tokenize = lineDiff.tokenize;
-jsonDiff.castInput = function (value, options) {
-  var undefinedReplacement = options.undefinedReplacement,
-    _options$stringifyRep = options.stringifyReplacer,
-    stringifyReplacer = _options$stringifyRep === void 0 ? function (k, v) {
-      return typeof v === 'undefined' ? undefinedReplacement : v;
-    } : _options$stringifyRep;
-  return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, '  ');
-};
-jsonDiff.equals = function (left, right, options) {
-  return Diff.prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'), options);
-};
-
+    JsonDiff.prototype.castInput = function (value, options) {
+        var undefinedReplacement = options.undefinedReplacement, _a = options.stringifyReplacer, stringifyReplacer = _a === void 0 ? function (k, v) { return typeof v === 'undefined' ? undefinedReplacement : v; } : _a;
+        return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), null, '  ');
+    };
+    JsonDiff.prototype.equals = function (left, right, options) {
+        return _super.prototype.equals.call(this, left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'), options);
+    };
+    return JsonDiff;
+}(Diff));
+new JsonDiff();
 // This function handles the presence of circular references by bailing out when encountering an
 // object that is already on the "stack" of items being processed. Accepts an optional replacer
 function canonicalize(obj, stack, replacementStack, replacer, key) {
-  stack = stack || [];
-  replacementStack = replacementStack || [];
-  if (replacer) {
-    obj = replacer(key, obj);
-  }
-  var i;
-  for (i = 0; i < stack.length; i += 1) {
-    if (stack[i] === obj) {
-      return replacementStack[i];
-    }
-  }
-  var canonicalizedObj;
-  if ('[object Array]' === Object.prototype.toString.call(obj)) {
-    stack.push(obj);
-    canonicalizedObj = new Array(obj.length);
-    replacementStack.push(canonicalizedObj);
-    for (i = 0; i < obj.length; i += 1) {
-      canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key);
-    }
-    stack.pop();
-    replacementStack.pop();
-    return canonicalizedObj;
-  }
-  if (obj && obj.toJSON) {
-    obj = obj.toJSON();
-  }
-  if (_typeof(obj) === 'object' && obj !== null) {
-    stack.push(obj);
-    canonicalizedObj = {};
-    replacementStack.push(canonicalizedObj);
-    var sortedKeys = [],
-      _key;
-    for (_key in obj) {
-      /* istanbul ignore else */
-      if (Object.prototype.hasOwnProperty.call(obj, _key)) {
-        sortedKeys.push(_key);
-      }
+    stack = stack || [];
+    replacementStack = replacementStack || [];
+    if (replacer) {
+        obj = replacer(key === undefined ? '' : key, obj);
+    }
+    var i;
+    for (i = 0; i < stack.length; i += 1) {
+        if (stack[i] === obj) {
+            return replacementStack[i];
+        }
+    }
+    var canonicalizedObj;
+    if ('[object Array]' === Object.prototype.toString.call(obj)) {
+        stack.push(obj);
+        canonicalizedObj = new Array(obj.length);
+        replacementStack.push(canonicalizedObj);
+        for (i = 0; i < obj.length; i += 1) {
+            canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, String(i));
+        }
+        stack.pop();
+        replacementStack.pop();
+        return canonicalizedObj;
+    }
+    if (obj && obj.toJSON) {
+        obj = obj.toJSON();
+    }
+    if (typeof obj === 'object' && obj !== null) {
+        stack.push(obj);
+        canonicalizedObj = {};
+        replacementStack.push(canonicalizedObj);
+        var sortedKeys = [];
+        var key_1;
+        for (key_1 in obj) {
+            /* istanbul ignore else */
+            if (Object.prototype.hasOwnProperty.call(obj, key_1)) {
+                sortedKeys.push(key_1);
+            }
+        }
+        sortedKeys.sort();
+        for (i = 0; i < sortedKeys.length; i += 1) {
+            key_1 = sortedKeys[i];
+            canonicalizedObj[key_1] = canonicalize(obj[key_1], stack, replacementStack, replacer, key_1);
+        }
+        stack.pop();
+        replacementStack.pop();
     }
-    sortedKeys.sort();
-    for (i = 0; i < sortedKeys.length; i += 1) {
-      _key = sortedKeys[i];
-      canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key);
+    else {
+        canonicalizedObj = obj;
     }
-    stack.pop();
-    replacementStack.pop();
-  } else {
-    canonicalizedObj = obj;
-  }
-  return canonicalizedObj;
+    return canonicalizedObj;
 }
 
-var arrayDiff = new Diff();
-arrayDiff.tokenize = function (value) {
-  return value.slice();
-};
-arrayDiff.join = arrayDiff.removeEmpty = function (value) {
-  return value;
+var __extends = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var ArrayDiff = /** @class */ (function (_super) {
+    __extends(ArrayDiff, _super);
+    function ArrayDiff() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ArrayDiff.prototype.tokenize = function (value) {
+        return value.slice();
+    };
+    ArrayDiff.prototype.join = function (value) {
+        return value;
+    };
+    ArrayDiff.prototype.removeEmpty = function (value) {
+        return value;
+    };
+    return ArrayDiff;
+}(Diff));
+new ArrayDiff();
+
+var __assign$2 = (undefined && undefined.__assign) || function () {
+    __assign$2 = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign$2.apply(this, arguments);
 };
 
-function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
-  if (!options) {
-    options = {};
-  }
-  if (typeof options === 'function') {
-    options = {
-      callback: options
+var __assign$1 = (undefined && undefined.__assign) || function () {
+    __assign$1 = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
     };
-  }
-  if (typeof options.context === 'undefined') {
-    options.context = 4;
-  }
-  if (options.newlineIsToken) {
-    throw new Error('newlineIsToken may not be used with patch-generation functions, only with diffing functions');
-  }
-  if (!options.callback) {
-    return diffLinesResultToPatch(diffLines(oldStr, newStr, options));
-  } else {
-    var _options = options,
-      _callback = _options.callback;
-    diffLines(oldStr, newStr, _objectSpread2(_objectSpread2({}, options), {}, {
-      callback: function callback(diff) {
-        var patch = diffLinesResultToPatch(diff);
-        _callback(patch);
-      }
-    }));
-  }
-  function diffLinesResultToPatch(diff) {
-    // STEP 1: Build up the patch with no "" lines and with the arrays
-    //         of lines containing trailing newline characters. We'll tidy up later...
+    return __assign$1.apply(this, arguments);
+};
 
-    if (!diff) {
-      return;
+var __assign = (undefined && undefined.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+    var optionsObj;
+    if (!options) {
+        optionsObj = {};
     }
-    diff.push({
-      value: '',
-      lines: []
-    }); // Append an empty value to make cleanup easier
-
-    function contextLines(lines) {
-      return lines.map(function (entry) {
-        return ' ' + entry;
-      });
+    else if (typeof options === 'function') {
+        optionsObj = { callback: options };
     }
-    var hunks = [];
-    var oldRangeStart = 0,
-      newRangeStart = 0,
-      curRange = [],
-      oldLine = 1,
-      newLine = 1;
-    var _loop = function _loop() {
-      var current = diff[i],
-        lines = current.lines || splitLines(current.value);
-      current.lines = lines;
-      if (current.added || current.removed) {
-        var _curRange;
-        // If we have previous context, start with that
-        if (!oldRangeStart) {
-          var prev = diff[i - 1];
-          oldRangeStart = oldLine;
-          newRangeStart = newLine;
-          if (prev) {
-            curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : [];
-            oldRangeStart -= curRange.length;
-            newRangeStart -= curRange.length;
-          }
-        }
-
-        // Output our changes
-        (_curRange = curRange).push.apply(_curRange, _toConsumableArray(lines.map(function (entry) {
-          return (current.added ? '+' : '-') + entry;
-        })));
-
-        // Track the updated file position
-        if (current.added) {
-          newLine += lines.length;
-        } else {
-          oldLine += lines.length;
+    else {
+        optionsObj = options;
+    }
+    if (typeof optionsObj.context === 'undefined') {
+        optionsObj.context = 4;
+    }
+    // We copy this into its own variable to placate TypeScript, which thinks
+    // optionsObj.context might be undefined in the callbacks below.
+    var context = optionsObj.context;
+    // @ts-expect-error (runtime check for something that is correctly a static type error)
+    if (optionsObj.newlineIsToken) {
+        throw new Error('newlineIsToken may not be used with patch-generation functions, only with diffing functions');
+    }
+    if (!optionsObj.callback) {
+        return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+    }
+    else {
+        var callback_1 = optionsObj.callback;
+        diffLines(oldStr, newStr, __assign(__assign({}, optionsObj), { callback: function (diff) {
+                var patch = diffLinesResultToPatch(diff);
+                // TypeScript is unhappy without the cast because it does not understand that `patch` may
+                // be undefined here only if `callback` is StructuredPatchCallbackAbortable:
+                callback_1(patch);
+            } }));
+    }
+    function diffLinesResultToPatch(diff) {
+        // STEP 1: Build up the patch with no "" lines and with the arrays
+        //         of lines containing trailing newline characters. We'll tidy up later...
+        if (!diff) {
+            return;
         }
-      } else {
-        // Identical context lines. Track line changes
-        if (oldRangeStart) {
-          // Close out any changes that have been output (or join overlapping)
-          if (lines.length <= options.context * 2 && i < diff.length - 2) {
-            var _curRange2;
-            // Overlapping
-            (_curRange2 = curRange).push.apply(_curRange2, _toConsumableArray(contextLines(lines)));
-          } else {
-            var _curRange3;
-            // end the range and output
-            var contextSize = Math.min(lines.length, options.context);
-            (_curRange3 = curRange).push.apply(_curRange3, _toConsumableArray(contextLines(lines.slice(0, contextSize))));
-            var _hunk = {
-              oldStart: oldRangeStart,
-              oldLines: oldLine - oldRangeStart + contextSize,
-              newStart: newRangeStart,
-              newLines: newLine - newRangeStart + contextSize,
-              lines: curRange
-            };
-            hunks.push(_hunk);
-            oldRangeStart = 0;
-            newRangeStart = 0;
-            curRange = [];
-          }
+        diff.push({ value: '', lines: [] }); // Append an empty value to make cleanup easier
+        function contextLines(lines) {
+            return lines.map(function (entry) { return ' ' + entry; });
+        }
+        var hunks = [];
+        var oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+        for (var i = 0; i < diff.length; i++) {
+            var current = diff[i], lines = current.lines || splitLines(current.value);
+            current.lines = lines;
+            if (current.added || current.removed) {
+                // If we have previous context, start with that
+                if (!oldRangeStart) {
+                    var prev = diff[i - 1];
+                    oldRangeStart = oldLine;
+                    newRangeStart = newLine;
+                    if (prev) {
+                        curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
+                        oldRangeStart -= curRange.length;
+                        newRangeStart -= curRange.length;
+                    }
+                }
+                // Output our changes
+                for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
+                    var line = lines_1[_i];
+                    curRange.push((current.added ? '+' : '-') + line);
+                }
+                // Track the updated file position
+                if (current.added) {
+                    newLine += lines.length;
+                }
+                else {
+                    oldLine += lines.length;
+                }
+            }
+            else {
+                // Identical context lines. Track line changes
+                if (oldRangeStart) {
+                    // Close out any changes that have been output (or join overlapping)
+                    if (lines.length <= context * 2 && i < diff.length - 2) {
+                        // Overlapping
+                        for (var _a = 0, _b = contextLines(lines); _a < _b.length; _a++) {
+                            var line = _b[_a];
+                            curRange.push(line);
+                        }
+                    }
+                    else {
+                        // end the range and output
+                        var contextSize = Math.min(lines.length, context);
+                        for (var _c = 0, _d = contextLines(lines.slice(0, contextSize)); _c < _d.length; _c++) {
+                            var line = _d[_c];
+                            curRange.push(line);
+                        }
+                        var hunk = {
+                            oldStart: oldRangeStart,
+                            oldLines: (oldLine - oldRangeStart + contextSize),
+                            newStart: newRangeStart,
+                            newLines: (newLine - newRangeStart + contextSize),
+                            lines: curRange
+                        };
+                        hunks.push(hunk);
+                        oldRangeStart = 0;
+                        newRangeStart = 0;
+                        curRange = [];
+                    }
+                }
+                oldLine += lines.length;
+                newLine += lines.length;
+            }
         }
-        oldLine += lines.length;
-        newLine += lines.length;
-      }
-    };
-    for (var i = 0; i < diff.length; i++) {
-      _loop();
-    }
-
-    // Step 2: eliminate the trailing `\n` from each line of each hunk, and, where needed, add
-    //         "".
-    for (var _i = 0, _hunks = hunks; _i < _hunks.length; _i++) {
-      var hunk = _hunks[_i];
-      for (var _i2 = 0; _i2 < hunk.lines.length; _i2++) {
-        if (hunk.lines[_i2].endsWith('\n')) {
-          hunk.lines[_i2] = hunk.lines[_i2].slice(0, -1);
-        } else {
-          hunk.lines.splice(_i2 + 1, 0, '\');
-          _i2++; // Skip the line we just added, then continue iterating
+        // Step 2: eliminate the trailing `\n` from each line of each hunk, and, where needed, add
+        //         "".
+        for (var _e = 0, hunks_1 = hunks; _e < hunks_1.length; _e++) {
+            var hunk = hunks_1[_e];
+            for (var i = 0; i < hunk.lines.length; i++) {
+                if (hunk.lines[i].endsWith('\n')) {
+                    hunk.lines[i] = hunk.lines[i].slice(0, -1);
+                }
+                else {
+                    hunk.lines.splice(i + 1, 0, '\');
+                    i++; // Skip the line we just added, then continue iterating
+                }
+            }
         }
-      }
+        return {
+            oldFileName: oldFileName, newFileName: newFileName,
+            oldHeader: oldHeader, newHeader: newHeader,
+            hunks: hunks
+        };
     }
-    return {
-      oldFileName: oldFileName,
-      newFileName: newFileName,
-      oldHeader: oldHeader,
-      newHeader: newHeader,
-      hunks: hunks
-    };
-  }
 }
-function formatPatch(diff) {
-  if (Array.isArray(diff)) {
-    return diff.map(formatPatch).join('\n');
-  }
-  var ret = [];
-  if (diff.oldFileName == diff.newFileName) {
-    ret.push('Index: ' + diff.oldFileName);
-  }
-  ret.push('===================================================================');
-  ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\t' + diff.oldHeader));
-  ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\t' + diff.newHeader));
-  for (var i = 0; i < diff.hunks.length; i++) {
-    var hunk = diff.hunks[i];
-    // Unified Diff Format quirk: If the chunk size is 0,
-    // the first number is one lower than one would expect.
-    // https://www.artima.com/weblogs/viewpost.jsp?thread=164293
-    if (hunk.oldLines === 0) {
-      hunk.oldStart -= 1;
+/**
+ * creates a unified diff patch.
+ * @param patch either a single structured patch object (as returned by `structuredPatch`) or an array of them (as returned by `parsePatch`)
+ */
+function formatPatch(patch) {
+    if (Array.isArray(patch)) {
+        return patch.map(formatPatch).join('\n');
     }
-    if (hunk.newLines === 0) {
-      hunk.newStart -= 1;
+    var ret = [];
+    if (patch.oldFileName == patch.newFileName) {
+        ret.push('Index: ' + patch.oldFileName);
     }
-    ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines + ' +' + hunk.newStart + ',' + hunk.newLines + ' @@');
-    ret.push.apply(ret, hunk.lines);
-  }
-  return ret.join('\n') + '\n';
+    ret.push('===================================================================');
+    ret.push('--- ' + patch.oldFileName + (typeof patch.oldHeader === 'undefined' ? '' : '\t' + patch.oldHeader));
+    ret.push('+++ ' + patch.newFileName + (typeof patch.newHeader === 'undefined' ? '' : '\t' + patch.newHeader));
+    for (var i = 0; i < patch.hunks.length; i++) {
+        var hunk = patch.hunks[i];
+        // Unified Diff Format quirk: If the chunk size is 0,
+        // the first number is one lower than one would expect.
+        // https://www.artima.com/weblogs/viewpost.jsp?thread=164293
+        if (hunk.oldLines === 0) {
+            hunk.oldStart -= 1;
+        }
+        if (hunk.newLines === 0) {
+            hunk.newStart -= 1;
+        }
+        ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines
+            + ' +' + hunk.newStart + ',' + hunk.newLines
+            + ' @@');
+        for (var _i = 0, _a = hunk.lines; _i < _a.length; _i++) {
+            var line = _a[_i];
+            ret.push(line);
+        }
+    }
+    return ret.join('\n') + '\n';
 }
 function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
-  var _options2;
-  if (typeof options === 'function') {
-    options = {
-      callback: options
-    };
-  }
-  if (!((_options2 = options) !== null && _options2 !== void 0 && _options2.callback)) {
-    var patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
-    if (!patchObj) {
-      return;
+    if (typeof options === 'function') {
+        options = { callback: options };
     }
-    return formatPatch(patchObj);
-  } else {
-    var _options3 = options,
-      _callback2 = _options3.callback;
-    structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, _objectSpread2(_objectSpread2({}, options), {}, {
-      callback: function callback(patchObj) {
+    if (!(options === null || options === void 0 ? void 0 : options.callback)) {
+        var patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
         if (!patchObj) {
-          _callback2();
-        } else {
-          _callback2(formatPatch(patchObj));
+            return;
         }
-      }
-    }));
-  }
+        return formatPatch(patchObj);
+    }
+    else {
+        var callback_2 = options.callback;
+        structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, __assign(__assign({}, options), { callback: function (patchObj) {
+                if (!patchObj) {
+                    callback_2(undefined);
+                }
+                else {
+                    callback_2(formatPatch(patchObj));
+                }
+            } }));
+    }
 }
-
 /**
  * Split `text` into an array of lines, including the trailing newline character (where present)
  */
 function splitLines(text) {
-  var hasTrailingNl = text.endsWith('\n');
-  var result = text.split('\n').map(function (line) {
-    return line + '\n';
-  });
-  if (hasTrailingNl) {
-    result.pop();
-  } else {
-    result.push(result.pop().slice(0, -1));
-  }
-  return result;
+    var hasTrailingNl = text.endsWith('\n');
+    var result = text.split('\n').map(function (line) { return line + '\n'; });
+    if (hasTrailingNl) {
+        result.pop();
+    }
+    else {
+        result.push(result.pop().slice(0, -1));
+    }
+    return result;
 }
 
 /* eslint-disable no-multi-assign */
@@ -56706,4 +56853,4 @@ var srcExports = requireSrc();
 var tinylr = /*@__PURE__*/getDefaultExportFromCjs(srcExports);
 
 export { HighlightJS as H, MarkdownIt as M, deflist_plugin as a, closest as b, createTwoFilesPatch as c, dedent as d, distance as e, fm as f, globSync as g, glob as h, isCI as i, moduleImporter as j, cliProgress as k, createInstance as l, minimatch as m, fse as n, tinylr as t, watch$1 as w };
-//# sourceMappingURL=vendor-DiqWVUfS.mjs.map
+//# sourceMappingURL=vendor-DxEOke6B.mjs.map