agent-claw: automated task changes

cdk/node_modules/constructs/lib/construct.d.ts

@@ -0,0 +1,381 @@
+import type { IDependable } from './dependency';
+import type { MetadataEntry } from './metadata';
+import type { IMixin } from './mixin';
+/**
+ * Represents a construct.
+ */
+export interface IConstruct extends IDependable {
+    /**
+     * The tree node.
+     */
+    readonly node: Node;
+    /**
+     * 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.
+     *
+     * @param mixins The mixins to apply
+     * @returns This construct for chaining
+     */
+    with(...mixins: IMixin[]): IConstruct;
+}
+/**
+ * Represents the construct node in the scope tree.
+ */
+export declare class Node {
+    private readonly host;
+    /**
+     * Separator used to delimit construct path components.
+     */
+    static readonly PATH_SEP = "/";
+    /**
+     * Returns the node associated with a construct.
+     * @param construct the construct
+     *
+     * @deprecated use `construct.node` instead
+     */
+    static of(construct: IConstruct): Node;
+    /**
+     * Returns the scope in which this construct is defined.
+     *
+     * The value is `undefined` at the root of the construct scope tree.
+     */
+    readonly scope?: IConstruct;
+    /**
+     * The id of this construct within the current scope.
+     *
+     * This is a scope-unique id. To obtain an app-unique id for this construct, use `addr`.
+     */
+    readonly id: string;
+    private _locked;
+    private _children;
+    private _context;
+    private _metadata;
+    private _dependencies;
+    private _defaultChild;
+    private _validations;
+    private _addr?;
+    constructor(host: Construct, scope: IConstruct, id: string);
+    /**
+     * The full, absolute path of this construct in the tree.
+     *
+     * Components are separated by '/'.
+     */
+    get path(): string;
+    /**
+     * Returns an opaque tree-unique address for this construct.
+     *
+     * Addresses are 42 characters hexadecimal strings. They begin with "c8"
+     * followed by 40 lowercase hexadecimal characters (0-9a-f).
+     *
+     * Addresses are calculated using a SHA-1 of the components of the construct
+     * path.
+     *
+     * To enable refactoring of construct trees, constructs with the ID `Default`
+     * will be excluded from the calculation. In those cases constructs in the
+     * same tree may have the same address.
+     *
+     * @example c83a2846e506bcc5f10682b564084bca2d275709ee
+     */
+    get addr(): string;
+    /**
+     * Return a direct child by id, or undefined
+     *
+     * @param id Identifier of direct child
+     * @returns the child if found, or undefined
+     */
+    tryFindChild(id: string): IConstruct | undefined;
+    /**
+     * 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: string): IConstruct;
+    /**
+     * 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(): IConstruct | undefined;
+    /**
+     * 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: IConstruct | undefined);
+    /**
+     * All direct children of this construct.
+     */
+    get children(): IConstruct[];
+    /**
+     * Return this construct and all of its children in the given order
+     */
+    findAll(order?: ConstructOrder): IConstruct[];
+    /**
+     * 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: string, value: any): void;
+    /**
+     * 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: string): any;
+    /**
+     * 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?: object): any;
+    /**
+     * 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: string): any;
+    /**
+     * 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(): MetadataEntry[];
+    /**
+     * 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: string, data: any, options?: MetadataOptions): void;
+    /**
+     * 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(): IConstruct[];
+    /**
+     * Returns the root of the construct tree.
+     * @returns The root of the construct tree.
+     */
+    get root(): IConstruct;
+    /**
+     * Returns true if this construct or the scopes in which it is defined are
+     * locked.
+     */
+    get locked(): boolean;
+    /**
+     * Add an ordering dependency on another construct.
+     *
+     * An `IDependable`
+     */
+    addDependency(...deps: IDependable[]): void;
+    /**
+     * Return all dependencies registered on this node (non-recursive).
+     */
+    get dependencies(): IConstruct[];
+    /**
+     * Remove the child with the given name, if present.
+     *
+     * @returns Whether a child with the given name was deleted.
+     */
+    tryRemoveChild(childName: string): boolean;
+    /**
+     * 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: IValidation): void;
+    /**
+     * 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(): string[];
+    /**
+     * 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(): void;
+    /**
+     * 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: IMixin[]): IConstruct;
+    /**
+     * 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
+     */
+    private addChild;
+}
+/**
+ * Represents the building block of the construct graph.
+ *
+ * All constructs besides the root construct must be created within the scope of
+ * another construct.
+ */
+export declare class Construct implements IConstruct {
+    /**
+     * 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: any): x is Construct;
+    /**
+     * The tree node.
+     */
+    readonly 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 (`/`), then it will be replaced by double
+     * dash `--`.
+     */
+    constructor(scope: Construct, id: string);
+    /**
+     * 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: IMixin[]): IConstruct;
+    /**
+     * Returns a string representation of this construct.
+     */
+    toString(): string;
+}
+/**
+ * Implement this interface in order for the construct to be able to validate itself.
+ */
+export interface IValidation {
+    /**
+     * Validate the current construct.
+     *
+     * This method can be implemented by derived constructs in order to perform
+     * validation logic. It is called on all constructs before synthesis.
+     *
+     * @returns An array of validation error messages, or an empty array if there the construct is valid.
+     */
+    validate(): string[];
+}
+/**
+ * In what order to return constructs
+ */
+export declare enum ConstructOrder {
+    /**
+     * Depth-first, pre-order
+     */
+    PREORDER = 0,
+    /**
+     * Depth-first, post-order (leaf nodes first)
+     */
+    POSTORDER = 1
+}
+/**
+ * Options for `construct.addMetadata()`.
+ */
+export interface MetadataOptions {
+    /**
+     * Include stack trace with metadata entry.
+     * @default false
+     */
+    readonly stackTrace?: boolean;
+    /**
+     * A JavaScript function to begin tracing from.
+     *
+     * This option is ignored unless `stackTrace` is `true`.
+     *
+     * @default addMetadata()
+     */
+    readonly traceFromFunction?: any;
+    /**
+     * The actual stack trace to be added to the metadata. If this
+     * parameter is passed, the stackTrace parameter is ignored.
+     */
+    readonly stackTraceOverride?: string[];
+}
+/**
+ * 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.
+ */
+export declare class RootConstruct extends Construct {
+    /**
+     * Creates a new root construct node.
+     *
+     * @param id The scoped construct ID. Must be unique amongst siblings. If
+     * the ID includes a path separator (`/`), then it will be replaced by double
+     * dash `--`.
+     */
+    constructor(id?: string);
+}

