@wix/cli 1.1.153 → 1.1.155

package/build/{chunk-EULO7YSZ.js → chunk-ZNOHJURI.js}

@@ -17,7 +17,7 @@ import {
   resolveUrl,
   serializer,
   toURLSearchParams
-} from "./chunk-3Q7XZST5.js";
+} from "./chunk-UMKJZ6EW.js";
 import {
   require_index_node,
   require_ms,
@@ -9356,14 +9356,14 @@ var require_find_made = __commonJS({
   "../../node_modules/mkdirp/lib/find-made.js"(exports2, module2) {
     "use strict";
     init_esm_shims();
-    var { dirname: dirname4 } = __require("path");
+    var { dirname: dirname5 } = __require("path");
     var findMade = (opts, parent, path2 = void 0) => {
       if (path2 === parent)
         return Promise.resolve();
       return opts.statAsync(parent).then(
         (st) => st.isDirectory() ? path2 : void 0,
         // will fail later
-        (er) => er.code === "ENOENT" ? findMade(opts, dirname4(parent), parent) : void 0
+        (er) => er.code === "ENOENT" ? findMade(opts, dirname5(parent), parent) : void 0
       );
     };
     var findMadeSync = (opts, parent, path2 = void 0) => {
@@ -9372,7 +9372,7 @@ var require_find_made = __commonJS({
       try {
         return opts.statSync(parent).isDirectory() ? path2 : void 0;
       } catch (er) {
-        return er.code === "ENOENT" ? findMadeSync(opts, dirname4(parent), parent) : void 0;
+        return er.code === "ENOENT" ? findMadeSync(opts, dirname5(parent), parent) : void 0;
       }
     };
     module2.exports = { findMade, findMadeSync };
@@ -9384,10 +9384,10 @@ var require_mkdirp_manual = __commonJS({
   "../../node_modules/mkdirp/lib/mkdirp-manual.js"(exports2, module2) {
     "use strict";
     init_esm_shims();
-    var { dirname: dirname4 } = __require("path");
+    var { dirname: dirname5 } = __require("path");
     var mkdirpManual = (path2, opts, made) => {
       opts.recursive = false;
-      const parent = dirname4(path2);
+      const parent = dirname5(path2);
       if (parent === path2) {
         return opts.mkdirAsync(path2, opts).catch((er) => {
           if (er.code !== "EISDIR")
@@ -9410,7 +9410,7 @@ var require_mkdirp_manual = __commonJS({
       });
     };
     var mkdirpManualSync = (path2, opts, made) => {
-      const parent = dirname4(path2);
+      const parent = dirname5(path2);
       opts.recursive = false;
       if (parent === path2) {
         try {
@@ -9447,12 +9447,12 @@ var require_mkdirp_native = __commonJS({
   "../../node_modules/mkdirp/lib/mkdirp-native.js"(exports2, module2) {
     "use strict";
     init_esm_shims();
-    var { dirname: dirname4 } = __require("path");
+    var { dirname: dirname5 } = __require("path");
     var { findMade, findMadeSync } = require_find_made();
     var { mkdirpManual, mkdirpManualSync } = require_mkdirp_manual();
     var mkdirpNative = (path2, opts) => {
       opts.recursive = true;
-      const parent = dirname4(path2);
+      const parent = dirname5(path2);
       if (parent === path2)
         return opts.mkdirAsync(path2, opts);
       return findMade(opts, path2).then((made) => opts.mkdirAsync(path2, opts).then(() => made).catch((er) => {
@@ -9464,7 +9464,7 @@ var require_mkdirp_native = __commonJS({
     };
     var mkdirpNativeSync = (path2, opts) => {
       opts.recursive = true;
-      const parent = dirname4(path2);
+      const parent = dirname5(path2);
       if (parent === path2)
         return opts.mkdirSync(path2, opts);
       const made = findMadeSync(opts, path2);
@@ -13222,7 +13222,7 @@ var require_polyfill = __commonJS({
       utimes
     } = __require("fs/promises");
     var {
-      dirname: dirname4,
+      dirname: dirname5,
       isAbsolute,
       join: join8,
       parse: parse3,
@@ -13320,7 +13320,7 @@ var require_polyfill = __commonJS({
       ]);
     }
     async function checkParentDir(destStat, src, dest, opts) {
-      const destParent = dirname4(dest);
+      const destParent = dirname5(dest);
       const dirExists = await pathExists2(destParent);
       if (dirExists) {
         return getStatsForCopy(destStat, src, dest, opts);
@@ -13336,8 +13336,8 @@ var require_polyfill = __commonJS({
       );
     }
     async function checkParentPaths(src, srcStat, dest) {
-      const srcParent = resolve(dirname4(src));
-      const destParent = resolve(dirname4(dest));
+      const srcParent = resolve(dirname5(src));
+      const destParent = resolve(dirname5(dest));
       if (destParent === srcParent || destParent === parse3(destParent).root) {
         return;
       }
@@ -13490,7 +13490,7 @@ var require_polyfill = __commonJS({
     async function onLink(destStat, src, dest) {
       let resolvedSrc = await readlink(src);
       if (!isAbsolute(resolvedSrc)) {
-        resolvedSrc = resolve(dirname4(src), resolvedSrc);
+        resolvedSrc = resolve(dirname5(src), resolvedSrc);
       }
       if (!destStat) {
         return symlink(resolvedSrc, dest);
@@ -13505,7 +13505,7 @@ var require_polyfill = __commonJS({
         throw err;
       }
       if (!isAbsolute(resolvedDest)) {
-        resolvedDest = resolve(dirname4(dest), resolvedDest);
+        resolvedDest = resolve(dirname5(dest), resolvedDest);
       }
       if (isSrcSubdir(resolvedSrc, resolvedDest)) {
         throw new ERR_FS_CP_EINVAL({
@@ -13617,7 +13617,7 @@ var require_move_file = __commonJS({
   "../../node_modules/cacache/node_modules/@npmcli/fs/lib/move-file.js"(exports2, module2) {
     "use strict";
     init_esm_shims();
-    var { dirname: dirname4, join: join8, resolve, relative: relative5, isAbsolute } = __require("path");
+    var { dirname: dirname5, join: join8, resolve, relative: relative5, isAbsolute } = __require("path");
     var fs = __require("fs/promises");
     var pathExists2 = async (path2) => {
       try {
@@ -13638,7 +13638,7 @@ var require_move_file = __commonJS({
       if (!options.overwrite && await pathExists2(destination)) {
         throw new Error(`The destination file exists: ${destination}`);
       }
-      await fs.mkdir(dirname4(destination), { recursive: true });
+      await fs.mkdir(dirname5(destination), { recursive: true });
       try {
         await fs.rename(source, destination);
       } catch (error) {
@@ -13666,7 +13666,7 @@ var require_move_file = __commonJS({
           }
           let targetStat = "file";
           try {
-            targetStat = await fs.stat(resolve(dirname4(symSource), target));
+            targetStat = await fs.stat(resolve(dirname5(symSource), target));
             if (targetStat.isDirectory()) {
               targetStat = "junction";
             }
@@ -18197,7 +18197,7 @@ var require_lib13 = __commonJS({
     var readdir2 = promisify(fs.readdir);
     var stat = promisify(fs.stat);
     var lstat = promisify(fs.lstat);
-    var { relative: relative5, resolve, basename, dirname: dirname4 } = __require("path");
+    var { relative: relative5, resolve, basename, dirname: dirname5 } = __require("path");
     var normalizePackageBin = require_lib11();
     var readPackage = ({ path: path2, packageJsonCache }) => packageJsonCache.has(path2) ? Promise.resolve(packageJsonCache.get(path2)) : readFile4(path2).then((json) => {
       const pkg = normalizePackageBin(JSON.parse(json));
@@ -18252,9 +18252,9 @@ var require_lib13 = __commonJS({
       }
       if (pkg) {
         if (pkg.bin) {
-          const dir = dirname4(path2);
+          const dir = dirname5(path2);
           const scope = basename(dir);
-          const nm = /^@.+/.test(scope) ? dirname4(dir) : dir;
+          const nm = /^@.+/.test(scope) ? dirname5(dir) : dir;
           const binFiles = [];
           Object.keys(pkg.bin).forEach((b) => {
             const base = resolve(nm, ".bin", b);
@@ -18476,7 +18476,7 @@ var require_lib15 = __commonJS({
     var { readFile: readFile4, lstat, readdir: readdir2 } = __require("fs/promises");
     var parse3 = require_lib14();
     var normalizePackageBin = require_lib11();
-    var { resolve, dirname: dirname4, join: join8, relative: relative5 } = __require("path");
+    var { resolve, dirname: dirname5, join: join8, relative: relative5 } = __require("path");
     var rpj = (path2) => readFile4(path2, "utf8").then((data) => readBinDir(path2, normalize(stripUnderscores(parse3(data))))).catch((er) => {
       er.path = path2;
       throw er;
@@ -18489,7 +18489,7 @@ var require_lib15 = __commonJS({
       if (!m || typeof m !== "string") {
         return data;
       }
-      const root = dirname4(path2);
+      const root = dirname5(path2);
       const dir = join8(".", join8("/", m));
       data.bin = await walkBinDir(root, dir, {});
       return data;
@@ -22345,14 +22345,14 @@ var require_read_json = __commonJS({
       if (data.man || !cwd) {
         return cb(null, data);
       }
-      const dirname4 = path2.dirname(file);
+      const dirname5 = path2.dirname(file);
       cwd = path2.resolve(path2.dirname(file), cwd);
       glob("**/*.[0-9]", { cwd }, function(er, mansGlob) {
         if (er) {
           return cb(er);
         }
         data.man = mansGlob.map(
-          (man) => path2.relative(dirname4, path2.join(cwd, man)).split(path2.sep).join("/")
+          (man) => path2.relative(dirname5, path2.join(cwd, man)).split(path2.sep).join("/")
         );
         return cb(null, data);
       });
@@ -37477,21 +37477,21 @@ var require_agent4 = __commonJS({
       });
     }
     module2.exports.getProcessEnv = getProcessEnv;
-    function getProcessEnv(env) {
-      if (!env) {
+    function getProcessEnv(env2) {
+      if (!env2) {
         return;
       }
       let value;
-      if (Array.isArray(env)) {
-        for (const e of env) {
+      if (Array.isArray(env2)) {
+        for (const e of env2) {
           value = process.env[e] || process.env[e.toUpperCase()] || process.env[e.toLowerCase()];
           if (typeof value !== "undefined") {
             break;
           }
         }
       }
-      if (typeof env === "string") {
-        value = process.env[env] || process.env[env.toUpperCase()] || process.env[env.toLowerCase()];
+      if (typeof env2 === "string") {
+        value = process.env[env2] || process.env[env2.toUpperCase()] || process.env[env2.toLowerCase()];
       }
       return value;
     }
@@ -40530,7 +40530,7 @@ var require_lib21 = __commonJS({
     init_esm_shims();
     var { Walker: IgnoreWalker } = require_lib20();
     var { lstatSync: lstat, readFileSync: readFile4 } = __require("fs");
-    var { basename, dirname: dirname4, extname, join: join8, relative: relative5, resolve, sep } = __require("path");
+    var { basename, dirname: dirname5, extname, join: join8, relative: relative5, resolve, sep } = __require("path");
     var defaultRules = Symbol("npm-packlist.rules.default");
     var strictRules = Symbol("npm-packlist.rules.strict");
     var nameIsBadForWindows = (file) => /\*/.test(file);
@@ -40615,7 +40615,7 @@ var require_lib21 = __commonJS({
           const prefix = normalizePath(options.prefix);
           const workspaces = options.workspaces.map((ws) => normalizePath(ws));
           if (path2 !== prefix && workspaces.includes(path2)) {
-            const relpath = relative5(options.prefix, dirname4(options.path));
+            const relpath = relative5(options.prefix, dirname5(options.path));
             additionalDefaults.push(...readOutOfTreeIgnoreFiles(options.prefix, relpath));
           } else if (path2 === prefix) {
             additionalDefaults.push(...workspaces.map((w) => normalizePath(relative5(options.path, w))));
@@ -40863,10 +40863,10 @@ var require_set_path = __commonJS({
   "../../node_modules/@npmcli/run-script/lib/set-path.js"(exports2, module2) {
     "use strict";
     init_esm_shims();
-    var { resolve, dirname: dirname4, delimiter } = __require("path");
+    var { resolve, dirname: dirname5, delimiter } = __require("path");
     var nodeGypPath = resolve(__dirname, "../lib/node-gyp-bin");
-    var setPATH = (projectPath, binPaths, env) => {
-      const PATH = Object.keys(env).filter((p2) => /^path$/i.test(p2) && env[p2]).map((p2) => env[p2].split(delimiter)).reduce((set, p2) => set.concat(p2.filter((concatted) => !set.includes(concatted))), []).join(delimiter);
+    var setPATH = (projectPath, binPaths, env2) => {
+      const PATH = Object.keys(env2).filter((p2) => /^path$/i.test(p2) && env2[p2]).map((p2) => env2[p2].split(delimiter)).reduce((set, p2) => set.concat(p2.filter((concatted) => !set.includes(concatted))), []).join(delimiter);
       const pathArr = [];
       if (binPaths) {
         pathArr.push(...binPaths);
@@ -40876,16 +40876,16 @@ var require_set_path = __commonJS({
       do {
         pathArr.push(resolve(p, "node_modules", ".bin"));
         pp = p;
-        p = dirname4(p);
+        p = dirname5(p);
       } while (p !== pp);
       pathArr.push(nodeGypPath, PATH);
       const pathVal = pathArr.join(delimiter);
-      for (const key of Object.keys(env)) {
+      for (const key of Object.keys(env2)) {
         if (/^path$/i.test(key)) {
-          env[key] = pathVal;
+          env2[key] = pathVal;
         }
       }
-      return env;
+      return env2;
     };
     module2.exports = setPATH;
   }
@@ -40905,7 +40905,7 @@ var require_make_spawn_args = __commonJS({
         path: path2,
         scriptShell = true,
         binPaths,
-        env = {},
+        env: env2 = {},
         stdio,
         cmd,
         args: args2 = [],
@@ -40914,7 +40914,7 @@ var require_make_spawn_args = __commonJS({
       const spawnEnv = setPATH(path2, binPaths, {
         // we need to at least save the PATH environment var
         ...process.env,
-        ...env,
+        ...env2,
         npm_package_json: resolve(path2, "package.json"),
         npm_lifecycle_event: event,
         npm_lifecycle_script: cmd,
@@ -41238,19 +41238,19 @@ var require_package_envs = __commonJS({
     "use strict";
     init_esm_shims();
     var envVal = (val) => Array.isArray(val) ? val.map((v) => envVal(v)).join("\n\n") : val === null || val === false ? "" : String(val);
-    var packageEnvs = (env, vals, prefix) => {
+    var packageEnvs = (env2, vals, prefix) => {
       for (const [key, val] of Object.entries(vals)) {
         if (val === void 0) {
           continue;
         } else if (val && !Array.isArray(val) && typeof val === "object") {
-          packageEnvs(env, val, `${prefix}${key}_`);
+          packageEnvs(env2, val, `${prefix}${key}_`);
         } else {
-          env[`${prefix}${key}`] = envVal(val);
+          env2[`${prefix}${key}`] = envVal(val);
         }
       }
-      return env;
+      return env2;
     };
-    module2.exports = (env, pkg) => packageEnvs({ ...env }, {
+    module2.exports = (env2, pkg) => packageEnvs({ ...env2 }, {
       name: pkg.name,
       version: pkg.version,
       config: pkg.config,
@@ -41376,7 +41376,7 @@ var require_run_script_pkg = __commonJS({
         path: path2,
         scriptShell,
         binPaths = false,
-        env = {},
+        env: env2 = {},
         stdio = "pipe",
         pkg,
         args: args2 = [],
@@ -41412,7 +41412,7 @@ var require_run_script_pkg = __commonJS({
         path: path2,
         scriptShell,
         binPaths,
-        env: packageEnvs(env, pkg),
+        env: packageEnvs(env2, pkg),
         stdio,
         cmd,
         args: args2,
@@ -41457,7 +41457,7 @@ var require_validate_options = __commonJS({
         event,
         path: path2,
         scriptShell,
-        env = {},
+        env: env2 = {},
         stdio = "pipe",
         args: args2 = [],
         cmd
@@ -41471,7 +41471,7 @@ var require_validate_options = __commonJS({
       if (scriptShell !== void 0 && typeof scriptShell !== "string") {
         throw new TypeError("invalid scriptShell option provided to runScript");
       }
-      if (typeof env !== "object" || !env) {
+      if (typeof env2 !== "object" || !env2) {
         throw new TypeError("invalid env option provided to runScript");
       }
       if (typeof stdio !== "string" && !Array.isArray(stdio)) {
@@ -42369,13 +42369,13 @@ var require_find = __commonJS({
     "use strict";
     init_esm_shims();
     var is = require_is();
-    var { dirname: dirname4 } = __require("path");
+    var { dirname: dirname5 } = __require("path");
     module2.exports = async ({ cwd = process.cwd() } = {}) => {
       if (await is({ cwd })) {
         return cwd;
       }
-      while (cwd !== dirname4(cwd)) {
-        cwd = dirname4(cwd);
+      while (cwd !== dirname5(cwd)) {
+        cwd = dirname5(cwd);
         if (await is({ cwd })) {
           return cwd;
         }
@@ -42418,11 +42418,11 @@ var require_npm = __commonJS({
     "use strict";
     init_esm_shims();
     var spawn = require_lib23();
-    module2.exports = (npmBin, npmCommand, cwd, env, extra) => {
+    module2.exports = (npmBin, npmCommand, cwd, env2, extra) => {
       const isJS = npmBin.endsWith(".js");
       const cmd = isJS ? process.execPath : npmBin;
       const args2 = (isJS ? [npmBin] : []).concat(npmCommand);
-      return spawn(cmd, args2, { cwd, env }, extra);
+      return spawn(cmd, args2, { cwd, env: env2 }, extra);
     };
   }
 });
@@ -42867,7 +42867,7 @@ var require_fetcher = __commonJS({
     var npa = require_npa();
     var ssri = require_lib4();
     var { promisify } = __require("util");
-    var { basename, dirname: dirname4 } = __require("path");
+    var { basename, dirname: dirname5 } = __require("path");
     var tar = require_tar();
     var log2 = require_lib3();
     var retry2 = require_promise_retry();
@@ -42931,7 +42931,7 @@ var require_fetcher = __commonJS({
         this.npmBin = opts.npmBin || "npm";
         this.npmInstallCmd = opts.npmInstallCmd || ["install", "--force"];
         this.npmCliConfig = opts.npmCliConfig || [
-          `--cache=${dirname4(this.cache)}`,
+          `--cache=${dirname5(this.cache)}`,
           `--prefer-offline=${!!this.preferOffline}`,
           `--prefer-online=${!!this.preferOnline}`,
           `--offline=${!!this.offline}`,
@@ -43127,7 +43127,7 @@ var require_fetcher = __commonJS({
       }
       // don't use this[_mkdir] because we don't want to rimraf anything
       async tarballFile(dest) {
-        const dir = dirname4(dest);
+        const dir = dirname5(dest);
         await fs.mkdir(dir, { recursive: true });
         return this[_toFile](dest);
       }
@@ -43504,6 +43504,7 @@ var require_types_impl = __commonJS({
       GridAppLayout4["ONLINE"] = "ONLINE";
       GridAppLayout4["GITHUB"] = "GITHUB";
       GridAppLayout4["GITHUB_BLOCKS"] = "GITHUB_BLOCKS";
+      GridAppLayout4["WIX_IDE"] = "WIX_IDE";
     })(GridAppLayout3 = exports2.GridAppLayout || (exports2.GridAppLayout = {}));
   }
 });
@@ -43620,7 +43621,7 @@ import { join as join4, relative as relative3 } from "node:path";
 import { access, readFile, writeFile } from "node:fs/promises";
 import { EOL } from "node:os";
 import { mkdir } from "node:fs/promises";
-import { dirname, join as join22, relative as relative2 } from "node:path";
+import { dirname as dirname2, join as join22, relative as relative2 } from "node:path";
 
 // ../../node_modules/@wix/velo-site-types-syncer/node_modules/p-retry/index.js
 init_esm_shims();
@@ -43711,11 +43712,13 @@ async function pRetry(input, options) {
 // ../../node_modules/@wix/velo-site-types-syncer/build/index.js
 var import_comment_json2 = __toESM(require_src3(), 1);
 var import_http_client = __toESM(require_index_node(), 1);
-import { join as join3 } from "node:path";
+import { dirname, join as join3 } from "node:path";
+import { createRequire } from "node:module";
+import { env } from "node:process";
 import { mkdir as mkdir2 } from "node:fs/promises";
-import { join as join32, dirname as dirname2, relative as relative22 } from "node:path";
+import { join as join32, dirname as dirname3, relative as relative22 } from "node:path";
 import { mkdir as mkdir3, writeFile as writeFile3, rm as rm2, readFile as readFile3 } from "node:fs/promises";
-import path, { dirname as dirname3, join as join6, relative as relative4 } from "node:path";
+import path, { dirname as dirname4, join as join6, relative as relative4 } from "node:path";
 var import_verror2 = __toESM(require_verror(), 1);
 var import_types = __toESM(require_types_impl(), 1);
 var import_types_impl = __toESM(require_types_impl2(), 1);
@@ -43944,6 +43947,9 @@ function transformPath(payload) {
       entityFqdn: "wix.velo.ide.v1.path_transform",
       method: "POST",
       methodFqn: "wix.velo.ide.v1.PathTransformations.TransformPath",
+      migrationOptions: {
+        optInTransformResponse: true
+      },
       url: resolveWixVeloIdeV1PathTransformationsUrl({
         protoPath: "/v1/path-transforms",
         data: serializedData,
@@ -44088,6 +44094,2170 @@ var getFullSdkType = (args2) => {
 var sdkTypes_default = { getFullSdkType };
 
 // ../../node_modules/@wix/velo-site-types-syncer/build/index.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require2 = /* @__PURE__ */ ((x) => typeof __require !== "undefined" ? __require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof __require !== "undefined" ? __require : a)[b]
+}) : x)(function(x) {
+  if (typeof __require !== "undefined")
+    return __require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS2 = (cb, mod) => function __require22() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var require_universalify = __commonJS2({
+  "../../node_modules/universalify/index.js"(exports2) {
+    "use strict";
+    exports2.fromCallback = function(fn2) {
+      return Object.defineProperty(function(...args2) {
+        if (typeof args2[args2.length - 1] === "function")
+          fn2.apply(this, args2);
+        else {
+          return new Promise((resolve, reject) => {
+            fn2.call(
+              this,
+              ...args2,
+              (err, res) => err != null ? reject(err) : resolve(res)
+            );
+          });
+        }
+      }, "name", { value: fn2.name });
+    };
+    exports2.fromPromise = function(fn2) {
+      return Object.defineProperty(function(...args2) {
+        const cb = args2[args2.length - 1];
+        if (typeof cb !== "function")
+          return fn2.apply(this, args2);
+        else
+          fn2.apply(this, args2.slice(0, -1)).then((r) => cb(null, r), cb);
+      }, "name", { value: fn2.name });
+    };
+  }
+});
+var require_polyfills = __commonJS2({
+  "../../node_modules/graceful-fs/polyfills.js"(exports2, module2) {
+    var constants = __require2("constants");
+    var origCwd = process.cwd;
+    var cwd = null;
+    var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    process.cwd = function() {
+      if (!cwd)
+        cwd = origCwd.call(process);
+      return cwd;
+    };
+    try {
+      process.cwd();
+    } catch (er) {
+    }
+    if (typeof process.chdir === "function") {
+      chdir = process.chdir;
+      process.chdir = function(d) {
+        cwd = null;
+        chdir.call(process, d);
+      };
+      if (Object.setPrototypeOf)
+        Object.setPrototypeOf(process.chdir, chdir);
+    }
+    var chdir;
+    module2.exports = patch;
+    function patch(fs2) {
+      if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+        patchLchmod(fs2);
+      }
+      if (!fs2.lutimes) {
+        patchLutimes(fs2);
+      }
+      fs2.chown = chownFix(fs2.chown);
+      fs2.fchown = chownFix(fs2.fchown);
+      fs2.lchown = chownFix(fs2.lchown);
+      fs2.chmod = chmodFix(fs2.chmod);
+      fs2.fchmod = chmodFix(fs2.fchmod);
+      fs2.lchmod = chmodFix(fs2.lchmod);
+      fs2.chownSync = chownFixSync(fs2.chownSync);
+      fs2.fchownSync = chownFixSync(fs2.fchownSync);
+      fs2.lchownSync = chownFixSync(fs2.lchownSync);
+      fs2.chmodSync = chmodFixSync(fs2.chmodSync);
+      fs2.fchmodSync = chmodFixSync(fs2.fchmodSync);
+      fs2.lchmodSync = chmodFixSync(fs2.lchmodSync);
+      fs2.stat = statFix(fs2.stat);
+      fs2.fstat = statFix(fs2.fstat);
+      fs2.lstat = statFix(fs2.lstat);
+      fs2.statSync = statFixSync(fs2.statSync);
+      fs2.fstatSync = statFixSync(fs2.fstatSync);
+      fs2.lstatSync = statFixSync(fs2.lstatSync);
+      if (fs2.chmod && !fs2.lchmod) {
+        fs2.lchmod = function(path2, mode, cb) {
+          if (cb)
+            process.nextTick(cb);
+        };
+        fs2.lchmodSync = function() {
+        };
+      }
+      if (fs2.chown && !fs2.lchown) {
+        fs2.lchown = function(path2, uid, gid, cb) {
+          if (cb)
+            process.nextTick(cb);
+        };
+        fs2.lchownSync = function() {
+        };
+      }
+      if (platform === "win32") {
+        fs2.rename = typeof fs2.rename !== "function" ? fs2.rename : function(fs$rename) {
+          function rename(from, to, cb) {
+            var start = Date.now();
+            var backoff = 0;
+            fs$rename(from, to, function CB(er) {
+              if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
+                setTimeout(function() {
+                  fs2.stat(to, function(stater, st) {
+                    if (stater && stater.code === "ENOENT")
+                      fs$rename(from, to, CB);
+                    else
+                      cb(er);
+                  });
+                }, backoff);
+                if (backoff < 100)
+                  backoff += 10;
+                return;
+              }
+              if (cb)
+                cb(er);
+            });
+          }
+          if (Object.setPrototypeOf)
+            Object.setPrototypeOf(rename, fs$rename);
+          return rename;
+        }(fs2.rename);
+      }
+      fs2.read = typeof fs2.read !== "function" ? fs2.read : function(fs$read) {
+        function read(fd, buffer, offset, length, position, callback_) {
+          var callback;
+          if (callback_ && typeof callback_ === "function") {
+            var eagCounter = 0;
+            callback = function(er, _, __) {
+              if (er && er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
+              }
+              callback_.apply(this, arguments);
+            };
+          }
+          return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
+        }
+        if (Object.setPrototypeOf)
+          Object.setPrototypeOf(read, fs$read);
+        return read;
+      }(fs2.read);
+      fs2.readSync = typeof fs2.readSync !== "function" ? fs2.readSync : /* @__PURE__ */ function(fs$readSync) {
+        return function(fd, buffer, offset, length, position) {
+          var eagCounter = 0;
+          while (true) {
+            try {
+              return fs$readSync.call(fs2, fd, buffer, offset, length, position);
+            } catch (er) {
+              if (er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                continue;
+              }
+              throw er;
+            }
+          }
+        };
+      }(fs2.readSync);
+      function patchLchmod(fs3) {
+        fs3.lchmod = function(path2, mode, callback) {
+          fs3.open(
+            path2,
+            constants.O_WRONLY | constants.O_SYMLINK,
+            mode,
+            function(err, fd) {
+              if (err) {
+                if (callback)
+                  callback(err);
+                return;
+              }
+              fs3.fchmod(fd, mode, function(err2) {
+                fs3.close(fd, function(err22) {
+                  if (callback)
+                    callback(err2 || err22);
+                });
+              });
+            }
+          );
+        };
+        fs3.lchmodSync = function(path2, mode) {
+          var fd = fs3.openSync(path2, constants.O_WRONLY | constants.O_SYMLINK, mode);
+          var threw = true;
+          var ret;
+          try {
+            ret = fs3.fchmodSync(fd, mode);
+            threw = false;
+          } finally {
+            if (threw) {
+              try {
+                fs3.closeSync(fd);
+              } catch (er) {
+              }
+            } else {
+              fs3.closeSync(fd);
+            }
+          }
+          return ret;
+        };
+      }
+      function patchLutimes(fs3) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs3.futimes) {
+          fs3.lutimes = function(path2, at, mt, cb) {
+            fs3.open(path2, constants.O_SYMLINK, function(er, fd) {
+              if (er) {
+                if (cb)
+                  cb(er);
+                return;
+              }
+              fs3.futimes(fd, at, mt, function(er2) {
+                fs3.close(fd, function(er22) {
+                  if (cb)
+                    cb(er2 || er22);
+                });
+              });
+            });
+          };
+          fs3.lutimesSync = function(path2, at, mt) {
+            var fd = fs3.openSync(path2, constants.O_SYMLINK);
+            var ret;
+            var threw = true;
+            try {
+              ret = fs3.futimesSync(fd, at, mt);
+              threw = false;
+            } finally {
+              if (threw) {
+                try {
+                  fs3.closeSync(fd);
+                } catch (er) {
+                }
+              } else {
+                fs3.closeSync(fd);
+              }
+            }
+            return ret;
+          };
+        } else if (fs3.futimes) {
+          fs3.lutimes = function(_a, _b, _c, cb) {
+            if (cb)
+              process.nextTick(cb);
+          };
+          fs3.lutimesSync = function() {
+          };
+        }
+      }
+      function chmodFix(orig) {
+        if (!orig)
+          return orig;
+        return function(target, mode, cb) {
+          return orig.call(fs2, target, mode, function(er) {
+            if (chownErOk(er))
+              er = null;
+            if (cb)
+              cb.apply(this, arguments);
+          });
+        };
+      }
+      function chmodFixSync(orig) {
+        if (!orig)
+          return orig;
+        return function(target, mode) {
+          try {
+            return orig.call(fs2, target, mode);
+          } catch (er) {
+            if (!chownErOk(er))
+              throw er;
+          }
+        };
+      }
+      function chownFix(orig) {
+        if (!orig)
+          return orig;
+        return function(target, uid, gid, cb) {
+          return orig.call(fs2, target, uid, gid, function(er) {
+            if (chownErOk(er))
+              er = null;
+            if (cb)
+              cb.apply(this, arguments);
+          });
+        };
+      }
+      function chownFixSync(orig) {
+        if (!orig)
+          return orig;
+        return function(target, uid, gid) {
+          try {
+            return orig.call(fs2, target, uid, gid);
+          } catch (er) {
+            if (!chownErOk(er))
+              throw er;
+          }
+        };
+      }
+      function statFix(orig) {
+        if (!orig)
+          return orig;
+        return function(target, options, cb) {
+          if (typeof options === "function") {
+            cb = options;
+            options = null;
+          }
+          function callback(er, stats) {
+            if (stats) {
+              if (stats.uid < 0)
+                stats.uid += 4294967296;
+              if (stats.gid < 0)
+                stats.gid += 4294967296;
+            }
+            if (cb)
+              cb.apply(this, arguments);
+          }
+          return options ? orig.call(fs2, target, options, callback) : orig.call(fs2, target, callback);
+        };
+      }
+      function statFixSync(orig) {
+        if (!orig)
+          return orig;
+        return function(target, options) {
+          var stats = options ? orig.call(fs2, target, options) : orig.call(fs2, target);
+          if (stats) {
+            if (stats.uid < 0)
+              stats.uid += 4294967296;
+            if (stats.gid < 0)
+              stats.gid += 4294967296;
+          }
+          return stats;
+        };
+      }
+      function chownErOk(er) {
+        if (!er)
+          return true;
+        if (er.code === "ENOSYS")
+          return true;
+        var nonroot = !process.getuid || process.getuid() !== 0;
+        if (nonroot) {
+          if (er.code === "EINVAL" || er.code === "EPERM")
+            return true;
+        }
+        return false;
+      }
+    }
+  }
+});
+var require_legacy_streams = __commonJS2({
+  "../../node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
+    var Stream = __require2("stream").Stream;
+    module2.exports = legacy;
+    function legacy(fs2) {
+      return {
+        ReadStream,
+        WriteStream
+      };
+      function ReadStream(path2, options) {
+        if (!(this instanceof ReadStream))
+          return new ReadStream(path2, options);
+        Stream.call(this);
+        var self = this;
+        this.path = path2;
+        this.fd = null;
+        this.readable = true;
+        this.paused = false;
+        this.flags = "r";
+        this.mode = 438;
+        this.bufferSize = 64 * 1024;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.encoding)
+          this.setEncoding(this.encoding);
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.end === void 0) {
+            this.end = Infinity;
+          } else if ("number" !== typeof this.end) {
+            throw TypeError("end must be a Number");
+          }
+          if (this.start > this.end) {
+            throw new Error("start must be <= end");
+          }
+          this.pos = this.start;
+        }
+        if (this.fd !== null) {
+          process.nextTick(function() {
+            self._read();
+          });
+          return;
+        }
+        fs2.open(this.path, this.flags, this.mode, function(err, fd) {
+          if (err) {
+            self.emit("error", err);
+            self.readable = false;
+            return;
+          }
+          self.fd = fd;
+          self.emit("open", fd);
+          self._read();
+        });
+      }
+      function WriteStream(path2, options) {
+        if (!(this instanceof WriteStream))
+          return new WriteStream(path2, options);
+        Stream.call(this);
+        this.path = path2;
+        this.fd = null;
+        this.writable = true;
+        this.flags = "w";
+        this.encoding = "binary";
+        this.mode = 438;
+        this.bytesWritten = 0;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.start < 0) {
+            throw new Error("start must be >= zero");
+          }
+          this.pos = this.start;
+        }
+        this.busy = false;
+        this._queue = [];
+        if (this.fd === null) {
+          this._open = fs2.open;
+          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
+          this.flush();
+        }
+      }
+    }
+  }
+});
+var require_clone2 = __commonJS2({
+  "../../node_modules/graceful-fs/clone.js"(exports2, module2) {
+    "use strict";
+    module2.exports = clone;
+    var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+      return obj.__proto__;
+    };
+    function clone(obj) {
+      if (obj === null || typeof obj !== "object")
+        return obj;
+      if (obj instanceof Object)
+        var copy = { __proto__: getPrototypeOf(obj) };
+      else
+        var copy = /* @__PURE__ */ Object.create(null);
+      Object.getOwnPropertyNames(obj).forEach(function(key) {
+        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+      });
+      return copy;
+    }
+  }
+});
+var require_graceful_fs = __commonJS2({
+  "../../node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
+    var fs2 = __require2("fs");
+    var polyfills = require_polyfills();
+    var legacy = require_legacy_streams();
+    var clone = require_clone2();
+    var util = __require2("util");
+    var gracefulQueue;
+    var previousSymbol;
+    if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+      gracefulQueue = Symbol.for("graceful-fs.queue");
+      previousSymbol = Symbol.for("graceful-fs.previous");
+    } else {
+      gracefulQueue = "___graceful-fs.queue";
+      previousSymbol = "___graceful-fs.previous";
+    }
+    function noop() {
+    }
+    function publishQueue(context, queue2) {
+      Object.defineProperty(context, gracefulQueue, {
+        get: function() {
+          return queue2;
+        }
+      });
+    }
+    var debug = noop;
+    if (util.debuglog)
+      debug = util.debuglog("gfs4");
+    else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
+      debug = function() {
+        var m = util.format.apply(util, arguments);
+        m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
+        console.error(m);
+      };
+    if (!fs2[gracefulQueue]) {
+      queue = global[gracefulQueue] || [];
+      publishQueue(fs2, queue);
+      fs2.close = function(fs$close) {
+        function close(fd, cb) {
+          return fs$close.call(fs2, fd, function(err) {
+            if (!err) {
+              resetQueue();
+            }
+            if (typeof cb === "function")
+              cb.apply(this, arguments);
+          });
+        }
+        Object.defineProperty(close, previousSymbol, {
+          value: fs$close
+        });
+        return close;
+      }(fs2.close);
+      fs2.closeSync = function(fs$closeSync) {
+        function closeSync(fd) {
+          fs$closeSync.apply(fs2, arguments);
+          resetQueue();
+        }
+        Object.defineProperty(closeSync, previousSymbol, {
+          value: fs$closeSync
+        });
+        return closeSync;
+      }(fs2.closeSync);
+      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
+        process.on("exit", function() {
+          debug(fs2[gracefulQueue]);
+          __require2("assert").equal(fs2[gracefulQueue].length, 0);
+        });
+      }
+    }
+    var queue;
+    if (!global[gracefulQueue]) {
+      publishQueue(global, fs2[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs2));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs2.__patched) {
+      module2.exports = patch(fs2);
+      fs2.__patched = true;
+    }
+    function patch(fs3) {
+      polyfills(fs3);
+      fs3.gracefulify = patch;
+      fs3.createReadStream = createReadStream;
+      fs3.createWriteStream = createWriteStream;
+      var fs$readFile = fs3.readFile;
+      fs3.readFile = readFile4;
+      function readFile4(path2, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$readFile(path2, options, cb);
+        function go$readFile(path3, options2, cb2, startTime) {
+          return fs$readFile(path3, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$readFile, [path3, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$writeFile = fs3.writeFile;
+      fs3.writeFile = writeFile4;
+      function writeFile4(path2, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$writeFile(path2, data, options, cb);
+        function go$writeFile(path3, data2, options2, cb2, startTime) {
+          return fs$writeFile(path3, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$writeFile, [path3, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$appendFile = fs3.appendFile;
+      if (fs$appendFile)
+        fs3.appendFile = appendFile;
+      function appendFile(path2, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$appendFile(path2, data, options, cb);
+        function go$appendFile(path3, data2, options2, cb2, startTime) {
+          return fs$appendFile(path3, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$appendFile, [path3, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$copyFile = fs3.copyFile;
+      if (fs$copyFile)
+        fs3.copyFile = copyFile;
+      function copyFile(src, dest, flags, cb) {
+        if (typeof flags === "function") {
+          cb = flags;
+          flags = 0;
+        }
+        return go$copyFile(src, dest, flags, cb);
+        function go$copyFile(src2, dest2, flags2, cb2, startTime) {
+          return fs$copyFile(src2, dest2, flags2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$readdir = fs3.readdir;
+      fs3.readdir = readdir2;
+      var noReaddirOptionVersions = /^v[0-5]\./;
+      function readdir2(path2, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path3, options2, cb2, startTime) {
+          return fs$readdir(path3, fs$readdirCallback(
+            path3,
+            options2,
+            cb2,
+            startTime
+          ));
+        } : function go$readdir2(path3, options2, cb2, startTime) {
+          return fs$readdir(path3, options2, fs$readdirCallback(
+            path3,
+            options2,
+            cb2,
+            startTime
+          ));
+        };
+        return go$readdir(path2, options, cb);
+        function fs$readdirCallback(path3, options2, cb2, startTime) {
+          return function(err, files) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([
+                go$readdir,
+                [path3, options2, cb2],
+                err,
+                startTime || Date.now(),
+                Date.now()
+              ]);
+            else {
+              if (files && files.sort)
+                files.sort();
+              if (typeof cb2 === "function")
+                cb2.call(this, err, files);
+            }
+          };
+        }
+      }
+      if (process.version.substr(0, 4) === "v0.8") {
+        var legStreams = legacy(fs3);
+        ReadStream = legStreams.ReadStream;
+        WriteStream = legStreams.WriteStream;
+      }
+      var fs$ReadStream = fs3.ReadStream;
+      if (fs$ReadStream) {
+        ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+        ReadStream.prototype.open = ReadStream$open;
+      }
+      var fs$WriteStream = fs3.WriteStream;
+      if (fs$WriteStream) {
+        WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+        WriteStream.prototype.open = WriteStream$open;
+      }
+      Object.defineProperty(fs3, "ReadStream", {
+        get: function() {
+          return ReadStream;
+        },
+        set: function(val) {
+          ReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(fs3, "WriteStream", {
+        get: function() {
+          return WriteStream;
+        },
+        set: function(val) {
+          WriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileReadStream = ReadStream;
+      Object.defineProperty(fs3, "FileReadStream", {
+        get: function() {
+          return FileReadStream;
+        },
+        set: function(val) {
+          FileReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileWriteStream = WriteStream;
+      Object.defineProperty(fs3, "FileWriteStream", {
+        get: function() {
+          return FileWriteStream;
+        },
+        set: function(val) {
+          FileWriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      function ReadStream(path2, options) {
+        if (this instanceof ReadStream)
+          return fs$ReadStream.apply(this, arguments), this;
+        else
+          return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
+      }
+      function ReadStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            if (that.autoClose)
+              that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+            that.read();
+          }
+        });
+      }
+      function WriteStream(path2, options) {
+        if (this instanceof WriteStream)
+          return fs$WriteStream.apply(this, arguments), this;
+        else
+          return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+      }
+      function WriteStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+          }
+        });
+      }
+      function createReadStream(path2, options) {
+        return new fs3.ReadStream(path2, options);
+      }
+      function createWriteStream(path2, options) {
+        return new fs3.WriteStream(path2, options);
+      }
+      var fs$open = fs3.open;
+      fs3.open = open;
+      function open(path2, flags, mode, cb) {
+        if (typeof mode === "function")
+          cb = mode, mode = null;
+        return go$open(path2, flags, mode, cb);
+        function go$open(path3, flags2, mode2, cb2, startTime) {
+          return fs$open(path3, flags2, mode2, function(err, fd) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$open, [path3, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      return fs3;
+    }
+    function enqueue(elem) {
+      debug("ENQUEUE", elem[0].name, elem[1]);
+      fs2[gracefulQueue].push(elem);
+      retry2();
+    }
+    var retryTimer;
+    function resetQueue() {
+      var now = Date.now();
+      for (var i = 0; i < fs2[gracefulQueue].length; ++i) {
+        if (fs2[gracefulQueue][i].length > 2) {
+          fs2[gracefulQueue][i][3] = now;
+          fs2[gracefulQueue][i][4] = now;
+        }
+      }
+      retry2();
+    }
+    function retry2() {
+      clearTimeout(retryTimer);
+      retryTimer = void 0;
+      if (fs2[gracefulQueue].length === 0)
+        return;
+      var elem = fs2[gracefulQueue].shift();
+      var fn2 = elem[0];
+      var args2 = elem[1];
+      var err = elem[2];
+      var startTime = elem[3];
+      var lastTime = elem[4];
+      if (startTime === void 0) {
+        debug("RETRY", fn2.name, args2);
+        fn2.apply(null, args2);
+      } else if (Date.now() - startTime >= 6e4) {
+        debug("TIMEOUT", fn2.name, args2);
+        var cb = args2.pop();
+        if (typeof cb === "function")
+          cb.call(null, err);
+      } else {
+        var sinceAttempt = Date.now() - lastTime;
+        var sinceStart = Math.max(lastTime - startTime, 1);
+        var desiredDelay = Math.min(sinceStart * 1.2, 100);
+        if (sinceAttempt >= desiredDelay) {
+          debug("RETRY", fn2.name, args2);
+          fn2.apply(null, args2.concat([startTime]));
+        } else {
+          fs2[gracefulQueue].push(elem);
+        }
+      }
+      if (retryTimer === void 0) {
+        retryTimer = setTimeout(retry2, 0);
+      }
+    }
+  }
+});
+var require_fs2 = __commonJS2({
+  "../../node_modules/fs-extra/lib/fs/index.js"(exports2) {
+    "use strict";
+    var u = require_universalify().fromCallback;
+    var fs2 = require_graceful_fs();
+    var api = [
+      "access",
+      "appendFile",
+      "chmod",
+      "chown",
+      "close",
+      "copyFile",
+      "fchmod",
+      "fchown",
+      "fdatasync",
+      "fstat",
+      "fsync",
+      "ftruncate",
+      "futimes",
+      "lchmod",
+      "lchown",
+      "link",
+      "lstat",
+      "mkdir",
+      "mkdtemp",
+      "open",
+      "opendir",
+      "readdir",
+      "readFile",
+      "readlink",
+      "realpath",
+      "rename",
+      "rm",
+      "rmdir",
+      "stat",
+      "symlink",
+      "truncate",
+      "unlink",
+      "utimes",
+      "writeFile"
+    ].filter((key) => {
+      return typeof fs2[key] === "function";
+    });
+    Object.assign(exports2, fs2);
+    api.forEach((method) => {
+      exports2[method] = u(fs2[method]);
+    });
+    exports2.exists = function(filename, callback) {
+      if (typeof callback === "function") {
+        return fs2.exists(filename, callback);
+      }
+      return new Promise((resolve) => {
+        return fs2.exists(filename, resolve);
+      });
+    };
+    exports2.read = function(fd, buffer, offset, length, position, callback) {
+      if (typeof callback === "function") {
+        return fs2.read(fd, buffer, offset, length, position, callback);
+      }
+      return new Promise((resolve, reject) => {
+        fs2.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+          if (err)
+            return reject(err);
+          resolve({ bytesRead, buffer: buffer2 });
+        });
+      });
+    };
+    exports2.write = function(fd, buffer, ...args2) {
+      if (typeof args2[args2.length - 1] === "function") {
+        return fs2.write(fd, buffer, ...args2);
+      }
+      return new Promise((resolve, reject) => {
+        fs2.write(fd, buffer, ...args2, (err, bytesWritten, buffer2) => {
+          if (err)
+            return reject(err);
+          resolve({ bytesWritten, buffer: buffer2 });
+        });
+      });
+    };
+    exports2.readv = function(fd, buffers, ...args2) {
+      if (typeof args2[args2.length - 1] === "function") {
+        return fs2.readv(fd, buffers, ...args2);
+      }
+      return new Promise((resolve, reject) => {
+        fs2.readv(fd, buffers, ...args2, (err, bytesRead, buffers2) => {
+          if (err)
+            return reject(err);
+          resolve({ bytesRead, buffers: buffers2 });
+        });
+      });
+    };
+    exports2.writev = function(fd, buffers, ...args2) {
+      if (typeof args2[args2.length - 1] === "function") {
+        return fs2.writev(fd, buffers, ...args2);
+      }
+      return new Promise((resolve, reject) => {
+        fs2.writev(fd, buffers, ...args2, (err, bytesWritten, buffers2) => {
+          if (err)
+            return reject(err);
+          resolve({ bytesWritten, buffers: buffers2 });
+        });
+      });
+    };
+    if (typeof fs2.realpath.native === "function") {
+      exports2.realpath.native = u(fs2.realpath.native);
+    } else {
+      process.emitWarning(
+        "fs.realpath.native is not a function. Is fs being monkey-patched?",
+        "Warning",
+        "fs-extra-WARN0003"
+      );
+    }
+  }
+});
+var require_utils3 = __commonJS2({
+  "../../node_modules/fs-extra/lib/mkdirs/utils.js"(exports2, module2) {
+    "use strict";
+    var path2 = __require2("path");
+    module2.exports.checkPath = function checkPath(pth) {
+      if (process.platform === "win32") {
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path2.parse(pth).root, ""));
+        if (pathHasInvalidWinCharacters) {
+          const error = new Error(`Path contains invalid characters: ${pth}`);
+          error.code = "EINVAL";
+          throw error;
+        }
+      }
+    };
+  }
+});
+var require_make_dir = __commonJS2({
+  "../../node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_fs2();
+    var { checkPath } = require_utils3();
+    var getMode = (options) => {
+      const defaults = { mode: 511 };
+      if (typeof options === "number")
+        return options;
+      return { ...defaults, ...options }.mode;
+    };
+    module2.exports.makeDir = async (dir, options) => {
+      checkPath(dir);
+      return fs2.mkdir(dir, {
+        mode: getMode(options),
+        recursive: true
+      });
+    };
+    module2.exports.makeDirSync = (dir, options) => {
+      checkPath(dir);
+      return fs2.mkdirSync(dir, {
+        mode: getMode(options),
+        recursive: true
+      });
+    };
+  }
+});
+var require_mkdirs = __commonJS2({
+  "../../node_modules/fs-extra/lib/mkdirs/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var { makeDir: _makeDir, makeDirSync } = require_make_dir();
+    var makeDir = u(_makeDir);
+    module2.exports = {
+      mkdirs: makeDir,
+      mkdirsSync: makeDirSync,
+      // alias
+      mkdirp: makeDir,
+      mkdirpSync: makeDirSync,
+      ensureDir: makeDir,
+      ensureDirSync: makeDirSync
+    };
+  }
+});
+var require_path_exists = __commonJS2({
+  "../../node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var fs2 = require_fs2();
+    function pathExists2(path2) {
+      return fs2.access(path2).then(() => true).catch(() => false);
+    }
+    module2.exports = {
+      pathExists: u(pathExists2),
+      pathExistsSync: fs2.existsSync
+    };
+  }
+});
+var require_utimes = __commonJS2({
+  "../../node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_fs2();
+    var u = require_universalify().fromPromise;
+    async function utimesMillis(path2, atime, mtime) {
+      const fd = await fs2.open(path2, "r+");
+      let closeErr = null;
+      try {
+        await fs2.futimes(fd, atime, mtime);
+      } finally {
+        try {
+          await fs2.close(fd);
+        } catch (e) {
+          closeErr = e;
+        }
+      }
+      if (closeErr) {
+        throw closeErr;
+      }
+    }
+    function utimesMillisSync(path2, atime, mtime) {
+      const fd = fs2.openSync(path2, "r+");
+      fs2.futimesSync(fd, atime, mtime);
+      return fs2.closeSync(fd);
+    }
+    module2.exports = {
+      utimesMillis: u(utimesMillis),
+      utimesMillisSync
+    };
+  }
+});
+var require_stat = __commonJS2({
+  "../../node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_fs2();
+    var path2 = __require2("path");
+    var u = require_universalify().fromPromise;
+    function getStats(src, dest, opts) {
+      const statFunc = opts.dereference ? (file) => fs2.stat(file, { bigint: true }) : (file) => fs2.lstat(file, { bigint: true });
+      return Promise.all([
+        statFunc(src),
+        statFunc(dest).catch((err) => {
+          if (err.code === "ENOENT")
+            return null;
+          throw err;
+        })
+      ]).then(([srcStat, destStat]) => ({ srcStat, destStat }));
+    }
+    function getStatsSync(src, dest, opts) {
+      let destStat;
+      const statFunc = opts.dereference ? (file) => fs2.statSync(file, { bigint: true }) : (file) => fs2.lstatSync(file, { bigint: true });
+      const srcStat = statFunc(src);
+      try {
+        destStat = statFunc(dest);
+      } catch (err) {
+        if (err.code === "ENOENT")
+          return { srcStat, destStat: null };
+        throw err;
+      }
+      return { srcStat, destStat };
+    }
+    async function checkPaths(src, dest, funcName, opts) {
+      const { srcStat, destStat } = await getStats(src, dest, opts);
+      if (destStat) {
+        if (areIdentical(srcStat, destStat)) {
+          const srcBaseName = path2.basename(src);
+          const destBaseName = path2.basename(dest);
+          if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+            return { srcStat, destStat, isChangingCase: true };
+          }
+          throw new Error("Source and destination must not be the same.");
+        }
+        if (srcStat.isDirectory() && !destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+        }
+        if (!srcStat.isDirectory() && destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+        }
+      }
+      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return { srcStat, destStat };
+    }
+    function checkPathsSync(src, dest, funcName, opts) {
+      const { srcStat, destStat } = getStatsSync(src, dest, opts);
+      if (destStat) {
+        if (areIdentical(srcStat, destStat)) {
+          const srcBaseName = path2.basename(src);
+          const destBaseName = path2.basename(dest);
+          if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+            return { srcStat, destStat, isChangingCase: true };
+          }
+          throw new Error("Source and destination must not be the same.");
+        }
+        if (srcStat.isDirectory() && !destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+        }
+        if (!srcStat.isDirectory() && destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+        }
+      }
+      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return { srcStat, destStat };
+    }
+    async function checkParentPaths(src, srcStat, dest, funcName) {
+      const srcParent = path2.resolve(path2.dirname(src));
+      const destParent = path2.resolve(path2.dirname(dest));
+      if (destParent === srcParent || destParent === path2.parse(destParent).root)
+        return;
+      let destStat;
+      try {
+        destStat = await fs2.stat(destParent, { bigint: true });
+      } catch (err) {
+        if (err.code === "ENOENT")
+          return;
+        throw err;
+      }
+      if (areIdentical(srcStat, destStat)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return checkParentPaths(src, srcStat, destParent, funcName);
+    }
+    function checkParentPathsSync(src, srcStat, dest, funcName) {
+      const srcParent = path2.resolve(path2.dirname(src));
+      const destParent = path2.resolve(path2.dirname(dest));
+      if (destParent === srcParent || destParent === path2.parse(destParent).root)
+        return;
+      let destStat;
+      try {
+        destStat = fs2.statSync(destParent, { bigint: true });
+      } catch (err) {
+        if (err.code === "ENOENT")
+          return;
+        throw err;
+      }
+      if (areIdentical(srcStat, destStat)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return checkParentPathsSync(src, srcStat, destParent, funcName);
+    }
+    function areIdentical(srcStat, destStat) {
+      return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
+    }
+    function isSrcSubdir(src, dest) {
+      const srcArr = path2.resolve(src).split(path2.sep).filter((i) => i);
+      const destArr = path2.resolve(dest).split(path2.sep).filter((i) => i);
+      return srcArr.every((cur, i) => destArr[i] === cur);
+    }
+    function errMsg(src, dest, funcName) {
+      return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
+    }
+    module2.exports = {
+      // checkPaths
+      checkPaths: u(checkPaths),
+      checkPathsSync,
+      // checkParent
+      checkParentPaths: u(checkParentPaths),
+      checkParentPathsSync,
+      // Misc
+      isSrcSubdir,
+      areIdentical
+    };
+  }
+});
+var require_copy = __commonJS2({
+  "../../node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_fs2();
+    var path2 = __require2("path");
+    var { mkdirs } = require_mkdirs();
+    var { pathExists: pathExists2 } = require_path_exists();
+    var { utimesMillis } = require_utimes();
+    var stat = require_stat();
+    async function copy(src, dest, opts = {}) {
+      if (typeof opts === "function") {
+        opts = { filter: opts };
+      }
+      opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+      opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+      if (opts.preserveTimestamps && process.arch === "ia32") {
+        process.emitWarning(
+          "Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269",
+          "Warning",
+          "fs-extra-WARN0001"
+        );
+      }
+      const { srcStat, destStat } = await stat.checkPaths(src, dest, "copy", opts);
+      await stat.checkParentPaths(src, srcStat, dest, "copy");
+      const include = await runFilter(src, dest, opts);
+      if (!include)
+        return;
+      const destParent = path2.dirname(dest);
+      const dirExists = await pathExists2(destParent);
+      if (!dirExists) {
+        await mkdirs(destParent);
+      }
+      await getStatsAndPerformCopy(destStat, src, dest, opts);
+    }
+    async function runFilter(src, dest, opts) {
+      if (!opts.filter)
+        return true;
+      return opts.filter(src, dest);
+    }
+    async function getStatsAndPerformCopy(destStat, src, dest, opts) {
+      const statFn = opts.dereference ? fs2.stat : fs2.lstat;
+      const srcStat = await statFn(src);
+      if (srcStat.isDirectory())
+        return onDir(srcStat, destStat, src, dest, opts);
+      if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice())
+        return onFile(srcStat, destStat, src, dest, opts);
+      if (srcStat.isSymbolicLink())
+        return onLink(destStat, src, dest, opts);
+      if (srcStat.isSocket())
+        throw new Error(`Cannot copy a socket file: ${src}`);
+      if (srcStat.isFIFO())
+        throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+      throw new Error(`Unknown file: ${src}`);
+    }
+    async function onFile(srcStat, destStat, src, dest, opts) {
+      if (!destStat)
+        return copyFile(srcStat, src, dest, opts);
+      if (opts.overwrite) {
+        await fs2.unlink(dest);
+        return copyFile(srcStat, src, dest, opts);
+      }
+      if (opts.errorOnExist) {
+        throw new Error(`'${dest}' already exists`);
+      }
+    }
+    async function copyFile(srcStat, src, dest, opts) {
+      await fs2.copyFile(src, dest);
+      if (opts.preserveTimestamps) {
+        if (fileIsNotWritable(srcStat.mode)) {
+          await makeFileWritable(dest, srcStat.mode);
+        }
+        const updatedSrcStat = await fs2.stat(src);
+        await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+      }
+      return fs2.chmod(dest, srcStat.mode);
+    }
+    function fileIsNotWritable(srcMode) {
+      return (srcMode & 128) === 0;
+    }
+    function makeFileWritable(dest, srcMode) {
+      return fs2.chmod(dest, srcMode | 128);
+    }
+    async function onDir(srcStat, destStat, src, dest, opts) {
+      if (!destStat) {
+        await fs2.mkdir(dest);
+      }
+      const items = await fs2.readdir(src);
+      await Promise.all(items.map(async (item) => {
+        const srcItem = path2.join(src, item);
+        const destItem = path2.join(dest, item);
+        const include = await runFilter(srcItem, destItem, opts);
+        if (!include)
+          return;
+        const { destStat: destStat2 } = await stat.checkPaths(srcItem, destItem, "copy", opts);
+        return getStatsAndPerformCopy(destStat2, srcItem, destItem, opts);
+      }));
+      if (!destStat) {
+        await fs2.chmod(dest, srcStat.mode);
+      }
+    }
+    async function onLink(destStat, src, dest, opts) {
+      let resolvedSrc = await fs2.readlink(src);
+      if (opts.dereference) {
+        resolvedSrc = path2.resolve(process.cwd(), resolvedSrc);
+      }
+      if (!destStat) {
+        return fs2.symlink(resolvedSrc, dest);
+      }
+      let resolvedDest = null;
+      try {
+        resolvedDest = await fs2.readlink(dest);
+      } catch (e) {
+        if (e.code === "EINVAL" || e.code === "UNKNOWN")
+          return fs2.symlink(resolvedSrc, dest);
+        throw e;
+      }
+      if (opts.dereference) {
+        resolvedDest = path2.resolve(process.cwd(), resolvedDest);
+      }
+      if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+        throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+      }
+      if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+        throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+      }
+      await fs2.unlink(dest);
+      return fs2.symlink(resolvedSrc, dest);
+    }
+    module2.exports = copy;
+  }
+});
+var require_copy_sync = __commonJS2({
+  "../../node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_graceful_fs();
+    var path2 = __require2("path");
+    var mkdirsSync = require_mkdirs().mkdirsSync;
+    var utimesMillisSync = require_utimes().utimesMillisSync;
+    var stat = require_stat();
+    function copySync(src, dest, opts) {
+      if (typeof opts === "function") {
+        opts = { filter: opts };
+      }
+      opts = opts || {};
+      opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+      opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+      if (opts.preserveTimestamps && process.arch === "ia32") {
+        process.emitWarning(
+          "Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269",
+          "Warning",
+          "fs-extra-WARN0002"
+        );
+      }
+      const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy", opts);
+      stat.checkParentPathsSync(src, srcStat, dest, "copy");
+      if (opts.filter && !opts.filter(src, dest))
+        return;
+      const destParent = path2.dirname(dest);
+      if (!fs2.existsSync(destParent))
+        mkdirsSync(destParent);
+      return getStats(destStat, src, dest, opts);
+    }
+    function getStats(destStat, src, dest, opts) {
+      const statSync = opts.dereference ? fs2.statSync : fs2.lstatSync;
+      const srcStat = statSync(src);
+      if (srcStat.isDirectory())
+        return onDir(srcStat, destStat, src, dest, opts);
+      else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice())
+        return onFile(srcStat, destStat, src, dest, opts);
+      else if (srcStat.isSymbolicLink())
+        return onLink(destStat, src, dest, opts);
+      else if (srcStat.isSocket())
+        throw new Error(`Cannot copy a socket file: ${src}`);
+      else if (srcStat.isFIFO())
+        throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+      throw new Error(`Unknown file: ${src}`);
+    }
+    function onFile(srcStat, destStat, src, dest, opts) {
+      if (!destStat)
+        return copyFile(srcStat, src, dest, opts);
+      return mayCopyFile(srcStat, src, dest, opts);
+    }
+    function mayCopyFile(srcStat, src, dest, opts) {
+      if (opts.overwrite) {
+        fs2.unlinkSync(dest);
+        return copyFile(srcStat, src, dest, opts);
+      } else if (opts.errorOnExist) {
+        throw new Error(`'${dest}' already exists`);
+      }
+    }
+    function copyFile(srcStat, src, dest, opts) {
+      fs2.copyFileSync(src, dest);
+      if (opts.preserveTimestamps)
+        handleTimestamps(srcStat.mode, src, dest);
+      return setDestMode(dest, srcStat.mode);
+    }
+    function handleTimestamps(srcMode, src, dest) {
+      if (fileIsNotWritable(srcMode))
+        makeFileWritable(dest, srcMode);
+      return setDestTimestamps(src, dest);
+    }
+    function fileIsNotWritable(srcMode) {
+      return (srcMode & 128) === 0;
+    }
+    function makeFileWritable(dest, srcMode) {
+      return setDestMode(dest, srcMode | 128);
+    }
+    function setDestMode(dest, srcMode) {
+      return fs2.chmodSync(dest, srcMode);
+    }
+    function setDestTimestamps(src, dest) {
+      const updatedSrcStat = fs2.statSync(src);
+      return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+    }
+    function onDir(srcStat, destStat, src, dest, opts) {
+      if (!destStat)
+        return mkDirAndCopy(srcStat.mode, src, dest, opts);
+      return copyDir(src, dest, opts);
+    }
+    function mkDirAndCopy(srcMode, src, dest, opts) {
+      fs2.mkdirSync(dest);
+      copyDir(src, dest, opts);
+      return setDestMode(dest, srcMode);
+    }
+    function copyDir(src, dest, opts) {
+      fs2.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+    }
+    function copyDirItem(item, src, dest, opts) {
+      const srcItem = path2.join(src, item);
+      const destItem = path2.join(dest, item);
+      if (opts.filter && !opts.filter(srcItem, destItem))
+        return;
+      const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
+      return getStats(destStat, srcItem, destItem, opts);
+    }
+    function onLink(destStat, src, dest, opts) {
+      let resolvedSrc = fs2.readlinkSync(src);
+      if (opts.dereference) {
+        resolvedSrc = path2.resolve(process.cwd(), resolvedSrc);
+      }
+      if (!destStat) {
+        return fs2.symlinkSync(resolvedSrc, dest);
+      } else {
+        let resolvedDest;
+        try {
+          resolvedDest = fs2.readlinkSync(dest);
+        } catch (err) {
+          if (err.code === "EINVAL" || err.code === "UNKNOWN")
+            return fs2.symlinkSync(resolvedSrc, dest);
+          throw err;
+        }
+        if (opts.dereference) {
+          resolvedDest = path2.resolve(process.cwd(), resolvedDest);
+        }
+        if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+          throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+        }
+        if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+          throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+        }
+        return copyLink(resolvedSrc, dest);
+      }
+    }
+    function copyLink(resolvedSrc, dest) {
+      fs2.unlinkSync(dest);
+      return fs2.symlinkSync(resolvedSrc, dest);
+    }
+    module2.exports = copySync;
+  }
+});
+var require_copy2 = __commonJS2({
+  "../../node_modules/fs-extra/lib/copy/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    module2.exports = {
+      copy: u(require_copy()),
+      copySync: require_copy_sync()
+    };
+  }
+});
+var require_remove = __commonJS2({
+  "../../node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_graceful_fs();
+    var u = require_universalify().fromCallback;
+    function remove(path2, callback) {
+      fs2.rm(path2, { recursive: true, force: true }, callback);
+    }
+    function removeSync(path2) {
+      fs2.rmSync(path2, { recursive: true, force: true });
+    }
+    module2.exports = {
+      remove: u(remove),
+      removeSync
+    };
+  }
+});
+var require_empty = __commonJS2({
+  "../../node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var fs2 = require_fs2();
+    var path2 = __require2("path");
+    var mkdir6 = require_mkdirs();
+    var remove = require_remove();
+    var emptyDir = u(async function emptyDir2(dir) {
+      let items;
+      try {
+        items = await fs2.readdir(dir);
+      } catch {
+        return mkdir6.mkdirs(dir);
+      }
+      return Promise.all(items.map((item) => remove.remove(path2.join(dir, item))));
+    });
+    function emptyDirSync(dir) {
+      let items;
+      try {
+        items = fs2.readdirSync(dir);
+      } catch {
+        return mkdir6.mkdirsSync(dir);
+      }
+      items.forEach((item) => {
+        item = path2.join(dir, item);
+        remove.removeSync(item);
+      });
+    }
+    module2.exports = {
+      emptyDirSync,
+      emptydirSync: emptyDirSync,
+      emptyDir,
+      emptydir: emptyDir
+    };
+  }
+});
+var require_file2 = __commonJS2({
+  "../../node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var path2 = __require2("path");
+    var fs2 = require_fs2();
+    var mkdir6 = require_mkdirs();
+    async function createFile(file) {
+      let stats;
+      try {
+        stats = await fs2.stat(file);
+      } catch {
+      }
+      if (stats && stats.isFile())
+        return;
+      const dir = path2.dirname(file);
+      let dirStats = null;
+      try {
+        dirStats = await fs2.stat(dir);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          await mkdir6.mkdirs(dir);
+          await fs2.writeFile(file, "");
+          return;
+        } else {
+          throw err;
+        }
+      }
+      if (dirStats.isDirectory()) {
+        await fs2.writeFile(file, "");
+      } else {
+        await fs2.readdir(dir);
+      }
+    }
+    function createFileSync(file) {
+      let stats;
+      try {
+        stats = fs2.statSync(file);
+      } catch {
+      }
+      if (stats && stats.isFile())
+        return;
+      const dir = path2.dirname(file);
+      try {
+        if (!fs2.statSync(dir).isDirectory()) {
+          fs2.readdirSync(dir);
+        }
+      } catch (err) {
+        if (err && err.code === "ENOENT")
+          mkdir6.mkdirsSync(dir);
+        else
+          throw err;
+      }
+      fs2.writeFileSync(file, "");
+    }
+    module2.exports = {
+      createFile: u(createFile),
+      createFileSync
+    };
+  }
+});
+var require_link = __commonJS2({
+  "../../node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var path2 = __require2("path");
+    var fs2 = require_fs2();
+    var mkdir6 = require_mkdirs();
+    var { pathExists: pathExists2 } = require_path_exists();
+    var { areIdentical } = require_stat();
+    async function createLink(srcpath, dstpath) {
+      let dstStat;
+      try {
+        dstStat = await fs2.lstat(dstpath);
+      } catch {
+      }
+      let srcStat;
+      try {
+        srcStat = await fs2.lstat(srcpath);
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureLink");
+        throw err;
+      }
+      if (dstStat && areIdentical(srcStat, dstStat))
+        return;
+      const dir = path2.dirname(dstpath);
+      const dirExists = await pathExists2(dir);
+      if (!dirExists) {
+        await mkdir6.mkdirs(dir);
+      }
+      await fs2.link(srcpath, dstpath);
+    }
+    function createLinkSync(srcpath, dstpath) {
+      let dstStat;
+      try {
+        dstStat = fs2.lstatSync(dstpath);
+      } catch {
+      }
+      try {
+        const srcStat = fs2.lstatSync(srcpath);
+        if (dstStat && areIdentical(srcStat, dstStat))
+          return;
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureLink");
+        throw err;
+      }
+      const dir = path2.dirname(dstpath);
+      const dirExists = fs2.existsSync(dir);
+      if (dirExists)
+        return fs2.linkSync(srcpath, dstpath);
+      mkdir6.mkdirsSync(dir);
+      return fs2.linkSync(srcpath, dstpath);
+    }
+    module2.exports = {
+      createLink: u(createLink),
+      createLinkSync
+    };
+  }
+});
+var require_symlink_paths = __commonJS2({
+  "../../node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
+    "use strict";
+    var path2 = __require2("path");
+    var fs2 = require_fs2();
+    var { pathExists: pathExists2 } = require_path_exists();
+    var u = require_universalify().fromPromise;
+    async function symlinkPaths(srcpath, dstpath) {
+      if (path2.isAbsolute(srcpath)) {
+        try {
+          await fs2.lstat(srcpath);
+        } catch (err) {
+          err.message = err.message.replace("lstat", "ensureSymlink");
+          throw err;
+        }
+        return {
+          toCwd: srcpath,
+          toDst: srcpath
+        };
+      }
+      const dstdir = path2.dirname(dstpath);
+      const relativeToDst = path2.join(dstdir, srcpath);
+      const exists = await pathExists2(relativeToDst);
+      if (exists) {
+        return {
+          toCwd: relativeToDst,
+          toDst: srcpath
+        };
+      }
+      try {
+        await fs2.lstat(srcpath);
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureSymlink");
+        throw err;
+      }
+      return {
+        toCwd: srcpath,
+        toDst: path2.relative(dstdir, srcpath)
+      };
+    }
+    function symlinkPathsSync(srcpath, dstpath) {
+      if (path2.isAbsolute(srcpath)) {
+        const exists2 = fs2.existsSync(srcpath);
+        if (!exists2)
+          throw new Error("absolute srcpath does not exist");
+        return {
+          toCwd: srcpath,
+          toDst: srcpath
+        };
+      }
+      const dstdir = path2.dirname(dstpath);
+      const relativeToDst = path2.join(dstdir, srcpath);
+      const exists = fs2.existsSync(relativeToDst);
+      if (exists) {
+        return {
+          toCwd: relativeToDst,
+          toDst: srcpath
+        };
+      }
+      const srcExists = fs2.existsSync(srcpath);
+      if (!srcExists)
+        throw new Error("relative srcpath does not exist");
+      return {
+        toCwd: srcpath,
+        toDst: path2.relative(dstdir, srcpath)
+      };
+    }
+    module2.exports = {
+      symlinkPaths: u(symlinkPaths),
+      symlinkPathsSync
+    };
+  }
+});
+var require_symlink_type = __commonJS2({
+  "../../node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_fs2();
+    var u = require_universalify().fromPromise;
+    async function symlinkType(srcpath, type) {
+      if (type)
+        return type;
+      let stats;
+      try {
+        stats = await fs2.lstat(srcpath);
+      } catch {
+        return "file";
+      }
+      return stats && stats.isDirectory() ? "dir" : "file";
+    }
+    function symlinkTypeSync(srcpath, type) {
+      if (type)
+        return type;
+      let stats;
+      try {
+        stats = fs2.lstatSync(srcpath);
+      } catch {
+        return "file";
+      }
+      return stats && stats.isDirectory() ? "dir" : "file";
+    }
+    module2.exports = {
+      symlinkType: u(symlinkType),
+      symlinkTypeSync
+    };
+  }
+});
+var require_symlink = __commonJS2({
+  "../../node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var path2 = __require2("path");
+    var fs2 = require_fs2();
+    var { mkdirs, mkdirsSync } = require_mkdirs();
+    var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
+    var { symlinkType, symlinkTypeSync } = require_symlink_type();
+    var { pathExists: pathExists2 } = require_path_exists();
+    var { areIdentical } = require_stat();
+    async function createSymlink(srcpath, dstpath, type) {
+      let stats;
+      try {
+        stats = await fs2.lstat(dstpath);
+      } catch {
+      }
+      if (stats && stats.isSymbolicLink()) {
+        const [srcStat, dstStat] = await Promise.all([
+          fs2.stat(srcpath),
+          fs2.stat(dstpath)
+        ]);
+        if (areIdentical(srcStat, dstStat))
+          return;
+      }
+      const relative5 = await symlinkPaths(srcpath, dstpath);
+      srcpath = relative5.toDst;
+      const toType = await symlinkType(relative5.toCwd, type);
+      const dir = path2.dirname(dstpath);
+      if (!await pathExists2(dir)) {
+        await mkdirs(dir);
+      }
+      return fs2.symlink(srcpath, dstpath, toType);
+    }
+    function createSymlinkSync(srcpath, dstpath, type) {
+      let stats;
+      try {
+        stats = fs2.lstatSync(dstpath);
+      } catch {
+      }
+      if (stats && stats.isSymbolicLink()) {
+        const srcStat = fs2.statSync(srcpath);
+        const dstStat = fs2.statSync(dstpath);
+        if (areIdentical(srcStat, dstStat))
+          return;
+      }
+      const relative5 = symlinkPathsSync(srcpath, dstpath);
+      srcpath = relative5.toDst;
+      type = symlinkTypeSync(relative5.toCwd, type);
+      const dir = path2.dirname(dstpath);
+      const exists = fs2.existsSync(dir);
+      if (exists)
+        return fs2.symlinkSync(srcpath, dstpath, type);
+      mkdirsSync(dir);
+      return fs2.symlinkSync(srcpath, dstpath, type);
+    }
+    module2.exports = {
+      createSymlink: u(createSymlink),
+      createSymlinkSync
+    };
+  }
+});
+var require_ensure = __commonJS2({
+  "../../node_modules/fs-extra/lib/ensure/index.js"(exports2, module2) {
+    "use strict";
+    var { createFile, createFileSync } = require_file2();
+    var { createLink, createLinkSync } = require_link();
+    var { createSymlink, createSymlinkSync } = require_symlink();
+    module2.exports = {
+      // file
+      createFile,
+      createFileSync,
+      ensureFile: createFile,
+      ensureFileSync: createFileSync,
+      // link
+      createLink,
+      createLinkSync,
+      ensureLink: createLink,
+      ensureLinkSync: createLinkSync,
+      // symlink
+      createSymlink,
+      createSymlinkSync,
+      ensureSymlink: createSymlink,
+      ensureSymlinkSync: createSymlinkSync
+    };
+  }
+});
+var require_utils22 = __commonJS2({
+  "../../node_modules/jsonfile/utils.js"(exports2, module2) {
+    function stringify3(obj, { EOL: EOL2 = "\n", finalEOL = true, replacer = null, spaces } = {}) {
+      const EOF = finalEOL ? EOL2 : "";
+      const str = JSON.stringify(obj, replacer, spaces);
+      return str.replace(/\n/g, EOL2) + EOF;
+    }
+    function stripBom(content) {
+      if (Buffer.isBuffer(content))
+        content = content.toString("utf8");
+      return content.replace(/^\uFEFF/, "");
+    }
+    module2.exports = { stringify: stringify3, stripBom };
+  }
+});
+var require_jsonfile = __commonJS2({
+  "../../node_modules/jsonfile/index.js"(exports2, module2) {
+    var _fs;
+    try {
+      _fs = require_graceful_fs();
+    } catch (_) {
+      _fs = __require2("fs");
+    }
+    var universalify = require_universalify();
+    var { stringify: stringify3, stripBom } = require_utils22();
+    async function _readFile(file, options = {}) {
+      if (typeof options === "string") {
+        options = { encoding: options };
+      }
+      const fs2 = options.fs || _fs;
+      const shouldThrow = "throws" in options ? options.throws : true;
+      let data = await universalify.fromCallback(fs2.readFile)(file, options);
+      data = stripBom(data);
+      let obj;
+      try {
+        obj = JSON.parse(data, options ? options.reviver : null);
+      } catch (err) {
+        if (shouldThrow) {
+          err.message = `${file}: ${err.message}`;
+          throw err;
+        } else {
+          return null;
+        }
+      }
+      return obj;
+    }
+    var readFile4 = universalify.fromPromise(_readFile);
+    function readFileSync(file, options = {}) {
+      if (typeof options === "string") {
+        options = { encoding: options };
+      }
+      const fs2 = options.fs || _fs;
+      const shouldThrow = "throws" in options ? options.throws : true;
+      try {
+        let content = fs2.readFileSync(file, options);
+        content = stripBom(content);
+        return JSON.parse(content, options.reviver);
+      } catch (err) {
+        if (shouldThrow) {
+          err.message = `${file}: ${err.message}`;
+          throw err;
+        } else {
+          return null;
+        }
+      }
+    }
+    async function _writeFile(file, obj, options = {}) {
+      const fs2 = options.fs || _fs;
+      const str = stringify3(obj, options);
+      await universalify.fromCallback(fs2.writeFile)(file, str, options);
+    }
+    var writeFile4 = universalify.fromPromise(_writeFile);
+    function writeFileSync(file, obj, options = {}) {
+      const fs2 = options.fs || _fs;
+      const str = stringify3(obj, options);
+      return fs2.writeFileSync(file, str, options);
+    }
+    var jsonfile = {
+      readFile: readFile4,
+      readFileSync,
+      writeFile: writeFile4,
+      writeFileSync
+    };
+    module2.exports = jsonfile;
+  }
+});
+var require_jsonfile2 = __commonJS2({
+  "../../node_modules/fs-extra/lib/json/jsonfile.js"(exports2, module2) {
+    "use strict";
+    var jsonFile = require_jsonfile();
+    module2.exports = {
+      // jsonfile exports
+      readJson: jsonFile.readFile,
+      readJsonSync: jsonFile.readFileSync,
+      writeJson: jsonFile.writeFile,
+      writeJsonSync: jsonFile.writeFileSync
+    };
+  }
+});
+var require_output_file = __commonJS2({
+  "../../node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var fs2 = require_fs2();
+    var path2 = __require2("path");
+    var mkdir6 = require_mkdirs();
+    var pathExists2 = require_path_exists().pathExists;
+    async function outputFile(file, data, encoding = "utf-8") {
+      const dir = path2.dirname(file);
+      if (!await pathExists2(dir)) {
+        await mkdir6.mkdirs(dir);
+      }
+      return fs2.writeFile(file, data, encoding);
+    }
+    function outputFileSync(file, ...args2) {
+      const dir = path2.dirname(file);
+      if (!fs2.existsSync(dir)) {
+        mkdir6.mkdirsSync(dir);
+      }
+      fs2.writeFileSync(file, ...args2);
+    }
+    module2.exports = {
+      outputFile: u(outputFile),
+      outputFileSync
+    };
+  }
+});
+var require_output_json = __commonJS2({
+  "../../node_modules/fs-extra/lib/json/output-json.js"(exports2, module2) {
+    "use strict";
+    var { stringify: stringify3 } = require_utils22();
+    var { outputFile } = require_output_file();
+    async function outputJson(file, data, options = {}) {
+      const str = stringify3(data, options);
+      await outputFile(file, str, options);
+    }
+    module2.exports = outputJson;
+  }
+});
+var require_output_json_sync = __commonJS2({
+  "../../node_modules/fs-extra/lib/json/output-json-sync.js"(exports2, module2) {
+    "use strict";
+    var { stringify: stringify3 } = require_utils22();
+    var { outputFileSync } = require_output_file();
+    function outputJsonSync(file, data, options) {
+      const str = stringify3(data, options);
+      outputFileSync(file, str, options);
+    }
+    module2.exports = outputJsonSync;
+  }
+});
+var require_json = __commonJS2({
+  "../../node_modules/fs-extra/lib/json/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    var jsonFile = require_jsonfile2();
+    jsonFile.outputJson = u(require_output_json());
+    jsonFile.outputJsonSync = require_output_json_sync();
+    jsonFile.outputJSON = jsonFile.outputJson;
+    jsonFile.outputJSONSync = jsonFile.outputJsonSync;
+    jsonFile.writeJSON = jsonFile.writeJson;
+    jsonFile.writeJSONSync = jsonFile.writeJsonSync;
+    jsonFile.readJSON = jsonFile.readJson;
+    jsonFile.readJSONSync = jsonFile.readJsonSync;
+    module2.exports = jsonFile;
+  }
+});
+var require_move = __commonJS2({
+  "../../node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_fs2();
+    var path2 = __require2("path");
+    var { copy } = require_copy2();
+    var { remove } = require_remove();
+    var { mkdirp } = require_mkdirs();
+    var { pathExists: pathExists2 } = require_path_exists();
+    var stat = require_stat();
+    async function move(src, dest, opts = {}) {
+      const overwrite = opts.overwrite || opts.clobber || false;
+      const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, "move", opts);
+      await stat.checkParentPaths(src, srcStat, dest, "move");
+      const destParent = path2.dirname(dest);
+      const parsedParentPath = path2.parse(destParent);
+      if (parsedParentPath.root !== destParent) {
+        await mkdirp(destParent);
+      }
+      return doRename(src, dest, overwrite, isChangingCase);
+    }
+    async function doRename(src, dest, overwrite, isChangingCase) {
+      if (!isChangingCase) {
+        if (overwrite) {
+          await remove(dest);
+        } else if (await pathExists2(dest)) {
+          throw new Error("dest already exists.");
+        }
+      }
+      try {
+        await fs2.rename(src, dest);
+      } catch (err) {
+        if (err.code !== "EXDEV") {
+          throw err;
+        }
+        await moveAcrossDevice(src, dest, overwrite);
+      }
+    }
+    async function moveAcrossDevice(src, dest, overwrite) {
+      const opts = {
+        overwrite,
+        errorOnExist: true,
+        preserveTimestamps: true
+      };
+      await copy(src, dest, opts);
+      return remove(src);
+    }
+    module2.exports = move;
+  }
+});
+var require_move_sync = __commonJS2({
+  "../../node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require_graceful_fs();
+    var path2 = __require2("path");
+    var copySync = require_copy2().copySync;
+    var removeSync = require_remove().removeSync;
+    var mkdirpSync = require_mkdirs().mkdirpSync;
+    var stat = require_stat();
+    function moveSync(src, dest, opts) {
+      opts = opts || {};
+      const overwrite = opts.overwrite || opts.clobber || false;
+      const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts);
+      stat.checkParentPathsSync(src, srcStat, dest, "move");
+      if (!isParentRoot(dest))
+        mkdirpSync(path2.dirname(dest));
+      return doRename(src, dest, overwrite, isChangingCase);
+    }
+    function isParentRoot(dest) {
+      const parent = path2.dirname(dest);
+      const parsedPath = path2.parse(parent);
+      return parsedPath.root === parent;
+    }
+    function doRename(src, dest, overwrite, isChangingCase) {
+      if (isChangingCase)
+        return rename(src, dest, overwrite);
+      if (overwrite) {
+        removeSync(dest);
+        return rename(src, dest, overwrite);
+      }
+      if (fs2.existsSync(dest))
+        throw new Error("dest already exists.");
+      return rename(src, dest, overwrite);
+    }
+    function rename(src, dest, overwrite) {
+      try {
+        fs2.renameSync(src, dest);
+      } catch (err) {
+        if (err.code !== "EXDEV")
+          throw err;
+        return moveAcrossDevice(src, dest, overwrite);
+      }
+    }
+    function moveAcrossDevice(src, dest, overwrite) {
+      const opts = {
+        overwrite,
+        errorOnExist: true,
+        preserveTimestamps: true
+      };
+      copySync(src, dest, opts);
+      return removeSync(src);
+    }
+    module2.exports = moveSync;
+  }
+});
+var require_move2 = __commonJS2({
+  "../../node_modules/fs-extra/lib/move/index.js"(exports2, module2) {
+    "use strict";
+    var u = require_universalify().fromPromise;
+    module2.exports = {
+      move: u(require_move()),
+      moveSync: require_move_sync()
+    };
+  }
+});
+var require_lib30 = __commonJS2({
+  "../../node_modules/fs-extra/lib/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {
+      // Export promiseified graceful-fs:
+      ...require_fs2(),
+      // Export extra methods:
+      ...require_copy2(),
+      ...require_empty(),
+      ...require_ensure(),
+      ...require_json(),
+      ...require_mkdirs(),
+      ...require_move2(),
+      ...require_output_file(),
+      ...require_path_exists(),
+      ...require_remove()
+    };
+  }
+});
 async function writeJson(file, object, opts) {
   const str = JSON.stringify(object, null, opts?.spaces).concat(EOL);
   await writeFile(file, str, "utf-8");
@@ -44109,7 +46279,23 @@ async function readJson(file) {
 function pathExists(path2) {
   return access(path2).then(() => true).catch(() => false);
 }
+var import_fs_extra2 = __toESM2(require_lib30(), 1);
 var WIX_CODE_TYPES_DIR = "wix-code-types";
+var require2 = createRequire(import.meta.url);
+var customRegistry = env.VELO_NPM_REGISTRY;
+function getBundledWixCodeTypesPath() {
+  const packageJsonPath = require2.resolve("@wix/wix-code-types/package.json");
+  return dirname(packageJsonPath);
+}
+async function copyBundledPackage(targetPath) {
+  const bundledPath = getBundledWixCodeTypesPath();
+  await import_fs_extra2.default.ensureDir(bundledPath);
+  await import_fs_extra2.default.ensureDir(targetPath);
+  await import_fs_extra2.default.copy(bundledPath, targetPath, {
+    overwrite: true,
+    errorOnExist: false
+  });
+}
 async function installWixCodeTypesPackage(projectFolder) {
   const wixCodeTypesPackageJsonPath = join3(
     wixCodeTypesPackagePath(projectFolder),
@@ -44117,20 +46303,56 @@ async function installWixCodeTypesPackage(projectFolder) {
   );
   const packageExists = await pathExists(wixCodeTypesPackageJsonPath);
   let localVersionIsLatest = false;
-  if (packageExists) {
-    const wixCodeTypesPackageJson = await readJson(wixCodeTypesPackageJsonPath);
-    localVersionIsLatest = (await import_pacote.default.manifest("@wix/wix-code-types")).version === wixCodeTypesPackageJson.version;
-  }
-  if (!packageExists || !localVersionIsLatest) {
-    await pRetry(
-      async () => {
-        await import_pacote.default.extract(
-          "@wix/wix-code-types",
-          wixCodeTypesPackagePath(projectFolder)
+  let shouldUpdate = false;
+  let canAccessNpm = true;
+  try {
+    if (packageExists) {
+      const wixCodeTypesPackageJson = await readJson(
+        wixCodeTypesPackageJsonPath
+      );
+      const latestManifest = await import_pacote.default.manifest("@wix/wix-code-types", {
+        registry: customRegistry
+      });
+      localVersionIsLatest = latestManifest.version === wixCodeTypesPackageJson.version;
+      shouldUpdate = !localVersionIsLatest;
+    } else {
+      shouldUpdate = true;
+    }
+  } catch (error) {
+    if (packageExists) {
+      return;
+    }
+    canAccessNpm = false;
+    shouldUpdate = true;
+  }
+  if (shouldUpdate) {
+    if (canAccessNpm) {
+      try {
+        await pRetry(
+          async () => {
+            await import_pacote.default.extract(
+              "@wix/wix-code-types",
+              wixCodeTypesPackagePath(projectFolder),
+              { registry: customRegistry }
+            );
+          },
+          { retries: 2 }
         );
-      },
-      { retries: 2 }
-    );
+        return;
+      } catch (error) {
+        if (packageExists) {
+          return;
+        }
+      }
+    }
+    try {
+      await copyBundledPackage(wixCodeTypesPackagePath(projectFolder));
+    } catch (fallbackError) {
+      throw new Error(
+        `Failed to install @wix/wix-code-types from both npm registry and bundled dependency. Ensure @wix/wix-code-types is listed in package.json dependencies. ${fallbackError}`,
+        { cause: fallbackError }
+      );
+    }
   }
 }
 function wixCodeTypesPackagePath(projectFolder) {
@@ -44153,10 +46375,10 @@ function pageFileTsConfigPath(projectFolder) {
 }
 async function writePublicFilesTypes(projectFolder, definitions) {
   const jsconfigPath = definitions.types.getPublicConfigPath(projectFolder);
-  await mkdir(dirname(jsconfigPath), { recursive: true });
+  await mkdir(dirname2(jsconfigPath), { recursive: true });
   await writeJson(jsconfigPath, {
     extends: relative2(
-      dirname(jsconfigPath),
+      dirname2(jsconfigPath),
       publicFilesTsConfigPath(projectFolder)
     ),
     compilerOptions: {
@@ -44166,7 +46388,7 @@ async function writePublicFilesTypes(projectFolder, definitions) {
         "backend/*.web.js": [
           join22(
             relative2(
-              dirname(jsconfigPath),
+              dirname2(jsconfigPath),
               definitions.layout.getBackendFolder(projectFolder)
             ),
             "*.web.js"
@@ -44175,7 +46397,7 @@ async function writePublicFilesTypes(projectFolder, definitions) {
         "backend/*.web": [
           join22(
             relative2(
-              dirname(jsconfigPath),
+              dirname2(jsconfigPath),
               definitions.layout.getBackendFolder(projectFolder)
             ),
             "*.web.js"
@@ -44183,25 +46405,26 @@ async function writePublicFilesTypes(projectFolder, definitions) {
         ]
       },
       outDir: "build",
-      rootDir: relative2(dirname(jsconfigPath), projectFolder)
+      rootDir: relative2(dirname2(jsconfigPath), projectFolder)
     },
+    references: [
+      {
+        path: relative2(
+          dirname2(jsconfigPath),
+          definitions.types.getBackendConfigPath(projectFolder)
+        )
+      }
+    ],
     include: [
       join22(
         relative2(
-          dirname(jsconfigPath),
+          dirname2(jsconfigPath),
           definitions.layout.getPublicFolder(projectFolder)
         ),
         "**/*"
       ),
-      join22(
-        relative2(
-          dirname(jsconfigPath),
-          definitions.layout.getBackendFolder(projectFolder)
-        ),
-        "**/*.web.js"
-      ),
       relative2(
-        dirname(jsconfigPath),
+        dirname2(jsconfigPath),
         definitions.types.getBackendDTSPath(projectFolder)
       )
     ]
@@ -44209,22 +46432,22 @@ async function writePublicFilesTypes(projectFolder, definitions) {
 }
 async function writeBackendFilesTypes(projectFolder, definitions) {
   const jsconfigPath = definitions.types.getBackendConfigPath(projectFolder);
-  await mkdir2(dirname2(jsconfigPath), { recursive: true });
+  await mkdir2(dirname3(jsconfigPath), { recursive: true });
   await writeJson(jsconfigPath, {
     extends: relative22(
-      dirname2(jsconfigPath),
+      dirname3(jsconfigPath),
       backendFilesTsConfigPath(projectFolder)
     ),
     compilerOptions: {
       composite: true,
       noEmit: false,
       outDir: "build",
-      rootDir: relative22(dirname2(jsconfigPath), projectFolder),
+      rootDir: relative22(dirname3(jsconfigPath), projectFolder),
       paths: {
         "public/*": [
           join32(
             relative22(
-              dirname2(jsconfigPath),
+              dirname3(jsconfigPath),
               definitions.layout.getPublicFolder(projectFolder)
             ),
             "*"
@@ -44233,7 +46456,7 @@ async function writeBackendFilesTypes(projectFolder, definitions) {
         "backend/*": [
           join32(
             relative22(
-              dirname2(jsconfigPath),
+              dirname3(jsconfigPath),
               definitions.layout.getBackendFolder(projectFolder)
             ),
             "*"
@@ -44241,20 +46464,21 @@ async function writeBackendFilesTypes(projectFolder, definitions) {
         ]
       }
     },
+    references: [
+      {
+        path: relative22(
+          dirname3(jsconfigPath),
+          definitions.types.getPublicConfigPath(projectFolder)
+        )
+      }
+    ],
     include: [
       join32(
         relative22(
-          dirname2(jsconfigPath),
+          dirname3(jsconfigPath),
           definitions.layout.getBackendFolder(projectFolder)
         ),
         "**/*"
-      ),
-      join32(
-        relative22(
-          dirname2(jsconfigPath),
-          definitions.layout.getPublicFolder(projectFolder)
-        ),
-        "**/*"
       )
     ]
   });
@@ -44389,7 +46613,7 @@ async function syncTypesForPages(projectFolder, pagesData, definitions, hasMaste
   );
   await Promise.all(
     Object.entries(pagesData).map(async ([pageId, page]) => {
-      const pageConfigDir = dirname3(
+      const pageConfigDir = dirname4(
         definitions.types.getPageConfigFilename(
           projectFolder,
           page.pageMetaData.pageId
@@ -44413,7 +46637,7 @@ async function syncTypesForPages(projectFolder, pagesData, definitions, hasMaste
         projectFolder,
         pageId
       );
-      await mkdir3(dirname3(jsConfigPath), { recursive: true });
+      await mkdir3(dirname4(jsConfigPath), { recursive: true });
       await writeJson(
         jsConfigPath,
         getConfigForPage(projectFolder, page, definitions),
@@ -44431,7 +46655,7 @@ function getConfigForPage(projectFolder, page, definitions) {
   );
   return {
     extends: relative4(
-      dirname3(configFilePath),
+      dirname4(configFilePath),
       pageFileTsConfigPath(projectFolder)
     ),
     compilerOptions: {
@@ -44444,7 +46668,7 @@ function getConfigForPage(projectFolder, page, definitions) {
         "public/*": [
           join6(
             relative4(
-              dirname3(configFilePath),
+              dirname4(configFilePath),
               definitions.layout.getPublicFolder(projectFolder)
             ),
             "*"
@@ -44453,7 +46677,7 @@ function getConfigForPage(projectFolder, page, definitions) {
         "backend/*.web.js": [
           join6(
             relative4(
-              dirname3(configFilePath),
+              dirname4(configFilePath),
               definitions.layout.getBackendFolder(projectFolder)
             ),
             "*.web.js"
@@ -44462,7 +46686,7 @@ function getConfigForPage(projectFolder, page, definitions) {
         "backend/*.web": [
           join6(
             relative4(
-              dirname3(configFilePath),
+              dirname4(configFilePath),
               definitions.layout.getBackendFolder(projectFolder)
             ),
             "*.web.js"
@@ -44470,34 +46694,34 @@ function getConfigForPage(projectFolder, page, definitions) {
         ]
       },
       outDir: "build",
-      rootDir: relative4(dirname3(configFilePath), projectFolder)
+      rootDir: relative4(dirname4(configFilePath), projectFolder)
     },
     files: [
       relative4(
-        dirname3(configFilePath),
+        dirname4(configFilePath),
         definitions.layout.getPageCodeFilePath(projectFolder, page, true)
       )
     ],
+    references: [
+      {
+        path: relative4(
+          dirname4(configFilePath),
+          definitions.types.getBackendConfigPath(projectFolder)
+        )
+      },
+      {
+        path: relative4(
+          dirname4(configFilePath),
+          definitions.types.getPublicConfigPath(projectFolder)
+        )
+      }
+    ],
     include: [
       ...Object.entries(
         getPageDeclarationFiles(projectFolder, page, definitions)
       ).map(([filename]) => filename),
-      join6(
-        relative4(
-          dirname3(configFilePath),
-          definitions.layout.getPublicFolder(projectFolder)
-        ),
-        "**/*"
-      ),
-      join6(
-        relative4(
-          dirname3(configFilePath),
-          definitions.layout.getBackendFolder(projectFolder)
-        ),
-        "**/*.web.js"
-      ),
       relative4(
-        dirname3(configFilePath),
+        dirname4(configFilePath),
         definitions.types.getBackendDTSPath(projectFolder)
       )
     ]
@@ -44523,10 +46747,10 @@ function getPageDeclarationFiles(projectFolder, page, definitions, hasMasterPage
   }
   let returnedDeclarationFiles;
   if (hasMasterPage) {
-    const masterPageDTSDir = dirname3(
+    const masterPageDTSDir = dirname4(
       definitions.types.getPageConfigFilename(projectFolder, MASTER_PAGE_NAME)
     );
-    const pageDTSDir = dirname3(
+    const pageDTSDir = dirname4(
       definitions.types.getPageConfigFilename(
         projectFolder,
         page.pageMetaData.pageId
@@ -45197,4 +47421,4 @@ make-fetch-happen/lib/fetch.js:
    * governing permissions and limitations under the License.
    *)
 */
-//# sourceMappingURL=chunk-EULO7YSZ.js.map
+//# sourceMappingURL=chunk-ZNOHJURI.js.map