cdk-ecr-deployment 3.2.2 → 3.3.1

package/node_modules/cacheable-lookup/index.d.ts

@@ -1,139 +0,0 @@
-import {Resolver, promises as dnsPromises, lookup} from 'dns';
-import {Agent} from 'http';
-
-type AsyncResolver = dnsPromises.Resolver;
-
-export type IPFamily = 4 | 6;
-
-type TPromise<T> = T | Promise<T>;
-
-export interface CacheInstance {
-	set(hostname: string, entries: EntryObject[], ttl: number): TPromise<void | boolean | this>;
-	get(hostname: string): TPromise<EntryObject[] | undefined>;
-	delete(hostname: string): TPromise<boolean>;
-	clear(): TPromise<void>;
-}
-
-export interface Options {
-	/**
-	 * Custom cache instance. If `undefined`, it will create a new one.
-	 * @default undefined
-	 */
-	cache?: CacheInstance;
-	/**
-	 * Limits the cache time (TTL). If set to `0`, it will make a new DNS query each time.
-	 * @default Infinity
-	 */
-	maxTtl?: number;
-	/**
-	 * DNS Resolver used to make DNS queries.
-	 * @default new dns.promises.Resolver()
-	 */
-	resolver?: Resolver | AsyncResolver;
-	/**
-	 * When the DNS server responds with `ENOTFOUND` or `ENODATA` and the OS reports that the entry is available,
-	 * it will use `dns.lookup(...)` directly for the requested hostnames for the specified amount of time (in seconds).
-	 *
-	 * If you don't query internal hostnames (such as `localhost`, `database.local` etc.),
-	 * it is strongly recommended to set this value to `0`.
-	 * @default 3600
-	 */
-	fallbackDuration?: number;
-	/**
-	 * The time how long it needs to remember failed queries (TTL in seconds).
-	 *
-	 * **Note**: This option is independent, `options.maxTtl` does not affect this.
-	 * @default 0.15
-	 */
-	errorTtl?: number;
-	/**
-	 * The fallback function to use when the DNS server responds with `ENOTFOUND` or `ENODATA`.
-	 *
-	 * **Note**: This has no effect if the `fallbackDuration` option is less than `1`.
-	 * @default dns.lookup
-	 */
-	lookup?: typeof lookup;
-}
-
-export interface EntryObject {
-	/**
-	 * The IP address (can be an IPv4 or IPv5 address).
-	 */
-	readonly address: string;
-	/**
-	 * The IP family.
-	 */
-	readonly family: IPFamily;
-	/**
-	 * The original TTL.
-	 */
-	readonly ttl?: number;
-	/**
-	 * The expiration timestamp.
-	 */
-	readonly expires?: number;
-}
-
-export interface LookupOptions {
-	/**
-	 * One or more supported getaddrinfo flags. Multiple flags may be passed by bitwise ORing their values.
-	 */
-	hints?: number;
-	/**
-	 * The record family. Must be `4` or `6`. IPv4 and IPv6 addresses are both returned by default.
-	 */
-	family?: IPFamily;
-	/**
-	 * When `true`, the callback returns all resolved addresses in an array. Otherwise, returns a single address.
-	 * @default false
-	 */
-	all?: boolean;
-}
-
-export default class CacheableLookup {
-	constructor(options?: Options);
-	/**
-	 * The DNS servers used to make queries. Can be overridden - doing so will clear the cache.
-	 */
-	servers: string[];
-	/**
-	 * @see https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback
-	 */
-	lookup(hostname: string, family: IPFamily, callback: (error: NodeJS.ErrnoException, address: string, family: IPFamily) => void): void;
-	lookup(hostname: string, callback: (error: NodeJS.ErrnoException, address: string, family: IPFamily) => void): void;
-	lookup(hostname: string, options: LookupOptions & {all: true}, callback: (error: NodeJS.ErrnoException, result: ReadonlyArray<EntryObject>) => void): void;
-	lookup(hostname: string, options: LookupOptions, callback: (error: NodeJS.ErrnoException, address: string, family: IPFamily) => void): void;
-	/**
-	 * The asynchronous version of `dns.lookup(…)`.
-	 */
-	lookupAsync(hostname: string, options: LookupOptions & {all: true}): Promise<ReadonlyArray<EntryObject>>;
-	lookupAsync(hostname: string, options: LookupOptions): Promise<EntryObject>;
-	lookupAsync(hostname: string): Promise<EntryObject>;
-	lookupAsync(hostname: string, family: IPFamily): Promise<EntryObject>;
-	/**
-	 * An asynchronous function which returns cached DNS lookup entries. This is the base for `lookupAsync(hostname, options)` and `lookup(hostname, options, callback)`.
-	 */
-	query(hostname: string): Promise<ReadonlyArray<EntryObject>>;
-	/**
-	 * An asynchronous function which makes a new DNS lookup query and updates the database. This is used by `query(hostname, family)` if no entry in the database is present. Returns an array of objects with `address`, `family`, `ttl` and `expires` properties.
-	 */
-	queryAndCache(hostname: string): Promise<ReadonlyArray<EntryObject>>;
-	/**
-	 * Attaches itself to an Agent instance.
-	 */
-	install(agent: Agent): void;
-	/**
-	 * Removes itself from an Agent instance.
-	 */
-	uninstall(agent: Agent): void;
-	/**
-	 * Updates interface info. For example, you need to run this when you plug or unplug your WiFi driver.
-	 *
-	 * **Note:** Running `updateInterfaceInfo()` will trigger `clear()` only on network interface removal.
-	 */
-	updateInterfaceInfo(): void;
-	/**
-	 * Clears the cache for the given hostname. If the hostname argument is not present, the entire cache will be emptied.
-	 */
-	clear(hostname?: string): void;
-}

