[TASK] Add missing node_modules

node_modules/@swc/helpers/.vscode/settings.json

+{
+    "editor.formatOnSave": true
+}
\ No newline at end of file

node_modules/@swc/helpers/lib/_apply_decorated_descriptor.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _applyDecoratedDescriptor;
+function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
+    var desc = {
+    };
+    Object['ke' + 'ys'](descriptor).forEach(function(key) {
+        desc[key] = descriptor[key];
+    });
+    desc.enumerable = !!desc.enumerable;
+    desc.configurable = !!desc.configurable;
+    if ('value' in desc || desc.initializer) {
+        desc.writable = true;
+    }
+    desc = decorators.slice().reverse().reduce(function(desc1, decorator) {
+        return decorator ? decorator(target, property, desc1) || desc1 : desc1;
+    }, desc);
+    if (context && desc.initializer !== void 0) {
+        desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
+        desc.initializer = undefined;
+    }
+    if (desc.initializer === void 0) {
+        Object['define' + 'Property'](target, property, desc);
+        desc = null;
+    }
+    return desc;
+}

node_modules/@swc/helpers/lib/_array_with_holes.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _arrayWithHoles;
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}

node_modules/@swc/helpers/lib/_array_without_holes.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _arrayWithoutHoles;
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) {
+        for(var i = 0, arr2 = new Array(arr.length); i < arr.length; i++){
+            arr2[i] = arr[i];
+        }
+        return arr2;
+    }
+}

node_modules/@swc/helpers/lib/_assert_this_initialized.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _assertThisInitialized;
+function _assertThisInitialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}

node_modules/@swc/helpers/lib/_async_generator.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = AsyncGenerator;
+var _awaitValue = _interopRequireDefault(require("./_await_value"));
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function AsyncGenerator(gen) {
+    var send = function send(key, arg) {
+        return new Promise(function(resolve, reject) {
+            var request = {
+                key: key,
+                arg: arg,
+                resolve: resolve,
+                reject: reject,
+                next: null
+            };
+            if (back) {
+                back = back.next = request;
+            } else {
+                front = back = request;
+                resume(key, arg);
+            }
+        });
+    };
+    var settle = function settle(type, value) {
+        switch(type){
+            case "return":
+                front.resolve({
+                    value: value,
+                    done: true
+                });
+                break;
+            case "throw":
+                front.reject(value);
+                break;
+            default:
+                front.resolve({
+                    value: value,
+                    done: false
+                });
+                break;
+        }
+        front = front.next;
+        if (front) {
+            resume(front.key, front.arg);
+        } else {
+            back = null;
+        }
+    };
+    var front, back;
+    function resume(key, arg) {
+        try {
+            var result = gen[key](arg);
+            var value = result.value;
+            var wrappedAwait = _instanceof(value, _awaitValue.default);
+            Promise.resolve(wrappedAwait ? value.wrapped : value).then(function(arg1) {
+                if (wrappedAwait) {
+                    resume("next", arg1);
+                    return;
+                }
+                settle(result.done ? "return" : "normal", arg1);
+            }, function(err) {
+                resume("throw", err);
+            });
+        } catch (err) {
+            settle("throw", err);
+        }
+    }
+    this._invoke = send;
+    if (typeof gen.return !== "function") {
+        this.return = undefined;
+    }
+}
+if (typeof Symbol === "function" && Symbol.asyncIterator) {
+    AsyncGenerator.prototype[Symbol.asyncIterator] = function() {
+        return this;
+    };
+}
+AsyncGenerator.prototype.next = function(arg) {
+    return this._invoke("next", arg);
+};
+AsyncGenerator.prototype.throw = function(arg) {
+    return this._invoke("throw", arg);
+};
+AsyncGenerator.prototype.return = function(arg) {
+    return this._invoke("return", arg);
+};

