cdk-ecr-deployment 0.0.81 → 0.0.85

package/node_modules/@types/responselike/node_modules/@types/node/stream/web.d.ts

@@ -1,5 +1,390 @@
 declare module 'stream/web' {
     // stub module, pending copy&paste from .d.ts or manual impl
+    // copy from lib.dom.d.ts
+
+    interface ReadableWritablePair<R = any, W = any> {
+        readable: ReadableStream<R>;
+        /**
+         * Provides a convenient, chainable way of piping this readable stream
+         * through a transform stream (or any other { writable, readable }
+         * pair). It simply pipes the stream into the writable side of the
+         * supplied pair, and returns the readable side for further use.
+         *
+         * Piping a stream will lock it for the duration of the pipe, preventing
+         * any other consumer from acquiring a reader.
+         */
+        writable: WritableStream<W>;
+    }
+
+    interface StreamPipeOptions {
+        preventAbort?: boolean;
+        preventCancel?: boolean;
+        /**
+         * Pipes this readable stream to a given writable stream destination.
+         * The way in which the piping process behaves under various error
+         * conditions can be customized with a number of passed options. It
+         * returns a promise that fulfills when the piping process completes
+         * successfully, or rejects if any errors were encountered.
+         *
+         * Piping a stream will lock it for the duration of the pipe, preventing
+         * any other consumer from acquiring a reader.
+         *
+         * Errors and closures of the source and destination streams propagate
+         * as follows:
+         *
+         * An error in this source readable stream will abort destination,
+         * unless preventAbort is truthy. The returned promise will be rejected
+         * with the source's error, or with any error that occurs during
+         * aborting the destination.
+         *
+         * An error in destination will cancel this source readable stream,
+         * unless preventCancel is truthy. The returned promise will be rejected
+         * with the destination's error, or with any error that occurs during
+         * canceling the source.
+         *
+         * When this source readable stream closes, destination will be closed,
+         * unless preventClose is truthy. The returned promise will be fulfilled
+         * once this process completes, unless an error is encountered while
+         * closing the destination, in which case it will be rejected with that
+         * error.
+         *
+         * If destination starts out closed or closing, this source readable
+         * stream will be canceled, unless preventCancel is true. The returned
+         * promise will be rejected with an error indicating piping to a closed
+         * stream failed, or with any error that occurs during canceling the
+         * source.
+         *
+         * The signal option can be set to an AbortSignal to allow aborting an
+         * ongoing pipe operation via the corresponding AbortController. In this
+         * case, this source readable stream will be canceled, and destination
+         * aborted, unless the respective options preventCancel or preventAbort
+         * are set.
+         */
+        preventClose?: boolean;
+        signal?: AbortSignal;
+    }
+
+    interface ReadableStreamGenericReader {
+        readonly closed: Promise<undefined>;
+        cancel(reason?: any): Promise<void>;
+    }
+
+    interface ReadableStreamDefaultReadValueResult<T> {
+        done: false;
+        value: T;
+    }
+
+    interface ReadableStreamDefaultReadDoneResult {
+        done: true;
+        value?: undefined;
+    }
+    type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
+    type ReadableStreamDefaultReadResult<T> =
+        | ReadableStreamDefaultReadValueResult<T>
+        | ReadableStreamDefaultReadDoneResult;
+
+    interface ReadableByteStreamControllerCallback {
+        (controller: ReadableByteStreamController): void | PromiseLike<void>;
+    }
+
+    interface UnderlyingSinkAbortCallback {
+        (reason?: any): void | PromiseLike<void>;
+    }
+
+    interface UnderlyingSinkCloseCallback {
+        (): void | PromiseLike<void>;
+    }
+
+    interface UnderlyingSinkStartCallback {
+        (controller: WritableStreamDefaultController): any;
+    }
+
+    interface UnderlyingSinkWriteCallback<W> {
+        (chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<void>;
+    }
+
+    interface UnderlyingSourceCancelCallback {
+        (reason?: any): void | PromiseLike<void>;
+    }
+
+    interface UnderlyingSourcePullCallback<R> {
+        (controller: ReadableStreamController<R>): void | PromiseLike<void>;
+    }
+
+    interface UnderlyingSourceStartCallback<R> {
+        (controller: ReadableStreamController<R>): any;
+    }
+
+    interface TransformerFlushCallback<O> {
+        (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
+    }
+
+    interface TransformerStartCallback<O> {
+        (controller: TransformStreamDefaultController<O>): any;
+    }
+
+    interface TransformerTransformCallback<I, O> {
+        (chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
+    }
+
+    interface UnderlyingByteSource {
+        autoAllocateChunkSize?: number;
+        cancel?: ReadableStreamErrorCallback;
+        pull?: ReadableByteStreamControllerCallback;
+        start?: ReadableByteStreamControllerCallback;
+        type: 'bytes';
+    }
+
+    interface UnderlyingSource<R = any> {
+        cancel?: UnderlyingSourceCancelCallback;
+        pull?: UnderlyingSourcePullCallback<R>;
+        start?: UnderlyingSourceStartCallback<R>;
+        type?: undefined;
+    }
+
+    interface UnderlyingSink<W = any> {
+        abort?: UnderlyingSinkAbortCallback;
+        close?: UnderlyingSinkCloseCallback;
+        start?: UnderlyingSinkStartCallback;
+        type?: undefined;
+        write?: UnderlyingSinkWriteCallback<W>;
+    }
+
+    interface ReadableStreamErrorCallback {
+        (reason: any): void | PromiseLike<void>;
+    }
+
+    /** This Streams API interface represents a readable stream of byte data. */
+    interface ReadableStream<R = any> {
+        readonly locked: boolean;
+        cancel(reason?: any): Promise<void>;
+        getReader(): ReadableStreamDefaultReader<R>;
+        pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
+        pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
+        tee(): [ReadableStream<R>, ReadableStream<R>];
+        [Symbol.asyncIterator](options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
+    }
+
+    const ReadableStream: {
+        prototype: ReadableStream;
+        new (
+            underlyingSource: UnderlyingByteSource,
+            strategy?: QueuingStrategy<Uint8Array>,
+        ): ReadableStream<Uint8Array>;
+        new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
+    };
+
+    interface ReadableStreamDefaultReader<R = any> extends ReadableStreamGenericReader {
+        read(): Promise<ReadableStreamDefaultReadResult<R>>;
+        releaseLock(): void;
+    }
+
+    const ReadableStreamDefaultReader: {
+        prototype: ReadableStreamDefaultReader;
+        new <R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
+    };
+
+    const ReadableStreamBYOBReader: any;
+    const ReadableStreamBYOBRequest: any;
+
+    interface ReadableByteStreamController {
+        readonly byobRequest: undefined;
+        readonly desiredSize: number | null;
+        close(): void;
+        enqueue(chunk: ArrayBufferView): void;
+        error(error?: any): void;
+    }
+
+    const ReadableByteStreamController: {
+        prototype: ReadableByteStreamController;
+        new (): ReadableByteStreamController;
+    };
+
+    interface ReadableStreamDefaultController<R = any> {
+        readonly desiredSize: number | null;
+        close(): void;
+        enqueue(chunk?: R): void;
+        error(e?: any): void;
+    }
+
+    const ReadableStreamDefaultController: {
+        prototype: ReadableStreamDefaultController;
+        new (): ReadableStreamDefaultController;
+    };
+
+    interface Transformer<I = any, O = any> {
+        flush?: TransformerFlushCallback<O>;
+        readableType?: undefined;
+        start?: TransformerStartCallback<O>;
+        transform?: TransformerTransformCallback<I, O>;
+        writableType?: undefined;
+    }
+
+    interface TransformStream<I = any, O = any> {
+        readonly readable: ReadableStream<O>;
+        readonly writable: WritableStream<I>;
+    }
+
+    const TransformStream: {
+        prototype: TransformStream;
+        new <I = any, O = any>(
+            transformer?: Transformer<I, O>,
+            writableStrategy?: QueuingStrategy<I>,
+            readableStrategy?: QueuingStrategy<O>,
+        ): TransformStream<I, O>;
+    };
+
+    interface TransformStreamDefaultController<O = any> {
+        readonly desiredSize: number | null;
+        enqueue(chunk?: O): void;
+        error(reason?: any): void;
+        terminate(): void;
+    }
+
+    const TransformStreamDefaultController: {
+        prototype: TransformStreamDefaultController;
+        new (): TransformStreamDefaultController;
+    };
+
+    /**
+     * This Streams API interface provides a standard abstraction for writing
+     * streaming data to a destination, known as a sink. This object comes with
+     * built-in back pressure and queuing.
+     */
+    interface WritableStream<W = any> {
+        readonly locked: boolean;
+        abort(reason?: any): Promise<void>;
+        close(): Promise<void>;
+        getWriter(): WritableStreamDefaultWriter<W>;
+    }
+
+    const WritableStream: {
+        prototype: WritableStream;
+        new <W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
+    };
+
+    /**
+     * This Streams API interface is the object returned by
+     * WritableStream.getWriter() and once created locks the < writer to the
+     * WritableStream ensuring that no other streams can write to the underlying
+     * sink.
+     */
+    interface WritableStreamDefaultWriter<W = any> {
+        readonly closed: Promise<undefined>;
+        readonly desiredSize: number | null;
+        readonly ready: Promise<undefined>;
+        abort(reason?: any): Promise<void>;
+        close(): Promise<void>;
+        releaseLock(): void;
+        write(chunk?: W): Promise<void>;
+    }
+
+    const WritableStreamDefaultWriter: {
+        prototype: WritableStreamDefaultWriter;
+        new <W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
+    };
+
+    /**
+     * This Streams API interface represents a controller allowing control of a
+     * WritableStream's state. When constructing a WritableStream, the
+     * underlying sink is given a corresponding WritableStreamDefaultController
+     * instance to manipulate.
+     */
+    interface WritableStreamDefaultController {
+        error(e?: any): void;
+    }
+
+    const WritableStreamDefaultController: {
+        prototype: WritableStreamDefaultController;
+        new (): WritableStreamDefaultController;
+    };
+
+    interface QueuingStrategy<T = any> {
+        highWaterMark?: number;
+        size?: QueuingStrategySize<T>;
+    }
+
+    interface QueuingStrategySize<T = any> {
+        (chunk?: T): number;
+    }
+
+    interface QueuingStrategyInit {
+        /**
+         * Creates a new ByteLengthQueuingStrategy with the provided high water
+         * mark.
+         *
+         * Note that the provided high water mark will not be validated ahead of
+         * time. Instead, if it is negative, NaN, or not a number, the resulting
+         * ByteLengthQueuingStrategy will cause the corresponding stream
+         * constructor to throw.
+         */
+        highWaterMark: number;
+    }
+
+    /**
+     * This Streams API interface provides a built-in byte length queuing
+     * strategy that can be used when constructing streams.
+     */
+    interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {
+        readonly highWaterMark: number;
+        readonly size: QueuingStrategySize<ArrayBufferView>;
+    }
+
+    const ByteLengthQueuingStrategy: {
+        prototype: ByteLengthQueuingStrategy;
+        new (init: QueuingStrategyInit): ByteLengthQueuingStrategy;
+    };
+
+    /**
+     * This Streams API interface provides a built-in byte length queuing
+     * strategy that can be used when constructing streams.
+     */
+    interface CountQueuingStrategy extends QueuingStrategy {
+        readonly highWaterMark: number;
+        readonly size: QueuingStrategySize;
+    }
+
+    const CountQueuingStrategy: {
+        prototype: CountQueuingStrategy;
+        new (init: QueuingStrategyInit): CountQueuingStrategy;
+    };
+
+    interface TextEncoderStream {
+        /** Returns "utf-8". */
+        readonly encoding: 'utf-8';
+        readonly readable: ReadableStream<Uint8Array>;
+        readonly writable: WritableStream<string>;
+        readonly [Symbol.toStringTag]: string;
+    }
+
+    const TextEncoderStream: {
+        prototype: TextEncoderStream;
+        new (): TextEncoderStream;
+    };
+
+    interface TextDecoderOptions {
+        fatal?: boolean;
+        ignoreBOM?: boolean;
+    }
+
+    type BufferSource = ArrayBufferView | ArrayBuffer;
+
+    interface TextDecoderStream {
+        /** Returns encoding's name, lower cased. */
+        readonly encoding: string;
+        /** Returns `true` if error mode is "fatal", and `false` otherwise. */
+        readonly fatal: boolean;
+        /** Returns `true` if ignore BOM flag is set, and `false` otherwise. */
+        readonly ignoreBOM: boolean;
+        readonly readable: ReadableStream<string>;
+        readonly writable: WritableStream<BufferSource>;
+        readonly [Symbol.toStringTag]: string;
+    }
+
+    const TextDecoderStream: {
+        prototype: TextDecoderStream;
+        new (label?: string, options?: TextDecoderOptions): TextDecoderStream;
+    };
 }
 declare module 'node:stream/web' {
     export * from 'stream/web';

package/node_modules/got/dist/source/as-promise/parse-body.d.ts

@@ -1,3 +1,3 @@
 import { ResponseType, Response, ParseJsonFunction } from './types';
-declare const parseBody: (response: Response, responseType: ResponseType, parseJson: ParseJsonFunction, encoding?: "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "latin1" | "binary" | "hex" | undefined) => unknown;
+declare const parseBody: (response: Response, responseType: ResponseType, parseJson: ParseJsonFunction, encoding?: "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex" | undefined) => unknown;
 export default parseBody;

package/node_modules/got/dist/source/as-promise/types.js

@@ -21,6 +21,7 @@ class ParseError extends core_1.RequestError {
         const { options } = response.request;
         super(`${error.message} in "${options.url.toString()}"`, error, response.request);
         this.name = 'ParseError';
+        this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_BODY_PARSE_FAILURE' : this.code;
     }
 }
 exports.ParseError = ParseError;
@@ -31,6 +32,7 @@ class CancelError extends core_1.RequestError {
     constructor(request) {
         super('Promise was canceled', {}, request);
         this.name = 'CancelError';
+        this.code = 'ERR_CANCELED';
     }
     get isCanceled() {
         return true;

package/node_modules/got/dist/source/core/index.d.ts

@@ -952,7 +952,7 @@ An error to be thrown when a request fails.
 Contains a `code` property with error class code, like `ECONNREFUSED`.
 */
 export declare class RequestError extends Error {
-    code?: string;
+    code: string;
     stack: string;
     readonly options: NormalizedOptions;
     readonly response?: Response;

package/node_modules/got/dist/source/core/index.js

@@ -121,11 +121,11 @@ Contains a `code` property with error class code, like `ECONNREFUSED`.
 */
 class RequestError extends Error {
     constructor(message, error, self) {
-        var _a;
+        var _a, _b;
         super(message);
         Error.captureStackTrace(this, this.constructor);
         this.name = 'RequestError';
-        this.code = error.code;
+        this.code = (_a = error.code) !== null && _a !== void 0 ? _a : 'ERR_GOT_REQUEST_ERROR';
         if (self instanceof Request) {
             Object.defineProperty(this, 'request', {
                 enumerable: false,
@@ -150,7 +150,7 @@ class RequestError extends Error {
                 value: self
             });
         }
-        this.timings = (_a = this.request) === null || _a === void 0 ? void 0 : _a.timings;
+        this.timings = (_b = this.request) === null || _b === void 0 ? void 0 : _b.timings;
         // Recover the original stacktrace
         if (is_1.default.string(error.stack) && is_1.default.string(this.stack)) {
             const indexOfMessage = this.stack.indexOf(this.message) + this.message.length;
@@ -173,6 +173,7 @@ class MaxRedirectsError extends RequestError {
     constructor(request) {
         super(`Redirected ${request.options.maxRedirects} times. Aborting.`, {}, request);
         this.name = 'MaxRedirectsError';
+        this.code = 'ERR_TOO_MANY_REDIRECTS';
     }
 }
 exports.MaxRedirectsError = MaxRedirectsError;
@@ -184,6 +185,7 @@ class HTTPError extends RequestError {
     constructor(response) {
         super(`Response code ${response.statusCode} (${response.statusMessage})`, {}, response.request);
         this.name = 'HTTPError';
+        this.code = 'ERR_NON_2XX_3XX_RESPONSE';
     }
 }
 exports.HTTPError = HTTPError;
@@ -195,6 +197,7 @@ class CacheError extends RequestError {
     constructor(error, request) {
         super(error.message, error, request);
         this.name = 'CacheError';
+        this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_CACHE_ACCESS' : this.code;
     }
 }
 exports.CacheError = CacheError;
@@ -205,6 +208,7 @@ class UploadError extends RequestError {
     constructor(error, request) {
         super(error.message, error, request);
         this.name = 'UploadError';
+        this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_UPLOAD' : this.code;
     }
 }
 exports.UploadError = UploadError;
@@ -228,6 +232,7 @@ class ReadError extends RequestError {
     constructor(error, request) {
         super(error.message, error, request);
         this.name = 'ReadError';
+        this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_READING_RESPONSE_STREAM' : this.code;
     }
 }
 exports.ReadError = ReadError;
@@ -238,6 +243,7 @@ class UnsupportedProtocolError extends RequestError {
     constructor(options) {
         super(`Unsupported protocol "${options.url.protocol}"`, {}, options);
         this.name = 'UnsupportedProtocolError';
+        this.code = 'ERR_UNSUPPORTED_PROTOCOL';
     }
 }
 exports.UnsupportedProtocolError = UnsupportedProtocolError;

package/node_modules/got/dist/source/types.d.ts

@@ -226,49 +226,51 @@ export interface Got extends Record<HTTPAlias, GotRequestFunction>, GotRequestFu
     */
     defaults: InstanceDefaults;
     /**
-    An error to be thrown when a cache method fails.
-    For example, if the database goes down or there's a filesystem error.
+    An error to be thrown when a cache method fails. For example, if the database goes down or there's a filesystem error.
+    Contains a `code` property with `ERR_CACHE_ACCESS` or a more specific failure code.
     */
     CacheError: typeof CacheError;
     /**
-    An error to be thrown when a request fails.
-    Contains a `code` property with error class code, like `ECONNREFUSED`.
+    An error to be thrown when a request fails. Contains a `code` property with error class code, like `ECONNREFUSED`.
+    If there is no specific code supplied, `code` defaults to `ERR_GOT_REQUEST_ERROR`.
     */
     RequestError: typeof RequestError;
     /**
-    An error to be thrown when reading from response stream fails.
+    An error to be thrown when reading from response stream fails. Contains a `code` property with
+    `ERR_READING_RESPONSE_STREAM` or a more specific failure code.
     */
     ReadError: typeof ReadError;
     /**
-    An error to be thrown when server response code is 2xx, and parsing body fails.
-    Includes a `response` property.
+    An error to be thrown when server response code is 2xx, and parsing body fails. Includes a
+    `response` property. Contains a `code` property with `ERR_BODY_PARSE_FAILURE` or a more specific failure code.
     */
     ParseError: typeof ParseError;
     /**
     An error to be thrown when the server response code is not 2xx nor 3xx if `options.followRedirect` is `true`, but always except for 304.
-    Includes a `response` property.
+    Includes a `response` property. Contains a `code` property with `ERR_NON_2XX_3XX_RESPONSE` or a more specific failure code.
     */
     HTTPError: typeof HTTPError;
     /**
     An error to be thrown when the server redirects you more than ten times.
-    Includes a `response` property.
+    Includes a `response` property. Contains a `code` property with `ERR_TOO_MANY_REDIRECTS`.
     */
     MaxRedirectsError: typeof MaxRedirectsError;
     /**
-    An error to be thrown when given an unsupported protocol.
+    An error to be thrown when given an unsupported protocol. Contains a `code` property with `ERR_UNSUPPORTED_PROTOCOL`.
     */
     UnsupportedProtocolError: typeof UnsupportedProtocolError;
     /**
     An error to be thrown when the request is aborted due to a timeout.
-    Includes an `event` and `timings` property.
+    Includes an `event` and `timings` property. Contains a `code` property with `ETIMEDOUT`.
     */
     TimeoutError: typeof TimeoutError;
     /**
     An error to be thrown when the request body is a stream and an error occurs while reading from that stream.
+    Contains a `code` property with `ERR_UPLOAD` or a more specific failure code.
     */
     UploadError: typeof UploadError;
     /**
-    An error to be thrown when the request is aborted with `.cancel()`.
+    An error to be thrown when the request is aborted with `.cancel()`. Contains a `code` property with `ERR_CANCELED`.
     */
     CancelError: typeof CancelError;
     /**

package/node_modules/got/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "got",
-	"version": "11.8.2",
+	"version": "11.8.3",
 	"description": "Human-friendly and powerful HTTP request library for Node.js",
 	"license": "MIT",
 	"repository": "sindresorhus/got",
@@ -48,7 +48,7 @@
 		"@types/cacheable-request": "^6.0.1",
 		"@types/responselike": "^1.0.0",
 		"cacheable-lookup": "^5.0.3",
-		"cacheable-request": "^7.0.1",
+		"cacheable-request": "^7.0.2",
 		"decompress-response": "^6.0.0",
 		"http2-wrapper": "^1.0.0-beta.5.2",
 		"lowercase-keys": "^2.0.0",

package/node_modules/got/readme.md

@@ -1705,43 +1705,44 @@ Additionaly, the errors may have `request` (Got Stream) and `response` (Got Resp
 
 #### got.RequestError
 
-When a request fails. Contains a `code` property with error class code, like `ECONNREFUSED`. All the errors below inherit this one.
+When a request fails. Contains a `code` property with error class code, like `ECONNREFUSED`. If there is no specific code supplied, `code` defaults to `ERR_GOT_REQUEST_ERROR`. All the errors below inherit this one.
 
 #### got.CacheError
 
-When a cache method fails, for example, if the database goes down or there's a filesystem error.
+When a cache method fails, for example, if the database goes down or there's a filesystem error. Contains a `code` property with `ERR_CACHE_ACCESS` or a more specific failure code.
 
 #### got.ReadError
 
-When reading from response stream fails.
+When reading from response stream fails. Contains a `code` property with `ERR_READING_RESPONSE_STREAM` or a more specific failure code.
 
 #### got.ParseError
 
-When server response code is 2xx, and parsing body fails. Includes a `response` property.
+When server response code is 2xx, and parsing body fails. Includes a `response` property. Contains a `code` property with `ERR_BODY_PARSE_FAILURE` or a more specific failure code.
 
 #### got.UploadError
 
-When the request body is a stream and an error occurs while reading from that stream.
+When the request body is a stream and an error occurs while reading from that stream. Contains a `code` property with `ERR_UPLOAD` or a more specific failure code.
 
 #### got.HTTPError
 
-When the server response code is not 2xx nor 3xx if `options.followRedirect` is `true`, but always except for 304. Includes a `response` property.
+When the server response code is not 2xx nor 3xx if `options.followRedirect` is `true`, but always except for 304. Includes a `response` property. Contains a `code` property with `ERR_NON_2XX_3XX_RESPONSE` or a more specific failure code.
+
 
 #### got.MaxRedirectsError
 
-When the server redirects you more than ten times. Includes a `response` property.
+When the server redirects you more than ten times. Includes a `response` property. Contains a `code` property with `ERR_TOO_MANY_REDIRECTS`.
 
 #### got.UnsupportedProtocolError
 
-When given an unsupported protocol.
+When given an unsupported protocol. Contains a `code` property with `ERR_UNSUPPORTED_PROTOCOL`.
 
 #### got.TimeoutError
 
-When the request is aborted due to a [timeout](#timeout). Includes an `event` and `timings` property.
+When the request is aborted due to a [timeout](#timeout). Includes an `event` and `timings` property. Contains a `code` property with `ETIMEDOUT`.
 
 #### got.CancelError
 
-When the request is aborted with `.cancel()`.
+When the request is aborted with `.cancel()`. Contains a `code` property with `ERR_CANCELED`.
 
 ## Aborting the request
 

package/node_modules/keyv/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017 Luke Childs
+Copyright (c) 2017-2021 Jared Wray & 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