@modern-js/module-tools 2.0.0-beta.2 → 2.0.0-beta.4

package/compiled/p-map/got/dist/source/core/utils/dns-ip-version.d.ts

@@ -0,0 +1,5 @@
+export declare type DnsLookupIpVersion = 'auto' | 'ipv4' | 'ipv6';
+declare type DnsIpFamily = 0 | 4 | 6;
+export declare const isDnsLookupIpVersion: (value: any) => boolean;
+export declare const dnsLookupIpVersionToFamily: (dnsLookupIpVersion: DnsLookupIpVersion) => DnsIpFamily;
+export {};

package/compiled/p-map/got/dist/source/core/utils/options-to-url.d.ts

@@ -0,0 +1,14 @@
+import { URL } from 'url';
+export interface URLOptions {
+    href?: string;
+    protocol?: string;
+    host?: string;
+    hostname?: string;
+    port?: string | number;
+    pathname?: string;
+    search?: string;
+    searchParams?: unknown;
+    path?: string;
+}
+declare const _default: (origin: string, options: URLOptions) => URL;
+export default _default;

package/compiled/p-map/got/dist/source/core/utils/timed-out.d.ts

@@ -0,0 +1,29 @@
+import { ClientRequest } from 'http';
+declare const reentry: unique symbol;
+interface TimedOutOptions {
+    host?: string;
+    hostname?: string;
+    protocol?: string;
+}
+export interface Delays {
+    lookup?: number;
+    connect?: number;
+    secureConnect?: number;
+    socket?: number;
+    response?: number;
+    send?: number;
+    request?: number;
+}
+export declare type ErrorCode = 'ETIMEDOUT' | 'ECONNRESET' | 'EADDRINUSE' | 'ECONNREFUSED' | 'EPIPE' | 'ENOTFOUND' | 'ENETUNREACH' | 'EAI_AGAIN';
+export declare class TimeoutError extends Error {
+    event: string;
+    code: ErrorCode;
+    constructor(threshold: number, event: string);
+}
+declare const _default: (request: ClientRequest, delays: Delays, options: TimedOutOptions) => () => void;
+export default _default;
+declare module 'http' {
+    interface ClientRequest {
+        [reentry]: boolean;
+    }
+}

package/compiled/p-map/got/dist/source/index.d.ts

@@ -0,0 +1,4 @@
+declare const got: import('./types').Got;
+export default got;
+export * from './create';
+export * from './as-promise';

package/compiled/p-map/got/dist/source/types.d.ts

