"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.RootConstruct = exports.ConstructOrder = exports.Construct = exports.Node = void 0;
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const dependency_1 = require("./dependency");
const node_addr_1 = require("./private/node-addr");
const stack_trace_1 = require("./private/stack-trace");
const CONSTRUCT_SYM = Symbol.for('constructs.Construct');
/**
 * Represents the construct node in the scope tree.
 */
class Node {
    host;
    static [JSII_RTTI_SYMBOL_1] = { fqn: "constructs.Node", version: "10.8.1" };
    /**
     * Separator used to delimit construct path components.
     */
    static PATH_SEP = '/';
    /**
     * Returns the node associated with a construct.
     * @param construct the construct
     *
     * @deprecated use `construct.node` instead
     */
    static of(construct) {
        return construct.node;
    }
    /**
     * Returns the scope in which this construct is defined.
     *
     * The value is `undefined` at the root of the construct scope tree.
     */
    scope;
    /**
     * The id of this construct within the current scope.
     *
     * This is a scope-unique id. To obtain an id that reflects the full location
     * of this construct in the tree, use `path` or `addr`.
     */
    id;
    /**
     * The full, absolute path of this construct in the tree.
     *
     * Components are separated by '/'.
     */
    path;
    _locked = false; // if this is "true", addChild will fail
    _children;
    _context;
    _metadata;
    _dependencies;
    _defaultChild;
    _validations;
    _addr; // cache
    _scopes;
    constructor(host, scope, id) {
        this.host = host;
        id = id ?? ''; // if undefined, convert to empty string
        this.id = sanitizeId(id);
        this.scope = scope;
        if (scope && !this.id) {
            throw new Error('Only root constructs may have an empty ID');
        }
        if (scope) {
            scope.node.addChild(host, this.id);
            this.path = scope.node.path ? `${scope.node.path}${Node.PATH_SEP}${this.id}` : this.id;
            this._scopes = [...scope.node._scopes, this.host];
        }
        else {
            this.path = this.id;
            this._scopes = [this.host];
        }
    }
    /**
     * All parent scopes of this construct.
     *
     * @returns a list of parent scopes. The last element in the list will always
     * be the current construct and the first element will be the root of the
     * tree.
     */
    get scopes() {
        // Needs to return a copy to make sure callers can't accidentally mutate
        // internal state. jsii doesn't support ReadonlyArray.
        return [...this._scopes];
    }
    /**
     * An opaque, deterministic address for this construct, derived from its path.
     *
     * The address is a 42 character string: the prefix "c8" followed by 40
     * lowercase hexadecimal characters (0-9a-f). It is a SHA-1 over the ids of
     * the constructs on the path from the root of the tree down to this
     * construct.
     *
     * To enable refactoring of construct trees, constructs with the ID `Default`
     * are excluded from the calculation. Within a tree, `a/Default/b` and `a/b`
     * have the same address.
     *
     * This means the address is *not* guaranteed to identify a construct uniquely:
     *
     * - Any construct whose path is made up of the same ids has the same address.
     *   Two trees that are shaped alike therefore hand out the same addresses.
     * - As described above, a construct under a `Default` scope has the same
     *   address as its counterpart outside of that scope.
     * - The digest is of fixed width, so even distinct paths can in principle hash
     *   to the same address. SHA-1 in particular is no longer collision resistant.
     *
     * Use an address to derive stable, deterministic names from the location of a
     * construct in the tree. Do not use it as the identity of a construct:
     * instead, compare construct instances or use the `path`.
     *
     * @example c83a2846e506bcc5f10682b564084bca2d275709ee
     */
    get addr() {
        if (!this._addr) {
            this._addr = (0, node_addr_1.addressOf)(this._scopes.map(c => c.node.id));
        }
        return this._addr;
    }
    /**
     * Return a direct child by id, or undefined
     *
     * @param id Identifier of direct child
     * @returns the child if found, or undefined
     */
    tryFindChild(id) {
        return this._children?.[sanitizeId(id)];
    }
    /**
     * Return a direct child by id
     *
     * Throws an error if the child is not found.
     *
     * @param id Identifier of direct child
     * @returns Child with the given id.
     */
    findChild(id) {
        const ret = this.tryFindChild(id);
        if (!ret) {
            throw new Error(`No child with id: '${id}'`);
        }
        return ret;
    }
    /**
     * Returns the child construct that has the id `Default` or `Resource`.
     * This is usually the construct that provides the bulk of the underlying functionality.
     * Useful for modifications of the underlying construct that are not available at the higher levels.
     *
     * @throws if there is more than one child
     * @returns a construct or undefined if there is no default child
     */
    get defaultChild() {
        if (this._defaultChild !== undefined) {
            return this._defaultChild;
        }
        const resourceChild = this.tryFindChild('Resource');
        const defaultChild = this.tryFindChild('Default');
        if (resourceChild && defaultChild) {
            throw new Error(`Cannot determine default child for ${this.path}. There is both a child with id "Resource" and id "Default"`);
        }
        return defaultChild || resourceChild;
    }
    /**
     * Override the defaultChild property.
     *
     * This should only be used in the cases where the correct
     * default child is not named 'Resource' or 'Default' as it
     * should be.
     *
     * If you set this to undefined, the default behavior of finding
     * the child named 'Resource' or 'Default' will be used.
     */
    set defaultChild(value) {
        this._defaultChild = value;
    }
    /**
     * All direct children of this construct.
     */
    get children() {
        return Object.values(this._children ?? {});
    }
    /**
     * Return this construct and all of its children in the given order
     */
    findAll(order = ConstructOrder.PREORDER) {
        const ret = new Array();
        visit(this.host);
        return ret;
        function visit(c) {
            if (order === ConstructOrder.PREORDER) {
                ret.push(c);
            }
            for (const child of c.node.children) {
                visit(child);
            }
            if (order === ConstructOrder.POSTORDER) {
                ret.push(c);
            }
        }
    }
    /**
     * This can be used to set contextual values.
     * Context must be set before any children are added, since children may consult context info during construction.
     * If the key already exists, it will be overridden.
     * @param key The context key
     * @param value The context value
     */
    setContext(key, value) {
        if (this.children.length > 0) {
            const names = this.children.map(c => c.node.id);
            throw new Error('Cannot set context after children have been added: ' + names.join(','));
        }
        if (!this._context) {
            this._context = {};
        }
        this._context[key] = value;
    }
    /**
     * Retrieves a value from tree context if present. Otherwise, would throw an error.
     *
     * Context is usually initialized at the root, but can be overridden at any point in the tree.
     *
     * @param key The context key
     * @returns The context value or throws error if there is no context value for this key
     */
    getContext(key) {
        const value = this._context?.[key];
        if (value !== undefined) {
            return value;
        }
        if (value === undefined && !this.scope?.node) {
            throw new Error(`No context value present for ${key} key`);
        }
        return this.scope && this.scope.node.getContext(key);
    }
    /**
     * Retrieves the all context of a node from tree context.
     *
     * Context is usually initialized at the root, but can be overridden at any point in the tree.
     *
     * @param defaults Any keys to override the retrieved context
     * @returns The context object or an empty object if there is discovered context
     */
    getAllContext(defaults) {
        const ret = { ...defaults };
        for (const scope of this._scopes) {
            Object.assign(ret, scope.node._context);
        }
        return ret;
    }
    /**
     * Retrieves a value from tree context.
     *
     * Context is usually initialized at the root, but can be overridden at any point in the tree.
     *
     * @param key The context key
     * @returns The context value or `undefined` if there is no context value for this key.
     */
    tryGetContext(key) {
        const value = this._context?.[key];
        if (value !== undefined) {
            return value;
        }
        return this.scope && this.scope.node.tryGetContext(key);
    }
    /**
     * An immutable array of metadata objects associated with this construct.
     * This can be used, for example, to implement support for deprecation notices, source mapping, etc.
     */
    get metadata() {
        return [...this._metadata ?? []];
    }
    /**
     * Adds a metadata entry to this construct.
     * Entries are arbitrary values and will also include a stack trace to allow tracing back to
     * the code location for when the entry was added. It can be used, for example, to include source
     * mapping in CloudFormation templates to improve diagnostics.
     * Note that construct metadata is not the same as CloudFormation resource metadata and is never written to the CloudFormation template.
     * The metadata entries are written to the Cloud Assembly Manifest if the `treeMetadata` property is specified in the props of the App that contains this Construct.
     *
     * @param type a string denoting the type of metadata
     * @param data the value of the metadata (can be a Token). If null/undefined, metadata will not be added.
     * @param options options
     */
    addMetadata(type, data, options = {}) {
        if (data == null) {
            return;
        }
        const node = this;
        function getTrace() {
            if (options.stackTraceOverride && options.stackTraceOverride.length > 0) {
                return options.stackTraceOverride;
            }
            const shouldTrace = options.stackTrace ?? false;
            return shouldTrace ? (0, stack_trace_1.captureStackTrace)(options.traceFromFunction ?? node.addMetadata) : undefined;
        }
        if (!this._metadata) {
            this._metadata = [];
        }
        this._metadata.push({ type, data, trace: getTrace() });
    }
    /**
     * Returns the root of the construct tree.
     * @returns The root of the construct tree.
     */
    get root() {
        return this._scopes[0];
    }
    /**
     * Returns true if this construct or the scopes in which it is defined are
     * locked.
     */
    get locked() {
        if (this._locked) {
            return true;
        }
        if (this.scope && this.scope.node.locked) {
            return true;
        }
        return false;
    }
    /**
     * Add an ordering dependency on a Dependable (a construct or set of constructs)
     *
     * It is up to the target document language to decide what an ordering
     * relationship means and how it should be rendered; for example, in the AWS
     * CDK for CloudFormation it means a dependency from every resource in scope
     * of the current construct to every resource in scope of the target set
     * of constructs, that get realized as either stack dependencies or
     * `DependsOn` relationships in the synthesized template.
     *
     * `IDependable` is a marker interface that indicates that a class has used
     * `Dependable.implement()` to implement the `IDependable` interface. It
     * can be used to make the target object represent more than one set of
     * constructs at a time. For example, a `DependencyGroup` uses this
     * interface to represent an explicit list of 0 or more constructs that should
     * be involved in the dependency relationship.
     */
    addDependency(...deps) {
        if (!this._dependencies) {
            this._dependencies = new Set();
        }
        for (const d of deps) {
            this._dependencies.add(d);
        }
    }
    /**
     * Remove an ordering dependency on a Dependenable (a construct or set of constructs)
     *
     * This removes any dependency added using `node.addDependency()`. It must
     * use the exact same object that was involved in the `addDependency()` call.
     */
    removeDependency(...deps) {
        if (!this._dependencies) {
            this._dependencies = new Set();
        }
        for (const d of deps) {
            this._dependencies.delete(d);
        }
    }
    /**
     * Constructs that this construct depends on directly
     *
     * This expands the sets of `Dependables` to the set of `Constructs` that they
     * represent.
     */
    get dependencies() {
        const result = new Array();
        if (this._dependencies) {
            for (const dep of this._dependencies) {
                for (const root of dependency_1.Dependable.of(dep).dependencyRoots) {
                    result.push(root);
                }
            }
        }
        return result;
    }
    /**
     * Remove the child with the given name, if present.
     *
     * @returns Whether a child with the given name was deleted.
     */
    tryRemoveChild(childName) {
        if (!this._children || !(childName in this._children)) {
            return false;
        }
        delete this._children[childName];
        return true;
    }
    /**
     * Adds a validation to this construct.
     *
     * When `node.validate()` is called, the `validate()` method will be called on
     * all validations and all errors will be returned.
     *
     * @param validation The validation object
     */
    addValidation(validation) {
        if (!this._validations) {
            this._validations = [];
        }
        this._validations.push(validation);
    }
    /**
     * Validates this construct.
     *
     * Invokes the `validate()` method on all validations added through
     * `addValidation()`.
     *
     * @returns an array of validation error messages associated with this
     * construct.
     */
    validate() {
        return (this._validations ?? []).flatMap(v => v.validate());
    }
    /**
     * Locks this construct from allowing more children to be added. After this
     * call, no more children can be added to this construct or to any children.
     */
    lock() {
        this._locked = true;
    }
    /**
     * Applies one or more mixins to this construct.
     *
     * Mixins are applied in order. The list of constructs is captured at the
     * start of the call, so constructs added by a mixin will not be visited.
     * Use multiple `with()` calls if subsequent mixins should apply to added
     * constructs.
     *
     * @param mixins The mixins to apply
     * @returns This construct for chaining
     */
    with(...mixins) {
        const allConstructs = this.findAll();
        for (const mixin of mixins) {
            for (const construct of allConstructs) {
                if (mixin.supports(construct)) {
                    mixin.applyTo(construct);
                }
            }
        }
        return this.host;
    }
    ;
    /**
     * Adds a child construct to this node.
     *
     * @param child The child construct
     * @param childName The type name of the child construct.
     * @returns The resolved path part name of the child
     */
    addChild(child, childName) {
        if (this.locked) {
            // special error if root is locked
            if (!this.path) {
                throw new Error('Cannot add children during synthesis');
            }
            throw new Error(`Cannot add children to "${this.path}" during synthesis`);
        }
        if (!this._children) {
            this._children = {};
        }
        if (this._children[childName]) {
            const name = this.id ?? '';
            const typeName = this.host.constructor.name;
            throw new Error(`There is already a Construct with name '${childName}' in ${typeName}${name.length > 0 ? ' [' + name + ']' : ''}`);
        }
        this._children[childName] = child;
    }
}
exports.Node = Node;
/**
 * Represents the building block of the construct graph.
 *
 * All constructs besides the root construct must be created within the scope of
 * another construct.
 */
