@oneblink/release-cli 1.1.1 → 1.2.0-beta.3

package/node_modules/patch-package/dist/patch/apply.js

@@ -0,0 +1,197 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeEffects = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = require("path");
+const assertNever_1 = require("../assertNever");
+const executeEffects = (effects, { dryRun }) => {
+    effects.forEach(eff => {
+        switch (eff.type) {
+            case "file deletion":
+                if (dryRun) {
+                    if (!fs_extra_1.default.existsSync(eff.path)) {
+                        throw new Error("Trying to delete file that doesn't exist: " + eff.path);
+                    }
+                }
+                else {
+                    // TODO: integrity checks
+                    fs_extra_1.default.unlinkSync(eff.path);
+                }
+                break;
+            case "rename":
+                if (dryRun) {
+                    // TODO: see what patch files look like if moving to exising path
+                    if (!fs_extra_1.default.existsSync(eff.fromPath)) {
+                        throw new Error("Trying to move file that doesn't exist: " + eff.fromPath);
+                    }
+                }
+                else {
+                    fs_extra_1.default.moveSync(eff.fromPath, eff.toPath);
+                }
+                break;
+            case "file creation":
+                if (dryRun) {
+                    if (fs_extra_1.default.existsSync(eff.path)) {
+                        throw new Error("Trying to create file that already exists: " + eff.path);
+                    }
+                    // todo: check file contents matches
+                }
+                else {
+                    const fileContents = eff.hunk
+                        ? eff.hunk.parts[0].lines.join("\n") +
+                            (eff.hunk.parts[0].noNewlineAtEndOfFile ? "" : "\n")
+                        : "";
+                    fs_extra_1.default.ensureDirSync(path_1.dirname(eff.path));
+                    fs_extra_1.default.writeFileSync(eff.path, fileContents, { mode: eff.mode });
+                }
+                break;
+            case "patch":
+                applyPatch(eff, { dryRun });
+                break;
+            case "mode change":
+                const currentMode = fs_extra_1.default.statSync(eff.path).mode;
+                if (((isExecutable(eff.newMode) && isExecutable(currentMode)) ||
+                    (!isExecutable(eff.newMode) && !isExecutable(currentMode))) &&
+                    dryRun) {
+                    console.warn(`Mode change is not required for file ${eff.path}`);
+                }
+                fs_extra_1.default.chmodSync(eff.path, eff.newMode);
+                break;
+            default:
+                assertNever_1.assertNever(eff);
+        }
+    });
+};
+exports.executeEffects = executeEffects;
+function isExecutable(fileMode) {
+    // tslint:disable-next-line:no-bitwise
+    return (fileMode & 64) > 0;
+}
+const trimRight = (s) => s.replace(/\s+$/, "");
+function linesAreEqual(a, b) {
+    return trimRight(a) === trimRight(b);
+}
+/**
+ * How does noNewLineAtEndOfFile work?
+ *
+ * if you remove the newline from a file that had one without editing other bits:
+ *
+ *    it creates an insertion/removal pair where the insertion has \ No new line at end of file
+ *
+ * if you edit a file that didn't have a new line and don't add one:
+ *
+ *    both insertion and deletion have \ No new line at end of file
+ *
+ * if you edit a file that didn't have a new line and add one:
+ *
+ *    deletion has \ No new line at end of file
+ *    but not insertion
+ *
+ * if you edit a file that had a new line and leave it in:
+ *
+ *    neither insetion nor deletion have the annoation
+ *
+ */
+function applyPatch({ hunks, path }, { dryRun }) {
+    // modifying the file in place
+    const fileContents = fs_extra_1.default.readFileSync(path).toString();
+    const mode = fs_extra_1.default.statSync(path).mode;
+    const fileLines = fileContents.split(/\n/);
+    const result = [];
+    for (const hunk of hunks) {
+        let fuzzingOffset = 0;
+        while (true) {
+            const modifications = evaluateHunk(hunk, fileLines, fuzzingOffset);
+            if (modifications) {
+                result.push(modifications);
+                break;
+            }
+            fuzzingOffset =
+                fuzzingOffset < 0 ? fuzzingOffset * -1 : fuzzingOffset * -1 - 1;
+            if (Math.abs(fuzzingOffset) > 20) {
+                throw new Error(`Cant apply hunk ${hunks.indexOf(hunk)} for file ${path}`);
+            }
+        }
+    }
+    if (dryRun) {
+        return;
+    }
+    let diffOffset = 0;
+    for (const modifications of result) {
+        for (const modification of modifications) {
+            switch (modification.type) {
+                case "splice":
+                    fileLines.splice(modification.index + diffOffset, modification.numToDelete, ...modification.linesToInsert);
+                    diffOffset +=
+                        modification.linesToInsert.length - modification.numToDelete;
+                    break;
+                case "pop":
+                    fileLines.pop();
+                    break;
+                case "push":
+                    fileLines.push(modification.line);
+                    break;
+                default:
+                    assertNever_1.assertNever(modification);
+            }
+        }
+    }
+    fs_extra_1.default.writeFileSync(path, fileLines.join("\n"), { mode });
+}
+function evaluateHunk(hunk, fileLines, fuzzingOffset) {
+    const result = [];
+    let contextIndex = hunk.header.original.start - 1 + fuzzingOffset;
+    // do bounds checks for index
+    if (contextIndex < 0) {
+        return null;
+    }
+    if (fileLines.length - contextIndex < hunk.header.original.length) {
+        return null;
+    }
+    for (const part of hunk.parts) {
+        switch (part.type) {
+            case "deletion":
+            case "context":
+                for (const line of part.lines) {
+                    const originalLine = fileLines[contextIndex];
+                    if (!linesAreEqual(originalLine, line)) {
+                        return null;
+                    }
+                    contextIndex++;
+                }
+                if (part.type === "deletion") {
+                    result.push({
+                        type: "splice",
+                        index: contextIndex - part.lines.length,
+                        numToDelete: part.lines.length,
+                        linesToInsert: [],
+                    });
+                    if (part.noNewlineAtEndOfFile) {
+                        result.push({
+                            type: "push",
+                            line: "",
+                        });
+                    }
+                }
+                break;
+            case "insertion":
+                result.push({
+                    type: "splice",
+                    index: contextIndex,
+                    numToDelete: 0,
+                    linesToInsert: part.lines,
+                });
+                if (part.noNewlineAtEndOfFile) {
+                    result.push({ type: "pop" });
+                }
+                break;
+            default:
+                assertNever_1.assertNever(part.type);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apply.js","sourceRoot":"","sources":["../../src/patch/apply.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs-extra\"\nimport { dirname } from \"path\"\nimport { ParsedPatchFile, FilePatch, Hunk } from \"./parse\"\nimport { assertNever } from \"../assertNever\"\n\nexport const executeEffects = (\n  effects: ParsedPatchFile,\n  { dryRun }: { dryRun: boolean },\n) => {\n  effects.forEach(eff => {\n    switch (eff.type) {\n      case \"file deletion\":\n        if (dryRun) {\n          if (!fs.existsSync(eff.path)) {\n            throw new Error(\n              \"Trying to delete file that doesn't exist: \" + eff.path,\n            )\n          }\n        } else {\n          // TODO: integrity checks\n          fs.unlinkSync(eff.path)\n        }\n        break\n      case \"rename\":\n        if (dryRun) {\n          // TODO: see what patch files look like if moving to exising path\n          if (!fs.existsSync(eff.fromPath)) {\n            throw new Error(\n              \"Trying to move file that doesn't exist: \" + eff.fromPath,\n            )\n          }\n        } else {\n          fs.moveSync(eff.fromPath, eff.toPath)\n        }\n        break\n      case \"file creation\":\n        if (dryRun) {\n          if (fs.existsSync(eff.path)) {\n            throw new Error(\n              \"Trying to create file that already exists: \" + eff.path,\n            )\n          }\n          // todo: check file contents matches\n        } else {\n          const fileContents = eff.hunk\n            ? eff.hunk.parts[0].lines.join(\"\\n\") +\n              (eff.hunk.parts[0].noNewlineAtEndOfFile ? \"\" : \"\\n\")\n            : \"\"\n          fs.ensureDirSync(dirname(eff.path))\n          fs.writeFileSync(eff.path, fileContents, { mode: eff.mode })\n        }\n        break\n      case \"patch\":\n        applyPatch(eff, { dryRun })\n        break\n      case \"mode change\":\n        const currentMode = fs.statSync(eff.path).mode\n        if (\n          ((isExecutable(eff.newMode) && isExecutable(currentMode)) ||\n            (!isExecutable(eff.newMode) && !isExecutable(currentMode))) &&\n          dryRun\n        ) {\n          console.warn(`Mode change is not required for file ${eff.path}`)\n        }\n        fs.chmodSync(eff.path, eff.newMode)\n        break\n      default:\n        assertNever(eff)\n    }\n  })\n}\n\nfunction isExecutable(fileMode: number) {\n  // tslint:disable-next-line:no-bitwise\n  return (fileMode & 0b001_000_000) > 0\n}\n\nconst trimRight = (s: string) => s.replace(/\\s+$/, \"\")\nfunction linesAreEqual(a: string, b: string) {\n  return trimRight(a) === trimRight(b)\n}\n\n/**\n * How does noNewLineAtEndOfFile work?\n *\n * if you remove the newline from a file that had one without editing other bits:\n *\n *    it creates an insertion/removal pair where the insertion has \\ No new line at end of file\n *\n * if you edit a file that didn't have a new line and don't add one:\n *\n *    both insertion and deletion have \\ No new line at end of file\n *\n * if you edit a file that didn't have a new line and add one:\n *\n *    deletion has \\ No new line at end of file\n *    but not insertion\n *\n * if you edit a file that had a new line and leave it in:\n *\n *    neither insetion nor deletion have the annoation\n *\n */\n\nfunction applyPatch(\n  { hunks, path }: FilePatch,\n  { dryRun }: { dryRun: boolean },\n): void {\n  // modifying the file in place\n  const fileContents = fs.readFileSync(path).toString()\n  const mode = fs.statSync(path).mode\n\n  const fileLines: string[] = fileContents.split(/\\n/)\n\n  const result: Modificaiton[][] = []\n\n  for (const hunk of hunks) {\n    let fuzzingOffset = 0\n    while (true) {\n      const modifications = evaluateHunk(hunk, fileLines, fuzzingOffset)\n      if (modifications) {\n        result.push(modifications)\n        break\n      }\n\n      fuzzingOffset =\n        fuzzingOffset < 0 ? fuzzingOffset * -1 : fuzzingOffset * -1 - 1\n\n      if (Math.abs(fuzzingOffset) > 20) {\n        throw new Error(\n          `Cant apply hunk ${hunks.indexOf(hunk)} for file ${path}`,\n        )\n      }\n    }\n  }\n\n  if (dryRun) {\n    return\n  }\n\n  let diffOffset = 0\n\n  for (const modifications of result) {\n    for (const modification of modifications) {\n      switch (modification.type) {\n        case \"splice\":\n          fileLines.splice(\n            modification.index + diffOffset,\n            modification.numToDelete,\n            ...modification.linesToInsert,\n          )\n          diffOffset +=\n            modification.linesToInsert.length - modification.numToDelete\n          break\n        case \"pop\":\n          fileLines.pop()\n          break\n        case \"push\":\n          fileLines.push(modification.line)\n          break\n        default:\n          assertNever(modification)\n      }\n    }\n  }\n\n  fs.writeFileSync(path, fileLines.join(\"\\n\"), { mode })\n}\n\ninterface Push {\n  type: \"push\"\n  line: string\n}\ninterface Pop {\n  type: \"pop\"\n}\ninterface Splice {\n  type: \"splice\"\n  index: number\n  numToDelete: number\n  linesToInsert: string[]\n}\n\ntype Modificaiton = Push | Pop | Splice\n\nfunction evaluateHunk(\n  hunk: Hunk,\n  fileLines: string[],\n  fuzzingOffset: number,\n): Modificaiton[] | null {\n  const result: Modificaiton[] = []\n  let contextIndex = hunk.header.original.start - 1 + fuzzingOffset\n  // do bounds checks for index\n  if (contextIndex < 0) {\n    return null\n  }\n  if (fileLines.length - contextIndex < hunk.header.original.length) {\n    return null\n  }\n\n  for (const part of hunk.parts) {\n    switch (part.type) {\n      case \"deletion\":\n      case \"context\":\n        for (const line of part.lines) {\n          const originalLine = fileLines[contextIndex]\n          if (!linesAreEqual(originalLine, line)) {\n            return null\n          }\n          contextIndex++\n        }\n\n        if (part.type === \"deletion\") {\n          result.push({\n            type: \"splice\",\n            index: contextIndex - part.lines.length,\n            numToDelete: part.lines.length,\n            linesToInsert: [],\n          })\n\n          if (part.noNewlineAtEndOfFile) {\n            result.push({\n              type: \"push\",\n              line: \"\",\n            })\n          }\n        }\n        break\n      case \"insertion\":\n        result.push({\n          type: \"splice\",\n          index: contextIndex,\n          numToDelete: 0,\n          linesToInsert: part.lines,\n        })\n        if (part.noNewlineAtEndOfFile) {\n          result.push({ type: \"pop\" })\n        }\n        break\n      default:\n        assertNever(part.type)\n    }\n  }\n\n  return result\n}\n"]}

package/node_modules/patch-package/dist/patch/parse.js

@@ -0,0 +1,330 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyHunkIntegrity = exports.parsePatchFile = exports.interpretParsedPatchFile = exports.EXECUTABLE_FILE_MODE = exports.NON_EXECUTABLE_FILE_MODE = exports.parseHunkHeaderLine = void 0;
+const assertNever_1 = require("../assertNever");
+const parseHunkHeaderLine = (headerLine) => {
+    const match = headerLine
+        .trim()
+        .match(/^@@ -(\d+)(,(\d+))? \+(\d+)(,(\d+))? @@.*/);
+    if (!match) {
+        throw new Error(`Bad header line: '${headerLine}'`);
+    }
+    return {
+        original: {
+            start: Math.max(Number(match[1]), 1),
+            length: Number(match[3] || 1),
+        },
+        patched: {
+            start: Math.max(Number(match[4]), 1),
+            length: Number(match[6] || 1),
+        },
+    };
+};
+exports.parseHunkHeaderLine = parseHunkHeaderLine;
+exports.NON_EXECUTABLE_FILE_MODE = 0o644;
+exports.EXECUTABLE_FILE_MODE = 0o755;
+const emptyFilePatch = () => ({
+    diffLineFromPath: null,
+    diffLineToPath: null,
+    oldMode: null,
+    newMode: null,
+    deletedFileMode: null,
+    newFileMode: null,
+    renameFrom: null,
+    renameTo: null,
+    beforeHash: null,
+    afterHash: null,
+    fromPath: null,
+    toPath: null,
+    hunks: null,
+});
+const emptyHunk = (headerLine) => ({
+    header: exports.parseHunkHeaderLine(headerLine),
+    parts: [],
+});
+const hunkLinetypes = {
+    "@": "header",
+    "-": "deletion",
+    "+": "insertion",
+    " ": "context",
+    "\\": "pragma",
+    // Treat blank lines as context
+    undefined: "context",
+};
+function parsePatchLines(lines, { supportLegacyDiffs }) {
+    const result = [];
+    let currentFilePatch = emptyFilePatch();
+    let state = "parsing header";
+    let currentHunk = null;
+    let currentHunkMutationPart = null;
+    function commitHunk() {
+        if (currentHunk) {
+            if (currentHunkMutationPart) {
+                currentHunk.parts.push(currentHunkMutationPart);
+                currentHunkMutationPart = null;
+            }
+            currentFilePatch.hunks.push(currentHunk);
+            currentHunk = null;
+        }
+    }
+    function commitFilePatch() {
+        commitHunk();
+        result.push(currentFilePatch);
+        currentFilePatch = emptyFilePatch();
+    }
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (state === "parsing header") {
+            if (line.startsWith("@@")) {
+                state = "parsing hunks";
+                currentFilePatch.hunks = [];
+                i--;
+            }
+            else if (line.startsWith("diff --git ")) {
+                if (currentFilePatch && currentFilePatch.diffLineFromPath) {
+                    commitFilePatch();
+                }
+                const match = line.match(/^diff --git a\/(.*?) b\/(.*?)\s*$/);
+                if (!match) {
+                    throw new Error("Bad diff line: " + line);
+                }
+                currentFilePatch.diffLineFromPath = match[1];
+                currentFilePatch.diffLineToPath = match[2];
+            }
+            else if (line.startsWith("old mode ")) {
+                currentFilePatch.oldMode = line.slice("old mode ".length).trim();
+            }
+            else if (line.startsWith("new mode ")) {
+                currentFilePatch.newMode = line.slice("new mode ".length).trim();
+            }
+            else if (line.startsWith("deleted file mode ")) {
+                currentFilePatch.deletedFileMode = line
+                    .slice("deleted file mode ".length)
+                    .trim();
+            }
+            else if (line.startsWith("new file mode ")) {
+                currentFilePatch.newFileMode = line
+                    .slice("new file mode ".length)
+                    .trim();
+            }
+            else if (line.startsWith("rename from ")) {
+                currentFilePatch.renameFrom = line.slice("rename from ".length).trim();
+            }
+            else if (line.startsWith("rename to ")) {
+                currentFilePatch.renameTo = line.slice("rename to ".length).trim();
+            }
+            else if (line.startsWith("index ")) {
+                const match = line.match(/(\w+)\.\.(\w+)/);
+                if (!match) {
+                    continue;
+                }
+                currentFilePatch.beforeHash = match[1];
+                currentFilePatch.afterHash = match[2];
+            }
+            else if (line.startsWith("--- ")) {
+                currentFilePatch.fromPath = line.slice("--- a/".length).trim();
+            }
+            else if (line.startsWith("+++ ")) {
+                currentFilePatch.toPath = line.slice("+++ b/".length).trim();
+            }
+        }
+        else {
+            if (supportLegacyDiffs && line.startsWith("--- a/")) {
+                state = "parsing header";
+                commitFilePatch();
+                i--;
+                continue;
+            }
+            // parsing hunks
+            const lineType = hunkLinetypes[line[0]] || null;
+            switch (lineType) {
+                case "header":
+                    commitHunk();
+                    currentHunk = emptyHunk(line);
+                    break;
+                case null:
+                    // unrecognized, bail out
+                    state = "parsing header";
+                    commitFilePatch();
+                    i--;
+                    break;
+                case "pragma":
+                    if (!line.startsWith("\")) {
+                        throw new Error("Unrecognized pragma in patch file: " + line);
+                    }
+                    if (!currentHunkMutationPart) {
+                        throw new Error("Bad parser state: No newline at EOF pragma encountered without context");
+                    }
+                    currentHunkMutationPart.noNewlineAtEndOfFile = true;
+                    break;
+                case "insertion":
+                case "deletion":
+                case "context":
+                    if (!currentHunk) {
+                        throw new Error("Bad parser state: Hunk lines encountered before hunk header");
+                    }
+                    if (currentHunkMutationPart &&
+                        currentHunkMutationPart.type !== lineType) {
+                        currentHunk.parts.push(currentHunkMutationPart);
+                        currentHunkMutationPart = null;
+                    }
+                    if (!currentHunkMutationPart) {
+                        currentHunkMutationPart = {
+                            type: lineType,
+                            lines: [],
+                            noNewlineAtEndOfFile: false,
+                        };
+                    }
+                    currentHunkMutationPart.lines.push(line.slice(1));
+                    break;
+                default:
+                    // exhausitveness check
+                    assertNever_1.assertNever(lineType);
+            }
+        }
+    }
+    commitFilePatch();
+    for (const { hunks } of result) {
+        if (hunks) {
+            for (const hunk of hunks) {
+                verifyHunkIntegrity(hunk);
+            }
+        }
+    }
+    return result;
+}
+function interpretParsedPatchFile(files) {
+    const result = [];
+    for (const file of files) {
+        const { diffLineFromPath, diffLineToPath, oldMode, newMode, deletedFileMode, newFileMode, renameFrom, renameTo, beforeHash, afterHash, fromPath, toPath, hunks, } = file;
+        const type = renameFrom
+            ? "rename"
+            : deletedFileMode
+                ? "file deletion"
+                : newFileMode
+                    ? "file creation"
+                    : hunks && hunks.length > 0
+                        ? "patch"
+                        : "mode change";
+        let destinationFilePath = null;
+        switch (type) {
+            case "rename":
+                if (!renameFrom || !renameTo) {
+                    throw new Error("Bad parser state: rename from & to not given");
+                }
+                result.push({
+                    type: "rename",
+                    fromPath: renameFrom,
+                    toPath: renameTo,
+                });
+                destinationFilePath = renameTo;
+                break;
+            case "file deletion": {
+                const path = diffLineFromPath || fromPath;
+                if (!path) {
+                    throw new Error("Bad parse state: no path given for file deletion");
+                }
+                result.push({
+                    type: "file deletion",
+                    hunk: (hunks && hunks[0]) || null,
+                    path,
+                    mode: parseFileMode(deletedFileMode),
+                    hash: beforeHash,
+                });
+                break;
+            }
+            case "file creation": {
+                const path = diffLineToPath || toPath;
+                if (!path) {
+                    throw new Error("Bad parse state: no path given for file creation");
+                }
+                result.push({
+                    type: "file creation",
+                    hunk: (hunks && hunks[0]) || null,
+                    path,
+                    mode: parseFileMode(newFileMode),
+                    hash: afterHash,
+                });
+                break;
+            }
+            case "patch":
+            case "mode change":
+                destinationFilePath = toPath || diffLineToPath;
+                break;
+            default:
+                assertNever_1.assertNever(type);
+        }
+        if (destinationFilePath && oldMode && newMode && oldMode !== newMode) {
+            result.push({
+                type: "mode change",
+                path: destinationFilePath,
+                oldMode: parseFileMode(oldMode),
+                newMode: parseFileMode(newMode),
+            });
+        }
+        if (destinationFilePath && hunks && hunks.length) {
+            result.push({
+                type: "patch",
+                path: destinationFilePath,
+                hunks,
+                beforeHash,
+                afterHash,
+            });
+        }
+    }
+    return result;
+}
+exports.interpretParsedPatchFile = interpretParsedPatchFile;
+function parseFileMode(mode) {
+    // tslint:disable-next-line:no-bitwise
+    const parsedMode = parseInt(mode, 8) & 0o777;
+    if (parsedMode !== exports.NON_EXECUTABLE_FILE_MODE &&
+        parsedMode !== exports.EXECUTABLE_FILE_MODE) {
+        throw new Error("Unexpected file mode string: " + mode);
+    }
+    return parsedMode;
+}
+function parsePatchFile(file) {
+    const lines = file.split(/\n/g);
+    if (lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    try {
+        return interpretParsedPatchFile(parsePatchLines(lines, { supportLegacyDiffs: false }));
+    }
+    catch (e) {
+        if (e instanceof Error &&
+            e.message === "hunk header integrity check failed") {
+            return interpretParsedPatchFile(parsePatchLines(lines, { supportLegacyDiffs: true }));
+        }
+        throw e;
+    }
+}
+exports.parsePatchFile = parsePatchFile;
+function verifyHunkIntegrity(hunk) {
+    // verify hunk integrity
+    let originalLength = 0;
+    let patchedLength = 0;
+    for (const { type, lines } of hunk.parts) {
+        switch (type) {
+            case "context":
+                patchedLength += lines.length;
+                originalLength += lines.length;
+                break;
+            case "deletion":
+                originalLength += lines.length;
+                break;
+            case "insertion":
+                patchedLength += lines.length;
+                break;
+            default:
+                assertNever_1.assertNever(type);
+        }
+    }
+    if (originalLength !== hunk.header.original.length ||
+        patchedLength !== hunk.header.patched.length) {
+        throw new Error("hunk header integrity check failed");
+    }
+}
+exports.verifyHunkIntegrity = verifyHunkIntegrity;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parse.js","sourceRoot":"","sources":["../../src/patch/parse.ts"],"names":[],"mappings":";;;AAAA,gDAA4C;AAarC,MAAM,mBAAmB,GAAG,CAAC,UAAkB,EAAc,EAAE;IACpE,MAAM,KAAK,GAAG,UAAU;SACrB,IAAI,EAAE;SACN,KAAK,CAAC,2CAA2C,CAAC,CAAA;IACrD,IAAI,CAAC,KAAK,EAAE;QACV,MAAM,IAAI,KAAK,CAAC,qBAAqB,UAAU,GAAG,CAAC,CAAA;KACpD;IAED,OAAO;QACL,QAAQ,EAAE;YACR,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACpC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;SAC9B;QACD,OAAO,EAAE;YACP,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACpC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;SAC9B;KACF,CAAA;AACH,CAAC,CAAA;AAlBY,QAAA,mBAAmB,uBAkB/B;AAEY,QAAA,wBAAwB,GAAG,KAAK,CAAA;AAChC,QAAA,oBAAoB,GAAG,KAAK,CAAA;AA+EzC,MAAM,cAAc,GAAG,GAAc,EAAE,CAAC,CAAC;IACvC,gBAAgB,EAAE,IAAI;IACtB,cAAc,EAAE,IAAI;IACpB,OAAO,EAAE,IAAI;IACb,OAAO,EAAE,IAAI;IACb,eAAe,EAAE,IAAI;IACrB,WAAW,EAAE,IAAI;IACjB,UAAU,EAAE,IAAI;IAChB,QAAQ,EAAE,IAAI;IACd,UAAU,EAAE,IAAI;IAChB,SAAS,EAAE,IAAI;IACf,QAAQ,EAAE,IAAI;IACd,MAAM,EAAE,IAAI;IACZ,KAAK,EAAE,IAAI;CACZ,CAAC,CAAA;AAEF,MAAM,SAAS,GAAG,CAAC,UAAkB,EAAQ,EAAE,CAAC,CAAC;IAC/C,MAAM,EAAE,2BAAmB,CAAC,UAAU,CAAC;IACvC,KAAK,EAAE,EAAE;CACV,CAAC,CAAA;AAEF,MAAM,aAAa,GAEf;IACF,GAAG,EAAE,QAAQ;IACb,GAAG,EAAE,UAAU;IACf,GAAG,EAAE,WAAW;IAChB,GAAG,EAAE,SAAS;IACd,IAAI,EAAE,QAAQ;IACd,+BAA+B;IAC/B,SAAS,EAAE,SAAS;CACrB,CAAA;AAED,SAAS,eAAe,CACtB,KAAe,EACf,EAAE,kBAAkB,EAAmC;IAEvD,MAAM,MAAM,GAAgB,EAAE,CAAA;IAC9B,IAAI,gBAAgB,GAAc,cAAc,EAAE,CAAA;IAClD,IAAI,KAAK,GAAU,gBAAgB,CAAA;IACnC,IAAI,WAAW,GAAgB,IAAI,CAAA;IACnC,IAAI,uBAAuB,GAA6B,IAAI,CAAA;IAE5D,SAAS,UAAU;QACjB,IAAI,WAAW,EAAE;YACf,IAAI,uBAAuB,EAAE;gBAC3B,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAA;gBAC/C,uBAAuB,GAAG,IAAI,CAAA;aAC/B;YACD,gBAAgB,CAAC,KAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;YACzC,WAAW,GAAG,IAAI,CAAA;SACnB;IACH,CAAC;IAED,SAAS,eAAe;QACtB,UAAU,EAAE,CAAA;QACZ,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAA;QAC7B,gBAAgB,GAAG,cAAc,EAAE,CAAA;IACrC,CAAC;IAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACrC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;QAErB,IAAI,KAAK,KAAK,gBAAgB,EAAE;YAC9B,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;gBACzB,KAAK,GAAG,eAAe,CAAA;gBACvB,gBAAgB,CAAC,KAAK,GAAG,EAAE,CAAA;gBAC3B,CAAC,EAAE,CAAA;aACJ;iBAAM,IAAI,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE;gBACzC,IAAI,gBAAgB,IAAI,gBAAgB,CAAC,gBAAgB,EAAE;oBACzD,eAAe,EAAE,CAAA;iBAClB;gBACD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,mCAAmC,CAAC,CAAA;gBAC7D,IAAI,CAAC,KAAK,EAAE;oBACV,MAAM,IAAI,KAAK,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAA;iBAC1C;gBACD,gBAAgB,CAAC,gBAAgB,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;gBAC5C,gBAAgB,CAAC,cAAc,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;aAC3C;iBAAM,IAAI,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE;gBACvC,gBAAgB,CAAC,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAA;aACjE;iBAAM,IAAI,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE;gBACvC,gBAAgB,CAAC,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAA;aACjE;iBAAM,IAAI,IAAI,CAAC,UAAU,CAAC,oBAAoB,CAAC,EAAE;gBAChD,gBAAgB,CAAC,eAAe,GAAG,IAAI;qBACpC,KAAK,CAAC,oBAAoB,CAAC,MAAM,CAAC;qBAClC,IAAI,EAAE,CAAA;aACV;iBAAM,IAAI,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,EAAE;gBAC5C,gBAAgB,CAAC,WAAW,GAAG,IAAI;qBAChC,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC;qBAC9B,IAAI,EAAE,CAAA;aACV;iBAAM,IAAI,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE;gBAC1C,gBAAgB,CAAC,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAA;aACvE;iBAAM,IAAI,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE;gBACxC,gBAAgB,CAAC,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAA;aACnE;iBAAM,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE;gBACpC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAA;gBAC1C,IAAI,CAAC,KAAK,EAAE;oBACV,SAAQ;iBACT;gBACD,gBAAgB,CAAC,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;gBACtC,gBAAgB,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;aACtC;iBAAM,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;gBAClC,gBAAgB,CAAC,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAA;aAC/D;iBAAM,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;gBAClC,gBAAgB,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAA;aAC7D;SACF;aAAM;YACL,IAAI,kBAAkB,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE;gBACnD,KAAK,GAAG,gBAAgB,CAAA;gBACxB,eAAe,EAAE,CAAA;gBACjB,CAAC,EAAE,CAAA;gBACH,SAAQ;aACT;YACD,gBAAgB;YAChB,MAAM,QAAQ,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAA;YAC/C,QAAQ,QAAQ,EAAE;gBAChB,KAAK,QAAQ;oBACX,UAAU,EAAE,CAAA;oBACZ,WAAW,GAAG,SAAS,CAAC,IAAI,CAAC,CAAA;oBAC7B,MAAK;gBACP,KAAK,IAAI;oBACP,yBAAyB;oBACzB,KAAK,GAAG,gBAAgB,CAAA;oBACxB,eAAe,EAAE,CAAA;oBACjB,CAAC,EAAE,CAAA;oBACH,MAAK;gBACP,KAAK,QAAQ;oBACX,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,8BAA8B,CAAC,EAAE;wBACpD,MAAM,IAAI,KAAK,CAAC,qCAAqC,GAAG,IAAI,CAAC,CAAA;qBAC9D;oBACD,IAAI,CAAC,uBAAuB,EAAE;wBAC5B,MAAM,IAAI,KAAK,CACb,wEAAwE,CACzE,CAAA;qBACF;oBACD,uBAAuB,CAAC,oBAAoB,GAAG,IAAI,CAAA;oBACnD,MAAK;gBACP,KAAK,WAAW,CAAC;gBACjB,KAAK,UAAU,CAAC;gBAChB,KAAK,SAAS;oBACZ,IAAI,CAAC,WAAW,EAAE;wBAChB,MAAM,IAAI,KAAK,CACb,6DAA6D,CAC9D,CAAA;qBACF;oBACD,IACE,uBAAuB;wBACvB,uBAAuB,CAAC,IAAI,KAAK,QAAQ,EACzC;wBACA,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAA;wBAC/C,uBAAuB,GAAG,IAAI,CAAA;qBAC/B;oBACD,IAAI,CAAC,uBAAuB,EAAE;wBAC5B,uBAAuB,GAAG;4BACxB,IAAI,EAAE,QAAQ;4BACd,KAAK,EAAE,EAAE;4BACT,oBAAoB,EAAE,KAAK;yBAC5B,CAAA;qBACF;oBACD,uBAAuB,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;oBACjD,MAAK;gBACP;oBACE,uBAAuB;oBACvB,yBAAW,CAAC,QAAQ,CAAC,CAAA;aACxB;SACF;KACF;IAED,eAAe,EAAE,CAAA;IAEjB,KAAK,MAAM,EAAE,KAAK,EAAE,IAAI,MAAM,EAAE;QAC9B,IAAI,KAAK,EAAE;YACT,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;gBACxB,mBAAmB,CAAC,IAAI,CAAC,CAAA;aAC1B;SACF;KACF;IAED,OAAO,MAAM,CAAA;AACf,CAAC;AAED,SAAgB,wBAAwB,CAAC,KAAkB;IACzD,MAAM,MAAM,GAAoB,EAAE,CAAA;IAElC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;QACxB,MAAM,EACJ,gBAAgB,EAChB,cAAc,EACd,OAAO,EACP,OAAO,EACP,eAAe,EACf,WAAW,EACX,UAAU,EACV,QAAQ,EACR,UAAU,EACV,SAAS,EACT,QAAQ,EACR,MAAM,EACN,KAAK,GACN,GAAG,IAAI,CAAA;QACR,MAAM,IAAI,GAA0B,UAAU;YAC5C,CAAC,CAAC,QAAQ;YACV,CAAC,CAAC,eAAe;gBACjB,CAAC,CAAC,eAAe;gBACjB,CAAC,CAAC,WAAW;oBACb,CAAC,CAAC,eAAe;oBACjB,CAAC,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;wBAC3B,CAAC,CAAC,OAAO;wBACT,CAAC,CAAC,aAAa,CAAA;QAEjB,IAAI,mBAAmB,GAAkB,IAAI,CAAA;QAC7C,QAAQ,IAAI,EAAE;YACZ,KAAK,QAAQ;gBACX,IAAI,CAAC,UAAU,IAAI,CAAC,QAAQ,EAAE;oBAC5B,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAA;iBAChE;gBACD,MAAM,CAAC,IAAI,CAAC;oBACV,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,UAAU;oBACpB,MAAM,EAAE,QAAQ;iBACjB,CAAC,CAAA;gBACF,mBAAmB,GAAG,QAAQ,CAAA;gBAC9B,MAAK;YACP,KAAK,eAAe,CAAC,CAAC;gBACpB,MAAM,IAAI,GAAG,gBAAgB,IAAI,QAAQ,CAAA;gBACzC,IAAI,CAAC,IAAI,EAAE;oBACT,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAA;iBACpE;gBACD,MAAM,CAAC,IAAI,CAAC;oBACV,IAAI,EAAE,eAAe;oBACrB,IAAI,EAAE,CAAC,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;oBACjC,IAAI;oBACJ,IAAI,EAAE,aAAa,CAAC,eAAgB,CAAC;oBACrC,IAAI,EAAE,UAAU;iBACjB,CAAC,CAAA;gBACF,MAAK;aACN;YACD,KAAK,eAAe,CAAC,CAAC;gBACpB,MAAM,IAAI,GAAG,cAAc,IAAI,MAAM,CAAA;gBACrC,IAAI,CAAC,IAAI,EAAE;oBACT,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAA;iBACpE;gBACD,MAAM,CAAC,IAAI,CAAC;oBACV,IAAI,EAAE,eAAe;oBACrB,IAAI,EAAE,CAAC,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;oBACjC,IAAI;oBACJ,IAAI,EAAE,aAAa,CAAC,WAAY,CAAC;oBACjC,IAAI,EAAE,SAAS;iBAChB,CAAC,CAAA;gBACF,MAAK;aACN;YACD,KAAK,OAAO,CAAC;YACb,KAAK,aAAa;gBAChB,mBAAmB,GAAG,MAAM,IAAI,cAAc,CAAA;gBAC9C,MAAK;YACP;gBACE,yBAAW,CAAC,IAAI,CAAC,CAAA;SACpB;QAED,IAAI,mBAAmB,IAAI,OAAO,IAAI,OAAO,IAAI,OAAO,KAAK,OAAO,EAAE;YACpE,MAAM,CAAC,IAAI,CAAC;gBACV,IAAI,EAAE,aAAa;gBACnB,IAAI,EAAE,mBAAmB;gBACzB,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC;gBAC/B,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC;aAChC,CAAC,CAAA;SACH;QAED,IAAI,mBAAmB,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE;YAChD,MAAM,CAAC,IAAI,CAAC;gBACV,IAAI,EAAE,OAAO;gBACb,IAAI,EAAE,mBAAmB;gBACzB,KAAK;gBACL,UAAU;gBACV,SAAS;aACV,CAAC,CAAA;SACH;KACF;IAED,OAAO,MAAM,CAAA;AACf,CAAC;AAnGD,4DAmGC;AAED,SAAS,aAAa,CAAC,IAAY;IACjC,sCAAsC;IACtC,MAAM,UAAU,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,KAAK,CAAA;IAC5C,IACE,UAAU,KAAK,gCAAwB;QACvC,UAAU,KAAK,4BAAoB,EACnC;QACA,MAAM,IAAI,KAAK,CAAC,+BAA+B,GAAG,IAAI,CAAC,CAAA;KACxD;IACD,OAAO,UAAU,CAAA;AACnB,CAAC;AAED,SAAgB,cAAc,CAAC,IAAY;IACzC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;IAC/B,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QAClC,KAAK,CAAC,GAAG,EAAE,CAAA;KACZ;IACD,IAAI;QACF,OAAO,wBAAwB,CAC7B,eAAe,CAAC,KAAK,EAAE,EAAE,kBAAkB,EAAE,KAAK,EAAE,CAAC,CACtD,CAAA;KACF;IAAC,OAAO,CAAC,EAAE;QACV,IACE,CAAC,YAAY,KAAK;YAClB,CAAC,CAAC,OAAO,KAAK,oCAAoC,EAClD;YACA,OAAO,wBAAwB,CAC7B,eAAe,CAAC,KAAK,EAAE,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC,CACrD,CAAA;SACF;QACD,MAAM,CAAC,CAAA;KACR;AACH,CAAC;AApBD,wCAoBC;AAED,SAAgB,mBAAmB,CAAC,IAAU;IAC5C,wBAAwB;IACxB,IAAI,cAAc,GAAG,CAAC,CAAA;IACtB,IAAI,aAAa,GAAG,CAAC,CAAA;IACrB,KAAK,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,IAAI,CAAC,KAAK,EAAE;QACxC,QAAQ,IAAI,EAAE;YACZ,KAAK,SAAS;gBACZ,aAAa,IAAI,KAAK,CAAC,MAAM,CAAA;gBAC7B,cAAc,IAAI,KAAK,CAAC,MAAM,CAAA;gBAC9B,MAAK;YACP,KAAK,UAAU;gBACb,cAAc,IAAI,KAAK,CAAC,MAAM,CAAA;gBAC9B,MAAK;YACP,KAAK,WAAW;gBACd,aAAa,IAAI,KAAK,CAAC,MAAM,CAAA;gBAC7B,MAAK;YACP;gBACE,yBAAW,CAAC,IAAI,CAAC,CAAA;SACpB;KACF;IAED,IACE,cAAc,KAAK,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM;QAC9C,aAAa,KAAK,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,EAC5C;QACA,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAA;KACtD;AACH,CAAC;AA3BD,kDA2BC","sourcesContent":["import { assertNever } from \"../assertNever\"\n\nexport interface HunkHeader {\n  original: {\n    start: number\n    length: number\n  }\n  patched: {\n    start: number\n    length: number\n  }\n}\n\nexport const parseHunkHeaderLine = (headerLine: string): HunkHeader => {\n  const match = headerLine\n    .trim()\n    .match(/^@@ -(\\d+)(,(\\d+))? \\+(\\d+)(,(\\d+))? @@.*/)\n  if (!match) {\n    throw new Error(`Bad header line: '${headerLine}'`)\n  }\n\n  return {\n    original: {\n      start: Math.max(Number(match[1]), 1),\n      length: Number(match[3] || 1),\n    },\n    patched: {\n      start: Math.max(Number(match[4]), 1),\n      length: Number(match[6] || 1),\n    },\n  }\n}\n\nexport const NON_EXECUTABLE_FILE_MODE = 0o644\nexport const EXECUTABLE_FILE_MODE = 0o755\n\ntype FileMode = typeof NON_EXECUTABLE_FILE_MODE | typeof EXECUTABLE_FILE_MODE\n\ninterface PatchMutationPart {\n  type: \"context\" | \"insertion\" | \"deletion\"\n  lines: string[]\n  noNewlineAtEndOfFile: boolean\n}\n\ninterface FileRename {\n  type: \"rename\"\n  fromPath: string\n  toPath: string\n}\n\ninterface FileModeChange {\n  type: \"mode change\"\n  path: string\n  oldMode: FileMode\n  newMode: FileMode\n}\n\nexport interface FilePatch {\n  type: \"patch\"\n  path: string\n  hunks: Hunk[]\n  beforeHash: string | null\n  afterHash: string | null\n}\n\ninterface FileDeletion {\n  type: \"file deletion\"\n  path: string\n  mode: FileMode\n  hunk: Hunk | null\n  hash: string | null\n}\n\ninterface FileCreation {\n  type: \"file creation\"\n  mode: FileMode\n  path: string\n  hunk: Hunk | null\n  hash: string | null\n}\n\nexport type PatchFilePart =\n  | FilePatch\n  | FileDeletion\n  | FileCreation\n  | FileRename\n  | FileModeChange\n\nexport type ParsedPatchFile = PatchFilePart[]\n\ntype State = \"parsing header\" | \"parsing hunks\"\n\ninterface FileDeets {\n  diffLineFromPath: string | null\n  diffLineToPath: string | null\n  oldMode: string | null\n  newMode: string | null\n  deletedFileMode: string | null\n  newFileMode: string | null\n  renameFrom: string | null\n  renameTo: string | null\n  beforeHash: string | null\n  afterHash: string | null\n  fromPath: string | null\n  toPath: string | null\n  hunks: Hunk[] | null\n}\n\nexport interface Hunk {\n  header: HunkHeader\n  parts: PatchMutationPart[]\n}\n\nconst emptyFilePatch = (): FileDeets => ({\n  diffLineFromPath: null,\n  diffLineToPath: null,\n  oldMode: null,\n  newMode: null,\n  deletedFileMode: null,\n  newFileMode: null,\n  renameFrom: null,\n  renameTo: null,\n  beforeHash: null,\n  afterHash: null,\n  fromPath: null,\n  toPath: null,\n  hunks: null,\n})\n\nconst emptyHunk = (headerLine: string): Hunk => ({\n  header: parseHunkHeaderLine(headerLine),\n  parts: [],\n})\n\nconst hunkLinetypes: {\n  [k: string]: PatchMutationPart[\"type\"] | \"pragma\" | \"header\"\n} = {\n  \"@\": \"header\",\n  \"-\": \"deletion\",\n  \"+\": \"insertion\",\n  \" \": \"context\",\n  \"\\\\\": \"pragma\",\n  // Treat blank lines as context\n  undefined: \"context\",\n}\n\nfunction parsePatchLines(\n  lines: string[],\n  { supportLegacyDiffs }: { supportLegacyDiffs: boolean },\n): FileDeets[] {\n  const result: FileDeets[] = []\n  let currentFilePatch: FileDeets = emptyFilePatch()\n  let state: State = \"parsing header\"\n  let currentHunk: Hunk | null = null\n  let currentHunkMutationPart: PatchMutationPart | null = null\n\n  function commitHunk() {\n    if (currentHunk) {\n      if (currentHunkMutationPart) {\n        currentHunk.parts.push(currentHunkMutationPart)\n        currentHunkMutationPart = null\n      }\n      currentFilePatch.hunks!.push(currentHunk)\n      currentHunk = null\n    }\n  }\n\n  function commitFilePatch() {\n    commitHunk()\n    result.push(currentFilePatch)\n    currentFilePatch = emptyFilePatch()\n  }\n\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i]\n\n    if (state === \"parsing header\") {\n      if (line.startsWith(\"@@\")) {\n        state = \"parsing hunks\"\n        currentFilePatch.hunks = []\n        i--\n      } else if (line.startsWith(\"diff --git \")) {\n        if (currentFilePatch && currentFilePatch.diffLineFromPath) {\n          commitFilePatch()\n        }\n        const match = line.match(/^diff --git a\\/(.*?) b\\/(.*?)\\s*$/)\n        if (!match) {\n          throw new Error(\"Bad diff line: \" + line)\n        }\n        currentFilePatch.diffLineFromPath = match[1]\n        currentFilePatch.diffLineToPath = match[2]\n      } else if (line.startsWith(\"old mode \")) {\n        currentFilePatch.oldMode = line.slice(\"old mode \".length).trim()\n      } else if (line.startsWith(\"new mode \")) {\n        currentFilePatch.newMode = line.slice(\"new mode \".length).trim()\n      } else if (line.startsWith(\"deleted file mode \")) {\n        currentFilePatch.deletedFileMode = line\n          .slice(\"deleted file mode \".length)\n          .trim()\n      } else if (line.startsWith(\"new file mode \")) {\n        currentFilePatch.newFileMode = line\n          .slice(\"new file mode \".length)\n          .trim()\n      } else if (line.startsWith(\"rename from \")) {\n        currentFilePatch.renameFrom = line.slice(\"rename from \".length).trim()\n      } else if (line.startsWith(\"rename to \")) {\n        currentFilePatch.renameTo = line.slice(\"rename to \".length).trim()\n      } else if (line.startsWith(\"index \")) {\n        const match = line.match(/(\\w+)\\.\\.(\\w+)/)\n        if (!match) {\n          continue\n        }\n        currentFilePatch.beforeHash = match[1]\n        currentFilePatch.afterHash = match[2]\n      } else if (line.startsWith(\"--- \")) {\n        currentFilePatch.fromPath = line.slice(\"--- a/\".length).trim()\n      } else if (line.startsWith(\"+++ \")) {\n        currentFilePatch.toPath = line.slice(\"+++ b/\".length).trim()\n      }\n    } else {\n      if (supportLegacyDiffs && line.startsWith(\"--- a/\")) {\n        state = \"parsing header\"\n        commitFilePatch()\n        i--\n        continue\n      }\n      // parsing hunks\n      const lineType = hunkLinetypes[line[0]] || null\n      switch (lineType) {\n        case \"header\":\n          commitHunk()\n          currentHunk = emptyHunk(line)\n          break\n        case null:\n          // unrecognized, bail out\n          state = \"parsing header\"\n          commitFilePatch()\n          i--\n          break\n        case \"pragma\":\n          if (!line.startsWith(\"\\\\ No newline at end of file\")) {\n            throw new Error(\"Unrecognized pragma in patch file: \" + line)\n          }\n          if (!currentHunkMutationPart) {\n            throw new Error(\n              \"Bad parser state: No newline at EOF pragma encountered without context\",\n            )\n          }\n          currentHunkMutationPart.noNewlineAtEndOfFile = true\n          break\n        case \"insertion\":\n        case \"deletion\":\n        case \"context\":\n          if (!currentHunk) {\n            throw new Error(\n              \"Bad parser state: Hunk lines encountered before hunk header\",\n            )\n          }\n          if (\n            currentHunkMutationPart &&\n            currentHunkMutationPart.type !== lineType\n          ) {\n            currentHunk.parts.push(currentHunkMutationPart)\n            currentHunkMutationPart = null\n          }\n          if (!currentHunkMutationPart) {\n            currentHunkMutationPart = {\n              type: lineType,\n              lines: [],\n              noNewlineAtEndOfFile: false,\n            }\n          }\n          currentHunkMutationPart.lines.push(line.slice(1))\n          break\n        default:\n          // exhausitveness check\n          assertNever(lineType)\n      }\n    }\n  }\n\n  commitFilePatch()\n\n  for (const { hunks } of result) {\n    if (hunks) {\n      for (const hunk of hunks) {\n        verifyHunkIntegrity(hunk)\n      }\n    }\n  }\n\n  return result\n}\n\nexport function interpretParsedPatchFile(files: FileDeets[]): ParsedPatchFile {\n  const result: ParsedPatchFile = []\n\n  for (const file of files) {\n    const {\n      diffLineFromPath,\n      diffLineToPath,\n      oldMode,\n      newMode,\n      deletedFileMode,\n      newFileMode,\n      renameFrom,\n      renameTo,\n      beforeHash,\n      afterHash,\n      fromPath,\n      toPath,\n      hunks,\n    } = file\n    const type: PatchFilePart[\"type\"] = renameFrom\n      ? \"rename\"\n      : deletedFileMode\n      ? \"file deletion\"\n      : newFileMode\n      ? \"file creation\"\n      : hunks && hunks.length > 0\n      ? \"patch\"\n      : \"mode change\"\n\n    let destinationFilePath: string | null = null\n    switch (type) {\n      case \"rename\":\n        if (!renameFrom || !renameTo) {\n          throw new Error(\"Bad parser state: rename from & to not given\")\n        }\n        result.push({\n          type: \"rename\",\n          fromPath: renameFrom,\n          toPath: renameTo,\n        })\n        destinationFilePath = renameTo\n        break\n      case \"file deletion\": {\n        const path = diffLineFromPath || fromPath\n        if (!path) {\n          throw new Error(\"Bad parse state: no path given for file deletion\")\n        }\n        result.push({\n          type: \"file deletion\",\n          hunk: (hunks && hunks[0]) || null,\n          path,\n          mode: parseFileMode(deletedFileMode!),\n          hash: beforeHash,\n        })\n        break\n      }\n      case \"file creation\": {\n        const path = diffLineToPath || toPath\n        if (!path) {\n          throw new Error(\"Bad parse state: no path given for file creation\")\n        }\n        result.push({\n          type: \"file creation\",\n          hunk: (hunks && hunks[0]) || null,\n          path,\n          mode: parseFileMode(newFileMode!),\n          hash: afterHash,\n        })\n        break\n      }\n      case \"patch\":\n      case \"mode change\":\n        destinationFilePath = toPath || diffLineToPath\n        break\n      default:\n        assertNever(type)\n    }\n\n    if (destinationFilePath && oldMode && newMode && oldMode !== newMode) {\n      result.push({\n        type: \"mode change\",\n        path: destinationFilePath,\n        oldMode: parseFileMode(oldMode),\n        newMode: parseFileMode(newMode),\n      })\n    }\n\n    if (destinationFilePath && hunks && hunks.length) {\n      result.push({\n        type: \"patch\",\n        path: destinationFilePath,\n        hunks,\n        beforeHash,\n        afterHash,\n      })\n    }\n  }\n\n  return result\n}\n\nfunction parseFileMode(mode: string): FileMode {\n  // tslint:disable-next-line:no-bitwise\n  const parsedMode = parseInt(mode, 8) & 0o777\n  if (\n    parsedMode !== NON_EXECUTABLE_FILE_MODE &&\n    parsedMode !== EXECUTABLE_FILE_MODE\n  ) {\n    throw new Error(\"Unexpected file mode string: \" + mode)\n  }\n  return parsedMode\n}\n\nexport function parsePatchFile(file: string): ParsedPatchFile {\n  const lines = file.split(/\\n/g)\n  if (lines[lines.length - 1] === \"\") {\n    lines.pop()\n  }\n  try {\n    return interpretParsedPatchFile(\n      parsePatchLines(lines, { supportLegacyDiffs: false }),\n    )\n  } catch (e) {\n    if (\n      e instanceof Error &&\n      e.message === \"hunk header integrity check failed\"\n    ) {\n      return interpretParsedPatchFile(\n        parsePatchLines(lines, { supportLegacyDiffs: true }),\n      )\n    }\n    throw e\n  }\n}\n\nexport function verifyHunkIntegrity(hunk: Hunk) {\n  // verify hunk integrity\n  let originalLength = 0\n  let patchedLength = 0\n  for (const { type, lines } of hunk.parts) {\n    switch (type) {\n      case \"context\":\n        patchedLength += lines.length\n        originalLength += lines.length\n        break\n      case \"deletion\":\n        originalLength += lines.length\n        break\n      case \"insertion\":\n        patchedLength += lines.length\n        break\n      default:\n        assertNever(type)\n    }\n  }\n\n  if (\n    originalLength !== hunk.header.original.length ||\n    patchedLength !== hunk.header.patched.length\n  ) {\n    throw new Error(\"hunk header integrity check failed\")\n  }\n}\n"]}