@modern-js/module-tools 2.0.0-beta.3 → 2.0.0-beta.6

package/compiled/less/package.json

@@ -0,0 +1 @@
+{"name":"less","author":{"name":"Alexis Sellier","email":"self@cloudhead.net"},"version":"4.1.3","license":"Apache-2.0"}

package/compiled/normalize-path/index.d.ts

@@ -0,0 +1,8 @@
+// Type definitions for normalize-path 3.0
+// Project: https://github.com/jonschlinkert/normalize-path
+// Definitions by: BendingBender <https://github.com/BendingBender>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export = normalizePath;
+
+declare function normalizePath(path: string, stripTrailing?: boolean): string;

package/compiled/normalize-path/index.js

@@ -0,0 +1,8 @@
+(()=>{var e={498:e=>{
+/*!
+ * normalize-path <https://github.com/jonschlinkert/normalize-path>
+ *
+ * Copyright (c) 2014-2018, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+e.exports=function(e,r){if(typeof e!=="string"){throw new TypeError("expected path to be a string")}if(e==="\\"||e==="/")return"/";var t=e.length;if(t<=1)return e;var _="";if(t>4&&e[3]==="\\"){var i=e[2];if((i==="?"||i===".")&&e.slice(0,2)==="\\\\"){e=e.slice(2);_="//"}}var a=e.split(/[/\\]+/);if(r!==false&&a[a.length-1]===""){a.pop()}return _+a.join("/")}}};var r={};function __nccwpck_require__(t){var _=r[t];if(_!==undefined){return _.exports}var i=r[t]={exports:{}};var a=true;try{e[t](i,i.exports,__nccwpck_require__);a=false}finally{if(a)delete r[t]}return i.exports}if(typeof __nccwpck_require__!=="undefined")__nccwpck_require__.ab=__dirname+"/";var t=__nccwpck_require__(498);module.exports=t})();

package/compiled/normalize-path/license

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2018, Jon Schlinkert.
+
+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.

package/compiled/normalize-path/package.json

@@ -0,0 +1 @@
+{"name":"normalize-path","author":"Jon Schlinkert (https://github.com/jonschlinkert)","version":"3.0.0","license":"MIT"}

package/compiled/p-map/@szmarczak/http-timer/dist/source/index.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import { ClientRequest, IncomingMessage } from 'http';
+export interface Timings {
+    start: number;
+    socket?: number;
+    lookup?: number;
+    connect?: number;
+    secureConnect?: number;
+    upload?: number;
+    response?: number;
+    end?: number;
+    error?: number;
+    abort?: number;
+    phases: {
+        wait?: number;
+        dns?: number;
+        tcp?: number;
+        tls?: number;
+        request?: number;
+        firstByte?: number;
+        download?: number;
+        total?: number;
+    };
+}
+export interface ClientRequestWithTimings extends ClientRequest {
+    timings?: Timings;
+}
+export interface IncomingMessageWithTimings extends IncomingMessage {
+    timings?: Timings;
+}
+declare const timer: (request: ClientRequestWithTimings) => Timings;
+export default timer;

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

@@ -0,0 +1,139 @@
+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/compiled/p-map/cacheable-request/index.d.ts

@@ -0,0 +1,137 @@
+// Type definitions for cacheable-request 6.0
+// Project: https://github.com/lukechilds/cacheable-request#readme
+// Definitions by: BendingBender <https://github.com/BendingBender>
+//                 Paul Melnikow <https://github.com/paulmelnikow>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+/// <reference types="node" />
+
+import { request, RequestOptions, ClientRequest, ServerResponse } from 'http';
+import { URL } from 'url';
+import { EventEmitter } from 'events';
+import { Store } from '../keyv';
+import { Options as CacheSemanticsOptions } from '../http-cache-semantics';
+import ResponseLike = require('../responselike');
+
+export = CacheableRequest;
+
+declare const CacheableRequest: CacheableRequest;
+
+type RequestFn = typeof request;
+
+interface CacheableRequest {
+    new (requestFn: RequestFn, storageAdapter?: string | CacheableRequest.StorageAdapter): (
+        opts: string | URL | (RequestOptions & CacheSemanticsOptions),
+        cb?: (response: ServerResponse | ResponseLike) => void
+    ) => CacheableRequest.Emitter;
+
+    RequestError: typeof RequestErrorCls;
+    CacheError: typeof CacheErrorCls;
+}
+
+declare namespace CacheableRequest {
+    type StorageAdapter = Store<any>;
+
+    interface Options {
+        /**
+         * If the cache should be used. Setting this to `false` will completely bypass the cache for the current request.
+         * @default true
+         */
+        cache?: boolean | undefined;
+
+        /**
+         * If set to `true` once a cached resource has expired it is deleted and will have to be re-requested.
+         *
+         * If set to `false`, after a cached resource's TTL expires it is kept in the cache and will be revalidated
+         * on the next request with `If-None-Match`/`If-Modified-Since` headers.
+         * @default false
+         */
+        strictTtl?: boolean | undefined;
+
+        /**
+         * Limits TTL. The `number` represents milliseconds.
+         * @default undefined
+         */
+        maxTtl?: number | undefined;
+
+        /**
+         * When set to `true`, if the DB connection fails we will automatically fallback to a network request.
+         * DB errors will still be emitted to notify you of the problem even though the request callback may succeed.
+         * @default false
+         */
+        automaticFailover?: boolean | undefined;
+
+        /**
+         * Forces refreshing the cache. If the response could be retrieved from the cache, it will perform a
+         * new request and override the cache instead.
+         * @default false
+         */
+        forceRefresh?: boolean | undefined;
+    }
+
+    interface Emitter extends EventEmitter {
+        addListener(event: 'request', listener: (request: ClientRequest) => void): this;
+        addListener(
+            event: 'response',
+            listener: (response: ServerResponse | ResponseLike) => void
+        ): this;
+        addListener(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+        on(event: 'request', listener: (request: ClientRequest) => void): this;
+        on(event: 'response', listener: (response: ServerResponse | ResponseLike) => void): this;
+        on(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+        once(event: 'request', listener: (request: ClientRequest) => void): this;
+        once(event: 'response', listener: (response: ServerResponse | ResponseLike) => void): this;
+        once(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+        prependListener(event: 'request', listener: (request: ClientRequest) => void): this;
+        prependListener(
+            event: 'response',
+            listener: (response: ServerResponse | ResponseLike) => void
+        ): this;
+        prependListener(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+        prependOnceListener(event: 'request', listener: (request: ClientRequest) => void): this;
+        prependOnceListener(
+            event: 'response',
+            listener: (response: ServerResponse | ResponseLike) => void
+        ): this;
+        prependOnceListener(
+            event: 'error',
+            listener: (error: RequestError | CacheError) => void
+        ): this;
+        removeListener(event: 'request', listener: (request: ClientRequest) => void): this;
+        removeListener(
+            event: 'response',
+            listener: (response: ServerResponse | ResponseLike) => void
+        ): this;
+        removeListener(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+        off(event: 'request', listener: (request: ClientRequest) => void): this;
+        off(event: 'response', listener: (response: ServerResponse | ResponseLike) => void): this;
+        off(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+        removeAllListeners(event?: 'request' | 'response' | 'error'): this;
+        listeners(event: 'request'): Array<(request: ClientRequest) => void>;
+        listeners(event: 'response'): Array<(response: ServerResponse | ResponseLike) => void>;
+        listeners(event: 'error'): Array<(error: RequestError | CacheError) => void>;
+        rawListeners(event: 'request'): Array<(request: ClientRequest) => void>;
+        rawListeners(event: 'response'): Array<(response: ServerResponse | ResponseLike) => void>;
+        rawListeners(event: 'error'): Array<(error: RequestError | CacheError) => void>;
+        emit(event: 'request', request: ClientRequest): boolean;
+        emit(event: 'response', response: ServerResponse | ResponseLike): boolean;
+        emit(event: 'error', error: RequestError | CacheError): boolean;
+        eventNames(): Array<'request' | 'response' | 'error'>;
+        listenerCount(type: 'request' | 'response' | 'error'): number;
+    }
+
+    type RequestError = RequestErrorCls;
+    type CacheError = CacheErrorCls;
+}
+
+declare class RequestErrorCls extends Error {
+    readonly name: 'RequestError';
+
+    constructor(error: Error);
+}
+declare class CacheErrorCls extends Error {
+    readonly name: 'CacheError';
+
+    constructor(error: Error);
+}

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

@@ -0,0 +1,3 @@
+import { NormalizedOptions, CancelableRequest } from './types';
+export default function asPromise<T>(normalizedOptions: NormalizedOptions): CancelableRequest<T>;
+export * from './types';

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

@@ -0,0 +1,256 @@
+/// <reference types="node" />
+import PCancelable = require('../../../../p-cancelable');
+import Request, { Options, Response, RequestError, RequestEvents } from '../core';
+/**
+All parsing methods supported by Got.
+*/
+export declare type ResponseType = 'json' | 'buffer' | 'text';
+export interface PaginationOptions<T, R> {
+    /**
+    All options accepted by `got.paginate()`.
+    */
+    pagination?: {
+        /**
+        A function that transform [`Response`](#response) into an array of items.
+        This is where you should do the parsing.
+
+        @default response => JSON.parse(response.body)
+        */
+        transform?: (response: Response<R>) => Promise<T[]> | T[];
+        /**
+        Checks whether the item should be emitted or not.
+
+        @default (item, allItems, currentItems) => true
+        */
+        filter?: (item: T, allItems: T[], currentItems: T[]) => boolean;
+        /**
+        The function takes three arguments:
+        - `response` - The current response object.
+        - `allItems` - An array of the emitted items.
+        - `currentItems` - Items from the current response.
+
+        It should return an object representing Got options pointing to the next page.
+        The options are merged automatically with the previous request, therefore the options returned `pagination.paginate(...)` must reflect changes only.
+        If there are no more pages, `false` should be returned.
+
+        @example
+        ```
+        const got = require('got');
+
+        (async () => {
+            const limit = 10;
+
+            const items = got.paginate('https://example.com/items', {
+                searchParams: {
+                    limit,
+                    offset: 0
+                },
+                pagination: {
+                    paginate: (response, allItems, currentItems) => {
+                        const previousSearchParams = response.request.options.searchParams;
+                        const previousOffset = previousSearchParams.get('offset');
+
+                        if (currentItems.length < limit) {
+                            return false;
+                        }
+
+                        return {
+                            searchParams: {
+                                ...previousSearchParams,
+                                offset: Number(previousOffset) + limit,
+                            }
+                        };
+                    }
+                }
+            });
+
+            console.log('Items from all pages:', items);
+        })();
+        ```
+        */
+        paginate?: (response: Response<R>, allItems: T[], currentItems: T[]) => Options | false;
+        /**
+        Checks whether the pagination should continue.
+
+        For example, if you need to stop **before** emitting an entry with some flag, you should use `(item, allItems, currentItems) => !item.flag`.
+        If you want to stop **after** emitting the entry, you should use `(item, allItems, currentItems) => allItems.some(entry => entry.flag)` instead.
+
+        @default (item, allItems, currentItems) => true
+        */
+        shouldContinue?: (item: T, allItems: T[], currentItems: T[]) => boolean;
+        /**
+        The maximum amount of items that should be emitted.
+
+        @default Infinity
+        */
+        countLimit?: number;
+        /**
+        Milliseconds to wait before the next request is triggered.
+
+        @default 0
+        */
+        backoff?: number;
+        /**
+        The maximum amount of request that should be triggered.
+        Retries on failure are not counted towards this limit.
+
+        For example, it can be helpful during development to avoid an infinite number of requests.
+
+        @default 10000
+        */
+        requestLimit?: number;
+        /**
+        Defines how the parameter `allItems` in pagination.paginate, pagination.filter and pagination.shouldContinue is managed.
+        When set to `false`, the parameter `allItems` is always an empty array.
+
+        This option can be helpful to save on memory usage when working with a large dataset.
+        */
+        stackAllItems?: boolean;
+    };
+}
+export declare type AfterResponseHook = (response: Response, retryWithMergedOptions: (options: Options) => CancelableRequest<Response>) => Response | CancelableRequest<Response> | Promise<Response | CancelableRequest<Response>>;
+export declare namespace PromiseOnly {
+    interface Hooks {
+        /**
+        Called with [response object](#response) and a retry function.
+        Calling the retry function will trigger `beforeRetry` hooks.
+
+        Each function should return the response.
+        This is especially useful when you want to refresh an access token.
+
+        __Note__: When using streams, this hook is ignored.
+
+        @example
+        ```
+        const got = require('got');
+
+        const instance = got.extend({
+            hooks: {
+                afterResponse: [
+                    (response, retryWithMergedOptions) => {
+                        if (response.statusCode === 401) { // Unauthorized
+                            const updatedOptions = {
+                                headers: {
+                                    token: getNewToken() // Refresh the access token
+                                }
+                            };
+
+                            // Save for further requests
+                            instance.defaults.options = got.mergeOptions(instance.defaults.options, updatedOptions);
+
+                            // Make a new retry
+                            return retryWithMergedOptions(updatedOptions);
+                        }
+
+                        // No changes otherwise
+                        return response;
+                    }
+                ],
+                beforeRetry: [
+                    (options, error, retryCount) => {
+                        // This will be called on `retryWithMergedOptions(...)`
+                    }
+                ]
+            },
+            mutableDefaults: true
+        });
+        ```
+        */
+        afterResponse?: AfterResponseHook[];
+    }
+    interface Options extends PaginationOptions<unknown, unknown> {
+        /**
+        The parsing method.
+
+        The promise also has `.text()`, `.json()` and `.buffer()` methods which return another Got promise for the parsed body.
+
+        It's like setting the options to `{responseType: 'json', resolveBodyOnly: true}` but without affecting the main Got promise.
+
+        __Note__: When using streams, this option is ignored.
+
+        @example
+        ```
+        (async () => {
+            const responsePromise = got(url);
+            const bufferPromise = responsePromise.buffer();
+            const jsonPromise = responsePromise.json();
+
+            const [response, buffer, json] = Promise.all([responsePromise, bufferPromise, jsonPromise]);
+            // `response` is an instance of Got Response
+            // `buffer` is an instance of Buffer
+            // `json` is an object
+        })();
+        ```
+
+        @example
+        ```
+        // This
+        const body = await got(url).json();
+
+        // is semantically the same as this
+        const body = await got(url, {responseType: 'json', resolveBodyOnly: true});
+        ```
+        */
+        responseType?: ResponseType;
+        /**
+        When set to `true` the promise will return the Response body instead of the Response object.
+
+        @default false
+        */
+        resolveBodyOnly?: boolean;
+        /**
+        Returns a `Stream` instead of a `Promise`.
+        This is equivalent to calling `got.stream(url, options?)`.
+
+        @default false
+        */
+        isStream?: boolean;
+        /**
+        [Encoding](https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings) to be used on `setEncoding` of the response data.
+
+        To get a [`Buffer`](https://nodejs.org/api/buffer.html), you need to set `responseType` to `buffer` instead.
+        Don't set this option to `null`.
+
+        __Note__: This doesn't affect streams! Instead, you need to do `got.stream(...).setEncoding(encoding)`.
+
+        @default 'utf-8'
+        */
+        encoding?: BufferEncoding;
+    }
+    interface NormalizedOptions {
+        responseType: ResponseType;
+        resolveBodyOnly: boolean;
+        isStream: boolean;
+        encoding?: BufferEncoding;
+        pagination?: Required<PaginationOptions<unknown, unknown>['pagination']>;
+    }
+    interface Defaults {
+        responseType: ResponseType;
+        resolveBodyOnly: boolean;
+        isStream: boolean;
+        pagination?: Required<PaginationOptions<unknown, unknown>['pagination']>;
+    }
+    type HookEvent = 'afterResponse';
+}
+/**
+An error to be thrown when server response code is 2xx, and parsing body fails.
+Includes a `response` property.
+*/
+export declare class ParseError extends RequestError {
+    readonly response: Response;
+    constructor(error: Error, response: Response);
+}
+/**
+An error to be thrown when the request is aborted with `.cancel()`.
+*/
+export declare class CancelError extends RequestError {
+    readonly response: Response;
+    constructor(request: Request);
+    get isCanceled(): boolean;
+}
+export interface CancelableRequest<T extends Response | Response['body'] = Response['body']> extends PCancelable<T>, RequestEvents<CancelableRequest<T>> {
+    json: <ReturnType>() => CancelableRequest<ReturnType>;
+    buffer: () => CancelableRequest<Buffer>;
+    text: () => CancelableRequest<string>;
+}
+export * from '../core';