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

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

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const process_1 = __importDefault(require("process"));
+const minimist_1 = __importDefault(require("minimist"));
+const applyPatches_1 = require("./applyPatches");
+const getAppRootPath_1 = require("./getAppRootPath");
+const makePatch_1 = require("./makePatch");
+const makeRegExp_1 = require("./makeRegExp");
+const detectPackageManager_1 = require("./detectPackageManager");
+const path_1 = require("./path");
+const path_2 = require("path");
+const slash = require("slash");
+const is_ci_1 = __importDefault(require("is-ci"));
+const appPath = getAppRootPath_1.getAppRootPath();
+const argv = minimist_1.default(process_1.default.argv.slice(2), {
+    boolean: [
+        "use-yarn",
+        "case-sensitive-path-filtering",
+        "reverse",
+        "help",
+        "version",
+        "error-on-fail",
+        "create-issue",
+    ],
+    string: ["patch-dir"],
+});
+const packageNames = argv._;
+console.log(chalk_1.default.bold("patch-package"), 
+// tslint:disable-next-line:no-var-requires
+require(path_1.join(__dirname, "../package.json")).version);
+if (argv.version || argv.v) {
+    // noop
+}
+else if (argv.help || argv.h) {
+    printHelp();
+}
+else {
+    const patchDir = slash(path_2.normalize((argv["patch-dir"] || "patches") + path_2.sep));
+    if (patchDir.startsWith("/")) {
+        throw new Error("--patch-dir must be a relative path");
+    }
+    if (packageNames.length) {
+        const includePaths = makeRegExp_1.makeRegExp(argv.include, "include", /.*/, argv["case-sensitive-path-filtering"]);
+        const excludePaths = makeRegExp_1.makeRegExp(argv.exclude, "exclude", /package\.json$/, argv["case-sensitive-path-filtering"]);
+        const packageManager = detectPackageManager_1.detectPackageManager(appPath, argv["use-yarn"] ? "yarn" : null);
+        const createIssue = argv["create-issue"];
+        packageNames.forEach((packagePathSpecifier) => {
+            makePatch_1.makePatch({
+                packagePathSpecifier,
+                appPath,
+                packageManager,
+                includePaths,
+                excludePaths,
+                patchDir,
+                createIssue,
+            });
+        });
+    }
+    else {
+        console.log("Applying patches...");
+        const reverse = !!argv["reverse"];
+        // don't want to exit(1) on postinsall locally.
+        // see https://github.com/ds300/patch-package/issues/86
+        const shouldExitWithError = !!argv["error-on-fail"] || is_ci_1.default || process_1.default.env.NODE_ENV === "test";
+        applyPatches_1.applyPatchesForApp({ appPath, reverse, patchDir, shouldExitWithError });
+    }
+}
+function printHelp() {
+    console.log(`
+Usage:
+
+  1. Patching packages
+  ====================
+
+    ${chalk_1.default.bold("patch-package")}
+
+  Without arguments, the ${chalk_1.default.bold("patch-package")} command will attempt to find and apply
+  patch files to your project. It looks for files named like
+
+     ./patches/<package-name>+<version>.patch
+
+  Options:
+
+    ${chalk_1.default.bold("--patch-dir <dirname>")}
+
+      Specify the name for the directory in which the patch files are located.
+      
+    ${chalk_1.default.bold("--error-on-fail")}
+    
+      Forces patch-package to exit with code 1 after failing.
+    
+      When running locally patch-package always exits with 0 by default.
+      This happens even after failing to apply patches because otherwise 
+      yarn.lock and package.json might get out of sync with node_modules,
+      which can be very confusing.
+      
+      --error-on-fail is ${chalk_1.default.bold("switched on")} by default on CI.
+      
+      See https://github.com/ds300/patch-package/issues/86 for background.
+
+    ${chalk_1.default.bold("--reverse")}
+        
+      Un-applies all patches.
+
+      Note that this will fail if the patched files have changed since being
+      patched. In that case, you'll probably need to re-install 'node_modules'.
+
+      This option was added to help people using CircleCI avoid an issue around caching
+      and patch file updates (https://github.com/ds300/patch-package/issues/37),
+      but might be useful in other contexts too.
+      
+
+  2. Creating patch files
+  =======================
+
+    ${chalk_1.default.bold("patch-package")} <package-name>${chalk_1.default.italic("[ <package-name>]")}
+
+  When given package names as arguments, patch-package will create patch files
+  based on any changes you've made to the versions installed by yarn/npm.
+
+  Options:
+  
+    ${chalk_1.default.bold("--create-issue")}
+    
+       For packages whose source is hosted on GitHub this option opens a web
+       browser with a draft issue based on your diff.
+
+    ${chalk_1.default.bold("--use-yarn")}
+
+        By default, patch-package checks whether you use npm or yarn based on
+        which lockfile you have. If you have both, it uses npm by default.
+        Set this option to override that default and always use yarn.
+
+    ${chalk_1.default.bold("--exclude <regexp>")}
+
+        Ignore paths matching the regexp when creating patch files.
+        Paths are relative to the root dir of the package to be patched.
+
+        Default: 'package\\.json$'
+
+    ${chalk_1.default.bold("--include <regexp>")}
+
+        Only consider paths matching the regexp when creating patch files.
+        Paths are relative to the root dir of the package to be patched.
+
+        Default '.*'
+
+    ${chalk_1.default.bold("--case-sensitive-path-filtering")}
+
+        Make regexps used in --include or --exclude filters case-sensitive.
+    
+    ${chalk_1.default.bold("--patch-dir")}
+
+        Specify the name for the directory in which to put the patch files.
+`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import chalk from \"chalk\"\nimport process from \"process\"\nimport minimist from \"minimist\"\n\nimport { applyPatchesForApp } from \"./applyPatches\"\nimport { getAppRootPath } from \"./getAppRootPath\"\nimport { makePatch } from \"./makePatch\"\nimport { makeRegExp } from \"./makeRegExp\"\nimport { detectPackageManager } from \"./detectPackageManager\"\nimport { join } from \"./path\"\nimport { normalize, sep } from \"path\"\nimport slash = require(\"slash\")\nimport isCi from \"is-ci\"\n\nconst appPath = getAppRootPath()\nconst argv = minimist(process.argv.slice(2), {\n  boolean: [\n    \"use-yarn\",\n    \"case-sensitive-path-filtering\",\n    \"reverse\",\n    \"help\",\n    \"version\",\n    \"error-on-fail\",\n    \"create-issue\",\n  ],\n  string: [\"patch-dir\"],\n})\nconst packageNames = argv._\n\nconsole.log(\n  chalk.bold(\"patch-package\"),\n  // tslint:disable-next-line:no-var-requires\n  require(join(__dirname, \"../package.json\")).version,\n)\n\nif (argv.version || argv.v) {\n  // noop\n} else if (argv.help || argv.h) {\n  printHelp()\n} else {\n  const patchDir = slash(normalize((argv[\"patch-dir\"] || \"patches\") + sep))\n  if (patchDir.startsWith(\"/\")) {\n    throw new Error(\"--patch-dir must be a relative path\")\n  }\n  if (packageNames.length) {\n    const includePaths = makeRegExp(\n      argv.include,\n      \"include\",\n      /.*/,\n      argv[\"case-sensitive-path-filtering\"],\n    )\n    const excludePaths = makeRegExp(\n      argv.exclude,\n      \"exclude\",\n      /package\\.json$/,\n      argv[\"case-sensitive-path-filtering\"],\n    )\n    const packageManager = detectPackageManager(\n      appPath,\n      argv[\"use-yarn\"] ? \"yarn\" : null,\n    )\n    const createIssue = argv[\"create-issue\"]\n    packageNames.forEach((packagePathSpecifier: string) => {\n      makePatch({\n        packagePathSpecifier,\n        appPath,\n        packageManager,\n        includePaths,\n        excludePaths,\n        patchDir,\n        createIssue,\n      })\n    })\n  } else {\n    console.log(\"Applying patches...\")\n    const reverse = !!argv[\"reverse\"]\n    // don't want to exit(1) on postinsall locally.\n    // see https://github.com/ds300/patch-package/issues/86\n    const shouldExitWithError =\n      !!argv[\"error-on-fail\"] || isCi || process.env.NODE_ENV === \"test\"\n    applyPatchesForApp({ appPath, reverse, patchDir, shouldExitWithError })\n  }\n}\n\nfunction printHelp() {\n  console.log(`\nUsage:\n\n  1. Patching packages\n  ====================\n\n    ${chalk.bold(\"patch-package\")}\n\n  Without arguments, the ${chalk.bold(\n    \"patch-package\",\n  )} command will attempt to find and apply\n  patch files to your project. It looks for files named like\n\n     ./patches/<package-name>+<version>.patch\n\n  Options:\n\n    ${chalk.bold(\"--patch-dir <dirname>\")}\n\n      Specify the name for the directory in which the patch files are located.\n      \n    ${chalk.bold(\"--error-on-fail\")}\n    \n      Forces patch-package to exit with code 1 after failing.\n    \n      When running locally patch-package always exits with 0 by default.\n      This happens even after failing to apply patches because otherwise \n      yarn.lock and package.json might get out of sync with node_modules,\n      which can be very confusing.\n      \n      --error-on-fail is ${chalk.bold(\"switched on\")} by default on CI.\n      \n      See https://github.com/ds300/patch-package/issues/86 for background.\n\n    ${chalk.bold(\"--reverse\")}\n        \n      Un-applies all patches.\n\n      Note that this will fail if the patched files have changed since being\n      patched. In that case, you'll probably need to re-install 'node_modules'.\n\n      This option was added to help people using CircleCI avoid an issue around caching\n      and patch file updates (https://github.com/ds300/patch-package/issues/37),\n      but might be useful in other contexts too.\n      \n\n  2. Creating patch files\n  =======================\n\n    ${chalk.bold(\"patch-package\")} <package-name>${chalk.italic(\n    \"[ <package-name>]\",\n  )}\n\n  When given package names as arguments, patch-package will create patch files\n  based on any changes you've made to the versions installed by yarn/npm.\n\n  Options:\n  \n    ${chalk.bold(\"--create-issue\")}\n    \n       For packages whose source is hosted on GitHub this option opens a web\n       browser with a draft issue based on your diff.\n\n    ${chalk.bold(\"--use-yarn\")}\n\n        By default, patch-package checks whether you use npm or yarn based on\n        which lockfile you have. If you have both, it uses npm by default.\n        Set this option to override that default and always use yarn.\n\n    ${chalk.bold(\"--exclude <regexp>\")}\n\n        Ignore paths matching the regexp when creating patch files.\n        Paths are relative to the root dir of the package to be patched.\n\n        Default: 'package\\\\.json$'\n\n    ${chalk.bold(\"--include <regexp>\")}\n\n        Only consider paths matching the regexp when creating patch files.\n        Paths are relative to the root dir of the package to be patched.\n\n        Default '.*'\n\n    ${chalk.bold(\"--case-sensitive-path-filtering\")}\n\n        Make regexps used in --include or --exclude filters case-sensitive.\n    \n    ${chalk.bold(\"--patch-dir\")}\n\n        Specify the name for the directory in which to put the patch files.\n`)\n}\n"]}

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

