Initial commit - full huishou project

node_modules/got/dist/source/utils/deep-freeze.d.ts

@@ -0,0 +1 @@
+export default function deepFreeze<T extends object>(object: T): Readonly<T>;

node_modules/got/dist/source/utils/deep-freeze.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_1 = require("@sindresorhus/is");
+function deepFreeze(object) {
+    for (const value of Object.values(object)) {
+        if (is_1.default.plainObject(value) || is_1.default.array(value)) {
+            deepFreeze(value);
+        }
+    }
+    return Object.freeze(object);
+}
+exports.default = deepFreeze;

node_modules/got/dist/source/utils/dynamic-require.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+declare const _default: (moduleObject: NodeModule, moduleId: string) => unknown;
+export default _default;

node_modules/got/dist/source/utils/dynamic-require.js

@@ -0,0 +1,4 @@
+"use strict";
+/* istanbul ignore file: used for webpack */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (moduleObject, moduleId) => moduleObject.require(moduleId);

node_modules/got/dist/source/utils/get-body-size.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { ClientRequestArgs } from 'http';
+interface Options {
+    body?: unknown;
+    headers: ClientRequestArgs['headers'];
+}
+declare const _default: (options: Options) => Promise<number | undefined>;
+export default _default;

node_modules/got/dist/source/utils/get-body-size.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const util_1 = require("util");
+const is_1 = require("@sindresorhus/is");
+const is_form_data_1 = require("./is-form-data");
+const statAsync = util_1.promisify(fs_1.stat);
+exports.default = async (options) => {
+    const { body, headers } = options;
+    if (headers && 'content-length' in headers) {
+        return Number(headers['content-length']);
+    }
+    if (!body) {
+        return 0;
+    }
+    if (is_1.default.string(body)) {
+        return Buffer.byteLength(body);
+    }
+    if (is_1.default.buffer(body)) {
+        return body.length;
+    }
+    if (is_form_data_1.default(body)) {
+        return util_1.promisify(body.getLength.bind(body))();
+    }
+    if (body instanceof fs_1.ReadStream) {
+        const { size } = await statAsync(body.path);
+        return size;
+    }
+    return undefined;
+};

node_modules/got/dist/source/utils/is-form-data.d.ts

@@ -0,0 +1,3 @@
+import FormData = require('form-data');
+declare const _default: (body: unknown) => body is FormData;
+export default _default;

node_modules/got/dist/source/utils/is-form-data.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_1 = require("@sindresorhus/is");
+exports.default = (body) => is_1.default.nodeStream(body) && is_1.default.function_(body.getBoundary);

node_modules/got/dist/source/utils/merge.d.ts

@@ -0,0 +1,6 @@
+import { Merge } from 'type-fest';
+export default function merge<Target extends {
+    [key: string]: any;
+}, Source extends {
+    [key: string]: any;
+}>(target: Target, ...sources: Source[]): Merge<Source, Target>;

node_modules/got/dist/source/utils/merge.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = require("url");
+const is_1 = require("@sindresorhus/is");
+function merge(target, ...sources) {
+    for (const source of sources) {
+        for (const [key, sourceValue] of Object.entries(source)) {
+            const targetValue = target[key];
+            if (is_1.default.urlInstance(targetValue) && is_1.default.string(sourceValue)) {
+                // @ts-ignore TS doesn't recognise Target accepts string keys
+                target[key] = new url_1.URL(sourceValue, targetValue);
+            }
+            else if (is_1.default.plainObject(sourceValue)) {
+                if (is_1.default.plainObject(targetValue)) {
+                    // @ts-ignore TS doesn't recognise Target accepts string keys
+                    target[key] = merge({}, targetValue, sourceValue);
+                }
+                else {
+                    // @ts-ignore TS doesn't recognise Target accepts string keys
+                    target[key] = merge({}, sourceValue);
+                }
+            }
+            else if (is_1.default.array(sourceValue)) {
+                // @ts-ignore TS doesn't recognise Target accepts string keys
+                target[key] = sourceValue.slice();
+            }
+            else {
+                // @ts-ignore TS doesn't recognise Target accepts string keys
+                target[key] = sourceValue;
+            }
+        }
+    }
+    return target;
+}
+exports.default = merge;

node_modules/got/dist/source/utils/options-to-url.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { URL, URLSearchParams } from 'url';
+export interface URLOptions {
+    href?: string;
+    origin?: string;
+    protocol?: string;
+    username?: string;
+    password?: string;
+    host?: string;
+    hostname?: string;
+    port?: string | number;
+    pathname?: string;
+    search?: string;
+    searchParams?: Record<string, string | number | boolean | null> | URLSearchParams | string;
+    hash?: string;
+    path?: string;
+}
+declare const _default: (options: URLOptions) => URL;
+export default _default;