class Construct {
    static [JSII_RTTI_SYMBOL_1] = { fqn: "constructs.Construct", version: "10.8.1" };
    /**
     * Checks if `x` is a construct.
     *
     * Use this method instead of `instanceof` to properly detect `Construct`
     * instances, even when the construct library is symlinked.
     *
     * Explanation: in JavaScript, multiple copies of the `constructs` library on
     * disk are seen as independent, completely different libraries. As a
     * consequence, the class `Construct` in each copy of the `constructs` library
     * is seen as a different class, and an instance of one class will not test as
     * `instanceof` the other class. `npm install` will not create installations
     * like this, but users may manually symlink construct libraries together or
     * use a monorepo tool: in those cases, multiple copies of the `constructs`
     * library can be accidentally installed, and `instanceof` will behave
     * unpredictably. It is safest to avoid using `instanceof`, and using
     * this type-testing method instead.
     *
     * @returns true if `x` is an object created from a class which extends `Construct`.
     * @param x Any object
     */
    static isConstruct(x) {
        return x && typeof x === 'object' && x[CONSTRUCT_SYM];
    }
    /**
     * The tree node.
     */
    node;
    /**
     * Creates a new construct node.
     *
     * @param scope The scope in which to define this construct
     * @param id The scoped construct ID. Must be unique amongst siblings. If
     * the ID includes a path separator (`/`) or a newline, then it will be
     * replaced by double dash `--`.
     */
    constructor(scope, id) {
        this.node = new Node(this, scope, id);
        // implement IDependable privately
        dependency_1.Dependable.implement(this, {
            dependencyRoots: [this],
        });
    }
    /**
     * Applies one or more mixins to this construct.
     *
     * Mixins are applied in order. The list of constructs is captured at the
     * start of the call, so constructs added by a mixin will not be visited.
     * Use multiple `with()` calls if subsequent mixins should apply to added
     * constructs.
     *
     * @param mixins The mixins to apply
     * @returns This construct for chaining
     */
    with(...mixins) {
        return this.node.with(...mixins);
    }
    ;
    /**
     * Returns a string representation of this construct.
     */
    toString() {
        return this.node.path || '<root>';
    }
}
exports.Construct = Construct;
/**
 * In what order to return constructs
 */
