@forsakringskassan/docs-generator 2.28.1 → 2.28.3

package/dist/{vendor-IOoC49Xw.mjs → vendor-DufRLcxZ.mjs}

@@ -16310,21 +16310,6 @@ function commonjsRequire(path) {
 	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
 }
 
-var registerTs = {};
-
-var hasRequiredRegisterTs;
-
-function requireRegisterTs () {
-	if (hasRequiredRegisterTs) return registerTs;
-	hasRequiredRegisterTs = 1;
-	if (typeof commonjsRequire !== 'undefined') {
-	  require$$0$1.registerTS(() => require$$1);
-	}
-	return registerTs;
-}
-
-requireRegisterTs();
-
 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; }
@@ -20757,6 +20742,21 @@ const closest = (str, arr) => {
     return arr[min_index];
 };
 
+var registerTs = {};
+
+var hasRequiredRegisterTs;
+
+function requireRegisterTs () {
+	if (hasRequiredRegisterTs) return registerTs;
+	hasRequiredRegisterTs = 1;
+	if (typeof commonjsRequire !== 'undefined') {
+	  require$$0$1.registerTS(() => require$$1);
+	}
+	return registerTs;
+}
+
+requireRegisterTs();
+
 var ciInfo = {};
 
 var require$$0 = [
@@ -24929,7 +24929,7 @@ class LanguageUtil {
     return found || [];
   }
   toResolveHierarchy(code, fallbackCode) {
-    const fallbackCodes = this.getFallbackCodes(fallbackCode || this.options.fallbackLng || [], code);
+    const fallbackCodes = this.getFallbackCodes((fallbackCode === false ? [] : fallbackCode) || this.options.fallbackLng || [], code);
     const codes = [];
     const addCode = c => {
       if (!c) return;
@@ -28470,14 +28470,11 @@ function deflist_plugin (md) {
   md.block.ruler.before('paragraph', 'deflist', deflist, { alt: ['paragraph', 'reference', 'blockquote'] });
 }
 
-var Diff = /** @class */ (function () {
-    function Diff() {
-    }
-    Diff.prototype.diff = function (oldStr, newStr, 
+class Diff {
+    diff(oldStr, newStr, 
     // Type below is not accurate/complete - see above for full possibilities - but it compiles
-    options) {
-        if (options === void 0) { options = {}; }
-        var callback;
+    options = {}) {
+        let callback;
         if (typeof options === 'function') {
             callback = options;
             options = {};
@@ -28486,17 +28483,16 @@ var Diff = /** @class */ (function () {
             callback = options.callback;
         }
         // Allow subclasses to massage the input prior to running
-        var oldString = this.castInput(oldStr, options);
-        var newString = this.castInput(newStr, options);
-        var oldTokens = this.removeEmpty(this.tokenize(oldString, options));
-        var newTokens = this.removeEmpty(this.tokenize(newString, options));
+        const oldString = this.castInput(oldStr, options);
+        const newString = this.castInput(newStr, options);
+        const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+        const 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;
+    }
+    diffWithOptionsObj(oldTokens, newTokens, options, callback) {
         var _a;
-        var done = function (value) {
-            value = _this.postProcess(value, options);
+        const done = (value) => {
+            value = this.postProcess(value, options);
             if (callback) {
                 setTimeout(function () { callback(value); }, 0);
                 return undefined;
@@ -28505,17 +28501,17 @@ var Diff = /** @class */ (function () {
                 return value;
             }
         };
-        var newLen = newTokens.length, oldLen = oldTokens.length;
-        var editLength = 1;
-        var maxEditLength = newLen + oldLen;
+        const newLen = newTokens.length, oldLen = oldTokens.length;
+        let editLength = 1;
+        let 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 }];
+        const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
+        const abortAfterTimestamp = Date.now() + maxExecutionTime;
+        const 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);
+        let 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));
@@ -28537,24 +28533,24 @@ var Diff = /** @class */ (function () {
         // 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;
+        let 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];
+        const execEditLength = () => {
+            for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+                let basePath;
+                const 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;
+                let canAdd = false;
                 if (addPath) {
                     // what newPos will be after we do an insertion:
-                    var addPathNewPos = addPath.oldPos - diagonalPath;
+                    const addPathNewPos = addPath.oldPos - diagonalPath;
                     canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
                 }
-                var canRemove = removePath && removePath.oldPos + 1 < oldLen;
+                const 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.
@@ -28565,15 +28561,15 @@ var Diff = /** @class */ (function () {
                 // 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);
+                    basePath = this.addToPath(addPath, true, false, 0, options);
                 }
                 else {
-                    basePath = _this.addToPath(removePath, false, true, 1, options);
+                    basePath = this.addToPath(removePath, false, true, 1, options);
                 }
-                newPos = _this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, 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;
+                    return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
                 }
                 else {
                     bestPath[diagonalPath] = basePath;
@@ -28605,15 +28601,15 @@ var Diff = /** @class */ (function () {
         }
         else {
             while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
-                var ret = execEditLength();
+                const ret = execEditLength();
                 if (ret) {
                     return ret;
                 }
             }
         }
-    };
-    Diff.prototype.addToPath = function (path, added, removed, oldPosInc, options) {
-        var last = path.lastComponent;
+    }
+    addToPath(path, added, removed, oldPosInc, options) {
+        const last = path.lastComponent;
         if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
             return {
                 oldPos: path.oldPos + oldPosInc,
@@ -28626,10 +28622,10 @@ var Diff = /** @class */ (function () {
                 lastComponent: { count: 1, added: added, removed: removed, previousComponent: last }
             };
         }
-    };
-    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;
+    }
+    extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+        const newLen = newTokens.length, oldLen = oldTokens.length;
+        let 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++;
@@ -28643,8 +28639,8 @@ var Diff = /** @class */ (function () {
         }
         basePath.oldPos = oldPos;
         return newPos;
-    };
-    Diff.prototype.equals = function (left, right, options) {
+    }
+    equals(left, right, options) {
         if (options.comparator) {
             return options.comparator(left, right);
         }
@@ -28652,48 +28648,44 @@ var Diff = /** @class */ (function () {
             return left === right
                 || (!!options.ignoreCase && left.toLowerCase() === right.toLowerCase());
         }
-    };
-    Diff.prototype.removeEmpty = function (array) {
-        var ret = [];
-        for (var i = 0; i < array.length; i++) {
+    }
+    removeEmpty(array) {
+        const ret = [];
+        for (let 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) {
+    castInput(value, options) {
         return value;
-    };
+    }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    Diff.prototype.tokenize = function (value, options) {
+    tokenize(value, options) {
         return Array.from(value);
-    };
-    Diff.prototype.join = function (chars) {
+    }
+    join(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, 
+    }
+    postProcess(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) {
+    }
+    get useLongestToken() {
+        return false;
+    }
+    buildValues(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;
+        const components = [];
+        let nextComponent;
         while (lastComponent) {
             components.push(lastComponent);
             nextComponent = lastComponent.previousComponent;
@@ -28701,15 +28693,15 @@ var Diff = /** @class */ (function () {
             lastComponent = nextComponent;
         }
         components.reverse();
-        var componentLen = components.length;
-        var componentPos = 0, newPos = 0, oldPos = 0;
+        const componentLen = components.length;
+        let componentPos = 0, newPos = 0, oldPos = 0;
         for (; componentPos < componentLen; componentPos++) {
-            var component = components[componentPos];
+            const component = components[componentPos];
             if (!component.removed) {
                 if (!component.added && this.useLongestToken) {
-                    var value = newTokens.slice(newPos, newPos + component.count);
+                    let value = newTokens.slice(newPos, newPos + component.count);
                     value = value.map(function (value, i) {
-                        var oldValue = oldTokens[oldPos + i];
+                        const oldValue = oldTokens[oldPos + i];
                         return oldValue.length > value.length ? oldValue : value;
                     });
                     component.value = this.join(value);
@@ -28729,462 +28721,15 @@ var Diff = /** @class */ (function () {
             }
         }
         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 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);
-        }
     }
-    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);
-        }
-    }
-    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);
-}
-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;
-}
-function removePrefix(string, oldPrefix) {
-    return replacePrefix(string, oldPrefix, '');
-}
-function removeSuffix(string, oldSuffix) {
-    return replaceSuffix(string, oldSuffix, '');
-}
-function maximumOverlap(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;
-        }
-        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 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:
-// Latin-1 Supplement, 0080–00FF
-//  - U+00D7  × Multiplication sign
-//  - U+00F7  ÷ Division sign
-// Latin Extended-A, 0100–017F
-// Latin Extended-B, 0180–024F
-// IPA Extensions, 0250–02AF
-// Spacing Modifier Letters, 02B0–02FF
-//  - U+02C7  ˇ &#711;  Caron
-//  - U+02D8  ˘ &#728;  Breve
-//  - U+02D9  ˙ &#729;  Dot Above
-//  - U+02DA  ˚ &#730;  Ring Above
-//  - U+02DB  ˛ &#731;  Ogonek
-//  - 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}';
-// Each token is one of the following:
-// - A punctuation mark plus the surrounding whitespace
-// - A word plus the surrounding whitespace
-// - Pure whitespace (but only in the special case where this the entire text
-//   is just whitespace)
-//
-// We have to include surrounding whitespace in the tokens because the two
-// alternative approaches produce horribly broken results:
-// * If we just discard the whitespace, we can't fully reproduce the original
-//   text from the sequence of tokens and any attempt to render the diff will
-//   get the whitespace wrong.
-// * If we have separate tokens for whitespace, then in a typical text every
-//   second token will be a single space character. But this often results in
-//   the optimal diff between two texts being a perverse one that preserves
-//   the spaces between words but deletes and reinserts actual common words.
-//   See https://github.com/kpdecker/jsdiff/issues/160#issuecomment-1866099640
-//   for an example.
-//
-// 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 = /** @class */ (function (_super) {
-    __extends$5(WordDiff, _super);
-    function WordDiff() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    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 = 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;
-    }
-    LineDiff.prototype.equals = function (left, right, options) {
+class LineDiff extends Diff {
+    constructor() {
+        super(...arguments);
+        this.tokenize = tokenize;
+    }
+    equals(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
@@ -29208,11 +28753,10 @@ var LineDiff = /** @class */ (function (_super) {
                 right = right.slice(0, -1);
             }
         }
-        return _super.prototype.equals.call(this, left, right, options);
-    };
-    return LineDiff;
-}(Diff));
-var lineDiff = new LineDiff();
+        return super.equals(left, right, options);
+    }
+}
+const lineDiff = new LineDiff();
 function diffLines(oldStr, newStr, options) {
     return lineDiff.diff(oldStr, newStr, options);
 }
@@ -29222,14 +28766,14 @@ function tokenize(value, options) {
         // 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)/);
+    const 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];
+    for (let i = 0; i < linesAndNewlines.length; i++) {
+        const line = linesAndNewlines[i];
         if (i % 2 && !options.newlineIsToken) {
             retLines[retLines.length - 1] += line;
         }
@@ -29240,100 +28784,24 @@ function tokenize(value, options) {
     return retLines;
 }
 
-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
-    });
-    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;
+class JsonDiff extends Diff {
+    constructor() {
+        super(...arguments);
+        this.tokenize = tokenize;
+    }
+    get useLongestToken() {
+        // 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;
+    }
+    castInput(value, options) {
+        const { undefinedReplacement, stringifyReplacer = (k, v) => typeof v === 'undefined' ? undefinedReplacement : v } = options;
         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));
+    }
+    equals(left, right, options) {
+        return super.equals(left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'), options);
+    }
+}
 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
@@ -29343,13 +28811,13 @@ function canonicalize(obj, stack, replacementStack, replacer, key) {
     if (replacer) {
         obj = replacer(key === undefined ? '' : key, obj);
     }
-    var i;
+    let i;
     for (i = 0; i < stack.length; i += 1) {
         if (stack[i] === obj) {
             return replacementStack[i];
         }
     }
-    var canonicalizedObj;
+    let canonicalizedObj;
     if ('[object Array]' === Object.prototype.toString.call(obj)) {
         stack.push(obj);
         canonicalizedObj = new Array(obj.length);
@@ -29368,18 +28836,18 @@ function canonicalize(obj, stack, replacementStack, replacer, key) {
         stack.push(obj);
         canonicalizedObj = {};
         replacementStack.push(canonicalizedObj);
-        var sortedKeys = [];
-        var key_1;
-        for (key_1 in obj) {
+        const sortedKeys = [];
+        let key;
+        for (key in obj) {
             /* istanbul ignore else */
-            if (Object.prototype.hasOwnProperty.call(obj, key_1)) {
-                sortedKeys.push(key_1);
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                sortedKeys.push(key);
             }
         }
         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);
+            key = sortedKeys[i];
+            canonicalizedObj[key] = canonicalize(obj[key], stack, replacementStack, replacer, key);
         }
         stack.pop();
         replacementStack.pop();
@@ -29390,76 +28858,8 @@ function canonicalize(obj, stack, replacementStack, replacer, key) {
     return canonicalizedObj;
 }
 
-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);
-};
-
-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;
-    };
-    return __assign$1.apply(this, arguments);
-};
-
-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;
+    let optionsObj;
     if (!options) {
         optionsObj = {};
     }
@@ -29474,7 +28874,7 @@ function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, ne
     }
     // 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;
+    const 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');
@@ -29483,12 +28883,12 @@ function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, ne
         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);
+        const { callback } = optionsObj;
+        diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
+                const 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);
+                callback(patch);
             } }));
     }
     function diffLinesResultToPatch(diff) {
@@ -29501,15 +28901,15 @@ function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, ne
         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);