cdk/node_modules/constructs/lib/dependency.d.ts

@@ -0,0 +1,69 @@
+import type { IConstruct } from './construct';
+/**
+ * Trait marker for classes that can be depended upon
+ *
+ * The presence of this interface indicates that an object has
+ * an `IDependable` implementation.
+ *
+ * This interface can be used to take an (ordering) dependency on a set of
+ * constructs. An ordering dependency implies that the resources represented by
+ * those constructs are deployed before the resources depending ON them are
+ * deployed.
+ */
+export interface IDependable {
+}
+/**
+ * A set of constructs to be used as a dependable
+ *
+ * This class can be used when a set of constructs which are disjoint in the
+ * construct tree needs to be combined to be used as a single dependable.
+ */
+export declare class DependencyGroup implements IDependable {
+    private readonly _deps;
+    constructor(...deps: IDependable[]);
+    /**
+     * Add a construct to the dependency roots
+     */
+    add(...scopes: IDependable[]): void;
+}
+/**
+ * Trait for IDependable
+ *
+ * Traits are interfaces that are privately implemented by objects. Instead of
+ * showing up in the public interface of a class, they need to be queried
+ * explicitly. This is used to implement certain framework features that are
+ * not intended to be used by Construct consumers, and so should be hidden
+ * from accidental use.
+ *
+ * @example
+ *
+ * // Usage
+ * const roots = Dependable.of(construct).dependencyRoots;
+ *
+ * // Definition
+ * Dependable.implement(construct, {
+ *       dependencyRoots: [construct],
+ * });
+ */
+export declare abstract class Dependable {
+    /**
+     * Turn any object into an IDependable.
+     */
+    static implement(instance: IDependable, trait: Dependable): void;
+    /**
+     * Return the matching Dependable for the given class instance.
+     */
+    static of(instance: IDependable): Dependable;
+    /**
+     * Return the matching Dependable for the given class instance.
+     * @deprecated use `of`
+     */
+    static get(instance: IDependable): Dependable;
+    /**
+     * The set of constructs that form the root of this dependable
+     *
+     * All resources under all returned constructs are included in the ordering
+     * dependency.
+     */
+    abstract readonly dependencyRoots: IConstruct[];
+}

cdk/node_modules/constructs/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './construct';
+export type * from './metadata';
+export type * from './mixin';
+export * from './dependency';