var ConstructOrder;
(function (ConstructOrder) {
    /**
     * Depth-first, pre-order
     */
    ConstructOrder[ConstructOrder["PREORDER"] = 0] = "PREORDER";
    /**
     * Depth-first, post-order (leaf nodes first)
     */
    ConstructOrder[ConstructOrder["POSTORDER"] = 1] = "POSTORDER";
})(ConstructOrder || (exports.ConstructOrder = ConstructOrder = {}));
const SEP_REGEX = new RegExp(`[${Node.PATH_SEP}${node_addr_1.ADDR_SEP}]`, 'g');
/**
 * Return a sanitized version of an arbitrary string, so it can be used as an ID
 */
function sanitizeId(id) {
    // Escape the separators used by `path` and by `addr` as double dashes, so a
    // single id never looks like multiple path components in either of them.
    return id.replace(SEP_REGEX, '--');
}
// Mark all instances of 'Construct'
Object.defineProperty(Construct.prototype, CONSTRUCT_SYM, {
    value: true,
    enumerable: false,
    writable: false,
});
/**
 * Creates a new root construct node.
 *
 * The root construct represents the top of the construct tree and is not contained within a parent scope itself.
 * For root constructs, the id is optional.
 */
class RootConstruct extends Construct {
    static [JSII_RTTI_SYMBOL_1] = { fqn: "constructs.RootConstruct", version: "10.8.1" };
    /**
     * Creates a new root construct node.
     *
     * @param id The scoped construct ID. Must be unique amongst siblings. If
     * the ID includes a path separator (`/`) or a newline, then it will be
     * replaced by double dash `--`.
     */
    constructor(id) {
        super(undefined, id ?? '');
    }
}
exports.RootConstruct = RootConstruct;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"construct.js","sourceRoot":"","sources":["../src/construct.ts"],"names":[],"mappings":"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","sourcesContent":["import type { IDependable } from './dependency';\nimport { Dependable } from './dependency';\nimport type { MetadataEntry } from './metadata';\nimport type { IMixin } from './mixin';\nimport { ADDR_SEP, addressOf } from './private/node-addr';\nimport { captureStackTrace } from './private/stack-trace';\n\nconst CONSTRUCT_SYM = Symbol.for('constructs.Construct');\n\n/**\n * Represents a construct.\n */\nexport interface IConstruct extends IDependable {\n  /**\n   * The tree node.\n   */\n  readonly node: Node;\n\n  /**\n   * Applies one or more mixins to this construct.\n   *\n   * Mixins are applied in order. The list of constructs is captured at the\n   * start of the call, so constructs added by a mixin will not be visited.\n   *\n   * @param mixins The mixins to apply\n   * @returns This construct for chaining\n   */\n  with(...mixins: IMixin[]): IConstruct;\n}\n\n/**\n * Represents the construct node in the scope tree.\n */\nexport class Node {\n  /**\n   * Separator used to delimit construct path components.\n   */\n  public static readonly PATH_SEP = '/';\n\n  /**\n   * Returns the node associated with a construct.\n   * @param construct the construct\n   *\n   * @deprecated use `construct.node` instead\n   */\n  public static of(construct: IConstruct): Node {\n    return construct.node;\n  }\n\n  /**\n   * Returns the scope in which this construct is defined.\n   *\n   * The value is `undefined` at the root of the construct scope tree.\n   */\n  public readonly scope?: IConstruct;\n\n  /**\n   * The id of this construct within the current scope.\n   *\n   * This is a scope-unique id. To obtain an id that reflects the full location\n   * of this construct in the tree, use `path` or `addr`.\n   */\n  public readonly id: string;\n\n  /**\n   * The full, absolute path of this construct in the tree.\n   *\n   * Components are separated by '/'.\n   */\n  public readonly path: string;\n\n  private _locked = false; // if this is \"true\", addChild will fail\n  private _children: { [id: string]: IConstruct } | undefined;\n  private _context: { [key: string]: any } | undefined;\n  private _metadata: Array<MetadataEntry> | undefined;\n  private _dependencies: Set<IDependable> | undefined;\n  private _defaultChild: IConstruct | undefined;\n  private _validations: Array<IValidation> | undefined;\n  private _addr?: string; // cache\n  private _scopes: readonly IConstruct[];\n\n\n  public constructor(private readonly host: Construct, scope: IConstruct, id: string) {\n    id = id ?? ''; // if undefined, convert to empty string\n\n    this.id = sanitizeId(id);\n    this.scope = scope;\n\n    if (scope && !this.id) {\n      throw new Error('Only root constructs may have an empty ID');\n    }\n\n    if (scope) {\n      scope.node.addChild(host, this.id);\n      this.path = scope.node.path ? `${scope.node.path}${Node.PATH_SEP}${this.id}` : this.id;\n      this._scopes = [...scope.node._scopes, this.host];\n    } else {\n      this.path = this.id;\n      this._scopes = [this.host];\n    }\n  }\n\n  /**\n   * All parent scopes of this construct.\n   *\n   * @returns a list of parent scopes. The last element in the list will always\n   * be the current construct and the first element will be the root of the\n   * tree.\n   */\n  public get scopes(): IConstruct[] {\n    // Needs to return a copy to make sure callers can't accidentally mutate\n    // internal state. jsii doesn't support ReadonlyArray.\n    return [...this._scopes];\n  }\n\n  /**\n   * An opaque, deterministic address for this construct, derived from its path.\n   *\n   * The address is a 42 character string: the prefix \"c8\" followed by 40\n   * lowercase hexadecimal characters (0-9a-f). It is a SHA-1 over the ids of\n   * the constructs on the path from the root of the tree down to this\n   * construct.\n   *\n   * To enable refactoring of construct trees, constructs with the ID `Default`\n   * are excluded from the calculation. Within a tree, `a/Default/b` and `a/b`\n   * have the same address.\n   *\n   * This means the address is *not* guaranteed to identify a construct uniquely:\n   *\n   * - Any construct whose path is made up of the same ids has the same address.\n   *   Two trees that are shaped alike therefore hand out the same addresses.\n   * - As described above, a construct under a `Default` scope has the same\n   *   address as its counterpart outside of that scope.\n   * - The digest is of fixed width, so even distinct paths can in principle hash\n   *   to the same address. SHA-1 in particular is no longer collision resistant.\n   *\n   * Use an address to derive stable, deterministic names from the location of a\n   * construct in the tree. Do not use it as the identity of a construct:\n   * instead, compare construct instances or use the `path`.\n   *\n   * @example c83a2846e506bcc5f10682b564084bca2d275709ee\n   */\n  public get addr(): string {\n    if (!this._addr) {\n      this._addr = addressOf(this._scopes.map(c => c.node.id));\n    }\n\n    return this._addr;\n  }\n\n  /**\n   * Return a direct child by id, or undefined\n   *\n   * @param id Identifier of direct child\n   * @returns the child if found, or undefined\n   */\n  public tryFindChild(id: string): IConstruct | undefined {\n    return this._children?.[sanitizeId(id)];\n  }\n\n  /**\n   * Return a direct child by id\n   *\n   * Throws an error if the child is not found.\n   *\n   * @param id Identifier of direct child\n   * @returns Child with the given id.\n   */\n  public findChild(id: string): IConstruct {\n    const ret = this.tryFindChild(id);\n    if (!ret) {\n      throw new Error(`No child with id: '${id}'`);\n    }\n    return ret;\n  }\n\n  /**\n   * Returns the child construct that has the id `Default` or `Resource`.\n   * This is usually the construct that provides the bulk of the underlying functionality.\n   * Useful for modifications of the underlying construct that are not available at the higher levels.\n   *\n   * @throws if there is more than one child\n   * @returns a construct or undefined if there is no default child\n   */\n  public get defaultChild(): IConstruct | undefined {\n    if (this._defaultChild !== undefined) {\n      return this._defaultChild;\n    }\n\n    const resourceChild = this.tryFindChild('Resource');\n    const defaultChild = this.tryFindChild('Default');\n    if (resourceChild && defaultChild) {\n      throw new Error(`Cannot determine default child for ${this.path}. There is both a child with id \"Resource\" and id \"Default\"`);\n    }\n\n    return defaultChild || resourceChild;\n  }\n\n  /**\n   * Override the defaultChild property.\n   *\n   * This should only be used in the cases where the correct\n   * default child is not named 'Resource' or 'Default' as it\n   * should be.\n   *\n   * If you set this to undefined, the default behavior of finding\n   * the child named 'Resource' or 'Default' will be used.\n   */\n  public set defaultChild(value: IConstruct | undefined) {\n    this._defaultChild = value;\n  }\n\n  /**\n   * All direct children of this construct.\n   */\n  public get children() {\n    return Object.values(this._children ?? {});\n  }\n\n  /**\n   * Return this construct and all of its children in the given order\n   */\n  public findAll(order: ConstructOrder = ConstructOrder.PREORDER): IConstruct[] {\n    const ret = new Array<IConstruct>();\n    visit(this.host);\n    return ret;\n\n    function visit(c: IConstruct) {\n      if (order === ConstructOrder.PREORDER) {\n        ret.push(c);\n      }\n\n      for (const child of c.node.children) {\n        visit(child);\n      }\n\n      if (order === ConstructOrder.POSTORDER) {\n        ret.push(c);\n      }\n    }\n  }\n\n  /**\n   * This can be used to set contextual values.\n   * Context must be set before any children are added, since children may consult context info during construction.\n   * If the key already exists, it will be overridden.\n   * @param key The context key\n   * @param value The context value\n   */\n  public setContext(key: string, value: any) {\n    if (this.children.length > 0) {\n      const names = this.children.map(c => c.node.id);\n      throw new Error('Cannot set context after children have been added: ' + names.join(','));\n    }\n    if (!this._context) {\n      this._context = {};\n    }\n    this._context[key] = value;\n  }\n\n  /**\n   * Retrieves a value from tree context if present. Otherwise, would throw an error.\n   *\n   * Context is usually initialized at the root, but can be overridden at any point in the tree.\n   *\n   * @param key The context key\n   * @returns The context value or throws error if there is no context value for this key\n   */\n  public getContext(key: string): any {\n    const value = this._context?.[key];\n\n    if (value !== undefined) { return value; }\n\n    if (value === undefined && !this.scope?.node) {\n      throw new Error(`No context value present for ${key} key`);\n    }\n\n    return this.scope && this.scope.node.getContext(key);\n  }\n\n  /**\n   * Retrieves the all context of a node from tree context.\n   *\n   * Context is usually initialized at the root, but can be overridden at any point in the tree.\n   *\n   * @param defaults Any keys to override the retrieved context\n   * @returns The context object or an empty object if there is discovered context\n   */\n  public getAllContext(defaults?: object): any {\n    const ret = { ...defaults };\n    for (const scope of this._scopes) {\n      Object.assign(ret, scope.node._context);\n    }\n    return ret;\n  }\n\n  /**\n   * Retrieves a value from tree context.\n   *\n   * Context is usually initialized at the root, but can be overridden at any point in the tree.\n   *\n   * @param key The context key\n   * @returns The context value or `undefined` if there is no context value for this key.\n   */\n  public tryGetContext(key: string): any {\n    const value = this._context?.[key];\n    if (value !== undefined) { return value; }\n\n    return this.scope && this.scope.node.tryGetContext(key);\n  }\n\n  /**\n   * An immutable array of metadata objects associated with this construct.\n   * This can be used, for example, to implement support for deprecation notices, source mapping, etc.\n   */\n  public get metadata() {\n    return [...this._metadata ?? []];\n  }\n\n  /**\n   * Adds a metadata entry to this construct.\n   * Entries are arbitrary values and will also include a stack trace to allow tracing back to\n   * the code location for when the entry was added. It can be used, for example, to include source\n   * mapping in CloudFormation templates to improve diagnostics.\n   * Note that construct metadata is not the same as CloudFormation resource metadata and is never written to the CloudFormation template.\n   * The metadata entries are written to the Cloud Assembly Manifest if the `treeMetadata` property is specified in the props of the App that contains this Construct.\n   *\n   * @param type a string denoting the type of metadata\n   * @param data the value of the metadata (can be a Token). If null/undefined, metadata will not be added.\n   * @param options options\n   */\n  public addMetadata(type: string, data: any, options: MetadataOptions = { }): void {\n    if (data == null) {\n      return;\n    }\n\n    const node = this;\n    function getTrace() {\n      if (options.stackTraceOverride && options.stackTraceOverride.length > 0) {\n        return options.stackTraceOverride;\n      }\n      const shouldTrace = options.stackTrace ?? false;\n      return shouldTrace ? captureStackTrace(options.traceFromFunction ?? node.addMetadata) : undefined;\n    }\n\n    if (!this._metadata) {\n      this._metadata = [];\n    }\n    this._metadata.push({ type, data, trace: getTrace() });\n  }\n\n  /**\n   * Returns the root of the construct tree.\n   * @returns The root of the construct tree.\n   */\n  public get root() {\n    return this._scopes[0];\n  }\n\n  /**\n   * Returns true if this construct or the scopes in which it is defined are\n   * locked.\n   */\n  public get locked() {\n    if (this._locked) {\n      return true;\n    }\n\n    if (this.scope && this.scope.node.locked) {\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Add an ordering dependency on a Dependable (a construct or set of constructs)\n   *\n   * It is up to the target document language to decide what an ordering\n   * relationship means and how it should be rendered; for example, in the AWS\n   * CDK for CloudFormation it means a dependency from every resource in scope\n   * of the current construct to every resource in scope of the target set\n   * of constructs, that get realized as either stack dependencies or\n   * `DependsOn` relationships in the synthesized template.\n   *\n   * `IDependable` is a marker interface that indicates that a class has used\n   * `Dependable.implement()` to implement the `IDependable` interface. It\n   * can be used to make the target object represent more than one set of\n   * constructs at a time. For example, a `DependencyGroup` uses this\n   * interface to represent an explicit list of 0 or more constructs that should\n   * be involved in the dependency relationship.\n   */\n  public addDependency(...deps: IDependable[]) {\n    if (!this._dependencies) {\n      this._dependencies = new Set();\n    }\n    for (const d of deps) {\n      this._dependencies.add(d);\n    }\n  }\n\n  /**\n   * Remove an ordering dependency on a Dependenable (a construct or set of constructs)\n   *\n   * This removes any dependency added using `node.addDependency()`. It must\n   * use the exact same object that was involved in the `addDependency()` call.\n   */\n  public removeDependency(...deps: IDependable[]) {\n    if (!this._dependencies) {\n      this._dependencies = new Set();\n    }\n    for (const d of deps) {\n      this._dependencies.delete(d);\n    }\n  }\n\n  /**\n   * Constructs that this construct depends on directly\n   *\n   * This expands the sets of `Dependables` to the set of `Constructs` that they\n   * represent.\n   */\n  public get dependencies(): IConstruct[] {\n    const result = new Array<IConstruct>();\n    if (this._dependencies) {\n      for (const dep of this._dependencies) {\n        for (const root of Dependable.of(dep).dependencyRoots) {\n          result.push(root);\n        }\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Remove the child with the given name, if present.\n   *\n   * @returns Whether a child with the given name was deleted.\n   */\n  public tryRemoveChild(childName: string): boolean {\n    if (!this._children || !(childName in this._children)) { return false; }\n    delete this._children[childName];\n    return true;\n  }\n\n  /**\n   * Adds a validation to this construct.\n   *\n   * When `node.validate()` is called, the `validate()` method will be called on\n   * all validations and all errors will be returned.\n   *\n   * @param validation The validation object\n   */\n  public addValidation(validation: IValidation) {\n    if (!this._validations) {\n      this._validations = [];\n    }\n    this._validations.push(validation);\n  }\n\n  /**\n   * Validates this construct.\n   *\n   * Invokes the `validate()` method on all validations added through\n   * `addValidation()`.\n   *\n   * @returns an array of validation error messages associated with this\n   * construct.\n   */\n  public validate(): string[] {\n    return (this._validations ?? []).flatMap(v => v.validate());\n  }\n\n  /**\n   * Locks this construct from allowing more children to be added. After this\n   * call, no more children can be added to this construct or to any children.\n   */\n  public lock() {\n    this._locked = true;\n  }\n\n  /**\n   * Applies one or more mixins to this construct.\n   *\n   * Mixins are applied in order. The list of constructs is captured at the\n   * start of the call, so constructs added by a mixin will not be visited.\n   * Use multiple `with()` calls if subsequent mixins should apply to added\n   * constructs.\n   *\n   * @param mixins The mixins to apply\n   * @returns This construct for chaining\n   */\n  public with(...mixins: IMixin[]): IConstruct {\n    const allConstructs = this.findAll();\n    for (const mixin of mixins) {\n      for (const construct of allConstructs) {\n        if (mixin.supports(construct)) {\n          mixin.applyTo(construct);\n        }\n      }\n    }\n    return this.host;\n  };\n\n  /**\n   * Adds a child construct to this node.\n   *\n   * @param child The child construct\n   * @param childName The type name of the child construct.\n   * @returns The resolved path part name of the child\n   */\n  private addChild(child: Construct, childName: string) {\n    if (this.locked) {\n\n      // special error if root is locked\n      if (!this.path) {\n        throw new Error('Cannot add children during synthesis');\n      }\n\n      throw new Error(`Cannot add children to \"${this.path}\" during synthesis`);\n    }\n\n    if (!this._children) {\n      this._children = {};\n    }\n\n    if (this._children[childName]) {\n      const name = this.id ?? '';\n      const typeName = this.host.constructor.name;\n      throw new Error(`There is already a Construct with name '${childName}' in ${typeName}${name.length > 0 ? ' [' + name + ']' : ''}`);\n    }\n\n    this._children[childName] = child;\n  }\n}\n\n/**\n * Represents the building block of the construct graph.\n *\n * All constructs besides the root construct must be created within the scope of\n * another construct.\n */\nexport class Construct implements IConstruct {\n  /**\n   * Checks if `x` is a construct.\n   *\n   * Use this method instead of `instanceof` to properly detect `Construct`\n   * instances, even when the construct library is symlinked.\n   *\n   * Explanation: in JavaScript, multiple copies of the `constructs` library on\n   * disk are seen as independent, completely different libraries. As a\n   * consequence, the class `Construct` in each copy of the `constructs` library\n   * is seen as a different class, and an instance of one class will not test as\n   * `instanceof` the other class. `npm install` will not create installations\n   * like this, but users may manually symlink construct libraries together or\n   * use a monorepo tool: in those cases, multiple copies of the `constructs`\n   * library can be accidentally installed, and `instanceof` will behave\n   * unpredictably. It is safest to avoid using `instanceof`, and using\n   * this type-testing method instead.\n   *\n   * @returns true if `x` is an object created from a class which extends `Construct`.\n   * @param x Any object\n   */\n  public static isConstruct(x: any): x is Construct {\n    return x && typeof x === 'object' && x[CONSTRUCT_SYM];\n  }\n\n  /**\n   * The tree node.\n   */\n  public readonly node: Node;\n\n  /**\n   * Creates a new construct node.\n   *\n   * @param scope The scope in which to define this construct\n   * @param id The scoped construct ID. Must be unique amongst siblings. If\n   * the ID includes a path separator (`/`) or a newline, then it will be\n   * replaced by double dash `--`.\n   */\n  constructor(scope: Construct, id: string) {\n    this.node = new Node(this, scope, id);\n\n    // implement IDependable privately\n    Dependable.implement(this, {\n      dependencyRoots: [this],\n    });\n  }\n\n  /**\n   * Applies one or more mixins to this construct.\n   *\n   * Mixins are applied in order. The list of constructs is captured at the\n   * start of the call, so constructs added by a mixin will not be visited.\n   * Use multiple `with()` calls if subsequent mixins should apply to added\n   * constructs.\n   *\n   * @param mixins The mixins to apply\n   * @returns This construct for chaining\n   */\n  public with(...mixins: IMixin[]): IConstruct {\n    return this.node.with(...mixins);\n  };\n\n  /**\n   * Returns a string representation of this construct.\n   */\n  public toString() {\n    return this.node.path || '<root>';\n  }\n}\n\n/**\n * Implement this interface in order for the construct to be able to validate itself.\n */\nexport interface IValidation {\n  /**\n   * Validate the current construct.\n   *\n   * This method can be implemented by derived constructs in order to perform\n   * validation logic. It is called on all constructs before synthesis.\n   *\n   * @returns An array of validation error messages, or an empty array if there the construct is valid.\n   */\n  validate(): string[];\n}\n\n/**\n * In what order to return constructs\n */\nexport enum ConstructOrder {\n  /**\n   * Depth-first, pre-order\n   */\n  PREORDER,\n\n  /**\n   * Depth-first, post-order (leaf nodes first)\n   */\n  POSTORDER,\n}\n\nconst SEP_REGEX = new RegExp(`[${Node.PATH_SEP}${ADDR_SEP}]`, 'g');\n\n/**\n * Return a sanitized version of an arbitrary string, so it can be used as an ID\n */\nfunction sanitizeId(id: string) {\n  // Escape the separators used by `path` and by `addr` as double dashes, so a\n  // single id never looks like multiple path components in either of them.\n  return id.replace(SEP_REGEX, '--');\n}\n\n/**\n * Options for `construct.addMetadata()`.\n */\nexport interface MetadataOptions {\n  /**\n   * Include stack trace with metadata entry.\n   * @default false\n   */\n  readonly stackTrace?: boolean;\n\n  /**\n   * A JavaScript function to begin tracing from.\n   *\n   * This option is ignored unless `stackTrace` is `true`.\n   *\n   * @default addMetadata()\n   */\n  readonly traceFromFunction?: any;\n\n  /**\n   * The actual stack trace to be added to the metadata. If this\n   * parameter is passed, the stackTrace parameter is ignored.\n   */\n  readonly stackTraceOverride?: string[];\n}\n\n// Mark all instances of 'Construct'\nObject.defineProperty(Construct.prototype, CONSTRUCT_SYM, {\n  value: true,\n  enumerable: false,\n  writable: false,\n});\n\n/**\n * Creates a new root construct node.\n *\n * The root construct represents the top of the construct tree and is not contained within a parent scope itself.\n * For root constructs, the id is optional.\n */\nexport class RootConstruct extends Construct {\n  /**\n   * Creates a new root construct node.\n   *\n   * @param id The scoped construct ID. Must be unique amongst siblings. If\n   * the ID includes a path separator (`/`) or a newline, then it will be\n   * replaced by double dash `--`.\n   */\n  constructor(id?: string) {\n    super(undefined as any, id ?? '');\n  }\n}\n"]}