@psync/patch-package 1.0.0

package/dist/makePatch.js

@@ -0,0 +1,450 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePatch = makePatch;
+exports.logPatchSequenceError = logPatchSequenceError;
+const chalk_1 = __importDefault(require("chalk"));
+const console_1 = __importDefault(require("console"));
+const fs_1 = require("fs");
+const fs_extra_1 = require("fs-extra");
+const tmp_1 = require("tmp");
+const zlib_1 = require("zlib");
+const applyPatches_1 = require("./applyPatches");
+const createIssue_1 = require("./createIssue");
+const filterFiles_1 = require("./filterFiles");
+const getPackageResolution_1 = require("./getPackageResolution");
+const getPackageVersion_1 = require("./getPackageVersion");
+const hash_1 = require("./hash");
+const PackageDetails_1 = require("./PackageDetails");
+const parse_1 = require("./patch/parse");
+const patchFs_1 = require("./patchFs");
+const path_1 = require("./path");
+const resolveRelativeFileDependencies_1 = require("./resolveRelativeFileDependencies");
+const spawnSafe_1 = require("./spawnSafe");
+const stateFile_1 = require("./stateFile");
+function printNoPackageFoundError(packageName, packageJsonPath) {
+    console_1.default.log(`No such package ${packageName}
+
+  File not found: ${packageJsonPath}`);
+}
+function makePatch({ packagePathSpecifier, appPath, packageManager, includePaths, excludePaths, patchDir, createIssue, mode, }) {
+    const packageDetails = (0, PackageDetails_1.getPatchDetailsFromCliString)(packagePathSpecifier);
+    if (!packageDetails) {
+        console_1.default.log("No such package", packagePathSpecifier);
+        return;
+    }
+    const state = (0, stateFile_1.getPatchApplicationState)(packageDetails);
+    const isRebasing = state?.isRebasing ?? false;
+    // If we are rebasing and no patches have been applied, --append is the only valid option because
+    // there are no previous patches to overwrite/update
+    if (isRebasing &&
+        state?.patches.filter((p) => p.didApply).length === 0 &&
+        mode.type === "overwrite_last") {
+        mode = { type: "append", name: "initial" };
+    }
+    if (isRebasing && state) {
+        (0, stateFile_1.verifyAppliedPatches)({ appPath, patchDir, state });
+    }
+    if (mode.type === "overwrite_last" &&
+        isRebasing &&
+        state?.patches.length === 0) {
+        mode = { type: "append", name: "initial" };
+    }
+    const existingPatches = (0, patchFs_1.getGroupedPatches)(patchDir).pathSpecifierToPatchFiles[packageDetails.pathSpecifier] || [];
+    // apply all existing patches if appending
+    // otherwise apply all but the last
+    const previouslyAppliedPatches = state?.patches.filter((p) => p.didApply);
+    const patchesToApplyBeforeDiffing = isRebasing
+        ? mode.type === "append"
+            ? existingPatches.slice(0, previouslyAppliedPatches.length)
+            : state.patches[state.patches.length - 1].didApply
+                ? existingPatches.slice(0, previouslyAppliedPatches.length - 1)
+                : existingPatches.slice(0, previouslyAppliedPatches.length)
+        : mode.type === "append"
+            ? existingPatches
+            : existingPatches.slice(0, -1);
+    if (createIssue && mode.type === "append") {
+        console_1.default.log("--create-issue is not compatible with --append.");
+        process.exit(1);
+    }
+    if (createIssue && isRebasing) {
+        console_1.default.log("--create-issue is not compatible with rebasing.");
+        process.exit(1);
+    }
+    const numPatchesAfterCreate = mode.type === "append" || existingPatches.length === 0
+        ? existingPatches.length + 1
+        : existingPatches.length;
+    const vcs = (0, createIssue_1.getPackageVCSDetails)(packageDetails);
+    const canCreateIssue = !isRebasing &&
+        (0, createIssue_1.shouldRecommendIssue)(vcs) &&
+        numPatchesAfterCreate === 1 &&
+        mode.type !== "append";
+    const appPackageJson = require((0, path_1.join)(appPath, "package.json"));
+    const packagePath = (0, path_1.join)(appPath, packageDetails.path);
+    const packageJsonPath = (0, path_1.join)(packagePath, "package.json");
+    if (!(0, fs_extra_1.existsSync)(packageJsonPath)) {
+        printNoPackageFoundError(packagePathSpecifier, packageJsonPath);
+        process.exit(1);
+    }
+    const tmpRepo = (0, tmp_1.dirSync)({ unsafeCleanup: true });
+    const tmpRepoPackagePath = (0, path_1.join)(tmpRepo.name, packageDetails.path);
+    const tmpRepoNpmRoot = tmpRepoPackagePath.slice(0, -`/node_modules/${packageDetails.name}`.length);
+    const tmpRepoPackageJsonPath = (0, path_1.join)(tmpRepoNpmRoot, "package.json");
+    try {
+        const patchesDir = (0, path_1.resolve)((0, path_1.join)(appPath, patchDir));
+        console_1.default.info(chalk_1.default.grey("•"), "Creating temporary folder");
+        // make a blank package.json
+        (0, fs_extra_1.mkdirpSync)(tmpRepoNpmRoot);
+        (0, fs_extra_1.writeFileSync)(tmpRepoPackageJsonPath, JSON.stringify({
+            dependencies: {
+                [packageDetails.name]: (0, getPackageResolution_1.getPackageResolution)({
+                    packageDetails,
+                    packageManager,
+                    appPath,
+                }),
+            },
+            resolutions: (0, resolveRelativeFileDependencies_1.resolveRelativeFileDependencies)(appPath, appPackageJson.resolutions || {}),
+        }));
+        const packageVersion = (0, getPackageVersion_1.getPackageVersion)((0, path_1.join)((0, path_1.resolve)(packageDetails.path), "package.json"));
+        [".npmrc", ".yarnrc", ".yarn"].forEach((rcFile) => {
+            const rcPath = (0, path_1.join)(appPath, rcFile);
+            if ((0, fs_extra_1.existsSync)(rcPath)) {
+                (0, fs_extra_1.copySync)(rcPath, (0, path_1.join)(tmpRepo.name, rcFile), { dereference: true });
+            }
+        });
+        if (packageManager === "yarn") {
+            console_1.default.info(chalk_1.default.grey("•"), `Installing ${packageDetails.name}@${packageVersion} with yarn`);
+            try {
+                // try first without ignoring scripts in case they are required
+                // this works in 99.99% of cases
+                (0, spawnSafe_1.spawnSafeSync)(`yarn`, ["install", "--ignore-engines"], {
+                    cwd: tmpRepoNpmRoot,
+                    logStdErrOnError: false,
+                });
+            }
+            catch (e) {
+                // try again while ignoring scripts in case the script depends on
+                // an implicit context which we haven't reproduced
+                (0, spawnSafe_1.spawnSafeSync)(`yarn`, ["install", "--ignore-engines", "--ignore-scripts"], {
+                    cwd: tmpRepoNpmRoot,
+                });
+            }
+        }
+        else if (packageManager === "bun") {
+            console_1.default.info(chalk_1.default.grey("•"), `Installing ${packageDetails.name}@${packageVersion} with bun`);
+            try {
+                (0, spawnSafe_1.spawnSafeSync)(`bun`, ["install"], {
+                    cwd: tmpRepoNpmRoot,
+                    logStdErrOnError: false,
+                });
+            }
+            catch (e) {
+                (0, spawnSafe_1.spawnSafeSync)(`bun`, ["install", "--no-save"], {
+                    cwd: tmpRepoNpmRoot,
+                });
+            }
+        }
+        else {
+            console_1.default.info(chalk_1.default.grey("•"), `Installing ${packageDetails.name}@${packageVersion} with npm`);
+            try {
+                // try first without ignoring scripts in case they are required
+                // this works in 99.99% of cases
+                (0, spawnSafe_1.spawnSafeSync)(`npm`, ["i", "--force"], {
+                    cwd: tmpRepoNpmRoot,
+                    logStdErrOnError: false,
+                    stdio: "ignore",
+                });
+            }
+            catch (e) {
+                // try again while ignoring scripts in case the script depends on
+                // an implicit context which we haven't reproduced
+                (0, spawnSafe_1.spawnSafeSync)(`npm`, ["i", "--ignore-scripts", "--force"], {
+                    cwd: tmpRepoNpmRoot,
+                    stdio: "ignore",
+                });
+            }
+        }
+        const git = (...args) => (0, spawnSafe_1.spawnSafeSync)("git", args, {
+            cwd: tmpRepo.name,
+            env: { ...process.env, HOME: tmpRepo.name },
+            maxBuffer: 1024 * 1024 * 100,
+        });
+        // remove nested node_modules just to be safe
+        (0, fs_extra_1.removeSync)((0, path_1.join)(tmpRepoPackagePath, "node_modules"));
+        // remove .git just to be safe
+        (0, fs_extra_1.removeSync)((0, path_1.join)(tmpRepoPackagePath, ".git"));
+        // remove patch-package state file
+        (0, fs_extra_1.removeSync)((0, path_1.join)(tmpRepoPackagePath, stateFile_1.STATE_FILE_NAME));
+        // commit the package
+        console_1.default.info(chalk_1.default.grey("•"), "Diffing your files with clean files");
+        (0, fs_extra_1.writeFileSync)((0, path_1.join)(tmpRepo.name, ".gitignore"), "!/node_modules\n\n");
+        git("init");
+        git("config", "--local", "user.name", "patch-package");
+        git("config", "--local", "user.email", "patch@pack.age");
+        // remove ignored files first
+        (0, filterFiles_1.removeIgnoredFiles)(tmpRepoPackagePath, includePaths, excludePaths);
+        for (const patchDetails of patchesToApplyBeforeDiffing) {
+            if (!(0, applyPatches_1.applyPatch)({
+                patchDetails,
+                patchDir,
+                patchFilePath: (0, path_1.join)(appPath, patchDir, patchDetails.patchFilename),
+                reverse: false,
+                cwd: tmpRepo.name,
+                bestEffort: false,
+            })) {
+                // TODO: add better error message once --rebase is implemented
+                console_1.default.log(`Failed to apply patch ${patchDetails.patchFilename} to ${packageDetails.pathSpecifier}`);
+                process.exit(1);
+            }
+        }
+        git("add", "-f", packageDetails.path);
+        git("commit", "--allow-empty", "-m", "init");
+        // replace package with user's version
+        (0, fs_extra_1.removeSync)(tmpRepoPackagePath);
+        // pnpm installs packages as symlinks, copySync would copy only the symlink
+        (0, fs_extra_1.copySync)((0, fs_extra_1.realpathSync)(packagePath), tmpRepoPackagePath);
+        // remove nested node_modules just to be safe
+        (0, fs_extra_1.removeSync)((0, path_1.join)(tmpRepoPackagePath, "node_modules"));
+        // remove .git just to be safe
+        (0, fs_extra_1.removeSync)((0, path_1.join)(tmpRepoPackagePath, ".git"));
+        // remove patch-package state file
+        (0, fs_extra_1.removeSync)((0, path_1.join)(tmpRepoPackagePath, stateFile_1.STATE_FILE_NAME));
+        // also remove ignored files like before
+        (0, filterFiles_1.removeIgnoredFiles)(tmpRepoPackagePath, includePaths, excludePaths);
+        // stage all files
+        git("add", "-f", packageDetails.path);
+        // get diff of changes
+        const diffResult = git("diff", "--cached", "--no-color", "--ignore-space-at-eol", "--no-ext-diff", "--src-prefix=a/", "--dst-prefix=b/");
+        if (diffResult.stdout.length === 0) {
+            console_1.default.log(`⁉️  Not creating patch file for package '${packagePathSpecifier}'`);
+            console_1.default.log(`⁉️  There don't appear to be any changes.`);
+            if (isRebasing && mode.type === "overwrite_last") {
+                console_1.default.log("\n💡 To remove a patch file, delete it and then reinstall node_modules from scratch.");
+            }
+            process.exit(1);
+            return;
+        }
+        try {
+            (0, parse_1.parsePatchFile)(diffResult.stdout.toString());
+        }
+        catch (e) {
+            if (e.message.includes("Unexpected file mode string: 120000")) {
+                console_1.default.log(`
+⛔️ ${chalk_1.default.red.bold("ERROR")}
+
+  Your changes involve creating symlinks. patch-package does not yet support
+  symlinks.
+
+  ️Please use ${chalk_1.default.bold("--include")} and/or ${chalk_1.default.bold("--exclude")} to narrow the scope of your patch if
+  this was unintentional.
+`);
+            }
+            else {
+                const outPath = "./patch-package-error.json.gz";
+                (0, fs_extra_1.writeFileSync)(outPath, (0, zlib_1.gzipSync)(JSON.stringify({
+                    error: {
+                        message: e.message,
+                        stack: e.stack,
+                    },
+                    patch: diffResult.stdout.toString(),
+                })));
+                console_1.default.log(`
+⛔️ ${chalk_1.default.red.bold("ERROR")}
+
+  patch-package was unable to read the patch-file made by git. This should not
+  happen.
+
+  A diagnostic file was written to
+
+    ${outPath}
+
+  Please attach it to a github issue
+
+    https://github.com/ds300/patch-package/issues/new?title=New+patch+parse+failed&body=Please+attach+the+diagnostic+file+by+dragging+it+into+here+🙏
+
+  Note that this diagnostic file will contain code from the package you were
+  attempting to patch.
+
+`);
+            }
+            process.exit(1);
+            return;
+        }
+        // maybe delete existing
+        if (mode.type === "append" && !isRebasing && existingPatches.length === 1) {
+            // if we are appending to an existing patch that doesn't have a sequence number let's rename it
+            const prevPatch = existingPatches[0];
+            if (prevPatch.sequenceNumber === undefined) {
+                const newFileName = createPatchFileName({
+                    packageDetails,
+                    packageVersion,
+                    sequenceNumber: 1,
+                    sequenceName: prevPatch.sequenceName ?? "initial",
+                });
+                const oldPath = (0, path_1.join)(appPath, patchDir, prevPatch.patchFilename);
+                const newPath = (0, path_1.join)(appPath, patchDir, newFileName);
+                (0, fs_1.renameSync)(oldPath, newPath);
+                prevPatch.sequenceNumber = 1;
+                prevPatch.patchFilename = newFileName;
+                prevPatch.sequenceName = prevPatch.sequenceName ?? "initial";
+            }
+        }
+        const lastPatch = existingPatches[state ? state.patches.length - 1 : existingPatches.length - 1];
+        const sequenceName = mode.type === "append" ? mode.name : lastPatch?.sequenceName;
+        const sequenceNumber = mode.type === "append"
+            ? (lastPatch?.sequenceNumber ?? 0) + 1
+            : lastPatch?.sequenceNumber;
+        const patchFileName = createPatchFileName({
+            packageDetails,
+            packageVersion,
+            sequenceName,
+            sequenceNumber,
+        });
+        const patchPath = (0, path_1.join)(patchesDir, patchFileName);
+        if (!(0, fs_extra_1.existsSync)((0, path_1.dirname)(patchPath))) {
+            // scoped package
+            (0, fs_extra_1.mkdirSync)((0, path_1.dirname)(patchPath));
+        }
+        // if we are inserting a new patch into a sequence we most likely need to update the sequence numbers
+        if (isRebasing && mode.type === "append") {
+            const patchesToNudge = existingPatches.slice(state.patches.length);
+            if (sequenceNumber === undefined) {
+                throw new Error("sequenceNumber is undefined while rebasing");
+            }
+            if (patchesToNudge[0]?.sequenceNumber !== undefined &&
+                patchesToNudge[0].sequenceNumber <= sequenceNumber) {
+                let next = sequenceNumber + 1;
+                for (const p of patchesToNudge) {
+                    const newName = createPatchFileName({
+                        packageDetails,
+                        packageVersion,
+                        sequenceName: p.sequenceName,
+                        sequenceNumber: next++,
+                    });
+                    console_1.default.log("Renaming", chalk_1.default.bold(p.patchFilename), "to", chalk_1.default.bold(newName));
+                    const oldPath = (0, path_1.join)(appPath, patchDir, p.patchFilename);
+                    const newPath = (0, path_1.join)(appPath, patchDir, newName);
+                    (0, fs_1.renameSync)(oldPath, newPath);
+                }
+            }
+        }
+        (0, fs_extra_1.writeFileSync)(patchPath, diffResult.stdout);
+        console_1.default.log(`${chalk_1.default.green("✔")} Created file ${(0, path_1.join)(patchDir, patchFileName)}\n`);
+        const prevState = patchesToApplyBeforeDiffing.map((p) => ({
+            patchFilename: p.patchFilename,
+            didApply: true,
+            patchContentHash: (0, hash_1.hashFile)((0, path_1.join)(appPath, patchDir, p.patchFilename)),
+        }));
+        const nextState = [
+            ...prevState,
+            {
+                patchFilename: patchFileName,
+                didApply: true,
+                patchContentHash: (0, hash_1.hashFile)(patchPath),
+            },
+        ];
+        // if any patches come after this one we just made, we should reapply them
+        let didFailWhileFinishingRebase = false;
+        if (isRebasing) {
+            const currentPatches = (0, patchFs_1.getGroupedPatches)((0, path_1.join)(appPath, patchDir))
+                .pathSpecifierToPatchFiles[packageDetails.pathSpecifier];
+            const previouslyUnappliedPatches = currentPatches.slice(nextState.length);
+            if (previouslyUnappliedPatches.length) {
+                console_1.default.log(`Fast forwarding...`);
+                for (const patch of previouslyUnappliedPatches) {
+                    const patchFilePath = (0, path_1.join)(appPath, patchDir, patch.patchFilename);
+                    if (!(0, applyPatches_1.applyPatch)({
+                        patchDetails: patch,
+                        patchDir,
+                        patchFilePath,
+                        reverse: false,
+                        cwd: process.cwd(),
+                        bestEffort: false,
+                    })) {
+                        didFailWhileFinishingRebase = true;
+                        logPatchSequenceError({ patchDetails: patch });
+                        nextState.push({
+                            patchFilename: patch.patchFilename,
+                            didApply: false,
+                            patchContentHash: (0, hash_1.hashFile)(patchFilePath),
+                        });
+                        break;
+                    }
+                    else {
+                        console_1.default.log(`  ${chalk_1.default.green("✔")} ${patch.patchFilename}`);
+                        nextState.push({
+                            patchFilename: patch.patchFilename,
+                            didApply: true,
+                            patchContentHash: (0, hash_1.hashFile)(patchFilePath),
+                        });
+                    }
+                }
+            }
+        }
+        if (isRebasing || numPatchesAfterCreate > 1) {
+            (0, stateFile_1.savePatchApplicationState)({
+                packageDetails,
+                patches: nextState,
+                isRebasing: didFailWhileFinishingRebase,
+            });
+        }
+        else {
+            (0, stateFile_1.clearPatchApplicationState)(packageDetails);
+        }
+        if (canCreateIssue) {
+            if (createIssue) {
+                (0, createIssue_1.openIssueCreationLink)({
+                    packageDetails,
+                    patchFileContents: diffResult.stdout.toString(),
+                    packageVersion,
+                    patchPath,
+                });
+            }
+            else {
+                (0, createIssue_1.maybePrintIssueCreationPrompt)(vcs, packageDetails, packageManager);
+            }
+        }
+    }
+    catch (e) {
+        console_1.default.log(e);
+        throw e;
+    }
+    finally {
+        tmpRepo.removeCallback();
+    }
+}
+function createPatchFileName({ packageDetails, packageVersion, sequenceNumber, sequenceName, }) {
+    const packageNames = packageDetails.packageNames
+        .map((name) => name.replace(/\//g, "+"))
+        .join("++");
+    const nameAndVersion = `${packageNames}+${packageVersion}`;
+    const num = sequenceNumber === undefined
+        ? ""
+        : `+${sequenceNumber.toString().padStart(3, "0")}`;
+    const name = !sequenceName ? "" : `+${sequenceName}`;
+    return `${nameAndVersion}${num}${name}.patch`;
+}
+function logPatchSequenceError({ patchDetails, }) {
+    console_1.default.log(`
+${chalk_1.default.red.bold("⛔ ERROR")}
+
+Failed to apply patch file ${chalk_1.default.bold(patchDetails.patchFilename)}.
+
+If this patch file is no longer useful, delete it and run
+
+  ${chalk_1.default.bold(`patch-package`)}
+
+To partially apply the patch (if possible) and output a log of errors to fix, run
+
+  ${chalk_1.default.bold(`patch-package --partial`)}
+
+After which you should make any required changes inside ${patchDetails.path}, and finally run
+
+  ${chalk_1.default.bold(`patch-package ${patchDetails.pathSpecifier}`)}
+
+to update the patch file.
+`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"makePatch.js","sourceRoot":"","sources":["../src/makePatch.ts"],"names":[],"mappings":"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","sourcesContent":["import chalk from \"chalk\"\r\nimport console from \"console\"\r\nimport { renameSync } from \"fs\"\r\nimport {\r\n  copySync,\r\n  existsSync,\r\n  mkdirpSync,\r\n  mkdirSync,\r\n  realpathSync,\r\n  removeSync,\r\n  writeFileSync,\r\n} from \"fs-extra\"\r\nimport { dirSync } from \"tmp\"\r\nimport { gzipSync } from \"zlib\"\r\nimport { applyPatch } from \"./applyPatches\"\r\nimport {\r\n  getPackageVCSDetails,\r\n  maybePrintIssueCreationPrompt,\r\n  openIssueCreationLink,\r\n  shouldRecommendIssue,\r\n} from \"./createIssue\"\r\nimport { PackageManager } from \"./detectPackageManager\"\r\nimport { removeIgnoredFiles } from \"./filterFiles\"\r\nimport { getPackageResolution } from \"./getPackageResolution\"\r\nimport { getPackageVersion } from \"./getPackageVersion\"\r\nimport { hashFile } from \"./hash\"\r\nimport {\r\n  getPatchDetailsFromCliString,\r\n  PackageDetails,\r\n  PatchedPackageDetails,\r\n} from \"./PackageDetails\"\r\nimport { parsePatchFile } from \"./patch/parse\"\r\nimport { getGroupedPatches } from \"./patchFs\"\r\nimport { dirname, join, resolve } from \"./path\"\r\nimport { resolveRelativeFileDependencies } from \"./resolveRelativeFileDependencies\"\r\nimport { spawnSafeSync } from \"./spawnSafe\"\r\nimport {\r\n  clearPatchApplicationState,\r\n  getPatchApplicationState,\r\n  PatchState,\r\n  savePatchApplicationState,\r\n  STATE_FILE_NAME,\r\n  verifyAppliedPatches,\r\n} from \"./stateFile\"\r\n\r\nfunction printNoPackageFoundError(\r\n  packageName: string,\r\n  packageJsonPath: string,\r\n) {\r\n  console.log(\r\n    `No such package ${packageName}\r\n\r\n  File not found: ${packageJsonPath}`,\r\n  )\r\n}\r\n\r\nexport function makePatch({\r\n  packagePathSpecifier,\r\n  appPath,\r\n  packageManager,\r\n  includePaths,\r\n  excludePaths,\r\n  patchDir,\r\n  createIssue,\r\n  mode,\r\n}: {\r\n  packagePathSpecifier: string\r\n  appPath: string\r\n  packageManager: PackageManager\r\n  includePaths: RegExp\r\n  excludePaths: RegExp\r\n  patchDir: string\r\n  createIssue: boolean\r\n  mode: { type: \"overwrite_last\" } | { type: \"append\"; name?: string }\r\n}) {\r\n  const packageDetails = getPatchDetailsFromCliString(packagePathSpecifier)\r\n\r\n  if (!packageDetails) {\r\n    console.log(\"No such package\", packagePathSpecifier)\r\n    return\r\n  }\r\n\r\n  const state = getPatchApplicationState(packageDetails)\r\n  const isRebasing = state?.isRebasing ?? false\r\n\r\n  // If we are rebasing and no patches have been applied, --append is the only valid option because\r\n  // there are no previous patches to overwrite/update\r\n  if (\r\n    isRebasing &&\r\n    state?.patches.filter((p) => p.didApply).length === 0 &&\r\n    mode.type === \"overwrite_last\"\r\n  ) {\r\n    mode = { type: \"append\", name: \"initial\" }\r\n  }\r\n\r\n  if (isRebasing && state) {\r\n    verifyAppliedPatches({ appPath, patchDir, state })\r\n  }\r\n\r\n  if (\r\n    mode.type === \"overwrite_last\" &&\r\n    isRebasing &&\r\n    state?.patches.length === 0\r\n  ) {\r\n    mode = { type: \"append\", name: \"initial\" }\r\n  }\r\n\r\n  const existingPatches =\r\n    getGroupedPatches(patchDir).pathSpecifierToPatchFiles[\r\n      packageDetails.pathSpecifier\r\n    ] || []\r\n\r\n  // apply all existing patches if appending\r\n  // otherwise apply all but the last\r\n  const previouslyAppliedPatches = state?.patches.filter((p) => p.didApply)\r\n  const patchesToApplyBeforeDiffing: PatchedPackageDetails[] = isRebasing\r\n    ? mode.type === \"append\"\r\n      ? existingPatches.slice(0, previouslyAppliedPatches!.length)\r\n      : state!.patches[state!.patches.length - 1].didApply\r\n        ? existingPatches.slice(0, previouslyAppliedPatches!.length - 1)\r\n        : existingPatches.slice(0, previouslyAppliedPatches!.length)\r\n    : mode.type === \"append\"\r\n      ? existingPatches\r\n      : existingPatches.slice(0, -1)\r\n\r\n  if (createIssue && mode.type === \"append\") {\r\n    console.log(\"--create-issue is not compatible with --append.\")\r\n    process.exit(1)\r\n  }\r\n\r\n  if (createIssue && isRebasing) {\r\n    console.log(\"--create-issue is not compatible with rebasing.\")\r\n    process.exit(1)\r\n  }\r\n\r\n  const numPatchesAfterCreate =\r\n    mode.type === \"append\" || existingPatches.length === 0\r\n      ? existingPatches.length + 1\r\n      : existingPatches.length\r\n  const vcs = getPackageVCSDetails(packageDetails)\r\n  const canCreateIssue =\r\n    !isRebasing &&\r\n    shouldRecommendIssue(vcs) &&\r\n    numPatchesAfterCreate === 1 &&\r\n    mode.type !== \"append\"\r\n\r\n  const appPackageJson = require(join(appPath, \"package.json\"))\r\n  const packagePath = join(appPath, packageDetails.path)\r\n  const packageJsonPath = join(packagePath, \"package.json\")\r\n\r\n  if (!existsSync(packageJsonPath)) {\r\n    printNoPackageFoundError(packagePathSpecifier, packageJsonPath)\r\n    process.exit(1)\r\n  }\r\n\r\n  const tmpRepo = dirSync({ unsafeCleanup: true })\r\n  const tmpRepoPackagePath = join(tmpRepo.name, packageDetails.path)\r\n  const tmpRepoNpmRoot = tmpRepoPackagePath.slice(\r\n    0,\r\n    -`/node_modules/${packageDetails.name}`.length,\r\n  )\r\n\r\n  const tmpRepoPackageJsonPath = join(tmpRepoNpmRoot, \"package.json\")\r\n\r\n  try {\r\n    const patchesDir = resolve(join(appPath, patchDir))\r\n\r\n    console.info(chalk.grey(\"•\"), \"Creating temporary folder\")\r\n\r\n    // make a blank package.json\r\n    mkdirpSync(tmpRepoNpmRoot)\r\n    writeFileSync(\r\n      tmpRepoPackageJsonPath,\r\n      JSON.stringify({\r\n        dependencies: {\r\n          [packageDetails.name]: getPackageResolution({\r\n            packageDetails,\r\n            packageManager,\r\n            appPath,\r\n          }),\r\n        },\r\n        resolutions: resolveRelativeFileDependencies(\r\n          appPath,\r\n          appPackageJson.resolutions || {},\r\n        ),\r\n      }),\r\n    )\r\n\r\n    const packageVersion = getPackageVersion(\r\n      join(resolve(packageDetails.path), \"package.json\"),\r\n    )\r\n\r\n    // copy .npmrc/.yarnrc in case packages are hosted in private registry\r\n    // copy .yarn directory as well to ensure installations work in yarn 2\r\n    // tslint:disable-next-line:align\r\n    ;[\".npmrc\", \".yarnrc\", \".yarn\"].forEach((rcFile) => {\r\n      const rcPath = join(appPath, rcFile)\r\n      if (existsSync(rcPath)) {\r\n        copySync(rcPath, join(tmpRepo.name, rcFile), { dereference: true })\r\n      }\r\n    })\r\n\r\n    if (packageManager === \"yarn\") {\r\n      console.info(\r\n        chalk.grey(\"•\"),\r\n        `Installing ${packageDetails.name}@${packageVersion} with yarn`,\r\n      )\r\n      try {\r\n        // try first without ignoring scripts in case they are required\r\n        // this works in 99.99% of cases\r\n        spawnSafeSync(`yarn`, [\"install\", \"--ignore-engines\"], {\r\n          cwd: tmpRepoNpmRoot,\r\n          logStdErrOnError: false,\r\n        })\r\n      } catch (e) {\r\n        // try again while ignoring scripts in case the script depends on\r\n        // an implicit context which we haven't reproduced\r\n        spawnSafeSync(\r\n          `yarn`,\r\n          [\"install\", \"--ignore-engines\", \"--ignore-scripts\"],\r\n          {\r\n            cwd: tmpRepoNpmRoot,\r\n          },\r\n        )\r\n      }\r\n    } else if (packageManager === \"bun\") {\r\n      console.info(\r\n        chalk.grey(\"•\"),\r\n        `Installing ${packageDetails.name}@${packageVersion} with bun`,\r\n      )\r\n      try {\r\n        spawnSafeSync(`bun`, [\"install\"], {\r\n          cwd: tmpRepoNpmRoot,\r\n          logStdErrOnError: false,\r\n        })\r\n      } catch (e) {\r\n        spawnSafeSync(`bun`, [\"install\", \"--no-save\"], {\r\n          cwd: tmpRepoNpmRoot,\r\n        })\r\n      }\r\n    } else {\r\n      console.info(\r\n        chalk.grey(\"•\"),\r\n        `Installing ${packageDetails.name}@${packageVersion} with npm`,\r\n      )\r\n      try {\r\n        // try first without ignoring scripts in case they are required\r\n        // this works in 99.99% of cases\r\n        spawnSafeSync(`npm`, [\"i\", \"--force\"], {\r\n          cwd: tmpRepoNpmRoot,\r\n          logStdErrOnError: false,\r\n          stdio: \"ignore\",\r\n        })\r\n      } catch (e) {\r\n        // try again while ignoring scripts in case the script depends on\r\n        // an implicit context which we haven't reproduced\r\n        spawnSafeSync(`npm`, [\"i\", \"--ignore-scripts\", \"--force\"], {\r\n          cwd: tmpRepoNpmRoot,\r\n          stdio: \"ignore\",\r\n        })\r\n      }\r\n    }\r\n\r\n    const git = (...args: string[]) =>\r\n      spawnSafeSync(\"git\", args, {\r\n        cwd: tmpRepo.name,\r\n        env: { ...process.env, HOME: tmpRepo.name },\r\n        maxBuffer: 1024 * 1024 * 100,\r\n      })\r\n\r\n    // remove nested node_modules just to be safe\r\n    removeSync(join(tmpRepoPackagePath, \"node_modules\"))\r\n    // remove .git just to be safe\r\n    removeSync(join(tmpRepoPackagePath, \".git\"))\r\n    // remove patch-package state file\r\n    removeSync(join(tmpRepoPackagePath, STATE_FILE_NAME))\r\n\r\n    // commit the package\r\n    console.info(chalk.grey(\"•\"), \"Diffing your files with clean files\")\r\n    writeFileSync(join(tmpRepo.name, \".gitignore\"), \"!/node_modules\\n\\n\")\r\n    git(\"init\")\r\n    git(\"config\", \"--local\", \"user.name\", \"patch-package\")\r\n    git(\"config\", \"--local\", \"user.email\", \"patch@pack.age\")\r\n\r\n    // remove ignored files first\r\n    removeIgnoredFiles(tmpRepoPackagePath, includePaths, excludePaths)\r\n\r\n    for (const patchDetails of patchesToApplyBeforeDiffing) {\r\n      if (\r\n        !applyPatch({\r\n          patchDetails,\r\n          patchDir,\r\n          patchFilePath: join(appPath, patchDir, patchDetails.patchFilename),\r\n          reverse: false,\r\n          cwd: tmpRepo.name,\r\n          bestEffort: false,\r\n        })\r\n      ) {\r\n        // TODO: add better error message once --rebase is implemented\r\n        console.log(\r\n          `Failed to apply patch ${patchDetails.patchFilename} to ${packageDetails.pathSpecifier}`,\r\n        )\r\n        process.exit(1)\r\n      }\r\n    }\r\n    git(\"add\", \"-f\", packageDetails.path)\r\n    git(\"commit\", \"--allow-empty\", \"-m\", \"init\")\r\n\r\n    // replace package with user's version\r\n    removeSync(tmpRepoPackagePath)\r\n\r\n    // pnpm installs packages as symlinks, copySync would copy only the symlink\r\n    copySync(realpathSync(packagePath), tmpRepoPackagePath)\r\n\r\n    // remove nested node_modules just to be safe\r\n    removeSync(join(tmpRepoPackagePath, \"node_modules\"))\r\n    // remove .git just to be safe\r\n    removeSync(join(tmpRepoPackagePath, \".git\"))\r\n    // remove patch-package state file\r\n    removeSync(join(tmpRepoPackagePath, STATE_FILE_NAME))\r\n\r\n    // also remove ignored files like before\r\n    removeIgnoredFiles(tmpRepoPackagePath, includePaths, excludePaths)\r\n\r\n    // stage all files\r\n    git(\"add\", \"-f\", packageDetails.path)\r\n\r\n    // get diff of changes\r\n    const diffResult = git(\r\n      \"diff\",\r\n      \"--cached\",\r\n      \"--no-color\",\r\n      \"--ignore-space-at-eol\",\r\n      \"--no-ext-diff\",\r\n      \"--src-prefix=a/\",\r\n      \"--dst-prefix=b/\",\r\n    )\r\n\r\n    if (diffResult.stdout.length === 0) {\r\n      console.log(\r\n        `⁉️  Not creating patch file for package '${packagePathSpecifier}'`,\r\n      )\r\n      console.log(`⁉️  There don't appear to be any changes.`)\r\n      if (isRebasing && mode.type === \"overwrite_last\") {\r\n        console.log(\r\n          \"\\n💡 To remove a patch file, delete it and then reinstall node_modules from scratch.\",\r\n        )\r\n      }\r\n      process.exit(1)\r\n      return\r\n    }\r\n\r\n    try {\r\n      parsePatchFile(diffResult.stdout.toString())\r\n    } catch (e) {\r\n      if (\r\n        (e as Error).message.includes(\"Unexpected file mode string: 120000\")\r\n      ) {\r\n        console.log(`\r\n⛔️ ${chalk.red.bold(\"ERROR\")}\r\n\r\n  Your changes involve creating symlinks. patch-package does not yet support\r\n  symlinks.\r\n\r\n  ️Please use ${chalk.bold(\"--include\")} and/or ${chalk.bold(\r\n    \"--exclude\",\r\n  )} to narrow the scope of your patch if\r\n  this was unintentional.\r\n`)\r\n      } else {\r\n        const outPath = \"./patch-package-error.json.gz\"\r\n        writeFileSync(\r\n          outPath,\r\n          gzipSync(\r\n            JSON.stringify({\r\n              error: {\r\n                message: (e as Error).message,\r\n                stack: (e as Error).stack,\r\n              },\r\n              patch: diffResult.stdout.toString(),\r\n            }),\r\n          ),\r\n        )\r\n        console.log(`\r\n⛔️ ${chalk.red.bold(\"ERROR\")}\r\n\r\n  patch-package was unable to read the patch-file made by git. This should not\r\n  happen.\r\n\r\n  A diagnostic file was written to\r\n\r\n    ${outPath}\r\n\r\n  Please attach it to a github issue\r\n\r\n    https://github.com/ds300/patch-package/issues/new?title=New+patch+parse+failed&body=Please+attach+the+diagnostic+file+by+dragging+it+into+here+🙏\r\n\r\n  Note that this diagnostic file will contain code from the package you were\r\n  attempting to patch.\r\n\r\n`)\r\n      }\r\n      process.exit(1)\r\n      return\r\n    }\r\n\r\n    // maybe delete existing\r\n    if (mode.type === \"append\" && !isRebasing && existingPatches.length === 1) {\r\n      // if we are appending to an existing patch that doesn't have a sequence number let's rename it\r\n      const prevPatch = existingPatches[0]\r\n      if (prevPatch.sequenceNumber === undefined) {\r\n        const newFileName = createPatchFileName({\r\n          packageDetails,\r\n          packageVersion,\r\n          sequenceNumber: 1,\r\n          sequenceName: prevPatch.sequenceName ?? \"initial\",\r\n        })\r\n        const oldPath = join(appPath, patchDir, prevPatch.patchFilename)\r\n        const newPath = join(appPath, patchDir, newFileName)\r\n        renameSync(oldPath, newPath)\r\n        prevPatch.sequenceNumber = 1\r\n        prevPatch.patchFilename = newFileName\r\n        prevPatch.sequenceName = prevPatch.sequenceName ?? \"initial\"\r\n      }\r\n    }\r\n\r\n    const lastPatch = existingPatches[\r\n      state ? state.patches.length - 1 : existingPatches.length - 1\r\n    ] as PatchedPackageDetails | undefined\r\n    const sequenceName =\r\n      mode.type === \"append\" ? mode.name : lastPatch?.sequenceName\r\n    const sequenceNumber =\r\n      mode.type === \"append\"\r\n        ? (lastPatch?.sequenceNumber ?? 0) + 1\r\n        : lastPatch?.sequenceNumber\r\n\r\n    const patchFileName = createPatchFileName({\r\n      packageDetails,\r\n      packageVersion,\r\n      sequenceName,\r\n      sequenceNumber,\r\n    })\r\n\r\n    const patchPath: string = join(patchesDir, patchFileName)\r\n    if (!existsSync(dirname(patchPath))) {\r\n      // scoped package\r\n      mkdirSync(dirname(patchPath))\r\n    }\r\n\r\n    // if we are inserting a new patch into a sequence we most likely need to update the sequence numbers\r\n    if (isRebasing && mode.type === \"append\") {\r\n      const patchesToNudge = existingPatches.slice(state!.patches.length)\r\n      if (sequenceNumber === undefined) {\r\n        throw new Error(\"sequenceNumber is undefined while rebasing\")\r\n      }\r\n      if (\r\n        patchesToNudge[0]?.sequenceNumber !== undefined &&\r\n        patchesToNudge[0].sequenceNumber <= sequenceNumber\r\n      ) {\r\n        let next = sequenceNumber + 1\r\n        for (const p of patchesToNudge) {\r\n          const newName = createPatchFileName({\r\n            packageDetails,\r\n            packageVersion,\r\n            sequenceName: p.sequenceName,\r\n            sequenceNumber: next++,\r\n          })\r\n          console.log(\r\n            \"Renaming\",\r\n            chalk.bold(p.patchFilename),\r\n            \"to\",\r\n            chalk.bold(newName),\r\n          )\r\n          const oldPath = join(appPath, patchDir, p.patchFilename)\r\n          const newPath = join(appPath, patchDir, newName)\r\n          renameSync(oldPath, newPath)\r\n        }\r\n      }\r\n    }\r\n\r\n    writeFileSync(patchPath, diffResult.stdout)\r\n    console.log(\r\n      `${chalk.green(\"✔\")} Created file ${join(patchDir, patchFileName)}\\n`,\r\n    )\r\n\r\n    const prevState: PatchState[] = patchesToApplyBeforeDiffing.map(\r\n      (p): PatchState => ({\r\n        patchFilename: p.patchFilename,\r\n        didApply: true,\r\n        patchContentHash: hashFile(join(appPath, patchDir, p.patchFilename)),\r\n      }),\r\n    )\r\n    const nextState: PatchState[] = [\r\n      ...prevState,\r\n      {\r\n        patchFilename: patchFileName,\r\n        didApply: true,\r\n        patchContentHash: hashFile(patchPath),\r\n      },\r\n    ]\r\n\r\n    // if any patches come after this one we just made, we should reapply them\r\n    let didFailWhileFinishingRebase = false\r\n    if (isRebasing) {\r\n      const currentPatches = getGroupedPatches(join(appPath, patchDir))\r\n        .pathSpecifierToPatchFiles[packageDetails.pathSpecifier]\r\n\r\n      const previouslyUnappliedPatches = currentPatches.slice(nextState.length)\r\n      if (previouslyUnappliedPatches.length) {\r\n        console.log(`Fast forwarding...`)\r\n        for (const patch of previouslyUnappliedPatches) {\r\n          const patchFilePath = join(appPath, patchDir, patch.patchFilename)\r\n          if (\r\n            !applyPatch({\r\n              patchDetails: patch,\r\n              patchDir,\r\n              patchFilePath,\r\n              reverse: false,\r\n              cwd: process.cwd(),\r\n              bestEffort: false,\r\n            })\r\n          ) {\r\n            didFailWhileFinishingRebase = true\r\n            logPatchSequenceError({ patchDetails: patch })\r\n            nextState.push({\r\n              patchFilename: patch.patchFilename,\r\n              didApply: false,\r\n              patchContentHash: hashFile(patchFilePath),\r\n            })\r\n            break\r\n          } else {\r\n            console.log(`  ${chalk.green(\"✔\")} ${patch.patchFilename}`)\r\n            nextState.push({\r\n              patchFilename: patch.patchFilename,\r\n              didApply: true,\r\n              patchContentHash: hashFile(patchFilePath),\r\n            })\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    if (isRebasing || numPatchesAfterCreate > 1) {\r\n      savePatchApplicationState({\r\n        packageDetails,\r\n        patches: nextState,\r\n        isRebasing: didFailWhileFinishingRebase,\r\n      })\r\n    } else {\r\n      clearPatchApplicationState(packageDetails)\r\n    }\r\n\r\n    if (canCreateIssue) {\r\n      if (createIssue) {\r\n        openIssueCreationLink({\r\n          packageDetails,\r\n          patchFileContents: diffResult.stdout.toString(),\r\n          packageVersion,\r\n          patchPath,\r\n        })\r\n      } else {\r\n        maybePrintIssueCreationPrompt(vcs, packageDetails, packageManager)\r\n      }\r\n    }\r\n  } catch (e) {\r\n    console.log(e)\r\n    throw e\r\n  } finally {\r\n    tmpRepo.removeCallback()\r\n  }\r\n}\r\n\r\nfunction createPatchFileName({\r\n  packageDetails,\r\n  packageVersion,\r\n  sequenceNumber,\r\n  sequenceName,\r\n}: {\r\n  packageDetails: PackageDetails\r\n  packageVersion: string\r\n  sequenceNumber?: number\r\n  sequenceName?: string\r\n}) {\r\n  const packageNames = packageDetails.packageNames\r\n    .map((name) => name.replace(/\\//g, \"+\"))\r\n    .join(\"++\")\r\n\r\n  const nameAndVersion = `${packageNames}+${packageVersion}`\r\n  const num =\r\n    sequenceNumber === undefined\r\n      ? \"\"\r\n      : `+${sequenceNumber.toString().padStart(3, \"0\")}`\r\n  const name = !sequenceName ? \"\" : `+${sequenceName}`\r\n\r\n  return `${nameAndVersion}${num}${name}.patch`\r\n}\r\n\r\nexport function logPatchSequenceError({\r\n  patchDetails,\r\n}: {\r\n  patchDetails: PatchedPackageDetails\r\n}) {\r\n  console.log(`\r\n${chalk.red.bold(\"⛔ ERROR\")}\r\n\r\nFailed to apply patch file ${chalk.bold(patchDetails.patchFilename)}.\r\n\r\nIf this patch file is no longer useful, delete it and run\r\n\r\n  ${chalk.bold(`patch-package`)}\r\n\r\nTo partially apply the patch (if possible) and output a log of errors to fix, run\r\n\r\n  ${chalk.bold(`patch-package --partial`)}\r\n\r\nAfter which you should make any required changes inside ${\r\n    patchDetails.path\r\n  }, and finally run\r\n\r\n  ${chalk.bold(`patch-package ${patchDetails.pathSpecifier}`)}\r\n\r\nto update the patch file.\r\n`)\r\n}\r\n"]}

package/dist/makeRegExp.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRegExp = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const makeRegExp = (reString, name, defaultValue, caseSensitive) => {
+    if (!reString) {
+        return defaultValue;
+    }
+    else {
+        try {
+            return new RegExp(reString, caseSensitive ? "" : "i");
+        }
+        catch (_) {
+            console.log(`${chalk_1.default.red.bold("***ERROR***")}
+Invalid format for option --${name}
+
+  Unable to convert the string ${JSON.stringify(reString)} to a regular expression.
+`);
+            process.exit(1);
+            return /unreachable/;
+        }
+    }
+};
+exports.makeRegExp = makeRegExp;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFrZVJlZ0V4cC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9tYWtlUmVnRXhwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLGtEQUF5QjtBQUVsQixNQUFNLFVBQVUsR0FBRyxDQUN4QixRQUFnQixFQUNoQixJQUFZLEVBQ1osWUFBb0IsRUFDcEIsYUFBc0IsRUFDZCxFQUFFO0lBQ1YsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ2QsT0FBTyxZQUFZLENBQUE7SUFDckIsQ0FBQztTQUFNLENBQUM7UUFDTixJQUFJLENBQUM7WUFDSCxPQUFPLElBQUksTUFBTSxDQUFDLFFBQVEsRUFBRSxhQUFhLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUE7UUFDdkQsQ0FBQztRQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7WUFDWCxPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsZUFBSyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDOzhCQUNwQixJQUFJOztpQ0FFRCxJQUFJLENBQUMsU0FBUyxDQUMzQyxRQUFRLENBQ1Q7Q0FDRixDQUFDLENBQUE7WUFFSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFBO1lBQ2YsT0FBTyxhQUFhLENBQUE7UUFDdEIsQ0FBQztJQUNILENBQUM7QUFDSCxDQUFDLENBQUE7QUF4QlksUUFBQSxVQUFVLGNBd0J0QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBjaGFsayBmcm9tIFwiY2hhbGtcIlxyXG5cclxuZXhwb3J0IGNvbnN0IG1ha2VSZWdFeHAgPSAoXHJcbiAgcmVTdHJpbmc6IHN0cmluZyxcclxuICBuYW1lOiBzdHJpbmcsXHJcbiAgZGVmYXVsdFZhbHVlOiBSZWdFeHAsXHJcbiAgY2FzZVNlbnNpdGl2ZTogYm9vbGVhbixcclxuKTogUmVnRXhwID0+IHtcclxuICBpZiAoIXJlU3RyaW5nKSB7XHJcbiAgICByZXR1cm4gZGVmYXVsdFZhbHVlXHJcbiAgfSBlbHNlIHtcclxuICAgIHRyeSB7XHJcbiAgICAgIHJldHVybiBuZXcgUmVnRXhwKHJlU3RyaW5nLCBjYXNlU2Vuc2l0aXZlID8gXCJcIiA6IFwiaVwiKVxyXG4gICAgfSBjYXRjaCAoXykge1xyXG4gICAgICBjb25zb2xlLmxvZyhgJHtjaGFsay5yZWQuYm9sZChcIioqKkVSUk9SKioqXCIpfVxyXG5JbnZhbGlkIGZvcm1hdCBmb3Igb3B0aW9uIC0tJHtuYW1lfVxyXG5cclxuICBVbmFibGUgdG8gY29udmVydCB0aGUgc3RyaW5nICR7SlNPTi5zdHJpbmdpZnkoXHJcbiAgICByZVN0cmluZyxcclxuICApfSB0byBhIHJlZ3VsYXIgZXhwcmVzc2lvbi5cclxuYClcclxuXHJcbiAgICAgIHByb2Nlc3MuZXhpdCgxKVxyXG4gICAgICByZXR1cm4gL3VucmVhY2hhYmxlL1xyXG4gICAgfVxyXG4gIH1cclxufVxyXG4iXX0=

package/dist/packageIsDevDependency.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageIsDevDependency = packageIsDevDependency;
+const path_1 = require("./path");
+const fs_1 = require("fs");
+function packageIsDevDependency({ appPath, patchDetails, }) {
+    const packageJsonPath = (0, path_1.join)(appPath, "package.json");
+    if (!(0, fs_1.existsSync)(packageJsonPath)) {
+        return false;
+    }
+    const { devDependencies } = require(packageJsonPath);
+    return Boolean(devDependencies && devDependencies[patchDetails.packageNames[0]]);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFja2FnZUlzRGV2RGVwZW5kZW5jeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9wYWNrYWdlSXNEZXZEZXBlbmRlbmN5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBSUEsd0RBZUM7QUFsQkQsaUNBQTZCO0FBQzdCLDJCQUErQjtBQUUvQixTQUFnQixzQkFBc0IsQ0FBQyxFQUNyQyxPQUFPLEVBQ1AsWUFBWSxHQUliO0lBQ0MsTUFBTSxlQUFlLEdBQUcsSUFBQSxXQUFJLEVBQUMsT0FBTyxFQUFFLGNBQWMsQ0FBQyxDQUFBO0lBQ3JELElBQUksQ0FBQyxJQUFBLGVBQVUsRUFBQyxlQUFlLENBQUMsRUFBRSxDQUFDO1FBQ2pDLE9BQU8sS0FBSyxDQUFBO0lBQ2QsQ0FBQztJQUNELE1BQU0sRUFBRSxlQUFlLEVBQUUsR0FBRyxPQUFPLENBQUMsZUFBZSxDQUFDLENBQUE7SUFDcEQsT0FBTyxPQUFPLENBQ1osZUFBZSxJQUFJLGVBQWUsQ0FBQyxZQUFZLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQ2pFLENBQUE7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGF0Y2hlZFBhY2thZ2VEZXRhaWxzIH0gZnJvbSBcIi4vUGFja2FnZURldGFpbHNcIlxyXG5pbXBvcnQgeyBqb2luIH0gZnJvbSBcIi4vcGF0aFwiXHJcbmltcG9ydCB7IGV4aXN0c1N5bmMgfSBmcm9tIFwiZnNcIlxyXG5cclxuZXhwb3J0IGZ1bmN0aW9uIHBhY2thZ2VJc0RldkRlcGVuZGVuY3koe1xyXG4gIGFwcFBhdGgsXHJcbiAgcGF0Y2hEZXRhaWxzLFxyXG59OiB7XHJcbiAgYXBwUGF0aDogc3RyaW5nXHJcbiAgcGF0Y2hEZXRhaWxzOiBQYXRjaGVkUGFja2FnZURldGFpbHNcclxufSkge1xyXG4gIGNvbnN0IHBhY2thZ2VKc29uUGF0aCA9IGpvaW4oYXBwUGF0aCwgXCJwYWNrYWdlLmpzb25cIilcclxuICBpZiAoIWV4aXN0c1N5bmMocGFja2FnZUpzb25QYXRoKSkge1xyXG4gICAgcmV0dXJuIGZhbHNlXHJcbiAgfVxyXG4gIGNvbnN0IHsgZGV2RGVwZW5kZW5jaWVzIH0gPSByZXF1aXJlKHBhY2thZ2VKc29uUGF0aClcclxuICByZXR1cm4gQm9vbGVhbihcclxuICAgIGRldkRlcGVuZGVuY2llcyAmJiBkZXZEZXBlbmRlbmNpZXNbcGF0Y2hEZXRhaWxzLnBhY2thZ2VOYW1lc1swXV0sXHJcbiAgKVxyXG59XHJcbiJdfQ==

package/dist/parseBunLockfile.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBunLockfile = parseBunLockfile;
+const child_process_1 = require("child_process");
+// Adapted from https://github.com/oven-sh/bun/blob/main/packages/bun-vscode/src/features/lockfile.ts,
+// rewritten to use spawnSync instead of spawn.
+function parseBunLockfile(lockFilePath) {
+    const process = (0, child_process_1.spawnSync)("bun", [lockFilePath], {
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (process.status !== 0) {
+        throw new Error(`Bun exited with code: ${process.status}\n${process.stderr.toString()}`);
+    }
+    return process.stdout.toString();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2VCdW5Mb2NrZmlsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9wYXJzZUJ1bkxvY2tmaWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBSUEsNENBVUM7QUFkRCxpREFBeUM7QUFFekMsc0dBQXNHO0FBQ3RHLCtDQUErQztBQUMvQyxTQUFnQixnQkFBZ0IsQ0FBQyxZQUFvQjtJQUNuRCxNQUFNLE9BQU8sR0FBRyxJQUFBLHlCQUFTLEVBQUMsS0FBSyxFQUFFLENBQUMsWUFBWSxDQUFDLEVBQUU7UUFDL0MsS0FBSyxFQUFFLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxNQUFNLENBQUM7S0FDbEMsQ0FBQyxDQUFBO0lBQ0YsSUFBSSxPQUFPLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ3pCLE1BQU0sSUFBSSxLQUFLLENBQ2IseUJBQXlCLE9BQU8sQ0FBQyxNQUFNLEtBQUssT0FBTyxDQUFDLE1BQU0sQ0FBQyxRQUFRLEVBQUUsRUFBRSxDQUN4RSxDQUFBO0lBQ0gsQ0FBQztJQUNELE9BQU8sT0FBTyxDQUFDLE1BQU0sQ0FBQyxRQUFRLEVBQUUsQ0FBQTtBQUNsQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgc3Bhd25TeW5jIH0gZnJvbSBcImNoaWxkX3Byb2Nlc3NcIlxyXG5cclxuLy8gQWRhcHRlZCBmcm9tIGh0dHBzOi8vZ2l0aHViLmNvbS9vdmVuLXNoL2J1bi9ibG9iL21haW4vcGFja2FnZXMvYnVuLXZzY29kZS9zcmMvZmVhdHVyZXMvbG9ja2ZpbGUudHMsXHJcbi8vIHJld3JpdHRlbiB0byB1c2Ugc3Bhd25TeW5jIGluc3RlYWQgb2Ygc3Bhd24uXHJcbmV4cG9ydCBmdW5jdGlvbiBwYXJzZUJ1bkxvY2tmaWxlKGxvY2tGaWxlUGF0aDogc3RyaW5nKTogc3RyaW5nIHtcclxuICBjb25zdCBwcm9jZXNzID0gc3Bhd25TeW5jKFwiYnVuXCIsIFtsb2NrRmlsZVBhdGhdLCB7XHJcbiAgICBzdGRpbzogW1wiaWdub3JlXCIsIFwicGlwZVwiLCBcInBpcGVcIl0sXHJcbiAgfSlcclxuICBpZiAocHJvY2Vzcy5zdGF0dXMgIT09IDApIHtcclxuICAgIHRocm93IG5ldyBFcnJvcihcclxuICAgICAgYEJ1biBleGl0ZWQgd2l0aCBjb2RlOiAke3Byb2Nlc3Muc3RhdHVzfVxcbiR7cHJvY2Vzcy5zdGRlcnIudG9TdHJpbmcoKX1gLFxyXG4gICAgKVxyXG4gIH1cclxuICByZXR1cm4gcHJvY2Vzcy5zdGRvdXQudG9TdHJpbmcoKVxyXG59XHJcbiJdfQ==