@vercel/microfrontends 0.9.0

package/dist/next/middleware.cjs

@@ -0,0 +1,763 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/next/middleware/index.ts
+var middleware_exports = {};
+__export(middleware_exports, {
+  getMicroFrontendsMiddleware: () => getMicroFrontendsMiddleware,
+  runMicroFrontendsMiddleware: () => runMicroFrontendsMiddleware
+});
+module.exports = __toCommonJS(middleware_exports);
+
+// src/next/middleware/middleware.ts
+var import_server = require("next/server");
+var import_path_to_regexp = require("path-to-regexp");
+
+// src/config/edge/micro-frontend-config.ts
+var import_jsonc_parser = require("jsonc-parser");
+
+// src/config/errors.ts
+var MicroFrontendError = class extends Error {
+  constructor(message, opts) {
+    super(message);
+    this.name = "MicroFrontendsError";
+    this.source = (opts == null ? void 0 : opts.source) ?? "@vercel/micro-frontends";
+    this.type = (opts == null ? void 0 : opts.type) ?? "unknown";
+    this.subtype = opts == null ? void 0 : opts.subtype;
+    Error.captureStackTrace(this, MicroFrontendError);
+  }
+  isKnown() {
+    return this.type !== "unknown";
+  }
+  isUnknown() {
+    return !this.isKnown();
+  }
+  /**
+   * Converts an error to a MicroFrontendsError.
+   * @param original - The original error to convert.
+   * @returns The converted MicroFrontendsError.
+   */
+  static convert(original, opts) {
+    if (opts == null ? void 0 : opts.fileName) {
+      const err = MicroFrontendError.convertFSError(original, opts.fileName);
+      if (err) {
+        return err;
+      }
+    }
+    if (original.message.includes(
+      "Code generation from strings disallowed for this context"
+    )) {
+      return new MicroFrontendError(original.message, {
+        type: "config",
+        subtype: "unsupported_validation_env",
+        source: "ajv"
+      });
+    }
+    return new MicroFrontendError(original.message);
+  }
+  static convertFSError(original, fileName) {
+    if (original instanceof Error && "code" in original) {
+      if (original.code === "ENOENT") {
+        return new MicroFrontendError(`Could not find "${fileName}"`, {
+          type: "config",
+          subtype: "unable_to_read_file",
+          source: "fs"
+        });
+      }
+      if (original.code === "EACCES") {
+        return new MicroFrontendError(
+          `Permission denied while accessing "${fileName}"`,
+          {
+            type: "config",
+            subtype: "invalid_permissions",
+            source: "fs"
+          }
+        );
+      }
+    }
+    if (original instanceof SyntaxError) {
+      return new MicroFrontendError(
+        `Failed to parse "${fileName}": Invalid JSON format.`,
+        {
+          type: "config",
+          subtype: "invalid_syntax",
+          source: "fs"
+        }
+      );
+    }
+    return null;
+  }
+  /**
+   * Handles an unknown error and returns a MicroFrontendsError instance.
+   * @param err - The error to handle.
+   * @returns A MicroFrontendsError instance.
+   */
+  static handle(err, opts) {
+    if (err instanceof MicroFrontendError) {
+      return err;
+    }
+    if (err instanceof Error) {
+      return MicroFrontendError.convert(err, opts);
+    }
+    if (typeof err === "object" && err !== null) {
+      if ("message" in err && typeof err.message === "string") {
+        return MicroFrontendError.convert(new Error(err.message), opts);
+      }
+    }
+    return new MicroFrontendError("An unknown error occurred");
+  }
+};
+
+// src/routing/url.ts
+function buildUrlSafeString(givenOpts = {}) {
+  const options = {
+    joinString: "-",
+    lowercaseOnly: true,
+    maxLen: 100,
+    regexRemovePattern: /(?:(?!(?:[a-z0-9])).)/gi,
+    trimWhitespace: true,
+    ...givenOpts
+  };
+  return {
+    generate: (...args) => {
+      const reJoinString = new RegExp(`${options.joinString}+`, "g");
+      let tag;
+      if (args.length === 0) {
+        throw new Error("generate method must be passed at least one argument");
+      }
+      for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (typeof arg !== "string")
+          throw new Error("all supplied arguments must be Strings");
+        if (options.trimWhitespace) {
+          args[i] = arg.trim();
+        }
+      }
+      tag = args.join(options.joinString);
+      tag = tag.replace(/\s/g, options.joinString);
+      if (options.lowercaseOnly)
+        tag = tag.toLowerCase();
+      tag = tag.replace(options.regexRemovePattern, (match) => {
+        if (match === options.joinString)
+          return match;
+        return "";
+      });
+      if (tag.length > options.maxLen)
+        tag = tag.substring(0, options.maxLen);
+      tag = tag.replace(reJoinString, options.joinString);
+      return tag;
+    }
+  };
+}
+var urlSafeString = buildUrlSafeString().generate;
+function makeUrlSafe(name) {
+  return urlSafeString(name.replace(/\//g, "-")).replace(/^-*/g, "").replace(/-*$/g, "");
+}
+
+// src/config/overrides/config.ts
+var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
+var _Overrides = class {
+  constructor(config) {
+    this.config = config;
+  }
+  static getAppEnvOverrideCookieName(zone) {
+    return `${_Overrides.overrideEnvCookiePrefix}${zone}`;
+  }
+  static isOverrideCookie(cookie) {
+    var _a;
+    return Boolean((_a = cookie.name) == null ? void 0 : _a.startsWith(OVERRIDES_COOKIE_PREFIX));
+  }
+  static getOverrideFromCookie(cookie) {
+    if (!_Overrides.isOverrideCookie(cookie) || !cookie.value)
+      return;
+    return {
+      zone: cookie.name.replace(_Overrides.overrideEnvCookiePrefix, ""),
+      host: cookie.value
+    };
+  }
+  static parseOverrides(cookies) {
+    const overridesConfig = { applications: {} };
+    cookies.forEach((cookie) => {
+      const override = _Overrides.getOverrideFromCookie(cookie);
+      if (!override)
+        return;
+      overridesConfig.applications[override.zone] = {
+        environment: { host: override.host }
+      };
+    });
+    return overridesConfig;
+  }
+  static validOverrideDomainsForZone(microFrontendConfig, zone) {
+    var _a, _b, _c, _d, _e;
+    const projectName = (_a = microFrontendConfig.getZone(zone).vercel) == null ? void 0 : _a.projectName;
+    if (!projectName) {
+      return [microFrontendConfig.getZone(zone).production.host];
+    }
+    const parsedProjectName = makeUrlSafe(projectName);
+    const previewDeploymentSuffix = (_c = (_b = microFrontendConfig.options) == null ? void 0 : _b.vercel) == null ? void 0 : _c.previewDeploymentSuffix;
+    const teamSlug = (_e = (_d = microFrontendConfig.options) == null ? void 0 : _d.vercel) == null ? void 0 : _e.teamSlug;
+    if (!teamSlug && !previewDeploymentSuffix) {
+      return [microFrontendConfig.getZone(zone).production.host];
+    }
+    const suffix = previewDeploymentSuffix ? `.${previewDeploymentSuffix}` : `-${teamSlug}.vercel.app`;
+    return [
+      `${parsedProjectName}-git-([a-zA-Z0-9-]+)${suffix}`,
+      microFrontendConfig.getZone(zone).production.host
+    ];
+  }
+  static validateOverrideDomain(microFrontendConfig, zone, domain) {
+    return new RegExp(
+      `^${_Overrides.validOverrideDomainsForZone(microFrontendConfig, zone).join(
+        "|"
+      )}$`
+    ).test(domain);
+  }
+  serialize() {
+    return this.config;
+  }
+};
+var Overrides = _Overrides;
+Overrides.overrideEnvCookiePrefix = `${OVERRIDES_COOKIE_PREFIX}:env:`;
+
+// src/config/common/host.ts
+var Host = class {
+  constructor({ protocol, host, port }) {
+    this.protocol = protocol || "https";
+    this.host = host;
+    this.port = Host.getPort({ port, protocol: this.protocol });
+    this.serialized = {
+      protocol,
+      host,
+      ...port ? { port } : void 0
+    };
+  }
+  isLocal() {
+    return this.host === "localhost" || this.host === "127.0.0.1";
+  }
+  static getPort({
+    protocol,
+    port
+  }) {
+    if (!port) {
+      if (protocol === "http") {
+        return 80;
+      }
+      return 443;
+    }
+    return port;
+  }
+  isDefaultPort() {
+    return this.port === Host.getPort({ protocol: this.protocol });
+  }
+  toString(opts = {}) {
+    const url = this.toUrl(opts);
+    return url.toString().replace(/\/$/, "");
+  }
+  toUrl(opts = {}) {
+    const { includeDefaultPort } = opts;
+    const url = `${this.protocol}://${this.host}${this.isDefaultPort() && !includeDefaultPort ? "" : `:${this.port}`}`;
+    return new URL(url);
+  }
+  serialize() {
+    return this.serialized;
+  }
+};
+
+// src/config/common/application.ts
+var Application = class {
+  constructor(name, {
+    app,
+    overrides
+  }) {
+    Application.validate(name, app);
+    this.name = name;
+    this.default = app.default;
+    this.routing = app.routing;
+    this.development = {
+      local: new Host(app.development.local),
+      fallback: app.development.fallback ? new Host(app.development.fallback) : void 0
+    };
+    this.production = new Host(app.production);
+    this.vercel = app.vercel;
+    this.overrides = (overrides == null ? void 0 : overrides.environment) ? {
+      environment: new Host(overrides.environment)
+    } : void 0;
+  }
+  isDefault() {
+    return this.default;
+  }
+  static validate(name, app) {
+    var _a, _b, _c, _d, _e;
+    if (((_b = (_a = app.routing) == null ? void 0 : _a.assetPrefix) == null ? void 0 : _b.startsWith("/")) || ((_d = (_c = app.routing) == null ? void 0 : _c.assetPrefix) == null ? void 0 : _d.endsWith("/"))) {
+      throw new MicroFrontendError(
+        `Invalid assetPrefix for application "${name}". Must not start or end with a slash.`,
+        { type: "zone", subtype: "invalid_asset_prefix" }
+      );
+    }
+    for (const group of ((_e = app.routing) == null ? void 0 : _e.matches) ?? []) {
+      for (const p of group.paths) {
+        if (p === "/") {
+          continue;
+        }
+        if (p.endsWith("/")) {
+          throw new MicroFrontendError(
+            `Invalid path for application "${name}". ${p} must not end with a slash.`,
+            { type: "zone", subtype: "invalid_path" }
+          );
+        }
+        if (!p.startsWith("/")) {
+          throw new MicroFrontendError(
+            `Invalid path for application "${name}". ${p} must start with a slash.`,
+            { type: "zone", subtype: "invalid_path" }
+          );
+        }
+      }
+    }
+  }
+  serialize() {
+    var _a, _b;
+    if (this.routing === void 0 || this.default) {
+      return {
+        default: true,
+        development: {
+          local: this.development.local.serialize(),
+          fallback: (_a = this.development.fallback) == null ? void 0 : _a.serialize()
+        },
+        production: this.production.serialize(),
+        vercel: this.vercel
+      };
+    }
+    return {
+      default: false,
+      routing: this.routing,
+      development: {
+        local: this.development.local.serialize(),
+        fallback: (_b = this.development.fallback) == null ? void 0 : _b.serialize()
+      },
+      production: this.production.serialize(),
+      vercel: this.vercel
+    };
+  }
+};
+
+// src/config/common/micro-frontend-config.ts
+var SUPPORTED_VERSIONS = ["1"];
+var DEFAULT_LOCAL_PROXY_PORT = 3024;
+var MicroFrontendConfigCommon = class {
+  constructor({
+    config,
+    overrides
+  }) {
+    this.zones = {};
+    var _a, _b, _c;
+    if (!SUPPORTED_VERSIONS.includes(config.version)) {
+      throw new MicroFrontendError(
+        `Unsupported version: ${config.version}. Supported versions are: ${SUPPORTED_VERSIONS.join(
+          ", "
+        )}`,
+        { type: "config", subtype: "unsupported_version" }
+      );
+    }
+    const disableOverrides = ((_b = (_a = config.options) == null ? void 0 : _a.vercel) == null ? void 0 : _b.disableOverrides) ?? false;
+    this.overrides = overrides && !disableOverrides ? new Overrides(overrides) : void 0;
+    for (const [zoneName, zoneConfig] of Object.entries(config.applications)) {
+      this.zones[zoneName] = new Application(zoneName, {
+        app: zoneConfig,
+        overrides: !disableOverrides ? (_c = this.overrides) == null ? void 0 : _c.config.applications[zoneName] : void 0
+      });
+    }
+    this.config = config;
+    this.name = config.name;
+    this.version = config.version;
+    this.options = config.options;
+    this.$schema = config.$schema;
+  }
+  isOverridesDisabled() {
+    var _a, _b;
+    return ((_b = (_a = this.options) == null ? void 0 : _a.vercel) == null ? void 0 : _b.disableOverrides) ?? false;
+  }
+  static getConfigFromEnv() {
+    const config = process.env.MFE_CONFIG;
+    if (!config) {
+      throw new MicroFrontendError(`Missing "MFE_CONFIG" in environment.`, {
+        type: "config",
+        subtype: "not_found_in_env"
+      });
+    }
+    return config;
+  }
+  static fromEnv(_) {
+    throw new Error("Not implemented");
+  }
+  getConfig() {
+    return this.config;
+  }
+  getAllApplications() {
+    return Object.values(this.zones);
+  }
+  getZone(name) {
+    const zone = this.zones[name];
+    if (!zone) {
+      throw new MicroFrontendError(
+        `Could not find micro-frontends configuration for application "${name}"`,
+        {
+          type: "zone",
+          subtype: "not_found"
+        }
+      );
+    }
+    return zone;
+  }
+  getApplicationByProjectId(projectId) {
+    return Object.values(this.zones).find(
+      (zone) => {
+        var _a;
+        return ((_a = zone.vercel) == null ? void 0 : _a.projectId) === projectId;
+      }
+    );
+  }
+  getDefaultZone() {
+    const zone = Object.values(this.zones).find((z) => z.default);
+    if (!zone) {
+      throw new MicroFrontendError(
+        `Could not find default zone in micro-frontends configuration`,
+        {
+          type: "zone",
+          subtype: "not_found"
+        }
+      );
+    }
+    return zone;
+  }
+  /**
+   * Returns the configured port for the local proxy
+   */
+  getLocalProxyPort() {
+    var _a, _b;
+    return ((_b = (_a = this.config.options) == null ? void 0 : _a.localProxy) == null ? void 0 : _b.port) ?? DEFAULT_LOCAL_PROXY_PORT;
+  }
+  /**
+   * Serializes the class back to the Schema type.
+   *
+   * NOTE: This is used when writing the config to disk and must always match the input Schema
+   */
+  toSchemaJson() {
+    const applications = {};
+    for (const [name, zone] of Object.entries(this.zones)) {
+      applications[name] = zone.serialize();
+    }
+    return {
+      $schema: this.$schema,
+      name: this.name,
+      version: this.version,
+      options: this.options,
+      applications
+    };
+  }
+  serialize() {
+    var _a;
+    const applications = {};
+    for (const [name, zone] of Object.entries(this.zones)) {
+      applications[name] = zone.serialize();
+    }
+    return {
+      config: {
+        name: this.name,
+        version: this.version,
+        applications,
+        options: this.options,
+        $schema: this.$schema
+      },
+      overrides: (_a = this.overrides) == null ? void 0 : _a.serialize()
+    };
+  }
+  write(_) {
+    throw new MicroFrontendError(
+      `Writing to file to disk requires using an instance of "MicroFrontendConfig".`,
+      { type: "config", subtype: "unsupported_operation" }
+    );
+  }
+};
+
+// src/config/edge/micro-frontend-config.ts
+var MicroFrontendConfigEdge = class extends MicroFrontendConfigCommon {
+  static fromEnv({
+    cookies
+  }) {
+    return new MicroFrontendConfigCommon({
+      config: (0, import_jsonc_parser.parse)(MicroFrontendConfigCommon.getConfigFromEnv()),
+      overrides: Overrides.parseOverrides(cookies)
+    });
+  }
+};
+
+// src/routing/get-domain-for-current-environment.ts
+function debugDomains(zone, env, domain) {
+  if (process.env.MFE_DEBUG === "true") {
+    const indent = " ".repeat(4);
+    const header = "domains (zone (env) -> domain)";
+    const separator = "\u23AF".repeat(header.length);
+    const line = `${indent} 1. ${zone} (${env}) -> ${domain}`;
+    console.log(`${indent}${header}
+${indent}${separator}
+${line}
+`);
+  }
+}
+function getDomainForCurrentEnvironment(zone) {
+  var _a;
+  if ((_a = zone.overrides) == null ? void 0 : _a.environment) {
+    return zone.overrides.environment.toString();
+  }
+  const zoneName = zone.name;
+  if (!process.env.VERCEL_ENV || process.env.VERCEL_ENV === "development") {
+    const domain = process.env.NODE_ENV === "test" ? zone.development.local.toString() : zone.production.toString();
+    debugDomains(zoneName, "development", domain);
+    return domain;
+  } else if (process.env.VERCEL_ENV === "production") {
+    const domain = zone.production.toString();
+    debugDomains(zoneName, "production", domain);
+    return domain;
+  } else if (process.env.VERCEL_ENV === "preview") {
+    const MFE_PREVIEW_DOMAINS = JSON.parse(
+      process.env.MFE_PREVIEW_DOMAINS ?? "{}"
+    );
+    if (MFE_PREVIEW_DOMAINS[zoneName]) {
+      debugDomains(zoneName, "preview", MFE_PREVIEW_DOMAINS[zoneName]);
+      return MFE_PREVIEW_DOMAINS[zoneName];
+    }
+    throw new Error(
+      `Could not find preview domain for application "${zoneName}"`
+    );
+  }
+  debugDomains(zoneName, process.env.VERCEL_ENV, zone.production.toString());
+  return zone.production.toString();
+}
+
+// src/next/middleware/middleware.ts
+async function verifyPreviewDomain(req, rewriteDomain) {
+  var _a;
+  const jwtCookie = (_a = req.cookies.get("_vercel_jwt")) == null ? void 0 : _a.value;
+  const deploymentProtectionBypassHeader = req.headers.get(
+    "x-vercel-protection-bypass"
+  );
+  const previewResponse = await fetch(rewriteDomain, {
+    method: "HEAD",
+    headers: {
+      "x-vercel-micro-frontends-check": "1",
+      ...jwtCookie ? { cookie: `_vercel_jwt=${jwtCookie}` } : {},
+      ...deploymentProtectionBypassHeader ? {
+        "x-vercel-protection-bypass": deploymentProtectionBypassHeader
+      } : {}
+    }
+  });
+  const vercelError = previewResponse.headers.get("x-vercel-error");
+  return !(previewResponse.status === 404 && (vercelError === "DEPLOYMENT_NOT_FOUND" || vercelError === "NOT_FOUND"));
+}
+function microFrontendInternalRoutingHandler({
+  config
+}) {
+  return async (req) => {
+    const payload = Object.fromEntries(
+      await Promise.all(
+        config.getAllApplications().map(async (application) => {
+          let rewriteDomain = getDomainForCurrentEnvironment(application);
+          const isPreviewDomainAvailable = await verifyPreviewDomain(
+            req,
+            rewriteDomain
+          );
+          if (!isPreviewDomainAvailable) {
+            rewriteDomain = application.production.toString();
+          }
+          return [
+            application.name,
+            { routing: { host: rewriteDomain } }
+          ];
+        })
+      )
+    );
+    return import_server.NextResponse.json(payload);
+  };
+}
+function getHandler({
+  application,
+  flagFn,
+  pattern
+}) {
+  return async (req) => {
+    var _a, _b, _c;
+    const pathname = req.nextUrl.pathname;
+    const search = req.nextUrl.search;
+    let rewriteDomain = getDomainForCurrentEnvironment(application);
+    const patchedHeaders = new Headers(req.headers);
+    const responseCallbacks = [];
+    const onRewrite = (response) => {
+      for (const callback of responseCallbacks) {
+        callback(response);
+      }
+      return response;
+    };
+    if (process.env.VERCEL_ENV === "preview" && rewriteDomain) {
+      const zoneFallbackCookieName = `__zone_${application.name}_production_fallback`;
+      const assetPrefix = (_a = application.routing) == null ? void 0 : _a.assetPrefix;
+      if (assetPrefix && pathname.startsWith(`/${assetPrefix}`) && ((_b = req.cookies.get(zoneFallbackCookieName)) == null ? void 0 : _b.value) === "1") {
+        rewriteDomain = application.production.toString();
+      } else {
+        try {
+          let deploymentFound;
+          if (req.headers.get("x-vercel-skip-deployment-existence-check")) {
+            deploymentFound = true;
+          } else {
+            deploymentFound = await verifyPreviewDomain(req, rewriteDomain);
+          }
+          if (!deploymentFound) {
+            rewriteDomain = application.production.toString();
+            responseCallbacks.push((response) => {
+              response.cookies.set(zoneFallbackCookieName, "1", {
+                httpOnly: true,
+                sameSite: "lax",
+                secure: true,
+                maxAge: 60
+                // 1 minute
+              });
+            });
+            try {
+              const existingCookie = patchedHeaders.get("cookie");
+              if (!(existingCookie == null ? void 0 : existingCookie.includes("__vercel_toolbar"))) {
+                patchedHeaders.set(
+                  "cookie",
+                  [`__vercel_toolbar=1`, existingCookie].join("; ")
+                );
+                responseCallbacks.push((response) => {
+                  response.cookies.set("__vercel_toolbar", "1", {
+                    httpOnly: false,
+                    sameSite: "lax",
+                    secure: true,
+                    maxAge: 29030400
+                  });
+                });
+              }
+            } catch (error) {
+            }
+          } else if (((_c = req.cookies.get(zoneFallbackCookieName)) == null ? void 0 : _c.value) === "1") {
+            responseCallbacks.push((response) => {
+              response.cookies.set(zoneFallbackCookieName, "", {
+                httpOnly: true,
+                sameSite: "lax",
+                secure: true,
+                maxAge: 0
+              });
+            });
+          }
+        } catch {
+        }
+      }
+    }
+    const isFlagEnabled = async () => flagFn ? flagFn() : true;
+    if (pattern.test(pathname) && await isFlagEnabled()) {
+      return onRewrite(
+        import_server.NextResponse.rewrite(`${rewriteDomain}${pathname}${search}`, {
+          request: {
+            headers: patchedHeaders
+          }
+        })
+      );
+    }
+  };
+}
+function getMicroFrontendsMiddleware({
+  request,
+  flagValues
+}) {
+  var _a, _b, _c;
+  const config = MicroFrontendConfigEdge.fromEnv({
+    cookies: request.cookies.getAll()
+  });
+  const middlewares = [];
+  middlewares.push({
+    src: "/.well-known/vercel/microfrontend-routing",
+    fn: microFrontendInternalRoutingHandler({ config })
+  });
+  for (const application of config.getAllApplications()) {
+    if (application.name === process.env.NEXT_PUBLIC_MFE_CURRENT_APPLICATION) {
+      continue;
+    }
+    if (application.routing) {
+      if (process.env.VERCEL_ENV === "preview" && application.routing.assetPrefix) {
+        const pattern = (0, import_path_to_regexp.pathToRegexp)(
+          `/${application.routing.assetPrefix}/:path+`
+        );
+        middlewares.push({
+          src: pattern,
+          fn: getHandler({
+            application,
+            pattern
+          })
+        });
+      }
+      for (const pathGroup of application.routing.matches) {
+        if (process.env.VERCEL_ENV === "preview" || ((_a = pathGroup.options) == null ? void 0 : _a.flag) || ((_b = pathGroup.options) == null ? void 0 : _b.routeToDefaultApplication)) {
+          const flagName = (_c = pathGroup.options) == null ? void 0 : _c.flag;
+          let flagFn;
+          if (flagName) {
+            flagFn = flagValues == null ? void 0 : flagValues[flagName];
+            if (!flagFn) {
+              throw new Error(
+                `Flag "${flagName}" was specified to control routing for path group "${pathGroup.group}" in application ${application.name} but not found in provided flag values.`
+              );
+            }
+          }
+          for (const path of pathGroup.paths) {
+            const pattern = (0, import_path_to_regexp.pathToRegexp)(path);
+            middlewares.push({
+              src: pattern,
+              fn: getHandler({
+                application,
+                flagFn,
+                pattern
+              })
+            });
+          }
+        }
+      }
+    }
+  }
+  return middlewares;
+}
+async function runMicroFrontendsMiddleware(request, flagValues) {
+  const pathname = request.nextUrl.pathname;
+  const middlewares = getMicroFrontendsMiddleware({
+    request,
+    flagValues
+  });
+  for (const mware of middlewares) {
+    if (typeof mware.src === "string" ? pathname === mware.src : mware.src.test(pathname)) {
+      const response = await mware.fn(request);
+      if (response) {
+        return response;
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMicroFrontendsMiddleware,
+  runMicroFrontendsMiddleware
+});
+//# sourceMappingURL=middleware.cjs.map