node_modules/@swc/helpers/lib/_async_generator_delegate.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _asyncGeneratorDelegate;
+function _asyncGeneratorDelegate(inner, awaitWrap) {
+    var pump = function pump(key, value) {
+        waiting = true;
+        value = new Promise(function(resolve) {
+            resolve(inner[key](value));
+        });
+        return {
+            done: false,
+            value: awaitWrap(value)
+        };
+    };
+    var iter = {
+    }, waiting = false;
+    ;
+    if (typeof Symbol === "function" && Symbol.iterator) {
+        iter[Symbol.iterator] = function() {
+            return this;
+        };
+    }
+    iter.next = function(value) {
+        if (waiting) {
+            waiting = false;
+            return value;
+        }
+        return pump("next", value);
+    };
+    if (typeof inner.throw === "function") {
+        iter.throw = function(value) {
+            if (waiting) {
+                waiting = false;
+                throw value;
+            }
+            return pump("throw", value);
+        };
+    }
+    if (typeof inner.return === "function") {
+        iter.return = function(value) {
+            return pump("return", value);
+        };
+    }
+    return iter;
+}

node_modules/@swc/helpers/lib/_async_iterator.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _asyncIterator;
+function _asyncIterator(iterable) {
+    var method;
+    if (typeof Symbol === "function") {
+        if (Symbol.asyncIterator) {
+            method = iterable[Symbol.asyncIterator];
+            if (method != null) return method.call(iterable);
+        }
+        if (Symbol.iterator) {
+            method = iterable[Symbol.iterator];
+            if (method != null) return method.call(iterable);
+        }
+    }
+    throw new TypeError("Object is not async iterable");
+}

node_modules/@swc/helpers/lib/_async_to_generator.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _asyncToGenerator;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}

node_modules/@swc/helpers/lib/_await_async_generator.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _awaitAsyncGenerator;
+var _awaitValue = _interopRequireDefault(require("./_await_value"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _awaitAsyncGenerator(value) {
+    return new _awaitValue.default(value);
+}

node_modules/@swc/helpers/lib/_await_value.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _AwaitValue;
+function _AwaitValue(value) {
+    this.wrapped = value;
+}

node_modules/@swc/helpers/lib/_class_call_check.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _classCallCheck;
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _classCallCheck(instance, Constructor) {
+    if (!_instanceof(instance, Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}

node_modules/@swc/helpers/lib/_class_name_tdz_error.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _classNameTDZError;
+function _classNameTDZError(name) {
+    throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys.");
+}

node_modules/@swc/helpers/lib/_class_private_field_get.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _classPrivateFieldGet;
+function _classPrivateFieldGet(receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver).value;
+}

node_modules/@swc/helpers/lib/_class_private_field_loose_base.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _classPrivateFieldBase;
+function _classPrivateFieldBase(receiver, privateKey) {
+    if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+        throw new TypeError("attempted to use private field on non-instance");
+    }
+    return receiver;
+}

node_modules/@swc/helpers/lib/_class_private_field_set.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _classPrivateFieldSet;
+function _classPrivateFieldSet(receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    var descriptor = privateMap.get(receiver);
+    if (!descriptor.writable) {
+        throw new TypeError("attempted to set read only private field");
+    }
+    descriptor.value = value;
+    return value;
+}

node_modules/@swc/helpers/lib/_class_private_method_get.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _classPrivateMethodGet;
+function _classPrivateMethodGet(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}

node_modules/@swc/helpers/lib/_class_private_method_set.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _classPrivateMethodSet;
+function _classPrivateMethodSet() {
+    throw new TypeError("attempted to reassign private method");
+}

node_modules/@swc/helpers/lib/_class_static_private_field_spec_get.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _classStaticPrivateFieldSpecGet;
+function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) {
+    if (receiver !== classConstructor) {
+        throw new TypeError("Private static access of wrong provenance");
+    }
+    return descriptor.value;
+}

node_modules/@swc/helpers/lib/_class_static_private_field_spec_set.js

+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = _classStaticPrivateFieldSpecSet;
+function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) {
+    if (receiver !== classConstructor) {
+        throw new TypeError("Private static access of wrong provenance");
+    }
+    if (!descriptor.writable) {
+        throw new TypeError("attempted to set read only private field");
+    }
+    descriptor.value = value;
+    return value;
+}