@@ -0,0 +1,231 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePatch = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = require("./path");
+const spawnSafe_1 = require("./spawnSafe");
+const filterFiles_1 = require("./filterFiles");
+const fs_extra_1 = require("fs-extra");
+const rimraf_1 = require("rimraf");
+const fs_extra_2 = require("fs-extra");
+const tmp_1 = require("tmp");
+const patchFs_1 = require("./patchFs");
+const PackageDetails_1 = require("./PackageDetails");
+const resolveRelativeFileDependencies_1 = require("./resolveRelativeFileDependencies");
+const getPackageResolution_1 = require("./getPackageResolution");
+const parse_1 = require("./patch/parse");
+const zlib_1 = require("zlib");
+const getPackageVersion_1 = require("./getPackageVersion");
+const createIssue_1 = require("./createIssue");
+function printNoPackageFoundError(packageName, packageJsonPath) {
+    console.error(`No such package ${packageName}
+
+  File not found: ${packageJsonPath}`);
+}
+function makePatch({ packagePathSpecifier, appPath, packageManager, includePaths, excludePaths, patchDir, createIssue, }) {
+    const packageDetails = PackageDetails_1.getPatchDetailsFromCliString(packagePathSpecifier);
+    if (!packageDetails) {
+        console.error("No such package", packagePathSpecifier);
+        return;
+    }
+    const appPackageJson = require(path_1.join(appPath, "package.json"));
+    const packagePath = path_1.join(appPath, packageDetails.path);
+    const packageJsonPath = path_1.join(packagePath, "package.json");
+    if (!fs_extra_1.existsSync(packageJsonPath)) {
+        printNoPackageFoundError(packagePathSpecifier, packageJsonPath);
+        process.exit(1);
+    }
+    const tmpRepo = tmp_1.dirSync({ unsafeCleanup: true });
+    const tmpRepoPackagePath = path_1.join(tmpRepo.name, packageDetails.path);
+    const tmpRepoNpmRoot = tmpRepoPackagePath.slice(0, -`/node_modules/${packageDetails.name}`.length);
+    const tmpRepoPackageJsonPath = path_1.join(tmpRepoNpmRoot, "package.json");
+    try {
+        const patchesDir = path_1.resolve(path_1.join(appPath, patchDir));
+        console.info(chalk_1.default.grey("•"), "Creating temporary folder");
+        // make a blank package.json
+        fs_extra_1.mkdirpSync(tmpRepoNpmRoot);
+        fs_extra_1.writeFileSync(tmpRepoPackageJsonPath, JSON.stringify({
+            dependencies: {
+                [packageDetails.name]: getPackageResolution_1.getPackageResolution({
+                    packageDetails,
+                    packageManager,
+                    appPath,
+                }),
+            },
+            resolutions: resolveRelativeFileDependencies_1.resolveRelativeFileDependencies(appPath, appPackageJson.resolutions || {}),
+        }));
+        const packageVersion = getPackageVersion_1.getPackageVersion(path_1.join(path_1.resolve(packageDetails.path), "package.json"));
+        [".npmrc", ".yarnrc"].forEach((rcFile) => {
+            const rcPath = path_1.join(appPath, rcFile);
+            if (fs_extra_1.existsSync(rcPath)) {
+                fs_extra_2.copySync(rcPath, path_1.join(tmpRepo.name, rcFile));
+            }
+        });
+        if (packageManager === "yarn") {
+            console.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
+                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 havn't reproduced
+                spawnSafe_1.spawnSafeSync(`yarn`, ["install", "--ignore-engines", "--ignore-scripts"], {
+                    cwd: tmpRepoNpmRoot,
+                });
+            }
+        }
+        else {
+            console.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
+                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 havn't reproduced
+                spawnSafe_1.spawnSafeSync(`npm`, ["i", "--ignore-scripts", "--force"], {
+                    cwd: tmpRepoNpmRoot,
+                    stdio: "ignore",
+                });
+            }
+        }
+        const git = (...args) => spawnSafe_1.spawnSafeSync("git", args, {
+            cwd: tmpRepo.name,
+            env: Object.assign(Object.assign({}, process.env), { HOME: tmpRepo.name }),
+            maxBuffer: 1024 * 1024 * 100,
+        });
+        // remove nested node_modules just to be safe
+        rimraf_1.sync(path_1.join(tmpRepoPackagePath, "node_modules"));
+        // remove .git just to be safe
+        rimraf_1.sync(path_1.join(tmpRepoPackagePath, ".git"));
+        // commit the package
+        console.info(chalk_1.default.grey("•"), "Diffing your files with clean files");
+        fs_extra_1.writeFileSync(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
+        filterFiles_1.removeIgnoredFiles(tmpRepoPackagePath, includePaths, excludePaths);
+        git("add", "-f", packageDetails.path);
+        git("commit", "--allow-empty", "-m", "init");
+        // replace package with user's version
+        rimraf_1.sync(tmpRepoPackagePath);
+        // pnpm installs packages as symlinks, copySync would copy only the symlink
+        fs_extra_2.copySync(fs_extra_1.realpathSync(packagePath), tmpRepoPackagePath);
+        // remove nested node_modules just to be safe
+        rimraf_1.sync(path_1.join(tmpRepoPackagePath, "node_modules"));
+        // remove .git just to be safe
+        rimraf_1.sync(path_1.join(tmpRepoPackagePath, ".git"));
+        // also remove ignored files like before
+        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");
+        if (diffResult.stdout.length === 0) {
+            console.warn(`⁉️  Not creating patch file for package '${packagePathSpecifier}'`);
+            console.warn(`⁉️  There don't appear to be any changes.`);
+            process.exit(1);
+            return;
+        }
+        try {
+            parse_1.parsePatchFile(diffResult.stdout.toString());
+        }
+        catch (e) {
+            if (e.message.includes("Unexpected file mode string: 120000")) {
+                console.error(`
+⛔️ ${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";
+                fs_extra_1.writeFileSync(outPath, zlib_1.gzipSync(JSON.stringify({
+                    error: { message: e.message, stack: e.stack },
+                    patch: diffResult.stdout.toString(),
+                })));
+                console.error(`
+⛔️ ${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
+        patchFs_1.getPatchFiles(patchDir).forEach((filename) => {
+            const deets = PackageDetails_1.getPackageDetailsFromPatchFilename(filename);
+            if (deets && deets.path === packageDetails.path) {
+                fs_extra_1.unlinkSync(path_1.join(patchDir, filename));
+            }
+        });
+        const patchFileName = createPatchFileName({
+            packageDetails,
+            packageVersion,
+        });
+        const patchPath = path_1.join(patchesDir, patchFileName);
+        if (!fs_extra_1.existsSync(path_1.dirname(patchPath))) {
+            // scoped package
+            fs_extra_1.mkdirSync(path_1.dirname(patchPath));
+        }
+        fs_extra_1.writeFileSync(patchPath, diffResult.stdout);
+        console.log(`${chalk_1.default.green("✔")} Created file ${path_1.join(patchDir, patchFileName)}\n`);
+        if (createIssue) {
+            createIssue_1.openIssueCreationLink({
+                packageDetails,
+                patchFileContents: diffResult.stdout.toString(),
+                packageVersion,
+            });
+        }
+        else {
+            createIssue_1.maybePrintIssueCreationPrompt(packageDetails, packageManager);
+        }
+    }
+    catch (e) {
+        console.error(e);
+        throw e;
+    }
+    finally {
+        tmpRepo.removeCallback();
+    }
+}
+exports.makePatch = makePatch;
+function createPatchFileName({ packageDetails, packageVersion, }) {
+    const packageNames = packageDetails.packageNames
+        .map((name) => name.replace(/\//g, "+"))
+        .join("++");
+    return `${packageNames}+${packageVersion}.patch`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"makePatch.js","sourceRoot":"","sources":["../src/makePatch.ts"],"names":[],"mappings":";;;;;;AAAA,kDAAyB;AACzB,iCAA+C;AAC/C,2CAA2C;AAE3C,+CAAkD;AAClD,uCAOiB;AACjB,mCAAuC;AACvC,uCAAmC;AACnC,6BAA6B;AAC7B,uCAAyC;AACzC,qDAIyB;AACzB,uFAAmF;AACnF,iEAA6D;AAC7D,yCAA8C;AAC9C,+BAA+B;AAC/B,2DAAuD;AACvD,+CAGsB;AAEtB,SAAS,wBAAwB,CAC/B,WAAmB,EACnB,eAAuB;IAEvB,OAAO,CAAC,KAAK,CACX,mBAAmB,WAAW;;oBAEd,eAAe,EAAE,CAClC,CAAA;AACH,CAAC;AAED,SAAgB,SAAS,CAAC,EACxB,oBAAoB,EACpB,OAAO,EACP,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,QAAQ,EACR,WAAW,GASZ;IACC,MAAM,cAAc,GAAG,6CAA4B,CAAC,oBAAoB,CAAC,CAAA;IAEzE,IAAI,CAAC,cAAc,EAAE;QACnB,OAAO,CAAC,KAAK,CAAC,iBAAiB,EAAE,oBAAoB,CAAC,CAAA;QACtD,OAAM;KACP;IACD,MAAM,cAAc,GAAG,OAAO,CAAC,WAAI,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,CAAA;IAC7D,MAAM,WAAW,GAAG,WAAI,CAAC,OAAO,EAAE,cAAc,CAAC,IAAI,CAAC,CAAA;IACtD,MAAM,eAAe,GAAG,WAAI,CAAC,WAAW,EAAE,cAAc,CAAC,CAAA;IAEzD,IAAI,CAAC,qBAAU,CAAC,eAAe,CAAC,EAAE;QAChC,wBAAwB,CAAC,oBAAoB,EAAE,eAAe,CAAC,CAAA;QAC/D,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;KAChB;IAED,MAAM,OAAO,GAAG,aAAO,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAA;IAChD,MAAM,kBAAkB,GAAG,WAAI,CAAC,OAAO,CAAC,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC,CAAA;IAClE,MAAM,cAAc,GAAG,kBAAkB,CAAC,KAAK,CAC7C,CAAC,EACD,CAAC,iBAAiB,cAAc,CAAC,IAAI,EAAE,CAAC,MAAM,CAC/C,CAAA;IAED,MAAM,sBAAsB,GAAG,WAAI,CAAC,cAAc,EAAE,cAAc,CAAC,CAAA;IAEnE,IAAI;QACF,MAAM,UAAU,GAAG,cAAO,CAAC,WAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAA;QAEnD,OAAO,CAAC,IAAI,CAAC,eAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,2BAA2B,CAAC,CAAA;QAE1D,4BAA4B;QAC5B,qBAAU,CAAC,cAAc,CAAC,CAAA;QAC1B,wBAAa,CACX,sBAAsB,EACtB,IAAI,CAAC,SAAS,CAAC;YACb,YAAY,EAAE;gBACZ,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,2CAAoB,CAAC;oBAC1C,cAAc;oBACd,cAAc;oBACd,OAAO;iBACR,CAAC;aACH;YACD,WAAW,EAAE,iEAA+B,CAC1C,OAAO,EACP,cAAc,CAAC,WAAW,IAAI,EAAE,CACjC;SACF,CAAC,CACH,CAAA;QAED,MAAM,cAAc,GAAG,qCAAiB,CACtC,WAAI,CAAC,cAAO,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,cAAc,CAAC,CACnD,CAIA;QAAA,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;YACxC,MAAM,MAAM,GAAG,WAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;YACpC,IAAI,qBAAU,CAAC,MAAM,CAAC,EAAE;gBACtB,mBAAQ,CAAC,MAAM,EAAE,WAAI,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAA;aAC7C;QACH,CAAC,CAAC,CAAA;QAEF,IAAI,cAAc,KAAK,MAAM,EAAE;YAC7B,OAAO,CAAC,IAAI,CACV,eAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EACf,cAAc,cAAc,CAAC,IAAI,IAAI,cAAc,YAAY,CAChE,CAAA;YACD,IAAI;gBACF,+DAA+D;gBAC/D,gCAAgC;gBAChC,yBAAa,CAAC,MAAM,EAAE,CAAC,SAAS,EAAE,kBAAkB,CAAC,EAAE;oBACrD,GAAG,EAAE,cAAc;oBACnB,gBAAgB,EAAE,KAAK;iBACxB,CAAC,CAAA;aACH;YAAC,OAAO,CAAC,EAAE;gBACV,iEAAiE;gBACjE,iDAAiD;gBACjD,yBAAa,CACX,MAAM,EACN,CAAC,SAAS,EAAE,kBAAkB,EAAE,kBAAkB,CAAC,EACnD;oBACE,GAAG,EAAE,cAAc;iBACpB,CACF,CAAA;aACF;SACF;aAAM;YACL,OAAO,CAAC,IAAI,CACV,eAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EACf,cAAc,cAAc,CAAC,IAAI,IAAI,cAAc,WAAW,CAC/D,CAAA;YACD,IAAI;gBACF,+DAA+D;gBAC/D,gCAAgC;gBAChC,yBAAa,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,SAAS,CAAC,EAAE;oBACrC,GAAG,EAAE,cAAc;oBACnB,gBAAgB,EAAE,KAAK;oBACvB,KAAK,EAAE,QAAQ;iBAChB,CAAC,CAAA;aACH;YAAC,OAAO,CAAC,EAAE;gBACV,iEAAiE;gBACjE,iDAAiD;gBACjD,yBAAa,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,kBAAkB,EAAE,SAAS,CAAC,EAAE;oBACzD,GAAG,EAAE,cAAc;oBACnB,KAAK,EAAE,QAAQ;iBAChB,CAAC,CAAA;aACH;SACF;QAED,MAAM,GAAG,GAAG,CAAC,GAAG,IAAc,EAAE,EAAE,CAChC,yBAAa,CAAC,KAAK,EAAE,IAAI,EAAE;YACzB,GAAG,EAAE,OAAO,CAAC,IAAI;YACjB,GAAG,kCAAO,OAAO,CAAC,GAAG,KAAE,IAAI,EAAE,OAAO,CAAC,IAAI,GAAE;YAC3C,SAAS,EAAE,IAAI,GAAG,IAAI,GAAG,GAAG;SAC7B,CAAC,CAAA;QAEJ,6CAA6C;QAC7C,aAAM,CAAC,WAAI,CAAC,kBAAkB,EAAE,cAAc,CAAC,CAAC,CAAA;QAChD,8BAA8B;QAC9B,aAAM,CAAC,WAAI,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC,CAAA;QAExC,qBAAqB;QACrB,OAAO,CAAC,IAAI,CAAC,eAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,qCAAqC,CAAC,CAAA;QACpE,wBAAa,CAAC,WAAI,CAAC,OAAO,CAAC,IAAI,EAAE,YAAY,CAAC,EAAE,oBAAoB,CAAC,CAAA;QACrE,GAAG,CAAC,MAAM,CAAC,CAAA;QACX,GAAG,CAAC,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,eAAe,CAAC,CAAA;QACtD,GAAG,CAAC,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAE,gBAAgB,CAAC,CAAA;QAExD,6BAA6B;QAC7B,gCAAkB,CAAC,kBAAkB,EAAE,YAAY,EAAE,YAAY,CAAC,CAAA;QAElE,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC,CAAA;QACrC,GAAG,CAAC,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,CAAC,CAAA;QAE5C,sCAAsC;QACtC,aAAM,CAAC,kBAAkB,CAAC,CAAA;QAE1B,2EAA2E;QAC3E,mBAAQ,CAAC,uBAAY,CAAC,WAAW,CAAC,EAAE,kBAAkB,CAAC,CAAA;QAEvD,6CAA6C;QAC7C,aAAM,CAAC,WAAI,CAAC,kBAAkB,EAAE,cAAc,CAAC,CAAC,CAAA;QAChD,8BAA8B;QAC9B,aAAM,CAAC,WAAI,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC,CAAA;QAExC,wCAAwC;QACxC,gCAAkB,CAAC,kBAAkB,EAAE,YAAY,EAAE,YAAY,CAAC,CAAA;QAElE,kBAAkB;QAClB,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC,CAAA;QAErC,sBAAsB;QACtB,MAAM,UAAU,GAAG,GAAG,CACpB,MAAM,EACN,UAAU,EACV,YAAY,EACZ,uBAAuB,EACvB,eAAe,CAChB,CAAA;QAED,IAAI,UAAU,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;YAClC,OAAO,CAAC,IAAI,CACV,4CAA4C,oBAAoB,GAAG,CACpE,CAAA;YACD,OAAO,CAAC,IAAI,CAAC,2CAA2C,CAAC,CAAA;YACzD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;YACf,OAAM;SACP;QAED,IAAI;YACF,sBAAc,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAA;SAC7C;QAAC,OAAO,CAAC,EAAE;YACV,IACG,CAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,qCAAqC,CAAC,EACpE;gBACA,OAAO,CAAC,KAAK,CAAC;KACjB,eAAK,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC;;;;;gBAKZ,eAAK,CAAC,IAAI,CAAC,WAAW,CAAC,WAAW,eAAK,CAAC,IAAI,CAClD,WAAW,CACZ;;CAER,CAAC,CAAA;aACK;iBAAM;gBACL,MAAM,OAAO,GAAG,+BAA+B,CAAA;gBAC/C,wBAAa,CACX,OAAO,EACP,eAAQ,CACN,IAAI,CAAC,SAAS,CAAC;oBACb,KAAK,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE;oBAC7C,KAAK,EAAE,UAAU,CAAC,MAAM,CAAC,QAAQ,EAAE;iBACpC,CAAC,CACH,CACF,CAAA;gBACD,OAAO,CAAC,KAAK,CAAC;KACjB,eAAK,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC;;;;;;;MAOtB,OAAO;;;;;;;;;CASZ,CAAC,CAAA;aACK;YACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;YACf,OAAM;SACP;QAED,wBAAwB;QACxB,uBAAa,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;YAC3C,MAAM,KAAK,GAAG,mDAAkC,CAAC,QAAQ,CAAC,CAAA;YAC1D,IAAI,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,cAAc,CAAC,IAAI,EAAE;gBAC/C,qBAAU,CAAC,WAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAA;aACrC;QACH,CAAC,CAAC,CAAA;QAEF,MAAM,aAAa,GAAG,mBAAmB,CAAC;YACxC,cAAc;YACd,cAAc;SACf,CAAC,CAAA;QAEF,MAAM,SAAS,GAAG,WAAI,CAAC,UAAU,EAAE,aAAa,CAAC,CAAA;QACjD,IAAI,CAAC,qBAAU,CAAC,cAAO,CAAC,SAAS,CAAC,CAAC,EAAE;YACnC,iBAAiB;YACjB,oBAAS,CAAC,cAAO,CAAC,SAAS,CAAC,CAAC,CAAA;SAC9B;QACD,wBAAa,CAAC,SAAS,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;QAC3C,OAAO,CAAC,GAAG,CACT,GAAG,eAAK,CAAC,KAAK,CAAC,GAAG,CAAC,iBAAiB,WAAI,CAAC,QAAQ,EAAE,aAAa,CAAC,IAAI,CACtE,CAAA;QACD,IAAI,WAAW,EAAE;YACf,mCAAqB,CAAC;gBACpB,cAAc;gBACd,iBAAiB,EAAE,UAAU,CAAC,MAAM,CAAC,QAAQ,EAAE;gBAC/C,cAAc;aACf,CAAC,CAAA;SACH;aAAM;YACL,2CAA6B,CAAC,cAAc,EAAE,cAAc,CAAC,CAAA;SAC9D;KACF;IAAC,OAAO,CAAC,EAAE;QACV,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;QAChB,MAAM,CAAC,CAAA;KACR;YAAS;QACR,OAAO,CAAC,cAAc,EAAE,CAAA;KACzB;AACH,CAAC;AAhRD,8BAgRC;AAED,SAAS,mBAAmB,CAAC,EAC3B,cAAc,EACd,cAAc,GAIf;IACC,MAAM,YAAY,GAAG,cAAc,CAAC,YAAY;SAC7C,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;SACvC,IAAI,CAAC,IAAI,CAAC,CAAA;IAEb,OAAO,GAAG,YAAY,IAAI,cAAc,QAAQ,CAAA;AAClD,CAAC","sourcesContent":["import chalk from \"chalk\"\nimport { join, dirname, resolve } from \"./path\"\nimport { spawnSafeSync } from \"./spawnSafe\"\nimport { PackageManager } from \"./detectPackageManager\"\nimport { removeIgnoredFiles } from \"./filterFiles\"\nimport {\n  writeFileSync,\n  existsSync,\n  mkdirSync,\n  unlinkSync,\n  mkdirpSync,\n  realpathSync,\n} from \"fs-extra\"\nimport { sync as rimraf } from \"rimraf\"\nimport { copySync } from \"fs-extra\"\nimport { dirSync } from \"tmp\"\nimport { getPatchFiles } from \"./patchFs\"\nimport {\n  getPatchDetailsFromCliString,\n  getPackageDetailsFromPatchFilename,\n  PackageDetails,\n} from \"./PackageDetails\"\nimport { resolveRelativeFileDependencies } from \"./resolveRelativeFileDependencies\"\nimport { getPackageResolution } from \"./getPackageResolution\"\nimport { parsePatchFile } from \"./patch/parse\"\nimport { gzipSync } from \"zlib\"\nimport { getPackageVersion } from \"./getPackageVersion\"\nimport {\n  maybePrintIssueCreationPrompt,\n  openIssueCreationLink,\n} from \"./createIssue\"\n\nfunction printNoPackageFoundError(\n  packageName: string,\n  packageJsonPath: string,\n) {\n  console.error(\n    `No such package ${packageName}\n\n  File not found: ${packageJsonPath}`,\n  )\n}\n\nexport function makePatch({\n  packagePathSpecifier,\n  appPath,\n  packageManager,\n  includePaths,\n  excludePaths,\n  patchDir,\n  createIssue,\n}: {\n  packagePathSpecifier: string\n  appPath: string\n  packageManager: PackageManager\n  includePaths: RegExp\n  excludePaths: RegExp\n  patchDir: string\n  createIssue: boolean\n}) {\n  const packageDetails = getPatchDetailsFromCliString(packagePathSpecifier)\n\n  if (!packageDetails) {\n    console.error(\"No such package\", packagePathSpecifier)\n    return\n  }\n  const appPackageJson = require(join(appPath, \"package.json\"))\n  const packagePath = join(appPath, packageDetails.path)\n  const packageJsonPath = join(packagePath, \"package.json\")\n\n  if (!existsSync(packageJsonPath)) {\n    printNoPackageFoundError(packagePathSpecifier, packageJsonPath)\n    process.exit(1)\n  }\n\n  const tmpRepo = dirSync({ unsafeCleanup: true })\n  const tmpRepoPackagePath = join(tmpRepo.name, packageDetails.path)\n  const tmpRepoNpmRoot = tmpRepoPackagePath.slice(\n    0,\n    -`/node_modules/${packageDetails.name}`.length,\n  )\n\n  const tmpRepoPackageJsonPath = join(tmpRepoNpmRoot, \"package.json\")\n\n  try {\n    const patchesDir = resolve(join(appPath, patchDir))\n\n    console.info(chalk.grey(\"•\"), \"Creating temporary folder\")\n\n    // make a blank package.json\n    mkdirpSync(tmpRepoNpmRoot)\n    writeFileSync(\n      tmpRepoPackageJsonPath,\n      JSON.stringify({\n        dependencies: {\n          [packageDetails.name]: getPackageResolution({\n            packageDetails,\n            packageManager,\n            appPath,\n          }),\n        },\n        resolutions: resolveRelativeFileDependencies(\n          appPath,\n          appPackageJson.resolutions || {},\n        ),\n      }),\n    )\n\n    const packageVersion = getPackageVersion(\n      join(resolve(packageDetails.path), \"package.json\"),\n    )\n\n    // copy .npmrc/.yarnrc in case packages are hosted in private registry\n    // tslint:disable-next-line:align\n    ;[\".npmrc\", \".yarnrc\"].forEach((rcFile) => {\n      const rcPath = join(appPath, rcFile)\n      if (existsSync(rcPath)) {\n        copySync(rcPath, join(tmpRepo.name, rcFile))\n      }\n    })\n\n    if (packageManager === \"yarn\") {\n      console.info(\n        chalk.grey(\"•\"),\n        `Installing ${packageDetails.name}@${packageVersion} with yarn`,\n      )\n      try {\n        // try first without ignoring scripts in case they are required\n        // this works in 99.99% of cases\n        spawnSafeSync(`yarn`, [\"install\", \"--ignore-engines\"], {\n          cwd: tmpRepoNpmRoot,\n          logStdErrOnError: false,\n        })\n      } catch (e) {\n        // try again while ignoring scripts in case the script depends on\n        // an implicit context which we havn't reproduced\n        spawnSafeSync(\n          `yarn`,\n          [\"install\", \"--ignore-engines\", \"--ignore-scripts\"],\n          {\n            cwd: tmpRepoNpmRoot,\n          },\n        )\n      }\n    } else {\n      console.info(\n        chalk.grey(\"•\"),\n        `Installing ${packageDetails.name}@${packageVersion} with npm`,\n      )\n      try {\n        // try first without ignoring scripts in case they are required\n        // this works in 99.99% of cases\n        spawnSafeSync(`npm`, [\"i\", \"--force\"], {\n          cwd: tmpRepoNpmRoot,\n          logStdErrOnError: false,\n          stdio: \"ignore\",\n        })\n      } catch (e) {\n        // try again while ignoring scripts in case the script depends on\n        // an implicit context which we havn't reproduced\n        spawnSafeSync(`npm`, [\"i\", \"--ignore-scripts\", \"--force\"], {\n          cwd: tmpRepoNpmRoot,\n          stdio: \"ignore\",\n        })\n      }\n    }\n\n    const git = (...args: string[]) =>\n      spawnSafeSync(\"git\", args, {\n        cwd: tmpRepo.name,\n        env: { ...process.env, HOME: tmpRepo.name },\n        maxBuffer: 1024 * 1024 * 100,\n      })\n\n    // remove nested node_modules just to be safe\n    rimraf(join(tmpRepoPackagePath, \"node_modules\"))\n    // remove .git just to be safe\n    rimraf(join(tmpRepoPackagePath, \".git\"))\n\n    // commit the package\n    console.info(chalk.grey(\"•\"), \"Diffing your files with clean files\")\n    writeFileSync(join(tmpRepo.name, \".gitignore\"), \"!/node_modules\\n\\n\")\n    git(\"init\")\n    git(\"config\", \"--local\", \"user.name\", \"patch-package\")\n    git(\"config\", \"--local\", \"user.email\", \"patch@pack.age\")\n\n    // remove ignored files first\n    removeIgnoredFiles(tmpRepoPackagePath, includePaths, excludePaths)\n\n    git(\"add\", \"-f\", packageDetails.path)\n    git(\"commit\", \"--allow-empty\", \"-m\", \"init\")\n\n    // replace package with user's version\n    rimraf(tmpRepoPackagePath)\n\n    // pnpm installs packages as symlinks, copySync would copy only the symlink\n    copySync(realpathSync(packagePath), tmpRepoPackagePath)\n\n    // remove nested node_modules just to be safe\n    rimraf(join(tmpRepoPackagePath, \"node_modules\"))\n    // remove .git just to be safe\n    rimraf(join(tmpRepoPackagePath, \".git\"))\n\n    // also remove ignored files like before\n    removeIgnoredFiles(tmpRepoPackagePath, includePaths, excludePaths)\n\n    // stage all files\n    git(\"add\", \"-f\", packageDetails.path)\n\n    // get diff of changes\n    const diffResult = git(\n      \"diff\",\n      \"--cached\",\n      \"--no-color\",\n      \"--ignore-space-at-eol\",\n      \"--no-ext-diff\",\n    )\n\n    if (diffResult.stdout.length === 0) {\n      console.warn(\n        `⁉️  Not creating patch file for package '${packagePathSpecifier}'`,\n      )\n      console.warn(`⁉️  There don't appear to be any changes.`)\n      process.exit(1)\n      return\n    }\n\n    try {\n      parsePatchFile(diffResult.stdout.toString())\n    } catch (e) {\n      if (\n        (e as Error).message.includes(\"Unexpected file mode string: 120000\")\n      ) {\n        console.error(`\n⛔️ ${chalk.red.bold(\"ERROR\")}\n\n  Your changes involve creating symlinks. patch-package does not yet support\n  symlinks.\n  \n  ️Please use ${chalk.bold(\"--include\")} and/or ${chalk.bold(\n          \"--exclude\",\n        )} to narrow the scope of your patch if\n  this was unintentional.\n`)\n      } else {\n        const outPath = \"./patch-package-error.json.gz\"\n        writeFileSync(\n          outPath,\n          gzipSync(\n            JSON.stringify({\n              error: { message: e.message, stack: e.stack },\n              patch: diffResult.stdout.toString(),\n            }),\n          ),\n        )\n        console.error(`\n⛔️ ${chalk.red.bold(\"ERROR\")}\n        \n  patch-package was unable to read the patch-file made by git. This should not\n  happen.\n  \n  A diagnostic file was written to\n  \n    ${outPath}\n  \n  Please attach it to a github issue\n  \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+🙏\n  \n  Note that this diagnostic file will contain code from the package you were\n  attempting to patch.\n\n`)\n      }\n      process.exit(1)\n      return\n    }\n\n    // maybe delete existing\n    getPatchFiles(patchDir).forEach((filename) => {\n      const deets = getPackageDetailsFromPatchFilename(filename)\n      if (deets && deets.path === packageDetails.path) {\n        unlinkSync(join(patchDir, filename))\n      }\n    })\n\n    const patchFileName = createPatchFileName({\n      packageDetails,\n      packageVersion,\n    })\n\n    const patchPath = join(patchesDir, patchFileName)\n    if (!existsSync(dirname(patchPath))) {\n      // scoped package\n      mkdirSync(dirname(patchPath))\n    }\n    writeFileSync(patchPath, diffResult.stdout)\n    console.log(\n      `${chalk.green(\"✔\")} Created file ${join(patchDir, patchFileName)}\\n`,\n    )\n    if (createIssue) {\n      openIssueCreationLink({\n        packageDetails,\n        patchFileContents: diffResult.stdout.toString(),\n        packageVersion,\n      })\n    } else {\n      maybePrintIssueCreationPrompt(packageDetails, packageManager)\n    }\n  } catch (e) {\n    console.error(e)\n    throw e\n  } finally {\n    tmpRepo.removeCallback()\n  }\n}\n\nfunction createPatchFileName({\n  packageDetails,\n  packageVersion,\n}: {\n  packageDetails: PackageDetails\n  packageVersion: string\n}) {\n  const packageNames = packageDetails.packageNames\n    .map((name) => name.replace(/\\//g, \"+\"))\n    .join(\"++\")\n\n  return `${packageNames}+${packageVersion}.patch`\n}\n"]}

package/node_modules/patch-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.error(`${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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFrZVJlZ0V4cC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9tYWtlUmVnRXhwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLGtEQUF5QjtBQUVsQixNQUFNLFVBQVUsR0FBRyxDQUN4QixRQUFnQixFQUNoQixJQUFZLEVBQ1osWUFBb0IsRUFDcEIsYUFBc0IsRUFDZCxFQUFFO0lBQ1YsSUFBSSxDQUFDLFFBQVEsRUFBRTtRQUNiLE9BQU8sWUFBWSxDQUFBO0tBQ3BCO1NBQU07UUFDTCxJQUFJO1lBQ0YsT0FBTyxJQUFJLE1BQU0sQ0FBQyxRQUFRLEVBQUUsYUFBYSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFBO1NBQ3REO1FBQUMsT0FBTyxDQUFDLEVBQUU7WUFDVixPQUFPLENBQUMsS0FBSyxDQUFDLEdBQUcsZUFBSyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDOzhCQUN0QixJQUFJOztpQ0FFRCxJQUFJLENBQUMsU0FBUyxDQUMzQyxRQUFRLENBQ1Q7Q0FDRixDQUFDLENBQUE7WUFFSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFBO1lBQ2YsT0FBTyxhQUFhLENBQUE7U0FDckI7S0FDRjtBQUNILENBQUMsQ0FBQTtBQXhCWSxRQUFBLFVBQVUsY0F3QnRCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGNoYWxrIGZyb20gXCJjaGFsa1wiXG5cbmV4cG9ydCBjb25zdCBtYWtlUmVnRXhwID0gKFxuICByZVN0cmluZzogc3RyaW5nLFxuICBuYW1lOiBzdHJpbmcsXG4gIGRlZmF1bHRWYWx1ZTogUmVnRXhwLFxuICBjYXNlU2Vuc2l0aXZlOiBib29sZWFuLFxuKTogUmVnRXhwID0+IHtcbiAgaWYgKCFyZVN0cmluZykge1xuICAgIHJldHVybiBkZWZhdWx0VmFsdWVcbiAgfSBlbHNlIHtcbiAgICB0cnkge1xuICAgICAgcmV0dXJuIG5ldyBSZWdFeHAocmVTdHJpbmcsIGNhc2VTZW5zaXRpdmUgPyBcIlwiIDogXCJpXCIpXG4gICAgfSBjYXRjaCAoXykge1xuICAgICAgY29uc29sZS5lcnJvcihgJHtjaGFsay5yZWQuYm9sZChcIioqKkVSUk9SKioqXCIpfVxuSW52YWxpZCBmb3JtYXQgZm9yIG9wdGlvbiAtLSR7bmFtZX1cblxuICBVbmFibGUgdG8gY29udmVydCB0aGUgc3RyaW5nICR7SlNPTi5zdHJpbmdpZnkoXG4gICAgcmVTdHJpbmcsXG4gICl9IHRvIGEgcmVndWxhciBleHByZXNzaW9uLlxuYClcblxuICAgICAgcHJvY2Vzcy5leGl0KDEpXG4gICAgICByZXR1cm4gL3VucmVhY2hhYmxlL1xuICAgIH1cbiAgfVxufVxuIl19

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

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

package/node_modules/patch-package/dist/packageIsDevDependency.test.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const packageIsDevDependency_1 = require("./packageIsDevDependency");
+const path_1 = require("./path");
+const path_2 = require("path");
+const PackageDetails_1 = require("./PackageDetails");
+const fs_1 = require("fs");
+const appPath = path_2.normalize(path_1.join(__dirname, "../"));
+describe(packageIsDevDependency_1.packageIsDevDependency, () => {
+    it("returns true if package is a dev dependency", () => {
+        expect(packageIsDevDependency_1.packageIsDevDependency({
+            appPath,
+            packageDetails: PackageDetails_1.getPackageDetailsFromPatchFilename("typescript+3.0.1.patch"),
+        })).toBe(true);
+    });
+    it("returns false if package is not a dev dependency", () => {
+        expect(packageIsDevDependency_1.packageIsDevDependency({
+            appPath,
+            packageDetails: PackageDetails_1.getPackageDetailsFromPatchFilename("chalk+3.0.1.patch"),
+        })).toBe(false);
+    });
+    it("returns false if package is a transitive dependency of a dev dependency", () => {
+        expect(fs_1.existsSync(path_1.join(appPath, "node_modules/cosmiconfig"))).toBe(true);
+        expect(packageIsDevDependency_1.packageIsDevDependency({
+            appPath,
+            packageDetails: PackageDetails_1.getPackageDetailsFromPatchFilename(
+            // cosmiconfig is a transitive dep of lint-staged
+            "cosmiconfig+3.0.1.patch"),
+        })).toBe(false);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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