node_modules/got/dist/source/utils/options-to-url.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = require("url");
+function validateSearchParams(searchParams) {
+    for (const value of Object.values(searchParams)) {
+        if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean' && value !== null) {
+            throw new TypeError(`The \`searchParams\` value '${String(value)}' must be a string, number, boolean or null`);
+        }
+    }
+}
+const keys = [
+    'protocol',
+    'username',
+    'password',
+    'host',
+    'hostname',
+    'port',
+    'pathname',
+    'search',
+    'hash'
+];
+exports.default = (options) => {
+    var _a, _b;
+    let origin;
+    if (options.path) {
+        if (options.pathname) {
+            throw new TypeError('Parameters `path` and `pathname` are mutually exclusive.');
+        }
+        if (options.search) {
+            throw new TypeError('Parameters `path` and `search` are mutually exclusive.');
+        }
+        if (options.searchParams) {
+            throw new TypeError('Parameters `path` and `searchParams` are mutually exclusive.');
+        }
+    }
+    if (Reflect.has(options, 'auth')) {
+        throw new TypeError('Parameter `auth` is deprecated. Use `username` / `password` instead.');
+    }
+    if (options.search && options.searchParams) {
+        throw new TypeError('Parameters `search` and `searchParams` are mutually exclusive.');
+    }
+    if (options.href) {
+        return new url_1.URL(options.href);
+    }
+    if (options.origin) {
+        origin = options.origin;
+    }
+    else {
+        if (!options.protocol) {
+            throw new TypeError('No URL protocol specified');
+        }
+        origin = `${options.protocol}//${_b = (_a = options.hostname, (_a !== null && _a !== void 0 ? _a : options.host)), (_b !== null && _b !== void 0 ? _b : '')}`;
+    }
+    const url = new url_1.URL(origin);
+    if (options.path) {
+        const searchIndex = options.path.indexOf('?');
+        if (searchIndex === -1) {
+            options.pathname = options.path;
+        }
+        else {
+            options.pathname = options.path.slice(0, searchIndex);
+            options.search = options.path.slice(searchIndex + 1);
+        }
+    }
+    if (Reflect.has(options, 'path')) {
+        delete options.path;
+    }
+    for (const key of keys) {
+        if (Reflect.has(options, key)) {
+            url[key] = options[key].toString();
+        }
+    }
+    if (options.searchParams) {
+        if (typeof options.searchParams !== 'string' && !(options.searchParams instanceof url_1.URLSearchParams)) {
+            validateSearchParams(options.searchParams);
+        }
+        (new url_1.URLSearchParams(options.searchParams)).forEach((value, key) => {
+            url.searchParams.append(key, value);
+        });
+    }
+    return url;
+};

node_modules/got/dist/source/utils/supports-brotli.d.ts

@@ -0,0 +1,2 @@
+declare const _default: boolean;
+export default _default;

node_modules/got/dist/source/utils/supports-brotli.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zlib = require("zlib");
+exports.default = typeof zlib.createBrotliDecompress === 'function';

node_modules/got/dist/source/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;
+    }
+}