cdk/node_modules/constructs/lib/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./construct"), exports);
+__exportStar(require("./dependency"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDhDQUE0QjtBQUc1QiwrQ0FBNkIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbnN0cnVjdCc7XG5leHBvcnQgdHlwZSAqIGZyb20gJy4vbWV0YWRhdGEnO1xuZXhwb3J0IHR5cGUgKiBmcm9tICcuL21peGluJztcbmV4cG9ydCAqIGZyb20gJy4vZGVwZW5kZW5jeSc7XG4iXX0=

cdk/node_modules/constructs/lib/metadata.d.ts

@@ -0,0 +1,21 @@
+/**
+ * An entry in the construct metadata table.
+ */
+export interface MetadataEntry {
+    /**
+     * The metadata entry type.
+     */
+    readonly type: string;
+    /**
+     * The data.
+     */
+    readonly data: any;
+    /**
+     * Stack trace at the point of adding the metadata.
+     *
+     * Only available if `addMetadata()` is called with `stackTrace: true`.
+     *
+     * @default - no trace information
+     */
+    readonly trace?: string[];
+}

cdk/node_modules/constructs/lib/metadata.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWV0YWRhdGEuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvbWV0YWRhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQW4gZW50cnkgaW4gdGhlIGNvbnN0cnVjdCBtZXRhZGF0YSB0YWJsZS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBNZXRhZGF0YUVudHJ5IHtcbiAgLyoqXG4gICAqIFRoZSBtZXRhZGF0YSBlbnRyeSB0eXBlLlxuICAgKi9cbiAgcmVhZG9ubHkgdHlwZTogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBUaGUgZGF0YS5cbiAgICovXG4gIHJlYWRvbmx5IGRhdGE6IGFueTtcblxuICAvKipcbiAgICogU3RhY2sgdHJhY2UgYXQgdGhlIHBvaW50IG9mIGFkZGluZyB0aGUgbWV0YWRhdGEuXG4gICAqXG4gICAqIE9ubHkgYXZhaWxhYmxlIGlmIGBhZGRNZXRhZGF0YSgpYCBpcyBjYWxsZWQgd2l0aCBgc3RhY2tUcmFjZTogdHJ1ZWAuXG4gICAqXG4gICAqIEBkZWZhdWx0IC0gbm8gdHJhY2UgaW5mb3JtYXRpb25cbiAgICovXG4gIHJlYWRvbmx5IHRyYWNlPzogc3RyaW5nW107XG59XG4iXX0=

cdk/node_modules/constructs/lib/mixin.d.ts

@@ -0,0 +1,15 @@
+import type { IConstruct } from './construct';
+/**
+ * A mixin is a reusable piece of functionality that can be applied to constructs
+ * to add behavior, properties, or modify existing functionality without inheritance.
+ */
+export interface IMixin {
+    /**
+     * Determines whether this mixin can be applied to the given construct.
+     */
+    supports(construct: IConstruct): boolean;
+    /**
+     * Applies the mixin functionality to the target construct.
+     */
+    applyTo(construct: IConstruct): void;
+}

cdk/node_modules/constructs/lib/mixin.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWl4aW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvbWl4aW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgSUNvbnN0cnVjdCB9IGZyb20gJy4vY29uc3RydWN0JztcblxuLyoqXG4gKiBBIG1peGluIGlzIGEgcmV1c2FibGUgcGllY2Ugb2YgZnVuY3Rpb25hbGl0eSB0aGF0IGNhbiBiZSBhcHBsaWVkIHRvIGNvbnN0cnVjdHNcbiAqIHRvIGFkZCBiZWhhdmlvciwgcHJvcGVydGllcywgb3IgbW9kaWZ5IGV4aXN0aW5nIGZ1bmN0aW9uYWxpdHkgd2l0aG91dCBpbmhlcml0YW5jZS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBJTWl4aW4ge1xuICAvKipcbiAgICogRGV0ZXJtaW5lcyB3aGV0aGVyIHRoaXMgbWl4aW4gY2FuIGJlIGFwcGxpZWQgdG8gdGhlIGdpdmVuIGNvbnN0cnVjdC5cbiAgICovXG4gIHN1cHBvcnRzKGNvbnN0cnVjdDogSUNvbnN0cnVjdCk6IGJvb2xlYW47XG5cbiAgLyoqXG4gICAqIEFwcGxpZXMgdGhlIG1peGluIGZ1bmN0aW9uYWxpdHkgdG8gdGhlIHRhcmdldCBjb25zdHJ1Y3QuXG4gICAqL1xuICBhcHBseVRvKGNvbnN0cnVjdDogSUNvbnN0cnVjdCk6IHZvaWQ7XG59XG4iXX0=

cdk/node_modules/constructs/lib/private/stack-trace.d.ts

@@ -0,0 +1 @@
+export declare function captureStackTrace(below?: Function): string[];

cdk/node_modules/constructs/lib/private/stack-trace.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureStackTrace = captureStackTrace;
+// tslint:disable-next-line:ban-types
+function captureStackTrace(below) {
+    below = below || captureStackTrace; // hide myself if nothing else
+    const object = { stack: '' };
+    const previousLimit = Error.stackTraceLimit;
+    try {
+        Error.stackTraceLimit = Number.MAX_SAFE_INTEGER;
+        Error.captureStackTrace(object, below);
+    }
+    finally {
+        Error.stackTraceLimit = previousLimit;
+    }
+    if (!object.stack) {
+        return [];
+    }
+    return object.stack.split('\n').slice(1).map(s => s.replace(/^\s*at\s+/, ''));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhY2stdHJhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJpdmF0ZS9zdGFjay10cmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUNBLDhDQWNDO0FBZkQscUNBQXFDO0FBQ3JDLFNBQWdCLGlCQUFpQixDQUFDLEtBQWdCO0lBQ2hELEtBQUssR0FBRyxLQUFLLElBQUksaUJBQWlCLENBQUMsQ0FBQyw4QkFBOEI7SUFDbEUsTUFBTSxNQUFNLEdBQUcsRUFBRSxLQUFLLEVBQUUsRUFBRSxFQUFFLENBQUM7SUFDN0IsTUFBTSxhQUFhLEdBQUcsS0FBSyxDQUFDLGVBQWUsQ0FBQztJQUM1QyxJQUFJLENBQUM7UUFDSCxLQUFLLENBQUMsZUFBZSxHQUFHLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQztRQUNoRCxLQUFLLENBQUMsaUJBQWlCLENBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBQ3pDLENBQUM7WUFBUyxDQUFDO1FBQ1QsS0FBSyxDQUFDLGVBQWUsR0FBRyxhQUFhLENBQUM7SUFDeEMsQ0FBQztJQUNELElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDbEIsT0FBTyxFQUFFLENBQUM7SUFDWixDQUFDO0lBQ0QsT0FBTyxNQUFNLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxXQUFXLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQztBQUNoRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gdHNsaW50OmRpc2FibGUtbmV4dC1saW5lOmJhbi10eXBlc1xuZXhwb3J0IGZ1bmN0aW9uIGNhcHR1cmVTdGFja1RyYWNlKGJlbG93PzogRnVuY3Rpb24pOiBzdHJpbmdbXSB7XG4gIGJlbG93ID0gYmVsb3cgfHwgY2FwdHVyZVN0YWNrVHJhY2U7IC8vIGhpZGUgbXlzZWxmIGlmIG5vdGhpbmcgZWxzZVxuICBjb25zdCBvYmplY3QgPSB7IHN0YWNrOiAnJyB9O1xuICBjb25zdCBwcmV2aW91c0xpbWl0ID0gRXJyb3Iuc3RhY2tUcmFjZUxpbWl0O1xuICB0cnkge1xuICAgIEVycm9yLnN0YWNrVHJhY2VMaW1pdCA9IE51bWJlci5NQVhfU0FGRV9JTlRFR0VSO1xuICAgIEVycm9yLmNhcHR1cmVTdGFja1RyYWNlKG9iamVjdCwgYmVsb3cpO1xuICB9IGZpbmFsbHkge1xuICAgIEVycm9yLnN0YWNrVHJhY2VMaW1pdCA9IHByZXZpb3VzTGltaXQ7XG4gIH1cbiAgaWYgKCFvYmplY3Quc3RhY2spIHtcbiAgICByZXR1cm4gW107XG4gIH1cbiAgcmV0dXJuIG9iamVjdC5zdGFjay5zcGxpdCgnXFxuJykuc2xpY2UoMSkubWFwKHMgPT4gcy5yZXBsYWNlKC9eXFxzKmF0XFxzKy8sICcnKSk7XG59XG4iXX0=

cdk/node_modules/constructs/lib/private/uniqueid.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Calculates the construct uid based on path components.
+ *
+ * Components named `Default` (case sensitive) are excluded from uid calculation
+ * to allow tree refactorings.
+ *
+ * @param components path components
+ */
+export declare function addressOf(components: string[]): string;

cdk/node_modules/constructs/lib/private/uniqueid.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addressOf = addressOf;
+const crypto = require("crypto");
+/**
+ * Resources with this ID are complete hidden from the logical ID calculation.
+ */
+const HIDDEN_ID = 'Default';
+/**
+ * Calculates the construct uid based on path components.
+ *
+ * Components named `Default` (case sensitive) are excluded from uid calculation
+ * to allow tree refactorings.
+ *
+ * @param components path components
+ */
+function addressOf(components) {
+    const hash = crypto.createHash('sha1');
+    for (const c of components) {
+        // skip components called "Default" to enable refactorings
+        if (c === HIDDEN_ID) {
+            continue;
+        }
+        hash.update(c);
+        hash.update('\n');
+    }
+    // prefix with "c8" so to ensure it starts with non-digit.
+    return 'c8' + hash.digest('hex');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5pcXVlaWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJpdmF0ZS91bmlxdWVpZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQWVBLDhCQVlDO0FBM0JELGlDQUFpQztBQUVqQzs7R0FFRztBQUNILE1BQU0sU0FBUyxHQUFHLFNBQVMsQ0FBQztBQUU1Qjs7Ozs7OztHQU9HO0FBQ0gsU0FBZ0IsU0FBUyxDQUFDLFVBQW9CO0lBQzVDLE1BQU0sSUFBSSxHQUFHLE1BQU0sQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDdkMsS0FBSyxNQUFNLENBQUMsSUFBSSxVQUFVLEVBQUUsQ0FBQztRQUMzQiwwREFBMEQ7UUFDMUQsSUFBSSxDQUFDLEtBQUssU0FBUyxFQUFFLENBQUM7WUFBQyxTQUFTO1FBQUMsQ0FBQztRQUVsQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ2YsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNwQixDQUFDO0lBRUQsMERBQTBEO0lBQzFELE9BQU8sSUFBSSxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7QUFDbkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIGNyeXB0byBmcm9tICdjcnlwdG8nO1xuXG4vKipcbiAqIFJlc291cmNlcyB3aXRoIHRoaXMgSUQgYXJlIGNvbXBsZXRlIGhpZGRlbiBmcm9tIHRoZSBsb2dpY2FsIElEIGNhbGN1bGF0aW9uLlxuICovXG5jb25zdCBISURERU5fSUQgPSAnRGVmYXVsdCc7XG5cbi8qKlxuICogQ2FsY3VsYXRlcyB0aGUgY29uc3RydWN0IHVpZCBiYXNlZCBvbiBwYXRoIGNvbXBvbmVudHMuXG4gKlxuICogQ29tcG9uZW50cyBuYW1lZCBgRGVmYXVsdGAgKGNhc2Ugc2Vuc2l0aXZlKSBhcmUgZXhjbHVkZWQgZnJvbSB1aWQgY2FsY3VsYXRpb25cbiAqIHRvIGFsbG93IHRyZWUgcmVmYWN0b3JpbmdzLlxuICpcbiAqIEBwYXJhbSBjb21wb25lbnRzIHBhdGggY29tcG9uZW50c1xuICovXG5leHBvcnQgZnVuY3Rpb24gYWRkcmVzc09mKGNvbXBvbmVudHM6IHN0cmluZ1tdKSB7XG4gIGNvbnN0IGhhc2ggPSBjcnlwdG8uY3JlYXRlSGFzaCgnc2hhMScpO1xuICBmb3IgKGNvbnN0IGMgb2YgY29tcG9uZW50cykge1xuICAgIC8vIHNraXAgY29tcG9uZW50cyBjYWxsZWQgXCJEZWZhdWx0XCIgdG8gZW5hYmxlIHJlZmFjdG9yaW5nc1xuICAgIGlmIChjID09PSBISURERU5fSUQpIHsgY29udGludWU7IH1cblxuICAgIGhhc2gudXBkYXRlKGMpO1xuICAgIGhhc2gudXBkYXRlKCdcXG4nKTtcbiAgfVxuXG4gIC8vIHByZWZpeCB3aXRoIFwiYzhcIiBzbyB0byBlbnN1cmUgaXQgc3RhcnRzIHdpdGggbm9uLWRpZ2l0LlxuICByZXR1cm4gJ2M4JyArIGhhc2guZGlnZXN0KCdoZXgnKTtcbn1cbiJdfQ==