@nsnanocat/util 0.0.0-preview-2c5e49e

package/dist/polyfill/Console.js

@@ -0,0 +1,216 @@
+import * as __WEBPACK_EXTERNAL_MODULE__lib_app_js__ from "../lib/app.js";
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+var _counts = /*#__PURE__*/ new WeakMap(), _groups = /*#__PURE__*/ new WeakMap(), _times = /*#__PURE__*/ new WeakMap(), _level = /*#__PURE__*/ new WeakMap();
+class ConsoleFactory {
+    error(...msg) {
+        if (_class_private_field_get(this, _level) < 1) return;
+        switch(__WEBPACK_EXTERNAL_MODULE__lib_app_js__.$app){
+            case 'Surge':
+            case 'Loon':
+            case 'Stash':
+            case 'Egern':
+            case 'Shadowrocket':
+            case 'Quantumult X':
+            case 'Node.js':
+                this.log(...msg.map((m)=>{
+                    if (m instanceof Error) return `❌ ${m.stack}`;
+                    return `❌ ${m}`;
+                }));
+                break;
+            default:
+                this.log(...msg.map((m)=>`❌ ${m}`));
+                break;
+        }
+    }
+    info(...msg) {
+        if (_class_private_field_get(this, _level) < 3) return;
+        this.log(...msg.map((m)=>`ℹ️ ${m}`));
+    }
+    get logLevel() {
+        switch(_class_private_field_get(this, _level)){
+            case 0:
+                return 'OFF';
+            case 1:
+                return 'ERROR';
+            case 2:
+                return 'WARN';
+            case 4:
+                return 'DEBUG';
+            case 5:
+                return 'ALL';
+            case 3:
+            default:
+                return 'INFO';
+        }
+    }
+    set logLevel(_level1) {
+        let level = _level1;
+        switch(typeof level){
+            case 'string':
+                level = level.toLowerCase();
+                break;
+            case 'number':
+                break;
+            case 'undefined':
+            default:
+                level = 'warn';
+                break;
+        }
+        switch(level){
+            case 0:
+            case 'off':
+                _class_private_field_set(this, _level, 0);
+                break;
+            case 1:
+            case 'error':
+                _class_private_field_set(this, _level, 1);
+                break;
+            case 3:
+            case 'info':
+                _class_private_field_set(this, _level, 3);
+                break;
+            case 4:
+            case 'debug':
+                _class_private_field_set(this, _level, 4);
+                break;
+            case 5:
+            case 'all':
+                _class_private_field_set(this, _level, 5);
+                break;
+            case 2:
+            case 'warn':
+            case 'warning':
+            default:
+                _class_private_field_set(this, _level, 2);
+                break;
+        }
+    }
+    warn(...args) {
+        if (_class_private_field_get(this, _level) < 2) return;
+        let msg = args;
+        msg = msg.map((m)=>`⚠️ ${m}`);
+        this.log(...msg);
+    }
+    constructor(){
+        _class_private_field_init(this, _counts, {
+            writable: true,
+            value: new Map([])
+        });
+        _class_private_field_init(this, _groups, {
+            writable: true,
+            value: []
+        });
+        _class_private_field_init(this, _times, {
+            writable: true,
+            value: new Map([])
+        });
+        _define_property(this, "clear", ()=>{});
+        _define_property(this, "count", (label = 'default')=>{
+            if (_class_private_field_get(this, _counts).has(label)) _class_private_field_get(this, _counts).set(label, _class_private_field_get(this, _counts).get(label) ?? 1);
+            else _class_private_field_get(this, _counts).set(label, 0);
+            this.log(`${label}: ${_class_private_field_get(this, _counts).get(label)}`);
+        });
+        _define_property(this, "countReset", (label = 'default')=>{
+            switch(_class_private_field_get(this, _counts).has(label)){
+                case true:
+                    _class_private_field_get(this, _counts).set(label, 0);
+                    this.log(`${label}: ${_class_private_field_get(this, _counts).get(label)}`);
+                    break;
+                case false:
+                    this.warn(`Counter "${label}" doesn’t exist`);
+                    break;
+            }
+        });
+        _define_property(this, "debug", (...args)=>{
+            if (_class_private_field_get(this, _level) < 4) return;
+            this.log(...args.map((m)=>`🅱️ ${m}`));
+        });
+        _define_property(this, "exception", (...msg)=>this.error(...msg));
+        _define_property(this, "group", (label)=>_class_private_field_get(this, _groups).unshift(label));
+        _define_property(this, "groupEnd", ()=>_class_private_field_get(this, _groups).shift());
+        _class_private_field_init(this, _level, {
+            writable: true,
+            value: 3
+        });
+        _define_property(this, "log", (...args)=>{
+            if (0 === _class_private_field_get(this, _level)) return;
+            let msg = args;
+            msg = msg.map((item)=>{
+                let log = item;
+                switch(typeof log){
+                    case 'object':
+                        log = JSON.stringify(log);
+                        break;
+                    case 'bigint':
+                    case 'number':
+                    case 'boolean':
+                    case 'string':
+                        log = log.toString();
+                        break;
+                    case 'undefined':
+                    default:
+                        break;
+                }
+                return log;
+            });
+            _class_private_field_get(this, _groups).forEach((group)=>{
+                msg = msg.map((log)=>`  ${log}`);
+                msg.unshift(`▼ ${group}:`);
+            });
+            msg = [
+                '',
+                ...msg
+            ];
+            console.log(msg.join('\n'));
+        });
+        _define_property(this, "time", (label = 'default')=>_class_private_field_get(this, _times).set(label, Date.now()));
+        _define_property(this, "timeEnd", (label = 'default')=>_class_private_field_get(this, _times).delete(label));
+        _define_property(this, "timeLog", (label = 'default')=>{
+            const time = _class_private_field_get(this, _times).get(label);
+            if (time) this.log(`${label}: ${Date.now() - time}ms`);
+            else this.warn(`Timer "${label}" doesn’t exist`);
+        });
+    }
+}
+const Console = new ConsoleFactory();
+export { Console };

