@psync/patch-package 1.0.0

package/dist/patch/parse.js

@@ -0,0 +1,335 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXECUTABLE_FILE_MODE = exports.NON_EXECUTABLE_FILE_MODE = exports.parseHunkHeaderLine = void 0;
+exports.interpretParsedPatchFile = interpretParsedPatchFile;
+exports.parsePatchFile = parsePatchFile;
+exports.verifyHunkIntegrity = verifyHunkIntegrity;
+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: (0, exports.parseHunkHeaderLine)(headerLine),
+    parts: [],
+    source: "",
+});
+const hunkLinetypes = {
+    "@": "header",
+    "-": "deletion",
+    "+": "insertion",
+    " ": "context",
+    "\\": "pragma",
+    // Treat blank lines as context
+    undefined: "context",
+    "\r": "context",
+};
+function parsePatchLines(lines, { supportLegacyDiffs }) {
+    const result = [];
+    let currentFilePatch = emptyFilePatch();
+    let state = "parsing header";
+    let currentHunk = null;
+    let currentHunkMutationPart = null;
+    let hunkStartLineIndex = 0;
+    function commitHunk(i) {
+        if (currentHunk) {
+            if (currentHunkMutationPart) {
+                currentHunk.parts.push(currentHunkMutationPart);
+                currentHunkMutationPart = null;
+            }
+            currentHunk.source = lines.slice(hunkStartLineIndex, i).join("\n");
+            currentFilePatch.hunks.push(currentHunk);
+            currentHunk = null;
+        }
+    }
+    function commitFilePatch(i) {
+        commitHunk(i);
+        result.push(currentFilePatch);
+        currentFilePatch = emptyFilePatch();
+    }
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (state === "parsing header") {
+            if (line.startsWith("@@")) {
+                hunkStartLineIndex = i;
+                state = "parsing hunks";
+                currentFilePatch.hunks = [];
+                i--;
+            }
+            else if (line.startsWith("diff --git ")) {
+                if (currentFilePatch && currentFilePatch.diffLineFromPath) {
+                    commitFilePatch(i);
+                }
+                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);
+                i--;
+                continue;
+            }
+            // parsing hunks
+            const lineType = hunkLinetypes[line[0]] || null;
+            switch (lineType) {
+                case "header":
+                    commitHunk(i);
+                    currentHunk = emptyHunk(line);
+                    break;
+                case null:
+                    // unrecognized, bail out
+                    state = "parsing header";
+                    commitFilePatch(i);
+                    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
+                    (0, assertNever_1.assertNever)(lineType);
+            }
+        }
+    }
+    commitFilePatch(lines.length);
+    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:
+                (0, 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;
+}
+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;
+    }
+}
+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:
+                (0, assertNever_1.assertNever)(type);
+        }
+    }
+    if (originalLength !== hunk.header.original.length ||
+        patchedLength !== hunk.header.patched.length) {
+        throw new Error("hunk header integrity check failed");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parse.js","sourceRoot":"","sources":["../../src/patch/parse.ts"],"names":[],"mappings":"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","sourcesContent":["import { assertNever } from \"../assertNever\"\r\n\r\nexport interface HunkHeader {\r\n  original: {\r\n    start: number\r\n    length: number\r\n  }\r\n  patched: {\r\n    start: number\r\n    length: number\r\n  }\r\n}\r\n\r\nexport const parseHunkHeaderLine = (headerLine: string): HunkHeader => {\r\n  const match = headerLine\r\n    .trim()\r\n    .match(/^@@ -(\\d+)(,(\\d+))? \\+(\\d+)(,(\\d+))? @@.*/)\r\n  if (!match) {\r\n    throw new Error(`Bad header line: '${headerLine}'`)\r\n  }\r\n\r\n  return {\r\n    original: {\r\n      start: Math.max(Number(match[1]), 1),\r\n      length: Number(match[3] || 1),\r\n    },\r\n    patched: {\r\n      start: Math.max(Number(match[4]), 1),\r\n      length: Number(match[6] || 1),\r\n    },\r\n  }\r\n}\r\n\r\nexport const NON_EXECUTABLE_FILE_MODE = 0o644\r\nexport const EXECUTABLE_FILE_MODE = 0o755\r\n\r\ntype FileMode = typeof NON_EXECUTABLE_FILE_MODE | typeof EXECUTABLE_FILE_MODE\r\n\r\ninterface PatchMutationPart {\r\n  type: \"context\" | \"insertion\" | \"deletion\"\r\n  lines: string[]\r\n  noNewlineAtEndOfFile: boolean\r\n}\r\n\r\ninterface FileRename {\r\n  type: \"rename\"\r\n  fromPath: string\r\n  toPath: string\r\n}\r\n\r\ninterface FileModeChange {\r\n  type: \"mode change\"\r\n  path: string\r\n  oldMode: FileMode\r\n  newMode: FileMode\r\n}\r\n\r\nexport interface FilePatch {\r\n  type: \"patch\"\r\n  path: string\r\n  hunks: Hunk[]\r\n  beforeHash: string | null\r\n  afterHash: string | null\r\n}\r\n\r\ninterface FileDeletion {\r\n  type: \"file deletion\"\r\n  path: string\r\n  mode: FileMode\r\n  hunk: Hunk | null\r\n  hash: string | null\r\n}\r\n\r\ninterface FileCreation {\r\n  type: \"file creation\"\r\n  mode: FileMode\r\n  path: string\r\n  hunk: Hunk | null\r\n  hash: string | null\r\n}\r\n\r\nexport type PatchFilePart =\r\n  | FilePatch\r\n  | FileDeletion\r\n  | FileCreation\r\n  | FileRename\r\n  | FileModeChange\r\n\r\nexport type ParsedPatchFile = PatchFilePart[]\r\n\r\ntype State = \"parsing header\" | \"parsing hunks\"\r\n\r\ninterface FileDeets {\r\n  diffLineFromPath: string | null\r\n  diffLineToPath: string | null\r\n  oldMode: string | null\r\n  newMode: string | null\r\n  deletedFileMode: string | null\r\n  newFileMode: string | null\r\n  renameFrom: string | null\r\n  renameTo: string | null\r\n  beforeHash: string | null\r\n  afterHash: string | null\r\n  fromPath: string | null\r\n  toPath: string | null\r\n  hunks: Hunk[] | null\r\n}\r\n\r\nexport interface Hunk {\r\n  header: HunkHeader\r\n  parts: PatchMutationPart[]\r\n  source: string\r\n}\r\n\r\nconst emptyFilePatch = (): FileDeets => ({\r\n  diffLineFromPath: null,\r\n  diffLineToPath: null,\r\n  oldMode: null,\r\n  newMode: null,\r\n  deletedFileMode: null,\r\n  newFileMode: null,\r\n  renameFrom: null,\r\n  renameTo: null,\r\n  beforeHash: null,\r\n  afterHash: null,\r\n  fromPath: null,\r\n  toPath: null,\r\n  hunks: null,\r\n})\r\n\r\nconst emptyHunk = (headerLine: string): Hunk => ({\r\n  header: parseHunkHeaderLine(headerLine),\r\n  parts: [],\r\n  source: \"\",\r\n})\r\n\r\nconst hunkLinetypes: {\r\n  [k: string]: PatchMutationPart[\"type\"] | \"pragma\" | \"header\"\r\n} = {\r\n  \"@\": \"header\",\r\n  \"-\": \"deletion\",\r\n  \"+\": \"insertion\",\r\n  \" \": \"context\",\r\n  \"\\\\\": \"pragma\",\r\n  // Treat blank lines as context\r\n  undefined: \"context\",\r\n  \"\\r\": \"context\",\r\n}\r\n\r\nfunction parsePatchLines(\r\n  lines: string[],\r\n  { supportLegacyDiffs }: { supportLegacyDiffs: boolean },\r\n): FileDeets[] {\r\n  const result: FileDeets[] = []\r\n  let currentFilePatch: FileDeets = emptyFilePatch()\r\n  let state: State = \"parsing header\"\r\n  let currentHunk: Hunk | null = null\r\n  let currentHunkMutationPart: PatchMutationPart | null = null\r\n  let hunkStartLineIndex = 0\r\n\r\n  function commitHunk(i: number) {\r\n    if (currentHunk) {\r\n      if (currentHunkMutationPart) {\r\n        currentHunk.parts.push(currentHunkMutationPart)\r\n        currentHunkMutationPart = null\r\n      }\r\n      currentHunk.source = lines.slice(hunkStartLineIndex, i).join(\"\\n\")\r\n      currentFilePatch.hunks!.push(currentHunk)\r\n      currentHunk = null\r\n    }\r\n  }\r\n\r\n  function commitFilePatch(i: number) {\r\n    commitHunk(i)\r\n    result.push(currentFilePatch)\r\n    currentFilePatch = emptyFilePatch()\r\n  }\r\n\r\n  for (let i = 0; i < lines.length; i++) {\r\n    const line = lines[i]\r\n\r\n    if (state === \"parsing header\") {\r\n      if (line.startsWith(\"@@\")) {\r\n        hunkStartLineIndex = i\r\n        state = \"parsing hunks\"\r\n        currentFilePatch.hunks = []\r\n        i--\r\n      } else if (line.startsWith(\"diff --git \")) {\r\n        if (currentFilePatch && currentFilePatch.diffLineFromPath) {\r\n          commitFilePatch(i)\r\n        }\r\n        const match = line.match(/^diff --git a\\/(.*?) b\\/(.*?)\\s*$/)\r\n        if (!match) {\r\n          throw new Error(\"Bad diff line: \" + line)\r\n        }\r\n        currentFilePatch.diffLineFromPath = match[1]\r\n        currentFilePatch.diffLineToPath = match[2]\r\n      } else if (line.startsWith(\"old mode \")) {\r\n        currentFilePatch.oldMode = line.slice(\"old mode \".length).trim()\r\n      } else if (line.startsWith(\"new mode \")) {\r\n        currentFilePatch.newMode = line.slice(\"new mode \".length).trim()\r\n      } else if (line.startsWith(\"deleted file mode \")) {\r\n        currentFilePatch.deletedFileMode = line\r\n          .slice(\"deleted file mode \".length)\r\n          .trim()\r\n      } else if (line.startsWith(\"new file mode \")) {\r\n        currentFilePatch.newFileMode = line\r\n          .slice(\"new file mode \".length)\r\n          .trim()\r\n      } else if (line.startsWith(\"rename from \")) {\r\n        currentFilePatch.renameFrom = line.slice(\"rename from \".length).trim()\r\n      } else if (line.startsWith(\"rename to \")) {\r\n        currentFilePatch.renameTo = line.slice(\"rename to \".length).trim()\r\n      } else if (line.startsWith(\"index \")) {\r\n        const match = line.match(/(\\w+)\\.\\.(\\w+)/)\r\n        if (!match) {\r\n          continue\r\n        }\r\n        currentFilePatch.beforeHash = match[1]\r\n        currentFilePatch.afterHash = match[2]\r\n      } else if (line.startsWith(\"--- \")) {\r\n        currentFilePatch.fromPath = line.slice(\"--- a/\".length).trim()\r\n      } else if (line.startsWith(\"+++ \")) {\r\n        currentFilePatch.toPath = line.slice(\"+++ b/\".length).trim()\r\n      }\r\n    } else {\r\n      if (supportLegacyDiffs && line.startsWith(\"--- a/\")) {\r\n        state = \"parsing header\"\r\n        commitFilePatch(i)\r\n        i--\r\n        continue\r\n      }\r\n      // parsing hunks\r\n      const lineType = hunkLinetypes[line[0]] || null\r\n      switch (lineType) {\r\n        case \"header\":\r\n          commitHunk(i)\r\n          currentHunk = emptyHunk(line)\r\n          break\r\n        case null:\r\n          // unrecognized, bail out\r\n          state = \"parsing header\"\r\n          commitFilePatch(i)\r\n          i--\r\n          break\r\n        case \"pragma\":\r\n          if (!line.startsWith(\"\\\\ No newline at end of file\")) {\r\n            throw new Error(\"Unrecognized pragma in patch file: \" + line)\r\n          }\r\n          if (!currentHunkMutationPart) {\r\n            throw new Error(\r\n              \"Bad parser state: No newline at EOF pragma encountered without context\",\r\n            )\r\n          }\r\n          currentHunkMutationPart.noNewlineAtEndOfFile = true\r\n          break\r\n        case \"insertion\":\r\n        case \"deletion\":\r\n        case \"context\":\r\n          if (!currentHunk) {\r\n            throw new Error(\r\n              \"Bad parser state: Hunk lines encountered before hunk header\",\r\n            )\r\n          }\r\n          if (\r\n            currentHunkMutationPart &&\r\n            currentHunkMutationPart.type !== lineType\r\n          ) {\r\n            currentHunk.parts.push(currentHunkMutationPart)\r\n            currentHunkMutationPart = null\r\n          }\r\n          if (!currentHunkMutationPart) {\r\n            currentHunkMutationPart = {\r\n              type: lineType,\r\n              lines: [],\r\n              noNewlineAtEndOfFile: false,\r\n            }\r\n          }\r\n          currentHunkMutationPart.lines.push(line.slice(1))\r\n          break\r\n        default:\r\n          // exhausitveness check\r\n          assertNever(lineType)\r\n      }\r\n    }\r\n  }\r\n\r\n  commitFilePatch(lines.length)\r\n\r\n  for (const { hunks } of result) {\r\n    if (hunks) {\r\n      for (const hunk of hunks) {\r\n        verifyHunkIntegrity(hunk)\r\n      }\r\n    }\r\n  }\r\n\r\n  return result\r\n}\r\n\r\nexport function interpretParsedPatchFile(files: FileDeets[]): ParsedPatchFile {\r\n  const result: ParsedPatchFile = []\r\n\r\n  for (const file of files) {\r\n    const {\r\n      diffLineFromPath,\r\n      diffLineToPath,\r\n      oldMode,\r\n      newMode,\r\n      deletedFileMode,\r\n      newFileMode,\r\n      renameFrom,\r\n      renameTo,\r\n      beforeHash,\r\n      afterHash,\r\n      fromPath,\r\n      toPath,\r\n      hunks,\r\n    } = file\r\n    const type: PatchFilePart[\"type\"] = renameFrom\r\n      ? \"rename\"\r\n      : deletedFileMode\r\n      ? \"file deletion\"\r\n      : newFileMode\r\n      ? \"file creation\"\r\n      : hunks && hunks.length > 0\r\n      ? \"patch\"\r\n      : \"mode change\"\r\n\r\n    let destinationFilePath: string | null = null\r\n    switch (type) {\r\n      case \"rename\":\r\n        if (!renameFrom || !renameTo) {\r\n          throw new Error(\"Bad parser state: rename from & to not given\")\r\n        }\r\n        result.push({\r\n          type: \"rename\",\r\n          fromPath: renameFrom,\r\n          toPath: renameTo,\r\n        })\r\n        destinationFilePath = renameTo\r\n        break\r\n      case \"file deletion\": {\r\n        const path = diffLineFromPath || fromPath\r\n        if (!path) {\r\n          throw new Error(\"Bad parse state: no path given for file deletion\")\r\n        }\r\n        result.push({\r\n          type: \"file deletion\",\r\n          hunk: (hunks && hunks[0]) || null,\r\n          path,\r\n          mode: parseFileMode(deletedFileMode!),\r\n          hash: beforeHash,\r\n        })\r\n        break\r\n      }\r\n      case \"file creation\": {\r\n        const path = diffLineToPath || toPath\r\n        if (!path) {\r\n          throw new Error(\"Bad parse state: no path given for file creation\")\r\n        }\r\n        result.push({\r\n          type: \"file creation\",\r\n          hunk: (hunks && hunks[0]) || null,\r\n          path,\r\n          mode: parseFileMode(newFileMode!),\r\n          hash: afterHash,\r\n        })\r\n        break\r\n      }\r\n      case \"patch\":\r\n      case \"mode change\":\r\n        destinationFilePath = toPath || diffLineToPath\r\n        break\r\n      default:\r\n        assertNever(type)\r\n    }\r\n\r\n    if (destinationFilePath && oldMode && newMode && oldMode !== newMode) {\r\n      result.push({\r\n        type: \"mode change\",\r\n        path: destinationFilePath,\r\n        oldMode: parseFileMode(oldMode),\r\n        newMode: parseFileMode(newMode),\r\n      })\r\n    }\r\n\r\n    if (destinationFilePath && hunks && hunks.length) {\r\n      result.push({\r\n        type: \"patch\",\r\n        path: destinationFilePath,\r\n        hunks,\r\n        beforeHash,\r\n        afterHash,\r\n      })\r\n    }\r\n  }\r\n\r\n  return result\r\n}\r\n\r\nfunction parseFileMode(mode: string): FileMode {\r\n  // tslint:disable-next-line:no-bitwise\r\n  const parsedMode = parseInt(mode, 8) & 0o777\r\n  if (\r\n    parsedMode !== NON_EXECUTABLE_FILE_MODE &&\r\n    parsedMode !== EXECUTABLE_FILE_MODE\r\n  ) {\r\n    throw new Error(\"Unexpected file mode string: \" + mode)\r\n  }\r\n  return parsedMode\r\n}\r\n\r\nexport function parsePatchFile(file: string): ParsedPatchFile {\r\n  const lines = file.split(/\\n/g)\r\n  if (lines[lines.length - 1] === \"\") {\r\n    lines.pop()\r\n  }\r\n  try {\r\n    return interpretParsedPatchFile(\r\n      parsePatchLines(lines, { supportLegacyDiffs: false }),\r\n    )\r\n  } catch (e) {\r\n    if (\r\n      e instanceof Error &&\r\n      e.message === \"hunk header integrity check failed\"\r\n    ) {\r\n      return interpretParsedPatchFile(\r\n        parsePatchLines(lines, { supportLegacyDiffs: true }),\r\n      )\r\n    }\r\n    throw e\r\n  }\r\n}\r\n\r\nexport function verifyHunkIntegrity(hunk: Hunk) {\r\n  // verify hunk integrity\r\n  let originalLength = 0\r\n  let patchedLength = 0\r\n  for (const { type, lines } of hunk.parts) {\r\n    switch (type) {\r\n      case \"context\":\r\n        patchedLength += lines.length\r\n        originalLength += lines.length\r\n        break\r\n      case \"deletion\":\r\n        originalLength += lines.length\r\n        break\r\n      case \"insertion\":\r\n        patchedLength += lines.length\r\n        break\r\n      default:\r\n        assertNever(type)\r\n    }\r\n  }\r\n\r\n  if (\r\n    originalLength !== hunk.header.original.length ||\r\n    patchedLength !== hunk.header.patched.length\r\n  ) {\r\n    throw new Error(\"hunk header integrity check failed\")\r\n  }\r\n}\r\n"]}