@@ -0,0 +1,344 @@
+/// <reference types="node" />
+import { URL } from 'url';
+import { CancelError } from '../../../p-cancelable';
+import { CancelableRequest, Response, Options, NormalizedOptions, Defaults as DefaultOptions, PaginationOptions, ParseError, RequestError, CacheError, ReadError, HTTPError, MaxRedirectsError, TimeoutError, UnsupportedProtocolError, UploadError } from './as-promise';
+import Request from './core';
+declare type Except<ObjectType, KeysType extends keyof ObjectType> = Pick<ObjectType, Exclude<keyof ObjectType, KeysType>>;
+declare type Merge<FirstType, SecondType> = Except<FirstType, Extract<keyof FirstType, keyof SecondType>> & SecondType;
+/**
+Defaults for each Got instance.
+*/
+export interface InstanceDefaults {
+    /**
+  An object containing the default options of Got.
+    */
+    options: DefaultOptions;
+    /**
+    An array of functions. You execute them directly by calling `got()`.
+    They are some sort of "global hooks" - these functions are called first.
+    The last handler (*it's hidden*) is either `asPromise` or `asStream`, depending on the `options.isStream` property.
+
+    @default []
+    */
+    handlers: HandlerFunction[];
+    /**
+    A read-only boolean describing whether the defaults are mutable or not.
+    If set to `true`, you can update headers over time, for example, update an access token when it expires.
+
+    @default false
+    */
+    mutableDefaults: boolean;
+    _rawHandlers?: HandlerFunction[];
+}
+/**
+A Request object returned by calling Got, or any of the Got HTTP alias request functions.
+*/
+export declare type GotReturn = Request | CancelableRequest;
+/**
+A function to handle options and returns a Request object.
+It acts sort of like a "global hook", and will be called before any actual request is made.
+*/
+export declare type HandlerFunction = <T extends GotReturn>(options: NormalizedOptions, next: (options: NormalizedOptions) => T) => T | Promise<T>;
+/**
+The options available for `got.extend()`.
+*/
+export interface ExtendOptions extends Options {
+    /**
+    An array of functions. You execute them directly by calling `got()`.
+    They are some sort of "global hooks" - these functions are called first.
+    The last handler (*it's hidden*) is either `asPromise` or `asStream`, depending on the `options.isStream` property.
+
+    @default []
+    */
+    handlers?: HandlerFunction[];
+    /**
+    A read-only boolean describing whether the defaults are mutable or not.
+    If set to `true`, you can update headers over time, for example, update an access token when it expires.
+
+    @default false
+    */
+    mutableDefaults?: boolean;
+}
+export declare type OptionsOfTextResponseBody = Merge<Options, {
+    isStream?: false;
+    resolveBodyOnly?: false;
+    responseType?: 'text';
+}>;
+export declare type OptionsOfJSONResponseBody = Merge<Options, {
+    isStream?: false;
+    resolveBodyOnly?: false;
+    responseType?: 'json';
+}>;
+export declare type OptionsOfBufferResponseBody = Merge<Options, {
+    isStream?: false;
+    resolveBodyOnly?: false;
+    responseType: 'buffer';
+}>;
+export declare type OptionsOfUnknownResponseBody = Merge<Options, {
+    isStream?: false;
+    resolveBodyOnly?: false;
+}>;
+export declare type StrictOptions = Except<Options, 'isStream' | 'responseType' | 'resolveBodyOnly'>;
+export declare type StreamOptions = Merge<Options, {
+    isStream?: true;
+}>;
+declare type ResponseBodyOnly = {
+    resolveBodyOnly: true;
+};
+export declare type OptionsWithPagination<T = unknown, R = unknown> = Merge<Options, PaginationOptions<T, R>>;
+/**
+An instance of `got.paginate`.
+*/
+export interface GotPaginate {
+    /**
+    Same as `GotPaginate.each`.
+    */
+    <T, R = unknown>(url: string | URL, options?: OptionsWithPagination<T, R>): AsyncIterableIterator<T>;
+    /**
+    Same as `GotPaginate.each`.
+    */
+    <T, R = unknown>(options?: OptionsWithPagination<T, R>): AsyncIterableIterator<T>;
+    /**
+    Returns an async iterator.
+
+    See pagination.options for more pagination options.
+
+    @example
+    ```
+    (async () => {
+        const countLimit = 10;
+
+        const pagination = got.paginate('https://api.github.com/repos/sindresorhus/got/commits', {
+            pagination: {countLimit}
+        });
+
+        console.log(`Printing latest ${countLimit} Got commits (newest to oldest):`);
+
+        for await (const commitData of pagination) {
+            console.log(commitData.commit.message);
+        }
+    })();
+    ```
+    */
+    each: (<T, R = unknown>(url: string | URL, options?: OptionsWithPagination<T, R>) => AsyncIterableIterator<T>) & (<T, R = unknown>(options?: OptionsWithPagination<T, R>) => AsyncIterableIterator<T>);
+    /**
+    Returns a Promise for an array of all results.
+
+    See pagination.options for more pagination options.
+
+    @example
+    ```
+    (async () => {
+        const countLimit = 10;
+
+        const results = await got.paginate.all('https://api.github.com/repos/sindresorhus/got/commits', {
+            pagination: {countLimit}
+        });
+
+        console.log(`Printing latest ${countLimit} Got commits (newest to oldest):`);
+        console.log(results);
+    })();
+    ```
+    */
+    all: (<T, R = unknown>(url: string | URL, options?: OptionsWithPagination<T, R>) => Promise<T[]>) & (<T, R = unknown>(options?: OptionsWithPagination<T, R>) => Promise<T[]>);
+}
+export interface GotRequestFunction {
+    (url: string | URL, options?: OptionsOfTextResponseBody): CancelableRequest<Response<string>>;
+    <T>(url: string | URL, options?: OptionsOfJSONResponseBody): CancelableRequest<Response<T>>;
+    (url: string | URL, options?: OptionsOfBufferResponseBody): CancelableRequest<Response<Buffer>>;
+    (url: string | URL, options?: OptionsOfUnknownResponseBody): CancelableRequest<Response>;
+    (options: OptionsOfTextResponseBody): CancelableRequest<Response<string>>;
+    <T>(options: OptionsOfJSONResponseBody): CancelableRequest<Response<T>>;
+    (options: OptionsOfBufferResponseBody): CancelableRequest<Response<Buffer>>;
+    (options: OptionsOfUnknownResponseBody): CancelableRequest<Response>;
+    (url: string | URL, options?: (Merge<OptionsOfTextResponseBody, ResponseBodyOnly>)): CancelableRequest<string>;
+    <T>(url: string | URL, options?: (Merge<OptionsOfJSONResponseBody, ResponseBodyOnly>)): CancelableRequest<T>;
+    (url: string | URL, options?: (Merge<OptionsOfBufferResponseBody, ResponseBodyOnly>)): CancelableRequest<Buffer>;
+    (options: (Merge<OptionsOfTextResponseBody, ResponseBodyOnly>)): CancelableRequest<string>;
+    <T>(options: (Merge<OptionsOfJSONResponseBody, ResponseBodyOnly>)): CancelableRequest<T>;
+    (options: (Merge<OptionsOfBufferResponseBody, ResponseBodyOnly>)): CancelableRequest<Buffer>;
+    (url: string | URL, options?: Merge<Options, {
+        isStream: true;
+    }>): Request;
+    (options: Merge<Options, {
+        isStream: true;
+    }>): Request;
+    (url: string | URL, options?: Options): CancelableRequest | Request;
+    (options: Options): CancelableRequest | Request;
+}
+/**
+All available HTTP request methods provided by Got.
+*/
+export declare type HTTPAlias = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete';
+interface GotStreamFunction {
+    (url: string | URL, options?: Merge<Options, {
+        isStream?: true;
+    }>): Request;
+    (options?: Merge<Options, {
+        isStream?: true;
+    }>): Request;
+}
+/**
+An instance of `got.stream()`.
+*/
+export declare type GotStream = GotStreamFunction & Record<HTTPAlias, GotStreamFunction>;
+/**
+An instance of `got`.
+*/
+export interface Got extends Record<HTTPAlias, GotRequestFunction>, GotRequestFunction {
+    /**
+    Sets `options.isStream` to `true`.
+
+    Returns a [duplex stream](https://nodejs.org/api/stream.html#stream_class_stream_duplex) with additional events:
+    - request
+    - response
+    - redirect
+    - uploadProgress
+    - downloadProgress
+    - error
+    */
+    stream: GotStream;
+    /**
+    Returns an async iterator.
+
+    See pagination.options for more pagination options.
+
+    @example
+    ```
+    (async () => {
+        const countLimit = 10;
+
+        const pagination = got.paginate('https://api.github.com/repos/sindresorhus/got/commits', {
+            pagination: {countLimit}
+        });
+
+        console.log(`Printing latest ${countLimit} Got commits (newest to oldest):`);
+
+        for await (const commitData of pagination) {
+            console.log(commitData.commit.message);
+        }
+    })();
+    ```
+    */
+    paginate: GotPaginate;
+    /**
+    The Got defaults used in that instance.
+    */
+    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.
+    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`.
+    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. 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. 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. 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. Contains a `code` property with `ERR_TOO_MANY_REDIRECTS`.
+    */
+    MaxRedirectsError: typeof MaxRedirectsError;
+    /**
+    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. 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()`. Contains a `code` property with `ERR_CANCELED`.
+    */
+    CancelError: typeof CancelError;
+    /**
+    Configure a new `got` instance with default `options`.
+    The `options` are merged with the parent instance's `defaults.options` using `got.mergeOptions`.
+    You can access the resolved options with the `.defaults` property on the instance.
+
+    Additionally, `got.extend()` accepts two properties from the `defaults` object: `mutableDefaults` and `handlers`.
+
+    It is also possible to merges many instances into a single one:
+    - options are merged using `got.mergeOptions()` (including hooks),
+    - handlers are stored in an array (you can access them through `instance.defaults.handlers`).
+
+    @example
+    ```js
+    const client = got.extend({
+        prefixUrl: 'https://example.com',
+        headers: {
+            'x-unicorn': 'rainbow'
+        }
+    });
+
+    client.get('demo');
+
+    // HTTP Request =>
+    // GET /demo HTTP/1.1
+    // Host: example.com
+    // x-unicorn: rainbow
+    ```
+    */
+    extend: (...instancesOrOptions: Array<Got | ExtendOptions>) => Got;
+    /**
+    Merges multiple `got` instances into the parent.
+    */
+    mergeInstances: (parent: Got, ...instances: Got[]) => Got;
+    /**
+    Extends parent options.
+    Avoid using [object spread](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax#Spread_in_object_literals) as it doesn't work recursively.
+
+    Options are deeply merged to a new object. The value of each key is determined as follows:
+
+    - If the new property is not defined, the old value is used.
+    - If the new property is explicitly set to `undefined`:
+        - If the parent property is a plain `object`, the parent value is deeply cloned.
+        - Otherwise, `undefined` is used.
+    - If the parent value is an instance of `URLSearchParams`:
+        - If the new value is a `string`, an `object` or an instance of `URLSearchParams`, a new `URLSearchParams` instance is created.
+            The values are merged using [`urlSearchParams.append(key, value)`](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams/append).
+            The keys defined in the new value override the keys defined in the parent value.
+        - Otherwise, the only available value is `undefined`.
+    - If the new property is a plain `object`:
+        - If the parent property is a plain `object` too, both values are merged recursively into a new `object`.
+        - Otherwise, only the new value is deeply cloned.
+    - If the new property is an `Array`, it overwrites the old one with a deep clone of the new property.
+    - Properties that are not enumerable, such as `context`, `body`, `json`, and `form`, will not be merged.
+    - Otherwise, the new value is assigned to the key.
+
+    **Note:** Only Got options are merged! Custom user options should be defined via [`options.context`](#context).
+
+    @example
+    ```
+    const a = {headers: {cat: 'meow', wolf: ['bark', 'wrrr']}};
+    const b = {headers: {cow: 'moo', wolf: ['auuu']}};
+
+    {...a, ...b}            // => {headers: {cow: 'moo', wolf: ['auuu']}}
+    got.mergeOptions(a, b)  // => {headers: {cat: 'meow', cow: 'moo', wolf: ['auuu']}}
+    ```
+    */
+    mergeOptions: (...sources: Options[]) => NormalizedOptions;
+}
+export {};