package/dist/polyfill/Lodash.cjs

@@ -0,0 +1,74 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = function(module) {
+        var getter = module && module.__esModule ? function() {
+            return module['default'];
+        } : function() {
+            return module;
+        };
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    Lodash: ()=>Lodash
+});
+const unset_namespaceObject = require("lodash/unset");
+var unset_default = /*#__PURE__*/ __webpack_require__.n(unset_namespaceObject);
+const toPath_namespaceObject = require("lodash/toPath");
+var toPath_default = /*#__PURE__*/ __webpack_require__.n(toPath_namespaceObject);
+const set_namespaceObject = require("lodash/set");
+var set_default = /*#__PURE__*/ __webpack_require__.n(set_namespaceObject);
+const pick_namespaceObject = require("lodash/pick");
+var pick_default = /*#__PURE__*/ __webpack_require__.n(pick_namespaceObject);
+const omit_namespaceObject = require("lodash/omit");
+var omit_default = /*#__PURE__*/ __webpack_require__.n(omit_namespaceObject);
+const unescape_namespaceObject = require("lodash/unescape");
+var unescape_default = /*#__PURE__*/ __webpack_require__.n(unescape_namespaceObject);
+const escape_namespaceObject = require("lodash/escape");
+var escape_default = /*#__PURE__*/ __webpack_require__.n(escape_namespaceObject);
+const get_namespaceObject = require("lodash/get");
+var get_default = /*#__PURE__*/ __webpack_require__.n(get_namespaceObject);
+const Lodash = {
+    escape: escape_default(),
+    get: get_default(),
+    omit: omit_default(),
+    pick: pick_default(),
+    set: set_default(),
+    toPath: toPath_default(),
+    unescape: unescape_default(),
+    unset: unset_default()
+};
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});

package/dist/polyfill/Lodash.d.ts