package/node_modules/cacheable-lookup/package.json

@@ -1,45 +0,0 @@
-{
-  "name": "cacheable-lookup",
-  "version": "5.0.4",
-  "description": "A cacheable dns.lookup(…) that respects the TTL",
-  "engines": {
-    "node": ">=10.6.0"
-  },
-  "files": [
-    "source",
-    "index.d.ts"
-  ],
-  "main": "source/index.js",
-  "types": "index.d.ts",
-  "scripts": {
-    "test": "xo && nyc --reporter=lcovonly --reporter=text ava && tsd"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/szmarczak/cacheable-lookup.git"
-  },
-  "keywords": [
-    "dns",
-    "lookup",
-    "cacheable",
-    "ttl"
-  ],
-  "author": "Szymon Marczak",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/szmarczak/cacheable-lookup/issues"
-  },
-  "homepage": "https://github.com/szmarczak/cacheable-lookup#readme",
-  "devDependencies": {
-    "@types/keyv": "^3.1.1",
-    "ava": "^3.8.2",
-    "benchmark": "^2.1.4",
-    "coveralls": "^3.0.9",
-    "keyv": "^4.0.0",
-    "nyc": "^15.0.0",
-    "proxyquire": "^2.1.3",
-    "tsd": "^0.11.0",
-    "quick-lru": "^5.1.0",
-    "xo": "^0.25.3"
-  }
-}

package/node_modules/cacheable-lookup/source/index.js

