@qwik.dev/core 2.0.0-beta.30 → 2.0.0-beta.31

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core/cli 2.0.0-beta.30-dev+5421ed4
+ * @qwik.dev/core/cli 2.0.0-beta.31-dev+906321a
  * Copyright QwikDev. All Rights Reserved.
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://github.com/QwikDev/qwik/blob/main/LICENSE
@@ -3397,9 +3397,9 @@ var require_json5_parser = __commonJS({
 
 // packages/qwik/src/cli/migrate-v2/tools/visit-not-ignored-files.ts
 import { existsSync as existsSync2, lstatSync, readFileSync as readFileSync4, readdirSync } from "fs";
-import ignore from "ignore";
 import { join as join8, relative as relative2 } from "path";
-function visitNotIgnoredFiles(dirPath, visitor) {
+async function visitNotIgnoredFiles(dirPath, visitor) {
+  const { default: ignore } = await import("ignore");
   let ig;
   if (existsSync2(".gitignore")) {
     ig = ignore();
@@ -3410,7 +3410,9 @@ function visitNotIgnoredFiles(dirPath, visitor) {
   if (dirPath !== "" && ig?.ignores(dirPath)) {
     return;
   }
-  for (const child of readdirSync(join8(process.cwd(), dirPath))) {
+  const dirResults = readdirSync(join8(process.cwd(), dirPath));
+  for (let i2 = 0; i2 < dirResults.length; i2++) {
+    const child = dirResults[i2];
     const fullPath = join8(dirPath, child);
     if (ig?.ignores(fullPath)) {
       continue;
@@ -3418,7 +3420,7 @@ function visitNotIgnoredFiles(dirPath, visitor) {
     if (lstatSync(fullPath).isFile()) {
       visitor(fullPath);
     } else {
-      visitNotIgnoredFiles(fullPath, visitor);
+      await visitNotIgnoredFiles(fullPath, visitor);
     }
   }
 }
@@ -3433,42 +3435,52 @@ var rename_import_exports = {};
 __export(rename_import_exports, {
   replaceImportInFiles: () => replaceImportInFiles
 });
-import { Project, ts } from "ts-morph";
-function replaceImportInFiles(changes, library) {
+async function replaceImportInFiles(changes, library) {
+  const { Project, ts } = await import("ts-morph");
   const project = new Project();
-  visitNotIgnoredFiles(".", (path7) => {
+  await visitNotIgnoredFiles(".", (path7) => {
     if (!path7.endsWith(".ts") && !path7.endsWith(".tsx")) {
       return;
     }
     project.addSourceFileAtPath(path7);
   });
-  project.getSourceFiles().forEach((sourceFile) => {
+  const sourceFiles = project.getSourceFiles();
+  for (let i2 = 0; i2 < sourceFiles.length; i2++) {
+    const sourceFile = sourceFiles[i2];
     let hasChanges = false;
-    sourceFile.getImportDeclarations().forEach((importDeclaration) => {
+    const importDeclarations = sourceFile.getImportDeclarations();
+    for (let j2 = 0; j2 < importDeclarations.length; j2++) {
+      const importDeclaration = importDeclarations[j2];
       if (importDeclaration.getModuleSpecifierValue().startsWith(library)) {
-        for (const [oldImport, newImport] of changes) {
-          importDeclaration.getNamedImports().forEach((namedImport) => {
+        for (let k3 = 0; k3 < changes.length; k3++) {
+          const [oldImport, newImport] = changes[k3];
+          const namedImports = importDeclaration.getNamedImports();
+          for (let l2 = 0; l2 < namedImports.length; l2++) {
+            const namedImport = namedImports[l2];
             if (namedImport.getName() === oldImport) {
               namedImport.setName(newImport);
               hasChanges = true;
             }
-          });
+          }
         }
       }
-    });
-    sourceFile.getDescendantsOfKind(ts.SyntaxKind.Identifier).forEach((identifier) => {
-      for (const [oldImport, newImport] of changes) {
+    }
+    const descendants = sourceFile.getDescendantsOfKind(ts.SyntaxKind.Identifier);
+    for (let m2 = 0; m2 < descendants.length; m2++) {
+      const identifier = descendants[m2];
+      for (let n2 = 0; n2 < changes.length; n2++) {
+        const [oldImport, newImport] = changes[n2];
         if (identifier.getText() === oldImport) {
           identifier.replaceWithText(newImport);
           hasChanges = true;
         }
       }
-    });
+    }
     if (hasChanges) {
       sourceFile.saveSync();
       M2.info(`Updated imports in ${sourceFile.getFilePath()}`);
     }
-  });
+  }
 }
 var init_rename_import = __esm({
   "packages/qwik/src/cli/migrate-v2/rename-import.ts"() {
@@ -10471,7 +10483,8 @@ async function getFilesDeep(root) {
       return;
     }
     const filesInDirectory = await fs.promises.readdir(directory);
-    for (const file of filesInDirectory) {
+    for (let i2 = 0; i2 < filesInDirectory.length; i2++) {
+      const file = filesInDirectory[i2];
       const absolute = join2(directory, file);
       if (fs.statSync(absolute).isDirectory()) {
         await getFiles(absolute);
@@ -10616,9 +10629,10 @@ function runInPkg(pkgManager, args, cwd) {
 function logNextStep(nextSteps, packageManager) {
   const outString = [];
   if (nextSteps) {
-    nextSteps.lines.forEach(
-      (step) => outString.push(`${step.replace(/\bpnpm\b/g, packageManager)}`)
-    );
+    for (let i2 = 0; i2 < nextSteps.lines.length; i2++) {
+      const step = nextSteps.lines[i2];
+      outString.push(`${step.replace(/\bpnpm\b/g, packageManager)}`);
+    }
   }
   return outString.join("\n");
 }
@@ -10686,9 +10700,10 @@ async function mergePackageJsons(fileUpdates, srcPath, destPath) {
     const srcPkgJson = JSON.parse(srcContent);
     const props = ["scripts", "dependencies", "devDependencies"];
     const destPkgJson = JSON.parse(await fs3.promises.readFile(destPath, "utf-8"));
-    props.forEach((prop) => {
+    for (let i2 = 0; i2 < props.length; i2++) {
+      const prop = props[i2];
       mergePackageJsonSort(srcPkgJson, destPkgJson, prop);
-    });
+    }
     if (destPkgJson.scripts?.qwik) {
       const qwikVal = destPkgJson.scripts.qwik;
       delete destPkgJson.scripts.qwik;
@@ -10738,7 +10753,8 @@ function mergePackageJsonSort(src, dest, prop) {
     }
     const sorted = {};
     const keys = Object.keys(dest[prop]).sort();
-    for (const key of keys) {
+    for (let i2 = 0; i2 < keys.length; i2++) {
+      const key = keys[i2];
       sorted[key] = dest[prop][key];
     }
     dest[prop] = sorted;
@@ -10772,7 +10788,8 @@ async function mergeIgnoresFile(fileUpdates, srcPath, destPath) {
     const destContent = await fs3.promises.readFile(destPath, "utf-8");
     const srcLines = srcContent.trim().split(/\r?\n/);
     const destLines = destContent.trim().split(/\r?\n/);
-    for (const srcLine of srcLines) {
+    for (let i2 = 0; i2 < srcLines.length; i2++) {
+      const srcLine = srcLines[i2];
       if (!destLines.includes(srcLine)) {
         if (srcLine.startsWith("#")) {
           destLines.push("");
@@ -10818,25 +10835,27 @@ import fs4 from "fs";
 import { join as join5 } from "path";
 
 // packages/qwik/src/cli/code-mod/code-mod.ts
-function updateViteConfig(ts2, sourceText, updates) {
+function updateViteConfig(ts, sourceText, updates) {
   if (!updates?.imports && !updates?.qwikViteConfig && !updates?.viteConfig && !updates?.vitePlugins && !updates?.vitePluginsPrepend) {
     return null;
   }
-  sourceText = transformSource(ts2, sourceText, () => (tsSourceFile) => {
+  sourceText = transformSource(ts, sourceText, () => (tsSourceFile) => {
     if (updates.imports) {
-      for (const importData of updates.imports) {
-        tsSourceFile = ensureImport(ts2, tsSourceFile, importData);
+      for (let i2 = 0; i2 < updates.imports.length; i2++) {
+        const importData = updates.imports[i2];
+        tsSourceFile = ensureImport(ts, tsSourceFile, importData);
       }
     }
     const statements = [];
-    for (const s2 of tsSourceFile.statements) {
-      if (ts2.isExportAssignment(s2) && s2.expression && ts2.isCallExpression(s2.expression)) {
-        if (ts2.isIdentifier(s2.expression.expression) && s2.expression.expression.text === "defineConfig" && (updates.viteConfig || updates.qwikViteConfig || updates.vitePlugins || updates.vitePluginsPrepend)) {
+    for (let i2 = 0; i2 < tsSourceFile.statements.length; i2++) {
+      const s2 = tsSourceFile.statements[i2];
+      if (ts.isExportAssignment(s2) && s2.expression && ts.isCallExpression(s2.expression)) {
+        if (ts.isIdentifier(s2.expression.expression) && s2.expression.expression.text === "defineConfig" && (updates.viteConfig || updates.qwikViteConfig || updates.vitePlugins || updates.vitePluginsPrepend)) {
           statements.push(
-            ts2.factory.updateExportAssignment(
+            ts.factory.updateExportAssignment(
               s2,
               s2.modifiers,
-              updateDefineConfig(ts2, s2.expression, updates)
+              updateDefineConfig(ts, s2.expression, updates)
             )
           );
           continue;
@@ -10844,20 +10863,21 @@ function updateViteConfig(ts2, sourceText, updates) {
       }
       statements.push(s2);
     }
-    return ts2.factory.updateSourceFile(tsSourceFile, statements);
+    return ts.factory.updateSourceFile(tsSourceFile, statements);
   });
   return sourceText;
 }
-function ensureImport(ts2, tsSourceFile, importData) {
+function ensureImport(ts, tsSourceFile, importData) {
   if (importData && importData.importPath) {
     if (Array.isArray(importData.namedImports)) {
-      importData.namedImports.forEach((namedImport) => {
-        tsSourceFile = ensureNamedImport(ts2, tsSourceFile, namedImport, importData.importPath);
-      });
+      for (let i2 = 0; i2 < importData.namedImports.length; i2++) {
+        const namedImport = importData.namedImports[i2];
+        tsSourceFile = ensureNamedImport(ts, tsSourceFile, namedImport, importData.importPath);
+      }
     }
     if (typeof importData.defaultImport === "string") {
       tsSourceFile = ensureDefaultImport(
-        ts2,
+        ts,
         tsSourceFile,
         importData.defaultImport,
         importData.importPath
@@ -10866,36 +10886,36 @@ function ensureImport(ts2, tsSourceFile, importData) {
   }
   return tsSourceFile;
 }
-function ensureNamedImport(ts2, tsSourceFile, namedImport, importPath) {
-  if (!hasNamedImport(ts2, tsSourceFile, namedImport, importPath)) {
-    tsSourceFile = appendImports(ts2, tsSourceFile, null, namedImport, importPath);
+function ensureNamedImport(ts, tsSourceFile, namedImport, importPath) {
+  if (!hasNamedImport(ts, tsSourceFile, namedImport, importPath)) {
+    tsSourceFile = appendImports(ts, tsSourceFile, null, namedImport, importPath);
   }
   return tsSourceFile;
 }
-function ensureDefaultImport(ts2, tsSourceFile, defaultImport, importPath) {
-  if (!hasDefaultImport(ts2, tsSourceFile, importPath)) {
-    tsSourceFile = appendImports(ts2, tsSourceFile, defaultImport, null, importPath);
+function ensureDefaultImport(ts, tsSourceFile, defaultImport, importPath) {
+  if (!hasDefaultImport(ts, tsSourceFile, importPath)) {
+    tsSourceFile = appendImports(ts, tsSourceFile, defaultImport, null, importPath);
   }
   return tsSourceFile;
 }
-function hasNamedImport(ts2, tsSourceFile, namedImport, importPath) {
-  return !!findNamedImport(ts2, tsSourceFile, namedImport, importPath);
+function hasNamedImport(ts, tsSourceFile, namedImport, importPath) {
+  return !!findNamedImport(ts, tsSourceFile, namedImport, importPath);
 }
-function hasDefaultImport(ts2, tsSourceFile, importPath) {
-  return !!findDefaultImport(ts2, tsSourceFile, importPath);
+function hasDefaultImport(ts, tsSourceFile, importPath) {
+  return !!findDefaultImport(ts, tsSourceFile, importPath);
 }
-function findNamedImport(ts2, tsSourceFile, namedImport, importPath) {
-  return findImportDeclarations(ts2, tsSourceFile).find((n2) => {
-    if (n2.importClause && n2.moduleSpecifier && ts2.isStringLiteral(n2.moduleSpecifier)) {
+function findNamedImport(ts, tsSourceFile, namedImport, importPath) {
+  return findImportDeclarations(ts, tsSourceFile).find((n2) => {
+    if (n2.importClause && n2.moduleSpecifier && ts.isStringLiteral(n2.moduleSpecifier)) {
       if (n2.moduleSpecifier.text !== importPath) {
         return false;
       }
       const namedImports = n2.importClause.namedBindings;
-      if (namedImports && ts2.isNamedImports(namedImports) && namedImports.elements) {
+      if (namedImports && ts.isNamedImports(namedImports) && namedImports.elements) {
         return namedImports.elements.some((namedImportElement) => {
-          if (ts2.isImportSpecifier(namedImportElement)) {
+          if (ts.isImportSpecifier(namedImportElement)) {
             const importName = namedImportElement.name;
-            if (importName && ts2.isIdentifier(importName)) {
+            if (importName && ts.isIdentifier(importName)) {
               return importName.text === namedImport;
             }
           }
@@ -10906,11 +10926,11 @@ function findNamedImport(ts2, tsSourceFile, namedImport, importPath) {
     return false;
   });
 }
-function findDefaultImport(ts2, tsSourceFile, importPath) {
-  return findImportDeclarations(ts2, tsSourceFile).find((n2) => {
+function findDefaultImport(ts, tsSourceFile, importPath) {
+  return findImportDeclarations(ts, tsSourceFile).find((n2) => {
     if (n2.importClause && n2.moduleSpecifier) {
       const modulePath = n2.moduleSpecifier;
-      if (ts2.isStringLiteral(modulePath) && modulePath.text === importPath) {
+      if (ts.isStringLiteral(modulePath) && modulePath.text === importPath) {
         const moduleDefault = n2.importClause.name;
         if (moduleDefault && moduleDefault.text === importPath) {
           return true;
@@ -10920,18 +10940,18 @@ function findDefaultImport(ts2, tsSourceFile, importPath) {
     return false;
   });
 }
-function findImportDeclarations(ts2, tsSourceFile) {
-  return tsSourceFile.statements.filter(ts2.isImportDeclaration);
+function findImportDeclarations(ts, tsSourceFile) {
+  return tsSourceFile.statements.filter(ts.isImportDeclaration);
 }
-function appendImports(ts2, tsSourceFile, defaultImport, namedImport, importPath) {
+function appendImports(ts, tsSourceFile, defaultImport, namedImport, importPath) {
   const statements = tsSourceFile.statements.slice();
   let foundExistingImport = false;
   for (let i2 = statements.length - 1; i2 >= 0; i2--) {
     const n2 = statements[i2];
-    if (!ts2.isImportDeclaration(n2)) {
+    if (!ts.isImportDeclaration(n2)) {
       continue;
     }
-    if (!n2.moduleSpecifier || !ts2.isStringLiteral(n2.moduleSpecifier)) {
+    if (!n2.moduleSpecifier || !ts.isStringLiteral(n2.moduleSpecifier)) {
       continue;
     }
     if (n2.moduleSpecifier.text !== importPath) {
@@ -10941,13 +10961,13 @@ function appendImports(ts2, tsSourceFile, defaultImport, namedImport, importPath
     const existingNamedImports = [];
     if (n2.importClause) {
       const namedImports = n2.importClause.namedBindings;
-      if (namedImports && ts2.isNamedImports(namedImports) && namedImports.elements) {
+      if (namedImports && ts.isNamedImports(namedImports) && namedImports.elements) {
         existingNamedImports.push(...namedImports.elements);
       }
     }
     if (typeof namedImport === "string") {
-      const identifier = ts2.factory.createIdentifier(namedImport);
-      const importSpecifier = ts2.factory.createImportSpecifier(false, void 0, identifier);
+      const identifier = ts.factory.createIdentifier(namedImport);
+      const importSpecifier = ts.factory.createImportSpecifier(false, void 0, identifier);
       existingNamedImports.push(importSpecifier);
     }
     existingNamedImports.sort((a2, b3) => {
@@ -10957,16 +10977,16 @@ function appendImports(ts2, tsSourceFile, defaultImport, namedImport, importPath
     });
     let defaultIdentifier = n2.importClause ? n2.importClause.name : void 0;
     if (typeof defaultImport === "string") {
-      defaultIdentifier = ts2.factory.createIdentifier(defaultImport);
+      defaultIdentifier = ts.factory.createIdentifier(defaultImport);
     }
     let namedBindings = void 0;
     if (existingNamedImports.length > 0) {
-      namedBindings = ts2.factory.createNamedImports(existingNamedImports);
+      namedBindings = ts.factory.createNamedImports(existingNamedImports);
     }
-    statements[i2] = ts2.factory.updateImportDeclaration(
+    statements[i2] = ts.factory.updateImportDeclaration(
       n2,
       void 0,
-      ts2.factory.createImportClause(false, defaultIdentifier, namedBindings),
+      ts.factory.createImportClause(false, defaultIdentifier, namedBindings),
       n2.moduleSpecifier,
       void 0
     );
@@ -10975,61 +10995,61 @@ function appendImports(ts2, tsSourceFile, defaultImport, namedImport, importPath
     let defaultIdentifier = void 0;
     let namedBindings = void 0;
     if (typeof defaultImport === "string") {
-      defaultIdentifier = ts2.factory.createIdentifier(defaultImport);
+      defaultIdentifier = ts.factory.createIdentifier(defaultImport);
     }
     if (typeof namedImport === "string") {
-      namedBindings = ts2.factory.createNamedImports([
-        ts2.factory.createImportSpecifier(
+      namedBindings = ts.factory.createNamedImports([
+        ts.factory.createImportSpecifier(
           false,
           void 0,
-          ts2.factory.createIdentifier(namedImport)
+          ts.factory.createIdentifier(namedImport)
         )
       ]);
     }
-    const newNamedImport = ts2.factory.createImportDeclaration(
+    const newNamedImport = ts.factory.createImportDeclaration(
       void 0,
-      ts2.factory.createImportClause(false, defaultIdentifier, namedBindings),
-      ts2.factory.createStringLiteral(importPath)
+      ts.factory.createImportClause(false, defaultIdentifier, namedBindings),
+      ts.factory.createStringLiteral(importPath)
     );
-    const lastImportIndex = findLastImportIndex(ts2, tsSourceFile);
+    const lastImportIndex = findLastImportIndex(ts, tsSourceFile);
     statements.splice(lastImportIndex + 1, 0, newNamedImport);
   }
-  return ts2.factory.updateSourceFile(tsSourceFile, statements);
+  return ts.factory.updateSourceFile(tsSourceFile, statements);
 }
-function findLastImportIndex(ts2, tsSourceFile) {
+function findLastImportIndex(ts, tsSourceFile) {
   for (let i2 = tsSourceFile.statements.length - 1; i2 >= 0; i2--) {
     const s2 = tsSourceFile.statements[i2];
-    if (ts2.isImportDeclaration(s2)) {
+    if (ts.isImportDeclaration(s2)) {
       return i2;
     }
-    if (ts2.isStringLiteral(s2) && s2.text === "use strict") {
+    if (ts.isStringLiteral(s2) && s2.text === "use strict") {
       return i2;
     }
   }
   return 0;
 }
-function updateDefineConfig(ts2, callExp, updates) {
+function updateDefineConfig(ts, callExp, updates) {
   const args = [];
   for (let i2 = 0; i2 < callExp.arguments.length; i2++) {
     const exp = callExp.arguments[i2];
     if (i2 === 0) {
-      if (ts2.isArrowFunction(exp) && ts2.isBlock(exp.body)) {
+      if (ts.isArrowFunction(exp) && ts.isBlock(exp.body)) {
         args.push(
-          ts2.factory.updateArrowFunction(
+          ts.factory.updateArrowFunction(
             exp,
             exp.modifiers,
             exp.typeParameters,
             exp.parameters,
             exp.type,
             exp.equalsGreaterThanToken,
-            updateDefineConfigFnReturn(ts2, exp.body, updates)
+            updateDefineConfigFnReturn(ts, exp.body, updates)
           )
         );
         continue;
       }
-      if (ts2.isFunctionExpression(exp) && ts2.isBlock(exp.body)) {
+      if (ts.isFunctionExpression(exp) && ts.isBlock(exp.body)) {
         args.push(
-          ts2.factory.updateFunctionExpression(
+          ts.factory.updateFunctionExpression(
             exp,
             exp.modifiers,
             exp.asteriskToken,
@@ -11037,53 +11057,55 @@ function updateDefineConfig(ts2, callExp, updates) {
             exp.typeParameters,
             exp.parameters,
             exp.type,
-            updateDefineConfigFnReturn(ts2, exp.body, updates)
+            updateDefineConfigFnReturn(ts, exp.body, updates)
           )
         );
         continue;
       }
-      if (ts2.isObjectLiteralExpression(exp)) {
-        args.push(updateVitConfigObj(ts2, exp, updates));
+      if (ts.isObjectLiteralExpression(exp)) {
+        args.push(updateVitConfigObj(ts, exp, updates));
         continue;
       }
     }
     args.push(exp);
   }
-  return ts2.factory.updateCallExpression(callExp, callExp.expression, callExp.typeArguments, args);
+  return ts.factory.updateCallExpression(callExp, callExp.expression, callExp.typeArguments, args);
 }
-function updateDefineConfigFnReturn(ts2, fnBody, updates) {
+function updateDefineConfigFnReturn(ts, fnBody, updates) {
   const statements = [];
-  for (const s2 of fnBody.statements) {
-    if (ts2.isReturnStatement(s2) && s2.expression && ts2.isObjectLiteralExpression(s2.expression)) {
+  for (let i2 = 0; i2 < fnBody.statements.length; i2++) {
+    const s2 = fnBody.statements[i2];
+    if (ts.isReturnStatement(s2) && s2.expression && ts.isObjectLiteralExpression(s2.expression)) {
       statements.push(
-        ts2.factory.updateReturnStatement(s2, updateVitConfigObj(ts2, s2.expression, updates))
+        ts.factory.updateReturnStatement(s2, updateVitConfigObj(ts, s2.expression, updates))
       );
     } else {
       statements.push(s2);
     }
   }
-  return ts2.factory.updateBlock(fnBody, statements);
+  return ts.factory.updateBlock(fnBody, statements);
 }
-function updateVitConfigObj(ts2, obj, updates) {
+function updateVitConfigObj(ts, obj, updates) {
   if (updates.viteConfig) {
-    obj = updateObjectLiteralExpression(ts2, obj, updates.viteConfig);
+    obj = updateObjectLiteralExpression(ts, obj, updates.viteConfig);
   }
   if (updates.vitePlugins || updates.vitePluginsPrepend || updates.qwikViteConfig) {
-    obj = updatePlugins(ts2, obj, updates);
+    obj = updatePlugins(ts, obj, updates);
   }
   return obj;
 }
-function updatePlugins(ts2, obj, updates) {
+function updatePlugins(ts, obj, updates) {
   const properties = [];
-  for (const p2 of obj.properties) {
-    if (ts2.isPropertyAssignment(p2)) {
-      if (p2.name && ts2.isIdentifier(p2.name) && p2.name.text === "plugins") {
-        if (ts2.isArrayLiteralExpression(p2.initializer)) {
+  for (let i2 = 0; i2 < obj.properties.length; i2++) {
+    const p2 = obj.properties[i2];
+    if (ts.isPropertyAssignment(p2)) {
+      if (p2.name && ts.isIdentifier(p2.name) && p2.name.text === "plugins") {
+        if (ts.isArrayLiteralExpression(p2.initializer)) {
           properties.push(
-            ts2.factory.updatePropertyAssignment(
+            ts.factory.updatePropertyAssignment(
               p2,
               p2.name,
-              updatePluginsArray(ts2, p2.initializer, updates)
+              updatePluginsArray(ts, p2.initializer, updates)
             )
           );
           continue;
@@ -11092,16 +11114,17 @@ function updatePlugins(ts2, obj, updates) {
     }
     properties.push(p2);
   }
-  return ts2.factory.updateObjectLiteralExpression(obj, properties);
+  return ts.factory.updateObjectLiteralExpression(obj, properties);
 }
-function updatePluginsArray(ts2, arr, updates) {
+function updatePluginsArray(ts, arr, updates) {
   const elms = [...arr.elements];
   if (updates.vitePlugins) {
-    for (const vitePlugin of updates.vitePlugins) {
-      const pluginExp = createPluginCall(ts2, vitePlugin);
+    for (let i2 = 0; i2 < updates.vitePlugins.length; i2++) {
+      const vitePlugin = updates.vitePlugins[i2];
+      const pluginExp = createPluginCall(ts, vitePlugin);
       const pluginName = pluginExp?.expression?.escapedText;
       const alreadyDefined = elms.some(
-        (el) => ts2.isCallExpression(el) && ts2.isIdentifier(el.expression) && el.expression.escapedText === pluginName
+        (el) => ts.isCallExpression(el) && ts.isIdentifier(el.expression) && el.expression.escapedText === pluginName
       );
       if (pluginExp && !alreadyDefined) {
         elms.push(pluginExp);
@@ -11109,11 +11132,12 @@ function updatePluginsArray(ts2, arr, updates) {
     }
   }
   if (updates.vitePluginsPrepend) {
-    for (const vitePlugin of updates.vitePluginsPrepend) {
-      const pluginExp = createPluginCall(ts2, vitePlugin);
+    for (let i2 = 0; i2 < updates.vitePluginsPrepend.length; i2++) {
+      const vitePlugin = updates.vitePluginsPrepend[i2];
+      const pluginExp = createPluginCall(ts, vitePlugin);
       const pluginName = pluginExp?.expression?.escapedText;
       const alreadyDefined = elms.some(
-        (el) => ts2.isCallExpression(el) && ts2.isIdentifier(el.expression) && el.expression.escapedText === pluginName
+        (el) => ts.isCallExpression(el) && ts.isIdentifier(el.expression) && el.expression.escapedText === pluginName
       );
       if (pluginExp && !alreadyDefined) {
         elms.unshift(pluginExp);
@@ -11123,68 +11147,73 @@ function updatePluginsArray(ts2, arr, updates) {
   if (updates.qwikViteConfig) {
     for (let i2 = 0; i2 < elms.length; i2++) {
       const elm = elms[i2];
-      if (ts2.isCallExpression(elm) && ts2.isIdentifier(elm.expression)) {
+      if (ts.isCallExpression(elm) && ts.isIdentifier(elm.expression)) {
         if (elm.expression.escapedText === "qwikVite") {
-          elms[i2] = updateQwikRouterPlugin(ts2, elm, updates.qwikViteConfig);
+          elms[i2] = updateQwikRouterPlugin(ts, elm, updates.qwikViteConfig);
         }
       }
     }
   }
-  return ts2.factory.updateArrayLiteralExpression(arr, elms);
+  return ts.factory.updateArrayLiteralExpression(arr, elms);
 }
-function createPluginCall(ts2, vitePlugin) {
+function createPluginCall(ts, vitePlugin) {
   if (typeof vitePlugin === "string") {
-    const tmp = ts2.createSourceFile(
+    const tmp = ts.createSourceFile(
       "tmp.ts",
       "export default " + vitePlugin,
-      ts2.ScriptTarget.Latest
+      ts.ScriptTarget.Latest
     );
-    for (const s2 of tmp.statements) {
-      if (ts2.isExportAssignment(s2)) {
+    for (let i2 = 0; i2 < tmp.statements.length; i2++) {
+      const s2 = tmp.statements[i2];
+      if (ts.isExportAssignment(s2)) {
         return s2.expression;
       }
     }
   }
   return null;
 }
-function updateQwikRouterPlugin(ts2, callExp, qwikViteConfig) {
+function updateQwikRouterPlugin(ts, callExp, qwikViteConfig) {
   const args = callExp.arguments.slice();
-  const config = args[0] && ts2.isObjectLiteralExpression(args[0]) ? args[0] : ts2.factory.createObjectLiteralExpression();
-  args[0] = updateObjectLiteralExpression(ts2, config, qwikViteConfig);
-  return ts2.factory.updateCallExpression(callExp, callExp.expression, callExp.typeArguments, args);
-}
-function updateObjectLiteralExpression(ts2, obj, updateObj) {
-  for (const [propName, value] of Object.entries(updateObj)) {
+  const config = args[0] && ts.isObjectLiteralExpression(args[0]) ? args[0] : ts.factory.createObjectLiteralExpression();
+  args[0] = updateObjectLiteralExpression(ts, config, qwikViteConfig);
+  return ts.factory.updateCallExpression(callExp, callExp.expression, callExp.typeArguments, args);
+}
+function updateObjectLiteralExpression(ts, obj, updateObj) {
+  const properties = Object.entries(updateObj);
+  for (let i2 = 0; i2 < properties.length; i2++) {
+    const [propName, value] = properties[i2];
     if (typeof value === "string") {
-      const tmp = ts2.createSourceFile("tmp.ts", "export default " + value, ts2.ScriptTarget.Latest);
-      for (const s2 of tmp.statements) {
-        if (ts2.isExportAssignment(s2)) {
+      const tmp = ts.createSourceFile("tmp.ts", "export default " + value, ts.ScriptTarget.Latest);
+      for (let j2 = 0; j2 < tmp.statements.length; j2++) {
+        const s2 = tmp.statements[j2];
+        if (ts.isExportAssignment(s2)) {
           const exp = s2.expression;
           let added = false;
-          const properties = [];
-          for (const p2 of obj.properties) {
-            if (p2.name && ts2.isIdentifier(p2.name) && p2.name.text === propName) {
-              properties.push(ts2.factory.createPropertyAssignment(propName, exp));
+          const properties2 = [];
+          for (let k3 = 0; k3 < obj.properties.length; k3++) {
+            const p2 = obj.properties[k3];
+            if (p2.name && ts.isIdentifier(p2.name) && p2.name.text === propName) {
+              properties2.push(ts.factory.createPropertyAssignment(propName, exp));
               added = true;
             } else {
-              properties.push(p2);
+              properties2.push(p2);
             }
           }
           if (!added) {
-            properties.unshift(ts2.factory.createPropertyAssignment(propName, exp));
+            properties2.unshift(ts.factory.createPropertyAssignment(propName, exp));
           }
-          obj = ts2.factory.updateObjectLiteralExpression(obj, properties);
+          obj = ts.factory.updateObjectLiteralExpression(obj, properties2);
         }
       }
     }
   }
   return obj;
 }
-function transformSource(ts2, sourceText, transformer) {
-  const t = ts2.transform(ts2.createSourceFile("/tmp.ts", sourceText, ts2.ScriptTarget.Latest), [
+function transformSource(ts, sourceText, transformer) {
+  const t = ts.transform(ts.createSourceFile("/tmp.ts", sourceText, ts.ScriptTarget.Latest), [
     transformer
   ]);
-  const p2 = ts2.createPrinter({
+  const p2 = ts.createPrinter({
     removeComments: false,
     omitTrailingSemicolon: false,
     noEmitHelpers: true
@@ -11205,8 +11234,8 @@ async function updateViteConfigs(fileUpdates, integration, rootDir) {
         throw new Error(`Could not find vite.config.ts or vite.config.ts in ${rootDir}`);
       }
       const destContent = await fs4.promises.readFile(viteConfigPath, "utf-8");
-      const ts2 = (await import("typescript")).default;
-      let updatedContent = updateViteConfig(ts2, destContent, viteConfig);
+      const ts = (await import("typescript")).default;
+      let updatedContent = updateViteConfig(ts, destContent, viteConfig);
       if (updatedContent) {
         try {
           const prettier = (await import("prettier")).default;
@@ -11272,7 +11301,9 @@ async function updateApp(pkgManager, opts) {
     let passed = true;
     try {
       const dirs = new Set(fileUpdates.files.map((f) => dirname3(f.path)));
-      for (const dir of Array.from(dirs)) {
+      const dirsArray = Array.from(dirs);
+      for (let i2 = 0; i2 < dirsArray.length; i2++) {
+        const dir = dirsArray[i2];
         try {
           fs5.mkdirSync(dir, { recursive: true });
         } catch (e2) {
@@ -11589,7 +11620,8 @@ async function printNewHelp() {
   );
   outString.push(``);
   outString.push(`${cyan("Available templates")}`);
-  for (const t of templates2) {
+  for (let i2 = 0; i2 < templates2.length; i2++) {
+    const t = templates2[i2];
     let postfix = "";
     if (t.id === "qwik") {
       postfix = " (default)";
@@ -11774,7 +11806,8 @@ async function writeToFile(name, slug, template, outDir) {
 }
 function inject(raw, vars) {
   let output = raw;
-  for (const v2 of vars) {
+  for (let i2 = 0; i2 < vars.length; i2++) {
+    const v2 = vars[i2];
     output = output.replaceAll(v2[0], v2[1]);
   }
   return output;
@@ -11917,18 +11950,22 @@ async function runBuildCommand(app) {
     );
   }
   console.log(``);
-  for (const script of prebuildScripts) {
+  for (let i2 = 0; i2 < prebuildScripts.length; i2++) {
+    const script = prebuildScripts[i2];
     console.log(dim(script));
   }
-  for (const script of scripts) {
+  for (let i2 = 0; i2 < scripts.length; i2++) {
+    const script = scripts[i2];
     console.log(dim(script));
   }
-  for (const script of postbuildScripts) {
+  for (let i2 = 0; i2 < postbuildScripts.length; i2++) {
+    const script = postbuildScripts[i2];
     console.log(dim(script));
   }
   console.log(``);
   let typecheck = null;
-  for (const script of prebuildScripts) {
+  for (let i2 = 0; i2 < prebuildScripts.length; i2++) {
+    const script = prebuildScripts[i2];
     try {
       await execaCommand(script, {
         cwd: app.rootDir,
@@ -12103,13 +12140,14 @@ async function runBuildCommand(app) {
   }
   if (step2.length > 0) {
     await Promise.all(step2).then((steps) => {
-      steps.forEach((step) => {
+      for (let i2 = 0; i2 < steps.length; i2++) {
+        const step = steps[i2];
         if (step.stdout) {
           console.log("");
           console.log(step.stdout);
         }
         console.log(`${cyan("\u2713")} ${step.title}`);
-      });
+      }
       if (!isPreviewBuild && !buildServerScript && !buildStaticScript && !isLibraryBuild) {
         const pmRun = pmRunCmd();
         console.log(``);
@@ -12139,7 +12177,8 @@ async function runBuildCommand(app) {
       }
     }).catch((error) => console.log(red(error)));
   }
-  for (const script of postbuildScripts) {
+  for (let i2 = 0; i2 < postbuildScripts.length; i2++) {
+    const script = postbuildScripts[i2];
     try {
       await execaCommand(script, {
         stdout: "inherit",
@@ -12474,12 +12513,14 @@ function replacePackageInDependencies(oldPackageName, newPackageName) {
     }
     try {
       const packageJson = JSON.parse(readFileSync5(path7, "utf-8"));
-      for (const deps of [
+      const dependencies = [
         packageJson.dependencies ?? {},
         packageJson.devDependencies ?? {},
         packageJson.peerDependencies ?? {},
         packageJson.optionalDependencies ?? {}
-      ]) {
+      ];
+      for (let i2 = 0; i2 < dependencies.length; i2++) {
+        const deps = dependencies[i2];
         if (oldPackageName in deps) {
           deps[newPackageName] = deps[oldPackageName];
           delete deps[oldPackageName];
@@ -12534,18 +12575,19 @@ var packageNames = [
 
 // packages/qwik/src/cli/migrate-v2/update-dependencies.ts
 init_dist2();
-import { major } from "semver";
 async function updateDependencies() {
   const packageJson = await readPackageJson(process.cwd());
-  const version = getPackageTag();
+  const version = await getPackageTag();
   const dependencyNames = [
     "dependencies",
     "devDependencies",
     "peerDependencies",
     "optionalDependencies"
   ];
-  for (const name of packageNames) {
-    for (const propName of dependencyNames) {
+  for (let i2 = 0; i2 < packageNames.length; i2++) {
+    const name = packageNames[i2];
+    for (let j2 = 0; j2 < dependencyNames.length; j2++) {
+      const propName = dependencyNames[j2];
       const prop = packageJson[propName];
       if (prop && prop[name]) {
         prop[name] = version;
@@ -12558,7 +12600,8 @@ async function updateDependencies() {
   await runInstall();
   loading.stop("Dependencies have been updated");
 }
-function getPackageTag() {
+async function getPackageTag() {
+  const { major } = await import("semver");
   const tags = execSync("npm dist-tag @qwik.dev/core", {
     encoding: "utf-8"
   })?.split("\n").filter(Boolean).map(
@@ -12573,7 +12616,8 @@ function getPackageTag() {
     }
     return aIndex - bIndex;
   });
-  for (const [, version] of tags) {
+  for (let i2 = 0; i2 < tags.length; i2++) {
+    const [, version] = tags[i2];
     if (major(version) === 2) {
       return version;
     }
@@ -12628,7 +12672,7 @@ ${bold(bgRed('Warning: migration tool is experimental and will migrate your appl
   try {
     const installedTsMorph = await installTsMorph();
     const { replaceImportInFiles: replaceImportInFiles2 } = await Promise.resolve().then(() => (init_rename_import(), rename_import_exports));
-    replaceImportInFiles2(
+    await replaceImportInFiles2(
       [
         ["QwikCityProvider", "QwikRouterProvider"],
         ["qwikCity", "qwikRouter"],
@@ -12639,12 +12683,12 @@ ${bold(bgRed('Warning: migration tool is experimental and will migrate your appl
       ],
       "@builder.io/qwik-city"
     );
-    replaceImportInFiles2(
+    await replaceImportInFiles2(
       [["qwikCityPlan", "qwikRouterConfig"]],
       "@qwik-city-plan"
       // using old name, package name will be updated in the next step
     );
-    replaceImportInFiles2([["jsxs", "jsx"]], "@builder.io/qwik/jsx-runtime");
+    await replaceImportInFiles2([["jsxs", "jsx"]], "@builder.io/qwik/jsx-runtime");
     replacePackage("@qwik-city-plan", "@qwik-router-config", true);
     replacePackage("@builder.io/qwik-city", "@qwik.dev/router");
     replacePackage("@builder.io/qwik-react", "@qwik.dev/react");
@@ -12733,7 +12777,8 @@ async function hasNewer(srcPath, timestamp) {
     } catch (err) {
       return;
     }
-    for (const item of items) {
+    for (let i2 = 0; i2 < items.length; i2++) {
+      const item = items[i2];
       if (returnValue) {
         return;
       }
@@ -12908,7 +12953,7 @@ async function printHelp(app) {
   await runCommand2(Object.assign(app, { task: args[0], args }));
 }
 function printVersion() {
-  console.log("2.0.0-beta.30-dev+5421ed4");
+  console.log("2.0.0-beta.31-dev+906321a");
 }
 export {
   runCli,