@@ -0,0 +1,41 @@
+export declare const Lodash: {
+    escape: (string?: string) => string;
+    get: {
+        <TObject extends object, TKey extends keyof TObject>(object: TObject, path: TKey | [TKey]): TObject[TKey];
+        <TObject extends object, TKey extends keyof TObject>(object: TObject | null | undefined, path: TKey | [TKey]): TObject[TKey] | undefined;
+        <TObject extends object, TKey extends keyof TObject, TDefault>(object: TObject | null | undefined, path: TKey | [TKey], defaultValue: TDefault): Exclude<TObject[TKey], undefined> | TDefault;
+        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(object: TObject, path: [TKey1, TKey2]): TObject[TKey1][TKey2];
+        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>>(object: TObject | null | undefined, path: [TKey1, TKey2]): NonNullable<TObject[TKey1]>[TKey2] | undefined;
+        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2], defaultValue: TDefault): Exclude<NonNullable<TObject[TKey1]>[TKey2], undefined> | TDefault;
+        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(object: TObject, path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3];
+        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TKey3 extends keyof NonNullable<NonNullable<TObject[TKey1]>[TKey2]>>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3]): NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3] | undefined;
+        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TKey3 extends keyof NonNullable<NonNullable<TObject[TKey1]>[TKey2]>, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3], defaultValue: TDefault): Exclude<NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3], undefined> | TDefault;
+        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(object: TObject, path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4];
+        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TKey3 extends keyof NonNullable<NonNullable<TObject[TKey1]>[TKey2]>, TKey4 extends keyof NonNullable<NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3]>>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3, TKey4]): NonNullable<NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3]>[TKey4] | undefined;
+        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TKey3 extends keyof NonNullable<NonNullable<TObject[TKey1]>[TKey2]>, TKey4 extends keyof NonNullable<NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3]>, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3, TKey4], defaultValue: TDefault): Exclude<NonNullable<NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3]>[TKey4], undefined> | TDefault;
+        <T>(object: import("lodash").NumericDictionary<T>, path: number): T;
+        <T>(object: import("lodash").NumericDictionary<T> | null | undefined, path: number): T | undefined;
+        <T, TDefault>(object: import("lodash").NumericDictionary<T> | null | undefined, path: number, defaultValue: TDefault): T | TDefault;
+        <TDefault>(object: null | undefined, path: import("lodash").PropertyPath, defaultValue: TDefault): TDefault;
+        (object: null | undefined, path: import("lodash").PropertyPath): undefined;
+        <TObject, TPath extends string>(data: TObject, path: TPath): string extends TPath ? any : import("lodash").GetFieldType<TObject, TPath>;
+        <TObject, TPath extends string, TDefault = import("lodash").GetFieldType<TObject, TPath, "Path">>(data: TObject, path: TPath, defaultValue: TDefault): Exclude<import("lodash").GetFieldType<TObject, TPath>, null | undefined> | TDefault;
+        (object: any, path: import("lodash").PropertyPath, defaultValue?: any): any;
+    };
+    omit: {
+        <T extends object, K extends import("lodash").PropertyName[]>(object: T | null | undefined, ...paths: K): Pick<T, Exclude<keyof T, K[number]>>;
+        <T extends object, K extends keyof T>(object: T | null | undefined, ...paths: Array<import("lodash").Many<K>>): import("lodash").Omit<T, K>;
+        <T extends object>(object: T | null | undefined, ...paths: Array<import("lodash").Many<import("lodash").PropertyName>>): import("lodash").PartialObject<T>;
+    };
+    pick: {
+        <T extends object, U extends keyof T>(object: T, ...props: Array<import("lodash").Many<U>>): Pick<T, U>;
+        <T>(object: T | null | undefined, ...props: Array<import("lodash").Many<import("lodash").PropertyPath>>): import("lodash").PartialObject<T>;
+    };
+    set: {
+        <T extends object>(object: T, path: import("lodash").PropertyPath, value: any): T;
+        <TResult>(object: object, path: import("lodash").PropertyPath, value: any): TResult;
+    };
+    toPath: (value: any) => string[];
+    unescape: (string?: string) => string;
+    unset: (object: any, path: import("lodash").PropertyPath) => boolean;
+};

package/dist/polyfill/Lodash.js

@@ -0,0 +1,19 @@
+import * as __WEBPACK_EXTERNAL_MODULE_lodash_unset__ from "lodash/unset";
+import * as __WEBPACK_EXTERNAL_MODULE_lodash_toPath__ from "lodash/toPath";
+import * as __WEBPACK_EXTERNAL_MODULE_lodash_set__ from "lodash/set";
+import * as __WEBPACK_EXTERNAL_MODULE_lodash_pick__ from "lodash/pick";
+import * as __WEBPACK_EXTERNAL_MODULE_lodash_omit__ from "lodash/omit";
+import * as __WEBPACK_EXTERNAL_MODULE_lodash_unescape__ from "lodash/unescape";
+import * as __WEBPACK_EXTERNAL_MODULE_lodash_escape__ from "lodash/escape";
+import * as __WEBPACK_EXTERNAL_MODULE_lodash_get__ from "lodash/get";
+const Lodash = {
+    escape: __WEBPACK_EXTERNAL_MODULE_lodash_escape__["default"],
+    get: __WEBPACK_EXTERNAL_MODULE_lodash_get__["default"],
+    omit: __WEBPACK_EXTERNAL_MODULE_lodash_omit__["default"],
+    pick: __WEBPACK_EXTERNAL_MODULE_lodash_pick__["default"],
+    set: __WEBPACK_EXTERNAL_MODULE_lodash_set__["default"],
+    toPath: __WEBPACK_EXTERNAL_MODULE_lodash_toPath__["default"],
+    unescape: __WEBPACK_EXTERNAL_MODULE_lodash_unescape__["default"],
+    unset: __WEBPACK_EXTERNAL_MODULE_lodash_unset__["default"]
+};
+export { Lodash };

package/dist/polyfill/StatusTexts.cjs

