@aws-cdk/core/lib/stack.js

"use strict";
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.rootPathTo = exports.Stack = exports.STACK_RESOURCE_LIMIT_CONTEXT = void 0;
const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const fs = require("fs");
const path = require("path");
const cxschema = require("@aws-cdk/cloud-assembly-schema");
const cxapi = require("@aws-cdk/cx-api");
const constructs_1 = require("constructs");
const minimatch = require("minimatch");
const annotations_1 = require("./annotations");
const app_1 = require("./app");
const arn_1 = require("./arn");
const cfn_element_1 = require("./cfn-element");
const cfn_fn_1 = require("./cfn-fn");
const cfn_pseudo_1 = require("./cfn-pseudo");
const cfn_resource_1 = require("./cfn-resource");
const context_provider_1 = require("./context-provider");
const feature_flags_1 = require("./feature-flags");
const cloudformation_lang_1 = require("./private/cloudformation-lang");
const logical_id_1 = require("./private/logical-id");
const resolve_1 = require("./private/resolve");
const uniqueid_1 = require("./private/uniqueid");
// v2 - keep this import as a separate section to reduce merge conflict when forward merging with the v2 branch.
// eslint-disable-next-line
const construct_compat_1 = require("./construct-compat");
const STACK_SYMBOL = Symbol.for('@aws-cdk/core.Stack');
const MY_STACK_CACHE = Symbol.for('@aws-cdk/core.Stack.myStack');
exports.STACK_RESOURCE_LIMIT_CONTEXT = '@aws-cdk/core:stackResourceLimit';
const VALID_STACK_NAME_REGEX = /^[A-Za-z][A-Za-z0-9-]*$/;
const MAX_RESOURCES = 500;
/**
 * A root construct which represents a single CloudFormation stack.
 */
