@blinkk/root 2.0.0-rc.0 → 2.0.0

package/dist/{chunk-7D26JHIF.js → chunk-A4DNVP34.js}

@@ -12,6 +12,7 @@ import {
   dirExists,
   directoryContains,
   fileExists,
+  flattenPackageDepsFromMonorepo,
   isDirectory,
   isJsFile,
   loadBundledConfig,
@@ -21,21 +22,21 @@ import {
   rmDir,
   writeFile,
   writeJson
-} from "./chunk-UJ6F5RQ5.js";
+} from "./chunk-HTBDTUFE.js";
 import {
   configureServerPlugins,
   getVitePlugins
-} from "./chunk-ZUUGSC6Z.js";
+} from "./chunk-MA6MSEP4.js";
 import {
   RouteTrie,
   htmlMinify,
   htmlPretty,
   isValidTagName,
   parseTagNames
-} from "./chunk-5YDJSEDK.js";
+} from "./chunk-3KGEENDW.js";
 
 // src/cli/cli.ts
-import { Command } from "commander";
+import { Command, InvalidArgumentError } from "commander";
 import { bgGreen, black } from "kleur/colors";
 
 // src/cli/build.ts
@@ -369,11 +370,6 @@ async function build(rootProjectDir, options) {
     });
   }
   const rootPlugins = rootConfig.plugins || [];