@@ -0,0 +1,99 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    StatusTexts: function() {
+        return StatusTexts;
+    }
+});
+const StatusTexts = {
+    100: 'Continue',
+    101: 'Switching Protocols',
+    102: 'Processing',
+    103: 'Early Hints',
+    200: 'OK',
+    201: 'Created',
+    202: 'Accepted',
+    203: 'Non-Authoritative Information',
+    204: 'No Content',
+    205: 'Reset Content',
+    206: 'Partial Content',
+    207: 'Multi-Status',
+    208: 'Already Reported',
+    226: 'IM Used',
+    300: 'Multiple Choices',
+    301: 'Moved Permanently',
+    302: 'Found',
+    304: 'Not Modified',
+    307: 'Temporary Redirect',
+    308: 'Permanent Redirect',
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    402: 'Payment Required',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    406: 'Not Acceptable',
+    407: 'Proxy Authentication Required',
+    408: 'Request Timeout',
+    409: 'Conflict',
+    410: 'Gone',
+    411: 'Length Required',
+    412: 'Precondition Failed',
+    413: 'Content Too Large',
+    414: 'URI Too Long',
+    415: 'Unsupported Media Type',
+    416: 'Range Not Satisfiable',
+    417: 'Expectation Failed',
+    418: "I'm a teapot",
+    421: 'Misdirected Request',
+    422: 'Unprocessable Entity',
+    423: 'Locked',
+    424: 'Failed Dependency',
+    425: 'Too Early',
+    426: 'Upgrade Required',
+    428: 'Precondition Required',
+    429: 'Too Many Requests',
+    431: 'Request Header Fields Too Large',
+    451: 'Unavailable For Legal Reasons',
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+    504: 'Gateway Timeout',
+    505: 'HTTP Version Not Supported',
+    506: 'Variant Also Negotiates',
+    507: 'Insufficient Storage',
+    508: 'Loop Detected',
+    510: 'Not Extended',
+    511: 'Network Authentication Required'
+};
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});

package/dist/polyfill/StatusTexts.d.ts

@@ -0,0 +1,62 @@
+export declare const StatusTexts: {
+    100: string;
+    101: string;
+    102: string;
+    103: string;
+    200: string;
+    201: string;
+    202: string;
+    203: string;
+    204: string;
+    205: string;
+    206: string;
+    207: string;
+    208: string;
+    226: string;
+    300: string;
+    301: string;
+    302: string;
+    304: string;
+    307: string;
+    308: string;
+    400: string;
+    401: string;
+    402: string;
+    403: string;
+    404: string;
+    405: string;
+    406: string;
+    407: string;
+    408: string;
+    409: string;
+    410: string;
+    411: string;
+    412: string;
+    413: string;
+    414: string;
+    415: string;
+    416: string;
+    417: string;
+    418: string;
+    421: string;
+    422: string;
+    423: string;
+    424: string;
+    425: string;
+    426: string;
+    428: string;
+    429: string;
+    431: string;
+    451: string;
+    500: string;
+    501: string;
+    502: string;
+    503: string;
+    504: string;
+    505: string;
+    506: string;
+    507: string;
+    508: string;
+    510: string;
+    511: string;
+};

package/dist/polyfill/StatusTexts.js

@@ -0,0 +1,63 @@
+const StatusTexts = {
+    100: 'Continue',
+    101: 'Switching Protocols',
+    102: 'Processing',
+    103: 'Early Hints',
+    200: 'OK',
+    201: 'Created',
+    202: 'Accepted',
+    203: 'Non-Authoritative Information',
+    204: 'No Content',
+    205: 'Reset Content',
+    206: 'Partial Content',
+    207: 'Multi-Status',
+    208: 'Already Reported',
+    226: 'IM Used',
+    300: 'Multiple Choices',
+    301: 'Moved Permanently',
+    302: 'Found',
+    304: 'Not Modified',
+    307: 'Temporary Redirect',
+    308: 'Permanent Redirect',
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    402: 'Payment Required',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    406: 'Not Acceptable',
+    407: 'Proxy Authentication Required',
+    408: 'Request Timeout',
+    409: 'Conflict',
+    410: 'Gone',
+    411: 'Length Required',
+    412: 'Precondition Failed',
+    413: 'Content Too Large',
+    414: 'URI Too Long',
+    415: 'Unsupported Media Type',
+    416: 'Range Not Satisfiable',
+    417: 'Expectation Failed',
+    418: "I'm a teapot",
+    421: 'Misdirected Request',
+    422: 'Unprocessable Entity',
+    423: 'Locked',
+    424: 'Failed Dependency',
+    425: 'Too Early',
+    426: 'Upgrade Required',
+    428: 'Precondition Required',
+    429: 'Too Many Requests',
+    431: 'Request Header Fields Too Large',
+    451: 'Unavailable For Legal Reasons',
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+    504: 'Gateway Timeout',
+    505: 'HTTP Version Not Supported',
+    506: 'Variant Also Negotiates',
+    507: 'Insufficient Storage',
+    508: 'Loop Detected',
+    510: 'Not Extended',
+    511: 'Network Authentication Required'
+};
+export { StatusTexts };