@@ -1,436 +0,0 @@
-'use strict';
-const {
-	V4MAPPED,
-	ADDRCONFIG,
-	ALL,
-	promises: {
-		Resolver: AsyncResolver
-	},
-	lookup: dnsLookup
-} = require('dns');
-const {promisify} = require('util');
-const os = require('os');
-
-const kCacheableLookupCreateConnection = Symbol('cacheableLookupCreateConnection');
-const kCacheableLookupInstance = Symbol('cacheableLookupInstance');
-const kExpires = Symbol('expires');
-
-const supportsALL = typeof ALL === 'number';
-
-const verifyAgent = agent => {
-	if (!(agent && typeof agent.createConnection === 'function')) {
-		throw new Error('Expected an Agent instance as the first argument');
-	}
-};
-
-const map4to6 = entries => {
-	for (const entry of entries) {
-		if (entry.family === 6) {
-			continue;
-		}
-
-		entry.address = `::ffff:${entry.address}`;
-		entry.family = 6;
-	}
-};
-
-const getIfaceInfo = () => {
-	let has4 = false;
-	let has6 = false;
-
-	for (const device of Object.values(os.networkInterfaces())) {
-		for (const iface of device) {
-			if (iface.internal) {
-				continue;
-			}
-
-			if (iface.family === 'IPv6') {
-				has6 = true;
-			} else {
-				has4 = true;
-			}
-
-			if (has4 && has6) {
-				return {has4, has6};
-			}
-		}
-	}
-
-	return {has4, has6};
-};
-
-const isIterable = map => {
-	return Symbol.iterator in map;
-};
-
-const ttl = {ttl: true};
-const all = {all: true};
-
-class CacheableLookup {
-	constructor({
-		cache = new Map(),
-		maxTtl = Infinity,
-		fallbackDuration = 3600,
-		errorTtl = 0.15,
-		resolver = new AsyncResolver(),
-		lookup = dnsLookup
-	} = {}) {
-		this.maxTtl = maxTtl;
-		this.errorTtl = errorTtl;
-
-		this._cache = cache;
-		this._resolver = resolver;
-		this._dnsLookup = promisify(lookup);
-
-		if (this._resolver instanceof AsyncResolver) {
-			this._resolve4 = this._resolver.resolve4.bind(this._resolver);
-			this._resolve6 = this._resolver.resolve6.bind(this._resolver);
-		} else {
-			this._resolve4 = promisify(this._resolver.resolve4.bind(this._resolver));
-			this._resolve6 = promisify(this._resolver.resolve6.bind(this._resolver));
-		}
-
-		this._iface = getIfaceInfo();
-
-		this._pending = {};
-		this._nextRemovalTime = false;
-		this._hostnamesToFallback = new Set();
-
-		if (fallbackDuration < 1) {
-			this._fallback = false;
-		} else {
-			this._fallback = true;
-
-			const interval = setInterval(() => {
-				this._hostnamesToFallback.clear();
-			}, fallbackDuration * 1000);
-
-			/* istanbul ignore next: There is no `interval.unref()` when running inside an Electron renderer */
-			if (interval.unref) {
-				interval.unref();
-			}
-		}
-
-		this.lookup = this.lookup.bind(this);
-		this.lookupAsync = this.lookupAsync.bind(this);
-	}
-
-	set servers(servers) {
-		this.clear();
-
-		this._resolver.setServers(servers);
-	}
-
-	get servers() {
-		return this._resolver.getServers();
-	}
-
-	lookup(hostname, options, callback) {
-		if (typeof options === 'function') {
-			callback = options;
-			options = {};
-		} else if (typeof options === 'number') {
-			options = {
-				family: options
-			};
-		}
-
-		if (!callback) {
-			throw new Error('Callback must be a function.');
-		}
-
-		// eslint-disable-next-line promise/prefer-await-to-then
-		this.lookupAsync(hostname, options).then(result => {
-			if (options.all) {
-				callback(null, result);
-			} else {
-				callback(null, result.address, result.family, result.expires, result.ttl);
-			}
-		}, callback);
-	}
-
-	async lookupAsync(hostname, options = {}) {
-		if (typeof options === 'number') {
-			options = {
-				family: options
-			};
-		}
-
-		let cached = await this.query(hostname);
-
-		if (options.family === 6) {
-			const filtered = cached.filter(entry => entry.family === 6);
-
-			if (options.hints & V4MAPPED) {
-				if ((supportsALL && options.hints & ALL) || filtered.length === 0) {
-					map4to6(cached);
-				} else {
-					cached = filtered;
-				}
-			} else {
-				cached = filtered;
-			}
-		} else if (options.family === 4) {
-			cached = cached.filter(entry => entry.family === 4);
-		}
-
-		if (options.hints & ADDRCONFIG) {
-			const {_iface} = this;
-			cached = cached.filter(entry => entry.family === 6 ? _iface.has6 : _iface.has4);
-		}
-
-		if (cached.length === 0) {
-			const error = new Error(`cacheableLookup ENOTFOUND ${hostname}`);
-			error.code = 'ENOTFOUND';
-			error.hostname = hostname;
-
-			throw error;
-		}
-
-		if (options.all) {
-			return cached;
-		}
-
-		return cached[0];
-	}
-
-	async query(hostname) {
-		let cached = await this._cache.get(hostname);
-
-		if (!cached) {
-			const pending = this._pending[hostname];
-
-			if (pending) {
-				cached = await pending;
-			} else {
-				const newPromise = this.queryAndCache(hostname);
-				this._pending[hostname] = newPromise;
-
-				try {
-					cached = await newPromise;
-				} finally {
-					delete this._pending[hostname];
-				}
-			}
-		}
-
-		cached = cached.map(entry => {
-			return {...entry};
-		});
-
-		return cached;
-	}
-
-	async _resolve(hostname) {
-		const wrap = async promise => {
-			try {
-				return await promise;
-			} catch (error) {
-				if (error.code === 'ENODATA' || error.code === 'ENOTFOUND') {
-					return [];
-				}
-
-				throw error;
-			}
-		};
-
-		// ANY is unsafe as it doesn't trigger new queries in the underlying server.
-		const [A, AAAA] = await Promise.all([
-			this._resolve4(hostname, ttl),
-			this._resolve6(hostname, ttl)
-		].map(promise => wrap(promise)));
-
-		let aTtl = 0;
-		let aaaaTtl = 0;
-		let cacheTtl = 0;
-
-		const now = Date.now();
-
-		for (const entry of A) {
-			entry.family = 4;
-			entry.expires = now + (entry.ttl * 1000);
-
-			aTtl = Math.max(aTtl, entry.ttl);
-		}
-
-		for (const entry of AAAA) {
-			entry.family = 6;
-			entry.expires = now + (entry.ttl * 1000);
-
-			aaaaTtl = Math.max(aaaaTtl, entry.ttl);
-		}
-
-		if (A.length > 0) {
-			if (AAAA.length > 0) {
-				cacheTtl = Math.min(aTtl, aaaaTtl);
-			} else {
-				cacheTtl = aTtl;
-			}
-		} else {
-			cacheTtl = aaaaTtl;
-		}
-
-		return {
-			entries: [
-				...A,
-				...AAAA
-			],
-			cacheTtl
-		};
-	}
-
-	async _lookup(hostname) {
-		try {
-			const entries = await this._dnsLookup(hostname, {
-				all: true
-			});
-
-			return {
-				entries,
-				cacheTtl: 0
-			};
-		} catch (_) {
-			return {
-				entries: [],
-				cacheTtl: 0
-			};
-		}
-	}
-
-	async _set(hostname, data, cacheTtl) {
-		if (this.maxTtl > 0 && cacheTtl > 0) {
-			cacheTtl = Math.min(cacheTtl, this.maxTtl) * 1000;
-			data[kExpires] = Date.now() + cacheTtl;
-
-			try {
-				await this._cache.set(hostname, data, cacheTtl);
-			} catch (error) {
-				this.lookupAsync = async () => {
-					const cacheError = new Error('Cache Error. Please recreate the CacheableLookup instance.');
-					cacheError.cause = error;
-
-					throw cacheError;
-				};
-			}
-
-			if (isIterable(this._cache)) {
-				this._tick(cacheTtl);
-			}
-		}
-	}
-
-	async queryAndCache(hostname) {
-		if (this._hostnamesToFallback.has(hostname)) {
-			return this._dnsLookup(hostname, all);
-		}
-
-		let query = await this._resolve(hostname);
-
-		if (query.entries.length === 0 && this._fallback) {
-			query = await this._lookup(hostname);
-
-			if (query.entries.length !== 0) {
-				// Use `dns.lookup(...)` for that particular hostname
-				this._hostnamesToFallback.add(hostname);
-			}
-		}
-
-		const cacheTtl = query.entries.length === 0 ? this.errorTtl : query.cacheTtl;
-		await this._set(hostname, query.entries, cacheTtl);
-
-		return query.entries;
-	}
-
-	_tick(ms) {
-		const nextRemovalTime = this._nextRemovalTime;
-
-		if (!nextRemovalTime || ms < nextRemovalTime) {
-			clearTimeout(this._removalTimeout);
-
-			this._nextRemovalTime = ms;
-
-			this._removalTimeout = setTimeout(() => {
-				this._nextRemovalTime = false;
-
-				let nextExpiry = Infinity;
-
-				const now = Date.now();
-
-				for (const [hostname, entries] of this._cache) {
-					const expires = entries[kExpires];
-
-					if (now >= expires) {
-						this._cache.delete(hostname);
-					} else if (expires < nextExpiry) {
-						nextExpiry = expires;
-					}
-				}
-
-				if (nextExpiry !== Infinity) {
-					this._tick(nextExpiry - now);
-				}
-			}, ms);
-
-			/* istanbul ignore next: There is no `timeout.unref()` when running inside an Electron renderer */
-			if (this._removalTimeout.unref) {
-				this._removalTimeout.unref();
-			}
-		}
-	}
-
-	install(agent) {
-		verifyAgent(agent);
-
-		if (kCacheableLookupCreateConnection in agent) {
-			throw new Error('CacheableLookup has been already installed');
-		}
-
-		agent[kCacheableLookupCreateConnection] = agent.createConnection;
-		agent[kCacheableLookupInstance] = this;
-
-		agent.createConnection = (options, callback) => {
-			if (!('lookup' in options)) {
-				options.lookup = this.lookup;
-			}
-
-			return agent[kCacheableLookupCreateConnection](options, callback);
-		};
-	}
-
-	uninstall(agent) {
-		verifyAgent(agent);
-
-		if (agent[kCacheableLookupCreateConnection]) {
-			if (agent[kCacheableLookupInstance] !== this) {
-				throw new Error('The agent is not owned by this CacheableLookup instance');
-			}
-
-			agent.createConnection = agent[kCacheableLookupCreateConnection];
-
-			delete agent[kCacheableLookupCreateConnection];
-			delete agent[kCacheableLookupInstance];
-		}
-	}
-
-	updateInterfaceInfo() {
-		const {_iface} = this;
-
-		this._iface = getIfaceInfo();
-
-		if ((_iface.has4 && !this._iface.has4) || (_iface.has6 && !this._iface.has6)) {
-			this._cache.clear();
-		}
-	}
-
-	clear(hostname) {
-		if (hostname) {
-			this._cache.delete(hostname);
-			return;
-		}
-
-		this._cache.clear();
-	}
-}
-
-module.exports = CacheableLookup;
-module.exports.default = CacheableLookup;

package/node_modules/cacheable-request/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2017 Luke Childs
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.