package/dist/patch/read.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPatch = readPatch;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("../path");
+const path_2 = require("path");
+const parse_1 = require("./parse");
+function readPatch({ patchFilePath, patchDetails, patchDir, }) {
+    try {
+        return (0, parse_1.parsePatchFile)((0, fs_extra_1.readFileSync)(patchFilePath).toString());
+    }
+    catch (e) {
+        const fixupSteps = [];
+        const relativePatchFilePath = (0, path_2.normalize)((0, path_1.relative)(process.cwd(), patchFilePath));
+        const patchBaseDir = relativePatchFilePath.slice(0, relativePatchFilePath.indexOf(patchDir));
+        if (patchBaseDir) {
+            fixupSteps.push(`cd ${patchBaseDir}`);
+        }
+        fixupSteps.push(`patch -p1 -i ${relativePatchFilePath.slice(relativePatchFilePath.indexOf(patchDir))}`);
+        fixupSteps.push(`npx patch-package ${patchDetails.pathSpecifier}`);
+        if (patchBaseDir) {
+            fixupSteps.push(`cd ${(0, path_1.relative)((0, path_1.resolve)(process.cwd(), patchBaseDir), process.cwd())}`);
+        }
+        console.log(`
+${chalk_1.default.red.bold("**ERROR**")} ${chalk_1.default.red(`Failed to apply patch for package ${chalk_1.default.bold(patchDetails.humanReadablePathSpecifier)}`)}
+    
+  This happened because the patch file ${relativePatchFilePath} could not be parsed.
+   
+  If you just upgraded patch-package, you can try running:
+  
+    ${fixupSteps.join("\n    ")}
+    
+  Otherwise, try manually creating the patch file again.
+  
+  If the problem persists, please submit a bug report:
+  
+    https://github.com/ds300/patch-package/issues/new?title=Patch+file+parse+error&body=%3CPlease+attach+the+patch+file+in+question%3E
+
+`);
+        process.exit(1);
+    }
+    return [];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/patch/reverse.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reversePatch = void 0;
+const parse_1 = require("./parse");
+const assertNever_1 = require("../assertNever");
+function reverseHunk(hunk) {
+    const header = {
+        original: hunk.header.patched,
+        patched: hunk.header.original,
+    };
+    const parts = [];
+    for (const part of hunk.parts) {
+        switch (part.type) {
+            case "context":
+                parts.push(part);
+                break;
+            case "deletion":
+                parts.push({
+                    type: "insertion",
+                    lines: part.lines,
+                    noNewlineAtEndOfFile: part.noNewlineAtEndOfFile,
+                });
+                break;
+            case "insertion":
+                parts.push({
+                    type: "deletion",
+                    lines: part.lines,
+                    noNewlineAtEndOfFile: part.noNewlineAtEndOfFile,
+                });
+                break;
+            default:
+                (0, assertNever_1.assertNever)(part.type);
+        }
+    }
+    // swap insertions and deletions over so deletions always come first
+    for (let i = 0; i < parts.length - 1; i++) {
+        if (parts[i].type === "insertion" && parts[i + 1].type === "deletion") {
+            const tmp = parts[i];
+            parts[i] = parts[i + 1];
+            parts[i + 1] = tmp;
+            i += 1;
+        }
+    }
+    const result = {
+        header,
+        parts,
+        source: hunk.source,
+    };
+    (0, parse_1.verifyHunkIntegrity)(result);
+    return result;
+}
+function reversePatchPart(part) {
+    switch (part.type) {
+        case "file creation":
+            return {
+                type: "file deletion",
+                path: part.path,
+                hash: part.hash,
+                hunk: part.hunk && reverseHunk(part.hunk),
+                mode: part.mode,
+            };
+        case "file deletion":
+            return {
+                type: "file creation",
+                path: part.path,
+                hunk: part.hunk && reverseHunk(part.hunk),
+                mode: part.mode,
+                hash: part.hash,
+            };
+        case "rename":
+            return {
+                type: "rename",
+                fromPath: part.toPath,
+                toPath: part.fromPath,
+            };
+        case "patch":
+            return {
+                type: "patch",
+                path: part.path,
+                hunks: part.hunks.map(reverseHunk),
+                beforeHash: part.afterHash,
+                afterHash: part.beforeHash,
+            };
+        case "mode change":
+            return {
+                type: "mode change",
+                path: part.path,
+                newMode: part.oldMode,
+                oldMode: part.newMode,
+            };
+    }
+}
+const reversePatch = (patch) => {
+    return patch.map(reversePatchPart).reverse();
+};
+exports.reversePatch = reversePatch;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/patchFs.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGroupedPatches = exports.getPatchFiles = void 0;
+const PackageDetails_1 = require("./PackageDetails");
+const path_1 = require("./path");
+const klaw_sync_1 = __importDefault(require("klaw-sync"));
+const getPatchFiles = (patchesDir) => {
+    try {
+        return (0, klaw_sync_1.default)(patchesDir, { nodir: true })
+            .map(({ path }) => (0, path_1.relative)(patchesDir, path))
+            .filter((path) => path.endsWith(".patch"));
+    }
+    catch (e) {
+        return [];
+    }
+};
+exports.getPatchFiles = getPatchFiles;
+const getGroupedPatches = (patchesDirectory) => {
+    const files = (0, exports.getPatchFiles)(patchesDirectory);
+    if (files.length === 0) {
+        return {
+            numPatchFiles: 0,
+            pathSpecifierToPatchFiles: {},
+            warnings: [],
+        };
+    }
+    const warnings = [];
+    const pathSpecifierToPatchFiles = {};
+    for (const file of files) {
+        const details = (0, PackageDetails_1.getPackageDetailsFromPatchFilename)(file);
+        if (!details) {
+            warnings.push(`Unrecognized patch file in patches directory ${file}`);
+            continue;
+        }
+        if (!pathSpecifierToPatchFiles[details.pathSpecifier]) {
+            pathSpecifierToPatchFiles[details.pathSpecifier] = [];
+        }
+        pathSpecifierToPatchFiles[details.pathSpecifier].push(details);
+    }
+    for (const arr of Object.values(pathSpecifierToPatchFiles)) {
+        arr.sort((a, b) => {
+            return (a.sequenceNumber ?? 0) - (b.sequenceNumber ?? 0);
+        });
+    }
+    return {
+        numPatchFiles: files.length,
+        pathSpecifierToPatchFiles,
+        warnings,
+    };
+};
+exports.getGroupedPatches = getGroupedPatches;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/path.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relative = exports.resolve = exports.dirname = exports.join = void 0;
+const slash_1 = __importDefault(require("slash"));
+const path_1 = __importDefault(require("path"));
+const join = (...args) => (0, slash_1.default)(path_1.default.join(...args));
+exports.join = join;
+var path_2 = require("path");
+Object.defineProperty(exports, "dirname", { enumerable: true, get: function () { return path_2.dirname; } });
+const resolve = (...args) => (0, slash_1.default)(path_1.default.resolve(...args));
+exports.resolve = resolve;
+const relative = (...args) => (0, slash_1.default)(path_1.default.relative(...args));
+exports.relative = relative;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9wYXRoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLGtEQUF5QjtBQUN6QixnREFBdUI7QUFFaEIsTUFBTSxJQUFJLEdBQXFCLENBQUMsR0FBRyxJQUFJLEVBQUUsRUFBRSxDQUFDLElBQUEsZUFBSyxFQUFDLGNBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQyxDQUFBO0FBQS9ELFFBQUEsSUFBSSxRQUEyRDtBQUU1RSw2QkFBOEI7QUFBckIsK0ZBQUEsT0FBTyxPQUFBO0FBRVQsTUFBTSxPQUFPLEdBQXdCLENBQUMsR0FBRyxJQUFJLEVBQUUsRUFBRSxDQUN0RCxJQUFBLGVBQUssRUFBQyxjQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsSUFBSSxDQUFDLENBQUMsQ0FBQTtBQURqQixRQUFBLE9BQU8sV0FDVTtBQUV2QixNQUFNLFFBQVEsR0FBeUIsQ0FBQyxHQUFHLElBQUksRUFBRSxFQUFFLENBQ3hELElBQUEsZUFBSyxFQUFDLGNBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQyxDQUFBO0FBRGxCLFFBQUEsUUFBUSxZQUNVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHNsYXNoIGZyb20gXCJzbGFzaFwiXHJcbmltcG9ydCBwYXRoIGZyb20gXCJwYXRoXCJcclxuXHJcbmV4cG9ydCBjb25zdCBqb2luOiB0eXBlb2YgcGF0aC5qb2luID0gKC4uLmFyZ3MpID0+IHNsYXNoKHBhdGguam9pbiguLi5hcmdzKSlcclxuXHJcbmV4cG9ydCB7IGRpcm5hbWUgfSBmcm9tIFwicGF0aFwiXHJcblxyXG5leHBvcnQgY29uc3QgcmVzb2x2ZTogdHlwZW9mIHBhdGgucmVzb2x2ZSA9ICguLi5hcmdzKSA9PlxyXG4gIHNsYXNoKHBhdGgucmVzb2x2ZSguLi5hcmdzKSlcclxuXHJcbmV4cG9ydCBjb25zdCByZWxhdGl2ZTogdHlwZW9mIHBhdGgucmVsYXRpdmUgPSAoLi4uYXJncykgPT5cclxuICBzbGFzaChwYXRoLnJlbGF0aXZlKC4uLmFyZ3MpKVxyXG4iXX0=