class Stack extends construct_compat_1.Construct {
    /**
     * Creates a new stack.
     *
     * @param scope Parent of this stack, usually an `App` or a `Stage`, but could be any construct.
     * @param id The construct ID of this stack. If `stackName` is not explicitly
     * defined, this id (and any parent IDs) will be used to determine the
     * physical ID of the stack.
     * @param props Stack properties.
     */
    constructor(scope, id, props = {}) {
        try {
            jsiiDeprecationWarnings._aws_cdk_core_StackProps(props);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, Stack);
            }
            throw error;
        }
        // For unit test scope and id are optional for stacks, but we still want an App
        // as the parent because apps implement much of the synthesis logic.
        scope = scope ?? new app_1.App({
            autoSynth: false,
            outdir: fs_1.FileSystem.mkdtemp('cdk-test-app-'),
        });
        // "Default" is a "hidden id" from a `node.uniqueId` perspective
        id = id ?? 'Default';
        super(scope, id);
        this._missingContext = new Array();
        this._stackDependencies = {};
        this.templateOptions = {};
        Object.defineProperty(this, STACK_SYMBOL, { value: true });
        this._logicalIds = new logical_id_1.LogicalIDs();
        const { account, region, environment } = this.parseEnvironment(props.env);
        this.account = account;
        this.region = region;
        this.environment = environment;
        this.terminationProtection = props.terminationProtection;
        if (props.description !== undefined) {
            // Max length 1024 bytes
            // Typically 2 bytes per character, may be more for more exotic characters
            if (props.description.length > 512) {
                throw new Error(`Stack description must be <= 1024 bytes. Received description: '${props.description}'`);
            }
            this.templateOptions.description = props.description;
        }
        this._stackName = props.stackName ?? this.generateStackName();
        if (this._stackName.length > 128) {
            throw new Error(`Stack name must be <= 128 characters. Stack name: '${this._stackName}'`);
        }
        this.tags = new tag_manager_1.TagManager(cfn_resource_1.TagType.KEY_VALUE, 'aws:cdk:stack', props.tags);
        if (!VALID_STACK_NAME_REGEX.test(this.stackName)) {
            throw new Error(`Stack name must match the regular expression: ${VALID_STACK_NAME_REGEX.toString()}, got '${this.stackName}'`);
        }
        // the preferred behavior is to generate a unique id for this stack and use
        // it as the artifact ID in the assembly. this allows multiple stacks to use
        // the same name. however, this behavior is breaking for 1.x so it's only
        // applied under a feature flag which is applied automatically for new
        // projects created using `cdk init`.
        //
        // Also use the new behavior if we are using the new CI/CD-ready synthesizer; that way
        // people only have to flip one flag.
        const featureFlags = feature_flags_1.FeatureFlags.of(this);
        const stackNameDupeContext = featureFlags.isEnabled(cxapi.ENABLE_STACK_NAME_DUPLICATES_CONTEXT);
        const newStyleSynthesisContext = featureFlags.isEnabled(cxapi.NEW_STYLE_STACK_SYNTHESIS_CONTEXT);
        this.artifactId = (stackNameDupeContext || newStyleSynthesisContext)
            ? this.generateStackArtifactId()
            : this.stackName;
        this.templateFile = `${this.artifactId}.template.json`;
        // Not for nested stacks
        this._versionReportingEnabled = (props.analyticsReporting ?? this.node.tryGetContext(cxapi.ANALYTICS_REPORTING_ENABLED_CONTEXT))
            && !this.nestedStackParent;
        this.synthesizer = props.synthesizer ?? (newStyleSynthesisContext
            ? new stack_synthesizers_1.DefaultStackSynthesizer()
            : new stack_synthesizers_1.LegacyStackSynthesizer());
        this.synthesizer.bind(this);
    }
    /**
     * Return whether the given object is a Stack.
     *
     * We do attribute detection since we can't reliably use 'instanceof'.
     */
    static isStack(x) {
        return x !== null && typeof (x) === 'object' && STACK_SYMBOL in x;
    }
    /**
     * Looks up the first stack scope in which `construct` is defined. Fails if there is no stack up the tree.
     * @param construct The construct to start the search from.
     */
    static of(construct) {
        // we want this to be as cheap as possible. cache this result by mutating
        // the object. anecdotally, at the time of this writing, @aws-cdk/core unit
        // tests hit this cache 1,112 times, @aws-cdk/aws-cloudformation unit tests
        // hit this 2,435 times).
        const cache = construct[MY_STACK_CACHE];
        if (cache) {
            return cache;
        }
        else {
            const value = _lookup(construct);
            Object.defineProperty(construct, MY_STACK_CACHE, {
                enumerable: false,
                writable: false,
                configurable: false,
                value,
            });
            return value;
        }
        function _lookup(c) {
            if (Stack.isStack(c)) {
                return c;
            }
            const _scope = constructs_1.Node.of(c).scope;
            if (stage_1.Stage.isStage(c) || !_scope) {
                throw new Error(`${construct.constructor?.name ?? 'Construct'} at '${constructs_1.Node.of(construct).path}' should be created in the scope of a Stack, but no Stack found`);
            }
            return _lookup(_scope);
        }
    }
    /**
     * Resolve a tokenized value in the context of the current stack.
     */
    resolve(obj) {
        return resolve_1.resolve(obj, {
            scope: this,
            prefix: [],
            resolver: cloudformation_lang_1.CLOUDFORMATION_TOKEN_RESOLVER,
            preparing: false,
        });
    }
    /**
     * Convert an object, potentially containing tokens, to a JSON string
     */
    toJsonString(obj, space) {
        return cloudformation_lang_1.CloudFormationLang.toJSON(obj, space).toString();
    }
    /**
     * DEPRECATED
     * @deprecated use `reportMissingContextKey()`
     */
    reportMissingContext(report) {
        try {
            jsiiDeprecationWarnings.print("@aws-cdk/core.Stack#reportMissingContext", "use `reportMissingContextKey()`");
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.reportMissingContext);
            }
            throw error;
        }
        if (!Object.values(cxschema.ContextProvider).includes(report.provider)) {
            throw new Error(`Unknown context provider requested in: ${JSON.stringify(report)}`);
        }
        this.reportMissingContextKey(report);
    }
    /**
     * Indicate that a context key was expected
     *
     * Contains instructions which will be emitted into the cloud assembly on how
     * the key should be supplied.
     *
     * @param report The set of parameters needed to obtain the context
     */
    reportMissingContextKey(report) {
        this._missingContext.push(report);
    }
    /**
     * Rename a generated logical identities
     *
     * To modify the naming scheme strategy, extend the `Stack` class and
     * override the `allocateLogicalId` method.
     */
    renameLogicalId(oldId, newId) {
        this._logicalIds.addRename(oldId, newId);
    }
    /**
     * Allocates a stack-unique CloudFormation-compatible logical identity for a
     * specific resource.
     *
     * This method is called when a `CfnElement` is created and used to render the
     * initial logical identity of resources. Logical ID renames are applied at
     * this stage.
     *
     * This method uses the protected method `allocateLogicalId` to render the
     * logical ID for an element. To modify the naming scheme, extend the `Stack`
     * class and override this method.
     *
     * @param element The CloudFormation element for which a logical identity is
     * needed.
     */
    getLogicalId(element) {
        try {
            jsiiDeprecationWarnings._aws_cdk_core_CfnElement(element);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.getLogicalId);
            }
            throw error;
        }
        const logicalId = this.allocateLogicalId(element);
        return this._logicalIds.applyRename(logicalId);
    }
    /**
     * Add a dependency between this stack and another stack.
     *
     * This can be used to define dependencies between any two stacks within an
     * app, and also supports nested stacks.
     */
    addDependency(target, reason) {
        try {
            jsiiDeprecationWarnings._aws_cdk_core_Stack(target);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.addDependency);
            }
            throw error;
        }
        deps_1.addDependency(this, target, reason);
    }
    /**
     * Return the stacks this stack depends on
     */
    get dependencies() {
        return Object.values(this._stackDependencies).map(x => x.stack);
    }
    /**
     * The concrete CloudFormation physical stack name.
     *
     * This is either the name defined explicitly in the `stackName` prop or
     * allocated based on the stack's location in the construct tree. Stacks that
     * are directly defined under the app use their construct `id` as their stack
     * name. Stacks that are defined deeper within the tree will use a hashed naming
     * scheme based on the construct path to ensure uniqueness.
     *
     * If you wish to obtain the deploy-time AWS::StackName intrinsic,
     * you can use `Aws.stackName` directly.
     */
    get stackName() {
        return this._stackName;
    }
    /**
     * The partition in which this stack is defined
     */
    get partition() {
        // Always return a non-scoped partition intrinsic. These will usually
        // be used to construct an ARN, but there are no cross-partition
        // calls anyway.
        return cfn_pseudo_1.Aws.PARTITION;
    }
    /**
     * The Amazon domain suffix for the region in which this stack is defined
     */
    get urlSuffix() {
        // Since URL Suffix always follows partition, it is unscoped like partition is.
        return cfn_pseudo_1.Aws.URL_SUFFIX;
    }
    /**
     * The ID of the stack
     *
     * @example
     * // After resolving, looks like
     * 'arn:aws:cloudformation:us-west-2:123456789012:stack/teststack/51af3dc0-da77-11e4-872e-1234567db123'
     */
    get stackId() {
        return new cfn_pseudo_1.ScopedAws(this).stackId;
    }
    /**
     * Returns the list of notification Amazon Resource Names (ARNs) for the current stack.
     */
    get notificationArns() {
        return new cfn_pseudo_1.ScopedAws(this).notificationArns;
    }
    /**
     * Indicates if this is a nested stack, in which case `parentStack` will include a reference to it's parent.
     */
    get nested() {
        return this.nestedStackResource !== undefined;
    }
    /**
     * Creates an ARN from components.
     *
     * If `partition`, `region` or `account` are not specified, the stack's
     * partition, region and account will be used.
     *
     * If any component is the empty string, an empty string will be inserted
     * into the generated ARN at the location that component corresponds to.
     *
     * The ARN will be formatted as follows:
     *
     *   arn:{partition}:{service}:{region}:{account}:{resource}{sep}}{resource-name}
     *
     * The required ARN pieces that are omitted will be taken from the stack that
     * the 'scope' is attached to. If all ARN pieces are supplied, the supplied scope
     * can be 'undefined'.
     */
    formatArn(components) {
        try {
            jsiiDeprecationWarnings._aws_cdk_core_ArnComponents(components);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.formatArn);
            }
            throw error;
        }
        return arn_1.Arn.format(components, this);
    }
    /**
     * Given an ARN, parses it and returns components.
     *
     * IF THE ARN IS A CONCRETE STRING...
     *
     * ...it will be parsed and validated. The separator (`sep`) will be set to '/'
     * if the 6th component includes a '/', in which case, `resource` will be set
     * to the value before the '/' and `resourceName` will be the rest. In case
     * there is no '/', `resource` will be set to the 6th components and
     * `resourceName` will be set to the rest of the string.
     *
     * IF THE ARN IS A TOKEN...
     *
     * ...it cannot be validated, since we don't have the actual value yet at the
     * time of this function call. You will have to supply `sepIfToken` and
     * whether or not ARNs of the expected format usually have resource names
     * in order to parse it properly. The resulting `ArnComponents` object will
     * contain tokens for the subexpressions of the ARN, not string literals.
     *
     * If the resource name could possibly contain the separator char, the actual
     * resource name cannot be properly parsed. This only occurs if the separator
     * char is '/', and happens for example for S3 object ARNs, IAM Role ARNs,
     * IAM OIDC Provider ARNs, etc. To properly extract the resource name from a
     * Tokenized ARN, you must know the resource type and call
     * `Arn.extractResourceName`.
     *
     * @param arn The ARN string to parse
     * @param sepIfToken The separator used to separate resource from resourceName
     * @param hasName Whether there is a name component in the ARN at all. For
     * example, SNS Topics ARNs have the 'resource' component contain the topic
     * name, and no 'resourceName' component.
     *
     * @returns an ArnComponents object which allows access to the various
     * components of the ARN.
     *
     * @returns an ArnComponents object which allows access to the various
     *      components of the ARN.
     *
     * @deprecated use splitArn instead
     */
    parseArn(arn, sepIfToken = '/', hasName = true) {
        try {
            jsiiDeprecationWarnings.print("@aws-cdk/core.Stack#parseArn", "use splitArn instead");
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.parseArn);
            }
            throw error;
        }
        return arn_1.Arn.parse(arn, sepIfToken, hasName);
    }
    /**
     * Splits the provided ARN into its components.
     * Works both if 'arn' is a string like 'arn:aws:s3:::bucket',
     * and a Token representing a dynamic CloudFormation expression
     * (in which case the returned components will also be dynamic CloudFormation expressions,
     * encoded as Tokens).
     *
     * @param arn the ARN to split into its components
     * @param arnFormat the expected format of 'arn' - depends on what format the service 'arn' represents uses
     */
    splitArn(arn, arnFormat) {
        try {
            jsiiDeprecationWarnings._aws_cdk_core_ArnFormat(arnFormat);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.splitArn);
            }
            throw error;
        }
        return arn_1.Arn.split(arn, arnFormat);
    }
    /**
     * Returns the list of AZs that are available in the AWS environment
     * (account/region) associated with this stack.
     *
     * If the stack is environment-agnostic (either account and/or region are
     * tokens), this property will return an array with 2 tokens that will resolve
     * at deploy-time to the first two availability zones returned from CloudFormation's
     * `Fn::GetAZs` intrinsic function.
     *
     * If they are not available in the context, returns a set of dummy values and
     * reports them as missing, and let the CLI resolve them by calling EC2
     * `DescribeAvailabilityZones` on the target environment.
     *
     * To specify a different strategy for selecting availability zones override this method.
     */
    get availabilityZones() {
        // if account/region are tokens, we can't obtain AZs through the context
        // provider, so we fallback to use Fn::GetAZs. the current lowest common
        // denominator is 2 AZs across all AWS regions.
        const agnostic = token_1.Token.isUnresolved(this.account) || token_1.Token.isUnresolved(this.region);
        if (agnostic) {
            return this.node.tryGetContext(cxapi.AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY) || [
                cfn_fn_1.Fn.select(0, cfn_fn_1.Fn.getAzs()),
                cfn_fn_1.Fn.select(1, cfn_fn_1.Fn.getAzs()),
            ];
        }
        const value = context_provider_1.ContextProvider.getValue(this, {
            provider: cxschema.ContextProvider.AVAILABILITY_ZONE_PROVIDER,
            dummyValue: ['dummy1a', 'dummy1b', 'dummy1c'],
        }).value;
        if (!Array.isArray(value)) {
            throw new Error(`Provider ${cxschema.ContextProvider.AVAILABILITY_ZONE_PROVIDER} expects a list`);
        }
        return value;
    }
    /**
     * Register a file asset on this Stack
     *
     * @deprecated Use `stack.synthesizer.addFileAsset()` if you are calling,
     * and a different IStackSynthesizer class if you are implementing.
     */
    addFileAsset(asset) {
        try {
            jsiiDeprecationWarnings.print("@aws-cdk/core.Stack#addFileAsset", "Use `stack.synthesizer.addFileAsset()` if you are calling,\nand a different IStackSynthesizer class if you are implementing.");
            jsiiDeprecationWarnings._aws_cdk_core_FileAssetSource(asset);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.addFileAsset);
            }
            throw error;
        }
        return this.synthesizer.addFileAsset(asset);
    }
    /**
     * Register a docker image asset on this Stack
     *
     * @deprecated Use `stack.synthesizer.addDockerImageAsset()` if you are calling,
     * and a different `IStackSynthesizer` class if you are implementing.
     */
    addDockerImageAsset(asset) {
        try {
            jsiiDeprecationWarnings.print("@aws-cdk/core.Stack#addDockerImageAsset", "Use `stack.synthesizer.addDockerImageAsset()` if you are calling,\nand a different `IStackSynthesizer` class if you are implementing.");
            jsiiDeprecationWarnings._aws_cdk_core_DockerImageAssetSource(asset);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.addDockerImageAsset);
            }
            throw error;
        }
        return this.synthesizer.addDockerImageAsset(asset);
    }
    /**
     * If this is a nested stack, returns it's parent stack.
     */
    get nestedStackParent() {
        return this.nestedStackResource && Stack.of(this.nestedStackResource);
    }
    /**
     * Returns the parent of a nested stack.
     *
     * @deprecated use `nestedStackParent`
     */
    get parentStack() {
        try {
            jsiiDeprecationWarnings.print("@aws-cdk/core.Stack#parentStack", "use `nestedStackParent`");
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, jsiiDeprecationWarnings.getPropertyDescriptor(this, "parentStack").get);
            }
            throw error;
        }
        return this.nestedStackParent;
    }
    /**
     * Add a Transform to this stack. A Transform is a macro that AWS
     * CloudFormation uses to process your template.
     *
     * Duplicate values are removed when stack is synthesized.
     *
     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-section-structure.html
     * @param transform The transform to add
     *
     * @example
     * declare const stack: Stack;
     *
     * stack.addTransform('AWS::Serverless-2016-10-31')
     */
    addTransform(transform) {
        if (!this.templateOptions.transforms) {
            this.templateOptions.transforms = [];
        }
        this.templateOptions.transforms.push(transform);
    }
    /**
     * Called implicitly by the `addDependency` helper function in order to
     * realize a dependency between two top-level stacks at the assembly level.
     *
     * Use `stack.addDependency` to define the dependency between any two stacks,
     * and take into account nested stack relationships.
     *
     * @internal
     */
    _addAssemblyDependency(target, reason) {
        // defensive: we should never get here for nested stacks
        if (this.nested || target.nested) {
            throw new Error('Cannot add assembly-level dependencies for nested stacks');
        }
        reason = reason || 'dependency added using stack.addDependency()';
        const cycle = target.stackDependencyReasons(this);
        if (cycle !== undefined) {
            // eslint-disable-next-line max-len
            throw new Error(`'${target.node.path}' depends on '${this.node.path}' (${cycle.join(', ')}). Adding this dependency (${reason}) would create a cyclic reference.`);
        }
        let dep = this._stackDependencies[names_1.Names.uniqueId(target)];
        if (!dep) {
            dep = this._stackDependencies[names_1.Names.uniqueId(target)] = {
                stack: target,
                reasons: [],
            };
        }
        dep.reasons.push(reason);
        if (process.env.CDK_DEBUG_DEPS) {
            // eslint-disable-next-line no-console
            console.error(`[CDK_DEBUG_DEPS] stack "${this.node.path}" depends on "${target.node.path}" because: ${reason}`);
        }
    }
    /**
     * Synthesizes the cloudformation template into a cloud assembly.
     * @internal
     */
    _synthesizeTemplate(session, lookupRoleArn) {
        // In principle, stack synthesis is delegated to the
        // StackSynthesis object.
        //
        // However, some parts of synthesis currently use some private
        // methods on Stack, and I don't really see the value in refactoring
        // this right now, so some parts still happen here.
        const builder = session.assembly;
        const template = this._toCloudFormation();
        // write the CloudFormation template as a JSON file
        const outPath = path.join(builder.outdir, this.templateFile);
        if (this.maxResources > 0) {
            const resources = template.Resources || {};
            const numberOfResources = Object.keys(resources).length;
            if (numberOfResources > this.maxResources) {
                const counts = Object.entries(count(Object.values(resources).map((r) => `${r?.Type}`))).map(([type, c]) => `${type} (${c})`).join(', ');
                throw new Error(`Number of resources in stack '${this.node.path}': ${numberOfResources} is greater than allowed maximum of ${this.maxResources}: ${counts}`);
            }
            else if (numberOfResources >= (this.maxResources * 0.8)) {
                annotations_1.Annotations.of(this).addInfo(`Number of resources: ${numberOfResources} is approaching allowed maximum of ${this.maxResources}`);
            }
        }
        fs.writeFileSync(outPath, JSON.stringify(template, undefined, 1));
        for (const ctx of this._missingContext) {
            if (lookupRoleArn != null) {
                builder.addMissing({ ...ctx, props: { ...ctx.props, lookupRoleArn } });
            }
            else {
                builder.addMissing(ctx);
            }
        }
    }
    /**
     * Look up a fact value for the given fact for the region of this stack
     *
     * Will return a definite value only if the region of the current stack is resolved.
     * If not, a lookup map will be added to the stack and the lookup will be done at
     * CDK deployment time.
     *
     * What regions will be included in the lookup map is controlled by the
     * `@aws-cdk/core:target-partitions` context value: it must be set to a list
     * of partitions, and only regions from the given partitions will be included.
     * If no such context key is set, all regions will be included.
     *
     * This function is intended to be used by construct library authors. Application
     * builders can rely on the abstractions offered by construct libraries and do
     * not have to worry about regional facts.
     *
     * If `defaultValue` is not given, it is an error if the fact is unknown for
     * the given region.
     */
    regionalFact(factName, defaultValue) {
        if (!token_1.Token.isUnresolved(this.region)) {
            const ret = region_info_1.Fact.find(this.region, factName) ?? defaultValue;
            if (ret === undefined) {
                throw new Error(`region-info: don't know ${factName} for region ${this.region}. Use 'Fact.register' to provide this value.`);
            }
            return ret;
        }
        const partitions = constructs_1.Node.of(this).tryGetContext(cxapi.TARGET_PARTITIONS);
        if (partitions !== undefined && !Array.isArray(partitions)) {
            throw new Error(`Context value '${cxapi.TARGET_PARTITIONS}' should be a list of strings, got: ${JSON.stringify(cxapi.TARGET_PARTITIONS)}`);
        }
        const lookupMap = partitions ? region_info_1.RegionInfo.limitedRegionMap(factName, partitions) : region_info_1.RegionInfo.regionMap(factName);
        return region_lookup_1.deployTimeLookup(this, factName, lookupMap, defaultValue);
    }
    /**
     * Create a CloudFormation Export for a value
     *
     * Returns a string representing the corresponding `Fn.importValue()`
     * expression for this Export. You can control the name for the export by
     * passing the `name` option.
     *
     * If you don't supply a value for `name`, the value you're exporting must be
     * a Resource attribute (for example: `bucket.bucketName`) and it will be
     * given the same name as the automatic cross-stack reference that would be created
     * if you used the attribute in another Stack.
     *
     * One of the uses for this method is to *remove* the relationship between
     * two Stacks established by automatic cross-stack references. It will
     * temporarily ensure that the CloudFormation Export still exists while you
     * remove the reference from the consuming stack. After that, you can remove
     * the resource and the manual export.
     *
     * ## Example
     *
     * Here is how the process works. Let's say there are two stacks,
     * `producerStack` and `consumerStack`, and `producerStack` has a bucket
     * called `bucket`, which is referenced by `consumerStack` (perhaps because
     * an AWS Lambda Function writes into it, or something like that).
     *
     * It is not safe to remove `producerStack.bucket` because as the bucket is being
     * deleted, `consumerStack` might still be using it.
     *
     * Instead, the process takes two deployments:
     *
     * ### Deployment 1: break the relationship
     *
     * - Make sure `consumerStack` no longer references `bucket.bucketName` (maybe the consumer
     *   stack now uses its own bucket, or it writes to an AWS DynamoDB table, or maybe you just
     *   remove the Lambda Function altogether).
     * - In the `ProducerStack` class, call `this.exportValue(this.bucket.bucketName)`. This
     *   will make sure the CloudFormation Export continues to exist while the relationship
     *   between the two stacks is being broken.
     * - Deploy (this will effectively only change the `consumerStack`, but it's safe to deploy both).
     *
     * ### Deployment 2: remove the bucket resource
     *
     * - You are now free to remove the `bucket` resource from `producerStack`.
     * - Don't forget to remove the `exportValue()` call as well.
     * - Deploy again (this time only the `producerStack` will be changed -- the bucket will be deleted).
     */
    exportValue(exportedValue, options = {}) {
        try {
            jsiiDeprecationWarnings._aws_cdk_core_ExportValueOptions(options);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.exportValue);
            }
            throw error;
        }
        if (options.name) {
            new cfn_output_1.CfnOutput(this, `Export${options.name}`, {
                value: exportedValue,
                exportName: options.name,
            });
            return cfn_fn_1.Fn.importValue(options.name);
        }
        const resolvable = token_1.Tokenization.reverse(exportedValue);
        if (!resolvable || !reference_1.Reference.isReference(resolvable)) {
            throw new Error('exportValue: either supply \'name\' or make sure to export a resource attribute (like \'bucket.bucketName\')');
        }
        // if exportValue is being called manually (which is pre onPrepare) then the logicalId
        // could potentially be changed by a call to overrideLogicalId. This would cause our Export/Import
        // to have an incorrect id. For a better user experience, lock the logicalId and throw an error
        // if the user tries to override the id _after_ calling exportValue
        if (cfn_element_1.CfnElement.isCfnElement(resolvable.target)) {
            resolvable.target._lockLogicalId();
        }
        // "teleport" the value here, in case it comes from a nested stack. This will also
        // ensure the value is from our own scope.
        const exportable = refs_1.referenceNestedStackValueInParent(resolvable, this);
        // Ensure a singleton "Exports" scoping Construct
        // This mostly exists to trigger LogicalID munging, which would be
        // disabled if we parented constructs directly under Stack.
        // Also it nicely prevents likely construct name clashes
        const exportsScope = getCreateExportsScope(this);
        // Ensure a singleton CfnOutput for this value
        const resolved = this.resolve(exportable);
        const id = 'Output' + JSON.stringify(resolved);
        const exportName = generateExportName(exportsScope, id);
        if (token_1.Token.isUnresolved(exportName)) {
            throw new Error(`unresolved token in generated export name: ${JSON.stringify(this.resolve(exportName))}`);
        }
        const output = exportsScope.node.tryFindChild(id);
        if (!output) {
            new cfn_output_1.CfnOutput(exportsScope, id, { value: token_1.Token.asString(exportable), exportName });
        }
        return cfn_fn_1.Fn.importValue(exportName);
    }
    /**
     * Returns the naming scheme used to allocate logical IDs. By default, uses
     * the `HashedAddressingScheme` but this method can be overridden to customize
     * this behavior.
     *
     * In order to make sure logical IDs are unique and stable, we hash the resource
     * construct tree path (i.e. toplevel/secondlevel/.../myresource) and add it as
     * a suffix to the path components joined without a separator (CloudFormation
     * IDs only allow alphanumeric characters).
     *
     * The result will be:
     *
     *   <path.join('')><md5(path.join('/')>
     *     "human"      "hash"
     *
     * If the "human" part of the ID exceeds 240 characters, we simply trim it so
     * the total ID doesn't exceed CloudFormation's 255 character limit.
     *
     * We only take 8 characters from the md5 hash (0.000005 chance of collision).
     *
     * Special cases:
     *
     * - If the path only contains a single component (i.e. it's a top-level
     *   resource), we won't add the hash to it. The hash is not needed for
     *   disamiguation and also, it allows for a more straightforward migration an
     *   existing CloudFormation template to a CDK stack without logical ID changes
     *   (or renames).
     * - For aesthetic reasons, if the last components of the path are the same
     *   (i.e. `L1/L2/Pipeline/Pipeline`), they will be de-duplicated to make the
     *   resulting human portion of the ID more pleasing: `L1L2Pipeline<HASH>`
     *   instead of `L1L2PipelinePipeline<HASH>`
     * - If a component is named "Default" it will be omitted from the path. This
     *   allows refactoring higher level abstractions around constructs without affecting
     *   the IDs of already deployed resources.
     * - If a component is named "Resource" it will be omitted from the user-visible
     *   path, but included in the hash. This reduces visual noise in the human readable
     *   part of the identifier.
     *
     * @param cfnElement The element for which the logical ID is allocated.
     */
    allocateLogicalId(cfnElement) {
        try {
            jsiiDeprecationWarnings._aws_cdk_core_CfnElement(cfnElement);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.allocateLogicalId);
            }
            throw error;
        }
        const scopes = cfnElement.node.scopes;
        const stackIndex = scopes.indexOf(cfnElement.stack);
        const pathComponents = scopes.slice(stackIndex + 1).map(x => x.node.id);
        return uniqueid_1.makeUniqueId(pathComponents);
    }
    /**
     * Validate stack name
     *
     * CloudFormation stack names can include dashes in addition to the regular identifier
     * character classes, and we don't allow one of the magic markers.
     *
     * @internal
     */
    _validateId(name) {
        if (name && !VALID_STACK_NAME_REGEX.test(name)) {
            throw new Error(`Stack name must match the regular expression: ${VALID_STACK_NAME_REGEX.toString()}, got '${name}'`);
        }
    }
    /**
     * Returns the CloudFormation template for this stack by traversing
     * the tree and invoking _toCloudFormation() on all Entity objects.
     *
     * @internal
     */
    _toCloudFormation() {
        let transform;
        if (this.templateOptions.transform) {
            // eslint-disable-next-line max-len
            annotations_1.Annotations.of(this).addWarning('This stack is using the deprecated `templateOptions.transform` property. Consider switching to `addTransform()`.');
            this.addTransform(this.templateOptions.transform);
        }
        if (this.templateOptions.transforms) {
            if (this.templateOptions.transforms.length === 1) { // Extract single value
                transform = this.templateOptions.transforms[0];
            }
            else { // Remove duplicate values
                transform = Array.from(new Set(this.templateOptions.transforms));
            }
        }
        const template = {
            Description: this.templateOptions.description,
            Transform: transform,
            AWSTemplateFormatVersion: this.templateOptions.templateFormatVersion,
            Metadata: this.templateOptions.metadata,
        };
        const elements = cfnElements(this);
        const fragments = elements.map(e => this.resolve(e._toCloudFormation()));
        // merge in all CloudFormation fragments collected from the tree
        for (const fragment of fragments) {
            merge(template, fragment);
        }
        // resolve all tokens and remove all empties
        const ret = this.resolve(template) || {};
        this._logicalIds.assertAllRenamesApplied();
        return ret;
    }
    /**
     * Deprecated.
     *
     * @see https://github.com/aws/aws-cdk/pull/7187
     * @returns reference itself without any change
     * @deprecated cross reference handling has been moved to `App.prepare()`.
     */
    prepareCrossReference(_sourceStack, reference) {
        try {
            jsiiDeprecationWarnings.print("@aws-cdk/core.Stack#prepareCrossReference", "cross reference handling has been moved to `App.prepare()`.");
            jsiiDeprecationWarnings._aws_cdk_core_Stack(_sourceStack);
            jsiiDeprecationWarnings._aws_cdk_core_Reference(reference);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.prepareCrossReference);
            }
            throw error;
        }
        return reference;
    }
    /**
     * Determine the various stack environment attributes.
     *
     */
    parseEnvironment(env = {}) {
        // if an environment property is explicitly specified when the stack is
        // created, it will be used. if not, use tokens for account and region.
        //
        // (They do not need to be anchored to any construct like resource attributes
        // are, because we'll never Export/Fn::ImportValue them -- the only situation
        // in which Export/Fn::ImportValue would work is if the value are the same
        // between producer and consumer anyway, so we can just assume that they are).
        const containingAssembly = stage_1.Stage.of(this);
        const account = env.account ?? containingAssembly?.account ?? cfn_pseudo_1.Aws.ACCOUNT_ID;
        const region = env.region ?? containingAssembly?.region ?? cfn_pseudo_1.Aws.REGION;
        // this is the "aws://" env specification that will be written to the cloud assembly
        // manifest. it will use "unknown-account" and "unknown-region" to indicate
        // environment-agnosticness.
        const envAccount = !token_1.Token.isUnresolved(account) ? account : cxapi.UNKNOWN_ACCOUNT;
        const envRegion = !token_1.Token.isUnresolved(region) ? region : cxapi.UNKNOWN_REGION;
        return {
            account,
            region,
            environment: cxapi.EnvironmentUtils.format(envAccount, envRegion),
        };
    }
    /**
     * Maximum number of resources in the stack
     *
     * Set to 0 to mean "unlimited".
     */
    get maxResources() {
        const contextLimit = this.node.tryGetContext(exports.STACK_RESOURCE_LIMIT_CONTEXT);
        return contextLimit !== undefined ? parseInt(contextLimit, 10) : MAX_RESOURCES;
    }
    /**
     * Check whether this stack has a (transitive) dependency on another stack
     *
     * Returns the list of reasons on the dependency path, or undefined
     * if there is no dependency.
     */
    stackDependencyReasons(other) {
        if (this === other) {
            return [];
        }
        for (const dep of Object.values(this._stackDependencies)) {
            const ret = dep.stack.stackDependencyReasons(other);
            if (ret !== undefined) {
                return [...dep.reasons, ...ret];
            }
        }
        return undefined;
    }
    /**
     * Calculate the stack name based on the construct path
     *
     * The stack name is the name under which we'll deploy the stack,
     * and incorporates containing Stage names by default.
     *
     * Generally this looks a lot like how logical IDs are calculated.
     * The stack name is calculated based on the construct root path,
     * as follows:
     *
     * - Path is calculated with respect to containing App or Stage (if any)
     * - If the path is one component long just use that component, otherwise
     *   combine them with a hash.
     *
     * Since the hash is quite ugly and we'd like to avoid it if possible -- but
     * we can't anymore in the general case since it has been written into legacy
     * stacks. The introduction of Stages makes it possible to make this nicer however.
     * When a Stack is nested inside a Stage, we use the path components below the
     * Stage, and prefix the path components of the Stage before it.
     */
    generateStackName() {
        const assembly = stage_1.Stage.of(this);
        const prefix = (assembly && assembly.stageName) ? `${assembly.stageName}-` : '';
        return `${prefix}${this.generateStackId(assembly)}`;
    }
    /**
     * The artifact ID for this stack
     *
     * Stack artifact ID is unique within the App's Cloud Assembly.
     */
    generateStackArtifactId() {
        return this.generateStackId(this.node.root);
    }
    /**
     * Generate an ID with respect to the given container construct.
     */
    generateStackId(container) {
        const rootPath = rootPathTo(this, container);
        const ids = rootPath.map(c => constructs_1.Node.of(c).id);
        // In unit tests our Stack (which is the only component) may not have an
        // id, so in that case just pretend it's "Stack".
        if (ids.length === 1 && !ids[0]) {
            throw new Error('unexpected: stack id must always be defined');
        }
        return makeStackName(ids);
    }
    /**
     * Indicates whether the stack requires bundling or not
     */
    get bundlingRequired() {
        const bundlingStacks = this.node.tryGetContext(cxapi.BUNDLING_STACKS) ?? ['*'];
        // bundlingStacks is of the form `Stage/Stack`, convert it to `Stage-Stack` before comparing to stack name
        return bundlingStacks.some(pattern => minimatch(this.stackName, pattern.replace('/', '-')));
    }
}
exports.Stack = Stack;
_a = JSII_RTTI_SYMBOL_1;
Stack[_a] = { fqn: "@aws-cdk/core.Stack", version: "1.204.0" };
function merge(template, fragment) {
    for (const section of Object.keys(fragment)) {
        const src = fragment[section];
        // create top-level section if it doesn't exist
        const dest = template[section];
        if (!dest) {
            template[section] = src;
        }
        else {
            template[section] = mergeSection(section, dest, src);
        }
    }
}
function mergeSection(section, val1, val2) {
    switch (section) {
        case 'Description':
            return `${val1}\n${val2}`;
        case 'AWSTemplateFormatVersion':
            if (val1 != null && val2 != null && val1 !== val2) {
                throw new Error(`Conflicting CloudFormation template versions provided: '${val1}' and '${val2}`);
            }
            return val1 ?? val2;
        case 'Transform':
            return mergeSets(val1, val2);
        default:
            return mergeObjectsWithoutDuplicates(section, val1, val2);
    }
}
function mergeSets(val1, val2) {
    const array1 = val1 == null ? [] : (Array.isArray(val1) ? val1 : [val1]);
    const array2 = val2 == null ? [] : (Array.isArray(val2) ? val2 : [val2]);
    for (const value of array2) {
        if (!array1.includes(value)) {
            array1.push(value);
        }
    }
    return array1.length === 1 ? array1[0] : array1;
}
function mergeObjectsWithoutDuplicates(section, dest, src) {
    if (typeof dest !== 'object') {
        throw new Error(`Expecting ${JSON.stringify(dest)} to be an object`);
    }
    if (typeof src !== 'object') {
        throw new Error(`Expecting ${JSON.stringify(src)} to be an object`);
    }
    // add all entities from source section to destination section
    for (const id of Object.keys(src)) {
        if (id in dest) {
            throw new Error(`section '${section}' already contains '${id}'`);
        }
        dest[id] = src[id];
    }
    return dest;
}
/**
 * Collect all CfnElements from a Stack.
 *
 * @param node Root node to collect all CfnElements from
 * @param into Array to append CfnElements to
 * @returns The same array as is being collected into
 */