package/compiled/p-map/http-cache-semantics/index.d.ts

@@ -0,0 +1,170 @@
+// Type definitions for http-cache-semantics 4.0
+// Project: https://github.com/kornelski/http-cache-semantics#readme
+// Definitions by: BendingBender <https://github.com/BendingBender>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export = CachePolicy;
+
+declare class CachePolicy {
+    constructor(req: CachePolicy.Request, res: CachePolicy.Response, options?: CachePolicy.Options);
+
+    /**
+     * Returns `true` if the response can be stored in a cache.
+     * If it's `false` then you MUST NOT store either the request or the response.
+     */
+    storable(): boolean;
+
+    /**
+     * This is the most important method. Use this method to check whether the cached response is still fresh
+     * in the context of the new request.
+     *
+     * If it returns `true`, then the given `request` matches the original response this cache policy has been
+     * created with, and the response can be reused without contacting the server. Note that the old response
+     * can't be returned without being updated, see `responseHeaders()`.
+     *
+     * If it returns `false`, then the response may not be matching at all (e.g. it's for a different URL or method),
+     * or may require to be refreshed first (see `revalidationHeaders()`).
+     */
+    satisfiesWithoutRevalidation(newRequest: CachePolicy.Request): boolean;
+
+    /**
+     * Returns updated, filtered set of response headers to return to clients receiving the cached response.
+     * This function is necessary, because proxies MUST always remove hop-by-hop headers (such as `TE` and `Connection`)
+     * and update response's `Age` to avoid doubling cache time.
+     *
+     * @example
+     * cachedResponse.headers = cachePolicy.responseHeaders(cachedResponse);
+     */
+    responseHeaders(): CachePolicy.Headers;
+
+    /**
+     * Returns approximate time in milliseconds until the response becomes stale (i.e. not fresh).
+     *
+     * After that time (when `timeToLive() <= 0`) the response might not be usable without revalidation. However,
+     * there are exceptions, e.g. a client can explicitly allow stale responses, so always check with
+     * `satisfiesWithoutRevalidation()`.
+     */
+    timeToLive(): number;
+
+    /**
+     * Chances are you'll want to store the `CachePolicy` object along with the cached response.
+     * `obj = policy.toObject()` gives a plain JSON-serializable object.
+     */
+    toObject(): CachePolicy.CachePolicyObject;
+
+    /**
+     * `policy = CachePolicy.fromObject(obj)` creates an instance from object created by `toObject()`.
+     */
+    static fromObject(obj: CachePolicy.CachePolicyObject): CachePolicy;
+
+    /**
+     * Returns updated, filtered set of request headers to send to the origin server to check if the cached
+     * response can be reused. These headers allow the origin server to return status 304 indicating the
+     * response is still fresh. All headers unrelated to caching are passed through as-is.
+     *
+     * Use this method when updating cache from the origin server.
+     *
+     * @example
+     * updateRequest.headers = cachePolicy.revalidationHeaders(updateRequest);
+     */
+    revalidationHeaders(newRequest: CachePolicy.Request): CachePolicy.Headers;
+
+    /**
+     * Use this method to update the cache after receiving a new response from the origin server.
+     */
+    revalidatedPolicy(
+        revalidationRequest: CachePolicy.Request,
+        revalidationResponse: CachePolicy.Response
+    ): CachePolicy.RevalidationPolicy;
+}
+
+declare namespace CachePolicy {
+    interface Request {
+        url?: string | undefined;
+        method?: string | undefined;
+        headers: Headers;
+    }
+
+    interface Response {
+        status?: number | undefined;
+        headers: Headers;
+    }
+
+    interface Options {
+        /**
+         * If `true`, then the response is evaluated from a perspective of a shared cache (i.e. `private` is not
+         * cacheable and `s-maxage` is respected). If `false`, then the response is evaluated from a perspective
+         * of a single-user cache (i.e. `private` is cacheable and `s-maxage` is ignored).
+         * `true` is recommended for HTTP clients.
+         * @default true
+         */
+        shared?: boolean | undefined;
+        /**
+         * A fraction of response's age that is used as a fallback cache duration. The default is 0.1 (10%),
+         * e.g. if a file hasn't been modified for 100 days, it'll be cached for 100*0.1 = 10 days.
+         * @default 0.1
+         */
+        cacheHeuristic?: number | undefined;
+        /**
+         * A number of milliseconds to assume as the default time to cache responses with `Cache-Control: immutable`.
+         * Note that [per RFC](https://httpwg.org/specs/rfc8246.html#the-immutable-cache-control-extension)
+         * these can become stale, so `max-age` still overrides the default.
+         * @default 24*3600*1000 (24h)
+         */
+        immutableMinTimeToLive?: number | undefined;
+        /**
+         * If `true`, common anti-cache directives will be completely ignored if the non-standard `pre-check`
+         * and `post-check` directives are present. These two useless directives are most commonly found
+         * in bad StackOverflow answers and PHP's "session limiter" defaults.
+         * @default false
+         */
+        ignoreCargoCult?: boolean | undefined;
+        /**
+         * If `false`, then server's `Date` header won't be used as the base for `max-age`. This is against the RFC,
+         * but it's useful if you want to cache responses with very short `max-age`, but your local clock
+         * is not exactly in sync with the server's.
+         * @default true
+         */
+        trustServerDate?: boolean | undefined;
+    }
+
+    interface CachePolicyObject {
+        v: number;
+        t: number;
+        sh: boolean;
+        ch: number;
+        imm: number;
+        st: number;
+        resh: Headers;
+        rescc: { [key: string]: string };
+        m: string;
+        u?: string | undefined;
+        h?: string | undefined;
+        a: boolean;
+        reqh: Headers | null;
+        reqcc: { [key: string]: string };
+    }
+
+    interface Headers {
+        [header: string]: string | string[] | undefined;
+    }
+
+    interface RevalidationPolicy {
+        /**
+         * A new `CachePolicy` with HTTP headers updated from `revalidationResponse`. You can always replace
+         * the old cached `CachePolicy` with the new one.
+         */
+        policy: CachePolicy;
+        /**
+         * Boolean indicating whether the response body has changed.
+         *
+         * - If `false`, then a valid 304 Not Modified response has been received, and you can reuse the old
+         * cached response body.
+         * - If `true`, you should use new response's body (if present), or make another request to the origin
+         * server without any conditional headers (i.e. don't use `revalidationHeaders()` this time) to get
+         * the new resource.
+         */
+        modified: boolean;
+        matches: boolean;
+    }
+}

