cdk-common 0.0.67 → 2.0.2

package/node_modules/@aws-cdk/cloudformation-diff/lib/format.js

@@ -0,0 +1,414 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSecurityChanges = exports.formatDifferences = void 0;
+const util_1 = require("util");
+const colors = require("colors/safe");
+const diff_template_1 = require("./diff-template");
+const util_2 = require("./diff/util");
+const format_table_1 = require("./format-table");
+// from cx-api
+const PATH_METADATA_KEY = 'aws:cdk:path';
+/* eslint-disable @typescript-eslint/no-require-imports */
+const { structuredPatch } = require('diff');
+/**
+ * Renders template differences to the process' console.
+ *
+ * @param stream           The IO stream where to output the rendered diff.
+ * @param templateDiff     TemplateDiff to be rendered to the console.
+ * @param logicalToPathMap A map from logical ID to construct path. Useful in
+ *                         case there is no aws:cdk:path metadata in the template.
+ * @param context          the number of context lines to use in arbitrary JSON diff (defaults to 3).
+ */
+function formatDifferences(stream, templateDiff, logicalToPathMap = {}, context = 3) {
+    const formatter = new Formatter(stream, logicalToPathMap, templateDiff, context);
+    if (templateDiff.awsTemplateFormatVersion || templateDiff.transform || templateDiff.description) {
+        formatter.printSectionHeader('Template');
+        formatter.formatDifference('AWSTemplateFormatVersion', 'AWSTemplateFormatVersion', templateDiff.awsTemplateFormatVersion);
+        formatter.formatDifference('Transform', 'Transform', templateDiff.transform);
+        formatter.formatDifference('Description', 'Description', templateDiff.description);
+        formatter.printSectionFooter();
+    }
+    formatSecurityChangesWithBanner(formatter, templateDiff);
+    formatter.formatSection('Parameters', 'Parameter', templateDiff.parameters);
+    formatter.formatSection('Metadata', 'Metadata', templateDiff.metadata);
+    formatter.formatSection('Mappings', 'Mapping', templateDiff.mappings);
+    formatter.formatSection('Conditions', 'Condition', templateDiff.conditions);
+    formatter.formatSection('Resources', 'Resource', templateDiff.resources, formatter.formatResourceDifference.bind(formatter));
+    formatter.formatSection('Outputs', 'Output', templateDiff.outputs);
+    formatter.formatSection('Other Changes', 'Unknown', templateDiff.unknown);
+}
+exports.formatDifferences = formatDifferences;
+/**
+ * Renders a diff of security changes to the given stream
+ */
+function formatSecurityChanges(stream, templateDiff, logicalToPathMap = {}, context) {
+    const formatter = new Formatter(stream, logicalToPathMap, templateDiff, context);
+    formatSecurityChangesWithBanner(formatter, templateDiff);
+}
+exports.formatSecurityChanges = formatSecurityChanges;
+function formatSecurityChangesWithBanner(formatter, templateDiff) {
+    if (!templateDiff.iamChanges.hasChanges && !templateDiff.securityGroupChanges.hasChanges) {
+        return;
+    }
+    formatter.formatIamChanges(templateDiff.iamChanges);
+    formatter.formatSecurityGroupChanges(templateDiff.securityGroupChanges);
+    formatter.warning('(NOTE: There may be security-related changes not in this list. See https://github.com/aws/aws-cdk/issues/1299)');
+    formatter.printSectionFooter();
+}
+const ADDITION = colors.green('[+]');
+const CONTEXT = colors.grey('[ ]');
+const UPDATE = colors.yellow('[~]');
+const REMOVAL = colors.red('[-]');
+class Formatter {
+    constructor(stream, logicalToPathMap, diff, context = 3) {
+        this.stream = stream;
+        this.logicalToPathMap = logicalToPathMap;
+        this.context = context;
+        // Read additional construct paths from the diff if it is supplied
+        if (diff) {
+            this.readConstructPathsFrom(diff);
+        }
+    }
+    print(fmt, ...args) {
+        this.stream.write(colors.white(util_1.format(fmt, ...args)) + '\n');
+    }
+    warning(fmt, ...args) {
+        this.stream.write(colors.yellow(util_1.format(fmt, ...args)) + '\n');
+    }
+    formatSection(title, entryType, collection, formatter = this.formatDifference.bind(this)) {
+        if (collection.differenceCount === 0) {
+            return;
+        }
+        this.printSectionHeader(title);
+        collection.forEachDifference((id, diff) => formatter(entryType, id, diff));
+        this.printSectionFooter();
+    }
+    printSectionHeader(title) {
+        this.print(colors.underline(colors.bold(title)));
+    }
+    printSectionFooter() {
+        this.print('');
+    }
+    /**
+     * Print a simple difference for a given named entity.
+     *
+     * @param logicalId the name of the entity that is different.
+     * @param diff the difference to be rendered.
+     */
+    formatDifference(type, logicalId, diff) {
+        if (!diff || !diff.isDifferent) {
+            return;
+        }
+        let value;
+        const oldValue = this.formatValue(diff.oldValue, colors.red);
+        const newValue = this.formatValue(diff.newValue, colors.green);
+        if (diff.isAddition) {
+            value = newValue;
+        }
+        else if (diff.isUpdate) {
+            value = `${oldValue} to ${newValue}`;
+        }
+        else if (diff.isRemoval) {
+            value = oldValue;
+        }
+        this.print(`${this.formatPrefix(diff)} ${colors.cyan(type)} ${this.formatLogicalId(logicalId)}: ${value}`);
+    }
+    /**
+     * Print a resource difference for a given logical ID.
+     *
+     * @param logicalId the logical ID of the resource that changed.
+     * @param diff      the change to be rendered.
+     */
+    formatResourceDifference(_type, logicalId, diff) {
+        if (!diff.isDifferent) {
+            return;
+        }
+        const resourceType = diff.isRemoval ? diff.oldResourceType : diff.newResourceType;
+        // eslint-disable-next-line max-len
+        this.print(`${this.formatPrefix(diff)} ${this.formatValue(resourceType, colors.cyan)} ${this.formatLogicalId(logicalId)} ${this.formatImpact(diff.changeImpact)}`);
+        if (diff.isUpdate) {
+            const differenceCount = diff.differenceCount;
+            let processedCount = 0;
+            diff.forEachDifference((_, name, values) => {
+                processedCount += 1;
+                this.formatTreeDiff(name, values, processedCount === differenceCount);
+            });
+        }
+    }
+    formatPrefix(diff) {
+        if (diff.isAddition) {
+            return ADDITION;
+        }
+        if (diff.isUpdate) {
+            return UPDATE;
+        }
+        if (diff.isRemoval) {
+            return REMOVAL;
+        }
+        return colors.white('[?]');
+    }
+    /**
+     * @param value the value to be formatted.
+     * @param color the color to be used.
+     *
+     * @returns the formatted string, with color applied.
+     */
+    formatValue(value, color) {
+        if (value == null) {
+            return undefined;
+        }
+        if (typeof value === 'string') {
+            return color(value);
+        }
+        return color(JSON.stringify(value));
+    }
+    /**
+     * @param impact the impact to be formatted
+     * @returns a user-friendly, colored string representing the impact.
+     */
+    formatImpact(impact) {
+        switch (impact) {
+            case diff_template_1.ResourceImpact.MAY_REPLACE:
+                return colors.italic(colors.yellow('may be replaced'));
+            case diff_template_1.ResourceImpact.WILL_REPLACE:
+                return colors.italic(colors.bold(colors.red('replace')));
+            case diff_template_1.ResourceImpact.WILL_DESTROY:
+                return colors.italic(colors.bold(colors.red('destroy')));
+            case diff_template_1.ResourceImpact.WILL_ORPHAN:
+                return colors.italic(colors.yellow('orphan'));
+            case diff_template_1.ResourceImpact.WILL_UPDATE:
+            case diff_template_1.ResourceImpact.WILL_CREATE:
+            case diff_template_1.ResourceImpact.NO_CHANGE:
+                return ''; // no extra info is gained here
+        }
+    }
+    /**
+     * Renders a tree of differences under a particular name.
+     * @param name    the name of the root of the tree.
+     * @param diff    the difference on the tree.
+     * @param last    whether this is the last node of a parent tree.
+     */
+    formatTreeDiff(name, diff, last) {
+        let additionalInfo = '';
+        if (diff_template_1.isPropertyDifference(diff)) {
+            if (diff.changeImpact === diff_template_1.ResourceImpact.MAY_REPLACE) {
+                additionalInfo = ' (may cause replacement)';
+            }
+            else if (diff.changeImpact === diff_template_1.ResourceImpact.WILL_REPLACE) {
+                additionalInfo = ' (requires replacement)';
+            }
+        }
+        this.print(' %s─ %s %s%s', last ? '└' : '├', this.changeTag(diff.oldValue, diff.newValue), name, additionalInfo);
+        return this.formatObjectDiff(diff.oldValue, diff.newValue, ` ${last ? ' ' : '│'}`);
+    }
+    /**
+     * Renders the difference between two objects, looking for the differences as deep as possible,
+     * and rendering a tree graph of the path until the difference is found.
+     *
+     * @param oldObject  the old object.
+     * @param newObject  the new object.
+     * @param linePrefix a prefix (indent-like) to be used on every line.
+     */
+    formatObjectDiff(oldObject, newObject, linePrefix) {
+        if ((typeof oldObject !== typeof newObject) || Array.isArray(oldObject) || typeof oldObject === 'string' || typeof oldObject === 'number') {
+            if (oldObject !== undefined && newObject !== undefined) {
+                if (typeof oldObject === 'object' || typeof newObject === 'object') {
+                    const oldStr = JSON.stringify(oldObject, null, 2);
+                    const newStr = JSON.stringify(newObject, null, 2);
+                    const diff = _diffStrings(oldStr, newStr, this.context);
+                    for (let i = 0; i < diff.length; i++) {
+                        this.print('%s   %s %s', linePrefix, i === 0 ? '└─' : '  ', diff[i]);
+                    }
+                }
+                else {
+                    this.print('%s   ├─ %s %s', linePrefix, REMOVAL, this.formatValue(oldObject, colors.red));
+                    this.print('%s   └─ %s %s', linePrefix, ADDITION, this.formatValue(newObject, colors.green));
+                }
+            }
+            else if (oldObject !== undefined /* && newObject === undefined */) {
+                this.print('%s   └─ %s', linePrefix, this.formatValue(oldObject, colors.red));
+            }
+            else /* if (oldObject === undefined && newObject !== undefined) */ {
+                this.print('%s   └─ %s', linePrefix, this.formatValue(newObject, colors.green));
+            }
+            return;
+        }
+        const keySet = new Set(Object.keys(oldObject));
+        Object.keys(newObject).forEach(k => keySet.add(k));
+        const keys = new Array(...keySet).filter(k => !util_2.deepEqual(oldObject[k], newObject[k])).sort();
+        const lastKey = keys[keys.length - 1];
+        for (const key of keys) {
+            const oldValue = oldObject[key];
+            const newValue = newObject[key];
+            const treePrefix = key === lastKey ? '└' : '├';
+            if (oldValue !== undefined && newValue !== undefined) {
+                this.print('%s   %s─ %s %s:', linePrefix, treePrefix, this.changeTag(oldValue, newValue), colors.blue(`.${key}`));
+                this.formatObjectDiff(oldValue, newValue, `${linePrefix}   ${key === lastKey ? ' ' : '│'}`);
+            }
+            else if (oldValue !== undefined /* && newValue === undefined */) {
+                this.print('%s   %s─ %s Removed: %s', linePrefix, treePrefix, REMOVAL, colors.blue(`.${key}`));
+            }
+            else /* if (oldValue === undefined && newValue !== undefined */ {
+                this.print('%s   %s─ %s Added: %s', linePrefix, treePrefix, ADDITION, colors.blue(`.${key}`));
+            }
+        }
+    }
+    /**
+     * @param oldValue the old value of a difference.
+     * @param newValue the new value of a difference.
+     *
+     * @returns a tag to be rendered in the diff, reflecting whether the difference
+     *      was an ADDITION, UPDATE or REMOVAL.
+     */
+    changeTag(oldValue, newValue) {
+        if (oldValue !== undefined && newValue !== undefined) {
+            return UPDATE;
+        }
+        else if (oldValue !== undefined /* && newValue === undefined*/) {
+            return REMOVAL;
+        }
+        else /* if (oldValue === undefined && newValue !== undefined) */ {
+            return ADDITION;
+        }
+    }
+    /**
+     * Find 'aws:cdk:path' metadata in the diff and add it to the logicalToPathMap
+     *
+     * There are multiple sources of logicalID -> path mappings: synth metadata
+     * and resource metadata, and we combine all sources into a single map.
+     */
+    readConstructPathsFrom(templateDiff) {
+        for (const [logicalId, resourceDiff] of Object.entries(templateDiff.resources)) {
+            if (!resourceDiff) {
+                continue;
+            }
+            const oldPathMetadata = resourceDiff.oldValue && resourceDiff.oldValue.Metadata && resourceDiff.oldValue.Metadata[PATH_METADATA_KEY];
+            if (oldPathMetadata && !(logicalId in this.logicalToPathMap)) {
+                this.logicalToPathMap[logicalId] = oldPathMetadata;
+            }
+            const newPathMetadata = resourceDiff.newValue && resourceDiff.newValue.Metadata && resourceDiff.newValue.Metadata[PATH_METADATA_KEY];
+            if (newPathMetadata && !(logicalId in this.logicalToPathMap)) {
+                this.logicalToPathMap[logicalId] = newPathMetadata;
+            }
+        }
+    }
+    formatLogicalId(logicalId) {
+        // if we have a path in the map, return it
+        const normalized = this.normalizedLogicalIdPath(logicalId);
+        if (normalized) {
+            return `${normalized} ${colors.gray(logicalId)}`;
+        }
+        return logicalId;
+    }
+    normalizedLogicalIdPath(logicalId) {
+        // if we have a path in the map, return it
+        const path = this.logicalToPathMap[logicalId];
+        return path ? normalizePath(path) : undefined;
+        /**
+         * Path is supposed to start with "/stack-name". If this is the case (i.e. path has more than
+         * two components, we remove the first part. Otherwise, we just use the full path.
+         * @param p
+         */
+        function normalizePath(p) {
+            if (p.startsWith('/')) {
+                p = p.substr(1);
+            }
+            let parts = p.split('/');
+            if (parts.length > 1) {
+                parts = parts.slice(1);
+                // remove the last component if it's "Resource" or "Default" (if we have more than a single component)
+                if (parts.length > 1) {
+                    const last = parts[parts.length - 1];
+                    if (last === 'Resource' || last === 'Default') {
+                        parts = parts.slice(0, parts.length - 1);
+                    }
+                }
+                p = parts.join('/');
+            }
+            return p;
+        }
+    }
+    formatIamChanges(changes) {
+        if (!changes.hasChanges) {
+            return;
+        }
+        if (changes.statements.hasChanges) {
+            this.printSectionHeader('IAM Statement Changes');
+            this.print(format_table_1.formatTable(this.deepSubstituteBracedLogicalIds(changes.summarizeStatements()), this.stream.columns));
+        }
+        if (changes.managedPolicies.hasChanges) {
+            this.printSectionHeader('IAM Policy Changes');
+            this.print(format_table_1.formatTable(this.deepSubstituteBracedLogicalIds(changes.summarizeManagedPolicies()), this.stream.columns));
+        }
+    }
+    formatSecurityGroupChanges(changes) {
+        if (!changes.hasChanges) {
+            return;
+        }
+        this.printSectionHeader('Security Group Changes');
+        this.print(format_table_1.formatTable(this.deepSubstituteBracedLogicalIds(changes.summarize()), this.stream.columns));
+    }
+    deepSubstituteBracedLogicalIds(rows) {
+        return rows.map(row => row.map(this.substituteBracedLogicalIds.bind(this)));
+    }
+    /**
+     * Substitute all strings like ${LogId.xxx} with the path instead of the logical ID
+     */
+    substituteBracedLogicalIds(source) {
+        return source.replace(/\$\{([^.}]+)(.[^}]+)?\}/ig, (_match, logId, suffix) => {
+            return '${' + (this.normalizedLogicalIdPath(logId) || logId) + (suffix || '') + '}';
+        });
+    }
+}
+/**
+ * Creates a unified diff of two strings.
+ *
+ * @param oldStr  the "old" version of the string.
+ * @param newStr  the "new" version of the string.
+ * @param context the number of context lines to use in arbitrary JSON diff.
+ *
+ * @returns an array of diff lines.
+ */
+function _diffStrings(oldStr, newStr, context) {
+    const patch = structuredPatch(null, null, oldStr, newStr, null, null, { context });
+    const result = new Array();
+    for (const hunk of patch.hunks) {
+        result.push(colors.magenta(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`));
+        const baseIndent = _findIndent(hunk.lines);
+        for (const line of hunk.lines) {
+            // Don't care about termination newline.
+            if (line === '\') {
+                continue;
+            }
+            const marker = line.charAt(0);
+            const text = line.slice(1 + baseIndent);
+            switch (marker) {
+                case ' ':
+                    result.push(`${CONTEXT} ${text}`);
+                    break;
+                case '+':
+                    result.push(colors.bold(`${ADDITION} ${colors.green(text)}`));
+                    break;
+                case '-':
+                    result.push(colors.bold(`${REMOVAL} ${colors.red(text)}`));
+                    break;
+                default:
+                    throw new Error(`Unexpected diff marker: ${marker} (full line: ${line})`);
+            }
+        }
+    }
+    return result;
+    function _findIndent(lines) {
+        let indent = Number.MAX_SAFE_INTEGER;
+        for (const line of lines) {
+            for (let i = 1; i < line.length; i++) {
+                if (line.charAt(i) !== ' ') {
+                    indent = indent > i - 1 ? i - 1 : indent;
+                    break;
+                }
+            }
+        }
+        return indent;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"format.js","sourceRoot":"","sources":["format.ts"],"names":[],"mappings":";;;AAAA,+BAA8B;AAC9B,sCAAsC;AACtC,mDAAuG;AAEvG,sCAAwC;AACxC,iDAA6C;AAI7C,cAAc;AACd,MAAM,iBAAiB,GAAG,cAAc,CAAC;AAEzC,0DAA0D;AAC1D,MAAM,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AAO5C;;;;;;;;GAQG;AACH,SAAgB,iBAAiB,CAC/B,MAAoB,EACpB,YAA0B,EAC1B,mBAAoD,EAAG,EACvD,UAAkB,CAAC;IACnB,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,MAAM,EAAE,gBAAgB,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IAEjF,IAAI,YAAY,CAAC,wBAAwB,IAAI,YAAY,CAAC,SAAS,IAAI,YAAY,CAAC,WAAW,EAAE;QAC/F,SAAS,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC;QACzC,SAAS,CAAC,gBAAgB,CAAC,0BAA0B,EAAE,0BAA0B,EAAE,YAAY,CAAC,wBAAwB,CAAC,CAAC;QAC1H,SAAS,CAAC,gBAAgB,CAAC,WAAW,EAAE,WAAW,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC;QAC7E,SAAS,CAAC,gBAAgB,CAAC,aAAa,EAAE,aAAa,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC;QACnF,SAAS,CAAC,kBAAkB,EAAE,CAAC;KAChC;IAED,+BAA+B,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;IAEzD,SAAS,CAAC,aAAa,CAAC,YAAY,EAAE,WAAW,EAAE,YAAY,CAAC,UAAU,CAAC,CAAC;IAC5E,SAAS,CAAC,aAAa,CAAC,UAAU,EAAE,UAAU,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC;IACvE,SAAS,CAAC,aAAa,CAAC,UAAU,EAAE,SAAS,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC;IACtE,SAAS,CAAC,aAAa,CAAC,YAAY,EAAE,WAAW,EAAE,YAAY,CAAC,UAAU,CAAC,CAAC;IAC5E,SAAS,CAAC,aAAa,CAAC,WAAW,EAAE,UAAU,EAAE,YAAY,CAAC,SAAS,EAAE,SAAS,CAAC,wBAAwB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;IAC7H,SAAS,CAAC,aAAa,CAAC,SAAS,EAAE,QAAQ,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;IACnE,SAAS,CAAC,aAAa,CAAC,eAAe,EAAE,SAAS,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;AAC5E,CAAC;AAxBD,8CAwBC;AAED;;GAEG;AACH,SAAgB,qBAAqB,CACnC,MAA0B,EAC1B,YAA0B,EAC1B,mBAAkD,EAAE,EACpD,OAAgB;IAChB,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,MAAM,EAAE,gBAAgB,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IAEjF,+BAA+B,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;AAC3D,CAAC;AARD,sDAQC;AAED,SAAS,+BAA+B,CAAC,SAAoB,EAAE,YAA0B;IACvF,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,UAAU,IAAI,CAAC,YAAY,CAAC,oBAAoB,CAAC,UAAU,EAAE;QAAE,OAAO;KAAE;IACrG,SAAS,CAAC,gBAAgB,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;IACpD,SAAS,CAAC,0BAA0B,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC;IAExE,SAAS,CAAC,OAAO,CAAC,gHAAgH,CAAC,CAAC;IACpI,SAAS,CAAC,kBAAkB,EAAE,CAAC;AACjC,CAAC;AAED,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AACrC,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACnC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AACpC,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AAElC,MAAM,SAAS;IACb,YACmB,MAAoB,EACpB,gBAAiD,EAClE,IAAmB,EACF,UAAkB,CAAC;QAHnB,WAAM,GAAN,MAAM,CAAc;QACpB,qBAAgB,GAAhB,gBAAgB,CAAiC;QAEjD,YAAO,GAAP,OAAO,CAAY;QACpC,kEAAkE;QAClE,IAAI,IAAI,EAAE;YACR,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;SACnC;IACH,CAAC;IAEM,KAAK,CAAC,GAAW,EAAE,GAAG,IAAW;QACtC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,aAAM,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAC/D,CAAC;IAEM,OAAO,CAAC,GAAW,EAAE,GAAG,IAAW;QACxC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,aAAM,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAChE,CAAC;IAEM,aAAa,CAClB,KAAa,EACb,SAAiB,EACjB,UAAsC,EACtC,YAAyD,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC;QAEzF,IAAI,UAAU,CAAC,eAAe,KAAK,CAAC,EAAE;YACpC,OAAO;SACR;QAED,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAC/B,UAAU,CAAC,iBAAiB,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC,SAAS,CAAC,SAAS,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC;QAC3E,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAEM,kBAAkB,CAAC,KAAa;QACrC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACnD,CAAC;IAEM,kBAAkB;QACvB,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACjB,CAAC;IAED;;;;;OAKG;IACI,gBAAgB,CAAC,IAAY,EAAE,SAAiB,EAAE,IAAiC;QACxF,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YAAE,OAAO;SAAE;QAE3C,IAAI,KAAK,CAAC;QAEV,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;QAC7D,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;QAC/D,IAAI,IAAI,CAAC,UAAU,EAAE;YACnB,KAAK,GAAG,QAAQ,CAAC;SAClB;aAAM,IAAI,IAAI,CAAC,QAAQ,EAAE;YACxB,KAAK,GAAG,GAAG,QAAQ,OAAO,QAAQ,EAAE,CAAC;SACtC;aAAM,IAAI,IAAI,CAAC,SAAS,EAAE;YACzB,KAAK,GAAG,QAAQ,CAAC;SAClB;QAED,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,KAAK,KAAK,EAAE,CAAC,CAAC;IAC7G,CAAC;IAED;;;;;OAKG;IACI,wBAAwB,CAAC,KAAa,EAAE,SAAiB,EAAE,IAAwB;QACxF,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YAAE,OAAO;SAAE;QAElC,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC;QAElF,mCAAmC;QACnC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;QAEnK,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,MAAM,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC;YAC7C,IAAI,cAAc,GAAG,CAAC,CAAC;YACvB,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE;gBACzC,cAAc,IAAI,CAAC,CAAC;gBACpB,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,KAAK,eAAe,CAAC,CAAC;YACxE,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;IAEM,YAAY,CAAI,IAAmB;QACxC,IAAI,IAAI,CAAC,UAAU,EAAE;YAAE,OAAO,QAAQ,CAAC;SAAE;QACzC,IAAI,IAAI,CAAC,QAAQ,EAAE;YAAE,OAAO,MAAM,CAAC;SAAE;QACrC,IAAI,IAAI,CAAC,SAAS,EAAE;YAAE,OAAO,OAAO,CAAC;SAAE;QACvC,OAAO,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;IAED;;;;;OAKG;IACI,WAAW,CAAC,KAAU,EAAE,KAA8B;QAC3D,IAAI,KAAK,IAAI,IAAI,EAAE;YAAE,OAAO,SAAS,CAAC;SAAE;QACxC,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAAE,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC;SAAE;QACvD,OAAO,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;IACtC,CAAC;IAED;;;OAGG;IACI,YAAY,CAAC,MAAsB;QACxC,QAAQ,MAAM,EAAE;YACd,KAAK,8BAAc,CAAC,WAAW;gBAC7B,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC;YACzD,KAAK,8BAAc,CAAC,YAAY;gBAC9B,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAC3D,KAAK,8BAAc,CAAC,YAAY;gBAC9B,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAC3D,KAAK,8BAAc,CAAC,WAAW;gBAC7B,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YAChD,KAAK,8BAAc,CAAC,WAAW,CAAC;YAChC,KAAK,8BAAc,CAAC,WAAW,CAAC;YAChC,KAAK,8BAAc,CAAC,SAAS;gBAC3B,OAAO,EAAE,CAAC,CAAC,+BAA+B;SAC7C;IACH,CAAC;IAED;;;;;OAKG;IACI,cAAc,CAAC,IAAY,EAAE,IAAqB,EAAE,IAAa;QACtE,IAAI,cAAc,GAAG,EAAE,CAAC;QACxB,IAAI,oCAAoB,CAAC,IAAI,CAAC,EAAE;YAC9B,IAAI,IAAI,CAAC,YAAY,KAAK,8BAAc,CAAC,WAAW,EAAE;gBACpD,cAAc,GAAG,0BAA0B,CAAC;aAC7C;iBAAM,IAAI,IAAI,CAAC,YAAY,KAAK,8BAAc,CAAC,YAAY,EAAE;gBAC5D,cAAc,GAAG,yBAAyB,CAAC;aAC5C;SACF;QACD,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC;QACjH,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;IACrF,CAAC;IAED;;;;;;;OAOG;IACI,gBAAgB,CAAC,SAAc,EAAE,SAAc,EAAE,UAAkB;QACxE,IAAI,CAAC,OAAO,SAAS,KAAK,OAAO,SAAS,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE;YACzI,IAAI,SAAS,KAAK,SAAS,IAAI,SAAS,KAAK,SAAS,EAAE;gBACtD,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE;oBAClE,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;oBAClD,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;oBAClD,MAAM,IAAI,GAAG,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;oBACxD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAG,CAAC,GAAG,IAAI,CAAC,MAAM,EAAG,CAAC,EAAE,EAAE;wBACtC,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,UAAU,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;qBACtE;iBACF;qBAAM;oBACL,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;oBAC1F,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;iBAC9F;aACF;iBAAM,IAAI,SAAS,KAAK,SAAS,CAAC,gCAAgC,EAAE;gBACnE,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,UAAU,EAAE,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;aAC/E;iBAAM,6DAA6D,CAAC;gBACnE,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,UAAU,EAAE,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;aACjF;YACD,OAAO;SACR;QACD,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;QAC/C,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACnD,MAAM,IAAI,GAAG,IAAI,KAAK,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,gBAAS,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAC7F,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACtC,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;YACtB,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;YAChC,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;YAChC,MAAM,UAAU,GAAG,GAAG,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;YAC/C,IAAI,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,SAAS,EAAE;gBACpD,IAAI,CAAC,KAAK,CAAC,iBAAiB,EAAE,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC;gBAClH,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,UAAU,MAAM,GAAG,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;aAC7F;iBAAM,IAAI,QAAQ,KAAK,SAAS,CAAC,+BAA+B,EAAE;gBACjE,IAAI,CAAC,KAAK,CAAC,yBAAyB,EAAE,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC;aAChG;iBAAM,0DAA0D,CAAC;gBAChE,IAAI,CAAC,KAAK,CAAC,uBAAuB,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC;aAC/F;SACF;IACH,CAAC;IAED;;;;;;OAMG;IACI,SAAS,CAAC,QAAyB,EAAE,QAAyB;QACnE,IAAI,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,SAAS,EAAE;YACpD,OAAO,MAAM,CAAC;SACf;aAAM,IAAI,QAAQ,KAAK,SAAS,CAAC,8BAA8B,EAAE;YAChE,OAAO,OAAO,CAAC;SAChB;aAAM,2DAA2D,CAAC;YACjE,OAAO,QAAQ,CAAC;SACjB;IACH,CAAC;IAED;;;;;OAKG;IACI,sBAAsB,CAAC,YAA0B;QACtD,KAAK,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,EAAE;YAC9E,IAAI,CAAC,YAAY,EAAE;gBAAE,SAAS;aAAE;YAEhC,MAAM,eAAe,GAAG,YAAY,CAAC,QAAQ,IAAI,YAAY,CAAC,QAAQ,CAAC,QAAQ,IAAI,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC;YACrI,IAAI,eAAe,IAAI,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,gBAAgB,CAAC,EAAE;gBAC5D,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,GAAG,eAAe,CAAC;aACpD;YAED,MAAM,eAAe,GAAG,YAAY,CAAC,QAAQ,IAAI,YAAY,CAAC,QAAQ,CAAC,QAAQ,IAAI,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC;YACrI,IAAI,eAAe,IAAI,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,gBAAgB,CAAC,EAAE;gBAC5D,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,GAAG,eAAe,CAAC;aACpD;SACF;IACH,CAAC;IAEM,eAAe,CAAC,SAAiB;QACtC,0CAA0C;QAC1C,MAAM,UAAU,GAAG,IAAI,CAAC,uBAAuB,CAAC,SAAS,CAAC,CAAC;QAE3D,IAAI,UAAU,EAAE;YACd,OAAO,GAAG,UAAU,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;SAClD;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;IAEM,uBAAuB,CAAC,SAAiB;QAC9C,0CAA0C;QAC1C,MAAM,IAAI,GAAG,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC;QAC9C,OAAO,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAE9C;;;;WAIG;QACH,SAAS,aAAa,CAAC,CAAS;YAC9B,IAAI,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;gBACrB,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;aACjB;YAED,IAAI,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YACzB,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;gBACpB,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBAEvB,sGAAsG;gBACtG,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;oBACpB,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;oBACrC,IAAI,IAAI,KAAK,UAAU,IAAI,IAAI,KAAK,SAAS,EAAE;wBAC7C,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;qBAC1C;iBACF;gBAED,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;aACrB;YACD,OAAO,CAAC,CAAC;QACX,CAAC;IACH,CAAC;IAEM,gBAAgB,CAAC,OAAmB;QACzC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE;YAAE,OAAO;SAAE;QAEpC,IAAI,OAAO,CAAC,UAAU,CAAC,UAAU,EAAE;YACjC,IAAI,CAAC,kBAAkB,CAAC,uBAAuB,CAAC,CAAC;YACjD,IAAI,CAAC,KAAK,CAAC,0BAAW,CAAC,IAAI,CAAC,8BAA8B,CAAC,OAAO,CAAC,mBAAmB,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;SAClH;QAED,IAAI,OAAO,CAAC,eAAe,CAAC,UAAU,EAAE;YACtC,IAAI,CAAC,kBAAkB,CAAC,oBAAoB,CAAC,CAAC;YAC9C,IAAI,CAAC,KAAK,CAAC,0BAAW,CAAC,IAAI,CAAC,8BAA8B,CAAC,OAAO,CAAC,wBAAwB,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;SACvH;IACH,CAAC;IAEM,0BAA0B,CAAC,OAA6B;QAC7D,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE;YAAE,OAAO;SAAE;QAEpC,IAAI,CAAC,kBAAkB,CAAC,wBAAwB,CAAC,CAAC;QAClD,IAAI,CAAC,KAAK,CAAC,0BAAW,CAAC,IAAI,CAAC,8BAA8B,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IACzG,CAAC;IAEM,8BAA8B,CAAC,IAAgB;QACpD,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,0BAA0B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC9E,CAAC;IAED;;OAEG;IACI,0BAA0B,CAAC,MAAc;QAC9C,OAAO,MAAM,CAAC,OAAO,CAAC,2BAA2B,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;YAC3E,OAAO,IAAI,GAAG,CAAC,IAAI,CAAC,uBAAuB,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,MAAM,IAAI,EAAE,CAAC,GAAG,GAAG,CAAC;QACtF,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AAuBD;;;;;;;;GAQG;AACH,SAAS,YAAY,CAAC,MAAc,EAAE,MAAc,EAAE,OAAe;IACnE,MAAM,KAAK,GAAU,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;IAC1F,MAAM,MAAM,GAAG,IAAI,KAAK,EAAU,CAAC;IACnC,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,KAAK,EAAE;QAC9B,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,KAAK,CAAC,CAAC,CAAC;QAC3G,MAAM,UAAU,GAAG,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC3C,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE;YAC7B,wCAAwC;YACxC,IAAI,IAAI,KAAK,8BAA8B,EAAE;gBAAE,SAAS;aAAE;YAC1D,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;YAC9B,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC;YACxC,QAAQ,MAAM,EAAE;gBACd,KAAK,GAAG;oBACN,MAAM,CAAC,IAAI,CAAC,GAAG,OAAO,IAAI,IAAI,EAAE,CAAC,CAAC;oBAClC,MAAM;gBACR,KAAK,GAAG;oBACN,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,QAAQ,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;oBAC9D,MAAM;gBACR,KAAK,GAAG;oBACN,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,OAAO,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;oBAC3D,MAAM;gBACR;oBACE,MAAM,IAAI,KAAK,CAAC,2BAA2B,MAAM,gBAAgB,IAAI,GAAG,CAAC,CAAC;aAC7E;SACF;KACF;IACD,OAAO,MAAM,CAAC;IAEd,SAAS,WAAW,CAAC,KAAe;QAClC,IAAI,MAAM,GAAG,MAAM,CAAC,gBAAgB,CAAC;QACrC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;YACxB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAG,CAAC,GAAG,IAAI,CAAC,MAAM,EAAG,CAAC,EAAE,EAAE;gBACtC,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;oBAC1B,MAAM,GAAG,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;oBACzC,MAAM;iBACP;aACF;SACF;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;AACH,CAAC","sourcesContent":["import { format } from 'util';\nimport * as colors from 'colors/safe';\nimport { Difference, isPropertyDifference, ResourceDifference, ResourceImpact } from './diff-template';\nimport { DifferenceCollection, TemplateDiff } from './diff/types';\nimport { deepEqual } from './diff/util';\nimport { formatTable } from './format-table';\nimport { IamChanges } from './iam/iam-changes';\nimport { SecurityGroupChanges } from './network/security-group-changes';\n\n// from cx-api\nconst PATH_METADATA_KEY = 'aws:cdk:path';\n\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst { structuredPatch } = require('diff');\n/* eslint-enable */\n\nexport interface FormatStream extends NodeJS.WritableStream {\n  columns?: number;\n}\n\n/**\n * Renders template differences to the process' console.\n *\n * @param stream           The IO stream where to output the rendered diff.\n * @param templateDiff     TemplateDiff to be rendered to the console.\n * @param logicalToPathMap A map from logical ID to construct path. Useful in\n *                         case there is no aws:cdk:path metadata in the template.\n * @param context          the number of context lines to use in arbitrary JSON diff (defaults to 3).\n */\nexport function formatDifferences(\n  stream: FormatStream,\n  templateDiff: TemplateDiff,\n  logicalToPathMap: { [logicalId: string]: string } = { },\n  context: number = 3) {\n  const formatter = new Formatter(stream, logicalToPathMap, templateDiff, context);\n\n  if (templateDiff.awsTemplateFormatVersion || templateDiff.transform || templateDiff.description) {\n    formatter.printSectionHeader('Template');\n    formatter.formatDifference('AWSTemplateFormatVersion', 'AWSTemplateFormatVersion', templateDiff.awsTemplateFormatVersion);\n    formatter.formatDifference('Transform', 'Transform', templateDiff.transform);\n    formatter.formatDifference('Description', 'Description', templateDiff.description);\n    formatter.printSectionFooter();\n  }\n\n  formatSecurityChangesWithBanner(formatter, templateDiff);\n\n  formatter.formatSection('Parameters', 'Parameter', templateDiff.parameters);\n  formatter.formatSection('Metadata', 'Metadata', templateDiff.metadata);\n  formatter.formatSection('Mappings', 'Mapping', templateDiff.mappings);\n  formatter.formatSection('Conditions', 'Condition', templateDiff.conditions);\n  formatter.formatSection('Resources', 'Resource', templateDiff.resources, formatter.formatResourceDifference.bind(formatter));\n  formatter.formatSection('Outputs', 'Output', templateDiff.outputs);\n  formatter.formatSection('Other Changes', 'Unknown', templateDiff.unknown);\n}\n\n/**\n * Renders a diff of security changes to the given stream\n */\nexport function formatSecurityChanges(\n  stream: NodeJS.WriteStream,\n  templateDiff: TemplateDiff,\n  logicalToPathMap: {[logicalId: string]: string} = {},\n  context?: number) {\n  const formatter = new Formatter(stream, logicalToPathMap, templateDiff, context);\n\n  formatSecurityChangesWithBanner(formatter, templateDiff);\n}\n\nfunction formatSecurityChangesWithBanner(formatter: Formatter, templateDiff: TemplateDiff) {\n  if (!templateDiff.iamChanges.hasChanges && !templateDiff.securityGroupChanges.hasChanges) { return; }\n  formatter.formatIamChanges(templateDiff.iamChanges);\n  formatter.formatSecurityGroupChanges(templateDiff.securityGroupChanges);\n\n  formatter.warning('(NOTE: There may be security-related changes not in this list. See https://github.com/aws/aws-cdk/issues/1299)');\n  formatter.printSectionFooter();\n}\n\nconst ADDITION = colors.green('[+]');\nconst CONTEXT = colors.grey('[ ]');\nconst UPDATE = colors.yellow('[~]');\nconst REMOVAL = colors.red('[-]');\n\nclass Formatter {\n  constructor(\n    private readonly stream: FormatStream,\n    private readonly logicalToPathMap: { [logicalId: string]: string },\n    diff?: TemplateDiff,\n    private readonly context: number = 3) {\n    // Read additional construct paths from the diff if it is supplied\n    if (diff) {\n      this.readConstructPathsFrom(diff);\n    }\n  }\n\n  public print(fmt: string, ...args: any[]) {\n    this.stream.write(colors.white(format(fmt, ...args)) + '\\n');\n  }\n\n  public warning(fmt: string, ...args: any[]) {\n    this.stream.write(colors.yellow(format(fmt, ...args)) + '\\n');\n  }\n\n  public formatSection<V, T extends Difference<V>>(\n    title: string,\n    entryType: string,\n    collection: DifferenceCollection<V, T>,\n    formatter: (type: string, id: string, diff: T) => void = this.formatDifference.bind(this)) {\n\n    if (collection.differenceCount === 0) {\n      return;\n    }\n\n    this.printSectionHeader(title);\n    collection.forEachDifference((id, diff) => formatter(entryType, id, diff));\n    this.printSectionFooter();\n  }\n\n  public printSectionHeader(title: string) {\n    this.print(colors.underline(colors.bold(title)));\n  }\n\n  public printSectionFooter() {\n    this.print('');\n  }\n\n  /**\n   * Print a simple difference for a given named entity.\n   *\n   * @param logicalId the name of the entity that is different.\n   * @param diff the difference to be rendered.\n   */\n  public formatDifference(type: string, logicalId: string, diff: Difference<any> | undefined) {\n    if (!diff || !diff.isDifferent) { return; }\n\n    let value;\n\n    const oldValue = this.formatValue(diff.oldValue, colors.red);\n    const newValue = this.formatValue(diff.newValue, colors.green);\n    if (diff.isAddition) {\n      value = newValue;\n    } else if (diff.isUpdate) {\n      value = `${oldValue} to ${newValue}`;\n    } else if (diff.isRemoval) {\n      value = oldValue;\n    }\n\n    this.print(`${this.formatPrefix(diff)} ${colors.cyan(type)} ${this.formatLogicalId(logicalId)}: ${value}`);\n  }\n\n  /**\n   * Print a resource difference for a given logical ID.\n   *\n   * @param logicalId the logical ID of the resource that changed.\n   * @param diff      the change to be rendered.\n   */\n  public formatResourceDifference(_type: string, logicalId: string, diff: ResourceDifference) {\n    if (!diff.isDifferent) { return; }\n\n    const resourceType = diff.isRemoval ? diff.oldResourceType : diff.newResourceType;\n\n    // eslint-disable-next-line max-len\n    this.print(`${this.formatPrefix(diff)} ${this.formatValue(resourceType, colors.cyan)} ${this.formatLogicalId(logicalId)} ${this.formatImpact(diff.changeImpact)}`);\n\n    if (diff.isUpdate) {\n      const differenceCount = diff.differenceCount;\n      let processedCount = 0;\n      diff.forEachDifference((_, name, values) => {\n        processedCount += 1;\n        this.formatTreeDiff(name, values, processedCount === differenceCount);\n      });\n    }\n  }\n\n  public formatPrefix<T>(diff: Difference<T>) {\n    if (diff.isAddition) { return ADDITION; }\n    if (diff.isUpdate) { return UPDATE; }\n    if (diff.isRemoval) { return REMOVAL; }\n    return colors.white('[?]');\n  }\n\n  /**\n   * @param value the value to be formatted.\n   * @param color the color to be used.\n   *\n   * @returns the formatted string, with color applied.\n   */\n  public formatValue(value: any, color: (str: string) => string) {\n    if (value == null) { return undefined; }\n    if (typeof value === 'string') { return color(value); }\n    return color(JSON.stringify(value));\n  }\n\n  /**\n   * @param impact the impact to be formatted\n   * @returns a user-friendly, colored string representing the impact.\n   */\n  public formatImpact(impact: ResourceImpact) {\n    switch (impact) {\n      case ResourceImpact.MAY_REPLACE:\n        return colors.italic(colors.yellow('may be replaced'));\n      case ResourceImpact.WILL_REPLACE:\n        return colors.italic(colors.bold(colors.red('replace')));\n      case ResourceImpact.WILL_DESTROY:\n        return colors.italic(colors.bold(colors.red('destroy')));\n      case ResourceImpact.WILL_ORPHAN:\n        return colors.italic(colors.yellow('orphan'));\n      case ResourceImpact.WILL_UPDATE:\n      case ResourceImpact.WILL_CREATE:\n      case ResourceImpact.NO_CHANGE:\n        return ''; // no extra info is gained here\n    }\n  }\n\n  /**\n   * Renders a tree of differences under a particular name.\n   * @param name    the name of the root of the tree.\n   * @param diff    the difference on the tree.\n   * @param last    whether this is the last node of a parent tree.\n   */\n  public formatTreeDiff(name: string, diff: Difference<any>, last: boolean) {\n    let additionalInfo = '';\n    if (isPropertyDifference(diff)) {\n      if (diff.changeImpact === ResourceImpact.MAY_REPLACE) {\n        additionalInfo = ' (may cause replacement)';\n      } else if (diff.changeImpact === ResourceImpact.WILL_REPLACE) {\n        additionalInfo = ' (requires replacement)';\n      }\n    }\n    this.print(' %s─ %s %s%s', last ? '└' : '├', this.changeTag(diff.oldValue, diff.newValue), name, additionalInfo);\n    return this.formatObjectDiff(diff.oldValue, diff.newValue, ` ${last ? ' ' : '│'}`);\n  }\n\n  /**\n   * Renders the difference between two objects, looking for the differences as deep as possible,\n   * and rendering a tree graph of the path until the difference is found.\n   *\n   * @param oldObject  the old object.\n   * @param newObject  the new object.\n   * @param linePrefix a prefix (indent-like) to be used on every line.\n   */\n  public formatObjectDiff(oldObject: any, newObject: any, linePrefix: string) {\n    if ((typeof oldObject !== typeof newObject) || Array.isArray(oldObject) || typeof oldObject === 'string' || typeof oldObject === 'number') {\n      if (oldObject !== undefined && newObject !== undefined) {\n        if (typeof oldObject === 'object' || typeof newObject === 'object') {\n          const oldStr = JSON.stringify(oldObject, null, 2);\n          const newStr = JSON.stringify(newObject, null, 2);\n          const diff = _diffStrings(oldStr, newStr, this.context);\n          for (let i = 0 ; i < diff.length ; i++) {\n            this.print('%s   %s %s', linePrefix, i === 0 ? '└─' : '  ', diff[i]);\n          }\n        } else {\n          this.print('%s   ├─ %s %s', linePrefix, REMOVAL, this.formatValue(oldObject, colors.red));\n          this.print('%s   └─ %s %s', linePrefix, ADDITION, this.formatValue(newObject, colors.green));\n        }\n      } else if (oldObject !== undefined /* && newObject === undefined */) {\n        this.print('%s   └─ %s', linePrefix, this.formatValue(oldObject, colors.red));\n      } else /* if (oldObject === undefined && newObject !== undefined) */ {\n        this.print('%s   └─ %s', linePrefix, this.formatValue(newObject, colors.green));\n      }\n      return;\n    }\n    const keySet = new Set(Object.keys(oldObject));\n    Object.keys(newObject).forEach(k => keySet.add(k));\n    const keys = new Array(...keySet).filter(k => !deepEqual(oldObject[k], newObject[k])).sort();\n    const lastKey = keys[keys.length - 1];\n    for (const key of keys) {\n      const oldValue = oldObject[key];\n      const newValue = newObject[key];\n      const treePrefix = key === lastKey ? '└' : '├';\n      if (oldValue !== undefined && newValue !== undefined) {\n        this.print('%s   %s─ %s %s:', linePrefix, treePrefix, this.changeTag(oldValue, newValue), colors.blue(`.${key}`));\n        this.formatObjectDiff(oldValue, newValue, `${linePrefix}   ${key === lastKey ? ' ' : '│'}`);\n      } else if (oldValue !== undefined /* && newValue === undefined */) {\n        this.print('%s   %s─ %s Removed: %s', linePrefix, treePrefix, REMOVAL, colors.blue(`.${key}`));\n      } else /* if (oldValue === undefined && newValue !== undefined */ {\n        this.print('%s   %s─ %s Added: %s', linePrefix, treePrefix, ADDITION, colors.blue(`.${key}`));\n      }\n    }\n  }\n\n  /**\n   * @param oldValue the old value of a difference.\n   * @param newValue the new value of a difference.\n   *\n   * @returns a tag to be rendered in the diff, reflecting whether the difference\n   *      was an ADDITION, UPDATE or REMOVAL.\n   */\n  public changeTag(oldValue: any | undefined, newValue: any | undefined): string {\n    if (oldValue !== undefined && newValue !== undefined) {\n      return UPDATE;\n    } else if (oldValue !== undefined /* && newValue === undefined*/) {\n      return REMOVAL;\n    } else /* if (oldValue === undefined && newValue !== undefined) */ {\n      return ADDITION;\n    }\n  }\n\n  /**\n   * Find 'aws:cdk:path' metadata in the diff and add it to the logicalToPathMap\n   *\n   * There are multiple sources of logicalID -> path mappings: synth metadata\n   * and resource metadata, and we combine all sources into a single map.\n   */\n  public readConstructPathsFrom(templateDiff: TemplateDiff) {\n    for (const [logicalId, resourceDiff] of Object.entries(templateDiff.resources)) {\n      if (!resourceDiff) { continue; }\n\n      const oldPathMetadata = resourceDiff.oldValue && resourceDiff.oldValue.Metadata && resourceDiff.oldValue.Metadata[PATH_METADATA_KEY];\n      if (oldPathMetadata && !(logicalId in this.logicalToPathMap)) {\n        this.logicalToPathMap[logicalId] = oldPathMetadata;\n      }\n\n      const newPathMetadata = resourceDiff.newValue && resourceDiff.newValue.Metadata && resourceDiff.newValue.Metadata[PATH_METADATA_KEY];\n      if (newPathMetadata && !(logicalId in this.logicalToPathMap)) {\n        this.logicalToPathMap[logicalId] = newPathMetadata;\n      }\n    }\n  }\n\n  public formatLogicalId(logicalId: string) {\n    // if we have a path in the map, return it\n    const normalized = this.normalizedLogicalIdPath(logicalId);\n\n    if (normalized) {\n      return `${normalized} ${colors.gray(logicalId)}`;\n    }\n\n    return logicalId;\n  }\n\n  public normalizedLogicalIdPath(logicalId: string): string | undefined {\n    // if we have a path in the map, return it\n    const path = this.logicalToPathMap[logicalId];\n    return path ? normalizePath(path) : undefined;\n\n    /**\n     * Path is supposed to start with \"/stack-name\". If this is the case (i.e. path has more than\n     * two components, we remove the first part. Otherwise, we just use the full path.\n     * @param p\n     */\n    function normalizePath(p: string) {\n      if (p.startsWith('/')) {\n        p = p.substr(1);\n      }\n\n      let parts = p.split('/');\n      if (parts.length > 1) {\n        parts = parts.slice(1);\n\n        // remove the last component if it's \"Resource\" or \"Default\" (if we have more than a single component)\n        if (parts.length > 1) {\n          const last = parts[parts.length - 1];\n          if (last === 'Resource' || last === 'Default') {\n            parts = parts.slice(0, parts.length - 1);\n          }\n        }\n\n        p = parts.join('/');\n      }\n      return p;\n    }\n  }\n\n  public formatIamChanges(changes: IamChanges) {\n    if (!changes.hasChanges) { return; }\n\n    if (changes.statements.hasChanges) {\n      this.printSectionHeader('IAM Statement Changes');\n      this.print(formatTable(this.deepSubstituteBracedLogicalIds(changes.summarizeStatements()), this.stream.columns));\n    }\n\n    if (changes.managedPolicies.hasChanges) {\n      this.printSectionHeader('IAM Policy Changes');\n      this.print(formatTable(this.deepSubstituteBracedLogicalIds(changes.summarizeManagedPolicies()), this.stream.columns));\n    }\n  }\n\n  public formatSecurityGroupChanges(changes: SecurityGroupChanges) {\n    if (!changes.hasChanges) { return; }\n\n    this.printSectionHeader('Security Group Changes');\n    this.print(formatTable(this.deepSubstituteBracedLogicalIds(changes.summarize()), this.stream.columns));\n  }\n\n  public deepSubstituteBracedLogicalIds(rows: string[][]): string[][] {\n    return rows.map(row => row.map(this.substituteBracedLogicalIds.bind(this)));\n  }\n\n  /**\n   * Substitute all strings like ${LogId.xxx} with the path instead of the logical ID\n   */\n  public substituteBracedLogicalIds(source: string): string {\n    return source.replace(/\\$\\{([^.}]+)(.[^}]+)?\\}/ig, (_match, logId, suffix) => {\n      return '${' + (this.normalizedLogicalIdPath(logId) || logId) + (suffix || '') + '}';\n    });\n  }\n}\n\n/**\n * A patch as returned by ``diff.structuredPatch``.\n */\ninterface Patch {\n  /**\n   * Hunks in the patch.\n   */\n  hunks: ReadonlyArray<PatchHunk>;\n}\n\n/**\n * A hunk in a patch produced by ``diff.structuredPatch``.\n */\ninterface PatchHunk {\n  oldStart: number;\n  oldLines: number;\n  newStart: number;\n  newLines: number;\n  lines: string[];\n}\n\n/**\n * Creates a unified diff of two strings.\n *\n * @param oldStr  the \"old\" version of the string.\n * @param newStr  the \"new\" version of the string.\n * @param context the number of context lines to use in arbitrary JSON diff.\n *\n * @returns an array of diff lines.\n */\nfunction _diffStrings(oldStr: string, newStr: string, context: number): string[] {\n  const patch: Patch = structuredPatch(null, null, oldStr, newStr, null, null, { context });\n  const result = new Array<string>();\n  for (const hunk of patch.hunks) {\n    result.push(colors.magenta(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`));\n    const baseIndent = _findIndent(hunk.lines);\n    for (const line of hunk.lines) {\n      // Don't care about termination newline.\n      if (line === '\\\\ No newline at end of file') { continue; }\n      const marker = line.charAt(0);\n      const text = line.slice(1 + baseIndent);\n      switch (marker) {\n        case ' ':\n          result.push(`${CONTEXT} ${text}`);\n          break;\n        case '+':\n          result.push(colors.bold(`${ADDITION} ${colors.green(text)}`));\n          break;\n        case '-':\n          result.push(colors.bold(`${REMOVAL} ${colors.red(text)}`));\n          break;\n        default:\n          throw new Error(`Unexpected diff marker: ${marker} (full line: ${line})`);\n      }\n    }\n  }\n  return result;\n\n  function _findIndent(lines: string[]): number {\n    let indent = Number.MAX_SAFE_INTEGER;\n    for (const line of lines) {\n      for (let i = 1 ; i < line.length ; i++) {\n        if (line.charAt(i) !== ' ') {\n          indent = indent > i - 1 ? i - 1 : indent;\n          break;\n        }\n      }\n    }\n    return indent;\n  }\n}\n"]}

package/node_modules/@aws-cdk/cloudformation-diff/lib/iam/iam-changes.d.ts

@@ -0,0 +1,62 @@
+import * as cfnspec from '@aws-cdk/cfnspec';
+import { PropertyChange, ResourceChange } from '../diff/types';
+import { DiffableCollection } from '../diffable';
+import { ManagedPolicyAttachment, ManagedPolicyJson } from './managed-policy';
+import { Statement, StatementJson } from './statement';
+export interface IamChangesProps {
+    propertyChanges: PropertyChange[];
+    resourceChanges: ResourceChange[];
+}
+/**
+ * Changes to IAM statements
+ */
+export declare class IamChanges {
+    static IamPropertyScrutinies: cfnspec.schema.PropertyScrutinyType[];
+    static IamResourceScrutinies: cfnspec.schema.ResourceScrutinyType[];
+    readonly statements: DiffableCollection<Statement>;
+    readonly managedPolicies: DiffableCollection<ManagedPolicyAttachment>;
+    constructor(props: IamChangesProps);
+    get hasChanges(): boolean;
+    /**
+     * Return whether the changes include broadened permissions
+     *
+     * Permissions are broadened if positive statements are added or
+     * negative statements are removed, or if managed policies are added.
+     */
+    get permissionsBroadened(): boolean;
+    /**
+     * Return a summary table of changes
+     */
+    summarizeStatements(): string[][];
+    summarizeManagedPolicies(): string[][];
+    /**
+     * Return a machine-readable version of the changes.
+     * This is only used in tests.
+     *
+     * @internal
+     */
+    _toJson(): IamChangesJson;
+    private readPropertyChange;
+    private readResourceChange;
+    /**
+     * Parse a list of policies on an identity
+     */
+    private readIdentityPolicies;
+    /**
+     * Parse an IAM::Policy resource
+     */
+    private readIdentityPolicyResource;
+    private readResourceStatements;
+    /**
+     * Parse an AWS::*::{Bucket,Topic,Queue}policy
+     */
+    private readResourcePolicyResource;
+    private readManagedPolicies;
+    private readLambdaStatements;
+}
+export interface IamChangesJson {
+    statementAdditions?: StatementJson[];
+    statementRemovals?: StatementJson[];
+    managedPolicyAdditions?: ManagedPolicyJson[];
+    managedPolicyRemovals?: ManagedPolicyJson[];
+}