-  for (const plugin of rootPlugins) {
-    if (typeof plugin.hooks?.startup === "function") {
-      await plugin.hooks.startup({ command: "build", rootConfig });
-    }
-  }
   const viteConfig = rootConfig.vite || {};
   const vitePlugins = [
     ...viteConfig.plugins || [],
@@ -605,7 +601,17 @@ async function build(rootProjectDir, options) {
   if (!ssrOnly) {
     const render = await import(path3.join(distDir, "server/render.js"));
     const renderer = new render.Renderer(rootConfig, { assetMap, elementGraph });
-    const sitemap = await renderer.getSitemap();
+    let sitemap = await renderer.getSitemap();
+    if (options?.filter) {
+      const filterRegex = new RegExp(`^${options.filter}`);
+      const filteredSitemap = {};
+      Object.entries(sitemap).forEach(([urlPath, sitemapItem]) => {
+        if (urlPath.match(filterRegex)) {
+          filteredSitemap[urlPath] = sitemapItem;
+        }
+      });
+      sitemap = filteredSitemap;
+    }
     const sitemapXmlItems = [];
     if (rootConfig.sitemap && !rootConfig.domain) {
       throw new Error(
@@ -615,56 +621,94 @@ async function build(rootProjectDir, options) {
     const domain = rootConfig.domain;
     console.log("\nhtml output:");
     const batchSize = Number(options?.concurrency || 10);
-    await batchAsyncCalls(Object.keys(sitemap), batchSize, async (urlPath) => {
-      const sitemapItem = sitemap[urlPath];
-      try {
-        const data = await renderer.renderRoute(sitemapItem.route, {
-          routeParams: sitemapItem.params
-        });
-        if (data.notFound) {
-          return;
-        }
-        let outFilePath = path3.join(urlPath.slice(1), "index.html");
-        if (outFilePath.endsWith("404/index.html")) {
-          outFilePath = outFilePath.replace("404/index.html", "404.html");
+    await batchAsyncCalls(
+      Object.entries(sitemap),
+      batchSize,
+      async ([urlPath, sitemapItem]) => {
+        if (rootConfig.build?.excludeDefaultLocaleFromIntlPaths) {
+          const defaultLocale = rootConfig.i18n?.defaultLocale || "en";
+          if (sitemapItem.locale === defaultLocale) {
+            return;
+          }
         }
-        const outPath = path3.join(buildDir, outFilePath);
-        if (rootConfig.sitemap && outFilePath.endsWith("index.html")) {
-          const sitemapXmlItem = {
-            url: `${domain}${urlPath}`,
-            locale: sitemapItem.locale,
-            alts: []
-          };
-          sitemapXmlItems.push(sitemapXmlItem);
-          if (sitemapItem.alts) {
-            Object.entries(sitemapItem.alts).forEach(([altLocale, item]) => {
-              sitemapXmlItem.alts.push({
-                url: `${domain}${item.urlPath}`,
-                locale: altLocale,
-                hreflang: item.hrefLang
+        try {
+          const routeModule = sitemapItem.route.module;
+          if (routeModule.getStaticContent) {
+            let props;
+            if (routeModule.getStaticProps) {
+              props = await routeModule.getStaticProps({
+                rootConfig,
+                params: sitemapItem.params
               });
-            });
+              if (props?.notFound) {
+                return;
+              }
+            } else {
+              props = { rootConfig, params: sitemapItem.params };
+            }
+            const result = await routeModule.getStaticContent(props);
+            let body;
+            if (typeof result === "string") {
+              body = result;
+            } else if (result && typeof result === "object") {
+              body = result.body;
+            } else {
+              body = "";
+            }
+            const outFilePath2 = urlPath.slice(1);
+            const outPath2 = path3.join(buildDir, outFilePath2);
+            await makeDir(path3.dirname(outPath2));
+            await writeFile(outPath2, body);
+            printFileOutput(fileSize(outPath2), "dist/html/", outFilePath2);
+            return;
           }
+          const data = await renderer.renderRoute(sitemapItem.route, {
+            routeParams: sitemapItem.params
+          });
+          if (data.notFound) {
+            return;
+          }
+          let outFilePath = path3.join(urlPath.slice(1), "index.html");
+          if (outFilePath.endsWith("404/index.html")) {
+            outFilePath = outFilePath.replace("404/index.html", "404.html");
+          }
+          const outPath = path3.join(buildDir, outFilePath);
+          if (rootConfig.sitemap && outFilePath.endsWith("index.html")) {
+            const sitemapXmlItem = {
+              url: `${domain}${urlPath}`,
+              locale: sitemapItem.locale,
+              alts: []
+            };
+            sitemapXmlItems.push(sitemapXmlItem);
+            if (sitemapItem.alts) {
+              Object.entries(sitemapItem.alts).forEach(([altLocale, item]) => {
+                sitemapXmlItem.alts.push({
+                  url: `${domain}${item.urlPath}`,
+                  locale: altLocale,
+                  hreflang: item.hrefLang
+                });
+              });
+            }
+          }
+          let html = data.html || "";
+          if (rootConfig.prettyHtml) {
+            html = await htmlPretty(html, rootConfig.prettyHtmlOptions);
+          } else if (rootConfig.minifyHtml) {
+            html = await htmlMinify(html, rootConfig.minifyHtmlOptions);
+          }
+          await writeFile(outPath, html);
+          printFileOutput(fileSize(outPath), "dist/html/", outFilePath);
+        } catch (e) {
+          logBuildError(
+            { route: sitemapItem.route, params: sitemapItem.params, urlPath },
+            e
+          );
+          throw new Error(
+            `BuildError: ${urlPath} (${sitemapItem.route.src}) failed to build.`
+          );
         }
-        let html = data.html || "";
-        if (rootConfig.prettyHtml !== false) {
-          html = await htmlPretty(html, rootConfig.prettyHtmlOptions);
-        }
-        if (rootConfig.minifyHtml !== false) {
-          html = await htmlMinify(html, rootConfig.minifyHtmlOptions);
-        }
-        await writeFile(outPath, html);
-        printFileOutput(fileSize(outPath), "dist/html/", outFilePath);
-      } catch (e) {
-        logBuildError(
-          { route: sitemapItem.route, params: sitemapItem.params, urlPath },
-          e
-        );
-        throw new Error(
-          `BuildError: ${urlPath} (${sitemapItem.route.src}) failed to build.`
-        );
       }
-    });
+    );
     if (rootConfig.sitemap) {
       const sitemapXmlBuilder = [];
       sitemapXmlItems.sort((a, b) => a.url.localeCompare(b.url));
@@ -860,7 +904,8 @@ async function createPackage(rootProjectDir, options) {
     }
   }
   if (target === "appengine") {
-    await onAppEngine({ rootDir, packageJson, outDir });
+    const appYamlPath = options?.appYaml || path5.join(rootDir, "app.yaml");
+    await onAppEngine({ packageJson, outDir, appYamlPath });
   } else if (target === "firebase") {
     await onFirebase({ rootDir, packageJson, outDir });
   }
@@ -883,77 +928,30 @@ async function generatePackageJson(rootDir) {
   const packageJson = await loadJson(
     path5.resolve(rootDir, "package.json")
   );
-  if (packageJson.peerDependencies) {
-    await updatePeerDepsFromWorkspace(rootDir, packageJson);
-  }
-  return packageJson;
-}
-async function updatePeerDepsFromWorkspace(rootDir, packageJson) {
-  const requiredPeerDeps = getRequiredPeerDeps(packageJson);
-  if (requiredPeerDeps.length === 0) {
-    return;
-  }
-  const workspaceRoot = await findWorkspaceRoot(rootDir);
-  if (!workspaceRoot) {
-    return;
-  }
-  const workspacePackageJsonPath = path5.resolve(workspaceRoot, "package.json");
-  const workspacePackageJson = await loadJson(
-    workspacePackageJsonPath
-  );
-  const workspaceDeps = workspacePackageJson.dependencies || {};
-  function setDep(name, value) {
-    if (!packageJson.dependencies) {
-      packageJson.dependencies = {};
+  const allDeps = flattenPackageDepsFromMonorepo(rootDir);
+  packageJson.dependencies ??= {};
+  for (const depName in allDeps) {
+    if (!packageJson.dependencies[depName]) {
+      packageJson.dependencies[depName] = allDeps[depName];
     }
-    packageJson.dependencies[name] = value;
-  }
-  for (const peerDep of requiredPeerDeps) {
-    const workspaceDepVersion = workspaceDeps[peerDep];
-    if (workspaceDepVersion) {
-      setDep(peerDep, workspaceDepVersion);
-    } else {
-      console.warn(
-        `could not find peer dep "${peerDep}" in workspace "${workspacePackageJsonPath}"`
-      );
-    }
-  }
-}
-async function findWorkspaceRoot(rootDir) {
-  const parentDir = path5.dirname(rootDir);
-  if (parentDir === "/") {
-    return null;
   }
-  const pnpmWorkspaceFile = path5.resolve(parentDir, "pnpm-workspace.yaml");
-  if (await fileExists(pnpmWorkspaceFile)) {
-    return parentDir;
-  }
-  const packageJsonPath = path5.resolve(parentDir, "package.json");
-  if (await fileExists(packageJsonPath)) {
-    const parentPackageJson = await loadJson(packageJsonPath);
-    if (parentPackageJson && parentPackageJson.workspaces) {
-      return parentDir;
+  Object.entries(packageJson.dependencies).forEach(([depName, depVersion]) => {
+    if (depVersion.startsWith("workspace:")) {
+      delete packageJson.dependencies[depName];
     }
+  });
+  if (packageJson.peerDependencies) {
+    delete packageJson.peerDependencies;
   }
-  return findWorkspaceRoot(parentDir);
-}
-function getRequiredPeerDeps(packageJson) {
-  const requiredPeerDeps = [];
-  const peerDeps = packageJson.peerDependencies || {};
-  const peerDepsMeta = packageJson.peerDependenciesMeta || {};
-  for (const key in peerDeps) {
-    const meta = peerDepsMeta[key];
-    if (!meta?.optional) {
-      requiredPeerDeps.push(key);
-    }
+  if (packageJson.devDependencies) {
+    delete packageJson.devDependencies;
   }
-  return requiredPeerDeps;
+  return packageJson;
 }
 async function onAppEngine(options) {
-  const { rootDir, outDir, packageJson } = options;
-  const configPath = path5.resolve(rootDir, "app.yaml");
-  if (await fileExists(configPath)) {
-    await fs4.copyFile(configPath, path5.resolve(outDir, "app.yaml"));
+  const { outDir, packageJson, appYamlPath } = options;
+  if (await fileExists(appYamlPath)) {
+    await fs4.copyFile(appYamlPath, path5.resolve(outDir, "app.yaml"));
   }
   if (packageJson.scripts?.start) {
     packageJson.scripts = { start: packageJson.scripts.start };
@@ -1061,9 +1059,15 @@ function verifyRedirectConfig(redirect) {
   if (!redirect.source) {
     return false;
   }
+  if (!redirect.source.startsWith("/")) {
+    return false;
+  }
   if (!redirect.destination) {
     return false;
   }
+  if (!testIsRedirectValid(redirect.destination)) {
+    return false;
+  }
   return true;
 }
 function replaceParams(urlPathFormat, params) {
@@ -1079,6 +1083,15 @@ function replaceParams(urlPathFormat, params) {
   );
   return urlPath;
 }
+function testIsRedirectValid(url) {
+  if (url.startsWith("/")) {
+    return true;
+  }
+  if (url.match(/^https?:\/\//)) {
+    return true;
+  }
+  return false;
+}
 
 // src/render/asset-map/dev-asset-map.ts
 import path6 from "node:path";
@@ -1269,9 +1282,10 @@ async function dev(rootProjectDir, options) {
   const server = await createDevServer({ rootDir, port });
   const rootConfig = server.get("rootConfig");
   const basePath = rootConfig.base || "";
+  const homePagePath = rootConfig.server?.homePagePath || basePath;
   console.log();
   console.log(`${dim2("\u2503")} project:  ${rootDir}`);
-  console.log(`${dim2("\u2503")} server:   http://${host}:${port}${basePath}`);
+  console.log(`${dim2("\u2503")} server:   http://${host}:${port}${homePagePath}`);
   if (testCmsEnabled(rootConfig)) {
     console.log(`${dim2("\u2503")} cms:      http://${host}:${port}/cms/`);
   }
@@ -1330,11 +1344,6 @@ async function createDevServer(options) {
     plugins,
     { type: "dev", rootConfig }
   );
-  for (const plugin of plugins) {
-    if (typeof plugin.hooks?.startup === "function") {
-      await plugin.hooks.startup({ command: "dev", rootConfig });
-    }
-  }
   return server;
 }
 async function createViteMiddleware(options) {
@@ -1475,6 +1484,175 @@ function debounce(fn, timeout) {
   };
 }
 
+// src/cli/gae-deploy.ts
+import { execSync } from "node:child_process";
+import fs5 from "node:fs";
+import yaml from "js-yaml";
+async function gaeDeploy(appDir, options) {
+  if (!appDir) {
+    throw new Error(
+      "[gae-deplopy] Missing app dir, e.g. `root gae-deploy <app dir>`"
+    );
+  }
+  const project = options?.project;
+  if (!project) {
+    throw new Error("[gae-deplopy] Missing: --project");
+  }
+  process.chdir(appDir);
+  const appYamlPath = "app.yaml";
+  if (!fs5.existsSync(appYamlPath)) {
+    throw new Error(`[gae-deplopy] Missing: ${appYamlPath}`);
+  }
+  const appYaml = yaml.load(fs5.readFileSync(appYamlPath, "utf8"));
+  const service = appYaml.service;
+  if (!service) {
+    throw new Error(
+      '[gae-deploy] Missing service definition. Ensure "service" is defined in app.yaml.'
+    );
+  }
+  let prefix = options?.prefix;
+  if (!prefix) {
+    prefix = options?.promote ? "prod" : "staging";
+  }
+  const version = `${prefix}-${getTimestamp()}`;
+  if (testVersionTooLong(version, service, project)) {
+    throw new Error(`version "${version}" should not exceed 63 chars`);
+  }
+  console.log("[gae-deploy] \u{1F680} starting deployment...");
+  const appYamlHasPlaceholders = testHasEnvPlaceholders(appYaml);
+  let backupAppYaml = "";
+  if (appYamlHasPlaceholders) {
+    backupAppYaml = updateAppYamlEnv(appYamlPath, appYaml);
+  }
+  execSync(
+    `gcloud app deploy -q --project=${project} --version=${version} --no-promote app.yaml`,
+    { stdio: "inherit" }
+  );
+  if (backupAppYaml) {
+    fs5.copyFileSync(backupAppYaml, "app.yaml");
+  }
+  if (options?.healthcheckUrl) {
+    const healthcheckPassed = await testHealth(
+      project,
+      service,
+      version,
+      options.healthcheckUrl
+    );
+    if (!healthcheckPassed) {
+      throw new Error(
+        `[gae-deploy] \u274C health check failed. check logs: 
+${getLogsURL(
+          project,
+          service,
+          version
+        )}`
+      );
+    }
+    console.log("[gae-deploy] \u2705 health check succeeded!");
+  }
+  if (options?.promote) {
+    console.log(`[gae-deploy] promoting version ${version}...`);
+    execSync(
+      `gcloud app -q --project=${project} services set-traffic ${service} --splits ${version}=1`,
+      { stdio: "inherit" }
+    );
+  }
+  if (options?.maxVersions) {
+    const resp = execSync(
+      `gcloud app versions list --project ${project} --service ${service} --format json`
+    ).toString();
+    const versions = JSON.parse(resp.toString());
+    const managedVersions = versions.filter(
+      (appInfo) => testManagedVersion(service, appInfo, prefix)
+    ).sort(
+      (a, b) => new Date(b.last_deployed_time.datetime).getTime() - new Date(a.last_deployed_time.datetime).getTime()
+    );
+    console.log(
+      `[gae-deploy] \u{1F4E6} all managed versions (${managedVersions.length}):`
+    );
+    for (const eachVersion of managedVersions) {
+      console.log(`  ${eachVersion.id}`);
+    }
+    for (const eachVersion of managedVersions.slice(options.maxVersions - 1)) {
+      console.log(`[gae-deploy] \u2702\uFE0F deleting old version ${eachVersion.id}`);
+      execSync(
+        `gcloud app versions delete -q --project=${project} --service=${service} ${eachVersion.id}`,
+        { stdio: "inherit" }
+      );
+    }
+  }
+  console.log(
+    `[gae-deploy] \u2728 deployment complete
+versions: ${getVersionsURL(
+      project,
+      service
+    )}`
+  );
+}
+function testVersionTooLong(version, service, project) {
+  const subdomain = `${version}-dot-${service}-dot-${project}`;
+  return subdomain.length > 63;
+}
+function getLogsURL(project, service, version) {
+  return `https://console.cloud.google.com/logs/query;query=resource.type%3D"gae_app"%0Aresource.labels.module_id%3D"${service}"%0Aresource.labels.version_id%3D"${version}"?project=${project}`;
+}
+function getVersionsURL(project, service) {
+  return `https://console.cloud.google.com/appengine/versions?project=${project}&serviceId=${service}`;
+}
+function testHasEnvPlaceholders(appYaml) {
+  if (typeof appYaml?.env_variables !== "object") {
+    return false;
+  }
+  const envVars = appYaml.env_variables;
+  return Object.values(envVars).some((envValue) => {
+    return testIsEnvPlaceholder(envValue);
+  });
+}
+function testIsEnvPlaceholder(envValue) {
+  if (typeof envValue === "string") {
+    return envValue.startsWith("{") && envValue.endsWith("}");
+  }
+  return false;
+}
+function updateAppYamlEnv(appYamlPath, appYaml) {
+  const backupAppYaml = `${appYamlPath}.bak`;
+  fs5.copyFileSync(appYamlPath, backupAppYaml);
+  let content = fs5.readFileSync(appYamlPath, "utf8");
+  const envVars = appYaml.env_variables;
+  Object.entries(envVars).forEach(([envVar, envValue]) => {
+    if (testIsEnvPlaceholder(envValue)) {
+      const value = process.env[envVar];
+      if (!value && content.includes(`{${envVar}}`)) {
+        console.warn(`[gae-deploy] Missing environment variable: ${envVar}`);
+        content = content.replaceAll(`{${envVar}}`, "");
+      } else if (value && content.includes(`{${envVar}}`)) {
+        content = content.replaceAll(`{${envVar}}`, value);
+      }
+    }
+  });
+  fs5.writeFileSync(appYamlPath, content, "utf8");
+  return backupAppYaml;
+}
+function getTimestamp() {
+  const pretty = (num) => (num + "").padStart(2, "0");
+  const date = /* @__PURE__ */ new Date();
+  return `${date.getFullYear()}${pretty(date.getMonth() + 1)}${pretty(
+    date.getDate()
+  )}t${pretty(date.getHours())}${pretty(date.getMinutes())}`;
+}
+async function testHealth(project, service, version, healthcheckUrl) {
+  if (!healthcheckUrl.startsWith("/")) {
+    healthcheckUrl = `/${healthcheckUrl}`;
+  }
+  const url = `https://${version}-dot-${service}-dot-${project}.appspot.com${healthcheckUrl}`;
+  const response = await fetch(url);
+  return response.status === 200;
+}
+function testManagedVersion(service, appInfo, prefix) {
+  const re = new RegExp(`${prefix}-\\d{8}t\\d{4}`);
+  return appInfo.service === service && re.exec(appInfo.id) && appInfo.traffic_split === 0;
+}
+
 // src/cli/preview.ts
 import path8 from "node:path";
 import compression from "compression";
@@ -1509,7 +1687,7 @@ async function createPreviewServer(options) {
   server.use(cookieParser2(sessionCookieSecret));
   server.use(sessionMiddleware());
   const plugins = rootConfig.plugins || [];
-  configureServerPlugins(
+  await configureServerPlugins(
     server,
     async () => {
       const userMiddlewares = rootConfig.server?.middlewares || [];
@@ -1539,11 +1717,6 @@ async function createPreviewServer(options) {
     plugins,
     { type: "preview", rootConfig }
   );
-  for (const plugin of plugins) {
-    if (typeof plugin.hooks?.startup === "function") {
-      await plugin.hooks.startup({ command: "preview", rootConfig });
-    }
-  }
   return server;
 }
 async function rootPreviewRendererMiddleware(options) {
@@ -1660,7 +1833,7 @@ async function createProdServer(options) {
   server.use(cookieParser3(sessionCookieSecret));
   server.use(sessionMiddleware());
   const plugins = rootConfig.plugins || [];
-  configureServerPlugins(
+  await configureServerPlugins(
     server,
     async () => {
       const userMiddlewares = rootConfig.server?.middlewares || [];
@@ -1690,11 +1863,6 @@ async function createProdServer(options) {
     plugins,
     { type: "prod", rootConfig }
   );
-  for (const plugin of plugins) {
-    if (typeof plugin.hooks?.startup === "function") {
-      await plugin.hooks.startup({ command: "start", rootConfig });
-    }
-  }
   return server;
 }
 async function rootProdRendererMiddleware(options) {
@@ -1805,11 +1973,18 @@ var CliRunner = class {
       "-c, --concurrency <num>",
       "number of files to build concurrently",
       "10"
+    ).option(
+      "--filter <urlPathRegex>",
+      'builds the url paths that match the given regex, e.g. "/products/.*"',
+      ""
     ).action(build);
     program.command("codegen [type] [name]").description("generates boilerplate code").option("--out <outdir>", "output dir").action(codegen);
     program.command("create-package [path]").alias("package").description(
       "creates a standalone npm package for deployment to various hosting services"
-    ).option("--target <target>", "hosting target, i.e. appengine or firebase").option("--out <outdir>", "output dir").option("--mode <mode>", "deployment mode, i.e. production or preview").action((rootPackageDir, options) => {
+    ).option("--target <target>", "hosting target, i.e. appengine or firebase").option("--out <outdir>", "output dir").option("--mode <mode>", "deployment mode, i.e. production or preview").option(
+      "--app-yaml <path>",
+      'for appengine targets, path to app.yaml (defaults to "app.yaml")'
+    ).action((rootPackageDir, options) => {
       options.version = this.version;
       createPackage(rootPackageDir, options);
     });
@@ -1817,6 +1992,19 @@ var CliRunner = class {
       "--host <host>",
       "network address the server should listen on, e.g. 127.0.0.1"
     ).action(dev);
+    program.command("gae-deploy <appdir>").description(
+      "appengine deploy utility that can optionally run healthchecks before diverting traffic to the new version and clean up old versions"
+    ).option("--project <project>", "GCP project id").option("--prefix <prefix>", "prefix to append the version").option(
+      "--promote",
+      "whether to promote the version (if healthchecks pass)"
+    ).option(
+      "--healthcheck-url <url>",
+      'healthcheck url path (e.g. "/healthcheck") which should return a 200 status with the text "OK"'
+    ).option(
+      "--max-versions <num>",
+      "the max number of versions to keep",
+      numberFlag
+    ).action(gaeDeploy);
     program.command("preview [path]").description("starts the server in preview mode").option(
       "--host <host>",
       "network address the server should listen on, e.g. 127.0.0.1"
@@ -1828,6 +2016,13 @@ var CliRunner = class {
     await program.parseAsync(argv);
   }
 };
+function numberFlag(value) {
+  const num = parseInt(value);
+  if (isNaN(num)) {
+    throw new InvalidArgumentError(`not a number: ${value}`);
+  }
+  return num;
+}
 
 export {
   build,
@@ -1840,4 +2035,4 @@ export {
   createProdServer,
   CliRunner
 };
-//# sourceMappingURL=chunk-7D26JHIF.js.map
+//# sourceMappingURL=chunk-A4DNVP34.js.map