package/compiled/p-map/index.d.ts

@@ -0,0 +1,67 @@
+declare namespace pMap {
+	interface Options {
+		/**
+		Number of concurrently pending promises returned by `mapper`.
+
+		Must be an integer from 1 and up or `Infinity`.
+
+		@default Infinity
+		*/
+		readonly concurrency?: number;
+
+		/**
+		When set to `false`, instead of stopping when a promise rejects, it will wait for all the promises to settle and then reject with an [aggregated error](https://github.com/sindresorhus/aggregate-error) containing all the errors from the rejected promises.
+
+		@default true
+		*/
+		readonly stopOnError?: boolean;
+	}
+
+	/**
+	Function which is called for every item in `input`. Expected to return a `Promise` or value.
+
+	@param element - Iterated element.
+	@param index - Index of the element in the source array.
+	*/
+	type Mapper<Element = any, NewElement = unknown> = (
+		element: Element,
+		index: number
+	) => NewElement | Promise<NewElement>;
+}
+
+/**
+@param input - Iterated over concurrently in the `mapper` function.
+@param mapper - Function which is called for every item in `input`. Expected to return a `Promise` or value.
+@returns A `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled, or rejects if any of the promises reject. The fulfilled value is an `Array` of the fulfilled values returned from `mapper` in `input` order.
+
+@example
+```
+import pMap = require('./p-map');
+import got = require('./got');
+
+const sites = [
+	getWebsiteFromUsername('https://sindresorhus'), //=> Promise
+	'https://ava.li',
+	'https://github.com'
+];
+
+(async () => {
+	const mapper = async site => {
+		const {requestUrl} = await got.head(site);
+		return requestUrl;
+	};
+
+	const result = await pMap(sites, mapper, {concurrency: 2});
+
+	console.log(result);
+	//=> ['https://sindresorhus.com/', 'https://ava.li/', 'https://github.com/']
+})();
+```
+*/
+declare function pMap<Element, NewElement>(
+	input: Iterable<Element>,
+	mapper: pMap.Mapper<Element, NewElement>,
+	options?: pMap.Options
+): Promise<NewElement[]>;
+
+export = pMap;

