@surgeapi/node 0.30.0 → 0.32.0

package/oidc/node_modules/npm/node_modules/diff/libesm/diff/word.js

@@ -1,276 +0,0 @@
-import Diff from './base.js';
-import { longestCommonPrefix, longestCommonSuffix, replacePrefix, replaceSuffix, removePrefix, removeSuffix, maximumOverlap, leadingWs, trailingWs } from '../util/string.js';
-// 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  ˇ ˇ  Caron
-//  - U+02D8  ˘ ˘  Breve
-//  - U+02D9  ˙ ˙  Dot Above
-//  - U+02DA  ˚ ˚  Ring Above
-//  - U+02DB  ˛ ˛  Ogonek
-//  - U+02DC  ˜ ˜  Small Tilde
-//  - U+02DD  ˝ ˝  Double Acute Accent
-// Latin Extended Additional, 1E00–1EFF
-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}';
-// 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.
-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) {
-        // 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((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;
-        // Change objects representing any insertion or deletion since the last
-        // "keep" change object. There can be at most one of each.
-        let insertion = null;
-        let deletion = null;
-        changes.forEach(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;
-    }
-}
-export const wordDiff = new WordDiff();
-export function diffWords(oldStr, newStr, options) {
-    // This option has never been documented and never will be (it's clearer to
-    // just call `diffWordsWithSpace` directly if you need that behavior), but
-    // has existed in jsdiff for a long time, so we retain support for it here
-    // for the sake of backwards compatibility.
-    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) {
-    // 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) {
-        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) {
-        // 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) {
-            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);
-        }
-        // otherwise we've got a deletion and no insertion
-    }
-    else if (startKeep && endKeep) {
-        const 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.
-        const 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.
-        const 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.
-        const endKeepWsPrefix = leadingWs(endKeep.value);
-        const deletionWsSuffix = trailingWs(deletion.value);
-        const 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.
-        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) {
-        // 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
-        const regex = new RegExp(`(\\r?\\n)|[${extendedWordChars}]+|[^\\S\\n\\r]+|[^${extendedWordChars}]`, 'ug');
-        return value.match(regex) || [];
-    }
-}
-export const wordsWithSpaceDiff = new WordsWithSpaceDiff();
-export function diffWordsWithSpace(oldStr, newStr, options) {
-    return wordsWithSpaceDiff.diff(oldStr, newStr, options);
-}

package/oidc/node_modules/npm/node_modules/diff/libesm/index.js

@@ -1,30 +0,0 @@
-/* See LICENSE file for terms of use */
-/*
- * Text diff implementation.
- *
- * This library supports the following APIs:
- * Diff.diffChars: Character by character diff
- * Diff.diffWords: Word (as defined by \b regex) diff which ignores whitespace
- * Diff.diffLines: Line based diff
- *
- * Diff.diffCss: Diff targeted at CSS content
- *
- * These methods are based on the implementation proposed in
- * "An O(ND) Difference Algorithm and its Variations" (Myers, 1986).
- * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927
- */
-import Diff from './diff/base.js';
-import { diffChars, characterDiff } from './diff/character.js';
-import { diffWords, diffWordsWithSpace, wordDiff, wordsWithSpaceDiff } from './diff/word.js';
-import { diffLines, diffTrimmedLines, lineDiff } from './diff/line.js';
-import { diffSentences, sentenceDiff } from './diff/sentence.js';
-import { diffCss, cssDiff } from './diff/css.js';
-import { diffJson, canonicalize, jsonDiff } from './diff/json.js';
-import { diffArrays, arrayDiff } from './diff/array.js';
-import { applyPatch, applyPatches } from './patch/apply.js';
-import { parsePatch } from './patch/parse.js';
-import { reversePatch } from './patch/reverse.js';
-import { structuredPatch, createTwoFilesPatch, createPatch, formatPatch } from './patch/create.js';
-import { convertChangesToDMP } from './convert/dmp.js';
-import { convertChangesToXML } from './convert/xml.js';
-export { Diff, diffChars, characterDiff, diffWords, wordDiff, diffWordsWithSpace, wordsWithSpaceDiff, diffLines, lineDiff, diffTrimmedLines, diffSentences, sentenceDiff, diffCss, cssDiff, diffJson, jsonDiff, diffArrays, arrayDiff, structuredPatch, createTwoFilesPatch, createPatch, formatPatch, applyPatch, applyPatches, parsePatch, reversePatch, convertChangesToDMP, convertChangesToXML, canonicalize };

package/oidc/node_modules/npm/node_modules/diff/libesm/package.json

@@ -1 +0,0 @@
-{"type":"module","sideEffects":false}

package/oidc/node_modules/npm/node_modules/diff/libesm/patch/apply.js