+        const hunks = [];
+        let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+        for (let i = 0; i < diff.length; i++) {
+            const 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];
+                    const prev = diff[i - 1];
                     oldRangeStart = oldLine;
                     newRangeStart = newLine;
                     if (prev) {
@@ -29519,8 +28919,7 @@ function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, ne
                     }
                 }
                 // Output our changes
-                for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
-                    var line = lines_1[_i];
+                for (const line of lines) {
                     curRange.push((current.added ? '+' : '-') + line);
                 }
                 // Track the updated file position
@@ -29537,19 +28936,17 @@ function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, ne
                     // 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];
+                        for (const line of contextLines(lines)) {
                             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];
+                        const contextSize = Math.min(lines.length, context);
+                        for (const line of contextLines(lines.slice(0, contextSize))) {
                             curRange.push(line);
                         }
-                        var hunk = {
+                        const hunk = {
                             oldStart: oldRangeStart,
                             oldLines: (oldLine - oldRangeStart + contextSize),
                             newStart: newRangeStart,
@@ -29568,9 +28965,8 @@ function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, ne
         }
         // 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++) {
+        for (const hunk of hunks) {
+            for (let i = 0; i < hunk.lines.length; i++) {
                 if (hunk.lines[i].endsWith('\n')) {
                     hunk.lines[i] = hunk.lines[i].slice(0, -1);
                 }
@@ -29595,15 +28991,15 @@ function formatPatch(patch) {
     if (Array.isArray(patch)) {
         return patch.map(formatPatch).join('\n');
     }
-    var ret = [];
+    const ret = [];
     if (patch.oldFileName == patch.newFileName) {
         ret.push('Index: ' + patch.oldFileName);
     }
     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];
+    for (let i = 0; i < patch.hunks.length; i++) {
+        const 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
@@ -29616,8 +29012,7 @@ function formatPatch(patch) {
         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];
+        for (const line of hunk.lines) {
             ret.push(line);
         }
     }
@@ -29628,20 +29023,20 @@ function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader
         options = { callback: options };
     }
     if (!(options === null || options === void 0 ? void 0 : options.callback)) {
-        var patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
+        const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
         if (!patchObj) {
             return;
         }
         return formatPatch(patchObj);
     }
     else {
-        var callback_2 = options.callback;
-        structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, __assign(__assign({}, options), { callback: function (patchObj) {
+        const { callback } = options;
+        structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: patchObj => {
                 if (!patchObj) {
-                    callback_2(undefined);
+                    callback(undefined);
                 }
                 else {
-                    callback_2(formatPatch(patchObj));
+                    callback(formatPatch(patchObj));
                 }
             } }));
     }
@@ -29650,8 +29045,8 @@ function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader
  * 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'; });
+    const hasTrailingNl = text.endsWith('\n');
+    const result = text.split('\n').map(line => line + '\n');
     if (hasTrailingNl) {
         result.pop();
     }
@@ -56764,5 +56159,5 @@ function requireSrc () {
 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-IOoC49Xw.mjs.map
+export { HighlightJS as H, MarkdownIt as M, createTwoFilesPatch as a, deflist_plugin as b, commonjsRequire as c, dedent as d, closest as e, distance as f, globSync as g, fm as h, isCI as i, glob as j, moduleImporter as k, cliProgress as l, minimatch as m, createInstance as n, fse as o, tinylr as t, watch$1 as w };
+//# sourceMappingURL=vendor-DufRLcxZ.mjs.map