cdk-nextjs 0.7.12 → 0.7.14

package/lib/nextjs-distribution.js

@@ -10,8 +10,9 @@ const constructs_1 = require("constructs");
 const function_groups_1 = require("./adapter/function-groups");
 const constants_1 = require("./constants");
 const base_path_1 = require("./utils/base-path");
+const viewer_request_functions_1 = require("./utils/viewer-request-functions");
 class NextjsDistribution extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsDistribution", version: "0.7.12" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsDistribution", version: "0.7.14" };
     distribution;
     props;
     /**
@@ -54,6 +55,18 @@ class NextjsDistribution extends constructs_1.Construct {
     dynamicOrigin;
     dynamicOriginResponsePolicy;
     dynamicCloudFrontFunctionAssociations;
+    /**
+     * `viewerRequestFunctionCode`, rendered and checked once, since
+     * `FunctionCode.fromFile` reads the file on every render.
+     */
+    viewerRequestCode;
+    /**
+     * The viewer-request function `viewerRequestFunctionCode` adds to behaviors
+     * with no viewer-request logic of their own, shared by all of them, so the
+     * `assetPrefix` behavior, which has a viewer-request function of its own,
+     * can tell it from an override's.
+     */
+    passThroughFunction;
     isFunctionCompute;
     staticBehaviorOptions;
     dynamicBehaviorOptions;