@@ -1,257 +0,0 @@
-import { hasOnlyWinLineEndings, hasOnlyUnixLineEndings } from '../util/string.js';
-import { isWin, isUnix, unixToWin, winToUnix } from './line-endings.js';
-import { parsePatch } from './parse.js';
-import distanceIterator from '../util/distance-iterator.js';
-/**
- * attempts to apply a unified diff patch.
- *
- * Hunks are applied first to last.
- * `applyPatch` first tries to apply the first hunk at the line number specified in the hunk header, and with all context lines matching exactly.
- * If that fails, it tries scanning backwards and forwards, one line at a time, to find a place to apply the hunk where the context lines match exactly.
- * If that still fails, and `fuzzFactor` is greater than zero, it increments the maximum number of mismatches (missing, extra, or changed context lines) that there can be between the hunk context and a region where we are trying to apply the patch such that the hunk will still be considered to match.
- * Regardless of `fuzzFactor`, lines to be deleted in the hunk *must* be present for a hunk to match, and the context lines *immediately* before and after an insertion must match exactly.
- *
- * Once a hunk is successfully fitted, the process begins again with the next hunk.
- * Regardless of `fuzzFactor`, later hunks must be applied later in the file than earlier hunks.
- *
- * If a hunk cannot be successfully fitted *anywhere* with fewer than `fuzzFactor` mismatches, `applyPatch` fails and returns `false`.
- *
- * If a hunk is successfully fitted but not at the line number specified by the hunk header, all subsequent hunks have their target line number adjusted accordingly.
- * (e.g. if the first hunk is applied 10 lines below where the hunk header said it should fit, `applyPatch` will *start* looking for somewhere to apply the second hunk 10 lines below where its hunk header says it goes.)
- *
- * If the patch was applied successfully, returns a string containing the patched text.
- * If the patch could not be applied (because some hunks in the patch couldn't be fitted to the text in `source`), `applyPatch` returns false.
- *
- * @param patch a string diff or the output from the `parsePatch` or `structuredPatch` methods.
- */
-export 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);
-        }
-    }
-    // Apply the diff to the input
-    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');
-    }
-    // Special case for empty patch.
-    if (!hunks.length) {
-        return source;
-    }
-    // Before anything else, handle EOFNL insertion/removal. If the patch tells us to make a change
-    // to the EOFNL that is redundant/impossible - i.e. to remove a newline that's not there, or add a
-    // newline that already exists - then we either return false and fail to apply the patch (if
-    // fuzzFactor is 0) or simply ignore the problem and do nothing (if fuzzFactor is >0).
-    // If we do need to remove/add a newline at EOF, this will always be in the final hunk:
-    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) {
-            // This means the final line gets changed but doesn't have a trailing newline in either the
-            // original or patched version. In that case, we do nothing if fuzzFactor > 0, and if
-            // fuzzFactor is 0, we simply validate that the source file has no trailing newline.
-            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;
-        }
-    }
-    /**
-     * Checks if the hunk can be made to fit at the provided location with at most `maxErrors`
-     * insertions, substitutions, or deletions, while ensuring also that:
-     * - lines deleted in the hunk match exactly, and
-     * - wherever an insertion operation or block of insertion operations appears in the hunk, the
-     *   immediately preceding and following lines of context match exactly
-     *
-     * `toPos` should be set such that lines[toPos] is meant to match hunkLines[0].
-     *
-     * If the hunk can be applied, returns an object with properties `oldLineLastI` and
-     * `replacementLines`. Otherwise, returns null.
-     */
-    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;
-                    }
-                    // Consider 3 possibilities in sequence:
-                    // 1. lines contains a *substitution* not included in the patch context, or
-                    // 2. lines contains an *insertion* not included in the patch context, or
-                    // 3. lines contains a *deletion* not included in the patch context
-                    // The first two options are of course only possible if the line from lines is non-null -
-                    // i.e. only option 3 is possible if we've overrun the end of the old file.
-                    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));
-                }
-            }
-        }
-        // Before returning, trim any unmodified context lines off the end of patchedLines and reduce
-        // toPos (and thus oldLineLastI) accordingly. This allows later hunks to be applied to a region
-        // that starts in this hunk's trailing context.
-        patchedLinesLength -= nConsecutiveOldContextLines;
-        toPos -= nConsecutiveOldContextLines;
-        patchedLines.length = patchedLinesLength;
-        return {
-            patchedLines,
-            oldLineLastI: toPos - 1
-        };
-    }
-    const resultLines = [];
-    // Search best fit offsets for each hunk based on the previous ones
-    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 !== undefined; toPos = iterator()) {
-                hunkResult = applyHunk(hunk.lines, toPos, maxErrors);
-                if (hunkResult) {
-                    break;
-                }
-            }
-            if (hunkResult) {
-                break;
-            }
-        }
-        if (!hunkResult) {
-            return false;
-        }
-        // Copy everything from the end of where we applied the last hunk to the start of this hunk
-        for (let i = minLine; i < toPos; i++) {
-            resultLines.push(lines[i]);
-        }
-        // Add the lines produced by applying the hunk:
-        for (let i = 0; i < hunkResult.patchedLines.length; i++) {
-            const line = hunkResult.patchedLines[i];
-            resultLines.push(line);
-        }
-        // Set lower text limit to end of the current hunk, so next ones don't try
-        // to fit over already patched text
-        minLine = hunkResult.oldLineLastI + 1;
-        // Note the offset between where the patch said the hunk should've applied and where we
-        // applied it, so we can adjust future hunks accordingly:
-        prevHunkOffset = toPos + 1 - hunk.oldStart;
-    }
-    // Copy over the rest of the lines from the old text
-    for (let i = minLine; i < lines.length; i++) {
-        resultLines.push(lines[i]);
-    }
-    return resultLines.join('\n');
-}
-/**
- * applies one or more patches.
- *
- * `patch` may be either an array of structured patch objects, or a string representing a patch in unified diff format (which may patch one or more files).
- *
- * This method will iterate over the contents of the patch and apply to data provided through callbacks. The general flow for each patch index is:
- *
- * - `options.loadFile(index, callback)` is called. The caller should then load the contents of the file and then pass that to the `callback(err, data)` callback. Passing an `err` will terminate further patch execution.
- * - `options.patched(index, content, callback)` is called once the patch has been applied. `content` will be the return value from `applyPatch`. When it's ready, the caller should call `callback(err)` callback. Passing an `err` will terminate further patch execution.
- *
- * Once all patches have been applied or an error occurs, the `options.complete(err)` callback is made.
- */
-export 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 (err) {
-                if (err) {
-                    return options.complete(err);
-                }
-                processIndex();
-            });
-        });
-    }
-    processIndex();
-}