package/compiled/p-map/index.js

@@ -0,0 +1 @@
+(()=>{"use strict";var e={964:(e,r,t)=>{const n=t(841);const o=t(111);const cleanInternalStack=e=>e.replace(/\s+at .*aggregate-error\/index.js:\d+:\d+\)?/g,"");class AggregateError extends Error{constructor(e){if(!Array.isArray(e)){throw new TypeError(`Expected input to be an Array, got ${typeof e}`)}e=[...e].map((e=>{if(e instanceof Error){return e}if(e!==null&&typeof e==="object"){return Object.assign(new Error(e.message),e)}return new Error(e)}));let r=e.map((e=>typeof e.stack==="string"?cleanInternalStack(o(e.stack)):String(e))).join("\n");r="\n"+n(r,4);super(r);this.name="AggregateError";Object.defineProperty(this,"_errors",{value:e})}*[Symbol.iterator](){for(const e of this._errors){yield e}}}e.exports=AggregateError},111:(e,r,t)=>{const n=t(37);const o=/\s+at.*(?:\(|\s)(.*)\)?/;const s=/^(?:(?:(?:node|(?:internal\/[\w/]*|.*node_modules\/(?:babel-polyfill|pirates)\/.*)?\w+)\.js:\d+:\d+)|native)/;const i=typeof n.homedir==="undefined"?"":n.homedir();e.exports=(e,r)=>{r=Object.assign({pretty:false},r);return e.replace(/\\/g,"/").split("\n").filter((e=>{const r=e.match(o);if(r===null||!r[1]){return true}const t=r[1];if(t.includes(".app/Contents/Resources/electron.asar")||t.includes(".app/Contents/Resources/default_app.asar")){return false}return!s.test(t)})).filter((e=>e.trim()!=="")).map((e=>{if(r.pretty){return e.replace(o,((e,r)=>e.replace(r,r.replace(i,"~"))))}return e})).join("\n")}},841:e=>{e.exports=(e,r=1,t)=>{t={indent:" ",includeEmptyLines:false,...t};if(typeof e!=="string"){throw new TypeError(`Expected \`input\` to be a \`string\`, got \`${typeof e}\``)}if(typeof r!=="number"){throw new TypeError(`Expected \`count\` to be a \`number\`, got \`${typeof r}\``)}if(typeof t.indent!=="string"){throw new TypeError(`Expected \`options.indent\` to be a \`string\`, got \`${typeof t.indent}\``)}if(r===0){return e}const n=t.includeEmptyLines?/^/gm:/^(?!\s*$)/gm;return e.replace(n,t.indent.repeat(r))}},977:(e,r,t)=>{const n=t(964);e.exports=async(e,r,{concurrency:t=Infinity,stopOnError:o=true}={})=>new Promise(((s,i)=>{if(typeof r!=="function"){throw new TypeError("Mapper function is required")}if(!((Number.isSafeInteger(t)||t===Infinity)&&t>=1)){throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${t}\` (${typeof t})`)}const a=[];const p=[];const c=e[Symbol.iterator]();let f=false;let u=false;let l=0;let y=0;const next=()=>{if(f){return}const e=c.next();const t=y;y++;if(e.done){u=true;if(l===0){if(!o&&p.length!==0){i(new n(p))}else{s(a)}}return}l++;(async()=>{try{const n=await e.value;a[t]=await r(n,t);l--;next()}catch(e){if(o){f=true;i(e)}else{p.push(e);l--;next()}}})()};for(let e=0;e<t;e++){next();if(u){break}}}))},37:e=>{e.exports=require("os")}};var r={};function __nccwpck_require__(t){var n=r[t];if(n!==undefined){return n.exports}var o=r[t]={exports:{}};var s=true;try{e[t](o,o.exports,__nccwpck_require__);s=false}finally{if(s)delete r[t]}return o.exports}if(typeof __nccwpck_require__!=="undefined")__nccwpck_require__.ab=__dirname+"/";var t=__nccwpck_require__(977);module.exports=t})();