@@ -61,6 +74,12 @@ class NextjsDistribution extends constructs_1.Construct {
     constructor(scope, id, props) {
         super(scope, id);
         this.props = props;
+        if (props.viewerRequestKeyValueStore && !props.viewerRequestFunctionCode) {
+            throw new Error(`${constants_1.LOG_PREFIX} \`viewerRequestKeyValueStore\` is only associated with ` +
+                `the functions \`viewerRequestFunctionCode\` runs in, so it needs ` +
+                `\`viewerRequestFunctionCode\` to read it.`);
+        }
+        this.viewerRequestCode = this.renderViewerRequestCode();
         this.basePath = (0, base_path_1.normalizeBasePath)(props.basePath);
         this.assetPrefix = this.resolveAssetPrefix();
         this.staticOrigin = this.createStaticOrigin();
@@ -144,78 +163,102 @@ class NextjsDistribution extends constructs_1.Construct {
         const associations = [];
         if (this.isFunctionCompute) {
             const cloudFrontFn = new aws_cloudfront_1.Function(this, "CloudFrontFn", {
-                // cloudfront-js-1.0, so ES5.1: `var`, no arrow functions, no template
-                // literals, no `Object.keys`.
-                code: aws_cloudfront_1.FunctionCode.fromInline(`
-          function handler(event) {
-            var request = event.request;
-            var uri = request.uri;
-
-            // Next.js answers any path containing a backslash or a repeated
-            // slash with a 308 to the collapsed path
-            // (\`normalizeRepeatedSlashes\`, called from \`base-server.ts\`), and so
-            // does this runtime. Behind a Lambda Function URL the origin never
-            // gets the chance: Origin Access Control signs the raw path while the
-            // Function URL canonicalizes it before verifying, so the origin
-            // answers 403 SignatureDoesNotMatch. Doing the redirect here is what
-            // makes \`/basepath//to-sv\` behave as it does under \`next start\`.
-            //
-            // A bare \`//\` reaches here too, and is answered the same way -
-            // measured, because \`//\` at the start of a request target is also the
-            // authority form and it was not obvious CloudFront would route it to a
-            // function at all. It does: \`GET //\` answers 308 to \`/\` with
-            // \`x-cache: FunctionGeneratedResponse\`, over both HTTP/1.1 and HTTP/2,
-            // which is what \`test/e2e/hydration\` asks for.
-            //
-            // Two things Next.js does that this cannot:
-            //
-            // - the body it sends with its own redirect (the destination, as
-            //   text), because a generated response can only carry one on
-            //   cloudfront-js-2.0. No known client reads it.
-            // - the original order of the query string. The event exposes
-            //   \`querystring\` as an object, never as the raw string, so
-            //   \`/x//y?a=1&b=2\` redirects to \`/x/y?b=2&a=1\`. The pairs all
-            //   survive; only their order is CloudFront's rather than the
-            //   client's, and a redirect target is not order-sensitive.
-            //
-            // A repeated key's \`multiValue\` already holds its first value, which
-            // \`value\` repeats, so it is one or the other, never both. Names and
-            // values arrive as the client sent them, still percent-encoded
-            // (measured: \`?a=%20b%26c&p=1+2\` reads back unchanged), so they are
-            // joined as-is; encoding them again would turn \`%20\` into \`%2520\`.
-            if (/\\\\|\\/\\//.test(uri)) {
-              var location = uri.replace(/\\\\/g, "/").replace(/\\/\\/+/g, "/");
-              var qs = [];
-              for (var name in request.querystring) {
-                var q = request.querystring[name];
-                var values = q.multiValue || [q];
-                for (var i = 0; i < values.length; i++) {
-                  var v = values[i].value;
-                  qs.push(v === "" ? name : name + "=" + v);
-                }
-              }
-              if (qs.length) {
-                location = location + "?" + qs.join("&");
-              }
-              return {
-                statusCode: 308,
-                statusDescription: "Permanent Redirect",
-                headers: { location: { value: location } },
-              };
-            }
-
-            request.headers["x-forwarded-host"] = request.headers.host;
-            return request;
-          }
-          `),
+                ...this.viewerRequestFunctionProps(viewer_request_functions_1.X_FORWARDED_HOST_HANDLER),
             });
             associations.push({
                 eventType: aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST,
                 function: cloudFrontFn,
             });
         }
+        else if (this.viewerRequestCode !== undefined) {
+            // Containers need no function of their own — their origin sees the
+            // viewer's `Host` — so this one only runs the user's code.
+            associations.push({
+                eventType: aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST,
+                function: this.getPassThroughFunction(),
+            });
+        }
         return associations;
     }
+    /**
+     * The function a behavior with no viewer-request logic of its own gets when
+     * `viewerRequestFunctionCode` is set, created on first use.
+     */
+    getPassThroughFunction() {
+        this.passThroughFunction ??= new aws_cloudfront_1.Function(this, "ViewerRequestFn", {
+            comment: this.getComment("NextJS viewer request", aws_cdk_lib_1.Stack.of(this).stackName),
+            ...this.viewerRequestFunctionProps(viewer_request_functions_1.PASS_THROUGH_HANDLER),
+        });
+        return this.passThroughFunction;
+    }
+    /**
+     * The code, runtime and KeyValueStore of a function whose `handler` is
+     * cdk-nextjs's, with `viewerRequestFunctionCode` spliced in
+     * ({@link spliceViewerRequest}) and checked against CloudFront's size limit.
+     *
+     * Every one runs on `cloudfront-js-2.0`, the runtime AWS recommends and the
+     * one with `async` and KeyValueStores, so the handlers are all `async`
+     * whether or not there is user code to await.
+     */
+    viewerRequestFunctionProps(handler) {
+        const userCode = this.viewerRequestCode;
+        const code = (0, viewer_request_functions_1.spliceViewerRequest)(handler, userCode);
+        if (userCode === undefined) {
+            return {
+                code: aws_cloudfront_1.FunctionCode.fromInline(code),
+                runtime: aws_cloudfront_1.FunctionRuntime.JS_2_0,
+            };
+        }
+        const size = Buffer.byteLength(code);
+        if (aws_cdk_lib_1.Token.isUnresolved(code)) {
+            // A token's placeholder isn't the length of what it resolves to.
+            aws_cdk_lib_1.Annotations.of(this).addWarning(`${constants_1.LOG_PREFIX} \`viewerRequestFunctionCode\` contains a CDK token, so ` +
+                `its size can't be checked against CloudFront's limit of ` +
+                `${viewer_request_functions_1.MAX_FUNCTION_CODE_BYTES} bytes until deploy.`);
+        }
+        else if (size > viewer_request_functions_1.MAX_FUNCTION_CODE_BYTES) {
+            throw new Error(`${constants_1.LOG_PREFIX} \`viewerRequestFunctionCode\` makes a CloudFront ` +
+                `Function of ${size} bytes, cdk-nextjs's own code included, over ` +
+                `CloudFront's limit of ${viewer_request_functions_1.MAX_FUNCTION_CODE_BYTES}. Shorten it ` +
+                `(comments and whitespace count). See ` +
+                `https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-functions`);
+        }
+        return {
+            code: aws_cloudfront_1.FunctionCode.fromInline(code),
+            runtime: aws_cloudfront_1.FunctionRuntime.JS_2_0,
+            keyValueStore: this.props.viewerRequestKeyValueStore,
+        };
+    }
+    /**
+     * `viewerRequestFunctionCode`, rendered once, since `FunctionCode.fromFile`
+     * reads the file on every render, and checked
+     * ({@link checkViewerRequestCode}).
+     */
+    renderViewerRequestCode() {
+        const userCode = this.props.viewerRequestFunctionCode?.render();
+        if (userCode === undefined) {
+            return undefined;
+        }
+        (0, viewer_request_functions_1.checkViewerRequestCode)(userCode);
+        return userCode;
+    }
+    /**
+     * CloudFront allows one function per event type per behavior, so an
+     * override's viewer-request association and one cdk-nextjs needs can't both
+     * be kept. Thrown at synth, where both halves are known, rather than left to
+     * a deploy that names neither.
+     */
+    assertViewerRequestUnclaimed(overrideName, associations, needs) {
+        const claimed = (associations ?? []).some((association) => association.eventType === aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST);
+        if (claimed) {
+            throw new Error(`${constants_1.LOG_PREFIX} \`overrides.${overrideName}.functionAssociations\` ` +
+                `associates a CloudFront function with ` +
+                `${aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST}, but ${needs}. ` +
+                `CloudFront permits only one function per event type per behavior. ` +
+                `Move the logic into \`viewerRequestFunctionCode\`, which runs ` +
+                `inside cdk-nextjs's own viewer-request function on every behavior.`);
+        }
+    }
     createStaticBehaviorOptions() {
         const staticBehaviorOptions = this.props.overrides?.staticBehaviorOptions;
         const responseHeadersPolicy = staticBehaviorOptions?.responseHeadersPolicy ??
@@ -224,7 +267,7 @@ class NextjsDistribution extends constructs_1.Construct {
                 comment: this.getComment("NextJS Static Response Headers Policy", aws_cdk_lib_1.Stack.of(this).stackName),
                 ...this.props.overrides?.staticResponseHeadersPolicyProps,
             });
-        return {
+        const options = {
             allowedMethods: aws_cloudfront_1.AllowedMethods.ALLOW_GET_HEAD_OPTIONS,
             cachedMethods: aws_cloudfront_1.CachedMethods.CACHE_GET_HEAD_OPTIONS,
             cachePolicy: aws_cloudfront_1.CachePolicy.CACHING_OPTIMIZED,
@@ -233,6 +276,20 @@ class NextjsDistribution extends constructs_1.Construct {
             viewerProtocolPolicy: aws_cloudfront_1.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
             ...staticBehaviorOptions,
         };
+        if (this.viewerRequestCode === undefined) {
+            return options;
+        }
+        this.assertViewerRequestUnclaimed("staticBehaviorOptions", staticBehaviorOptions?.functionAssociations, "`viewerRequestFunctionCode` needs that event type on the static behaviors");
+        return {
+            ...options,
+            functionAssociations: [
+                ...(staticBehaviorOptions?.functionAssociations ?? []),
+                {
+                    eventType: aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST,
+                    function: this.getPassThroughFunction(),
+                },
+            ],
+        };
     }
     createDynamicBehaviorOptions() {
         const dynamicBehaviorOptions = this.props.overrides?.dynamicBehaviorOptions;
@@ -271,7 +328,8 @@ class NextjsDistribution extends constructs_1.Construct {
     }
     /**
      * The behavior's function associations: an override's, plus the viewer-request
-     * function Global Functions depends on.
+     * function Global Functions depends on, or the one `viewerRequestFunctionCode`
+     * adds on Global Containers.
      *
      * Spreading the override's `functionAssociations` over ours would silently
      * drop that function, and with it the only thing standing between a viewer's
@@ -282,25 +340,21 @@ class NextjsDistribution extends constructs_1.Construct {
      * allows only one of per behavior — is an error rather than a replacement.
      */
     withDynamicFunctionAssociations(overrideName, overridden) {
+        const ours = this.dynamicCloudFrontFunctionAssociations;
         if (!overridden) {
-            return this.dynamicCloudFrontFunctionAssociations;
+            return ours;
         }
-        if (!this.isFunctionCompute) {
+        if (!ours.length) {
             return overridden;
         }
-        const claimed = overridden.some((association) => association.eventType === aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST);
-        if (claimed) {
-            throw new Error(`${constants_1.LOG_PREFIX} \`overrides.${overrideName}.functionAssociations\` ` +
-                `associates a CloudFront function with ` +
-                `${aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST}, but NextjsGlobalFunctions needs ` +
-                `that event type for its own function, which overwrites ` +
-                `\`x-forwarded-host\` with the viewer's \`Host\` (the runtime trusts ` +
-                `that header behind CloudFront) and redirects repeated slashes. ` +
-                `CloudFront permits only one function per event type per behavior. ` +
-                `Move the logic to ${aws_cloudfront_1.FunctionEventType.VIEWER_RESPONSE}, or into ` +
-                `the app's middleware.`);
-        }
-        return [...overridden, ...this.dynamicCloudFrontFunctionAssociations];
+        this.assertViewerRequestUnclaimed(overrideName, overridden, this.isFunctionCompute
+            ? `NextjsGlobalFunctions needs that event type for its own function, ` +
+                `which overwrites \`x-forwarded-host\` with the viewer's \`Host\` ` +
+                `(the runtime trusts that header behind CloudFront) and redirects ` +
+                `repeated slashes`
+            : "`viewerRequestFunctionCode` needs that event type on the dynamic " +
+                "and image behaviors");
+        return [...overridden, ...ours];
     }
     /**
      * `_next/image*` goes to the same origin as everything else — the Next.js
@@ -353,6 +407,17 @@ class NextjsDistribution extends constructs_1.Construct {
             distribution = this.props.distribution;
         }
         else {
+            // Under a `basePath`, the behaviors cdk-nextjs adds for it serve the
+            // app, so the default behavior is the user's to replace.
+            if (this.viewerRequestCode !== undefined &&
+                !this.basePath &&
+                this.props.overrides?.distributionProps?.defaultBehavior) {
+                throw new Error(`${constants_1.LOG_PREFIX} \`overrides.distributionProps.defaultBehavior\` ` +
+                    `replaces the default behavior cdk-nextjs builds, and with it the ` +
+                    `viewer-request function \`viewerRequestFunctionCode\` runs in, ` +
+                    `so pages and API routes would skip it. Customize the default ` +
+                    `behavior through \`overrides.dynamicBehaviorOptions\` instead.`);
+            }
             distribution = new aws_cloudfront_1.Distribution(this, "Distribution", {
                 minimumProtocolVersion: aws_cloudfront_1.SecurityPolicyProtocol.TLS_V1_2_2021,
                 defaultBehavior: this.dynamicBehaviorOptions,
@@ -488,41 +553,79 @@ class NextjsDistribution extends constructs_1.Construct {
      * parse.
      */
     addAssetPrefixBehavior() {
-        // CloudFront allows one function per event type per behavior, so an override
-        // that already claims VIEWER_REQUEST on the static behavior cannot coexist
-        // with the rewrite below — the distribution would synth and then be rejected
-        // at deploy, naming neither. Thrown here instead, where both halves are
-        // known.
-        const claimed = (this.staticBehaviorOptions.functionAssociations ?? []).some((association) => association.eventType === aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST);
-        if (claimed) {
-            throw new Error(`${constants_1.LOG_PREFIX} \`overrides.staticBehaviorOptions.functionAssociations\` ` +
-                `already associates a CloudFront function with ` +
-                `${aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST}, but serving \`assetPrefix\` ` +
-                `("${this.assetPrefix}") needs that event type to rewrite the request ` +
-                `URI to the object's key, and CloudFront permits only one function per ` +
-                `event type per behavior. Either drop the override, or fold its logic ` +
-                `into a single function and set \`assetPrefix\` to "" so this ` +
-                `construct adds no behavior of its own.`);
-        }
+        // The static behaviors' own viewer-request function, when
+        // `viewerRequestFunctionCode` added one, gives way to the rewrite, which
+        // runs the same code first.
+        const associations = (this.staticBehaviorOptions.functionAssociations ?? []).filter((association) => association.function !== this.passThroughFunction);
+        this.assertViewerRequestUnclaimed("staticBehaviorOptions", associations, `serving \`assetPrefix\` ("${this.assetPrefix}") needs that event type ` +
+            `to rewrite the request URI to the object's key`);
         const rewrite = new aws_cloudfront_1.Function(this, "AssetPrefixFn", {
             comment: this.getComment("NextJS assetPrefix rewrite", aws_cdk_lib_1.Stack.of(this).stackName),
-            code: aws_cloudfront_1.FunctionCode.fromInline(`
-        function handler(event) {
-          var request = event.request;
-          request.uri = ${JSON.stringify(this.basePath ? `/${this.basePath}` : "")} + request.uri.slice(${this.assetPrefix.length});
-          return request;
-        }
-        `),
+            ...this.viewerRequestFunctionProps((0, viewer_request_functions_1.assetPrefixRewriteHandler)(this.basePath, this.assetPrefix)),
         });
         this.distribution.addBehavior(`${this.assetPrefix}/_next/static*`, this.staticOrigin, {
             ...this.staticBehaviorOptions,
             functionAssociations: [
-                ...(this.staticBehaviorOptions.functionAssociations ?? []),
+                ...associations,
                 { eventType: aws_cloudfront_1.FunctionEventType.VIEWER_REQUEST, function: rewrite },
             ],
         });
     }
+    /**
+     * Serves `_next/static/service-worker/*` with `Service-Worker-Allowed`, which
+     * the browser requires before it registers a service worker at a scope above
+     * the script's own directory. Added ahead of `_next/static*`, which would
+     * otherwise match first.
+     *
+     * The policy is the static one plus the header, so security headers and any
+     * `staticResponseHeadersPolicyProps` still apply. A whole
+     * `staticBehaviorOptions.responseHeadersPolicy` can't be added to, so it is
+     * used as it is, with a warning.
+     */
+    addServiceWorkerBehavior(serviceWorkerAllowed) {
+        const overridden = this.props.overrides?.staticBehaviorOptions?.responseHeadersPolicy;
+        if (overridden) {
+            aws_cdk_lib_1.Annotations.of(this).addWarning(`${constants_1.LOG_PREFIX} \`overrides.staticBehaviorOptions.responseHeadersPolicy\` ` +
+                `is used for \`_next/static/service-worker/*\` too, so service ` +
+                `workers get no \`Service-Worker-Allowed: ${serviceWorkerAllowed}\` ` +
+                `unless that policy sends it, and registering one at a scope above ` +
+                `its own directory fails. Add the header to your policy, or set ` +
+                `\`overrides.staticResponseHeadersPolicyProps\` instead.`);
+        }
+        const props = this.props.overrides?.staticResponseHeadersPolicyProps;
+        const customHeaders = props?.customHeadersBehavior?.customHeaders ?? [];
+        const responseHeadersPolicy = overridden ??
+            new aws_cloudfront_1.ResponseHeadersPolicy(this, "ServiceWorkerResponseHeadersPolicy", {
+                securityHeadersBehavior: this.commonSecurityHeadersBehavior,
+                comment: this.getComment("NextJS Service Worker Response Headers Policy", aws_cdk_lib_1.Stack.of(this).stackName),
+                ...props,
+                // Policy names are unique per account, so the static policy's can't be
+                // reused as it is, and are at most 128 characters, so a suffix can't
+                // simply be added to one that is already that long.
+                responseHeadersPolicyName: props?.responseHeadersPolicyName &&
+                    `${aws_cdk_lib_1.Token.isUnresolved(props.responseHeadersPolicyName)
+                        ? props.responseHeadersPolicyName
+                        : props.responseHeadersPolicyName.slice(0, MAX_POLICY_NAME_LENGTH - SERVICE_WORKER_SUFFIX.length)}${SERVICE_WORKER_SUFFIX}`,
+                customHeadersBehavior: {
+                    // One the override sets itself is kept.
+                    customHeaders: customHeaders.some(({ header }) => header.toLowerCase() === "service-worker-allowed")
+                        ? customHeaders
+                        : [
+                            ...customHeaders,
+                            {
+                                header: "Service-Worker-Allowed",
+                                value: serviceWorkerAllowed,
+                                override: true,
+                            },
+                        ],
+                },
+            });
+        this.distribution.addBehavior(this.getPathPattern("_next/static/service-worker/*"), this.staticOrigin, { ...this.staticBehaviorOptions, responseHeadersPolicy });
+    }
     addStaticBehaviors() {
+        if (this.props.serviceWorkerAllowed !== undefined) {
+            this.addServiceWorkerBehavior(this.props.serviceWorkerAllowed);
+        }
         this.distribution.addBehavior(this.getPathPattern("_next/static*"), this.staticOrigin, this.staticBehaviorOptions);
         if (this.assetPrefix) {
             this.addAssetPrefixBehavior();
@@ -641,11 +744,15 @@ class NextjsDistribution extends constructs_1.Construct {
         const groupPatterns = this.functionGroupBehaviors().length;
         // The default behavior, `_next/image*`, `_next/static*`, plus — with a
         // basePath — the two that stand in for the default behavior's coverage, and
-        // — with a path-style assetPrefix — the one that serves bundles under it.
+        // — with a path-style assetPrefix — the one that serves bundles under it,
+        // and — with service workers — the one that adds `Service-Worker-Allowed`.
         // `this.basePath`, not the raw prop: `basePath: "/"` normalizes to `""` and
         // adds no behaviors, so counting it added 2 to the total and could throw
         // "over the limit" on an app that is under it.
-        const fixed = 3 + (this.basePath ? 2 : 0) + (this.assetPrefix ? 1 : 0);
+        const fixed = 3 +
+            (this.basePath ? 2 : 0) +
+            (this.assetPrefix ? 1 : 0) +
+            (this.props.serviceWorkerAllowed !== undefined ? 1 : 0);
         const total = fixed + publicPatterns + groupPatterns;
         if (total <= limit) {
             return;
@@ -762,6 +869,13 @@ const DEFAULT_MAX_CACHE_BEHAVIORS = 75;
 function isPathPatternChar(char) {
     return char === "*" || char === "?" || function_groups_1.PATH_PATTERN_LITERAL.test(char);
 }
+/**
+ * CloudFront's limit on a response headers policy name, and the suffix that
+ * tells the service worker policy's apart from the static one's.
+ * @see https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ResponseHeadersPolicyConfig.html
+ */
+const MAX_POLICY_NAME_LENGTH = 128;
+const SERVICE_WORKER_SUFFIX = "-sw";
 /** CloudFront's path pattern length limit. */
 const MAX_PATH_PATTERN_LENGTH = 255;
 /**
@@ -789,4 +903,4 @@ function toPathPattern(name) {
         : "?".repeat(Buffer.byteLength(char, "utf8")))
         .join("");
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-distribution.js","sourceRoot":"","sources":["../src/nextjs-distribution.ts"],"names":[],"mappings":"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","sourcesContent":["import { Annotations, Duration, Stack, Token } from \"aws-cdk-lib\";\nimport { ICertificate } from \"aws-cdk-lib/aws-certificatemanager\";\nimport {\n  AccessLevel,\n  AddBehaviorOptions,\n  AllowedMethods,\n  BehaviorOptions,\n  CacheCookieBehavior,\n  CacheHeaderBehavior,\n  CachePolicy,\n  CachePolicyProps,\n  CacheQueryStringBehavior,\n  CachedMethods,\n  Function as CloudFrontFunction,\n  Distribution,\n  FunctionAssociation,\n  FunctionCode,\n  FunctionEventType,\n  HeadersFrameOption,\n  HeadersReferrerPolicy,\n  HttpVersion,\n  IOrigin,\n  IOriginRequestPolicy,\n  OriginProtocolPolicy,\n  OriginRequestPolicy,\n  ResponseHeadersPolicy,\n  ResponseHeadersPolicyProps,\n  ResponseSecurityHeadersBehavior,\n  SecurityPolicyProtocol,\n  ViewerProtocolPolicy,\n} from \"aws-cdk-lib/aws-cloudfront\";\nimport {\n  FunctionUrlOrigin,\n  FunctionUrlOriginWithOACProps,\n  S3BucketOrigin,\n  VpcOrigin,\n  VpcOriginWithEndpointProps,\n} from \"aws-cdk-lib/aws-cloudfront-origins\";\nimport { IApplicationLoadBalancer } from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport { CfnPermission, IFunctionUrl } from \"aws-cdk-lib/aws-lambda\";\nimport { IBucket } from \"aws-cdk-lib/aws-s3\";\nimport { Construct } from \"constructs\";\nimport {\n  cloudFrontPatternRegex,\n  DEFAULT_FUNCTION_GROUP,\n  PATH_PATTERN_LITERAL,\n} from \"./adapter/function-groups\";\nimport { LOG_PREFIX, NextjsType } from \"./constants\";\nimport { OptionalDistributionProps } from \"./generated-structs/OptionalDistributionProps\";\nimport { OptionalS3OriginBucketWithOACProps } from \"./generated-structs/OptionalS3OriginBucketWithOACProps\";\nimport {\n  NextjsFunctionGroupBehavior,\n  PublicDirEntry,\n} from \"./nextjs-build/nextjs-build\";\nimport { assetPrefixPath, normalizeBasePath } from \"./utils/base-path\";\n\nexport interface NextjsDistributionOverrides {\n  readonly distributionProps?: OptionalDistributionProps;\n  readonly imageBehaviorOptions?: AddBehaviorOptions;\n  readonly imageCachePolicyProps?: CachePolicyProps;\n  readonly imageResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;\n  readonly dynamicBehaviorOptions?: AddBehaviorOptions;\n  readonly dynamicCachePolicyProps?: CachePolicyProps;\n  readonly dynamicResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;\n  readonly dynamicFunctionUrlOriginWithOACProps?: FunctionUrlOriginWithOACProps;\n  readonly dynamicVpcOriginWithEndpointProps?: VpcOriginWithEndpointProps;\n  readonly staticBehaviorOptions?: AddBehaviorOptions;\n  readonly staticResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;\n  readonly s3BucketOriginProps?: OptionalS3OriginBucketWithOACProps;\n}\n\nexport interface NextjsDistributionProps {\n  /**\n   * Bucket containing static assets.\n   * Must be provided if you want to serve static files.\n   */\n  readonly assetsBucket: IBucket;\n  /**\n   * The app's own `assetPrefix`. Next.js emits `<assetPrefix>/_next/static/...`\n   * for every bundle while the objects stay at `<basePath>/_next/static/...` in\n   * S3, so the prefix's path gets a cache behavior of its own that rewrites it\n   * away.\n   *\n   * Either form is accepted: a path (\"/cdn\"), or an absolute URL, in which case\n   * only its path counts (\"https://cdn.example.com/cdn\" behaves as \"/cdn\", and\n   * \"https://cdn.example.com\" needs no behavior at all). An absolute prefix's path\n   * matters because `next build` compiles a `/cdn/_next/:path+` rewrite of its\n   * own, so `next start` serves every bundle under it — a CDN fronting this\n   * distribution there has to be answered too.\n   *\n   * Applied on top of `basePath`, not under it, because that is how Next.js\n   * builds the URL.\n   *\n   * @default - none; pass `NextjsBuild.nextConfigAssetPrefixPath`\n   */\n  readonly assetPrefix?: string;\n  /**\n   * URI path prefix the app is served at. Surrounding slashes are normalized\n   * away, so \"/base\", \"base\" and \"/base/\" all produce the same cache behaviors.\n   */\n  readonly basePath?: string;\n  /**\n   * Optional but only applicable for `NextjsType.GLOBAL_CONTAINERS`\n   */\n  readonly certificate?: ICertificate;\n  readonly distribution?: Distribution;\n  /**\n   * Required if `NextjsType.GLOBAL_FUNCTIONS`\n   */\n  readonly functionUrl?: IFunctionUrl;\n  /**\n   * Required if `NextjsType.GLOBAL_CONTAINERS` or `NextjsType.REGIONAL_CONTAINERS`\n   */\n  readonly loadBalancer?: IApplicationLoadBalancer;\n  readonly nextjsType: NextjsType;\n  /**\n   * Override props for every construct.\n   */\n  readonly overrides?: NextjsDistributionOverrides;\n  /**\n   * Entries (files/directories) within Next.js app's public directory. Used to\n   * add static behaviors to distribution.\n   */\n  readonly publicDirEntries: PublicDirEntry[];\n  /**\n   * The non-`default` function groups, the origins\n   * {@link functionGroupBehaviors} route to.\n   * @default - no splitting; the default behavior serves every dynamic route\n   */\n  readonly functionGroups?: NextjsDistributionFunctionGroup[];\n  /**\n   * `NextjsBuild.functionGroupBehaviors`: one cache behavior each, added in\n   * order, so the routes each group was packaged with reach it rather than the\n   * default function.\n   * @default - none\n   */\n  readonly functionGroupBehaviors?: NextjsFunctionGroupBehavior[];\n  /**\n   * The most cache behaviors the distribution may have, the default one\n   * included. cdk-nextjs counts what it adds against this at synth, so running\n   * out is a synth error naming what used them rather than a failed deploy.\n   *\n   * Raise it after raising the \"Cache behaviors per distribution\" quota for\n   * your account. Lower it by the behaviors a supplied {@link distribution}\n   * (or `overrides.distributionProps`) already has, which are not counted.\n   * @default 75 - CloudFront's default quota\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions\n   */\n  readonly maxCacheBehaviors?: number;\n}\n\n/** A non-default function group and the origin its routes must reach. */\nexport interface NextjsDistributionFunctionGroup {\n  readonly name: string;\n  /** The group's Lambda Function URL. */\n  readonly functionUrl: IFunctionUrl;\n}\n\nexport class NextjsDistribution extends Construct {\n  distribution: Distribution;\n\n  private props: NextjsDistributionProps;\n  /**\n   * `props.basePath` normalized to a bare path segment. This construct is the\n   * one place that needs it with a leading slash — CloudFront path patterns are\n   * written against the request path — so it prepends its own rather than\n   * relying on the caller having passed one.\n   */\n  private basePath: string;\n  /**\n   * `props.assetPrefix` normalized to a leading-slash path, `\"\"` when the app\n   * sets none or sets one that already equals the `basePath` prefix — in which\n   * case the ordinary `_next/static*` behavior already covers it and a second one\n   * would be a duplicate pattern CloudFront rejects.\n   */\n  private assetPrefix: string;\n  /**\n   * Common security headers applied by default to all origins\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-response-headers-policies.html#managed-response-headers-policies-security\n   */\n  private commonSecurityHeadersBehavior: ResponseSecurityHeadersBehavior = {\n    contentTypeOptions: { override: false },\n    frameOptions: {\n      frameOption: HeadersFrameOption.SAMEORIGIN,\n      override: false,\n    },\n    referrerPolicy: {\n      override: false,\n      referrerPolicy: HeadersReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN,\n    },\n\n    strictTransportSecurity: {\n      accessControlMaxAge: Duration.days(365),\n      includeSubdomains: true,\n      override: false,\n      preload: true,\n    },\n    xssProtection: { override: false, protection: true, modeBlock: true },\n  };\n  private staticOrigin: IOrigin;\n  private dynamicOrigin: IOrigin;\n  private dynamicOriginResponsePolicy: IOriginRequestPolicy;\n  private dynamicCloudFrontFunctionAssociations: FunctionAssociation[];\n  private isFunctionCompute: boolean;\n  private staticBehaviorOptions: BehaviorOptions;\n  private dynamicBehaviorOptions: BehaviorOptions;\n  private imageBehaviorOptions: BehaviorOptions;\n\n  constructor(scope: Construct, id: string, props: NextjsDistributionProps) {\n    super(scope, id);\n    this.props = props;\n    this.basePath = normalizeBasePath(props.basePath);\n    this.assetPrefix = this.resolveAssetPrefix();\n    this.staticOrigin = this.createStaticOrigin();\n    this.isFunctionCompute = props.nextjsType === NextjsType.GLOBAL_FUNCTIONS;\n    this.validateFunctionGroupProps();\n    this.dynamicOrigin = this.createDynamicOrigin();\n    this.dynamicOriginResponsePolicy = this.createDynamicOriginRequestPolicy();\n    this.dynamicCloudFrontFunctionAssociations =\n      this.createDynamicCloudFrontFunctionAssociations();\n    this.staticBehaviorOptions = this.createStaticBehaviorOptions();\n    this.dynamicBehaviorOptions = this.createDynamicBehaviorOptions();\n    this.imageBehaviorOptions = this.createImageBehaviorOptions();\n    this.distribution = this.getDistribution();\n    if (this.isFunctionCompute) {\n      this.grantInvoke(DEFAULT_FUNCTION_GROUP, props.functionUrl!);\n    }\n    this.addStaticBehaviors();\n    this.addDynamicBehaviors();\n  }\n\n  /**\n   * Creates a CloudFront comment that is safe for the 128 character limit.\n   * If the full comment with stack name exceeds 128 characters, returns the base comment only.\n   * @param baseComment The base comment text\n   * @param stackName The stack name to append\n   * @returns A comment string that is guaranteed to be < 128 characters\n   */\n  private getComment(baseComment: string, stackName: string): string {\n    const fullComment = `${baseComment} for ${stackName}`;\n    return fullComment.length < 128 ? fullComment : baseComment;\n  }\n\n  private createStaticOrigin(): IOrigin {\n    return S3BucketOrigin.withOriginAccessControl(this.props.assetsBucket, {\n      // LIST lets S3 answer a missing key with 404 instead of 403\n      originAccessLevels: [AccessLevel.READ, AccessLevel.LIST],\n      ...this.props.overrides?.s3BucketOriginProps,\n    });\n  }\n  private createDynamicOrigin(): IOrigin {\n    if (this.isFunctionCompute) {\n      if (!this.props.functionUrl) {\n        throw new Error(\"Missing NextjsDistributionProps.functionUrl\");\n      }\n      return FunctionUrlOrigin.withOriginAccessControl(\n        this.props.functionUrl,\n        this.props.overrides?.dynamicFunctionUrlOriginWithOACProps,\n      );\n    } else {\n      const loadBalancer = this.props.loadBalancer;\n      if (!loadBalancer) {\n        throw new Error(\"Missing NextjsDistributionProps.loadBalancer\");\n      }\n      return VpcOrigin.withApplicationLoadBalancer(loadBalancer, {\n        protocolPolicy: this.props.certificate\n          ? OriginProtocolPolicy.HTTPS_ONLY\n          : OriginProtocolPolicy.HTTP_ONLY,\n        ...this.props.overrides?.dynamicVpcOriginWithEndpointProps,\n      });\n    }\n  }\n  /**\n   * Lambda Function URLs \"expect the `Host` header to contain the origin domain\n   * name, not the domain name of the CloudFront distribution.\"\n   *\n   * A container origin also gets CloudFront's own headers, for\n   * `CloudFront-Forwarded-Proto`: without a certificate CloudFront reaches the\n   * ALB over plain HTTP, so the ALB's `X-Forwarded-Proto` is `http`, and the\n   * runtime would build every absolute URL (`request.url`, the origin a server\n   * action is forwarded to) as `http://` behind a viewer on HTTPS.\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html#managed-origin-request-policy-all-viewer-except-host-header\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html#managed-origin-request-policy-all-viewer-and-cloudfront\n   */\n  private createDynamicOriginRequestPolicy(): IOriginRequestPolicy {\n    return this.isFunctionCompute\n      ? OriginRequestPolicy.ALL_VIEWER_EXCEPT_HOST_HEADER\n      : OriginRequestPolicy.ALL_VIEWER_AND_CLOUDFRONT_2022;\n  }\n  /**\n   * Ensures Next.js `request.url` will be correct domain instead of URL of\n   * compute (Lambda or Fargate)\n   * @see https://open-next.js.org/advanced/workaround#workaround-set-x-forwarded-host-header-aws-specific\n   */\n  private createDynamicCloudFrontFunctionAssociations(): FunctionAssociation[] {\n    const associations: FunctionAssociation[] = [];\n    if (this.isFunctionCompute) {\n      const cloudFrontFn = new CloudFrontFunction(this, \"CloudFrontFn\", {\n        // cloudfront-js-1.0, so ES5.1: `var`, no arrow functions, no template\n        // literals, no `Object.keys`.\n        code: FunctionCode.fromInline(`\n          function handler(event) {\n            var request = event.request;\n            var uri = request.uri;\n\n            // Next.js answers any path containing a backslash or a repeated\n            // slash with a 308 to the collapsed path\n            // (\\`normalizeRepeatedSlashes\\`, called from \\`base-server.ts\\`), and so\n            // does this runtime. Behind a Lambda Function URL the origin never\n            // gets the chance: Origin Access Control signs the raw path while the\n            // Function URL canonicalizes it before verifying, so the origin\n            // answers 403 SignatureDoesNotMatch. Doing the redirect here is what\n            // makes \\`/basepath//to-sv\\` behave as it does under \\`next start\\`.\n            //\n            // A bare \\`//\\` reaches here too, and is answered the same way -\n            // measured, because \\`//\\` at the start of a request target is also the\n            // authority form and it was not obvious CloudFront would route it to a\n            // function at all. It does: \\`GET //\\` answers 308 to \\`/\\` with\n            // \\`x-cache: FunctionGeneratedResponse\\`, over both HTTP/1.1 and HTTP/2,\n            // which is what \\`test/e2e/hydration\\` asks for.\n            //\n            // Two things Next.js does that this cannot:\n            //\n            // - the body it sends with its own redirect (the destination, as\n            //   text), because a generated response can only carry one on\n            //   cloudfront-js-2.0. No known client reads it.\n            // - the original order of the query string. The event exposes\n            //   \\`querystring\\` as an object, never as the raw string, so\n            //   \\`/x//y?a=1&b=2\\` redirects to \\`/x/y?b=2&a=1\\`. The pairs all\n            //   survive; only their order is CloudFront's rather than the\n            //   client's, and a redirect target is not order-sensitive.\n            //\n            // A repeated key's \\`multiValue\\` already holds its first value, which\n            // \\`value\\` repeats, so it is one or the other, never both. Names and\n            // values arrive as the client sent them, still percent-encoded\n            // (measured: \\`?a=%20b%26c&p=1+2\\` reads back unchanged), so they are\n            // joined as-is; encoding them again would turn \\`%20\\` into \\`%2520\\`.\n            if (/\\\\\\\\|\\\\/\\\\//.test(uri)) {\n              var location = uri.replace(/\\\\\\\\/g, \"/\").replace(/\\\\/\\\\/+/g, \"/\");\n              var qs = [];\n              for (var name in request.querystring) {\n                var q = request.querystring[name];\n                var values = q.multiValue || [q];\n                for (var i = 0; i < values.length; i++) {\n                  var v = values[i].value;\n                  qs.push(v === \"\" ? name : name + \"=\" + v);\n                }\n              }\n              if (qs.length) {\n                location = location + \"?\" + qs.join(\"&\");\n              }\n              return {\n                statusCode: 308,\n                statusDescription: \"Permanent Redirect\",\n                headers: { location: { value: location } },\n              };\n            }\n\n            request.headers[\"x-forwarded-host\"] = request.headers.host;\n            return request;\n          }\n          `),\n      });\n      associations.push({\n        eventType: FunctionEventType.VIEWER_REQUEST,\n        function: cloudFrontFn,\n      });\n    }\n    return associations;\n  }\n  private createStaticBehaviorOptions(): BehaviorOptions {\n    const staticBehaviorOptions = this.props.overrides?.staticBehaviorOptions;\n    const responseHeadersPolicy =\n      staticBehaviorOptions?.responseHeadersPolicy ??\n      new ResponseHeadersPolicy(this, \"StaticResponseHeadersPolicy\", {\n        securityHeadersBehavior: this.commonSecurityHeadersBehavior,\n        comment: this.getComment(\n          \"NextJS Static Response Headers Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.staticResponseHeadersPolicyProps,\n      });\n    return {\n      allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,\n      cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,\n      cachePolicy: CachePolicy.CACHING_OPTIMIZED,\n      origin: this.staticOrigin,\n      responseHeadersPolicy,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      ...staticBehaviorOptions,\n    };\n  }\n  private createDynamicBehaviorOptions(): BehaviorOptions {\n    const dynamicBehaviorOptions = this.props.overrides?.dynamicBehaviorOptions;\n    const cachePolicyProps = this.props.overrides?.dynamicCachePolicyProps;\n    // create default cache policy if not provided\n    const cachePolicy =\n      dynamicBehaviorOptions?.cachePolicy ??\n      new CachePolicy(this, \"DynamicCachePolicy\", {\n        ...(isCachingDisabled(cachePolicyProps)\n          ? DISABLED_CACHE_KEY\n          : DYNAMIC_CACHE_KEY),\n        // A response with no `Cache-Control` is not cached, which is what Next.js\n        // and every app written for it assume: a dynamic route handler sets none.\n        // CDK's default is a day, which cached `/api/*` responses at the edge for\n        // 24 hours. Anything Next.js *means* to cache - ISR, SSG, a PPR shell -\n        // says so with `s-maxage`, which `maxTtl` still honors.\n        defaultTtl: Duration.seconds(0),\n        comment: this.getComment(\n          \"NextJS Dynamic Cache Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...cachePolicyProps,\n      });\n    const responseHeadersPolicy =\n      dynamicBehaviorOptions?.responseHeadersPolicy ??\n      new ResponseHeadersPolicy(this, \"DynamicResponseHeadersPolicy\", {\n        securityHeadersBehavior: this.commonSecurityHeadersBehavior,\n        comment: this.getComment(\n          \"NextJS Dynamic Response Headers Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.dynamicResponseHeadersPolicyProps,\n      });\n    return {\n      allowedMethods: AllowedMethods.ALLOW_ALL,\n      cachePolicy,\n      origin: this.dynamicOrigin,\n      originRequestPolicy: this.dynamicOriginResponsePolicy,\n      responseHeadersPolicy,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      ...dynamicBehaviorOptions,\n      functionAssociations: this.withDynamicFunctionAssociations(\n        \"dynamicBehaviorOptions\",\n        dynamicBehaviorOptions?.functionAssociations,\n      ),\n    };\n  }\n  /**\n   * The behavior's function associations: an override's, plus the viewer-request\n   * function Global Functions depends on.\n   *\n   * Spreading the override's `functionAssociations` over ours would silently\n   * drop that function, and with it the only thing standing between a viewer's\n   * own `X-Forwarded-Host` and the runtime, which trusts that header on Function\n   * URL events (`lambda-event.ts`): host injection into redirects and absolute\n   * URLs, cached for other viewers because the header is not in the cache key.\n   * So ours is kept, and an override claiming VIEWER_REQUEST — which CloudFront\n   * allows only one of per behavior — is an error rather than a replacement.\n   */\n  private withDynamicFunctionAssociations(\n    overrideName: string,\n    overridden: FunctionAssociation[] | undefined,\n  ): FunctionAssociation[] {\n    if (!overridden) {\n      return this.dynamicCloudFrontFunctionAssociations;\n    }\n    if (!this.isFunctionCompute) {\n      return overridden;\n    }\n    const claimed = overridden.some(\n      (association) =>\n        association.eventType === FunctionEventType.VIEWER_REQUEST,\n    );\n    if (claimed) {\n      throw new Error(\n        `${LOG_PREFIX} \\`overrides.${overrideName}.functionAssociations\\` ` +\n          `associates a CloudFront function with ` +\n          `${FunctionEventType.VIEWER_REQUEST}, but NextjsGlobalFunctions needs ` +\n          `that event type for its own function, which overwrites ` +\n          `\\`x-forwarded-host\\` with the viewer's \\`Host\\` (the runtime trusts ` +\n          `that header behind CloudFront) and redirects repeated slashes. ` +\n          `CloudFront permits only one function per event type per behavior. ` +\n          `Move the logic to ${FunctionEventType.VIEWER_RESPONSE}, or into ` +\n          `the app's middleware.`,\n      );\n    }\n    return [...overridden, ...this.dynamicCloudFrontFunctionAssociations];\n  }\n  /**\n   * `_next/image*` goes to the same origin as everything else — the Next.js\n   * server optimizes images in-process — but keeps its own behavior for the\n   * cache policy: `queryStringBehavior: all()` plus `accept` in the cache key is\n   * right for image requests and wrong for the rest.\n   */\n  private createImageBehaviorOptions(): BehaviorOptions {\n    const imageBehaviorOptions = this.props.overrides?.imageBehaviorOptions;\n    // add default cache policy if not provided\n    const cachePolicy =\n      imageBehaviorOptions?.cachePolicy ??\n      new CachePolicy(this, \"ImageCachePolicy\", {\n        // SECURITY NOTE: by default we don't include cookies in cache for\n        // images b/c it significantly improves image perf for most sites BUT\n        // if you have private images locked behind auth implemented with cookies\n        // you need to override this.\n        queryStringBehavior: CacheQueryStringBehavior.all(),\n        headerBehavior: CacheHeaderBehavior.allowList(\"accept\"),\n        cookieBehavior: CacheCookieBehavior.none(),\n        enableAcceptEncodingBrotli: true,\n        enableAcceptEncodingGzip: true,\n        comment: this.getComment(\n          \"NextJS Image Cache Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.imageCachePolicyProps,\n      });\n    // add default response headers policy if not provided\n    const responseHeadersPolicy =\n      imageBehaviorOptions?.responseHeadersPolicy ??\n      new ResponseHeadersPolicy(this, \"ImageResponseHeadersPolicy\", {\n        securityHeadersBehavior: this.commonSecurityHeadersBehavior,\n        comment: this.getComment(\n          \"NextJS Image Response Headers Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.imageResponseHeadersPolicyProps,\n      });\n    return {\n      allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,\n      cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,\n      origin: this.dynamicOrigin,\n      originRequestPolicy: this.dynamicOriginResponsePolicy,\n      cachePolicy,\n      responseHeadersPolicy,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      ...imageBehaviorOptions,\n      functionAssociations: this.withDynamicFunctionAssociations(\n        \"imageBehaviorOptions\",\n        imageBehaviorOptions?.functionAssociations,\n      ),\n    };\n  }\n  /**\n   * Creates or uses user specified CloudFront Distribution\n   */\n  private getDistribution(): Distribution {\n    let distribution: Distribution;\n    if (this.props.distribution) {\n      distribution = this.props.distribution;\n    } else {\n      distribution = new Distribution(this, \"Distribution\", {\n        minimumProtocolVersion: SecurityPolicyProtocol.TLS_V1_2_2021,\n        defaultBehavior: this.dynamicBehaviorOptions,\n        // best to use HTTP 2 and 3 for compatability (HTTP 2) and performance (HTTP3)\n        // CloudFront will choose best option for client\n        httpVersion: HttpVersion.HTTP2_AND_3,\n        comment: this.getComment(\n          \"NextJS Distribution\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.distributionProps,\n      });\n    }\n    return distribution;\n  }\n  private addDynamicBehaviors() {\n    // Image Behavior\n    this.distribution.addBehavior(\n      this.getPathPattern(\"_next/image*\"),\n      this.imageBehaviorOptions.origin,\n      this.imageBehaviorOptions,\n    );\n    // Function group behaviors, before the basePath catch-all below and after\n    // `_next/image*` (no group pattern can match an image request, and keeping\n    // the order of the unsplit case byte-identical is worth more than symmetry).\n    this.addFunctionGroupBehaviors();\n    // Root Path Behaviors\n    if (this.basePath) {\n      // because we already have a basePath we don't use / instead we use /base-path\n      this.distribution.addBehavior(\n        `/${this.basePath}`,\n        this.dynamicBehaviorOptions.origin,\n        this.dynamicBehaviorOptions,\n      );\n      // when basePath is set, we emulate the \"default behavior\" (*) for the site as `/base-path/*`\n      this.distribution.addBehavior(\n        this.getPathPattern(\"*\"),\n        this.dynamicBehaviorOptions.origin,\n        this.dynamicBehaviorOptions,\n      );\n    } else {\n      // if no base path, then default behavior will handle all other paths\n    }\n  }\n  /**\n   * Before any behavior is computed: the budget and the `public/` checks both\n   * generate the group patterns, and would otherwise fail first with a less\n   * useful message.\n   */\n  private validateFunctionGroupProps() {\n    if (\n      !this.props.functionGroups?.length &&\n      !this.props.functionGroupBehaviors?.length\n    ) {\n      return;\n    }\n    if (!this.isFunctionCompute) {\n      throw new Error(\n        \"`functionGroups` is only supported by NextjsGlobalFunctions.\",\n      );\n    }\n  }\n  /**\n   * Every group behavior, final path pattern included, in the order\n   * {@link addFunctionGroupBehaviors} adds them.\n   */\n  private functionGroupBehaviors() {\n    return (this.props.functionGroupBehaviors ?? []).map((behavior) => {\n      const group = this.props.functionGroups?.find(\n        (it) => it.name === behavior.group,\n      );\n      if (!group) {\n        throw new Error(\n          `${LOG_PREFIX} \\`functionGroupBehaviors\\` routes to function group ` +\n            `\"${behavior.group}\", which is not in \\`functionGroups\\`.`,\n        );\n      }\n      return {\n        ...behavior,\n        group,\n        pathPattern: this.getPathPattern(behavior.pattern),\n      };\n    });\n  }\n  /**\n   * One behavior per group pattern, most specific first.\n   *\n   * The order is the whole mechanism. CloudFront evaluates behaviors in order\n   * and stops at the first whose path pattern matches, and `addBehavior`\n   * appends — so `api/*` added before `api/reports/*` would swallow every\n   * report request and send it to a function whose package has no report\n   * entrypoint. The adapter sorted the list when it checked it against how\n   * `assignRoutesToGroups` packaged the same routes, so it is added as it is.\n   */\n  private addFunctionGroupBehaviors() {\n    const originPerGroup = new Map<string, IOrigin>();\n    for (const { group, pathPattern } of this.functionGroupBehaviors()) {\n      let origin = originPerGroup.get(group.name);\n      if (!origin) {\n        origin = FunctionUrlOrigin.withOriginAccessControl(\n          group.functionUrl,\n          this.props.overrides?.dynamicFunctionUrlOriginWithOACProps,\n        );\n        originPerGroup.set(group.name, origin);\n        this.grantInvoke(group.name, group.functionUrl);\n      }\n      // Same behavior options as every other dynamic route — only the origin\n      // differs, and it is passed separately.\n      const { origin: _ignored, ...behaviorOptions } =\n        this.dynamicBehaviorOptions;\n      this.distribution.addBehavior(pathPattern, origin, behaviorOptions);\n    }\n  }\n  /**\n   * `lambda:InvokeFunction` for CloudFront, which a Function URL behind OAC\n   * needs besides the `lambda:InvokeFunctionUrl` `FunctionUrlOrigin` grants,\n   * and scoped the same way: to this distribution, and to calls that come\n   * through the Function URL.\n   */\n  private grantInvoke(group: string, functionUrl: IFunctionUrl) {\n    new CfnPermission(this, `InvokeFunction-${group}`, {\n      action: \"lambda:InvokeFunction\",\n      principal: \"cloudfront.amazonaws.com\",\n      functionName: functionUrl.functionArn,\n      sourceArn: this.distribution.distributionArn,\n      invokedViaFunctionUrl: true,\n    });\n  }\n  /**\n   * The `assetPrefix` path that needs a behavior of its own, or `\"\"` for none.\n   *\n   * An absolute prefix contributes its *path*: \"https://cdn.example.com\" needs no\n   * behavior, but \"https://cdn.example.com/cdn\" does, because `next build`\n   * compiles a `/cdn/_next/:path+` rewrite of its own and `next start` serves\n   * every bundle under that path — so a CDN fronting this distribution there has\n   * to be answered. A prefix equal to the `basePath` prefix is dropped — that is\n   * the Next.js default when `basePath` is set, and `_next/static*` already\n   * resolves under it, so adding a second identical pattern would make CloudFront\n   * reject the distribution.\n   */\n  private resolveAssetPrefix(): string {\n    const prefix = assetPrefixPath(this.props.assetPrefix ?? \"\");\n    return normalizeBasePath(prefix) === this.basePath ? \"\" : prefix;\n  }\n  /**\n   * Serves `<assetPrefix>/_next/static/*` from the same S3 objects as\n   * `_next/static/*`.\n   *\n   * Needed because Next.js puts `assetPrefix` in front of every bundle URL it\n   * emits while the objects keep their `<basePath>/_next/static/...` keys, and\n   * `assetPrefix` sits on top of `basePath` rather than under it, so\n   * `getPathPattern` is deliberately not used here. Without this behavior the\n   * request falls through to the default one, reaches the compute origin, and\n   * 404s: the deployment package carries no `.next/static` directory at all.\n   *\n   * A viewer-request function does the rewrite because an S3 origin keys on the\n   * request URI and `originPath` can only prepend. The prefix is a synth-time\n   * literal, so the function is a fixed-length string operation rather than a\n   * parse.\n   */\n  private addAssetPrefixBehavior() {\n    // CloudFront allows one function per event type per behavior, so an override\n    // that already claims VIEWER_REQUEST on the static behavior cannot coexist\n    // with the rewrite below — the distribution would synth and then be rejected\n    // at deploy, naming neither. Thrown here instead, where both halves are\n    // known.\n    const claimed = (\n      this.staticBehaviorOptions.functionAssociations ?? []\n    ).some(\n      (association) =>\n        association.eventType === FunctionEventType.VIEWER_REQUEST,\n    );\n    if (claimed) {\n      throw new Error(\n        `${LOG_PREFIX} \\`overrides.staticBehaviorOptions.functionAssociations\\` ` +\n          `already associates a CloudFront function with ` +\n          `${FunctionEventType.VIEWER_REQUEST}, but serving \\`assetPrefix\\` ` +\n          `(\"${this.assetPrefix}\") needs that event type to rewrite the request ` +\n          `URI to the object's key, and CloudFront permits only one function per ` +\n          `event type per behavior. Either drop the override, or fold its logic ` +\n          `into a single function and set \\`assetPrefix\\` to \"\" so this ` +\n          `construct adds no behavior of its own.`,\n      );\n    }\n    const rewrite = new CloudFrontFunction(this, \"AssetPrefixFn\", {\n      comment: this.getComment(\n        \"NextJS assetPrefix rewrite\",\n        Stack.of(this).stackName,\n      ),\n      code: FunctionCode.fromInline(`\n        function handler(event) {\n          var request = event.request;\n          request.uri = ${JSON.stringify(\n            this.basePath ? `/${this.basePath}` : \"\",\n          )} + request.uri.slice(${this.assetPrefix.length});\n          return request;\n        }\n        `),\n    });\n    this.distribution.addBehavior(\n      `${this.assetPrefix}/_next/static*`,\n      this.staticOrigin,\n      {\n        ...this.staticBehaviorOptions,\n        functionAssociations: [\n          ...(this.staticBehaviorOptions.functionAssociations ?? []),\n          { eventType: FunctionEventType.VIEWER_REQUEST, function: rewrite },\n        ],\n      },\n    );\n  }\n  private addStaticBehaviors() {\n    this.distribution.addBehavior(\n      this.getPathPattern(\"_next/static*\"),\n      this.staticOrigin,\n      this.staticBehaviorOptions,\n    );\n    if (this.assetPrefix) {\n      this.addAssetPrefixBehavior();\n    }\n    const publicPathPatterns = this.publicPathPatterns();\n    this.assertBehaviorBudget(publicPathPatterns.length);\n    this.assertNoPublicCollisions(publicPathPatterns);\n    for (const pathPattern of publicPathPatterns) {\n      this.distribution.addBehavior(\n        pathPattern,\n        this.staticOrigin,\n        this.staticBehaviorOptions,\n      );\n    }\n  }\n  /**\n   * The behavior path pattern for each top-level `public/` entry, final form:\n   * `/*` for a directory and the basePath prefix both applied.\n   *\n   * An entry whose name has no character CloudFront can spell is left out, with\n   * a warning, rather than given a pattern of nothing but wildcards. `фото/` is\n   * `????????/*` — any 8-byte first segment — and public/ behaviors are added\n   * ahead of every compute behavior, so it would send `/products/42` and\n   * `/settings/*` to S3, which answers 403. Leaving the entry out costs its own\n   * files instead: those requests reach the compute, which does not have them,\n   * and 404. One literal character is enough to keep a pattern narrow —\n   * `????????.jpg` only matches `.jpg` requests — so only the all-wildcard ones\n   * go.\n   *\n   * The length limit is checked here, on the final pattern, rather than in\n   * {@link toPathPattern}: the `/*` and the basePath count against it too, and a\n   * pattern that passed without them failed at deploy instead.\n   */\n  private publicPathPatterns(): string[] {\n    const patterns: string[] = [];\n    const unmatchable: string[] = [];\n    for (const publicFile of this.props.publicDirEntries) {\n      const name = toPathPattern(publicFile.name);\n      if (!/[^?*/]/.test(name)) {\n        unmatchable.push(`\"${publicFile.name}\"`);\n        continue;\n      }\n      const pathPattern = this.getPathPattern(\n        publicFile.isDirectory ? `${name}/*` : name,\n      );\n      if (pathPattern.length > MAX_PATH_PATTERN_LENGTH) {\n        throw new Error(\n          `The public/ entry \"${publicFile.name}\" needs a ` +\n            `${pathPattern.length}-character CloudFront path pattern, over ` +\n            `the ${MAX_PATH_PATTERN_LENGTH}-character ` +\n            \"limit. Rename it, or move it into a subdirectory of public/ whose \" +\n            \"own name is short enough. See \" +\n            \"https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesCacheBehavior.html#DownloadDistValuesPathPattern\",\n        );\n      }\n      patterns.push(pathPattern);\n    }\n    if (unmatchable.length > 0) {\n      Annotations.of(this).addWarning(\n        `${LOG_PREFIX} These top-level public/ entries have no character a ` +\n          \"CloudFront path pattern can spell, so their pattern would be \" +\n          \"wildcards alone and would capture every app route of the same \" +\n          `length. They get no behavior, so their requests reach the server, ` +\n          `which reads them from S3 instead: ${unmatchable.join(\", \")}. To serve ` +\n          \"them from S3 directly, rename them, or move them into a public/ \" +\n          \"subdirectory whose name has at least one ASCII letter or digit.\",\n      );\n    }\n    return patterns;\n  }\n  /**\n   * Refuse a group behavior that a `public/` behavior would make unreachable.\n   *\n   * `public/` behaviors are added first, and CloudFront stops at the first match,\n   * so two cases send a group's route to S3 instead of its function — which is\n   * why this is checked at synth, where both sides are known:\n   * - the same pattern twice: `public/docs/` and `/docs/**` both deploy as\n   *   `docs/*`. The synth succeeded and CloudFront rejected the deploy.\n   * - a group pattern under a public directory: `/docs/guide/**` behind\n   *   `docs/*` deploys and never matches.\n   */\n  private assertNoPublicCollisions(publicPathPatterns: string[]) {\n    const publicRegexes = publicPathPatterns.map((pattern) => ({\n      pattern,\n      regex: cloudFrontPatternRegex(`/${pattern.replace(/^\\/+/, \"\")}`),\n    }));\n    for (const { group, route, pathPattern } of this.functionGroupBehaviors()) {\n      const duplicate = publicPathPatterns.includes(pathPattern);\n      // Matching the group pattern's own text is enough: its only wildcard is a\n      // trailing `*`, so a public pattern that matches the text up to and\n      // including it matches every URL the group pattern does.\n      const shadow = duplicate\n        ? undefined\n        : publicRegexes.find(({ regex }) =>\n            regex.test(`/${pathPattern.replace(/^\\/+/, \"\")}`),\n          );\n      if (!duplicate && !shadow) {\n        continue;\n      }\n      throw new Error(\n        `${LOG_PREFIX} \\`functionGroups\\` pattern \"${route}\" (group ` +\n          `\"${group.name}\") ` +\n          (duplicate\n            ? `deploys as the path pattern \"${pathPattern}\", which a top-level ` +\n              `public/ entry already uses — CloudFront rejects a distribution ` +\n              `with two behaviors on one path pattern. `\n            : `deploys as \"${pathPattern}\", but the top-level public/ entry ` +\n              `behind \"${shadow!.pattern}\" is matched first and sends every ` +\n              `such request to S3, so the group's function would never see ` +\n              `them. `) +\n          `Move those public/ files under a directory no route uses, or ` +\n          `group a different path.`,\n      );\n    }\n  }\n  /**\n   * CloudFront has a per-distribution cache behavior quota, counting the default\n   * one — 75 unless raised, and `maxCacheBehaviors` says which — and there are\n   * three things competing for it: `public/` entries, function groups, and\n   * cdk-nextjs's own fixed set.\n   * Checked in one place so the error can say which to cut.\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions\n   */\n  private assertBehaviorBudget(publicPatterns: number) {\n    const limit = this.props.maxCacheBehaviors ?? DEFAULT_MAX_CACHE_BEHAVIORS;\n    if (Token.isUnresolved(limit)) {\n      return;\n    }\n    const groupPatterns = this.functionGroupBehaviors().length;\n    // The default behavior, `_next/image*`, `_next/static*`, plus — with a\n    // basePath — the two that stand in for the default behavior's coverage, and\n    // — with a path-style assetPrefix — the one that serves bundles under it.\n    // `this.basePath`, not the raw prop: `basePath: \"/\"` normalizes to `\"\"` and\n    // adds no behaviors, so counting it added 2 to the total and could throw\n    // \"over the limit\" on an app that is under it.\n    const fixed = 3 + (this.basePath ? 2 : 0) + (this.assetPrefix ? 1 : 0);\n    const total = fixed + publicPatterns + groupPatterns;\n    if (total <= limit) {\n      return;\n    }\n    const parts = [\n      `${fixed} used by cdk-nextjs itself`,\n      `${publicPatterns} for top-level public/ entries`,\n    ];\n    if (groupPatterns) {\n      parts.push(`${groupPatterns} for \\`functionGroups\\` patterns`);\n    }\n    throw new Error(\n      `This Next.js app needs ${total} CloudFront cache behaviors, over the ` +\n        `limit of ${limit} per distribution: ${parts.join(\", \")}. ` +\n        `Move public/ files into a single top-level directory (one behavior ` +\n        `serves \\`static/*\\`)` +\n        (groupPatterns\n          ? `, and prefer one subtree pattern per function group over several ` +\n            `exact paths`\n          : ``) +\n        `. If your account's quota is higher than ${limit}, set ` +\n        `\\`maxCacheBehaviors\\` to it. See https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions`,\n    );\n  }\n  /**\n   * Optionally prepends base path to given path pattern.\n   *\n   * A trailing slash on `pathPattern` is load-bearing and survives, which is why\n   * this concatenates rather than going through `joinPath`. The build's\n   * `functionGroupBehaviors` hold both \"pricing\" and \"pricing/\" for a\n   * `trailingSlash` app, and normalizing the second one collapsed it onto the\n   * first: `addBehavior` was\n   * then called twice with `/base/pricing`, which CloudFront rejects at deploy\n   * (\"more than one cache behavior has the same path pattern\"), and the\n   * canonical `/base/pricing/` was left to the `/base/*` catch-all — the misroute\n   * the second pattern exists to prevent.\n   */\n  private getPathPattern(pathPattern: string) {\n    if (!this.basePath) {\n      return pathPattern;\n    }\n    return `/${this.basePath}/${pathPattern.replace(/^\\/+/, \"\")}`;\n  }\n}\n\n/**\n * Whether `dynamicCachePolicyProps` turns the dynamic cache off, by capping every\n * TTL at 0.\n *\n * CloudFront rejects a policy that caches nothing but still has a cache key\n * (\"HeaderBehavior is invalid for policy with caching disabled\"), so such a\n * policy has to drop the key. Until the default TTL became 0 this could not\n * come up: CDK raises `maxTtl` to `defaultTtl` when it is lower, so an override\n * of `maxTtl: 0` synthesized as a day and deployed. Now it is honored, and\n * without this the upgrade deploy would fail.\n *\n * The TTLs are resolved the way CDK resolves them: `defaultTtl` raised to\n * `minTtl`, then `maxTtl` raised to `defaultTtl`. Checking `maxTtl` alone called\n * `{ maxTtl: 0, defaultTtl: 1h }` disabled, dropped the key, and CDK then\n * synthesized a policy that caches for an hour keyed on nothing — one viewer's\n * page served to every viewer.\n */\nfunction isCachingDisabled(props: CachePolicyProps | undefined): boolean {\n  const ttls = [props?.maxTtl, props?.defaultTtl, props?.minTtl];\n  if (props?.maxTtl === undefined) return false; // CDK's default is a year\n  return ttls.every(\n    (ttl) =>\n      ttl === undefined ||\n      (!Token.isUnresolved(ttl.toString()) && ttl.toSeconds() === 0),\n  );\n}\n\n/** The cache-key half of {@link CachePolicyProps}. */\ninterface CacheKeyProps {\n  readonly queryStringBehavior: CacheQueryStringBehavior;\n  readonly headerBehavior: CacheHeaderBehavior;\n  readonly cookieBehavior: CacheCookieBehavior;\n  readonly enableAcceptEncodingBrotli: boolean;\n  readonly enableAcceptEncodingGzip: boolean;\n}\n\n/**\n * What the dynamic cache policy keys on: every request input a Next.js response\n * varies by.\n */\nconst DYNAMIC_CACHE_KEY: CacheKeyProps = {\n  queryStringBehavior: CacheQueryStringBehavior.all(),\n  headerBehavior: CacheHeaderBehavior.allowList(\n    // NOTE: CloudFront Custom Cache Policies have soft max of 10 headers\n    // cdk-nextjs includes the most essential headers for Next.js functionality\n    // and leaves out the one commented out below; keying on it as well needs a\n    // quota increase\n    // more here: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-policies\n    \"accept\", // content negotiation (HTML vs RSC payload)\n    \"rsc\", // React Server Components requests\n    \"next-url\", // Next.js routing\n    \"next-router-state-tree\", // App Router navigation state\n    \"next-router-prefetch\", // prefetch behavior\n    \"next-router-segment-prefetch\", // segment-level prefetching\n    \"x-prerender-revalidate\", // on-demand ISR revalidation\n    // Draft mode needs no header: it is the `__prerender_bypass` cookie, which\n    // `cookieBehavior.all()` already keys on.\n    // \"x-prerender-revalidate-if-generated\", // conditional revalidation (niche use case)\n  ),\n  cookieBehavior: CacheCookieBehavior.all(),\n  enableAcceptEncodingBrotli: true,\n  enableAcceptEncodingGzip: true,\n};\n\n/**\n * A cache key of nothing, for a policy that caches nothing. Forwarding is\n * unaffected: the dynamic origin request policy sends every viewer header,\n * cookie and query string regardless.\n */\nconst DISABLED_CACHE_KEY: CacheKeyProps = {\n  queryStringBehavior: CacheQueryStringBehavior.none(),\n  headerBehavior: CacheHeaderBehavior.none(),\n  cookieBehavior: CacheCookieBehavior.none(),\n  enableAcceptEncodingBrotli: false,\n  enableAcceptEncodingGzip: false,\n};\n\n/**\n * CloudFront's default \"Cache behaviors per distribution\" quota, the default\n * behavior included. Adjustable, hence `maxCacheBehaviors`.\n *\n * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions\n */\nconst DEFAULT_MAX_CACHE_BEHAVIORS = 75;\n\n/**\n * Whether `char` is in CloudFront's path pattern alphabet: the literals, plus the\n * `*` and `?` wildcards. No space, no `%`, nothing non-ASCII.\n */\nfunction isPathPatternChar(char: string): boolean {\n  return char === \"*\" || char === \"?\" || PATH_PATTERN_LITERAL.test(char);\n}\n/** CloudFront's path pattern length limit. */\nconst MAX_PATH_PATTERN_LENGTH = 255;\n\n/**\n * A `public/` entry's name as a CloudFront path pattern.\n *\n * `public/hello world.jpg` is a valid Next.js asset — `next start` serves it, and\n * `next/image` points at it — but a space cannot appear in a path pattern, so\n * cdk-nextjs used to throw at synth and the app could not be deployed at all\n * (`next-image-legacy/unicode`, whose `public/` also holds `äöüščří.png`).\n *\n * CloudFront URL-decodes the request path before matching it, so the pattern is\n * matched against `hello world.jpg`, not the `/hello%20world.jpg` on the wire.\n * Each character outside the alphabet is replaced by one `?` per byte of its\n * UTF-8 encoding, because that is what `?` matches: `hello?world.jpg` for the\n * space, and two `?` for each character of `äöüščří.png`. Measured against a\n * deployed distribution; a `?` per *percent-encoded* character (`hello???world`)\n * synthesizes fine and never matches. A `*` would be shorter and much wider:\n * `äöüščří.png` would become `*.png`, which would pull every `.png` request in\n * the app onto the static origin.\n */\nfunction toPathPattern(name: string): string {\n  return [...name]\n    .map((char) =>\n      isPathPatternChar(char)\n        ? char\n        : \"?\".repeat(Buffer.byteLength(char, \"utf8\")),\n    )\n    .join(\"\");\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-distribution.js","sourceRoot":"","sources":["../src/nextjs-distribution.ts"],"names":[],"mappings":";;;;AAAA,6CAAkE;AAElE,+DA+BoC;AACpC,+EAM4C;AAE5C,uDAAqE;AAErE,2CAAuC;AACvC,+DAImC;AACnC,2CAAqD;AAOrD,iDAAuE;AACvE,+EAO0C;AA6I1C,MAAa,kBAAmB,SAAQ,sBAAS;;IAC/C,YAAY,CAAe;IAEnB,KAAK,CAA0B;IACvC;;;;;OAKG;IACK,QAAQ,CAAS;IACzB;;;;;OAKG;IACK,WAAW,CAAS;IAC5B;;;OAGG;IACK,6BAA6B,GAAoC;QACvE,kBAAkB,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE;QACvC,YAAY,EAAE;YACZ,WAAW,EAAE,mCAAkB,CAAC,UAAU;YAC1C,QAAQ,EAAE,KAAK;SAChB;QACD,cAAc,EAAE;YACd,QAAQ,EAAE,KAAK;YACf,cAAc,EAAE,sCAAqB,CAAC,+BAA+B;SACtE;QAED,uBAAuB,EAAE;YACvB,mBAAmB,EAAE,sBAAQ,CAAC,IAAI,CAAC,GAAG,CAAC;YACvC,iBAAiB,EAAE,IAAI;YACvB,QAAQ,EAAE,KAAK;YACf,OAAO,EAAE,IAAI;SACd;QACD,aAAa,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE;KACtE,CAAC;IACM,YAAY,CAAU;IACtB,aAAa,CAAU;IACvB,2BAA2B,CAAuB;IAClD,qCAAqC,CAAwB;IACrE;;;OAGG;IACK,iBAAiB,CAAU;IACnC;;;;;OAKG;IACK,mBAAmB,CAAsB;IACzC,iBAAiB,CAAU;IAC3B,qBAAqB,CAAkB;IACvC,sBAAsB,CAAkB;IACxC,oBAAoB,CAAkB;IAE9C,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA8B;QACtE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,KAAK,CAAC,0BAA0B,IAAI,CAAC,KAAK,CAAC,yBAAyB,EAAE,CAAC;YACzE,MAAM,IAAI,KAAK,CACb,GAAG,sBAAU,0DAA0D;gBACrE,mEAAmE;gBACnE,2CAA2C,CAC9C,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,uBAAuB,EAAE,CAAC;QACxD,IAAI,CAAC,QAAQ,GAAG,IAAA,6BAAiB,EAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAClD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC7C,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC9C,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC,UAAU,KAAK,sBAAU,CAAC,gBAAgB,CAAC;QAC1E,IAAI,CAAC,0BAA0B,EAAE,CAAC;QAClC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAChD,IAAI,CAAC,2BAA2B,GAAG,IAAI,CAAC,gCAAgC,EAAE,CAAC;QAC3E,IAAI,CAAC,qCAAqC;YACxC,IAAI,CAAC,2CAA2C,EAAE,CAAC;QACrD,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,2BAA2B,EAAE,CAAC;QAChE,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,4BAA4B,EAAE,CAAC;QAClE,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,0BAA0B,EAAE,CAAC;QAC9D,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QAC3C,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC3B,IAAI,CAAC,WAAW,CAAC,wCAAsB,EAAE,KAAK,CAAC,WAAY,CAAC,CAAC;QAC/D,CAAC;QACD,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC7B,CAAC;IAED;;;;;;OAMG;IACK,UAAU,CAAC,WAAmB,EAAE,SAAiB;QACvD,MAAM,WAAW,GAAG,GAAG,WAAW,QAAQ,SAAS,EAAE,CAAC;QACtD,OAAO,WAAW,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC;IAC9D,CAAC;IAEO,kBAAkB;QACxB,OAAO,uCAAc,CAAC,uBAAuB,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE;YACrE,4DAA4D;YAC5D,kBAAkB,EAAE,CAAC,4BAAW,CAAC,IAAI,EAAE,4BAAW,CAAC,IAAI,CAAC;YACxD,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,mBAAmB;SAC7C,CAAC,CAAC;IACL,CAAC;IACO,mBAAmB;QACzB,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC3B,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;gBAC5B,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;YACjE,CAAC;YACD,OAAO,0CAAiB,CAAC,uBAAuB,CAC9C,IAAI,CAAC,KAAK,CAAC,WAAW,EACtB,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,oCAAoC,CAC3D,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC;YAC7C,IAAI,CAAC,YAAY,EAAE,CAAC;gBAClB,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;YAClE,CAAC;YACD,OAAO,kCAAS,CAAC,2BAA2B,CAAC,YAAY,EAAE;gBACzD,cAAc,EAAE,IAAI,CAAC,KAAK,CAAC,WAAW;oBACpC,CAAC,CAAC,qCAAoB,CAAC,UAAU;oBACjC,CAAC,CAAC,qCAAoB,CAAC,SAAS;gBAClC,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,iCAAiC;aAC3D,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD;;;;;;;;;;;OAWG;IACK,gCAAgC;QACtC,OAAO,IAAI,CAAC,iBAAiB;YAC3B,CAAC,CAAC,oCAAmB,CAAC,6BAA6B;YACnD,CAAC,CAAC,oCAAmB,CAAC,8BAA8B,CAAC;IACzD,CAAC;IACD;;;;OAIG;IACK,2CAA2C;QACjD,MAAM,YAAY,GAA0B,EAAE,CAAC;QAC/C,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC3B,MAAM,YAAY,GAAG,IAAI,yBAAkB,CAAC,IAAI,EAAE,cAAc,EAAE;gBAChE,GAAG,IAAI,CAAC,0BAA0B,CAAC,mDAAwB,CAAC;aAC7D,CAAC,CAAC;YACH,YAAY,CAAC,IAAI,CAAC;gBAChB,SAAS,EAAE,kCAAiB,CAAC,cAAc;gBAC3C,QAAQ,EAAE,YAAY;aACvB,CAAC,CAAC;QACL,CAAC;aAAM,IAAI,IAAI,CAAC,iBAAiB,KAAK,SAAS,EAAE,CAAC;YAChD,mEAAmE;YACnE,2DAA2D;YAC3D,YAAY,CAAC,IAAI,CAAC;gBAChB,SAAS,EAAE,kCAAiB,CAAC,cAAc;gBAC3C,QAAQ,EAAE,IAAI,CAAC,sBAAsB,EAAE;aACxC,CAAC,CAAC;QACL,CAAC;QACD,OAAO,YAAY,CAAC;IACtB,CAAC;IACD;;;OAGG;IACK,sBAAsB;QAC5B,IAAI,CAAC,mBAAmB,KAAK,IAAI,yBAAkB,CACjD,IAAI,EACJ,iBAAiB,EACjB;YACE,OAAO,EAAE,IAAI,CAAC,UAAU,CACtB,uBAAuB,EACvB,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,CACzB;YACD,GAAG,IAAI,CAAC,0BAA0B,CAAC,+CAAoB,CAAC;SACzD,CACF,CAAC;QACF,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IACD;;;;;;;;OAQG;IACK,0BAA0B,CAChC,OAAe;QAEf,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC;QACxC,MAAM,IAAI,GAAG,IAAA,8CAAmB,EAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;QACpD,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO;gBACL,IAAI,EAAE,6BAAY,CAAC,UAAU,CAAC,IAAI,CAAC;gBACnC,OAAO,EAAE,gCAAe,CAAC,MAAM;aAChC,CAAC;QACJ,CAAC;QACD,MAAM,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACrC,IAAI,mBAAK,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;YAC7B,iEAAiE;YACjE,yBAAW,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,UAAU,CAC7B,GAAG,sBAAU,0DAA0D;gBACrE,0DAA0D;gBAC1D,GAAG,kDAAuB,sBAAsB,CACnD,CAAC;QACJ,CAAC;aAAM,IAAI,IAAI,GAAG,kDAAuB,EAAE,CAAC;YAC1C,MAAM,IAAI,KAAK,CACb,GAAG,sBAAU,oDAAoD;gBAC/D,eAAe,IAAI,+CAA+C;gBAClE,yBAAyB,kDAAuB,eAAe;gBAC/D,uCAAuC;gBACvC,4GAA4G,CAC/G,CAAC;QACJ,CAAC;QACD,OAAO;YACL,IAAI,EAAE,6BAAY,CAAC,UAAU,CAAC,IAAI,CAAC;YACnC,OAAO,EAAE,gCAAe,CAAC,MAAM;YAC/B,aAAa,EAAE,IAAI,CAAC,KAAK,CAAC,0BAA0B;SACrD,CAAC;IACJ,CAAC;IACD;;;;OAIG;IACK,uBAAuB;QAC7B,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,yBAAyB,EAAE,MAAM,EAAE,CAAC;QAChE,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,IAAA,iDAAsB,EAAC,QAAQ,CAAC,CAAC;QACjC,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD;;;;;OAKG;IACK,4BAA4B,CAClC,YAAoB,EACpB,YAA+C,EAC/C,KAAa;QAEb,MAAM,OAAO,GAAG,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC,IAAI,CACvC,CAAC,WAAW,EAAE,EAAE,CACd,WAAW,CAAC,SAAS,KAAK,kCAAiB,CAAC,cAAc,CAC7D,CAAC;QACF,IAAI,OAAO,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CACb,GAAG,sBAAU,gBAAgB,YAAY,0BAA0B;gBACjE,wCAAwC;gBACxC,GAAG,kCAAiB,CAAC,cAAc,SAAS,KAAK,IAAI;gBACrD,oEAAoE;gBACpE,gEAAgE;gBAChE,oEAAoE,CACvE,CAAC;QACJ,CAAC;IACH,CAAC;IACO,2BAA2B;QACjC,MAAM,qBAAqB,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,qBAAqB,CAAC;QAC1E,MAAM,qBAAqB,GACzB,qBAAqB,EAAE,qBAAqB;YAC5C,IAAI,sCAAqB,CAAC,IAAI,EAAE,6BAA6B,EAAE;gBAC7D,uBAAuB,EAAE,IAAI,CAAC,6BAA6B;gBAC3D,OAAO,EAAE,IAAI,CAAC,UAAU,CACtB,uCAAuC,EACvC,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,CACzB;gBACD,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,gCAAgC;aAC1D,CAAC,CAAC;QACL,MAAM,OAAO,GAAoB;YAC/B,cAAc,EAAE,+BAAc,CAAC,sBAAsB;YACrD,aAAa,EAAE,8BAAa,CAAC,sBAAsB;YACnD,WAAW,EAAE,4BAAW,CAAC,iBAAiB;YAC1C,MAAM,EAAE,IAAI,CAAC,YAAY;YACzB,qBAAqB;YACrB,oBAAoB,EAAE,qCAAoB,CAAC,iBAAiB;YAC5D,GAAG,qBAAqB;SACzB,CAAC;QACF,IAAI,IAAI,CAAC,iBAAiB,KAAK,SAAS,EAAE,CAAC;YACzC,OAAO,OAAO,CAAC;QACjB,CAAC;QACD,IAAI,CAAC,4BAA4B,CAC/B,uBAAuB,EACvB,qBAAqB,EAAE,oBAAoB,EAC3C,2EAA2E,CAC5E,CAAC;QACF,OAAO;YACL,GAAG,OAAO;YACV,oBAAoB,EAAE;gBACpB,GAAG,CAAC,qBAAqB,EAAE,oBAAoB,IAAI,EAAE,CAAC;gBACtD;oBACE,SAAS,EAAE,kCAAiB,CAAC,cAAc;oBAC3C,QAAQ,EAAE,IAAI,CAAC,sBAAsB,EAAE;iBACxC;aACF;SACF,CAAC;IACJ,CAAC;IACO,4BAA4B;QAClC,MAAM,sBAAsB,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,sBAAsB,CAAC;QAC5E,MAAM,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,uBAAuB,CAAC;QACvE,8CAA8C;QAC9C,MAAM,WAAW,GACf,sBAAsB,EAAE,WAAW;YACnC,IAAI,4BAAW,CAAC,IAAI,EAAE,oBAAoB,EAAE;gBAC1C,GAAG,CAAC,iBAAiB,CAAC,gBAAgB,CAAC;oBACrC,CAAC,CAAC,kBAAkB;oBACpB,CAAC,CAAC,iBAAiB,CAAC;gBACtB,0EAA0E;gBAC1E,0EAA0E;gBAC1E,0EAA0E;gBAC1E,wEAAwE;gBACxE,wDAAwD;gBACxD,UAAU,EAAE,sBAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;gBAC/B,OAAO,EAAE,IAAI,CAAC,UAAU,CACtB,6BAA6B,EAC7B,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,CACzB;gBACD,GAAG,gBAAgB;aACpB,CAAC,CAAC;QACL,MAAM,qBAAqB,GACzB,sBAAsB,EAAE,qBAAqB;YAC7C,IAAI,sCAAqB,CAAC,IAAI,EAAE,8BAA8B,EAAE;gBAC9D,uBAAuB,EAAE,IAAI,CAAC,6BAA6B;gBAC3D,OAAO,EAAE,IAAI,CAAC,UAAU,CACtB,wCAAwC,EACxC,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,CACzB;gBACD,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,iCAAiC;aAC3D,CAAC,CAAC;QACL,OAAO;YACL,cAAc,EAAE,+BAAc,CAAC,SAAS;YACxC,WAAW;YACX,MAAM,EAAE,IAAI,CAAC,aAAa;YAC1B,mBAAmB,EAAE,IAAI,CAAC,2BAA2B;YACrD,qBAAqB;YACrB,oBAAoB,EAAE,qCAAoB,CAAC,iBAAiB;YAC5D,GAAG,sBAAsB;YACzB,oBAAoB,EAAE,IAAI,CAAC,+BAA+B,CACxD,wBAAwB,EACxB,sBAAsB,EAAE,oBAAoB,CAC7C;SACF,CAAC;IACJ,CAAC;IACD;;;;;;;;;;;;OAYG;IACK,+BAA+B,CACrC,YAAoB,EACpB,UAA6C;QAE7C,MAAM,IAAI,GAAG,IAAI,CAAC,qCAAqC,CAAC;QACxD,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,OAAO,UAAU,CAAC;QACpB,CAAC;QACD,IAAI,CAAC,4BAA4B,CAC/B,YAAY,EACZ,UAAU,EACV,IAAI,CAAC,iBAAiB;YACpB,CAAC,CAAC,oEAAoE;gBAClE,mEAAmE;gBACnE,mEAAmE;gBACnE,kBAAkB;YACtB,CAAC,CAAC,mEAAmE;gBACjE,qBAAqB,CAC5B,CAAC;QACF,OAAO,CAAC,GAAG,UAAU,EAAE,GAAG,IAAI,CAAC,CAAC;IAClC,CAAC;IACD;;;;;OAKG;IACK,0BAA0B;QAChC,MAAM,oBAAoB,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,oBAAoB,CAAC;QACxE,2CAA2C;QAC3C,MAAM,WAAW,GACf,oBAAoB,EAAE,WAAW;YACjC,IAAI,4BAAW,CAAC,IAAI,EAAE,kBAAkB,EAAE;gBACxC,kEAAkE;gBAClE,qEAAqE;gBACrE,yEAAyE;gBACzE,6BAA6B;gBAC7B,mBAAmB,EAAE,yCAAwB,CAAC,GAAG,EAAE;gBACnD,cAAc,EAAE,oCAAmB,CAAC,SAAS,CAAC,QAAQ,CAAC;gBACvD,cAAc,EAAE,oCAAmB,CAAC,IAAI,EAAE;gBAC1C,0BAA0B,EAAE,IAAI;gBAChC,wBAAwB,EAAE,IAAI;gBAC9B,OAAO,EAAE,IAAI,CAAC,UAAU,CACtB,2BAA2B,EAC3B,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,CACzB;gBACD,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,qBAAqB;aAC/C,CAAC,CAAC;QACL,sDAAsD;QACtD,MAAM,qBAAqB,GACzB,oBAAoB,EAAE,qBAAqB;YAC3C,IAAI,sCAAqB,CAAC,IAAI,EAAE,4BAA4B,EAAE;gBAC5D,uBAAuB,EAAE,IAAI,CAAC,6BAA6B;gBAC3D,OAAO,EAAE,IAAI,CAAC,UAAU,CACtB,sCAAsC,EACtC,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,CACzB;gBACD,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,+BAA+B;aACzD,CAAC,CAAC;QACL,OAAO;YACL,cAAc,EAAE,+BAAc,CAAC,sBAAsB;YACrD,aAAa,EAAE,8BAAa,CAAC,sBAAsB;YACnD,MAAM,EAAE,IAAI,CAAC,aAAa;YAC1B,mBAAmB,EAAE,IAAI,CAAC,2BAA2B;YACrD,WAAW;YACX,qBAAqB;YACrB,oBAAoB,EAAE,qCAAoB,CAAC,iBAAiB;YAC5D,GAAG,oBAAoB;YACvB,oBAAoB,EAAE,IAAI,CAAC,+BAA+B,CACxD,sBAAsB,EACtB,oBAAoB,EAAE,oBAAoB,CAC3C;SACF,CAAC;IACJ,CAAC;IACD;;OAEG;IACK,eAAe;QACrB,IAAI,YAA0B,CAAC;QAC/B,IAAI,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC;YAC5B,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC;QACzC,CAAC;aAAM,CAAC;YACN,qEAAqE;YACrE,yDAAyD;YACzD,IACE,IAAI,CAAC,iBAAiB,KAAK,SAAS;gBACpC,CAAC,IAAI,CAAC,QAAQ;gBACd,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,iBAAiB,EAAE,eAAe,EACxD,CAAC;gBACD,MAAM,IAAI,KAAK,CACb,GAAG,sBAAU,mDAAmD;oBAC9D,mEAAmE;oBACnE,iEAAiE;oBACjE,+DAA+D;oBAC/D,gEAAgE,CACnE,CAAC;YACJ,CAAC;YACD,YAAY,GAAG,IAAI,6BAAY,CAAC,IAAI,EAAE,cAAc,EAAE;gBACpD,sBAAsB,EAAE,uCAAsB,CAAC,aAAa;gBAC5D,eAAe,EAAE,IAAI,CAAC,sBAAsB;gBAC5C,8EAA8E;gBAC9E,gDAAgD;gBAChD,WAAW,EAAE,4BAAW,CAAC,WAAW;gBACpC,OAAO,EAAE,IAAI,CAAC,UAAU,CACtB,qBAAqB,EACrB,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,CACzB;gBACD,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,iBAAiB;aAC3C,CAAC,CAAC;QACL,CAAC;QACD,OAAO,YAAY,CAAC;IACtB,CAAC;IACO,mBAAmB;QACzB,iBAAiB;QACjB,IAAI,CAAC,YAAY,CAAC,WAAW,CAC3B,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,EACnC,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAChC,IAAI,CAAC,oBAAoB,CAC1B,CAAC;QACF,0EAA0E;QAC1E,2EAA2E;QAC3E,6EAA6E;QAC7E,IAAI,CAAC,yBAAyB,EAAE,CAAC;QACjC,sBAAsB;QACtB,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,8EAA8E;YAC9E,IAAI,CAAC,YAAY,CAAC,WAAW,CAC3B,IAAI,IAAI,CAAC,QAAQ,EAAE,EACnB,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAClC,IAAI,CAAC,sBAAsB,CAC5B,CAAC;YACF,6FAA6F;YAC7F,IAAI,CAAC,YAAY,CAAC,WAAW,CAC3B,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EACxB,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAClC,IAAI,CAAC,sBAAsB,CAC5B,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,qEAAqE;QACvE,CAAC;IACH,CAAC;IACD;;;;OAIG;IACK,0BAA0B;QAChC,IACE,CAAC,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,MAAM;YAClC,CAAC,IAAI,CAAC,KAAK,CAAC,sBAAsB,EAAE,MAAM,EAC1C,CAAC;YACD,OAAO;QACT,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CACb,8DAA8D,CAC/D,CAAC;QACJ,CAAC;IACH,CAAC;IACD;;;OAGG;IACK,sBAAsB;QAC5B,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,sBAAsB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE;YAChE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,IAAI,CAC3C,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,KAAK,QAAQ,CAAC,KAAK,CACnC,CAAC;YACF,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,MAAM,IAAI,KAAK,CACb,GAAG,sBAAU,uDAAuD;oBAClE,IAAI,QAAQ,CAAC,KAAK,wCAAwC,CAC7D,CAAC;YACJ,CAAC;YACD,OAAO;gBACL,GAAG,QAAQ;gBACX,KAAK;gBACL,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,OAAO,CAAC;aACnD,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IACD;;;;;;;;;OASG;IACK,yBAAyB;QAC/B,MAAM,cAAc,GAAG,IAAI,GAAG,EAAmB,CAAC;QAClD,KAAK,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,IAAI,CAAC,sBAAsB,EAAE,EAAE,CAAC;YACnE,IAAI,MAAM,GAAG,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAC5C,IAAI,CAAC,MAAM,EAAE,CAAC;gBACZ,MAAM,GAAG,0CAAiB,CAAC,uBAAuB,CAChD,KAAK,CAAC,WAAW,EACjB,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,oCAAoC,CAC3D,CAAC;gBACF,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;gBACvC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;YAClD,CAAC;YACD,uEAAuE;YACvE,wCAAwC;YACxC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,eAAe,EAAE,GAC5C,IAAI,CAAC,sBAAsB,CAAC;YAC9B,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC;QACtE,CAAC;IACH,CAAC;IACD;;;;;OAKG;IACK,WAAW,CAAC,KAAa,EAAE,WAAyB;QAC1D,IAAI,0BAAa,CAAC,IAAI,EAAE,kBAAkB,KAAK,EAAE,EAAE;YACjD,MAAM,EAAE,uBAAuB;YAC/B,SAAS,EAAE,0BAA0B;YACrC,YAAY,EAAE,WAAW,CAAC,WAAW;YACrC,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,eAAe;YAC5C,qBAAqB,EAAE,IAAI;SAC5B,CAAC,CAAC;IACL,CAAC;IACD;;;;;;;;;;;OAWG;IACK,kBAAkB;QACxB,MAAM,MAAM,GAAG,IAAA,2BAAe,EAAC,IAAI,CAAC,KAAK,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC;QAC7D,OAAO,IAAA,6BAAiB,EAAC,MAAM,CAAC,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;IACnE,CAAC;IACD;;;;;;;;;;;;;;;OAeG;IACK,sBAAsB;QAC5B,0DAA0D;QAC1D,yEAAyE;QACzE,4BAA4B;QAC5B,MAAM,YAAY,GAAG,CACnB,IAAI,CAAC,qBAAqB,CAAC,oBAAoB,IAAI,EAAE,CACtD,CAAC,MAAM,CACN,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,QAAQ,KAAK,IAAI,CAAC,mBAAmB,CACnE,CAAC;QACF,IAAI,CAAC,4BAA4B,CAC/B,uBAAuB,EACvB,YAAY,EACZ,6BAA6B,IAAI,CAAC,WAAW,2BAA2B;YACtE,gDAAgD,CACnD,CAAC;QACF,MAAM,OAAO,GAAG,IAAI,yBAAkB,CAAC,IAAI,EAAE,eAAe,EAAE;YAC5D,OAAO,EAAE,IAAI,CAAC,UAAU,CACtB,4BAA4B,EAC5B,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,CACzB;YACD,GAAG,IAAI,CAAC,0BAA0B,CAChC,IAAA,oDAAyB,EAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,CAC3D;SACF,CAAC,CAAC;QACH,IAAI,CAAC,YAAY,CAAC,WAAW,CAC3B,GAAG,IAAI,CAAC,WAAW,gBAAgB,EACnC,IAAI,CAAC,YAAY,EACjB;YACE,GAAG,IAAI,CAAC,qBAAqB;YAC7B,oBAAoB,EAAE;gBACpB,GAAG,YAAY;gBACf,EAAE,SAAS,EAAE,kCAAiB,CAAC,cAAc,EAAE,QAAQ,EAAE,OAAO,EAAE;aACnE;SACF,CACF,CAAC;IACJ,CAAC;IACD;;;;;;;;;;OAUG;IACK,wBAAwB,CAAC,oBAA4B;QAC3D,MAAM,UAAU,GACd,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,qBAAqB,EAAE,qBAAqB,CAAC;QACrE,IAAI,UAAU,EAAE,CAAC;YACf,yBAAW,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,UAAU,CAC7B,GAAG,sBAAU,6DAA6D;gBACxE,gEAAgE;gBAChE,4CAA4C,oBAAoB,KAAK;gBACrE,oEAAoE;gBACpE,iEAAiE;gBACjE,yDAAyD,CAC5D,CAAC;QACJ,CAAC;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,gCAAgC,CAAC;QACrE,MAAM,aAAa,GAAG,KAAK,EAAE,qBAAqB,EAAE,aAAa,IAAI,EAAE,CAAC;QACxE,MAAM,qBAAqB,GACzB,UAAU;YACV,IAAI,sCAAqB,CAAC,IAAI,EAAE,oCAAoC,EAAE;gBACpE,uBAAuB,EAAE,IAAI,CAAC,6BAA6B;gBAC3D,OAAO,EAAE,IAAI,CAAC,UAAU,CACtB,+CAA+C,EAC/C,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,CACzB;gBACD,GAAG,KAAK;gBACR,uEAAuE;gBACvE,qEAAqE;gBACrE,oDAAoD;gBACpD,yBAAyB,EACvB,KAAK,EAAE,yBAAyB;oBAChC,GACE,mBAAK,CAAC,YAAY,CAAC,KAAK,CAAC,yBAAyB,CAAC;wBACjD,CAAC,CAAC,KAAK,CAAC,yBAAyB;wBACjC,CAAC,CAAC,KAAK,CAAC,yBAAyB,CAAC,KAAK,CACnC,CAAC,EACD,sBAAsB,GAAG,qBAAqB,CAAC,MAAM,CAE7D,GAAG,qBAAqB,EAAE;gBAC5B,qBAAqB,EAAE;oBACrB,wCAAwC;oBACxC,aAAa,EAAE,aAAa,CAAC,IAAI,CAC/B,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,KAAK,wBAAwB,CAClE;wBACC,CAAC,CAAC,aAAa;wBACf,CAAC,CAAC;4BACE,GAAG,aAAa;4BAChB;gCACE,MAAM,EAAE,wBAAwB;gCAChC,KAAK,EAAE,oBAAoB;gCAC3B,QAAQ,EAAE,IAAI;6BACf;yBACF;iBACN;aACF,CAAC,CAAC;QACL,IAAI,CAAC,YAAY,CAAC,WAAW,CAC3B,IAAI,CAAC,cAAc,CAAC,+BAA+B,CAAC,EACpD,IAAI,CAAC,YAAY,EACjB,EAAE,GAAG,IAAI,CAAC,qBAAqB,EAAE,qBAAqB,EAAE,CACzD,CAAC;IACJ,CAAC;IACO,kBAAkB;QACxB,IAAI,IAAI,CAAC,KAAK,CAAC,oBAAoB,KAAK,SAAS,EAAE,CAAC;YAClD,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC;QACjE,CAAC;QACD,IAAI,CAAC,YAAY,CAAC,WAAW,CAC3B,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,EACpC,IAAI,CAAC,YAAY,EACjB,IAAI,CAAC,qBAAqB,CAC3B,CAAC;QACF,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAChC,CAAC;QACD,MAAM,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;QACrD,IAAI,CAAC,oBAAoB,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;QACrD,IAAI,CAAC,wBAAwB,CAAC,kBAAkB,CAAC,CAAC;QAClD,KAAK,MAAM,WAAW,IAAI,kBAAkB,EAAE,CAAC;YAC7C,IAAI,CAAC,YAAY,CAAC,WAAW,CAC3B,WAAW,EACX,IAAI,CAAC,YAAY,EACjB,IAAI,CAAC,qBAAqB,CAC3B,CAAC;QACJ,CAAC;IACH,CAAC;IACD;;;;;;;;;;;;;;;;;OAiBG;IACK,kBAAkB;QACxB,MAAM,QAAQ,GAAa,EAAE,CAAC;QAC9B,MAAM,WAAW,GAAa,EAAE,CAAC;QACjC,KAAK,MAAM,UAAU,IAAI,IAAI,CAAC,KAAK,CAAC,gBAAgB,EAAE,CAAC;YACrD,MAAM,IAAI,GAAG,aAAa,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YAC5C,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;gBACzB,WAAW,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,IAAI,GAAG,CAAC,CAAC;gBACzC,SAAS;YACX,CAAC;YACD,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CACrC,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAC5C,CAAC;YACF,IAAI,WAAW,CAAC,MAAM,GAAG,uBAAuB,EAAE,CAAC;gBACjD,MAAM,IAAI,KAAK,CACb,sBAAsB,UAAU,CAAC,IAAI,YAAY;oBAC/C,GAAG,WAAW,CAAC,MAAM,2CAA2C;oBAChE,OAAO,uBAAuB,aAAa;oBAC3C,oEAAoE;oBACpE,gCAAgC;oBAChC,uIAAuI,CAC1I,CAAC;YACJ,CAAC;YACD,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC7B,CAAC;QACD,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC3B,yBAAW,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,UAAU,CAC7B,GAAG,sBAAU,uDAAuD;gBAClE,+DAA+D;gBAC/D,gEAAgE;gBAChE,oEAAoE;gBACpE,qCAAqC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa;gBACxE,kEAAkE;gBAClE,iEAAiE,CACpE,CAAC;QACJ,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD;;;;;;;;;;OAUG;IACK,wBAAwB,CAAC,kBAA4B;QAC3D,MAAM,aAAa,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;YACzD,OAAO;YACP,KAAK,EAAE,IAAA,wCAAsB,EAAC,IAAI,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;SACjE,CAAC,CAAC,CAAC;QACJ,KAAK,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,IAAI,CAAC,sBAAsB,EAAE,EAAE,CAAC;YAC1E,MAAM,SAAS,GAAG,kBAAkB,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;YAC3D,0EAA0E;YAC1E,oEAAoE;YACpE,yDAAyD;YACzD,MAAM,MAAM,GAAG,SAAS;gBACtB,CAAC,CAAC,SAAS;gBACX,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAC/B,KAAK,CAAC,IAAI,CAAC,IAAI,WAAW,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC,CAClD,CAAC;YACN,IAAI,CAAC,SAAS,IAAI,CAAC,MAAM,EAAE,CAAC;gBAC1B,SAAS;YACX,CAAC;YACD,MAAM,IAAI,KAAK,CACb,GAAG,sBAAU,gCAAgC,KAAK,WAAW;gBAC3D,IAAI,KAAK,CAAC,IAAI,KAAK;gBACnB,CAAC,SAAS;oBACR,CAAC,CAAC,gCAAgC,WAAW,uBAAuB;wBAClE,iEAAiE;wBACjE,0CAA0C;oBAC5C,CAAC,CAAC,eAAe,WAAW,qCAAqC;wBAC/D,WAAW,MAAO,CAAC,OAAO,qCAAqC;wBAC/D,8DAA8D;wBAC9D,QAAQ,CAAC;gBACb,+DAA+D;gBAC/D,yBAAyB,CAC5B,CAAC;QACJ,CAAC;IACH,CAAC;IACD;;;;;;;;OAQG;IACK,oBAAoB,CAAC,cAAsB;QACjD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,iBAAiB,IAAI,2BAA2B,CAAC;QAC1E,IAAI,mBAAK,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;YAC9B,OAAO;QACT,CAAC;QACD,MAAM,aAAa,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC,MAAM,CAAC;QAC3D,uEAAuE;QACvE,4EAA4E;QAC5E,0EAA0E;QAC1E,2EAA2E;QAC3E,4EAA4E;QAC5E,yEAAyE;QACzE,+CAA+C;QAC/C,MAAM,KAAK,GACT,CAAC;YACD,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACvB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1B,CAAC,IAAI,CAAC,KAAK,CAAC,oBAAoB,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1D,MAAM,KAAK,GAAG,KAAK,GAAG,cAAc,GAAG,aAAa,CAAC;QACrD,IAAI,KAAK,IAAI,KAAK,EAAE,CAAC;YACnB,OAAO;QACT,CAAC;QACD,MAAM,KAAK,GAAG;YACZ,GAAG,KAAK,4BAA4B;YACpC,GAAG,cAAc,gCAAgC;SAClD,CAAC;QACF,IAAI,aAAa,EAAE,CAAC;YAClB,KAAK,CAAC,IAAI,CAAC,GAAG,aAAa,kCAAkC,CAAC,CAAC;QACjE,CAAC;QACD,MAAM,IAAI,KAAK,CACb,0BAA0B,KAAK,wCAAwC;YACrE,YAAY,KAAK,sBAAsB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;YAC3D,qEAAqE;YACrE,sBAAsB;YACtB,CAAC,aAAa;gBACZ,CAAC,CAAC,mEAAmE;oBACnE,aAAa;gBACf,CAAC,CAAC,EAAE,CAAC;YACP,4CAA4C,KAAK,QAAQ;YACzD,qJAAqJ,CACxJ,CAAC;IACJ,CAAC;IACD;;;;;;;;;;;;OAYG;IACK,cAAc,CAAC,WAAmB;QACxC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,OAAO,WAAW,CAAC;QACrB,CAAC;QACD,OAAO,IAAI,IAAI,CAAC,QAAQ,IAAI,WAAW,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;IAChE,CAAC;;AAr6BH,gDAs6BC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,SAAS,iBAAiB,CAAC,KAAmC;IAC5D,MAAM,IAAI,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;IAC/D,IAAI,KAAK,EAAE,MAAM,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC,CAAC,0BAA0B;IACzE,OAAO,IAAI,CAAC,KAAK,CACf,CAAC,GAAG,EAAE,EAAE,CACN,GAAG,KAAK,SAAS;QACjB,CAAC,CAAC,mBAAK,CAAC,YAAY,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,IAAI,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CACjE,CAAC;AACJ,CAAC;AAWD;;;GAGG;AACH,MAAM,iBAAiB,GAAkB;IACvC,mBAAmB,EAAE,yCAAwB,CAAC,GAAG,EAAE;IACnD,cAAc,EAAE,oCAAmB,CAAC,SAAS;IAC3C,qEAAqE;IACrE,2EAA2E;IAC3E,2EAA2E;IAC3E,iBAAiB;IACjB,uHAAuH;IACvH,QAAQ,EAAE,4CAA4C;IACtD,KAAK,EAAE,mCAAmC;IAC1C,UAAU,EAAE,kBAAkB;IAC9B,wBAAwB,EAAE,8BAA8B;IACxD,sBAAsB,EAAE,oBAAoB;IAC5C,8BAA8B,EAAE,4BAA4B;IAC5D,wBAAwB,CAIzB;IACD,cAAc,EAAE,oCAAmB,CAAC,GAAG,EAAE;IACzC,0BAA0B,EAAE,IAAI;IAChC,wBAAwB,EAAE,IAAI;CAC/B,CAAC;AAEF;;;;GAIG;AACH,MAAM,kBAAkB,GAAkB;IACxC,mBAAmB,EAAE,yCAAwB,CAAC,IAAI,EAAE;IACpD,cAAc,EAAE,oCAAmB,CAAC,IAAI,EAAE;IAC1C,cAAc,EAAE,oCAAmB,CAAC,IAAI,EAAE;IAC1C,0BAA0B,EAAE,KAAK;IACjC,wBAAwB,EAAE,KAAK;CAChC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,2BAA2B,GAAG,EAAE,CAAC;AAEvC;;;GAGG;AACH,SAAS,iBAAiB,CAAC,IAAY;IACrC,OAAO,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK,GAAG,IAAI,sCAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACzE,CAAC;AACD;;;;GAIG;AACH,MAAM,sBAAsB,GAAG,GAAG,CAAC;AACnC,MAAM,qBAAqB,GAAG,KAAK,CAAC;AACpC,8CAA8C;AAC9C,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAEpC;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAS,aAAa,CAAC,IAAY;IACjC,OAAO,CAAC,GAAG,IAAI,CAAC;SACb,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACZ,iBAAiB,CAAC,IAAI,CAAC;QACrB,CAAC,CAAC,IAAI;QACN,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAChD;SACA,IAAI,CAAC,EAAE,CAAC,CAAC;AACd,CAAC","sourcesContent":["import { Annotations, Duration, Stack, Token } from \"aws-cdk-lib\";\nimport { ICertificate } from \"aws-cdk-lib/aws-certificatemanager\";\nimport {\n  AccessLevel,\n  AddBehaviorOptions,\n  AllowedMethods,\n  BehaviorOptions,\n  CacheCookieBehavior,\n  CacheHeaderBehavior,\n  CachePolicy,\n  CachePolicyProps,\n  CacheQueryStringBehavior,\n  CachedMethods,\n  Function as CloudFrontFunction,\n  Distribution,\n  FunctionAssociation,\n  FunctionCode,\n  FunctionEventType,\n  FunctionProps,\n  FunctionRuntime,\n  HeadersFrameOption,\n  HeadersReferrerPolicy,\n  HttpVersion,\n  IKeyValueStore,\n  IOrigin,\n  IOriginRequestPolicy,\n  OriginProtocolPolicy,\n  OriginRequestPolicy,\n  ResponseHeadersPolicy,\n  ResponseHeadersPolicyProps,\n  ResponseSecurityHeadersBehavior,\n  SecurityPolicyProtocol,\n  ViewerProtocolPolicy,\n} from \"aws-cdk-lib/aws-cloudfront\";\nimport {\n  FunctionUrlOrigin,\n  FunctionUrlOriginWithOACProps,\n  S3BucketOrigin,\n  VpcOrigin,\n  VpcOriginWithEndpointProps,\n} from \"aws-cdk-lib/aws-cloudfront-origins\";\nimport { IApplicationLoadBalancer } from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport { CfnPermission, IFunctionUrl } from \"aws-cdk-lib/aws-lambda\";\nimport { IBucket } from \"aws-cdk-lib/aws-s3\";\nimport { Construct } from \"constructs\";\nimport {\n  cloudFrontPatternRegex,\n  DEFAULT_FUNCTION_GROUP,\n  PATH_PATTERN_LITERAL,\n} from \"./adapter/function-groups\";\nimport { LOG_PREFIX, NextjsType } from \"./constants\";\nimport { OptionalDistributionProps } from \"./generated-structs/OptionalDistributionProps\";\nimport { OptionalS3OriginBucketWithOACProps } from \"./generated-structs/OptionalS3OriginBucketWithOACProps\";\nimport {\n  NextjsFunctionGroupBehavior,\n  PublicDirEntry,\n} from \"./nextjs-build/nextjs-build\";\nimport { assetPrefixPath, normalizeBasePath } from \"./utils/base-path\";\nimport {\n  assetPrefixRewriteHandler,\n  checkViewerRequestCode,\n  MAX_FUNCTION_CODE_BYTES,\n  PASS_THROUGH_HANDLER,\n  spliceViewerRequest,\n  X_FORWARDED_HOST_HANDLER,\n} from \"./utils/viewer-request-functions\";\n\nexport interface NextjsDistributionOverrides {\n  readonly distributionProps?: OptionalDistributionProps;\n  readonly imageBehaviorOptions?: AddBehaviorOptions;\n  readonly imageCachePolicyProps?: CachePolicyProps;\n  readonly imageResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;\n  readonly dynamicBehaviorOptions?: AddBehaviorOptions;\n  readonly dynamicCachePolicyProps?: CachePolicyProps;\n  readonly dynamicResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;\n  readonly dynamicFunctionUrlOriginWithOACProps?: FunctionUrlOriginWithOACProps;\n  readonly dynamicVpcOriginWithEndpointProps?: VpcOriginWithEndpointProps;\n  readonly staticBehaviorOptions?: AddBehaviorOptions;\n  readonly staticResponseHeadersPolicyProps?: ResponseHeadersPolicyProps;\n  readonly s3BucketOriginProps?: OptionalS3OriginBucketWithOACProps;\n}\n\nexport interface NextjsDistributionProps {\n  /**\n   * Bucket containing static assets.\n   * Must be provided if you want to serve static files.\n   */\n  readonly assetsBucket: IBucket;\n  /**\n   * The app's own `assetPrefix`. Next.js emits `<assetPrefix>/_next/static/...`\n   * for every bundle while the objects stay at `<basePath>/_next/static/...` in\n   * S3, so the prefix's path gets a cache behavior of its own that rewrites it\n   * away.\n   *\n   * Either form is accepted: a path (\"/cdn\"), or an absolute URL, in which case\n   * only its path counts (\"https://cdn.example.com/cdn\" behaves as \"/cdn\", and\n   * \"https://cdn.example.com\" needs no behavior at all). An absolute prefix's path\n   * matters because `next build` compiles a `/cdn/_next/:path+` rewrite of its\n   * own, so `next start` serves every bundle under it — a CDN fronting this\n   * distribution there has to be answered too.\n   *\n   * Applied on top of `basePath`, not under it, because that is how Next.js\n   * builds the URL.\n   *\n   * @default - none; pass `NextjsBuild.nextConfigAssetPrefixPath`\n   */\n  readonly assetPrefix?: string;\n  /**\n   * URI path prefix the app is served at. Surrounding slashes are normalized\n   * away, so \"/base\", \"base\" and \"/base/\" all produce the same cache behaviors.\n   */\n  readonly basePath?: string;\n  /**\n   * Optional but only applicable for `NextjsType.GLOBAL_CONTAINERS`\n   */\n  readonly certificate?: ICertificate;\n  readonly distribution?: Distribution;\n  /**\n   * Required if `NextjsType.GLOBAL_FUNCTIONS`\n   */\n  readonly functionUrl?: IFunctionUrl;\n  /**\n   * Required if `NextjsType.GLOBAL_CONTAINERS` or `NextjsType.REGIONAL_CONTAINERS`\n   */\n  readonly loadBalancer?: IApplicationLoadBalancer;\n  readonly nextjsType: NextjsType;\n  /**\n   * Override props for every construct.\n   */\n  readonly overrides?: NextjsDistributionOverrides;\n  /**\n   * Entries (files/directories) within Next.js app's public directory. Used to\n   * add static behaviors to distribution.\n   */\n  readonly publicDirEntries: PublicDirEntry[];\n  /**\n   * The `Service-Worker-Allowed` header for `_next/static/service-worker/*`,\n   * which Next.js sends so a compiled service worker can register at a scope\n   * wider than its own directory, such as `/`. S3 can't send an arbitrary\n   * header, so setting this adds a behavior for those files whose response\n   * headers policy does. Next.js uses the app's `basePath`, or `/` for none.\n   * @default - no behavior; the build has no service worker\n   */\n  readonly serviceWorkerAllowed?: string;\n  /**\n   * The non-`default` function groups, the origins\n   * {@link functionGroupBehaviors} route to.\n   * @default - no splitting; the default behavior serves every dynamic route\n   */\n  readonly functionGroups?: NextjsDistributionFunctionGroup[];\n  /**\n   * `NextjsBuild.functionGroupBehaviors`: one cache behavior each, added in\n   * order, so the routes each group was packaged with reach it rather than the\n   * default function.\n   * @default - none\n   */\n  readonly functionGroupBehaviors?: NextjsFunctionGroupBehavior[];\n  /**\n   * The most cache behaviors the distribution may have, the default one\n   * included. cdk-nextjs counts what it adds against this at synth, so running\n   * out is a synth error naming what used them rather than a failed deploy.\n   *\n   * Raise it after raising the \"Cache behaviors per distribution\" quota for\n   * your account. Lower it by the behaviors a supplied {@link distribution}\n   * (or `overrides.distributionProps`) already has, which are not counted.\n   * @default 75 - CloudFront's default quota\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions\n   */\n  readonly maxCacheBehaviors?: number;\n  /**\n   * CloudFront Function code run first on every viewer request, on every\n   * behavior cdk-nextjs adds, static assets included — HTTP Basic auth on a\n   * pre-launch site, geo-gating.\n   *\n   * It must define `viewerRequest(event)` (a function, sync or async, or a\n   * `var`/`let`/`const`): return a response to answer the viewer, or the\n   * request (or nothing) to carry on. It is spliced into cdk-nextjs's own\n   * viewer-request functions, ahead of their logic, so it may not use the\n   * name `handler`, and the combined function must fit CloudFront's 10 KB.\n   * It runs on `cloudfront-js-2.0`, so it may be async and read\n   * {@link viewerRequestKeyValueStore} with `cf.kvs()`. A bring-your-own\n   * {@link distribution}'s default behavior isn't covered.\n   *\n   * @default - none\n   * @see https://github.com/cdklabs/cdk-nextjs#running-code-on-every-viewer-request\n   */\n  readonly viewerRequestFunctionCode?: FunctionCode;\n  /**\n   * A CloudFront KeyValueStore associated with every viewer-request function\n   * {@link viewerRequestFunctionCode} is copied into (up to three, one per kind\n   * of behavior), so values it reads — Basic auth credentials, an allowlist —\n   * live outside the CloudFormation template and change without a deploy.\n   * Read it with `cf.kvs()`, no ID needed.\n   * @default - none\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/functions-custom-methods.html\n   */\n  readonly viewerRequestKeyValueStore?: IKeyValueStore;\n}\n\n/** A non-default function group and the origin its routes must reach. */\nexport interface NextjsDistributionFunctionGroup {\n  readonly name: string;\n  /** The group's Lambda Function URL. */\n  readonly functionUrl: IFunctionUrl;\n}\n\nexport class NextjsDistribution extends Construct {\n  distribution: Distribution;\n\n  private props: NextjsDistributionProps;\n  /**\n   * `props.basePath` normalized to a bare path segment. This construct is the\n   * one place that needs it with a leading slash — CloudFront path patterns are\n   * written against the request path — so it prepends its own rather than\n   * relying on the caller having passed one.\n   */\n  private basePath: string;\n  /**\n   * `props.assetPrefix` normalized to a leading-slash path, `\"\"` when the app\n   * sets none or sets one that already equals the `basePath` prefix — in which\n   * case the ordinary `_next/static*` behavior already covers it and a second one\n   * would be a duplicate pattern CloudFront rejects.\n   */\n  private assetPrefix: string;\n  /**\n   * Common security headers applied by default to all origins\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-response-headers-policies.html#managed-response-headers-policies-security\n   */\n  private commonSecurityHeadersBehavior: ResponseSecurityHeadersBehavior = {\n    contentTypeOptions: { override: false },\n    frameOptions: {\n      frameOption: HeadersFrameOption.SAMEORIGIN,\n      override: false,\n    },\n    referrerPolicy: {\n      override: false,\n      referrerPolicy: HeadersReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN,\n    },\n\n    strictTransportSecurity: {\n      accessControlMaxAge: Duration.days(365),\n      includeSubdomains: true,\n      override: false,\n      preload: true,\n    },\n    xssProtection: { override: false, protection: true, modeBlock: true },\n  };\n  private staticOrigin: IOrigin;\n  private dynamicOrigin: IOrigin;\n  private dynamicOriginResponsePolicy: IOriginRequestPolicy;\n  private dynamicCloudFrontFunctionAssociations: FunctionAssociation[];\n  /**\n   * `viewerRequestFunctionCode`, rendered and checked once, since\n   * `FunctionCode.fromFile` reads the file on every render.\n   */\n  private viewerRequestCode?: string;\n  /**\n   * The viewer-request function `viewerRequestFunctionCode` adds to behaviors\n   * with no viewer-request logic of their own, shared by all of them, so the\n   * `assetPrefix` behavior, which has a viewer-request function of its own,\n   * can tell it from an override's.\n   */\n  private passThroughFunction?: CloudFrontFunction;\n  private isFunctionCompute: boolean;\n  private staticBehaviorOptions: BehaviorOptions;\n  private dynamicBehaviorOptions: BehaviorOptions;\n  private imageBehaviorOptions: BehaviorOptions;\n\n  constructor(scope: Construct, id: string, props: NextjsDistributionProps) {\n    super(scope, id);\n    this.props = props;\n    if (props.viewerRequestKeyValueStore && !props.viewerRequestFunctionCode) {\n      throw new Error(\n        `${LOG_PREFIX} \\`viewerRequestKeyValueStore\\` is only associated with ` +\n          `the functions \\`viewerRequestFunctionCode\\` runs in, so it needs ` +\n          `\\`viewerRequestFunctionCode\\` to read it.`,\n      );\n    }\n    this.viewerRequestCode = this.renderViewerRequestCode();\n    this.basePath = normalizeBasePath(props.basePath);\n    this.assetPrefix = this.resolveAssetPrefix();\n    this.staticOrigin = this.createStaticOrigin();\n    this.isFunctionCompute = props.nextjsType === NextjsType.GLOBAL_FUNCTIONS;\n    this.validateFunctionGroupProps();\n    this.dynamicOrigin = this.createDynamicOrigin();\n    this.dynamicOriginResponsePolicy = this.createDynamicOriginRequestPolicy();\n    this.dynamicCloudFrontFunctionAssociations =\n      this.createDynamicCloudFrontFunctionAssociations();\n    this.staticBehaviorOptions = this.createStaticBehaviorOptions();\n    this.dynamicBehaviorOptions = this.createDynamicBehaviorOptions();\n    this.imageBehaviorOptions = this.createImageBehaviorOptions();\n    this.distribution = this.getDistribution();\n    if (this.isFunctionCompute) {\n      this.grantInvoke(DEFAULT_FUNCTION_GROUP, props.functionUrl!);\n    }\n    this.addStaticBehaviors();\n    this.addDynamicBehaviors();\n  }\n\n  /**\n   * Creates a CloudFront comment that is safe for the 128 character limit.\n   * If the full comment with stack name exceeds 128 characters, returns the base comment only.\n   * @param baseComment The base comment text\n   * @param stackName The stack name to append\n   * @returns A comment string that is guaranteed to be < 128 characters\n   */\n  private getComment(baseComment: string, stackName: string): string {\n    const fullComment = `${baseComment} for ${stackName}`;\n    return fullComment.length < 128 ? fullComment : baseComment;\n  }\n\n  private createStaticOrigin(): IOrigin {\n    return S3BucketOrigin.withOriginAccessControl(this.props.assetsBucket, {\n      // LIST lets S3 answer a missing key with 404 instead of 403\n      originAccessLevels: [AccessLevel.READ, AccessLevel.LIST],\n      ...this.props.overrides?.s3BucketOriginProps,\n    });\n  }\n  private createDynamicOrigin(): IOrigin {\n    if (this.isFunctionCompute) {\n      if (!this.props.functionUrl) {\n        throw new Error(\"Missing NextjsDistributionProps.functionUrl\");\n      }\n      return FunctionUrlOrigin.withOriginAccessControl(\n        this.props.functionUrl,\n        this.props.overrides?.dynamicFunctionUrlOriginWithOACProps,\n      );\n    } else {\n      const loadBalancer = this.props.loadBalancer;\n      if (!loadBalancer) {\n        throw new Error(\"Missing NextjsDistributionProps.loadBalancer\");\n      }\n      return VpcOrigin.withApplicationLoadBalancer(loadBalancer, {\n        protocolPolicy: this.props.certificate\n          ? OriginProtocolPolicy.HTTPS_ONLY\n          : OriginProtocolPolicy.HTTP_ONLY,\n        ...this.props.overrides?.dynamicVpcOriginWithEndpointProps,\n      });\n    }\n  }\n  /**\n   * Lambda Function URLs \"expect the `Host` header to contain the origin domain\n   * name, not the domain name of the CloudFront distribution.\"\n   *\n   * A container origin also gets CloudFront's own headers, for\n   * `CloudFront-Forwarded-Proto`: without a certificate CloudFront reaches the\n   * ALB over plain HTTP, so the ALB's `X-Forwarded-Proto` is `http`, and the\n   * runtime would build every absolute URL (`request.url`, the origin a server\n   * action is forwarded to) as `http://` behind a viewer on HTTPS.\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html#managed-origin-request-policy-all-viewer-except-host-header\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html#managed-origin-request-policy-all-viewer-and-cloudfront\n   */\n  private createDynamicOriginRequestPolicy(): IOriginRequestPolicy {\n    return this.isFunctionCompute\n      ? OriginRequestPolicy.ALL_VIEWER_EXCEPT_HOST_HEADER\n      : OriginRequestPolicy.ALL_VIEWER_AND_CLOUDFRONT_2022;\n  }\n  /**\n   * Ensures Next.js `request.url` will be correct domain instead of URL of\n   * compute (Lambda or Fargate)\n   * @see https://open-next.js.org/advanced/workaround#workaround-set-x-forwarded-host-header-aws-specific\n   */\n  private createDynamicCloudFrontFunctionAssociations(): FunctionAssociation[] {\n    const associations: FunctionAssociation[] = [];\n    if (this.isFunctionCompute) {\n      const cloudFrontFn = new CloudFrontFunction(this, \"CloudFrontFn\", {\n        ...this.viewerRequestFunctionProps(X_FORWARDED_HOST_HANDLER),\n      });\n      associations.push({\n        eventType: FunctionEventType.VIEWER_REQUEST,\n        function: cloudFrontFn,\n      });\n    } else if (this.viewerRequestCode !== undefined) {\n      // Containers need no function of their own — their origin sees the\n      // viewer's `Host` — so this one only runs the user's code.\n      associations.push({\n        eventType: FunctionEventType.VIEWER_REQUEST,\n        function: this.getPassThroughFunction(),\n      });\n    }\n    return associations;\n  }\n  /**\n   * The function a behavior with no viewer-request logic of its own gets when\n   * `viewerRequestFunctionCode` is set, created on first use.\n   */\n  private getPassThroughFunction() {\n    this.passThroughFunction ??= new CloudFrontFunction(\n      this,\n      \"ViewerRequestFn\",\n      {\n        comment: this.getComment(\n          \"NextJS viewer request\",\n          Stack.of(this).stackName,\n        ),\n        ...this.viewerRequestFunctionProps(PASS_THROUGH_HANDLER),\n      },\n    );\n    return this.passThroughFunction;\n  }\n  /**\n   * The code, runtime and KeyValueStore of a function whose `handler` is\n   * cdk-nextjs's, with `viewerRequestFunctionCode` spliced in\n   * ({@link spliceViewerRequest}) and checked against CloudFront's size limit.\n   *\n   * Every one runs on `cloudfront-js-2.0`, the runtime AWS recommends and the\n   * one with `async` and KeyValueStores, so the handlers are all `async`\n   * whether or not there is user code to await.\n   */\n  private viewerRequestFunctionProps(\n    handler: string,\n  ): Pick<FunctionProps, \"code\" | \"runtime\" | \"keyValueStore\"> {\n    const userCode = this.viewerRequestCode;\n    const code = spliceViewerRequest(handler, userCode);\n    if (userCode === undefined) {\n      return {\n        code: FunctionCode.fromInline(code),\n        runtime: FunctionRuntime.JS_2_0,\n      };\n    }\n    const size = Buffer.byteLength(code);\n    if (Token.isUnresolved(code)) {\n      // A token's placeholder isn't the length of what it resolves to.\n      Annotations.of(this).addWarning(\n        `${LOG_PREFIX} \\`viewerRequestFunctionCode\\` contains a CDK token, so ` +\n          `its size can't be checked against CloudFront's limit of ` +\n          `${MAX_FUNCTION_CODE_BYTES} bytes until deploy.`,\n      );\n    } else if (size > MAX_FUNCTION_CODE_BYTES) {\n      throw new Error(\n        `${LOG_PREFIX} \\`viewerRequestFunctionCode\\` makes a CloudFront ` +\n          `Function of ${size} bytes, cdk-nextjs's own code included, over ` +\n          `CloudFront's limit of ${MAX_FUNCTION_CODE_BYTES}. Shorten it ` +\n          `(comments and whitespace count). See ` +\n          `https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-functions`,\n      );\n    }\n    return {\n      code: FunctionCode.fromInline(code),\n      runtime: FunctionRuntime.JS_2_0,\n      keyValueStore: this.props.viewerRequestKeyValueStore,\n    };\n  }\n  /**\n   * `viewerRequestFunctionCode`, rendered once, since `FunctionCode.fromFile`\n   * reads the file on every render, and checked\n   * ({@link checkViewerRequestCode}).\n   */\n  private renderViewerRequestCode(): string | undefined {\n    const userCode = this.props.viewerRequestFunctionCode?.render();\n    if (userCode === undefined) {\n      return undefined;\n    }\n    checkViewerRequestCode(userCode);\n    return userCode;\n  }\n  /**\n   * CloudFront allows one function per event type per behavior, so an\n   * override's viewer-request association and one cdk-nextjs needs can't both\n   * be kept. Thrown at synth, where both halves are known, rather than left to\n   * a deploy that names neither.\n   */\n  private assertViewerRequestUnclaimed(\n    overrideName: string,\n    associations: FunctionAssociation[] | undefined,\n    needs: string,\n  ) {\n    const claimed = (associations ?? []).some(\n      (association) =>\n        association.eventType === FunctionEventType.VIEWER_REQUEST,\n    );\n    if (claimed) {\n      throw new Error(\n        `${LOG_PREFIX} \\`overrides.${overrideName}.functionAssociations\\` ` +\n          `associates a CloudFront function with ` +\n          `${FunctionEventType.VIEWER_REQUEST}, but ${needs}. ` +\n          `CloudFront permits only one function per event type per behavior. ` +\n          `Move the logic into \\`viewerRequestFunctionCode\\`, which runs ` +\n          `inside cdk-nextjs's own viewer-request function on every behavior.`,\n      );\n    }\n  }\n  private createStaticBehaviorOptions(): BehaviorOptions {\n    const staticBehaviorOptions = this.props.overrides?.staticBehaviorOptions;\n    const responseHeadersPolicy =\n      staticBehaviorOptions?.responseHeadersPolicy ??\n      new ResponseHeadersPolicy(this, \"StaticResponseHeadersPolicy\", {\n        securityHeadersBehavior: this.commonSecurityHeadersBehavior,\n        comment: this.getComment(\n          \"NextJS Static Response Headers Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.staticResponseHeadersPolicyProps,\n      });\n    const options: BehaviorOptions = {\n      allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,\n      cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,\n      cachePolicy: CachePolicy.CACHING_OPTIMIZED,\n      origin: this.staticOrigin,\n      responseHeadersPolicy,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      ...staticBehaviorOptions,\n    };\n    if (this.viewerRequestCode === undefined) {\n      return options;\n    }\n    this.assertViewerRequestUnclaimed(\n      \"staticBehaviorOptions\",\n      staticBehaviorOptions?.functionAssociations,\n      \"`viewerRequestFunctionCode` needs that event type on the static behaviors\",\n    );\n    return {\n      ...options,\n      functionAssociations: [\n        ...(staticBehaviorOptions?.functionAssociations ?? []),\n        {\n          eventType: FunctionEventType.VIEWER_REQUEST,\n          function: this.getPassThroughFunction(),\n        },\n      ],\n    };\n  }\n  private createDynamicBehaviorOptions(): BehaviorOptions {\n    const dynamicBehaviorOptions = this.props.overrides?.dynamicBehaviorOptions;\n    const cachePolicyProps = this.props.overrides?.dynamicCachePolicyProps;\n    // create default cache policy if not provided\n    const cachePolicy =\n      dynamicBehaviorOptions?.cachePolicy ??\n      new CachePolicy(this, \"DynamicCachePolicy\", {\n        ...(isCachingDisabled(cachePolicyProps)\n          ? DISABLED_CACHE_KEY\n          : DYNAMIC_CACHE_KEY),\n        // A response with no `Cache-Control` is not cached, which is what Next.js\n        // and every app written for it assume: a dynamic route handler sets none.\n        // CDK's default is a day, which cached `/api/*` responses at the edge for\n        // 24 hours. Anything Next.js *means* to cache - ISR, SSG, a PPR shell -\n        // says so with `s-maxage`, which `maxTtl` still honors.\n        defaultTtl: Duration.seconds(0),\n        comment: this.getComment(\n          \"NextJS Dynamic Cache Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...cachePolicyProps,\n      });\n    const responseHeadersPolicy =\n      dynamicBehaviorOptions?.responseHeadersPolicy ??\n      new ResponseHeadersPolicy(this, \"DynamicResponseHeadersPolicy\", {\n        securityHeadersBehavior: this.commonSecurityHeadersBehavior,\n        comment: this.getComment(\n          \"NextJS Dynamic Response Headers Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.dynamicResponseHeadersPolicyProps,\n      });\n    return {\n      allowedMethods: AllowedMethods.ALLOW_ALL,\n      cachePolicy,\n      origin: this.dynamicOrigin,\n      originRequestPolicy: this.dynamicOriginResponsePolicy,\n      responseHeadersPolicy,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      ...dynamicBehaviorOptions,\n      functionAssociations: this.withDynamicFunctionAssociations(\n        \"dynamicBehaviorOptions\",\n        dynamicBehaviorOptions?.functionAssociations,\n      ),\n    };\n  }\n  /**\n   * The behavior's function associations: an override's, plus the viewer-request\n   * function Global Functions depends on, or the one `viewerRequestFunctionCode`\n   * adds on Global Containers.\n   *\n   * Spreading the override's `functionAssociations` over ours would silently\n   * drop that function, and with it the only thing standing between a viewer's\n   * own `X-Forwarded-Host` and the runtime, which trusts that header on Function\n   * URL events (`lambda-event.ts`): host injection into redirects and absolute\n   * URLs, cached for other viewers because the header is not in the cache key.\n   * So ours is kept, and an override claiming VIEWER_REQUEST — which CloudFront\n   * allows only one of per behavior — is an error rather than a replacement.\n   */\n  private withDynamicFunctionAssociations(\n    overrideName: string,\n    overridden: FunctionAssociation[] | undefined,\n  ): FunctionAssociation[] {\n    const ours = this.dynamicCloudFrontFunctionAssociations;\n    if (!overridden) {\n      return ours;\n    }\n    if (!ours.length) {\n      return overridden;\n    }\n    this.assertViewerRequestUnclaimed(\n      overrideName,\n      overridden,\n      this.isFunctionCompute\n        ? `NextjsGlobalFunctions needs that event type for its own function, ` +\n            `which overwrites \\`x-forwarded-host\\` with the viewer's \\`Host\\` ` +\n            `(the runtime trusts that header behind CloudFront) and redirects ` +\n            `repeated slashes`\n        : \"`viewerRequestFunctionCode` needs that event type on the dynamic \" +\n            \"and image behaviors\",\n    );\n    return [...overridden, ...ours];\n  }\n  /**\n   * `_next/image*` goes to the same origin as everything else — the Next.js\n   * server optimizes images in-process — but keeps its own behavior for the\n   * cache policy: `queryStringBehavior: all()` plus `accept` in the cache key is\n   * right for image requests and wrong for the rest.\n   */\n  private createImageBehaviorOptions(): BehaviorOptions {\n    const imageBehaviorOptions = this.props.overrides?.imageBehaviorOptions;\n    // add default cache policy if not provided\n    const cachePolicy =\n      imageBehaviorOptions?.cachePolicy ??\n      new CachePolicy(this, \"ImageCachePolicy\", {\n        // SECURITY NOTE: by default we don't include cookies in cache for\n        // images b/c it significantly improves image perf for most sites BUT\n        // if you have private images locked behind auth implemented with cookies\n        // you need to override this.\n        queryStringBehavior: CacheQueryStringBehavior.all(),\n        headerBehavior: CacheHeaderBehavior.allowList(\"accept\"),\n        cookieBehavior: CacheCookieBehavior.none(),\n        enableAcceptEncodingBrotli: true,\n        enableAcceptEncodingGzip: true,\n        comment: this.getComment(\n          \"NextJS Image Cache Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.imageCachePolicyProps,\n      });\n    // add default response headers policy if not provided\n    const responseHeadersPolicy =\n      imageBehaviorOptions?.responseHeadersPolicy ??\n      new ResponseHeadersPolicy(this, \"ImageResponseHeadersPolicy\", {\n        securityHeadersBehavior: this.commonSecurityHeadersBehavior,\n        comment: this.getComment(\n          \"NextJS Image Response Headers Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.imageResponseHeadersPolicyProps,\n      });\n    return {\n      allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,\n      cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,\n      origin: this.dynamicOrigin,\n      originRequestPolicy: this.dynamicOriginResponsePolicy,\n      cachePolicy,\n      responseHeadersPolicy,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      ...imageBehaviorOptions,\n      functionAssociations: this.withDynamicFunctionAssociations(\n        \"imageBehaviorOptions\",\n        imageBehaviorOptions?.functionAssociations,\n      ),\n    };\n  }\n  /**\n   * Creates or uses user specified CloudFront Distribution\n   */\n  private getDistribution(): Distribution {\n    let distribution: Distribution;\n    if (this.props.distribution) {\n      distribution = this.props.distribution;\n    } else {\n      // Under a `basePath`, the behaviors cdk-nextjs adds for it serve the\n      // app, so the default behavior is the user's to replace.\n      if (\n        this.viewerRequestCode !== undefined &&\n        !this.basePath &&\n        this.props.overrides?.distributionProps?.defaultBehavior\n      ) {\n        throw new Error(\n          `${LOG_PREFIX} \\`overrides.distributionProps.defaultBehavior\\` ` +\n            `replaces the default behavior cdk-nextjs builds, and with it the ` +\n            `viewer-request function \\`viewerRequestFunctionCode\\` runs in, ` +\n            `so pages and API routes would skip it. Customize the default ` +\n            `behavior through \\`overrides.dynamicBehaviorOptions\\` instead.`,\n        );\n      }\n      distribution = new Distribution(this, \"Distribution\", {\n        minimumProtocolVersion: SecurityPolicyProtocol.TLS_V1_2_2021,\n        defaultBehavior: this.dynamicBehaviorOptions,\n        // best to use HTTP 2 and 3 for compatability (HTTP 2) and performance (HTTP3)\n        // CloudFront will choose best option for client\n        httpVersion: HttpVersion.HTTP2_AND_3,\n        comment: this.getComment(\n          \"NextJS Distribution\",\n          Stack.of(this).stackName,\n        ),\n        ...this.props.overrides?.distributionProps,\n      });\n    }\n    return distribution;\n  }\n  private addDynamicBehaviors() {\n    // Image Behavior\n    this.distribution.addBehavior(\n      this.getPathPattern(\"_next/image*\"),\n      this.imageBehaviorOptions.origin,\n      this.imageBehaviorOptions,\n    );\n    // Function group behaviors, before the basePath catch-all below and after\n    // `_next/image*` (no group pattern can match an image request, and keeping\n    // the order of the unsplit case byte-identical is worth more than symmetry).\n    this.addFunctionGroupBehaviors();\n    // Root Path Behaviors\n    if (this.basePath) {\n      // because we already have a basePath we don't use / instead we use /base-path\n      this.distribution.addBehavior(\n        `/${this.basePath}`,\n        this.dynamicBehaviorOptions.origin,\n        this.dynamicBehaviorOptions,\n      );\n      // when basePath is set, we emulate the \"default behavior\" (*) for the site as `/base-path/*`\n      this.distribution.addBehavior(\n        this.getPathPattern(\"*\"),\n        this.dynamicBehaviorOptions.origin,\n        this.dynamicBehaviorOptions,\n      );\n    } else {\n      // if no base path, then default behavior will handle all other paths\n    }\n  }\n  /**\n   * Before any behavior is computed: the budget and the `public/` checks both\n   * generate the group patterns, and would otherwise fail first with a less\n   * useful message.\n   */\n  private validateFunctionGroupProps() {\n    if (\n      !this.props.functionGroups?.length &&\n      !this.props.functionGroupBehaviors?.length\n    ) {\n      return;\n    }\n    if (!this.isFunctionCompute) {\n      throw new Error(\n        \"`functionGroups` is only supported by NextjsGlobalFunctions.\",\n      );\n    }\n  }\n  /**\n   * Every group behavior, final path pattern included, in the order\n   * {@link addFunctionGroupBehaviors} adds them.\n   */\n  private functionGroupBehaviors() {\n    return (this.props.functionGroupBehaviors ?? []).map((behavior) => {\n      const group = this.props.functionGroups?.find(\n        (it) => it.name === behavior.group,\n      );\n      if (!group) {\n        throw new Error(\n          `${LOG_PREFIX} \\`functionGroupBehaviors\\` routes to function group ` +\n            `\"${behavior.group}\", which is not in \\`functionGroups\\`.`,\n        );\n      }\n      return {\n        ...behavior,\n        group,\n        pathPattern: this.getPathPattern(behavior.pattern),\n      };\n    });\n  }\n  /**\n   * One behavior per group pattern, most specific first.\n   *\n   * The order is the whole mechanism. CloudFront evaluates behaviors in order\n   * and stops at the first whose path pattern matches, and `addBehavior`\n   * appends — so `api/*` added before `api/reports/*` would swallow every\n   * report request and send it to a function whose package has no report\n   * entrypoint. The adapter sorted the list when it checked it against how\n   * `assignRoutesToGroups` packaged the same routes, so it is added as it is.\n   */\n  private addFunctionGroupBehaviors() {\n    const originPerGroup = new Map<string, IOrigin>();\n    for (const { group, pathPattern } of this.functionGroupBehaviors()) {\n      let origin = originPerGroup.get(group.name);\n      if (!origin) {\n        origin = FunctionUrlOrigin.withOriginAccessControl(\n          group.functionUrl,\n          this.props.overrides?.dynamicFunctionUrlOriginWithOACProps,\n        );\n        originPerGroup.set(group.name, origin);\n        this.grantInvoke(group.name, group.functionUrl);\n      }\n      // Same behavior options as every other dynamic route — only the origin\n      // differs, and it is passed separately.\n      const { origin: _ignored, ...behaviorOptions } =\n        this.dynamicBehaviorOptions;\n      this.distribution.addBehavior(pathPattern, origin, behaviorOptions);\n    }\n  }\n  /**\n   * `lambda:InvokeFunction` for CloudFront, which a Function URL behind OAC\n   * needs besides the `lambda:InvokeFunctionUrl` `FunctionUrlOrigin` grants,\n   * and scoped the same way: to this distribution, and to calls that come\n   * through the Function URL.\n   */\n  private grantInvoke(group: string, functionUrl: IFunctionUrl) {\n    new CfnPermission(this, `InvokeFunction-${group}`, {\n      action: \"lambda:InvokeFunction\",\n      principal: \"cloudfront.amazonaws.com\",\n      functionName: functionUrl.functionArn,\n      sourceArn: this.distribution.distributionArn,\n      invokedViaFunctionUrl: true,\n    });\n  }\n  /**\n   * The `assetPrefix` path that needs a behavior of its own, or `\"\"` for none.\n   *\n   * An absolute prefix contributes its *path*: \"https://cdn.example.com\" needs no\n   * behavior, but \"https://cdn.example.com/cdn\" does, because `next build`\n   * compiles a `/cdn/_next/:path+` rewrite of its own and `next start` serves\n   * every bundle under that path — so a CDN fronting this distribution there has\n   * to be answered. A prefix equal to the `basePath` prefix is dropped — that is\n   * the Next.js default when `basePath` is set, and `_next/static*` already\n   * resolves under it, so adding a second identical pattern would make CloudFront\n   * reject the distribution.\n   */\n  private resolveAssetPrefix(): string {\n    const prefix = assetPrefixPath(this.props.assetPrefix ?? \"\");\n    return normalizeBasePath(prefix) === this.basePath ? \"\" : prefix;\n  }\n  /**\n   * Serves `<assetPrefix>/_next/static/*` from the same S3 objects as\n   * `_next/static/*`.\n   *\n   * Needed because Next.js puts `assetPrefix` in front of every bundle URL it\n   * emits while the objects keep their `<basePath>/_next/static/...` keys, and\n   * `assetPrefix` sits on top of `basePath` rather than under it, so\n   * `getPathPattern` is deliberately not used here. Without this behavior the\n   * request falls through to the default one, reaches the compute origin, and\n   * 404s: the deployment package carries no `.next/static` directory at all.\n   *\n   * A viewer-request function does the rewrite because an S3 origin keys on the\n   * request URI and `originPath` can only prepend. The prefix is a synth-time\n   * literal, so the function is a fixed-length string operation rather than a\n   * parse.\n   */\n  private addAssetPrefixBehavior() {\n    // The static behaviors' own viewer-request function, when\n    // `viewerRequestFunctionCode` added one, gives way to the rewrite, which\n    // runs the same code first.\n    const associations = (\n      this.staticBehaviorOptions.functionAssociations ?? []\n    ).filter(\n      (association) => association.function !== this.passThroughFunction,\n    );\n    this.assertViewerRequestUnclaimed(\n      \"staticBehaviorOptions\",\n      associations,\n      `serving \\`assetPrefix\\` (\"${this.assetPrefix}\") needs that event type ` +\n        `to rewrite the request URI to the object's key`,\n    );\n    const rewrite = new CloudFrontFunction(this, \"AssetPrefixFn\", {\n      comment: this.getComment(\n        \"NextJS assetPrefix rewrite\",\n        Stack.of(this).stackName,\n      ),\n      ...this.viewerRequestFunctionProps(\n        assetPrefixRewriteHandler(this.basePath, this.assetPrefix),\n      ),\n    });\n    this.distribution.addBehavior(\n      `${this.assetPrefix}/_next/static*`,\n      this.staticOrigin,\n      {\n        ...this.staticBehaviorOptions,\n        functionAssociations: [\n          ...associations,\n          { eventType: FunctionEventType.VIEWER_REQUEST, function: rewrite },\n        ],\n      },\n    );\n  }\n  /**\n   * Serves `_next/static/service-worker/*` with `Service-Worker-Allowed`, which\n   * the browser requires before it registers a service worker at a scope above\n   * the script's own directory. Added ahead of `_next/static*`, which would\n   * otherwise match first.\n   *\n   * The policy is the static one plus the header, so security headers and any\n   * `staticResponseHeadersPolicyProps` still apply. A whole\n   * `staticBehaviorOptions.responseHeadersPolicy` can't be added to, so it is\n   * used as it is, with a warning.\n   */\n  private addServiceWorkerBehavior(serviceWorkerAllowed: string) {\n    const overridden =\n      this.props.overrides?.staticBehaviorOptions?.responseHeadersPolicy;\n    if (overridden) {\n      Annotations.of(this).addWarning(\n        `${LOG_PREFIX} \\`overrides.staticBehaviorOptions.responseHeadersPolicy\\` ` +\n          `is used for \\`_next/static/service-worker/*\\` too, so service ` +\n          `workers get no \\`Service-Worker-Allowed: ${serviceWorkerAllowed}\\` ` +\n          `unless that policy sends it, and registering one at a scope above ` +\n          `its own directory fails. Add the header to your policy, or set ` +\n          `\\`overrides.staticResponseHeadersPolicyProps\\` instead.`,\n      );\n    }\n    const props = this.props.overrides?.staticResponseHeadersPolicyProps;\n    const customHeaders = props?.customHeadersBehavior?.customHeaders ?? [];\n    const responseHeadersPolicy =\n      overridden ??\n      new ResponseHeadersPolicy(this, \"ServiceWorkerResponseHeadersPolicy\", {\n        securityHeadersBehavior: this.commonSecurityHeadersBehavior,\n        comment: this.getComment(\n          \"NextJS Service Worker Response Headers Policy\",\n          Stack.of(this).stackName,\n        ),\n        ...props,\n        // Policy names are unique per account, so the static policy's can't be\n        // reused as it is, and are at most 128 characters, so a suffix can't\n        // simply be added to one that is already that long.\n        responseHeadersPolicyName:\n          props?.responseHeadersPolicyName &&\n          `${\n            Token.isUnresolved(props.responseHeadersPolicyName)\n              ? props.responseHeadersPolicyName\n              : props.responseHeadersPolicyName.slice(\n                  0,\n                  MAX_POLICY_NAME_LENGTH - SERVICE_WORKER_SUFFIX.length,\n                )\n          }${SERVICE_WORKER_SUFFIX}`,\n        customHeadersBehavior: {\n          // One the override sets itself is kept.\n          customHeaders: customHeaders.some(\n            ({ header }) => header.toLowerCase() === \"service-worker-allowed\",\n          )\n            ? customHeaders\n            : [\n                ...customHeaders,\n                {\n                  header: \"Service-Worker-Allowed\",\n                  value: serviceWorkerAllowed,\n                  override: true,\n                },\n              ],\n        },\n      });\n    this.distribution.addBehavior(\n      this.getPathPattern(\"_next/static/service-worker/*\"),\n      this.staticOrigin,\n      { ...this.staticBehaviorOptions, responseHeadersPolicy },\n    );\n  }\n  private addStaticBehaviors() {\n    if (this.props.serviceWorkerAllowed !== undefined) {\n      this.addServiceWorkerBehavior(this.props.serviceWorkerAllowed);\n    }\n    this.distribution.addBehavior(\n      this.getPathPattern(\"_next/static*\"),\n      this.staticOrigin,\n      this.staticBehaviorOptions,\n    );\n    if (this.assetPrefix) {\n      this.addAssetPrefixBehavior();\n    }\n    const publicPathPatterns = this.publicPathPatterns();\n    this.assertBehaviorBudget(publicPathPatterns.length);\n    this.assertNoPublicCollisions(publicPathPatterns);\n    for (const pathPattern of publicPathPatterns) {\n      this.distribution.addBehavior(\n        pathPattern,\n        this.staticOrigin,\n        this.staticBehaviorOptions,\n      );\n    }\n  }\n  /**\n   * The behavior path pattern for each top-level `public/` entry, final form:\n   * `/*` for a directory and the basePath prefix both applied.\n   *\n   * An entry whose name has no character CloudFront can spell is left out, with\n   * a warning, rather than given a pattern of nothing but wildcards. `фото/` is\n   * `????????/*` — any 8-byte first segment — and public/ behaviors are added\n   * ahead of every compute behavior, so it would send `/products/42` and\n   * `/settings/*` to S3, which answers 403. Leaving the entry out costs its own\n   * files instead: those requests reach the compute, which does not have them,\n   * and 404. One literal character is enough to keep a pattern narrow —\n   * `????????.jpg` only matches `.jpg` requests — so only the all-wildcard ones\n   * go.\n   *\n   * The length limit is checked here, on the final pattern, rather than in\n   * {@link toPathPattern}: the `/*` and the basePath count against it too, and a\n   * pattern that passed without them failed at deploy instead.\n   */\n  private publicPathPatterns(): string[] {\n    const patterns: string[] = [];\n    const unmatchable: string[] = [];\n    for (const publicFile of this.props.publicDirEntries) {\n      const name = toPathPattern(publicFile.name);\n      if (!/[^?*/]/.test(name)) {\n        unmatchable.push(`\"${publicFile.name}\"`);\n        continue;\n      }\n      const pathPattern = this.getPathPattern(\n        publicFile.isDirectory ? `${name}/*` : name,\n      );\n      if (pathPattern.length > MAX_PATH_PATTERN_LENGTH) {\n        throw new Error(\n          `The public/ entry \"${publicFile.name}\" needs a ` +\n            `${pathPattern.length}-character CloudFront path pattern, over ` +\n            `the ${MAX_PATH_PATTERN_LENGTH}-character ` +\n            \"limit. Rename it, or move it into a subdirectory of public/ whose \" +\n            \"own name is short enough. See \" +\n            \"https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesCacheBehavior.html#DownloadDistValuesPathPattern\",\n        );\n      }\n      patterns.push(pathPattern);\n    }\n    if (unmatchable.length > 0) {\n      Annotations.of(this).addWarning(\n        `${LOG_PREFIX} These top-level public/ entries have no character a ` +\n          \"CloudFront path pattern can spell, so their pattern would be \" +\n          \"wildcards alone and would capture every app route of the same \" +\n          `length. They get no behavior, so their requests reach the server, ` +\n          `which reads them from S3 instead: ${unmatchable.join(\", \")}. To serve ` +\n          \"them from S3 directly, rename them, or move them into a public/ \" +\n          \"subdirectory whose name has at least one ASCII letter or digit.\",\n      );\n    }\n    return patterns;\n  }\n  /**\n   * Refuse a group behavior that a `public/` behavior would make unreachable.\n   *\n   * `public/` behaviors are added first, and CloudFront stops at the first match,\n   * so two cases send a group's route to S3 instead of its function — which is\n   * why this is checked at synth, where both sides are known:\n   * - the same pattern twice: `public/docs/` and `/docs/**` both deploy as\n   *   `docs/*`. The synth succeeded and CloudFront rejected the deploy.\n   * - a group pattern under a public directory: `/docs/guide/**` behind\n   *   `docs/*` deploys and never matches.\n   */\n  private assertNoPublicCollisions(publicPathPatterns: string[]) {\n    const publicRegexes = publicPathPatterns.map((pattern) => ({\n      pattern,\n      regex: cloudFrontPatternRegex(`/${pattern.replace(/^\\/+/, \"\")}`),\n    }));\n    for (const { group, route, pathPattern } of this.functionGroupBehaviors()) {\n      const duplicate = publicPathPatterns.includes(pathPattern);\n      // Matching the group pattern's own text is enough: its only wildcard is a\n      // trailing `*`, so a public pattern that matches the text up to and\n      // including it matches every URL the group pattern does.\n      const shadow = duplicate\n        ? undefined\n        : publicRegexes.find(({ regex }) =>\n            regex.test(`/${pathPattern.replace(/^\\/+/, \"\")}`),\n          );\n      if (!duplicate && !shadow) {\n        continue;\n      }\n      throw new Error(\n        `${LOG_PREFIX} \\`functionGroups\\` pattern \"${route}\" (group ` +\n          `\"${group.name}\") ` +\n          (duplicate\n            ? `deploys as the path pattern \"${pathPattern}\", which a top-level ` +\n              `public/ entry already uses — CloudFront rejects a distribution ` +\n              `with two behaviors on one path pattern. `\n            : `deploys as \"${pathPattern}\", but the top-level public/ entry ` +\n              `behind \"${shadow!.pattern}\" is matched first and sends every ` +\n              `such request to S3, so the group's function would never see ` +\n              `them. `) +\n          `Move those public/ files under a directory no route uses, or ` +\n          `group a different path.`,\n      );\n    }\n  }\n  /**\n   * CloudFront has a per-distribution cache behavior quota, counting the default\n   * one — 75 unless raised, and `maxCacheBehaviors` says which — and there are\n   * three things competing for it: `public/` entries, function groups, and\n   * cdk-nextjs's own fixed set.\n   * Checked in one place so the error can say which to cut.\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions\n   */\n  private assertBehaviorBudget(publicPatterns: number) {\n    const limit = this.props.maxCacheBehaviors ?? DEFAULT_MAX_CACHE_BEHAVIORS;\n    if (Token.isUnresolved(limit)) {\n      return;\n    }\n    const groupPatterns = this.functionGroupBehaviors().length;\n    // The default behavior, `_next/image*`, `_next/static*`, plus — with a\n    // basePath — the two that stand in for the default behavior's coverage, and\n    // — with a path-style assetPrefix — the one that serves bundles under it,\n    // and — with service workers — the one that adds `Service-Worker-Allowed`.\n    // `this.basePath`, not the raw prop: `basePath: \"/\"` normalizes to `\"\"` and\n    // adds no behaviors, so counting it added 2 to the total and could throw\n    // \"over the limit\" on an app that is under it.\n    const fixed =\n      3 +\n      (this.basePath ? 2 : 0) +\n      (this.assetPrefix ? 1 : 0) +\n      (this.props.serviceWorkerAllowed !== undefined ? 1 : 0);\n    const total = fixed + publicPatterns + groupPatterns;\n    if (total <= limit) {\n      return;\n    }\n    const parts = [\n      `${fixed} used by cdk-nextjs itself`,\n      `${publicPatterns} for top-level public/ entries`,\n    ];\n    if (groupPatterns) {\n      parts.push(`${groupPatterns} for \\`functionGroups\\` patterns`);\n    }\n    throw new Error(\n      `This Next.js app needs ${total} CloudFront cache behaviors, over the ` +\n        `limit of ${limit} per distribution: ${parts.join(\", \")}. ` +\n        `Move public/ files into a single top-level directory (one behavior ` +\n        `serves \\`static/*\\`)` +\n        (groupPatterns\n          ? `, and prefer one subtree pattern per function group over several ` +\n            `exact paths`\n          : ``) +\n        `. If your account's quota is higher than ${limit}, set ` +\n        `\\`maxCacheBehaviors\\` to it. See https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions`,\n    );\n  }\n  /**\n   * Optionally prepends base path to given path pattern.\n   *\n   * A trailing slash on `pathPattern` is load-bearing and survives, which is why\n   * this concatenates rather than going through `joinPath`. The build's\n   * `functionGroupBehaviors` hold both \"pricing\" and \"pricing/\" for a\n   * `trailingSlash` app, and normalizing the second one collapsed it onto the\n   * first: `addBehavior` was\n   * then called twice with `/base/pricing`, which CloudFront rejects at deploy\n   * (\"more than one cache behavior has the same path pattern\"), and the\n   * canonical `/base/pricing/` was left to the `/base/*` catch-all — the misroute\n   * the second pattern exists to prevent.\n   */\n  private getPathPattern(pathPattern: string) {\n    if (!this.basePath) {\n      return pathPattern;\n    }\n    return `/${this.basePath}/${pathPattern.replace(/^\\/+/, \"\")}`;\n  }\n}\n\n/**\n * Whether `dynamicCachePolicyProps` turns the dynamic cache off, by capping every\n * TTL at 0.\n *\n * CloudFront rejects a policy that caches nothing but still has a cache key\n * (\"HeaderBehavior is invalid for policy with caching disabled\"), so such a\n * policy has to drop the key. Until the default TTL became 0 this could not\n * come up: CDK raises `maxTtl` to `defaultTtl` when it is lower, so an override\n * of `maxTtl: 0` synthesized as a day and deployed. Now it is honored, and\n * without this the upgrade deploy would fail.\n *\n * The TTLs are resolved the way CDK resolves them: `defaultTtl` raised to\n * `minTtl`, then `maxTtl` raised to `defaultTtl`. Checking `maxTtl` alone called\n * `{ maxTtl: 0, defaultTtl: 1h }` disabled, dropped the key, and CDK then\n * synthesized a policy that caches for an hour keyed on nothing — one viewer's\n * page served to every viewer.\n */\nfunction isCachingDisabled(props: CachePolicyProps | undefined): boolean {\n  const ttls = [props?.maxTtl, props?.defaultTtl, props?.minTtl];\n  if (props?.maxTtl === undefined) return false; // CDK's default is a year\n  return ttls.every(\n    (ttl) =>\n      ttl === undefined ||\n      (!Token.isUnresolved(ttl.toString()) && ttl.toSeconds() === 0),\n  );\n}\n\n/** The cache-key half of {@link CachePolicyProps}. */\ninterface CacheKeyProps {\n  readonly queryStringBehavior: CacheQueryStringBehavior;\n  readonly headerBehavior: CacheHeaderBehavior;\n  readonly cookieBehavior: CacheCookieBehavior;\n  readonly enableAcceptEncodingBrotli: boolean;\n  readonly enableAcceptEncodingGzip: boolean;\n}\n\n/**\n * What the dynamic cache policy keys on: every request input a Next.js response\n * varies by.\n */\nconst DYNAMIC_CACHE_KEY: CacheKeyProps = {\n  queryStringBehavior: CacheQueryStringBehavior.all(),\n  headerBehavior: CacheHeaderBehavior.allowList(\n    // NOTE: CloudFront Custom Cache Policies have soft max of 10 headers\n    // cdk-nextjs includes the most essential headers for Next.js functionality\n    // and leaves out the one commented out below; keying on it as well needs a\n    // quota increase\n    // more here: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-policies\n    \"accept\", // content negotiation (HTML vs RSC payload)\n    \"rsc\", // React Server Components requests\n    \"next-url\", // Next.js routing\n    \"next-router-state-tree\", // App Router navigation state\n    \"next-router-prefetch\", // prefetch behavior\n    \"next-router-segment-prefetch\", // segment-level prefetching\n    \"x-prerender-revalidate\", // on-demand ISR revalidation\n    // Draft mode needs no header: it is the `__prerender_bypass` cookie, which\n    // `cookieBehavior.all()` already keys on.\n    // \"x-prerender-revalidate-if-generated\", // conditional revalidation (niche use case)\n  ),\n  cookieBehavior: CacheCookieBehavior.all(),\n  enableAcceptEncodingBrotli: true,\n  enableAcceptEncodingGzip: true,\n};\n\n/**\n * A cache key of nothing, for a policy that caches nothing. Forwarding is\n * unaffected: the dynamic origin request policy sends every viewer header,\n * cookie and query string regardless.\n */\nconst DISABLED_CACHE_KEY: CacheKeyProps = {\n  queryStringBehavior: CacheQueryStringBehavior.none(),\n  headerBehavior: CacheHeaderBehavior.none(),\n  cookieBehavior: CacheCookieBehavior.none(),\n  enableAcceptEncodingBrotli: false,\n  enableAcceptEncodingGzip: false,\n};\n\n/**\n * CloudFront's default \"Cache behaviors per distribution\" quota, the default\n * behavior included. Adjustable, hence `maxCacheBehaviors`.\n *\n * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html#limits-web-distributions\n */\nconst DEFAULT_MAX_CACHE_BEHAVIORS = 75;\n\n/**\n * Whether `char` is in CloudFront's path pattern alphabet: the literals, plus the\n * `*` and `?` wildcards. No space, no `%`, nothing non-ASCII.\n */\nfunction isPathPatternChar(char: string): boolean {\n  return char === \"*\" || char === \"?\" || PATH_PATTERN_LITERAL.test(char);\n}\n/**\n * CloudFront's limit on a response headers policy name, and the suffix that\n * tells the service worker policy's apart from the static one's.\n * @see https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_ResponseHeadersPolicyConfig.html\n */\nconst MAX_POLICY_NAME_LENGTH = 128;\nconst SERVICE_WORKER_SUFFIX = \"-sw\";\n/** CloudFront's path pattern length limit. */\nconst MAX_PATH_PATTERN_LENGTH = 255;\n\n/**\n * A `public/` entry's name as a CloudFront path pattern.\n *\n * `public/hello world.jpg` is a valid Next.js asset — `next start` serves it, and\n * `next/image` points at it — but a space cannot appear in a path pattern, so\n * cdk-nextjs used to throw at synth and the app could not be deployed at all\n * (`next-image-legacy/unicode`, whose `public/` also holds `äöüščří.png`).\n *\n * CloudFront URL-decodes the request path before matching it, so the pattern is\n * matched against `hello world.jpg`, not the `/hello%20world.jpg` on the wire.\n * Each character outside the alphabet is replaced by one `?` per byte of its\n * UTF-8 encoding, because that is what `?` matches: `hello?world.jpg` for the\n * space, and two `?` for each character of `äöüščří.png`. Measured against a\n * deployed distribution; a `?` per *percent-encoded* character (`hello???world`)\n * synthesizes fine and never matches. A `*` would be shorter and much wider:\n * `äöüščří.png` would become `*.png`, which would pull every `.png` request in\n * the app onto the static origin.\n */\nfunction toPathPattern(name: string): string {\n  return [...name]\n    .map((char) =>\n      isPathPatternChar(char)\n        ? char\n        : \"?\".repeat(Buffer.byteLength(char, \"utf8\")),\n    )\n    .join(\"\");\n}\n"]}