function cfnElements(node, into = []) {
    if (cfn_element_1.CfnElement.isCfnElement(node)) {
        into.push(node);
    }
    for (const child of constructs_1.Node.of(node).children) {
        // Don't recurse into a substack
        if (Stack.isStack(child)) {
            continue;
        }
        cfnElements(child, into);
    }
    return into;
}
/**
 * Return the construct root path of the given construct relative to the given ancestor
 *
 * If no ancestor is given or the ancestor is not found, return the entire root path.
 */
function rootPathTo(construct, ancestor) {
    const scopes = constructs_1.Node.of(construct).scopes;
    for (let i = scopes.length - 2; i >= 0; i--) {
        if (scopes[i] === ancestor) {
            return scopes.slice(i + 1);
        }
    }
    return scopes;
}
exports.rootPathTo = rootPathTo;
/**
 * makeUniqueId, specialized for Stack names
 *
 * Stack names may contain '-', so we allow that character if the stack name
 * has only one component. Otherwise we fall back to the regular "makeUniqueId"
 * behavior.
 */
function makeStackName(components) {
    if (components.length === 1) {
        return components[0];
    }
    return uniqueid_1.makeUniqueId(components);
}
function getCreateExportsScope(stack) {
    const exportsName = 'Exports';
    let stackExports = stack.node.tryFindChild(exportsName);
    if (stackExports === undefined) {
        stackExports = new construct_compat_1.Construct(stack, exportsName);
    }
    return stackExports;
}
function generateExportName(stackExports, id) {
    const stackRelativeExports = feature_flags_1.FeatureFlags.of(stackExports).isEnabled(cxapi.STACK_RELATIVE_EXPORTS_CONTEXT);
    const stack = Stack.of(stackExports);
    const components = [
        ...stackExports.node.scopes
            .slice(stackRelativeExports ? stack.node.scopes.length : 2)
            .map(c => c.node.id),
        id,
    ];
    const prefix = stack.stackName ? stack.stackName + ':' : '';
    const localPart = uniqueid_1.makeUniqueId(components);
    const maxLength = 255;
    return prefix + localPart.slice(Math.max(0, localPart.length - maxLength + prefix.length));
}
function count(xs) {
    const ret = {};
    for (const x of xs) {
        if (x in ret) {
            ret[x] += 1;
        }
        else {
            ret[x] = 1;
        }
    }
    return ret;
}
// These imports have to be at the end to prevent circular imports
const cfn_output_1 = require("./cfn-output");
const deps_1 = require("./deps");
const fs_1 = require("./fs");
const names_1 = require("./names");
const reference_1 = require("./reference");
const stack_synthesizers_1 = require("./stack-synthesizers");
const stage_1 = require("./stage");
const tag_manager_1 = require("./tag-manager");
const token_1 = require("./token");
const refs_1 = require("./private/refs");
const region_info_1 = require("@aws-cdk/region-info");
const region_lookup_1 = require("./private/region-lookup");
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack.js","sourceRoot":"","sources":["stack.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport * as cxschema from '@aws-cdk/cloud-assembly-schema';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport { IConstruct, Construct, Node } from 'constructs';\nimport * as minimatch from 'minimatch';\nimport { Annotations } from './annotations';\nimport { App } from './app';\nimport { Arn, ArnComponents, ArnFormat } from './arn';\nimport { DockerImageAssetLocation, DockerImageAssetSource, FileAssetLocation, FileAssetSource } from './assets';\nimport { CfnElement } from './cfn-element';\nimport { Fn } from './cfn-fn';\nimport { Aws, ScopedAws } from './cfn-pseudo';\nimport { CfnResource, TagType } from './cfn-resource';\nimport { ISynthesisSession } from './construct-compat';\nimport { ContextProvider } from './context-provider';\nimport { Environment } from './environment';\nimport { FeatureFlags } from './feature-flags';\nimport { CLOUDFORMATION_TOKEN_RESOLVER, CloudFormationLang } from './private/cloudformation-lang';\nimport { LogicalIDs } from './private/logical-id';\nimport { resolve } from './private/resolve';\nimport { makeUniqueId } from './private/uniqueid';\n\n// v2 - keep this import as a separate section to reduce merge conflict when forward merging with the v2 branch.\n// eslint-disable-next-line\nimport { Construct as CoreConstruct } from './construct-compat';\n\nconst STACK_SYMBOL = Symbol.for('@aws-cdk/core.Stack');\nconst MY_STACK_CACHE = Symbol.for('@aws-cdk/core.Stack.myStack');\n\nexport const STACK_RESOURCE_LIMIT_CONTEXT = '@aws-cdk/core:stackResourceLimit';\n\nconst VALID_STACK_NAME_REGEX = /^[A-Za-z][A-Za-z0-9-]*$/;\n\nconst MAX_RESOURCES = 500;\n\nexport interface StackProps {\n  /**\n   * A description of the stack.\n   *\n   * @default - No description.\n   */\n  readonly description?: string;\n\n  /**\n   * The AWS environment (account/region) where this stack will be deployed.\n   *\n   * Set the `region`/`account` fields of `env` to either a concrete value to\n   * select the indicated environment (recommended for production stacks), or to\n   * the values of environment variables\n   * `CDK_DEFAULT_REGION`/`CDK_DEFAULT_ACCOUNT` to let the target environment\n   * depend on the AWS credentials/configuration that the CDK CLI is executed\n   * under (recommended for development stacks).\n   *\n   * If the `Stack` is instantiated inside a `Stage`, any undefined\n   * `region`/`account` fields from `env` will default to the same field on the\n   * encompassing `Stage`, if configured there.\n   *\n   * If either `region` or `account` are not set nor inherited from `Stage`, the\n   * Stack will be considered \"*environment-agnostic*\"\". Environment-agnostic\n   * stacks can be deployed to any environment but may not be able to take\n   * advantage of all features of the CDK. For example, they will not be able to\n   * use environmental context lookups such as `ec2.Vpc.fromLookup` and will not\n   * automatically translate Service Principals to the right format based on the\n   * environment's AWS partition, and other such enhancements.\n   *\n   * @example\n   *\n   * // Use a concrete account and region to deploy this stack to:\n   * // `.account` and `.region` will simply return these values.\n   * new Stack(app, 'Stack1', {\n   *   env: {\n   *     account: '123456789012',\n   *     region: 'us-east-1'\n   *   },\n   * });\n   *\n   * // Use the CLI's current credentials to determine the target environment:\n   * // `.account` and `.region` will reflect the account+region the CLI\n   * // is configured to use (based on the user CLI credentials)\n   * new Stack(app, 'Stack2', {\n   *   env: {\n   *     account: process.env.CDK_DEFAULT_ACCOUNT,\n   *     region: process.env.CDK_DEFAULT_REGION\n   *   },\n   * });\n   *\n   * // Define multiple stacks stage associated with an environment\n   * const myStage = new Stage(app, 'MyStage', {\n   *   env: {\n   *     account: '123456789012',\n   *     region: 'us-east-1'\n   *   }\n   * });\n   *\n   * // both of these stacks will use the stage's account/region:\n   * // `.account` and `.region` will resolve to the concrete values as above\n   * new MyStack(myStage, 'Stack1');\n   * new YourStack(myStage, 'Stack2');\n   *\n   * // Define an environment-agnostic stack:\n   * // `.account` and `.region` will resolve to `{ \"Ref\": \"AWS::AccountId\" }` and `{ \"Ref\": \"AWS::Region\" }` respectively.\n   * // which will only resolve to actual values by CloudFormation during deployment.\n   * new MyStack(app, 'Stack1');\n   *\n   * @default - The environment of the containing `Stage` if available,\n   * otherwise create the stack will be environment-agnostic.\n   */\n  readonly env?: Environment;\n\n  /**\n   * Name to deploy the stack with\n   *\n   * @default - Derived from construct path.\n   */\n  readonly stackName?: string;\n\n  /**\n   * Stack tags that will be applied to all the taggable resources and the stack itself.\n   *\n   * @default {}\n   */\n  readonly tags?: { [key: string]: string };\n\n  /**\n   * Synthesis method to use while deploying this stack\n   *\n   * @default - `DefaultStackSynthesizer` if the `@aws-cdk/core:newStyleStackSynthesis` feature flag\n   * is set, `LegacyStackSynthesizer` otherwise.\n   */\n  readonly synthesizer?: IStackSynthesizer;\n\n  /**\n   * Whether to enable termination protection for this stack.\n   *\n   * @default false\n   */\n  readonly terminationProtection?: boolean;\n\n  /**\n   * Include runtime versioning information in this Stack\n   *\n   * @default `analyticsReporting` setting of containing `App`, or value of\n   * 'aws:cdk:version-reporting' context key\n   */\n  readonly analyticsReporting?: boolean;\n}\n\n/**\n * A root construct which represents a single CloudFormation stack.\n */\nexport class Stack extends CoreConstruct implements ITaggable {\n  /**\n   * Return whether the given object is a Stack.\n   *\n   * We do attribute detection since we can't reliably use 'instanceof'.\n   */\n  public static isStack(x: any): x is Stack {\n    return x !== null && typeof(x) === 'object' && STACK_SYMBOL in x;\n  }\n\n  /**\n   * Looks up the first stack scope in which `construct` is defined. Fails if there is no stack up the tree.\n   * @param construct The construct to start the search from.\n   */\n  public static of(construct: IConstruct): Stack {\n    // we want this to be as cheap as possible. cache this result by mutating\n    // the object. anecdotally, at the time of this writing, @aws-cdk/core unit\n    // tests hit this cache 1,112 times, @aws-cdk/aws-cloudformation unit tests\n    // hit this 2,435 times).\n    const cache = (construct as any)[MY_STACK_CACHE] as Stack | undefined;\n    if (cache) {\n      return cache;\n    } else {\n      const value = _lookup(construct);\n      Object.defineProperty(construct, MY_STACK_CACHE, {\n        enumerable: false,\n        writable: false,\n        configurable: false,\n        value,\n      });\n      return value;\n    }\n\n    function _lookup(c: IConstruct): Stack {\n      if (Stack.isStack(c)) {\n        return c;\n      }\n\n      const _scope = Node.of(c).scope;\n      if (Stage.isStage(c) || !_scope) {\n        throw new Error(`${construct.constructor?.name ?? 'Construct'} at '${Node.of(construct).path}' should be created in the scope of a Stack, but no Stack found`);\n      }\n\n      return _lookup(_scope);\n    }\n  }\n\n  /**\n   * Tags to be applied to the stack.\n   */\n  public readonly tags: TagManager;\n\n  /**\n   * Options for CloudFormation template (like version, transform, description).\n   */\n  public readonly templateOptions: ITemplateOptions;\n\n  /**\n   * The AWS region into which this stack will be deployed (e.g. `us-west-2`).\n   *\n   * This value is resolved according to the following rules:\n   *\n   * 1. The value provided to `env.region` when the stack is defined. This can\n   *    either be a concerete region (e.g. `us-west-2`) or the `Aws.region`\n   *    token.\n   * 3. `Aws.region`, which is represents the CloudFormation intrinsic reference\n   *    `{ \"Ref\": \"AWS::Region\" }` encoded as a string token.\n   *\n   * Preferably, you should use the return value as an opaque string and not\n   * attempt to parse it to implement your logic. If you do, you must first\n   * check that it is a concerete value an not an unresolved token. If this\n   * value is an unresolved token (`Token.isUnresolved(stack.region)` returns\n   * `true`), this implies that the user wishes that this stack will synthesize\n   * into a **region-agnostic template**. In this case, your code should either\n   * fail (throw an error, emit a synth error using `Annotations.of(construct).addError()`) or\n   * implement some other region-agnostic behavior.\n   */\n  public readonly region: string;\n\n  /**\n   * The AWS account into which this stack will be deployed.\n   *\n   * This value is resolved according to the following rules:\n   *\n   * 1. The value provided to `env.account` when the stack is defined. This can\n   *    either be a concerete account (e.g. `585695031111`) or the\n   *    `Aws.accountId` token.\n   * 3. `Aws.accountId`, which represents the CloudFormation intrinsic reference\n   *    `{ \"Ref\": \"AWS::AccountId\" }` encoded as a string token.\n   *\n   * Preferably, you should use the return value as an opaque string and not\n   * attempt to parse it to implement your logic. If you do, you must first\n   * check that it is a concerete value an not an unresolved token. If this\n   * value is an unresolved token (`Token.isUnresolved(stack.account)` returns\n   * `true`), this implies that the user wishes that this stack will synthesize\n   * into a **account-agnostic template**. In this case, your code should either\n   * fail (throw an error, emit a synth error using `Annotations.of(construct).addError()`) or\n   * implement some other region-agnostic behavior.\n   */\n  public readonly account: string;\n\n  /**\n   * The environment coordinates in which this stack is deployed. In the form\n   * `aws://account/region`. Use `stack.account` and `stack.region` to obtain\n   * the specific values, no need to parse.\n   *\n   * You can use this value to determine if two stacks are targeting the same\n   * environment.\n   *\n   * If either `stack.account` or `stack.region` are not concrete values (e.g.\n   * `Aws.account` or `Aws.region`) the special strings `unknown-account` and/or\n   * `unknown-region` will be used respectively to indicate this stack is\n   * region/account-agnostic.\n   */\n  public readonly environment: string;\n\n  /**\n   * Whether termination protection is enabled for this stack.\n   */\n  public readonly terminationProtection?: boolean;\n\n  /**\n   * If this is a nested stack, this represents its `AWS::CloudFormation::Stack`\n   * resource. `undefined` for top-level (non-nested) stacks.\n   *\n   */\n  public readonly nestedStackResource?: CfnResource;\n\n  /**\n   * The name of the CloudFormation template file emitted to the output\n   * directory during synthesis.\n   *\n   * Example value: `MyStack.template.json`\n   */\n  public readonly templateFile: string;\n\n  /**\n   * The ID of the cloud assembly artifact for this stack.\n   */\n  public readonly artifactId: string;\n\n  /**\n   * Synthesis method for this stack\n   *\n   */\n  public readonly synthesizer: IStackSynthesizer;\n\n  /**\n   * Whether version reporting is enabled for this stack\n   *\n   * Controls whether the CDK Metadata resource is injected\n   *\n   * @internal\n   */\n  public readonly _versionReportingEnabled: boolean;\n\n  /**\n   * Logical ID generation strategy\n   */\n  private readonly _logicalIds: LogicalIDs;\n\n  /**\n   * Other stacks this stack depends on\n   */\n  private readonly _stackDependencies: { [uniqueId: string]: StackDependency };\n\n  /**\n   * Lists all missing contextual information.\n   * This is returned when the stack is synthesized under the 'missing' attribute\n   * and allows tooling to obtain the context and re-synthesize.\n   */\n  private readonly _missingContext: cxschema.MissingContext[];\n\n  private readonly _stackName: string;\n\n  /**\n   * Creates a new stack.\n   *\n   * @param scope Parent of this stack, usually an `App` or a `Stage`, but could be any construct.\n   * @param id The construct ID of this stack. If `stackName` is not explicitly\n   * defined, this id (and any parent IDs) will be used to determine the\n   * physical ID of the stack.\n   * @param props Stack properties.\n   */\n  public constructor(scope?: Construct, id?: string, props: StackProps = {}) {\n    // For unit test scope and id are optional for stacks, but we still want an App\n    // as the parent because apps implement much of the synthesis logic.\n    scope = scope ?? new App({\n      autoSynth: false,\n      outdir: FileSystem.mkdtemp('cdk-test-app-'),\n    });\n\n    // \"Default\" is a \"hidden id\" from a `node.uniqueId` perspective\n    id = id ?? 'Default';\n\n    super(scope, id);\n\n    this._missingContext = new Array<cxschema.MissingContext>();\n    this._stackDependencies = { };\n    this.templateOptions = { };\n\n    Object.defineProperty(this, STACK_SYMBOL, { value: true });\n\n    this._logicalIds = new LogicalIDs();\n\n    const { account, region, environment } = this.parseEnvironment(props.env);\n\n    this.account = account;\n    this.region = region;\n    this.environment = environment;\n    this.terminationProtection = props.terminationProtection;\n\n    if (props.description !== undefined) {\n      // Max length 1024 bytes\n      // Typically 2 bytes per character, may be more for more exotic characters\n      if (props.description.length > 512) {\n        throw new Error(`Stack description must be <= 1024 bytes. Received description: '${props.description}'`);\n      }\n      this.templateOptions.description = props.description;\n    }\n\n    this._stackName = props.stackName ?? this.generateStackName();\n    if (this._stackName.length > 128) {\n      throw new Error(`Stack name must be <= 128 characters. Stack name: '${this._stackName}'`);\n    }\n    this.tags = new TagManager(TagType.KEY_VALUE, 'aws:cdk:stack', props.tags);\n\n    if (!VALID_STACK_NAME_REGEX.test(this.stackName)) {\n      throw new Error(`Stack name must match the regular expression: ${VALID_STACK_NAME_REGEX.toString()}, got '${this.stackName}'`);\n    }\n\n    // the preferred behavior is to generate a unique id for this stack and use\n    // it as the artifact ID in the assembly. this allows multiple stacks to use\n    // the same name. however, this behavior is breaking for 1.x so it's only\n    // applied under a feature flag which is applied automatically for new\n    // projects created using `cdk init`.\n    //\n    // Also use the new behavior if we are using the new CI/CD-ready synthesizer; that way\n    // people only have to flip one flag.\n    const featureFlags = FeatureFlags.of(this);\n    const stackNameDupeContext = featureFlags.isEnabled(cxapi.ENABLE_STACK_NAME_DUPLICATES_CONTEXT);\n    const newStyleSynthesisContext = featureFlags.isEnabled(cxapi.NEW_STYLE_STACK_SYNTHESIS_CONTEXT);\n    this.artifactId = (stackNameDupeContext || newStyleSynthesisContext)\n      ? this.generateStackArtifactId()\n      : this.stackName;\n\n    this.templateFile = `${this.artifactId}.template.json`;\n\n    // Not for nested stacks\n    this._versionReportingEnabled = (props.analyticsReporting ?? this.node.tryGetContext(cxapi.ANALYTICS_REPORTING_ENABLED_CONTEXT))\n      && !this.nestedStackParent;\n\n    this.synthesizer = props.synthesizer ?? (newStyleSynthesisContext\n      ? new DefaultStackSynthesizer()\n      : new LegacyStackSynthesizer());\n    this.synthesizer.bind(this);\n  }\n\n  /**\n   * Resolve a tokenized value in the context of the current stack.\n   */\n  public resolve(obj: any): any {\n    return resolve(obj, {\n      scope: this,\n      prefix: [],\n      resolver: CLOUDFORMATION_TOKEN_RESOLVER,\n      preparing: false,\n    });\n  }\n\n  /**\n   * Convert an object, potentially containing tokens, to a JSON string\n   */\n  public toJsonString(obj: any, space?: number): string {\n    return CloudFormationLang.toJSON(obj, space).toString();\n  }\n\n  /**\n   * DEPRECATED\n   * @deprecated use `reportMissingContextKey()`\n   */\n  public reportMissingContext(report: cxapi.MissingContext) {\n    if (!Object.values(cxschema.ContextProvider).includes(report.provider as cxschema.ContextProvider)) {\n      throw new Error(`Unknown context provider requested in: ${JSON.stringify(report)}`);\n    }\n    this.reportMissingContextKey(report as cxschema.MissingContext);\n  }\n\n  /**\n   * Indicate that a context key was expected\n   *\n   * Contains instructions which will be emitted into the cloud assembly on how\n   * the key should be supplied.\n   *\n   * @param report The set of parameters needed to obtain the context\n   */\n  public reportMissingContextKey(report: cxschema.MissingContext) {\n    this._missingContext.push(report);\n  }\n\n  /**\n   * Rename a generated logical identities\n   *\n   * To modify the naming scheme strategy, extend the `Stack` class and\n   * override the `allocateLogicalId` method.\n   */\n  public renameLogicalId(oldId: string, newId: string) {\n    this._logicalIds.addRename(oldId, newId);\n  }\n\n  /**\n   * Allocates a stack-unique CloudFormation-compatible logical identity for a\n   * specific resource.\n   *\n   * This method is called when a `CfnElement` is created and used to render the\n   * initial logical identity of resources. Logical ID renames are applied at\n   * this stage.\n   *\n   * This method uses the protected method `allocateLogicalId` to render the\n   * logical ID for an element. To modify the naming scheme, extend the `Stack`\n   * class and override this method.\n   *\n   * @param element The CloudFormation element for which a logical identity is\n   * needed.\n   */\n  public getLogicalId(element: CfnElement): string {\n    const logicalId = this.allocateLogicalId(element);\n    return this._logicalIds.applyRename(logicalId);\n  }\n\n  /**\n   * Add a dependency between this stack and another stack.\n   *\n   * This can be used to define dependencies between any two stacks within an\n   * app, and also supports nested stacks.\n   */\n  public addDependency(target: Stack, reason?: string) {\n    addDependency(this, target, reason);\n  }\n\n  /**\n   * Return the stacks this stack depends on\n   */\n  public get dependencies(): Stack[] {\n    return Object.values(this._stackDependencies).map(x => x.stack);\n  }\n\n  /**\n   * The concrete CloudFormation physical stack name.\n   *\n   * This is either the name defined explicitly in the `stackName` prop or\n   * allocated based on the stack's location in the construct tree. Stacks that\n   * are directly defined under the app use their construct `id` as their stack\n   * name. Stacks that are defined deeper within the tree will use a hashed naming\n   * scheme based on the construct path to ensure uniqueness.\n   *\n   * If you wish to obtain the deploy-time AWS::StackName intrinsic,\n   * you can use `Aws.stackName` directly.\n   */\n  public get stackName(): string {\n    return this._stackName;\n  }\n\n  /**\n   * The partition in which this stack is defined\n   */\n  public get partition(): string {\n    // Always return a non-scoped partition intrinsic. These will usually\n    // be used to construct an ARN, but there are no cross-partition\n    // calls anyway.\n    return Aws.PARTITION;\n  }\n\n  /**\n   * The Amazon domain suffix for the region in which this stack is defined\n   */\n  public get urlSuffix(): string {\n    // Since URL Suffix always follows partition, it is unscoped like partition is.\n    return Aws.URL_SUFFIX;\n  }\n\n  /**\n   * The ID of the stack\n   *\n   * @example\n   * // After resolving, looks like\n   * 'arn:aws:cloudformation:us-west-2:123456789012:stack/teststack/51af3dc0-da77-11e4-872e-1234567db123'\n   */\n  public get stackId(): string {\n    return new ScopedAws(this).stackId;\n  }\n\n  /**\n   * Returns the list of notification Amazon Resource Names (ARNs) for the current stack.\n   */\n  public get notificationArns(): string[] {\n    return new ScopedAws(this).notificationArns;\n  }\n\n  /**\n   * Indicates if this is a nested stack, in which case `parentStack` will include a reference to it's parent.\n   */\n  public get nested(): boolean {\n    return this.nestedStackResource !== undefined;\n  }\n\n  /**\n   * Creates an ARN from components.\n   *\n   * If `partition`, `region` or `account` are not specified, the stack's\n   * partition, region and account will be used.\n   *\n   * If any component is the empty string, an empty string will be inserted\n   * into the generated ARN at the location that component corresponds to.\n   *\n   * The ARN will be formatted as follows:\n   *\n   *   arn:{partition}:{service}:{region}:{account}:{resource}{sep}}{resource-name}\n   *\n   * The required ARN pieces that are omitted will be taken from the stack that\n   * the 'scope' is attached to. If all ARN pieces are supplied, the supplied scope\n   * can be 'undefined'.\n   */\n  public formatArn(components: ArnComponents): string {\n    return Arn.format(components, this);\n  }\n\n  /**\n   * Given an ARN, parses it and returns components.\n   *\n   * IF THE ARN IS A CONCRETE STRING...\n   *\n   * ...it will be parsed and validated. The separator (`sep`) will be set to '/'\n   * if the 6th component includes a '/', in which case, `resource` will be set\n   * to the value before the '/' and `resourceName` will be the rest. In case\n   * there is no '/', `resource` will be set to the 6th components and\n   * `resourceName` will be set to the rest of the string.\n   *\n   * IF THE ARN IS A TOKEN...\n   *\n   * ...it cannot be validated, since we don't have the actual value yet at the\n   * time of this function call. You will have to supply `sepIfToken` and\n   * whether or not ARNs of the expected format usually have resource names\n   * in order to parse it properly. The resulting `ArnComponents` object will\n   * contain tokens for the subexpressions of the ARN, not string literals.\n   *\n   * If the resource name could possibly contain the separator char, the actual\n   * resource name cannot be properly parsed. This only occurs if the separator\n   * char is '/', and happens for example for S3 object ARNs, IAM Role ARNs,\n   * IAM OIDC Provider ARNs, etc. To properly extract the resource name from a\n   * Tokenized ARN, you must know the resource type and call\n   * `Arn.extractResourceName`.\n   *\n   * @param arn The ARN string to parse\n   * @param sepIfToken The separator used to separate resource from resourceName\n   * @param hasName Whether there is a name component in the ARN at all. For\n   * example, SNS Topics ARNs have the 'resource' component contain the topic\n   * name, and no 'resourceName' component.\n   *\n   * @returns an ArnComponents object which allows access to the various\n   * components of the ARN.\n   *\n   * @returns an ArnComponents object which allows access to the various\n   *      components of the ARN.\n   *\n   * @deprecated use splitArn instead\n   */\n  public parseArn(arn: string, sepIfToken: string = '/', hasName: boolean = true): ArnComponents {\n    return Arn.parse(arn, sepIfToken, hasName);\n  }\n\n  /**\n   * Splits the provided ARN into its components.\n   * Works both if 'arn' is a string like 'arn:aws:s3:::bucket',\n   * and a Token representing a dynamic CloudFormation expression\n   * (in which case the returned components will also be dynamic CloudFormation expressions,\n   * encoded as Tokens).\n   *\n   * @param arn the ARN to split into its components\n   * @param arnFormat the expected format of 'arn' - depends on what format the service 'arn' represents uses\n   */\n  public splitArn(arn: string, arnFormat: ArnFormat): ArnComponents {\n    return Arn.split(arn, arnFormat);\n  }\n\n  /**\n   * Returns the list of AZs that are available in the AWS environment\n   * (account/region) associated with this stack.\n   *\n   * If the stack is environment-agnostic (either account and/or region are\n   * tokens), this property will return an array with 2 tokens that will resolve\n   * at deploy-time to the first two availability zones returned from CloudFormation's\n   * `Fn::GetAZs` intrinsic function.\n   *\n   * If they are not available in the context, returns a set of dummy values and\n   * reports them as missing, and let the CLI resolve them by calling EC2\n   * `DescribeAvailabilityZones` on the target environment.\n   *\n   * To specify a different strategy for selecting availability zones override this method.\n   */\n  public get availabilityZones(): string[] {\n    // if account/region are tokens, we can't obtain AZs through the context\n    // provider, so we fallback to use Fn::GetAZs. the current lowest common\n    // denominator is 2 AZs across all AWS regions.\n    const agnostic = Token.isUnresolved(this.account) || Token.isUnresolved(this.region);\n    if (agnostic) {\n      return this.node.tryGetContext(cxapi.AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY) || [\n        Fn.select(0, Fn.getAzs()),\n        Fn.select(1, Fn.getAzs()),\n      ];\n    }\n\n    const value = ContextProvider.getValue(this, {\n      provider: cxschema.ContextProvider.AVAILABILITY_ZONE_PROVIDER,\n      dummyValue: ['dummy1a', 'dummy1b', 'dummy1c'],\n    }).value;\n\n    if (!Array.isArray(value)) {\n      throw new Error(`Provider ${cxschema.ContextProvider.AVAILABILITY_ZONE_PROVIDER} expects a list`);\n    }\n\n    return value;\n  }\n\n  /**\n   * Register a file asset on this Stack\n   *\n   * @deprecated Use `stack.synthesizer.addFileAsset()` if you are calling,\n   * and a different IStackSynthesizer class if you are implementing.\n   */\n  public addFileAsset(asset: FileAssetSource): FileAssetLocation {\n    return this.synthesizer.addFileAsset(asset);\n  }\n\n  /**\n   * Register a docker image asset on this Stack\n   *\n   * @deprecated Use `stack.synthesizer.addDockerImageAsset()` if you are calling,\n   * and a different `IStackSynthesizer` class if you are implementing.\n   */\n  public addDockerImageAsset(asset: DockerImageAssetSource): DockerImageAssetLocation {\n    return this.synthesizer.addDockerImageAsset(asset);\n  }\n\n  /**\n   * If this is a nested stack, returns it's parent stack.\n   */\n  public get nestedStackParent() {\n    return this.nestedStackResource && Stack.of(this.nestedStackResource);\n  }\n\n  /**\n   * Returns the parent of a nested stack.\n   *\n   * @deprecated use `nestedStackParent`\n   */\n  public get parentStack() {\n    return this.nestedStackParent;\n  }\n\n  /**\n   * Add a Transform to this stack. A Transform is a macro that AWS\n   * CloudFormation uses to process your template.\n   *\n   * Duplicate values are removed when stack is synthesized.\n   *\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-section-structure.html\n   * @param transform The transform to add\n   *\n   * @example\n   * declare const stack: Stack;\n   *\n   * stack.addTransform('AWS::Serverless-2016-10-31')\n   */\n  public addTransform(transform: string) {\n    if (!this.templateOptions.transforms) {\n      this.templateOptions.transforms = [];\n    }\n    this.templateOptions.transforms.push(transform);\n  }\n\n  /**\n   * Called implicitly by the `addDependency` helper function in order to\n   * realize a dependency between two top-level stacks at the assembly level.\n   *\n   * Use `stack.addDependency` to define the dependency between any two stacks,\n   * and take into account nested stack relationships.\n   *\n   * @internal\n   */\n  public _addAssemblyDependency(target: Stack, reason?: string) {\n    // defensive: we should never get here for nested stacks\n    if (this.nested || target.nested) {\n      throw new Error('Cannot add assembly-level dependencies for nested stacks');\n    }\n\n    reason = reason || 'dependency added using stack.addDependency()';\n    const cycle = target.stackDependencyReasons(this);\n    if (cycle !== undefined) {\n      // eslint-disable-next-line max-len\n      throw new Error(`'${target.node.path}' depends on '${this.node.path}' (${cycle.join(', ')}). Adding this dependency (${reason}) would create a cyclic reference.`);\n    }\n\n    let dep = this._stackDependencies[Names.uniqueId(target)];\n    if (!dep) {\n      dep = this._stackDependencies[Names.uniqueId(target)] = {\n        stack: target,\n        reasons: [],\n      };\n    }\n\n    dep.reasons.push(reason);\n\n    if (process.env.CDK_DEBUG_DEPS) {\n      // eslint-disable-next-line no-console\n      console.error(`[CDK_DEBUG_DEPS] stack \"${this.node.path}\" depends on \"${target.node.path}\" because: ${reason}`);\n    }\n  }\n\n  /**\n   * Synthesizes the cloudformation template into a cloud assembly.\n   * @internal\n   */\n  public _synthesizeTemplate(session: ISynthesisSession, lookupRoleArn?: string): void {\n    // In principle, stack synthesis is delegated to the\n    // StackSynthesis object.\n    //\n    // However, some parts of synthesis currently use some private\n    // methods on Stack, and I don't really see the value in refactoring\n    // this right now, so some parts still happen here.\n    const builder = session.assembly;\n\n    const template = this._toCloudFormation();\n\n    // write the CloudFormation template as a JSON file\n    const outPath = path.join(builder.outdir, this.templateFile);\n\n    if (this.maxResources > 0) {\n      const resources = template.Resources || {};\n      const numberOfResources = Object.keys(resources).length;\n\n      if (numberOfResources > this.maxResources) {\n        const counts = Object.entries(count(Object.values(resources).map((r: any) => `${r?.Type}`))).map(([type, c]) => `${type} (${c})`).join(', ');\n        throw new Error(`Number of resources in stack '${this.node.path}': ${numberOfResources} is greater than allowed maximum of ${this.maxResources}: ${counts}`);\n      } else if (numberOfResources >= (this.maxResources * 0.8)) {\n        Annotations.of(this).addInfo(`Number of resources: ${numberOfResources} is approaching allowed maximum of ${this.maxResources}`);\n      }\n    }\n    fs.writeFileSync(outPath, JSON.stringify(template, undefined, 1));\n\n    for (const ctx of this._missingContext) {\n      if (lookupRoleArn != null) {\n        builder.addMissing({ ...ctx, props: { ...ctx.props, lookupRoleArn } });\n      } else {\n        builder.addMissing(ctx);\n      }\n    }\n  }\n\n  /**\n   * Look up a fact value for the given fact for the region of this stack\n   *\n   * Will return a definite value only if the region of the current stack is resolved.\n   * If not, a lookup map will be added to the stack and the lookup will be done at\n   * CDK deployment time.\n   *\n   * What regions will be included in the lookup map is controlled by the\n   * `@aws-cdk/core:target-partitions` context value: it must be set to a list\n   * of partitions, and only regions from the given partitions will be included.\n   * If no such context key is set, all regions will be included.\n   *\n   * This function is intended to be used by construct library authors. Application\n   * builders can rely on the abstractions offered by construct libraries and do\n   * not have to worry about regional facts.\n   *\n   * If `defaultValue` is not given, it is an error if the fact is unknown for\n   * the given region.\n   */\n  public regionalFact(factName: string, defaultValue?: string): string {\n    if (!Token.isUnresolved(this.region)) {\n      const ret = Fact.find(this.region, factName) ?? defaultValue;\n      if (ret === undefined) {\n        throw new Error(`region-info: don't know ${factName} for region ${this.region}. Use 'Fact.register' to provide this value.`);\n      }\n      return ret;\n    }\n\n    const partitions = Node.of(this).tryGetContext(cxapi.TARGET_PARTITIONS);\n    if (partitions !== undefined && !Array.isArray(partitions)) {\n      throw new Error(`Context value '${cxapi.TARGET_PARTITIONS}' should be a list of strings, got: ${JSON.stringify(cxapi.TARGET_PARTITIONS)}`);\n    }\n\n    const lookupMap = partitions ? RegionInfo.limitedRegionMap(factName, partitions) : RegionInfo.regionMap(factName);\n\n    return deployTimeLookup(this, factName, lookupMap, defaultValue);\n  }\n\n\n  /**\n   * Create a CloudFormation Export for a value\n   *\n   * Returns a string representing the corresponding `Fn.importValue()`\n   * expression for this Export. You can control the name for the export by\n   * passing the `name` option.\n   *\n   * If you don't supply a value for `name`, the value you're exporting must be\n   * a Resource attribute (for example: `bucket.bucketName`) and it will be\n   * given the same name as the automatic cross-stack reference that would be created\n   * if you used the attribute in another Stack.\n   *\n   * One of the uses for this method is to *remove* the relationship between\n   * two Stacks established by automatic cross-stack references. It will\n   * temporarily ensure that the CloudFormation Export still exists while you\n   * remove the reference from the consuming stack. After that, you can remove\n   * the resource and the manual export.\n   *\n   * ## Example\n   *\n   * Here is how the process works. Let's say there are two stacks,\n   * `producerStack` and `consumerStack`, and `producerStack` has a bucket\n   * called `bucket`, which is referenced by `consumerStack` (perhaps because\n   * an AWS Lambda Function writes into it, or something like that).\n   *\n   * It is not safe to remove `producerStack.bucket` because as the bucket is being\n   * deleted, `consumerStack` might still be using it.\n   *\n   * Instead, the process takes two deployments:\n   *\n   * ### Deployment 1: break the relationship\n   *\n   * - Make sure `consumerStack` no longer references `bucket.bucketName` (maybe the consumer\n   *   stack now uses its own bucket, or it writes to an AWS DynamoDB table, or maybe you just\n   *   remove the Lambda Function altogether).\n   * - In the `ProducerStack` class, call `this.exportValue(this.bucket.bucketName)`. This\n   *   will make sure the CloudFormation Export continues to exist while the relationship\n   *   between the two stacks is being broken.\n   * - Deploy (this will effectively only change the `consumerStack`, but it's safe to deploy both).\n   *\n   * ### Deployment 2: remove the bucket resource\n   *\n   * - You are now free to remove the `bucket` resource from `producerStack`.\n   * - Don't forget to remove the `exportValue()` call as well.\n   * - Deploy again (this time only the `producerStack` will be changed -- the bucket will be deleted).\n   */\n  public exportValue(exportedValue: any, options: ExportValueOptions = {}) {\n    if (options.name) {\n      new CfnOutput(this, `Export${options.name}`, {\n        value: exportedValue,\n        exportName: options.name,\n      });\n      return Fn.importValue(options.name);\n    }\n\n    const resolvable = Tokenization.reverse(exportedValue);\n    if (!resolvable || !Reference.isReference(resolvable)) {\n      throw new Error('exportValue: either supply \\'name\\' or make sure to export a resource attribute (like \\'bucket.bucketName\\')');\n    }\n\n    // if exportValue is being called manually (which is pre onPrepare) then the logicalId\n    // could potentially be changed by a call to overrideLogicalId. This would cause our Export/Import\n    // to have an incorrect id. For a better user experience, lock the logicalId and throw an error\n    // if the user tries to override the id _after_ calling exportValue\n    if (CfnElement.isCfnElement(resolvable.target)) {\n      resolvable.target._lockLogicalId();\n    }\n\n    // \"teleport\" the value here, in case it comes from a nested stack. This will also\n    // ensure the value is from our own scope.\n    const exportable = referenceNestedStackValueInParent(resolvable, this);\n\n    // Ensure a singleton \"Exports\" scoping Construct\n    // This mostly exists to trigger LogicalID munging, which would be\n    // disabled if we parented constructs directly under Stack.\n    // Also it nicely prevents likely construct name clashes\n    const exportsScope = getCreateExportsScope(this);\n\n    // Ensure a singleton CfnOutput for this value\n    const resolved = this.resolve(exportable);\n    const id = 'Output' + JSON.stringify(resolved);\n    const exportName = generateExportName(exportsScope, id);\n\n    if (Token.isUnresolved(exportName)) {\n      throw new Error(`unresolved token in generated export name: ${JSON.stringify(this.resolve(exportName))}`);\n    }\n\n    const output = exportsScope.node.tryFindChild(id) as CfnOutput;\n    if (!output) {\n      new CfnOutput(exportsScope, id, { value: Token.asString(exportable), exportName });\n    }\n\n    return Fn.importValue(exportName);\n  }\n\n  /**\n   * Returns the naming scheme used to allocate logical IDs. By default, uses\n   * the `HashedAddressingScheme` but this method can be overridden to customize\n   * this behavior.\n   *\n   * In order to make sure logical IDs are unique and stable, we hash the resource\n   * construct tree path (i.e. toplevel/secondlevel/.../myresource) and add it as\n   * a suffix to the path components joined without a separator (CloudFormation\n   * IDs only allow alphanumeric characters).\n   *\n   * The result will be:\n   *\n   *   <path.join('')><md5(path.join('/')>\n   *     \"human\"      \"hash\"\n   *\n   * If the \"human\" part of the ID exceeds 240 characters, we simply trim it so\n   * the total ID doesn't exceed CloudFormation's 255 character limit.\n   *\n   * We only take 8 characters from the md5 hash (0.000005 chance of collision).\n   *\n   * Special cases:\n   *\n   * - If the path only contains a single component (i.e. it's a top-level\n   *   resource), we won't add the hash to it. The hash is not needed for\n   *   disamiguation and also, it allows for a more straightforward migration an\n   *   existing CloudFormation template to a CDK stack without logical ID changes\n   *   (or renames).\n   * - For aesthetic reasons, if the last components of the path are the same\n   *   (i.e. `L1/L2/Pipeline/Pipeline`), they will be de-duplicated to make the\n   *   resulting human portion of the ID more pleasing: `L1L2Pipeline<HASH>`\n   *   instead of `L1L2PipelinePipeline<HASH>`\n   * - If a component is named \"Default\" it will be omitted from the path. This\n   *   allows refactoring higher level abstractions around constructs without affecting\n   *   the IDs of already deployed resources.\n   * - If a component is named \"Resource\" it will be omitted from the user-visible\n   *   path, but included in the hash. This reduces visual noise in the human readable\n   *   part of the identifier.\n   *\n   * @param cfnElement The element for which the logical ID is allocated.\n   */\n  protected allocateLogicalId(cfnElement: CfnElement): string {\n    const scopes = cfnElement.node.scopes;\n    const stackIndex = scopes.indexOf(cfnElement.stack);\n    const pathComponents = scopes.slice(stackIndex + 1).map(x => x.node.id);\n    return makeUniqueId(pathComponents);\n  }\n\n  /**\n   * Validate stack name\n   *\n   * CloudFormation stack names can include dashes in addition to the regular identifier\n   * character classes, and we don't allow one of the magic markers.\n   *\n   * @internal\n   */\n  protected _validateId(name: string) {\n    if (name && !VALID_STACK_NAME_REGEX.test(name)) {\n      throw new Error(`Stack name must match the regular expression: ${VALID_STACK_NAME_REGEX.toString()}, got '${name}'`);\n    }\n  }\n\n  /**\n   * Returns the CloudFormation template for this stack by traversing\n   * the tree and invoking _toCloudFormation() on all Entity objects.\n   *\n   * @internal\n   */\n  protected _toCloudFormation() {\n    let transform: string | string[] | undefined;\n\n    if (this.templateOptions.transform) {\n      // eslint-disable-next-line max-len\n      Annotations.of(this).addWarning('This stack is using the deprecated `templateOptions.transform` property. Consider switching to `addTransform()`.');\n      this.addTransform(this.templateOptions.transform);\n    }\n\n    if (this.templateOptions.transforms) {\n      if (this.templateOptions.transforms.length === 1) { // Extract single value\n        transform = this.templateOptions.transforms[0];\n      } else { // Remove duplicate values\n        transform = Array.from(new Set(this.templateOptions.transforms));\n      }\n    }\n\n    const template: any = {\n      Description: this.templateOptions.description,\n      Transform: transform,\n      AWSTemplateFormatVersion: this.templateOptions.templateFormatVersion,\n      Metadata: this.templateOptions.metadata,\n    };\n\n    const elements = cfnElements(this);\n    const fragments = elements.map(e => this.resolve(e._toCloudFormation()));\n\n    // merge in all CloudFormation fragments collected from the tree\n    for (const fragment of fragments) {\n      merge(template, fragment);\n    }\n\n    // resolve all tokens and remove all empties\n    const ret = this.resolve(template) || {};\n\n    this._logicalIds.assertAllRenamesApplied();\n\n    return ret;\n  }\n\n  /**\n   * Deprecated.\n   *\n   * @see https://github.com/aws/aws-cdk/pull/7187\n   * @returns reference itself without any change\n   * @deprecated cross reference handling has been moved to `App.prepare()`.\n   */\n  protected prepareCrossReference(_sourceStack: Stack, reference: Reference): IResolvable {\n    return reference;\n  }\n\n  /**\n   * Determine the various stack environment attributes.\n   *\n   */\n  private parseEnvironment(env: Environment = {}) {\n    // if an environment property is explicitly specified when the stack is\n    // created, it will be used. if not, use tokens for account and region.\n    //\n    // (They do not need to be anchored to any construct like resource attributes\n    // are, because we'll never Export/Fn::ImportValue them -- the only situation\n    // in which Export/Fn::ImportValue would work is if the value are the same\n    // between producer and consumer anyway, so we can just assume that they are).\n    const containingAssembly = Stage.of(this);\n    const account = env.account ?? containingAssembly?.account ?? Aws.ACCOUNT_ID;\n    const region = env.region ?? containingAssembly?.region ?? Aws.REGION;\n\n    // this is the \"aws://\" env specification that will be written to the cloud assembly\n    // manifest. it will use \"unknown-account\" and \"unknown-region\" to indicate\n    // environment-agnosticness.\n    const envAccount = !Token.isUnresolved(account) ? account : cxapi.UNKNOWN_ACCOUNT;\n    const envRegion = !Token.isUnresolved(region) ? region : cxapi.UNKNOWN_REGION;\n\n    return {\n      account,\n      region,\n      environment: cxapi.EnvironmentUtils.format(envAccount, envRegion),\n    };\n  }\n\n  /**\n   * Maximum number of resources in the stack\n   *\n   * Set to 0 to mean \"unlimited\".\n   */\n  private get maxResources(): number {\n    const contextLimit = this.node.tryGetContext(STACK_RESOURCE_LIMIT_CONTEXT);\n    return contextLimit !== undefined ? parseInt(contextLimit, 10) : MAX_RESOURCES;\n  }\n\n  /**\n   * Check whether this stack has a (transitive) dependency on another stack\n   *\n   * Returns the list of reasons on the dependency path, or undefined\n   * if there is no dependency.\n   */\n  private stackDependencyReasons(other: Stack): string[] | undefined {\n    if (this === other) { return []; }\n    for (const dep of Object.values(this._stackDependencies)) {\n      const ret = dep.stack.stackDependencyReasons(other);\n      if (ret !== undefined) {\n        return [...dep.reasons, ...ret];\n      }\n    }\n    return undefined;\n  }\n\n  /**\n   * Calculate the stack name based on the construct path\n   *\n   * The stack name is the name under which we'll deploy the stack,\n   * and incorporates containing Stage names by default.\n   *\n   * Generally this looks a lot like how logical IDs are calculated.\n   * The stack name is calculated based on the construct root path,\n   * as follows:\n   *\n   * - Path is calculated with respect to containing App or Stage (if any)\n   * - If the path is one component long just use that component, otherwise\n   *   combine them with a hash.\n   *\n   * Since the hash is quite ugly and we'd like to avoid it if possible -- but\n   * we can't anymore in the general case since it has been written into legacy\n   * stacks. The introduction of Stages makes it possible to make this nicer however.\n   * When a Stack is nested inside a Stage, we use the path components below the\n   * Stage, and prefix the path components of the Stage before it.\n   */\n  private generateStackName() {\n    const assembly = Stage.of(this);\n    const prefix = (assembly && assembly.stageName) ? `${assembly.stageName}-` : '';\n    return `${prefix}${this.generateStackId(assembly)}`;\n  }\n\n  /**\n   * The artifact ID for this stack\n   *\n   * Stack artifact ID is unique within the App's Cloud Assembly.\n   */\n  private generateStackArtifactId() {\n    return this.generateStackId(this.node.root);\n  }\n\n  /**\n   * Generate an ID with respect to the given container construct.\n   */\n  private generateStackId(container: IConstruct | undefined) {\n    const rootPath = rootPathTo(this, container);\n    const ids = rootPath.map(c => Node.of(c).id);\n\n    // In unit tests our Stack (which is the only component) may not have an\n    // id, so in that case just pretend it's \"Stack\".\n    if (ids.length === 1 && !ids[0]) {\n      throw new Error('unexpected: stack id must always be defined');\n    }\n\n    return makeStackName(ids);\n  }\n\n  /**\n   * Indicates whether the stack requires bundling or not\n   */\n  public get bundlingRequired() {\n    const bundlingStacks: string[] = this.node.tryGetContext(cxapi.BUNDLING_STACKS) ?? ['*'];\n\n    // bundlingStacks is of the form `Stage/Stack`, convert it to `Stage-Stack` before comparing to stack name\n    return bundlingStacks.some(pattern => minimatch(\n      this.stackName,\n      pattern.replace('/', '-'),\n    ));\n  }\n}\n\nfunction merge(template: any, fragment: any): void {\n  for (const section of Object.keys(fragment)) {\n    const src = fragment[section];\n\n    // create top-level section if it doesn't exist\n    const dest = template[section];\n    if (!dest) {\n      template[section] = src;\n    } else {\n      template[section] = mergeSection(section, dest, src);\n    }\n  }\n}\n\nfunction mergeSection(section: string, val1: any, val2: any): any {\n  switch (section) {\n    case 'Description':\n      return `${val1}\\n${val2}`;\n    case 'AWSTemplateFormatVersion':\n      if (val1 != null && val2 != null && val1 !== val2) {\n        throw new Error(`Conflicting CloudFormation template versions provided: '${val1}' and '${val2}`);\n      }\n      return val1 ?? val2;\n    case 'Transform':\n      return mergeSets(val1, val2);\n    default:\n      return mergeObjectsWithoutDuplicates(section, val1, val2);\n  }\n}\n\nfunction mergeSets(val1: any, val2: any): any {\n  const array1 = val1 == null ? [] : (Array.isArray(val1) ? val1 : [val1]);\n  const array2 = val2 == null ? [] : (Array.isArray(val2) ? val2 : [val2]);\n  for (const value of array2) {\n    if (!array1.includes(value)) {\n      array1.push(value);\n    }\n  }\n  return array1.length === 1 ? array1[0] : array1;\n}\n\nfunction mergeObjectsWithoutDuplicates(section: string, dest: any, src: any): any {\n  if (typeof dest !== 'object') {\n    throw new Error(`Expecting ${JSON.stringify(dest)} to be an object`);\n  }\n  if (typeof src !== 'object') {\n    throw new Error(`Expecting ${JSON.stringify(src)} to be an object`);\n  }\n\n  // add all entities from source section to destination section\n  for (const id of Object.keys(src)) {\n    if (id in dest) {\n      throw new Error(`section '${section}' already contains '${id}'`);\n    }\n    dest[id] = src[id];\n  }\n\n  return dest;\n}\n\n/**\n * CloudFormation template options for a stack.\n */\nexport interface ITemplateOptions {\n  /**\n   * Gets or sets the description of this stack.\n   * If provided, it will be included in the CloudFormation template's \"Description\" attribute.\n   */\n  description?: string;\n\n  /**\n   * Gets or sets the AWSTemplateFormatVersion field of the CloudFormation template.\n   */\n  templateFormatVersion?: string;\n\n  /**\n   * Gets or sets the top-level template transform for this stack (e.g. \"AWS::Serverless-2016-10-31\").\n   *\n   * @deprecated use `transforms` instead.\n   */\n  transform?: string;\n\n  /**\n   * Gets or sets the top-level template transform(s) for this stack (e.g. `[\"AWS::Serverless-2016-10-31\"]`).\n   */\n  transforms?: string[];\n\n  /**\n   * Metadata associated with the CloudFormation template.\n   */\n  metadata?: { [key: string]: any };\n}\n\n/**\n * Collect all CfnElements from a Stack.\n *\n * @param node Root node to collect all CfnElements from\n * @param into Array to append CfnElements to\n * @returns The same array as is being collected into\n */\nfunction cfnElements(node: IConstruct, into: CfnElement[] = []): CfnElement[] {\n  if (CfnElement.isCfnElement(node)) {\n    into.push(node);\n  }\n\n  for (const child of Node.of(node).children) {\n    // Don't recurse into a substack\n    if (Stack.isStack(child)) { continue; }\n\n    cfnElements(child, into);\n  }\n\n  return into;\n}\n\n/**\n * Return the construct root path of the given construct relative to the given ancestor\n *\n * If no ancestor is given or the ancestor is not found, return the entire root path.\n */\nexport function rootPathTo(construct: IConstruct, ancestor?: IConstruct): IConstruct[] {\n  const scopes = Node.of(construct).scopes;\n  for (let i = scopes.length - 2; i >= 0; i--) {\n    if (scopes[i] === ancestor) {\n      return scopes.slice(i + 1);\n    }\n  }\n  return scopes;\n}\n\n/**\n * makeUniqueId, specialized for Stack names\n *\n * Stack names may contain '-', so we allow that character if the stack name\n * has only one component. Otherwise we fall back to the regular \"makeUniqueId\"\n * behavior.\n */\nfunction makeStackName(components: string[]) {\n  if (components.length === 1) { return components[0]; }\n  return makeUniqueId(components);\n}\n\nfunction getCreateExportsScope(stack: Stack) {\n  const exportsName = 'Exports';\n  let stackExports = stack.node.tryFindChild(exportsName) as CoreConstruct;\n  if (stackExports === undefined) {\n    stackExports = new CoreConstruct(stack, exportsName);\n  }\n\n  return stackExports;\n}\n\nfunction generateExportName(stackExports: CoreConstruct, id: string) {\n  const stackRelativeExports = FeatureFlags.of(stackExports).isEnabled(cxapi.STACK_RELATIVE_EXPORTS_CONTEXT);\n  const stack = Stack.of(stackExports);\n\n  const components = [\n    ...stackExports.node.scopes\n      .slice(stackRelativeExports ? stack.node.scopes.length : 2)\n      .map(c => c.node.id),\n    id,\n  ];\n  const prefix = stack.stackName ? stack.stackName + ':' : '';\n  const localPart = makeUniqueId(components);\n  const maxLength = 255;\n  return prefix + localPart.slice(Math.max(0, localPart.length - maxLength + prefix.length));\n}\n\ninterface StackDependency {\n  stack: Stack;\n  reasons: string[];\n}\n\n/**\n * Options for the `stack.exportValue()` method\n */\nexport interface ExportValueOptions {\n  /**\n   * The name of the export to create\n   *\n   * @default - A name is automatically chosen\n   */\n  readonly name?: string;\n}\n\nfunction count(xs: string[]): Record<string, number> {\n  const ret: Record<string, number> = {};\n  for (const x of xs) {\n    if (x in ret) {\n      ret[x] += 1;\n    } else {\n      ret[x] = 1;\n    }\n  }\n  return ret;\n}\n\n// These imports have to be at the end to prevent circular imports\nimport { CfnOutput } from './cfn-output';\nimport { addDependency } from './deps';\nimport { FileSystem } from './fs';\nimport { Names } from './names';\nimport { Reference } from './reference';\nimport { IResolvable } from './resolvable';\nimport { DefaultStackSynthesizer, IStackSynthesizer, LegacyStackSynthesizer } from './stack-synthesizers';\nimport { Stage } from './stage';\nimport { ITaggable, TagManager } from './tag-manager';\nimport { Token, Tokenization } from './token';\nimport { referenceNestedStackValueInParent } from './private/refs';\nimport { Fact, RegionInfo } from '@aws-cdk/region-info';\nimport { deployTimeLookup } from './private/region-lookup';\n\n"]}