node_modules/got/dist/source/utils/timed-out.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const net = require("net");
+const unhandle_1 = require("./unhandle");
+const reentry = Symbol('reentry');
+const noop = () => { };
+class TimeoutError extends Error {
+    constructor(threshold, event) {
+        super(`Timeout awaiting '${event}' for ${threshold}ms`);
+        this.event = event;
+        this.name = 'TimeoutError';
+        this.code = 'ETIMEDOUT';
+    }
+}
+exports.TimeoutError = TimeoutError;
+exports.default = (request, delays, options) => {
+    if (Reflect.has(request, reentry)) {
+        return noop;
+    }
+    request[reentry] = true;
+    const cancelers = [];
+    const { once, unhandleAll } = unhandle_1.default();
+    const addTimeout = (delay, callback, event) => {
+        var _a, _b;
+        const timeout = setTimeout(callback, delay, delay, event);
+        (_b = (_a = timeout).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        const cancel = () => {
+            clearTimeout(timeout);
+        };
+        cancelers.push(cancel);
+        return cancel;
+    };
+    const { host, hostname } = options;
+    const timeoutHandler = (delay, event) => {
+        if (request.socket) {
+            // @ts-ignore We do not want the `socket hang up` error
+            request.socket._hadError = true;
+        }
+        request.abort();
+        request.emit('error', new TimeoutError(delay, event));
+    };
+    const cancelTimeouts = () => {
+        for (const cancel of cancelers) {
+            cancel();
+        }
+        unhandleAll();
+    };
+    request.once('error', error => {
+        cancelTimeouts();
+        // Save original behavior
+        if (request.listenerCount('error') === 0) {
+            throw error;
+        }
+    });
+    request.once('abort', cancelTimeouts);
+    once(request, 'response', (response) => {
+        once(response, 'end', cancelTimeouts);
+    });
+    if (typeof delays.request !== 'undefined') {
+        addTimeout(delays.request, timeoutHandler, 'request');
+    }
+    if (typeof delays.socket !== 'undefined') {
+        const socketTimeoutHandler = () => {
+            timeoutHandler(delays.socket, 'socket');
+        };
+        request.setTimeout(delays.socket, socketTimeoutHandler);
+        // `request.setTimeout(0)` causes a memory leak.
+        // We can just remove the listener and forget about the timer - it's unreffed.
+        // See https://github.com/sindresorhus/got/issues/690
+        cancelers.push(() => {
+            request.removeListener('timeout', socketTimeoutHandler);
+        });
+    }
+    once(request, 'socket', (socket) => {
+        var _a;
+        // @ts-ignore Node typings doesn't have this property
+        const { socketPath } = request;
+        /* istanbul ignore next: hard to test */
+        if (socket.connecting) {
+            const hasPath = Boolean((socketPath !== null && socketPath !== void 0 ? socketPath : net.isIP((_a = (hostname !== null && hostname !== void 0 ? hostname : host), (_a !== null && _a !== void 0 ? _a : ''))) !== 0));
+            if (typeof delays.lookup !== 'undefined' && !hasPath && typeof socket.address().address === 'undefined') {
+                const cancelTimeout = addTimeout(delays.lookup, timeoutHandler, 'lookup');
+                once(socket, 'lookup', cancelTimeout);
+            }
+            if (typeof delays.connect !== 'undefined') {
+                const timeConnect = () => addTimeout(delays.connect, timeoutHandler, 'connect');
+                if (hasPath) {
+                    once(socket, 'connect', timeConnect());
+                }
+                else {
+                    once(socket, 'lookup', (error) => {
+                        if (error === null) {
+                            once(socket, 'connect', timeConnect());
+                        }
+                    });
+                }
+            }
+            if (typeof delays.secureConnect !== 'undefined' && options.protocol === 'https:') {
+                once(socket, 'connect', () => {
+                    const cancelTimeout = addTimeout(delays.secureConnect, timeoutHandler, 'secureConnect');
+                    once(socket, 'secureConnect', cancelTimeout);
+                });
+            }
+        }
+        if (typeof delays.send !== 'undefined') {
+            const timeRequest = () => addTimeout(delays.send, timeoutHandler, 'send');
+            /* istanbul ignore next: hard to test */
+            if (socket.connecting) {
+                once(socket, 'connect', () => {
+                    once(request, 'upload-complete', timeRequest());
+                });
+            }
+            else {
+                once(request, 'upload-complete', timeRequest());
+            }
+        }
+    });
+    if (typeof delays.response !== 'undefined') {
+        once(request, 'upload-complete', () => {
+            const cancelTimeout = addTimeout(delays.response, timeoutHandler, 'response');
+            once(request, 'response', cancelTimeout);
+        });
+    }
+    return cancelTimeouts;
+};

node_modules/got/dist/source/utils/unhandle.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import EventEmitter = require('events');
+declare type Origin = EventEmitter;
+declare type Event = string | symbol;
+declare type Fn = (...args: any[]) => void;
+interface Unhandler {
+    once: (origin: Origin, event: Event, fn: Fn) => void;
+    unhandleAll: () => void;
+}
+declare const _default: () => Unhandler;
+export default _default;

node_modules/got/dist/source/utils/unhandle.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// When attaching listeners, it's very easy to forget about them.
+// Especially if you do error handling and set timeouts.
+// So instead of checking if it's proper to throw an error on every timeout ever,
+// use this simple tool which will remove all listeners you have attached.
+exports.default = () => {
+    const handlers = [];
+    return {
+        once(origin, event, fn) {
+            origin.once(event, fn);
+            handlers.push({ origin, event, fn });
+        },
+        unhandleAll() {
+            for (const handler of handlers) {
+                const { origin, event, fn } = handler;
+                origin.removeListener(event, fn);
+            }
+            handlers.length = 0;
+        }
+    };
+};

node_modules/got/dist/source/utils/url-to-options.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { URL, UrlWithStringQuery } from 'url';
+export interface LegacyUrlOptions {
+    protocol: string;
+    hostname: string;
+    host: string;
+    hash: string | null;
+    search: string | null;
+    pathname: string;
+    href: string;
+    path: string;
+    port?: number;
+    auth?: string;
+}
+declare const _default: (url: URL | UrlWithStringQuery) => LegacyUrlOptions;
+export default _default;

node_modules/got/dist/source/utils/url-to-options.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_1 = require("@sindresorhus/is");
+exports.default = (url) => {
+    // Cast to URL
+    url = url;
+    const options = {
+        protocol: url.protocol,
+        hostname: is_1.default.string(url.hostname) && url.hostname.startsWith('[') ? url.hostname.slice(1, -1) : url.hostname,
+        host: url.host,
+        hash: url.hash,
+        search: url.search,
+        pathname: url.pathname,
+        href: url.href,
+        path: `${url.pathname || ''}${url.search || ''}`
+    };
+    if (is_1.default.string(url.port) && url.port.length !== 0) {
+        options.port = Number(url.port);
+    }
+    if (url.username || url.password) {
+        options.auth = `${url.username || ''}:${url.password || ''}`;
+    }
+    return options;
+};