@embedder/embedder 2.0.29 → 2.0.31

package/assets/index-BCtIIzI8.js

@@ -1,835 +0,0 @@
-#!/usr/bin/env node
-import { D as Diff, t as tokenize } from "./cli-Cvo-V2B8.js";
-import { b, c, d, a, f, l, s } from "./cli-Cvo-V2B8.js";
-import "./_commonjsHelpers-CSHRO93D.js";
-import "signal-exit";
-import "node:process";
-import "node:events";
-import "node:fs";
-import "module";
-import "node:os";
-import "node:tty";
-import "node:buffer";
-import "node:util";
-import "node:path";
-import "node:url";
-import "node:child_process";
-import "node:fs/promises";
-import "@sentry/node";
-import "fs";
-import "crypto";
-import "os";
-import "path";
-import "http";
-import "url";
-import "util";
-import "stream";
-import "buffer";
-import "events";
-import "zlib";
-import "tty";
-import "string_decoder";
-import "https";
-import "node:crypto";
-import "node:stream";
-import "node:string_decoder";
-import "fs/promises";
-import "child_process";
-class CharacterDiff extends Diff {
-}
-const characterDiff = new CharacterDiff();
-function diffChars(oldStr, newStr, options) {
-  return characterDiff.diff(oldStr, newStr, options);
-}
-function longestCommonPrefix(str1, str2) {
-  let 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) {
-  let i;
-  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 ${JSON.stringify(string)} doesn't start with prefix ${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 ${JSON.stringify(string)} doesn't end with suffix ${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));
-}
-function overlapCount(a2, b2) {
-  let startA = 0;
-  if (a2.length > b2.length) {
-    startA = a2.length - b2.length;
-  }
-  let endB = b2.length;
-  if (a2.length < b2.length) {
-    endB = a2.length;
-  }
-  const map = Array(endB);
-  let k = 0;
-  map[0] = 0;
-  for (let j = 1; j < endB; j++) {
-    if (b2[j] == b2[k]) {
-      map[j] = map[k];
-    } else {
-      map[j] = k;
-    }
-    while (k > 0 && b2[j] != b2[k]) {
-      k = map[k];
-    }
-    if (b2[j] == b2[k]) {
-      k++;
-    }
-  }
-  k = 0;
-  for (let i = startA; i < a2.length; i++) {
-    while (k > 0 && a2[i] != b2[k]) {
-      k = map[k];
-    }
-    if (a2[i] == b2[k]) {
-      k++;
-    }
-  }
-  return k;
-}
-function hasOnlyWinLineEndings(string) {
-  return string.includes("\r\n") && !string.startsWith("\n") && !string.match(/[^\r]\n/);
-}
-function hasOnlyUnixLineEndings(string) {
-  return !string.includes("\r\n") && string.includes("\n");
-}
-function trailingWs(string) {
-  let i;
-  for (i = string.length - 1; i >= 0; i--) {
-    if (!string[i].match(/\s/)) {
-      break;
-    }
-  }
-  return string.substring(i + 1);
-}
-function leadingWs(string) {
-  const match = string.match(/^\s*/);
-  return match ? match[0] : "";
-}
-const 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}";
-const tokenizeIncludingWhitespace = new RegExp(`[${extendedWordChars}]+|\\s+|[^${extendedWordChars}]`, "ug");
-class WordDiff extends Diff {
-  equals(left, right, options) {
-    if (options.ignoreCase) {
-      left = left.toLowerCase();
-      right = right.toLowerCase();
-    }
-    return left.trim() === right.trim();
-  }
-  tokenize(value, options = {}) {
-    let parts;
-    if (options.intlSegmenter) {
-      const 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), (segment) => segment.segment);
-    } else {
-      parts = value.match(tokenizeIncludingWhitespace) || [];
-    }
-    const tokens = [];
-    let prevPart = null;
-    parts.forEach((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;
-  }
-  join(tokens) {
-    return tokens.map((token, i) => {
-      if (i == 0) {
-        return token;
-      } else {
-        return token.replace(/^\s+/, "");
-      }
-    }).join("");
-  }
-  postProcess(changes, options) {
-    if (!changes || options.oneChangePerToken) {
-      return changes;
-    }
-    let lastKeep = null;
-    let insertion = null;
-    let deletion = null;
-    changes.forEach((change) => {
-      if (change.added) {
-        insertion = change;
-      } else if (change.removed) {
-        deletion = change;
-      } else {
-        if (insertion || deletion) {
-          dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);
-        }
-        lastKeep = change;
-        insertion = null;
-        deletion = null;
-      }
-    });
-    if (insertion || deletion) {
-      dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);
-    }
-    return changes;
-  }
-}
-const wordDiff = new WordDiff();
-function diffWords(oldStr, newStr, options) {
-  if ((options === null || options === void 0 ? void 0 : options.ignoreWhitespace) != null && !options.ignoreWhitespace) {
-    return diffWordsWithSpace(oldStr, newStr, options);
-  }
-  return wordDiff.diff(oldStr, newStr, options);
-}
-function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep) {
-  if (deletion && insertion) {
-    const oldWsPrefix = leadingWs(deletion.value);
-    const oldWsSuffix = trailingWs(deletion.value);
-    const newWsPrefix = leadingWs(insertion.value);
-    const newWsSuffix = trailingWs(insertion.value);
-    if (startKeep) {
-      const 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) {
-      const 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) {
-    if (startKeep) {
-      const ws = leadingWs(insertion.value);
-      insertion.value = insertion.value.substring(ws.length);
-    }
-    if (endKeep) {
-      const ws = leadingWs(endKeep.value);
-      endKeep.value = endKeep.value.substring(ws.length);
-    }
-  } else if (startKeep && endKeep) {
-    const newWsFull = leadingWs(endKeep.value), delWsStart = leadingWs(deletion.value), delWsEnd = trailingWs(deletion.value);
-    const newWsStart = longestCommonPrefix(newWsFull, delWsStart);
-    deletion.value = removePrefix(deletion.value, newWsStart);
-    const newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
-    deletion.value = removeSuffix(deletion.value, newWsEnd);
-    endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd);
-    startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
-  } else if (endKeep) {
-    const endKeepWsPrefix = leadingWs(endKeep.value);
-    const deletionWsSuffix = trailingWs(deletion.value);
-    const overlap = maximumOverlap(deletionWsSuffix, endKeepWsPrefix);
-    deletion.value = removeSuffix(deletion.value, overlap);
-  } else if (startKeep) {
-    const startKeepWsSuffix = trailingWs(startKeep.value);
-    const deletionWsPrefix = leadingWs(deletion.value);
-    const overlap = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
-    deletion.value = removePrefix(deletion.value, overlap);
-  }
-}
-class WordsWithSpaceDiff extends Diff {
-  tokenize(value) {
-    const regex = new RegExp(`(\\r?\\n)|[${extendedWordChars}]+|[^\\S\\n\\r]+|[^${extendedWordChars}]`, "ug");
-    return value.match(regex) || [];
-  }
-}
-const wordsWithSpaceDiff = new WordsWithSpaceDiff();
-function diffWordsWithSpace(oldStr, newStr, options) {
-  return wordsWithSpaceDiff.diff(oldStr, newStr, options);
-}
-function isSentenceEndPunct(char) {
-  return char == "." || char == "!" || char == "?";
-}
-class SentenceDiff extends Diff {
-  tokenize(value) {
-    var _a;
-    const result = [];
-    let tokenStartI = 0;
-    for (let i = 0; i < value.length; i++) {
-      if (i == value.length - 1) {
-        result.push(value.slice(tokenStartI));
-        break;
-      }
-      if (isSentenceEndPunct(value[i]) && value[i + 1].match(/\s/)) {
-        result.push(value.slice(tokenStartI, i + 1));
-        i = tokenStartI = i + 1;
-        while ((_a = value[i + 1]) === null || _a === void 0 ? void 0 : _a.match(/\s/)) {
-          i++;
-        }
-        result.push(value.slice(tokenStartI, i + 1));
-        tokenStartI = i + 1;
-      }
-    }
-    return result;
-  }
-}
-const sentenceDiff = new SentenceDiff();
-function diffSentences(oldStr, newStr, options) {
-  return sentenceDiff.diff(oldStr, newStr, options);
-}
-class CssDiff extends Diff {
-  tokenize(value) {
-    return value.split(/([{}:;,]|\s+)/);
-  }
-}
-const cssDiff = new CssDiff();
-function diffCss(oldStr, newStr, options) {
-  return cssDiff.diff(oldStr, newStr, options);
-}
-class JsonDiff extends Diff {
-  constructor() {
-    super(...arguments);
-    this.tokenize = tokenize;
-  }
-  get useLongestToken() {
-    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, "  ");
-  }
-  equals(left, right, options) {
-    return super.equals(left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"), options);
-  }
-}
-const jsonDiff = new JsonDiff();
-function diffJson(oldStr, newStr, options) {
-  return jsonDiff.diff(oldStr, newStr, options);
-}
-function canonicalize(obj, stack, replacementStack, replacer, key) {
-  stack = stack || [];
-  replacementStack = replacementStack || [];
-  if (replacer) {
-    obj = replacer(key === void 0 ? "" : key, obj);
-  }
-  let i;
-  for (i = 0; i < stack.length; i += 1) {
-    if (stack[i] === obj) {
-      return replacementStack[i];
-    }
-  }
-  let 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);
-    const sortedKeys = [];
-    let key2;
-    for (key2 in obj) {
-      if (Object.prototype.hasOwnProperty.call(obj, key2)) {
-        sortedKeys.push(key2);
-      }
-    }
-    sortedKeys.sort();
-    for (i = 0; i < sortedKeys.length; i += 1) {
-      key2 = sortedKeys[i];
-      canonicalizedObj[key2] = canonicalize(obj[key2], stack, replacementStack, replacer, key2);
-    }
-    stack.pop();
-    replacementStack.pop();
-  } else {
-    canonicalizedObj = obj;
-  }
-  return canonicalizedObj;
-}
-class ArrayDiff extends Diff {
-  tokenize(value) {
-    return value.slice();
-  }
-  join(value) {
-    return value;
-  }
-  removeEmpty(value) {
-    return value;
-  }
-}
-const arrayDiff = new ArrayDiff();
-function diffArrays(oldArr, newArr, options) {
-  return arrayDiff.diff(oldArr, newArr, options);
-}
-function unixToWin(patch) {
-  if (Array.isArray(patch)) {
-    return patch.map((p) => unixToWin(p));
-  }
-  return Object.assign(Object.assign({}, patch), { hunks: patch.hunks.map((hunk) => Object.assign(Object.assign({}, hunk), { lines: hunk.lines.map((line, i) => {
-    var _a;
-    return line.startsWith("\\") || line.endsWith("\r") || ((_a = hunk.lines[i + 1]) === null || _a === void 0 ? void 0 : _a.startsWith("\\")) ? line : line + "\r";
-  }) })) });
-}
-function winToUnix(patch) {
-  if (Array.isArray(patch)) {
-    return patch.map((p) => winToUnix(p));
-  }
-  return Object.assign(Object.assign({}, patch), { hunks: patch.hunks.map((hunk) => Object.assign(Object.assign({}, hunk), { lines: hunk.lines.map((line) => line.endsWith("\r") ? line.substring(0, line.length - 1) : line) })) });
-}
-function isUnix(patch) {
-  if (!Array.isArray(patch)) {
-    patch = [patch];
-  }
-  return !patch.some((index) => index.hunks.some((hunk) => hunk.lines.some((line) => !line.startsWith("\\") && line.endsWith("\r"))));
-}
-function isWin(patch) {
-  if (!Array.isArray(patch)) {
-    patch = [patch];
-  }
-  return patch.some((index) => index.hunks.some((hunk) => hunk.lines.some((line) => line.endsWith("\r")))) && patch.every((index) => index.hunks.every((hunk) => hunk.lines.every((line, i) => {
-    var _a;
-    return line.startsWith("\\") || line.endsWith("\r") || ((_a = hunk.lines[i + 1]) === null || _a === void 0 ? void 0 : _a.startsWith("\\"));
-  })));
-}
-function parsePatch(uniDiff) {
-  const diffstr = uniDiff.split(/\n/), list = [];
-  let i = 0;
-  function parseIndex() {
-    const index = {};
-    list.push(index);
-    while (i < diffstr.length) {
-      const line = diffstr[i];
-      if (/^(---|\+\+\+|@@)\s/.test(line)) {
-        break;
-      }
-      const header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
-      if (header) {
-        index.index = header[1];
-      }
-      i++;
-    }
-    parseFileHeader(index);
-    parseFileHeader(index);
-    index.hunks = [];
-    while (i < diffstr.length) {
-      const line = diffstr[i];
-      if (/^(Index:\s|diff\s|---\s|\+\+\+\s|===================================================================)/.test(line)) {
-        break;
-      } else if (/^@@/.test(line)) {
-        index.hunks.push(parseHunk());
-      } else if (line) {
-        throw new Error("Unknown line " + (i + 1) + " " + JSON.stringify(line));
-      } else {
-        i++;
-      }
-    }
-  }
-  function parseFileHeader(index) {
-    const fileHeader = /^(---|\+\+\+)\s+(.*)\r?$/.exec(diffstr[i]);
-    if (fileHeader) {
-      const data = fileHeader[2].split("	", 2), header = (data[1] || "").trim();
-      let fileName = data[0].replace(/\\\\/g, "\\");
-      if (/^".*"$/.test(fileName)) {
-        fileName = fileName.substr(1, fileName.length - 2);
-      }
-      if (fileHeader[1] === "---") {
-        index.oldFileName = fileName;
-        index.oldHeader = header;
-      } else {
-        index.newFileName = fileName;
-        index.newHeader = header;
-      }
-      i++;
-    }
-  }
-  function parseHunk() {
-    var _a;
-    const chunkHeaderIndex = i, chunkHeaderLine = diffstr[i++], chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
-    const hunk = {
-      oldStart: +chunkHeader[1],
-      oldLines: typeof chunkHeader[2] === "undefined" ? 1 : +chunkHeader[2],
-      newStart: +chunkHeader[3],
-      newLines: typeof chunkHeader[4] === "undefined" ? 1 : +chunkHeader[4],
-      lines: []
-    };
-    if (hunk.oldLines === 0) {
-      hunk.oldStart += 1;
-    }
-    if (hunk.newLines === 0) {
-      hunk.newStart += 1;
-    }
-    let addCount = 0, removeCount = 0;
-    for (; i < diffstr.length && (removeCount < hunk.oldLines || addCount < hunk.newLines || ((_a = diffstr[i]) === null || _a === void 0 ? void 0 : _a.startsWith("\\"))); i++) {
-      const operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? " " : diffstr[i][0];
-      if (operation === "+" || operation === "-" || operation === " " || operation === "\\") {
-        hunk.lines.push(diffstr[i]);
-        if (operation === "+") {
-          addCount++;
-        } else if (operation === "-") {
-          removeCount++;
-        } else if (operation === " ") {
-          addCount++;
-          removeCount++;
-        }
-      } else {
-        throw new Error(`Hunk at line ${chunkHeaderIndex + 1} contained invalid line ${diffstr[i]}`);
-      }
-    }
-    if (!addCount && hunk.newLines === 1) {
-      hunk.newLines = 0;
-    }
-    if (!removeCount && hunk.oldLines === 1) {
-      hunk.oldLines = 0;
-    }
-    if (addCount !== hunk.newLines) {
-      throw new Error("Added line count did not match for hunk at line " + (chunkHeaderIndex + 1));
-    }
-    if (removeCount !== hunk.oldLines) {
-      throw new Error("Removed line count did not match for hunk at line " + (chunkHeaderIndex + 1));
-    }
-    return hunk;
-  }
-  while (i < diffstr.length) {
-    parseIndex();
-  }
-  return list;
-}
-function distanceIterator(start, minLine, maxLine) {
-  let wantForward = true, backwardExhausted = false, forwardExhausted = false, localOffset = 1;
-  return function iterator() {
-    if (wantForward && !forwardExhausted) {
-      if (backwardExhausted) {
-        localOffset++;
-      } else {
-        wantForward = false;
-      }
-      if (start + localOffset <= maxLine) {
-        return start + localOffset;
-      }
-      forwardExhausted = true;
-    }
-    if (!backwardExhausted) {
-      if (!forwardExhausted) {
-        wantForward = true;
-      }
-      if (minLine <= start - localOffset) {
-        return start - localOffset++;
-      }
-      backwardExhausted = true;
-      return iterator();
-    }
-    return void 0;
-  };
-}
-function applyPatch(source, patch, options = {}) {
-  let patches;
-  if (typeof patch === "string") {
-    patches = parsePatch(patch);
-  } else if (Array.isArray(patch)) {
-    patches = patch;
-  } else {
-    patches = [patch];
-  }
-  if (patches.length > 1) {
-    throw new Error("applyPatch only works with a single input.");
-  }
-  return applyStructuredPatch(source, patches[0], options);
-}
-function applyStructuredPatch(source, patch, options = {}) {
-  if (options.autoConvertLineEndings || options.autoConvertLineEndings == null) {
-    if (hasOnlyWinLineEndings(source) && isUnix(patch)) {
-      patch = unixToWin(patch);
-    } else if (hasOnlyUnixLineEndings(source) && isWin(patch)) {
-      patch = winToUnix(patch);
-    }
-  }
-  const lines = source.split("\n"), hunks = patch.hunks, compareLine = options.compareLine || ((lineNumber, line, operation, patchContent) => line === patchContent), fuzzFactor = options.fuzzFactor || 0;
-  let minLine = 0;
-  if (fuzzFactor < 0 || !Number.isInteger(fuzzFactor)) {
-    throw new Error("fuzzFactor must be a non-negative integer");
-  }
-  if (!hunks.length) {
-    return source;
-  }
-  let prevLine = "", removeEOFNL = false, addEOFNL = false;
-  for (let i = 0; i < hunks[hunks.length - 1].lines.length; i++) {
-    const line = hunks[hunks.length - 1].lines[i];
-    if (line[0] == "\\") {
-      if (prevLine[0] == "+") {
-        removeEOFNL = true;
-      } else if (prevLine[0] == "-") {
-        addEOFNL = true;
-      }
-    }
-    prevLine = line;
-  }
-  if (removeEOFNL) {
-    if (addEOFNL) {
-      if (!fuzzFactor && lines[lines.length - 1] == "") {
-        return false;
-      }
-    } else if (lines[lines.length - 1] == "") {
-      lines.pop();
-    } else if (!fuzzFactor) {
-      return false;
-    }
-  } else if (addEOFNL) {
-    if (lines[lines.length - 1] != "") {
-      lines.push("");
-    } else if (!fuzzFactor) {
-      return false;
-    }
-  }
-  function applyHunk(hunkLines, toPos, maxErrors, hunkLinesI = 0, lastContextLineMatched = true, patchedLines = [], patchedLinesLength = 0) {
-    let nConsecutiveOldContextLines = 0;
-    let nextContextLineMustMatch = false;
-    for (; hunkLinesI < hunkLines.length; hunkLinesI++) {
-      const hunkLine = hunkLines[hunkLinesI], operation = hunkLine.length > 0 ? hunkLine[0] : " ", content = hunkLine.length > 0 ? hunkLine.substr(1) : hunkLine;
-      if (operation === "-") {
-        if (compareLine(toPos + 1, lines[toPos], operation, content)) {
-          toPos++;
-          nConsecutiveOldContextLines = 0;
-        } else {
-          if (!maxErrors || lines[toPos] == null) {
-            return null;
-          }
-          patchedLines[patchedLinesLength] = lines[toPos];
-          return applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1);
-        }
-      }
-      if (operation === "+") {
-        if (!lastContextLineMatched) {
-          return null;
-        }
-        patchedLines[patchedLinesLength] = content;
-        patchedLinesLength++;
-        nConsecutiveOldContextLines = 0;
-        nextContextLineMustMatch = true;
-      }
-      if (operation === " ") {
-        nConsecutiveOldContextLines++;
-        patchedLines[patchedLinesLength] = lines[toPos];
-        if (compareLine(toPos + 1, lines[toPos], operation, content)) {
-          patchedLinesLength++;
-          lastContextLineMatched = true;
-          nextContextLineMustMatch = false;
-          toPos++;
-        } else {
-          if (nextContextLineMustMatch || !maxErrors) {
-            return null;
-          }
-          return lines[toPos] && (applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength + 1) || applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1)) || applyHunk(hunkLines, toPos, maxErrors - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength);
-        }
-      }
-    }
-    patchedLinesLength -= nConsecutiveOldContextLines;
-    toPos -= nConsecutiveOldContextLines;
-    patchedLines.length = patchedLinesLength;
-    return {
-      patchedLines,
-      oldLineLastI: toPos - 1
-    };
-  }
-  const resultLines = [];
-  let prevHunkOffset = 0;
-  for (let i = 0; i < hunks.length; i++) {
-    const hunk = hunks[i];
-    let hunkResult;
-    const maxLine = lines.length - hunk.oldLines + fuzzFactor;
-    let toPos;
-    for (let maxErrors = 0; maxErrors <= fuzzFactor; maxErrors++) {
-      toPos = hunk.oldStart + prevHunkOffset - 1;
-      const iterator = distanceIterator(toPos, minLine, maxLine);
-      for (; toPos !== void 0; toPos = iterator()) {
-        hunkResult = applyHunk(hunk.lines, toPos, maxErrors);
-        if (hunkResult) {
-          break;
-        }
-      }
-      if (hunkResult) {
-        break;
-      }
-    }
-    if (!hunkResult) {
-      return false;
-    }
-    for (let i2 = minLine; i2 < toPos; i2++) {
-      resultLines.push(lines[i2]);
-    }
-    for (let i2 = 0; i2 < hunkResult.patchedLines.length; i2++) {
-      const line = hunkResult.patchedLines[i2];
-      resultLines.push(line);
-    }
-    minLine = hunkResult.oldLineLastI + 1;
-    prevHunkOffset = toPos + 1 - hunk.oldStart;
-  }
-  for (let i = minLine; i < lines.length; i++) {
-    resultLines.push(lines[i]);
-  }
-  return resultLines.join("\n");
-}
-function applyPatches(uniDiff, options) {
-  const spDiff = typeof uniDiff === "string" ? parsePatch(uniDiff) : uniDiff;
-  let currentIndex = 0;
-  function processIndex() {
-    const index = spDiff[currentIndex++];
-    if (!index) {
-      return options.complete();
-    }
-    options.loadFile(index, function(err, data) {
-      if (err) {
-        return options.complete(err);
-      }
-      const updatedContent = applyPatch(data, index, options);
-      options.patched(index, updatedContent, function(err2) {
-        if (err2) {
-          return options.complete(err2);
-        }
-        processIndex();
-      });
-    });
-  }
-  processIndex();
-}
-function reversePatch(structuredPatch) {
-  if (Array.isArray(structuredPatch)) {
-    return structuredPatch.map((patch) => reversePatch(patch)).reverse();
-  }
-  return Object.assign(Object.assign({}, structuredPatch), { oldFileName: structuredPatch.newFileName, oldHeader: structuredPatch.newHeader, newFileName: structuredPatch.oldFileName, newHeader: structuredPatch.oldHeader, hunks: structuredPatch.hunks.map((hunk) => {
-    return {
-      oldLines: hunk.newLines,
-      oldStart: hunk.newStart,
-      newLines: hunk.oldLines,
-      newStart: hunk.oldStart,
-      lines: hunk.lines.map((l2) => {
-        if (l2.startsWith("-")) {
-          return `+${l2.slice(1)}`;
-        }
-        if (l2.startsWith("+")) {
-          return `-${l2.slice(1)}`;
-        }
-        return l2;
-      })
-    };
-  }) });
-}
-function convertChangesToDMP(changes) {
-  const ret = [];
-  let change, operation;
-  for (let i = 0; i < changes.length; i++) {
-    change = changes[i];
-    if (change.added) {
-      operation = 1;
-    } else if (change.removed) {
-      operation = -1;
-    } else {
-      operation = 0;
-    }
-    ret.push([operation, change.value]);
-  }
-  return ret;
-}
-function convertChangesToXML(changes) {
-  const ret = [];
-  for (let i = 0; i < changes.length; i++) {
-    const change = changes[i];
-    if (change.added) {
-      ret.push("<ins>");
-    } else if (change.removed) {
-      ret.push("<del>");
-    }
-    ret.push(escapeHTML(change.value));
-    if (change.added) {
-      ret.push("</ins>");
-    } else if (change.removed) {
-      ret.push("</del>");
-    }
-  }
-  return ret.join("");
-}
-function escapeHTML(s2) {
-  let n = s2;
-  n = n.replace(/&/g, "&amp;");
-  n = n.replace(/</g, "&lt;");
-  n = n.replace(/>/g, "&gt;");
-  n = n.replace(/"/g, "&quot;");
-  return n;
-}
-export {
-  Diff,
-  applyPatch,
-  applyPatches,
-  arrayDiff,
-  canonicalize,
-  characterDiff,
-  convertChangesToDMP,
-  convertChangesToXML,
-  b as createPatch,
-  c as createTwoFilesPatch,
-  cssDiff,
-  diffArrays,
-  diffChars,
-  diffCss,
-  diffJson,
-  d as diffLines,
-  diffSentences,
-  a as diffTrimmedLines,
-  diffWords,
-  diffWordsWithSpace,
-  f as formatPatch,
-  jsonDiff,
-  l as lineDiff,
-  parsePatch,
-  reversePatch,
-  sentenceDiff,
-  s as structuredPatch,
-  wordDiff,
-  wordsWithSpaceDiff
-};