mobx-downloader 0.3.3 → 0.3.4

package/dist/index.cjs

@@ -0,0 +1,2083 @@
+function _instanceof(left, right) {
+	"@swc/helpers - instanceof";
+	if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) return !!right[Symbol.hasInstance](left);
+	else return left instanceof right;
+}
+function _type_of(obj) {
+	"@swc/helpers - typeof";
+	return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = function __copyProps(to, from, except, desc) {
+	if (from && (typeof from === "undefined" ? "undefined" : _type_of(from)) === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: (function(k) {
+				return from[k];
+			}).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = function __toESM(mod, isNodeMode, target) {
+	return target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod);
+};
+var mobx = require("mobx");
+mobx = __toESM(mobx);
+var mobx_restful = require("mobx-restful");
+var koajax = require("koajax");
+var web_utility = require("web-utility");
+function _apply_decs_2203_r$1(targetClass, memberDecs, classDecs, parentClass) {
+	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+		return function addInitializer(initializer) {
+			assertNotFinished(decoratorFinishedRef, "addInitializer");
+			assertCallable(initializer, "An initializer");
+			initializers.push(initializer);
+		};
+	}
+	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+		var kindStr;
+		switch (kind) {
+			case 1:
+				kindStr = "accessor";
+				break;
+			case 2:
+				kindStr = "method";
+				break;
+			case 3:
+				kindStr = "getter";
+				break;
+			case 4:
+				kindStr = "setter";
+				break;
+			default: kindStr = "field";
+		}
+		var ctx = {
+			kind: kindStr,
+			name: isPrivate ? "#" + name : name,
+			static: isStatic,
+			private: isPrivate,
+			metadata
+		};
+		var decoratorFinishedRef = { v: false };
+		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+		var get, set;
+		if (kind === 0) {
+			if (isPrivate) {
+				get = desc.get;
+				set = desc.set;
+			} else {
+				get = function get() {
+					return this[name];
+				};
+				set = function set(v) {
+					this[name] = v;
+				};
+			}
+		} else if (kind === 2) get = function get() {
+			return desc.value;
+		};
+		else {
+			if (kind === 1 || kind === 3) get = function get() {
+				return desc.get.call(this);
+			};
+			if (kind === 1 || kind === 4) set = function set(v) {
+				desc.set.call(this, v);
+			};
+		}
+		if (get) {
+			var originalGet = get;
+			get = function get(target) {
+				if (arguments.length === 0) target = this;
+				return originalGet.call(target);
+			};
+		}
+		if (set) {
+			var originalSet = set;
+			set = function set(target, value) {
+				if (arguments.length === 1) {
+					value = target;
+					target = this;
+				}
+				return originalSet.call(target, value);
+			};
+		}
+		if (isPrivate) ctx.access = get && set ? {
+			get,
+			set
+		} : get ? { get } : { set };
+		else {
+			var has = function has(target) {
+				return name in target;
+			};
+			ctx.access = get && set ? {
+				has,
+				get,
+				set
+			} : get ? {
+				has,
+				get
+			} : {
+				has,
+				set
+			};
+		}
+		var newValue = dec(value, ctx);
+		decoratorFinishedRef.v = true;
+		return newValue;
+	}
+	function assertNotFinished(decoratorFinishedRef, fnName) {
+		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+	}
+	function assertCallable(fn, hint) {
+		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
+	}
+	function assertValidReturnValue(kind, value) {
+		var type = typeof value === "undefined" ? "undefined" : _type_of(value);
+		if (kind === 1) {
+			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
+			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
+			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
+		} else if (type !== "function") {
+			var hint;
+			if (kind === 0) hint = "field";
+			else if (kind === 10) hint = "class";
+			else hint = "method";
+			throw new TypeError(hint + " decorators must return a function or void 0");
+		}
+	}
+	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+		var decs = decInfo[0];
+		var desc, init, value;
+		if (isPrivate) {
+			if (kind === 0 || kind === 1) desc = {
+				get: decInfo[3],
+				set: decInfo[4]
+			};
+			else if (kind === 3) desc = { get: decInfo[3] };
+			else if (kind === 4) desc = { set: decInfo[3] };
+			else desc = { value: decInfo[3] };
+		} else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
+		if (kind === 1) value = {
+			get: desc.get,
+			set: desc.set
+		};
+		else if (kind === 2) value = desc.value;
+		else if (kind === 3) value = desc.get;
+		else if (kind === 4) value = desc.set;
+		var newValue, get, set;
+		if (typeof decs === "function") {
+			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				if (kind === 0) init = newValue;
+				else if (kind === 1) {
+					init = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+			}
+		} else for (var i = decs.length - 1; i >= 0; i--) {
+			var dec = decs[i];
+			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				var newInit;
+				if (kind === 0) newInit = newValue;
+				else if (kind === 1) {
+					newInit = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+				if (newInit !== void 0) {
+					if (init === void 0) init = newInit;
+					else if (typeof init === "function") init = [init, newInit];
+					else init.push(newInit);
+				}
+			}
+		}
+		if (kind === 0 || kind === 1) {
+			if (init === void 0) init = function init(instance, init) {
+				return init;
+			};
+			else if (typeof init !== "function") {
+				var ownInitializers = init;
+				init = function init(instance, init) {
+					var value = init;
+					for (var i = 0; i < ownInitializers.length; i++) value = ownInitializers[i].call(instance, value);
+					return value;
+				};
+			} else {
+				var originalInitializer = init;
+				init = function init(instance, init) {
+					return originalInitializer.call(instance, init);
+				};
+			}
+			ret.push(init);
+		}
+		if (kind !== 0) {
+			if (kind === 1) {
+				desc.get = value.get;
+				desc.set = value.set;
+			} else if (kind === 2) desc.value = value;
+			else if (kind === 3) desc.get = value;
+			else if (kind === 4) desc.set = value;
+			if (isPrivate) {
+				if (kind === 1) {
+					ret.push(function(instance, args) {
+						return value.get.call(instance, args);
+					});
+					ret.push(function(instance, args) {
+						return value.set.call(instance, args);
+					});
+				} else if (kind === 2) ret.push(value);
+				else ret.push(function(instance, args) {
+					return value.call(instance, args);
+				});
+			} else Object.defineProperty(base, name, desc);
+		}
+	}
+	function applyMemberDecs(Class, decInfos, metadata) {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var existingProtoNonFields = /* @__PURE__ */ new Map();
+		var existingStaticNonFields = /* @__PURE__ */ new Map();
+		for (var i = 0; i < decInfos.length; i++) {
+			var decInfo = decInfos[i];
+			if (!Array.isArray(decInfo)) continue;
+			var kind = decInfo[1];
+			var name = decInfo[2];
+			var isPrivate = decInfo.length > 3;
+			var isStatic = kind >= 5;
+			var base;
+			var initializers;
+			if (isStatic) {
+				base = Class;
+				kind = kind - 5;
+				staticInitializers = staticInitializers || [];
+				initializers = staticInitializers;
+			} else {
+				base = Class.prototype;
+				protoInitializers = protoInitializers || [];
+				initializers = protoInitializers;
+			}
+			if (kind !== 0 && !isPrivate) {
+				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+				var existingKind = existingNonFields.get(name) || 0;
+				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+				else existingNonFields.set(name, true);
+			}
+			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+		}
+		pushInitializers(ret, protoInitializers);
+		pushInitializers(ret, staticInitializers);
+		return ret;
+	}
+	function pushInitializers(ret, initializers) {
+		if (initializers) ret.push(function(instance) {
+			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+			return instance;
+		});
+	}
+	function applyClassDecs(targetClass, classDecs, metadata) {
+		if (classDecs.length > 0) {
+			var initializers = [];
+			var newClass = targetClass;
+			var name = targetClass.name;
+			for (var i = classDecs.length - 1; i >= 0; i--) {
+				var decoratorFinishedRef = { v: false };
+				var nextNewClass = classDecs[i](newClass, {
+					kind: "class",
+					name,
+					addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+					metadata
+				});
+				decoratorFinishedRef.v = true;
+				if (nextNewClass !== void 0) {
+					assertValidReturnValue(10, nextNewClass);
+					newClass = nextNewClass;
+				}
+			}
+			return [defineMetadata(newClass, metadata), function() {
+				for (var i = 0; i < initializers.length; i++) initializers[i].call(newClass);
+			}];
+		}
+	}
+	function defineMetadata(Class, metadata) {
+		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	_apply_decs_2203_r$1 = function _apply_decs_2203_r$1(targetClass, memberDecs, classDecs, parentClass) {
+		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+		var e = applyMemberDecs(targetClass, memberDecs, metadata);
+		if (!classDecs.length) defineMetadata(targetClass, metadata);
+		return {
+			e,
+			get c() {
+				return applyClassDecs(targetClass, classDecs, metadata);
+			}
+		};
+	};
+	return _apply_decs_2203_r$1(targetClass, memberDecs, classDecs, parentClass);
+}
+function _array_like_to_array$1(arr, len) {
+	if (len == null || len > arr.length) len = arr.length;
+	for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+	return arr2;
+}
+function _array_with_holes$1(arr) {
+	if (Array.isArray(arr)) return arr;
+}
+function _async_iterator$1(iterable) {
+	var method, async, sync, retry = 2;
+	for ("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) {
+		if (async && null != (method = iterable[async])) return method.call(iterable);
+		if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator$1(method.call(iterable));
+		async = "@@asyncIterator", sync = "@@iterator";
+	}
+	throw new TypeError("Object is not async iterable");
+}
+function AsyncFromSyncIterator$1(s) {
+	function AsyncFromSyncIteratorContinuation(r) {
+		if (Object(r) !== r) return Promise.reject(/* @__PURE__ */ new TypeError(r + " is not an object."));
+		var done = r.done;
+		return Promise.resolve(r.value).then(function(value) {
+			return {
+				value,
+				done
+			};
+		});
+	}
+	return AsyncFromSyncIterator$1 = function AsyncFromSyncIterator$1(s) {
+		this.s = s, this.n = s.next;
+	}, AsyncFromSyncIterator$1.prototype = {
+		s: null,
+		n: null,
+		next: function next() {
+			return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+		},
+		return: function _return(value) {
+			var ret = this.s.return;
+			return void 0 === ret ? Promise.resolve({
+				value,
+				done: !0
+			}) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
+		},
+		throw: function _throw(value) {
+			var thr = this.s.return;
+			return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
+		}
+	}, new AsyncFromSyncIterator$1(s);
+}
+function asyncGeneratorStep$1(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 _async_to_generator$1(fn) {
+	return function() {
+		var self = this, args = arguments;
+		return new Promise(function(resolve, reject) {
+			var gen = fn.apply(self, args);
+			function _next(value) {
+				asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+			}
+			function _throw(err) {
+				asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+			}
+			_next(void 0);
+		});
+	};
+}
+function _check_private_redeclaration$1(obj, privateCollection) {
+	if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_apply_descriptor_get$1(receiver, descriptor) {
+	if (descriptor.get) return descriptor.get.call(receiver);
+	return descriptor.value;
+}
+function _class_apply_descriptor_set$1(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_call_check$2(instance, Constructor) {
+	if (!_instanceof(instance, Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function _class_extract_field_descriptor$1(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$1(receiver, privateMap) {
+	return _class_apply_descriptor_get$1(receiver, _class_extract_field_descriptor$1(receiver, privateMap, "get"));
+}
+function _class_private_field_init$1(obj, privateMap, value) {
+	_check_private_redeclaration$1(obj, privateMap);
+	privateMap.set(obj, value);
+}
+function _class_private_field_set$1(receiver, privateMap, value) {
+	_class_apply_descriptor_set$1(receiver, _class_extract_field_descriptor$1(receiver, privateMap, "set"), value);
+	return value;
+}
+function _defineProperties$2(target, props) {
+	for (var i = 0; i < props.length; i++) {
+		var descriptor = props[i];
+		descriptor.enumerable = descriptor.enumerable || false;
+		descriptor.configurable = true;
+		if ("value" in descriptor) descriptor.writable = true;
+		Object.defineProperty(target, descriptor.key, descriptor);
+	}
+}
+function _create_class$2(Constructor, protoProps, staticProps) {
+	if (protoProps) _defineProperties$2(Constructor.prototype, protoProps);
+	if (staticProps) _defineProperties$2(Constructor, staticProps);
+	return Constructor;
+}
+function _define_property$2(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+	else obj[key] = value;
+	return obj;
+}
+function _iterable_to_array_limit$1(arr, i) {
+	var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+	if (_i == null) return;
+	var _arr = [];
+	var _n = true;
+	var _d = false;
+	var _s, _e;
+	try {
+		for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+			_arr.push(_s.value);
+			if (i && _arr.length === i) break;
+		}
+	} catch (err) {
+		_d = true;
+		_e = err;
+	} finally {
+		try {
+			if (!_n && _i["return"] != null) _i["return"]();
+		} finally {
+			if (_d) throw _e;
+		}
+	}
+	return _arr;
+}
+function _non_iterable_rest$1() {
+	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$1(target) {
+	for (var i = 1; i < arguments.length; i++) {
+		var source = arguments[i] != null ? arguments[i] : {};
+		var ownKeys = Object.keys(source);
+		if (typeof Object.getOwnPropertySymbols === "function") ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+			return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+		}));
+		ownKeys.forEach(function(key) {
+			_define_property$2(target, key, source[key]);
+		});
+	}
+	return target;
+}
+function _object_without_properties(source, excluded) {
+	if (source == null) return {};
+	var target = {}, sourceKeys, key, i;
+	if (typeof Reflect !== "undefined" && Reflect.ownKeys) {
+		sourceKeys = Reflect.ownKeys(Object(source));
+		for (i = 0; i < sourceKeys.length; i++) {
+			key = sourceKeys[i];
+			if (excluded.indexOf(key) >= 0) continue;
+			if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+			target[key] = source[key];
+		}
+		return target;
+	}
+	target = _object_without_properties_loose(source, excluded);
+	if (Object.getOwnPropertySymbols) {
+		sourceKeys = Object.getOwnPropertySymbols(source);
+		for (i = 0; i < sourceKeys.length; i++) {
+			key = sourceKeys[i];
+			if (excluded.indexOf(key) >= 0) continue;
+			if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+			target[key] = source[key];
+		}
+	}
+	return target;
+}
+function _object_without_properties_loose(source, excluded) {
+	if (source == null) return {};
+	var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i = 0;
+	for (; i < sourceKeys.length; i++) {
+		key = sourceKeys[i];
+		if (excluded.indexOf(key) >= 0) continue;
+		if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+		target[key] = source[key];
+	}
+	return target;
+}
+function _sliced_to_array$1(arr, i) {
+	return _array_with_holes$1(arr) || _iterable_to_array_limit$1(arr, i) || _unsupported_iterable_to_array$1(arr, i) || _non_iterable_rest$1();
+}
+function _ts_generator$2(thisArg, body) {
+	var f, y, t, _ = {
+		label: 0,
+		sent: function sent() {
+			if (t[0] & 1) throw t[1];
+			return t[1];
+		},
+		trys: [],
+		ops: []
+	}, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+	return d(g, "next", { value: verb(0) }), d(g, "throw", { value: verb(1) }), d(g, "return", { value: verb(2) }), typeof Symbol === "function" && d(g, Symbol.iterator, { value: function value() {
+		return this;
+	} }), g;
+	function verb(n) {
+		return function(v) {
+			return step([n, v]);
+		};
+	}
+	function step(op) {
+		if (f) throw new TypeError("Generator is already executing.");
+		while (g && (g = 0, op[0] && (_ = 0)), _) try {
+			if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+			if (y = 0, t) op = [op[0] & 2, t.value];
+			switch (op[0]) {
+				case 0:
+				case 1:
+					t = op;
+					break;
+				case 4:
+					_.label++;
+					return {
+						value: op[1],
+						done: false
+					};
+				case 5:
+					_.label++;
+					y = op[1];
+					op = [0];
+					continue;
+				case 7:
+					op = _.ops.pop();
+					_.trys.pop();
+					continue;
+				default:
+					if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+						_ = 0;
+						continue;
+					}
+					if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+						_.label = op[1];
+						break;
+					}
+					if (op[0] === 6 && _.label < t[1]) {
+						_.label = t[1];
+						t = op;
+						break;
+					}
+					if (t && _.label < t[2]) {
+						_.label = t[2];
+						_.ops.push(op);
+						break;
+					}
+					if (t[2]) _.ops.pop();
+					_.trys.pop();
+					continue;
+			}
+			op = body.call(thisArg, _);
+		} catch (e) {
+			op = [6, e];
+			y = 0;
+		} finally {
+			f = t = 0;
+		}
+		if (op[0] & 5) throw op[1];
+		return {
+			value: op[0] ? op[1] : void 0,
+			done: true
+		};
+	}
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+	if (!o) return;
+	if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+	var n = Object.prototype.toString.call(o).slice(8, -1);
+	if (n === "Object" && o.constructor) n = o.constructor.name;
+	if (n === "Map" || n === "Set") return Array.from(o);
+	if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+}
+var _dec$1;
+var _dec1;
+var _dec2;
+var _dec3;
+var _dec4;
+var _dec5;
+var _dec6;
+var _dec7;
+var _init_id;
+var _init_name;
+var _init_path;
+var _init_fsHandle;
+var _init_total;
+var _init_loaded;
+var _init_percent;
+var _init_executing;
+var _init_options;
+var _initProto$1;
+var observable$1 = mobx.observable;
+var computed$1 = mobx.computed;
+var ref = Reflect.get(mobx, "observableRef") || Reflect.get(observable$1, "ref");
+_dec$1 = (0, mobx_restful.persist)(), _dec1 = (0, mobx_restful.persist)(), _dec2 = (0, mobx_restful.persist)(), _dec3 = (0, mobx_restful.persist)(), _dec4 = (0, mobx_restful.persist)(), _dec5 = (0, mobx_restful.persist)(), _dec6 = (0, mobx_restful.persist)(), _dec7 = (0, mobx_restful.persist)();
+var ____private_id_1 = /* @__PURE__ */ new WeakMap();
+var ____private_name_2 = /* @__PURE__ */ new WeakMap();
+var ____private_path_3 = /* @__PURE__ */ new WeakMap();
+var ____private_fsHandle_4 = /* @__PURE__ */ new WeakMap();
+var ____private_total_5 = /* @__PURE__ */ new WeakMap();
+var ____private_loaded_6 = /* @__PURE__ */ new WeakMap();
+var ____private_percent_7 = /* @__PURE__ */ new WeakMap();
+var ____private_executing_8 = /* @__PURE__ */ new WeakMap();
+var ____private_options_9 = /* @__PURE__ */ new WeakMap();
+var DownloadTask = function() {
+	"use strict";
+	function DownloadTask(path) {
+		var name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DownloadTask.nameOf(path);
+		_class_call_check$2(this, DownloadTask);
+		_class_private_field_init$1(this, ____private_id_1, {
+			writable: true,
+			value: (_initProto$1(this), _init_id(this, ""))
+		});
+		_class_private_field_init$1(this, ____private_name_2, {
+			writable: true,
+			value: _init_name(this, "")
+		});
+		_class_private_field_init$1(this, ____private_path_3, {
+			writable: true,
+			value: _init_path(this, "")
+		});
+		_class_private_field_init$1(this, ____private_fsHandle_4, {
+			writable: true,
+			value: _init_fsHandle(this)
+		});
+		_class_private_field_init$1(this, ____private_total_5, {
+			writable: true,
+			value: _init_total(this, 0)
+		});
+		_class_private_field_init$1(this, ____private_loaded_6, {
+			writable: true,
+			value: _init_loaded(this, 0)
+		});
+		_class_private_field_init$1(this, ____private_percent_7, {
+			writable: true,
+			value: _init_percent(this, 0)
+		});
+		_class_private_field_init$1(this, ____private_executing_8, {
+			writable: true,
+			value: _init_executing(this, false)
+		});
+		_class_private_field_init$1(this, ____private_options_9, {
+			writable: true,
+			value: _init_options(this)
+		});
+		_define_property$2(this, "stream", void 0);
+		this.path = path;
+		this.name = name;
+	}
+	_create_class$2(DownloadTask, [
+		{
+			key: "id",
+			get: function get() {
+				return _class_private_field_get$1(this, ____private_id_1);
+			},
+			set: function set(_v) {
+				_class_private_field_set$1(this, ____private_id_1, _v);
+			}
+		},
+		{
+			key: "name",
+			get: function get() {
+				return _class_private_field_get$1(this, ____private_name_2);
+			},
+			set: function set(_v) {
+				_class_private_field_set$1(this, ____private_name_2, _v);
+			}
+		},
+		{
+			key: "path",
+			get: function get() {
+				return _class_private_field_get$1(this, ____private_path_3);
+			},
+			set: function set(_v) {
+				_class_private_field_set$1(this, ____private_path_3, _v);
+			}
+		},
+		{
+			key: "fsHandle",
+			get: function get() {
+				return _class_private_field_get$1(this, ____private_fsHandle_4);
+			},
+			set: function set(_v) {
+				_class_private_field_set$1(this, ____private_fsHandle_4, _v);
+			}
+		},
+		{
+			key: "total",
+			get: function get() {
+				return _class_private_field_get$1(this, ____private_total_5);
+			},
+			set: function set(_v) {
+				_class_private_field_set$1(this, ____private_total_5, _v);
+			}
+		},
+		{
+			key: "loaded",
+			get: function get() {
+				return _class_private_field_get$1(this, ____private_loaded_6);
+			},
+			set: function set(_v) {
+				_class_private_field_set$1(this, ____private_loaded_6, _v);
+			}
+		},
+		{
+			key: "percent",
+			get: function get() {
+				return _class_private_field_get$1(this, ____private_percent_7);
+			},
+			set: function set(_v) {
+				_class_private_field_set$1(this, ____private_percent_7, _v);
+			}
+		},
+		{
+			key: "executing",
+			get: function get() {
+				return _class_private_field_get$1(this, ____private_executing_8);
+			},
+			set: function set(_v) {
+				_class_private_field_set$1(this, ____private_executing_8, _v);
+			}
+		},
+		{
+			key: "options",
+			get: function get() {
+				return _class_private_field_get$1(this, ____private_options_9);
+			},
+			set: function set(_v) {
+				_class_private_field_set$1(this, ____private_options_9, _v);
+			}
+		},
+		{
+			key: "totalSize",
+			get: function get() {
+				return new web_utility.ByteSize(this.total);
+			}
+		},
+		{
+			key: "loadedSize",
+			get: function get() {
+				return new web_utility.ByteSize(this.loaded);
+			}
+		},
+		{
+			key: "toJSON",
+			value: function toJSON() {
+				var _this = this, id = _this.id, name = _this.name, path = _this.path, fsHandle = _this.fsHandle, total = _this.total, loaded = _this.loaded, percent = _this.percent, options = _this.options;
+				return _object_spread$1({}, {
+					id,
+					name,
+					path,
+					fsHandle,
+					options
+				}, {
+					total,
+					loaded,
+					percent
+				});
+			}
+		},
+		{
+			key: "saveMeta",
+			value: function saveMeta() {
+				var data = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+				data.buffer;
+				var progress = _object_without_properties(data, ["buffer"]);
+				Object.assign(this, progress);
+				return data;
+			}
+		},
+		{
+			key: "start",
+			value: function start() {
+				return _async_to_generator$1(function() {
+					var options, started, _ReadableStream_from_tee, innerStream, outerStream;
+					var _arguments = arguments;
+					return _ts_generator$2(this, function(_state) {
+						switch (_state.label) {
+							case 0:
+								options = _arguments.length > 0 && _arguments[0] !== void 0 ? _arguments[0] : this.options;
+								this.options = options;
+								started = Promise.withResolvers();
+								return [4, import("web-streams-polyfill")];
+							case 1:
+								_ReadableStream_from_tee = _sliced_to_array$1.apply(void 0, [_state.sent().ReadableStream.from(this.loadStream(options)).tee(), 2]), innerStream = _ReadableStream_from_tee[0], outerStream = _ReadableStream_from_tee[1];
+								(function() {
+									return _async_to_generator$1(function() {
+										var _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, chunk, err, error;
+										return _ts_generator$2(this, function(_state) {
+											switch (_state.label) {
+												case 0:
+													_state.trys.push([
+														0,
+														13,
+														,
+														14
+													]);
+													_iteratorAbruptCompletion = false, _didIteratorError = false;
+													_state.label = 1;
+												case 1:
+													_state.trys.push([
+														1,
+														6,
+														7,
+														12
+													]);
+													_iterator = _async_iterator$1(innerStream);
+													_state.label = 2;
+												case 2: return [4, _iterator.next()];
+												case 3:
+													if (!(_iteratorAbruptCompletion = !(_step = _state.sent()).done)) return [3, 5];
+													_value = _step.value;
+													chunk = _value;
+													started.resolve();
+													console.table(chunk);
+													_state.label = 4;
+												case 4:
+													_iteratorAbruptCompletion = false;
+													return [3, 2];
+												case 5: return [3, 12];
+												case 6:
+													err = _state.sent();
+													_didIteratorError = true;
+													_iteratorError = err;
+													return [3, 12];
+												case 7:
+													_state.trys.push([
+														7,
+														,
+														10,
+														11
+													]);
+													if (!(_iteratorAbruptCompletion && _iterator.return != null)) return [3, 9];
+													return [4, _iterator.return()];
+												case 8:
+													_state.sent();
+													_state.label = 9;
+												case 9: return [3, 11];
+												case 10:
+													if (_didIteratorError) throw _iteratorError;
+													return [7];
+												case 11: return [7];
+												case 12: return [3, 14];
+												case 13:
+													error = _state.sent();
+													started.reject(error);
+													return [3, 14];
+												case 14: return [2];
+											}
+										});
+									})();
+								})();
+								return [4, started.promise];
+							case 2:
+								_state.sent();
+								return [2, this.stream = outerStream];
+						}
+					});
+				}).apply(this, arguments);
+			}
+		},
+		{
+			key: "pause",
+			value: function pause() {
+				return _async_to_generator$1(function() {
+					return _ts_generator$2(this, function(_state) {
+						this.executing = false;
+						return [2];
+					});
+				}).call(this);
+			}
+		},
+		{
+			key: "destroy",
+			value: function destroy1() {
+				return _async_to_generator$1(function() {
+					return _ts_generator$2(this, function(_state) {
+						switch (_state.label) {
+							case 0: return [4, this.pause()];
+							case 1:
+								_state.sent();
+								return [2, (0, mobx_restful.destroy)(this, this.id)];
+						}
+					});
+				}).call(this);
+			}
+		}
+	], [{
+		key: "nameOf",
+		value: function nameOf(URI) {
+			return (0, web_utility.fileNameOf)(URI);
+		}
+	}]);
+	return DownloadTask;
+}();
+var ref2 = _sliced_to_array$1(_apply_decs_2203_r$1(DownloadTask, [
+	[
+		[_dec$1, observable$1],
+		1,
+		"id"
+	],
+	[
+		[_dec1, observable$1],
+		1,
+		"name"
+	],
+	[
+		[_dec2, observable$1],
+		1,
+		"path"
+	],
+	[
+		[_dec3, ref],
+		1,
+		"fsHandle"
+	],
+	[
+		[_dec4, observable$1],
+		1,
+		"total"
+	],
+	[
+		[_dec5, observable$1],
+		1,
+		"loaded"
+	],
+	[
+		[_dec6, observable$1],
+		1,
+		"percent"
+	],
+	[
+		observable$1,
+		1,
+		"executing"
+	],
+	[
+		[_dec7, observable$1],
+		1,
+		"options"
+	],
+	[
+		computed$1,
+		3,
+		"totalSize"
+	],
+	[
+		computed$1,
+		3,
+		"loadedSize"
+	]
+], []).e, 10);
+_init_id = ref2[0], _init_name = ref2[1], _init_path = ref2[2], _init_fsHandle = ref2[3], _init_total = ref2[4], _init_loaded = ref2[5], _init_percent = ref2[6], _init_executing = ref2[7], _init_options = ref2[8], _initProto$1 = ref2[9];
+function _assert_this_initialized(self) {
+	if (self === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+	return self;
+}
+function _async_generator(gen) {
+	var front, back;
+	function send(key, arg) {
+		return new Promise(function(resolve, reject) {
+			var request = {
+				key,
+				arg,
+				resolve,
+				reject,
+				next: null
+			};
+			if (back) back = back.next = request;
+			else {
+				front = back = request;
+				resume(key, arg);
+			}
+		});
+	}
+	function resume(key, arg) {
+		try {
+			var result = gen[key](arg);
+			var value = result.value;
+			var overloaded = _instanceof(value, _overload_yield);
+			Promise.resolve(overloaded ? value.v : value).then(function(arg) {
+				if (overloaded) {
+					var nextKey = key === "return" ? "return" : "next";
+					if (!value.k || arg.done) return resume(nextKey, arg);
+					else arg = gen[nextKey](arg).value;
+				}
+				settle(result.done ? "return" : "normal", arg);
+			}, function(err) {
+				resume("throw", err);
+			});
+		} catch (err) {
+			settle("throw", err);
+		}
+	}
+	function settle(type, value) {
+		switch (type) {
+			case "return":
+				front.resolve({
+					value,
+					done: true
+				});
+				break;
+			case "throw":
+				front.reject(value);
+				break;
+			default: front.resolve({
+				value,
+				done: false
+			});
+		}
+		front = front.next;
+		if (front) resume(front.key, front.arg);
+		else back = null;
+	}
+	this._invoke = send;
+	if (typeof gen.return !== "function") this.return = void 0;
+}
+_async_generator.prototype[typeof Symbol === "function" && Symbol.asyncIterator || "@@asyncIterator"] = function() {
+	return this;
+};
+_async_generator.prototype.next = function(arg) {
+	return this._invoke("next", arg);
+};
+_async_generator.prototype.throw = function(arg) {
+	return this._invoke("throw", arg);
+};
+_async_generator.prototype.return = function(arg) {
+	return this._invoke("return", arg);
+};
+function _async_iterator(iterable) {
+	var method, async, sync, retry = 2;
+	for ("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) {
+		if (async && null != (method = iterable[async])) return method.call(iterable);
+		if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));
+		async = "@@asyncIterator", sync = "@@iterator";
+	}
+	throw new TypeError("Object is not async iterable");
+}
+function AsyncFromSyncIterator(s) {
+	function AsyncFromSyncIteratorContinuation(r) {
+		if (Object(r) !== r) return Promise.reject(/* @__PURE__ */ new TypeError(r + " is not an object."));
+		var done = r.done;
+		return Promise.resolve(r.value).then(function(value) {
+			return {
+				value,
+				done
+			};
+		});
+	}
+	return AsyncFromSyncIterator = function AsyncFromSyncIterator(s) {
+		this.s = s, this.n = s.next;
+	}, AsyncFromSyncIterator.prototype = {
+		s: null,
+		n: null,
+		next: function next() {
+			return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+		},
+		return: function _return(value) {
+			var ret = this.s.return;
+			return void 0 === ret ? Promise.resolve({
+				value,
+				done: !0
+			}) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
+		},
+		throw: function _throw(value) {
+			var thr = this.s.return;
+			return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
+		}
+	}, new AsyncFromSyncIterator(s);
+}
+function _await_async_generator(value) {
+	return new _overload_yield(value, 0);
+}
+function _call_super(_this, derived, args) {
+	derived = _get_prototype_of(derived);
+	return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$1(instance, Constructor) {
+	if (!_instanceof(instance, Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties$1(target, props) {
+	for (var i = 0; i < props.length; i++) {
+		var descriptor = props[i];
+		descriptor.enumerable = descriptor.enumerable || false;
+		descriptor.configurable = true;
+		if ("value" in descriptor) descriptor.writable = true;
+		Object.defineProperty(target, descriptor.key, descriptor);
+	}
+}
+function _create_class$1(Constructor, protoProps, staticProps) {
+	if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+	if (staticProps) _defineProperties$1(Constructor, staticProps);
+	return Constructor;
+}
+function _define_property$1(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+	else obj[key] = value;
+	return obj;
+}
+function _get_prototype_of(o) {
+	_get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+		return o.__proto__ || Object.getPrototypeOf(o);
+	};
+	return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+	if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function");
+	subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+		value: subClass,
+		writable: true,
+		configurable: true
+	} });
+	if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _is_native_reflect_construct() {
+	try {
+		var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+	} catch (_) {}
+	return (_is_native_reflect_construct = function _is_native_reflect_construct() {
+		return !!result;
+	})();
+}
+function _object_spread(target) {
+	for (var i = 1; i < arguments.length; i++) {
+		var source = arguments[i] != null ? arguments[i] : {};
+		var ownKeys = Object.keys(source);
+		if (typeof Object.getOwnPropertySymbols === "function") ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+			return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+		}));
+		ownKeys.forEach(function(key) {
+			_define_property$1(target, key, source[key]);
+		});
+	}
+	return target;
+}
+function _overload_yield(value, kind) {
+	this.v = value;
+	this.k = kind;
+}
+function _possible_constructor_return(self, call) {
+	if (call && (_type_of1(call) === "object" || typeof call === "function")) return call;
+	return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+	_set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+		o.__proto__ = p;
+		return o;
+	};
+	return _set_prototype_of(o, p);
+}
+function _ts_generator$1(thisArg, body) {
+	var f, y, t, _ = {
+		label: 0,
+		sent: function sent() {
+			if (t[0] & 1) throw t[1];
+			return t[1];
+		},
+		trys: [],
+		ops: []
+	}, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+	return d(g, "next", { value: verb(0) }), d(g, "throw", { value: verb(1) }), d(g, "return", { value: verb(2) }), typeof Symbol === "function" && d(g, Symbol.iterator, { value: function value() {
+		return this;
+	} }), g;
+	function verb(n) {
+		return function(v) {
+			return step([n, v]);
+		};
+	}
+	function step(op) {
+		if (f) throw new TypeError("Generator is already executing.");
+		while (g && (g = 0, op[0] && (_ = 0)), _) try {
+			if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+			if (y = 0, t) op = [op[0] & 2, t.value];
+			switch (op[0]) {
+				case 0:
+				case 1:
+					t = op;
+					break;
+				case 4:
+					_.label++;
+					return {
+						value: op[1],
+						done: false
+					};
+				case 5:
+					_.label++;
+					y = op[1];
+					op = [0];
+					continue;
+				case 7:
+					op = _.ops.pop();
+					_.trys.pop();
+					continue;
+				default:
+					if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+						_ = 0;
+						continue;
+					}
+					if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+						_.label = op[1];
+						break;
+					}
+					if (op[0] === 6 && _.label < t[1]) {
+						_.label = t[1];
+						t = op;
+						break;
+					}
+					if (t && _.label < t[2]) {
+						_.label = t[2];
+						_.ops.push(op);
+						break;
+					}
+					if (t[2]) _.ops.pop();
+					_.trys.pop();
+					continue;
+			}
+			op = body.call(thisArg, _);
+		} catch (e) {
+			op = [6, e];
+			y = 0;
+		} finally {
+			f = t = 0;
+		}
+		if (op[0] & 5) throw op[1];
+		return {
+			value: op[0] ? op[1] : void 0,
+			done: true
+		};
+	}
+}
+function _type_of1(obj) {
+	"@swc/helpers - typeof";
+	return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_async_generator(fn) {
+	return function() {
+		return new _async_generator(fn.apply(this, arguments));
+	};
+}
+var HTTPDownloadTask = function(DownloadTask1) {
+	"use strict";
+	_inherits(HTTPDownloadTask, DownloadTask1);
+	function HTTPDownloadTask(path, name) {
+		_class_call_check$1(this, HTTPDownloadTask);
+		var _this = _call_super(this, HTTPDownloadTask, [path, name]);
+		_define_property$1(_this, "client", new koajax.HTTPClient({ responseType: "arraybuffer" }));
+		_this.id = "http-download-task-".concat(_this.name);
+		(0, mobx_restful.restore)(_this, _this.id);
+		return _this;
+	}
+	_create_class$1(HTTPDownloadTask, [{
+		key: "loadStream",
+		value: function loadStream(options) {
+			return _wrap_async_generator(function() {
+				var path, suggestedName, _tmp, _, writer, stream, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, chunk, err;
+				return _ts_generator$1(this, function(_state) {
+					switch (_state.label) {
+						case 0:
+							path = this.path;
+							suggestedName = DownloadTask.nameOf(path);
+							_tmp = this.fsHandle;
+							if (_tmp) return [3, 3];
+							_ = this;
+							return [4, _await_async_generator(import("native-file-system-adapter"))];
+						case 1: return [4, _await_async_generator.apply(void 0, [_state.sent().showSaveFilePicker({ suggestedName })])];
+						case 2:
+							_tmp = _.fsHandle = _state.sent();
+							_state.label = 3;
+						case 3: return [4, _await_async_generator(this.fsHandle.createWritable({ keepExistingData: true }))];
+						case 4:
+							writer = _state.sent(), stream = this.client.download(path, _object_spread({ range: [this.loaded] }, options));
+							_state.label = 5;
+						case 5:
+							_state.trys.push([
+								5,
+								,
+								20,
+								22
+							]);
+							this.executing = true;
+							_iteratorAbruptCompletion = false, _didIteratorError = false;
+							_state.label = 6;
+						case 6:
+							_state.trys.push([
+								6,
+								13,
+								14,
+								19
+							]);
+							_iterator = _async_iterator(stream);
+							_state.label = 7;
+						case 7: return [4, _await_async_generator(_iterator.next())];
+						case 8:
+							if (!(_iteratorAbruptCompletion = !(_step = _state.sent()).done)) return [3, 12];
+							_value = _step.value;
+							chunk = _value;
+							return [4, _await_async_generator(writer.write({
+								type: "write",
+								position: this.loaded,
+								data: chunk.buffer
+							}))];
+						case 9:
+							_state.sent();
+							return [4, this.saveMeta(chunk)];
+						case 10:
+							_state.sent();
+							if (!this.executing) return [3, 12];
+							_state.label = 11;
+						case 11:
+							_iteratorAbruptCompletion = false;
+							return [3, 7];
+						case 12: return [3, 19];
+						case 13:
+							err = _state.sent();
+							_didIteratorError = true;
+							_iteratorError = err;
+							return [3, 19];
+						case 14:
+							_state.trys.push([
+								14,
+								,
+								17,
+								18
+							]);
+							if (!(_iteratorAbruptCompletion && _iterator.return != null)) return [3, 16];
+							return [4, _await_async_generator(_iterator.return())];
+						case 15:
+							_state.sent();
+							_state.label = 16;
+						case 16: return [3, 18];
+						case 17:
+							if (_didIteratorError) throw _iteratorError;
+							return [7];
+						case 18: return [7];
+						case 19: return [3, 22];
+						case 20: return [4, _await_async_generator(writer.close())];
+						case 21:
+							_state.sent();
+							this.executing = false;
+							return [7];
+						case 22: return [2];
+					}
+				});
+			}).call(this);
+		}
+	}]);
+	return HTTPDownloadTask;
+}(DownloadTask);
+function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+		return function addInitializer(initializer) {
+			assertNotFinished(decoratorFinishedRef, "addInitializer");
+			assertCallable(initializer, "An initializer");
+			initializers.push(initializer);
+		};
+	}
+	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+		var kindStr;
+		switch (kind) {
+			case 1:
+				kindStr = "accessor";
+				break;
+			case 2:
+				kindStr = "method";
+				break;
+			case 3:
+				kindStr = "getter";
+				break;
+			case 4:
+				kindStr = "setter";
+				break;
+			default: kindStr = "field";
+		}
+		var ctx = {
+			kind: kindStr,
+			name: isPrivate ? "#" + name : name,
+			static: isStatic,
+			private: isPrivate,
+			metadata
+		};
+		var decoratorFinishedRef = { v: false };
+		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+		var get, set;
+		if (kind === 0) {
+			if (isPrivate) {
+				get = desc.get;
+				set = desc.set;
+			} else {
+				get = function get() {
+					return this[name];
+				};
+				set = function set(v) {
+					this[name] = v;
+				};
+			}
+		} else if (kind === 2) get = function get() {
+			return desc.value;
+		};
+		else {
+			if (kind === 1 || kind === 3) get = function get() {
+				return desc.get.call(this);
+			};
+			if (kind === 1 || kind === 4) set = function set(v) {
+				desc.set.call(this, v);
+			};
+		}
+		if (get) {
+			var originalGet = get;
+			get = function get(target) {
+				if (arguments.length === 0) target = this;
+				return originalGet.call(target);
+			};
+		}
+		if (set) {
+			var originalSet = set;
+			set = function set(target, value) {
+				if (arguments.length === 1) {
+					value = target;
+					target = this;
+				}
+				return originalSet.call(target, value);
+			};
+		}
+		if (isPrivate) ctx.access = get && set ? {
+			get,
+			set
+		} : get ? { get } : { set };
+		else {
+			var has = function has(target) {
+				return name in target;
+			};
+			ctx.access = get && set ? {
+				has,
+				get,
+				set
+			} : get ? {
+				has,
+				get
+			} : {
+				has,
+				set
+			};
+		}
+		var newValue = dec(value, ctx);
+		decoratorFinishedRef.v = true;
+		return newValue;
+	}
+	function assertNotFinished(decoratorFinishedRef, fnName) {
+		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+	}
+	function assertCallable(fn, hint) {
+		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
+	}
+	function assertValidReturnValue(kind, value) {
+		var type = typeof value === "undefined" ? "undefined" : _type_of(value);
+		if (kind === 1) {
+			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
+			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
+			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
+		} else if (type !== "function") {
+			var hint;
+			if (kind === 0) hint = "field";
+			else if (kind === 10) hint = "class";
+			else hint = "method";
+			throw new TypeError(hint + " decorators must return a function or void 0");
+		}
+	}
+	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+		var decs = decInfo[0];
+		var desc, init, value;
+		if (isPrivate) {
+			if (kind === 0 || kind === 1) desc = {
+				get: decInfo[3],
+				set: decInfo[4]
+			};
+			else if (kind === 3) desc = { get: decInfo[3] };
+			else if (kind === 4) desc = { set: decInfo[3] };
+			else desc = { value: decInfo[3] };
+		} else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
+		if (kind === 1) value = {
+			get: desc.get,
+			set: desc.set
+		};
+		else if (kind === 2) value = desc.value;
+		else if (kind === 3) value = desc.get;
+		else if (kind === 4) value = desc.set;
+		var newValue, get, set;
+		if (typeof decs === "function") {
+			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				if (kind === 0) init = newValue;
+				else if (kind === 1) {
+					init = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+			}
+		} else for (var i = decs.length - 1; i >= 0; i--) {
+			var dec = decs[i];
+			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				var newInit;
+				if (kind === 0) newInit = newValue;
+				else if (kind === 1) {
+					newInit = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+				if (newInit !== void 0) {
+					if (init === void 0) init = newInit;
+					else if (typeof init === "function") init = [init, newInit];
+					else init.push(newInit);
+				}
+			}
+		}
+		if (kind === 0 || kind === 1) {
+			if (init === void 0) init = function init(instance, init) {
+				return init;
+			};
+			else if (typeof init !== "function") {
+				var ownInitializers = init;
+				init = function init(instance, init) {
+					var value = init;
+					for (var i = 0; i < ownInitializers.length; i++) value = ownInitializers[i].call(instance, value);
+					return value;
+				};
+			} else {
+				var originalInitializer = init;
+				init = function init(instance, init) {
+					return originalInitializer.call(instance, init);
+				};
+			}
+			ret.push(init);
+		}
+		if (kind !== 0) {
+			if (kind === 1) {
+				desc.get = value.get;
+				desc.set = value.set;
+			} else if (kind === 2) desc.value = value;
+			else if (kind === 3) desc.get = value;
+			else if (kind === 4) desc.set = value;
+			if (isPrivate) {
+				if (kind === 1) {
+					ret.push(function(instance, args) {
+						return value.get.call(instance, args);
+					});
+					ret.push(function(instance, args) {
+						return value.set.call(instance, args);
+					});
+				} else if (kind === 2) ret.push(value);
+				else ret.push(function(instance, args) {
+					return value.call(instance, args);
+				});
+			} else Object.defineProperty(base, name, desc);
+		}
+	}
+	function applyMemberDecs(Class, decInfos, metadata) {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var existingProtoNonFields = /* @__PURE__ */ new Map();
+		var existingStaticNonFields = /* @__PURE__ */ new Map();
+		for (var i = 0; i < decInfos.length; i++) {
+			var decInfo = decInfos[i];
+			if (!Array.isArray(decInfo)) continue;
+			var kind = decInfo[1];
+			var name = decInfo[2];
+			var isPrivate = decInfo.length > 3;
+			var isStatic = kind >= 5;
+			var base;
+			var initializers;
+			if (isStatic) {
+				base = Class;
+				kind = kind - 5;
+				staticInitializers = staticInitializers || [];
+				initializers = staticInitializers;
+			} else {
+				base = Class.prototype;
+				protoInitializers = protoInitializers || [];
+				initializers = protoInitializers;
+			}
+			if (kind !== 0 && !isPrivate) {
+				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+				var existingKind = existingNonFields.get(name) || 0;
+				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+				else existingNonFields.set(name, true);
+			}
+			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+		}
+		pushInitializers(ret, protoInitializers);
+		pushInitializers(ret, staticInitializers);
+		return ret;
+	}
+	function pushInitializers(ret, initializers) {
+		if (initializers) ret.push(function(instance) {
+			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+			return instance;
+		});
+	}
+	function applyClassDecs(targetClass, classDecs, metadata) {
+		if (classDecs.length > 0) {
+			var initializers = [];
+			var newClass = targetClass;
+			var name = targetClass.name;
+			for (var i = classDecs.length - 1; i >= 0; i--) {
+				var decoratorFinishedRef = { v: false };
+				var nextNewClass = classDecs[i](newClass, {
+					kind: "class",
+					name,
+					addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+					metadata
+				});
+				decoratorFinishedRef.v = true;
+				if (nextNewClass !== void 0) {
+					assertValidReturnValue(10, nextNewClass);
+					newClass = nextNewClass;
+				}
+			}
+			return [defineMetadata(newClass, metadata), function() {
+				for (var i = 0; i < initializers.length; i++) initializers[i].call(newClass);
+			}];
+		}
+	}
+	function defineMetadata(Class, metadata) {
+		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	_apply_decs_2203_r = function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+		var e = applyMemberDecs(targetClass, memberDecs, metadata);
+		if (!classDecs.length) defineMetadata(targetClass, metadata);
+		return {
+			e,
+			get c() {
+				return applyClassDecs(targetClass, classDecs, metadata);
+			}
+		};
+	};
+	return _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass);
+}
+function _array_like_to_array(arr, len) {
+	if (len == null || len > arr.length) len = arr.length;
+	for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+	return arr2;
+}
+function _array_with_holes(arr) {
+	if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+	if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+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 _async_to_generator(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(void 0);
+		});
+	};
+}
+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_call_check(instance, Constructor) {
+	if (!_instanceof(instance, Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+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) {
+	return _class_apply_descriptor_get(receiver, _class_extract_field_descriptor(receiver, privateMap, "get"));
+}
+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) {
+	_class_apply_descriptor_set(receiver, _class_extract_field_descriptor(receiver, privateMap, "set"), value);
+	return value;
+}
+function _defineProperties(target, props) {
+	for (var i = 0; i < props.length; i++) {
+		var descriptor = props[i];
+		descriptor.enumerable = descriptor.enumerable || false;
+		descriptor.configurable = true;
+		if ("value" in descriptor) descriptor.writable = true;
+		Object.defineProperty(target, descriptor.key, descriptor);
+	}
+}
+function _create_class(Constructor, protoProps, staticProps) {
+	if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+	if (staticProps) _defineProperties(Constructor, staticProps);
+	return Constructor;
+}
+function _define_property(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+	else obj[key] = value;
+	return obj;
+}
+function _iterable_to_array(iter) {
+	if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+	var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+	if (_i == null) return;
+	var _arr = [];
+	var _n = true;
+	var _d = false;
+	var _s, _e;
+	try {
+		for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+			_arr.push(_s.value);
+			if (i && _arr.length === i) break;
+		}
+	} catch (err) {
+		_d = true;
+		_e = err;
+	} finally {
+		try {
+			if (!_n && _i["return"] != null) _i["return"]();
+		} finally {
+			if (_d) throw _e;
+		}
+	}
+	return _arr;
+}
+function _non_iterable_rest() {
+	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+	throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+	return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+	return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _ts_generator(thisArg, body) {
+	var f, y, t, _ = {
+		label: 0,
+		sent: function sent() {
+			if (t[0] & 1) throw t[1];
+			return t[1];
+		},
+		trys: [],
+		ops: []
+	}, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+	return d(g, "next", { value: verb(0) }), d(g, "throw", { value: verb(1) }), d(g, "return", { value: verb(2) }), typeof Symbol === "function" && d(g, Symbol.iterator, { value: function value() {
+		return this;
+	} }), g;
+	function verb(n) {
+		return function(v) {
+			return step([n, v]);
+		};
+	}
+	function step(op) {
+		if (f) throw new TypeError("Generator is already executing.");
+		while (g && (g = 0, op[0] && (_ = 0)), _) try {
+			if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+			if (y = 0, t) op = [op[0] & 2, t.value];
+			switch (op[0]) {
+				case 0:
+				case 1:
+					t = op;
+					break;
+				case 4:
+					_.label++;
+					return {
+						value: op[1],
+						done: false
+					};
+				case 5:
+					_.label++;
+					y = op[1];
+					op = [0];
+					continue;
+				case 7:
+					op = _.ops.pop();
+					_.trys.pop();
+					continue;
+				default:
+					if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+						_ = 0;
+						continue;
+					}
+					if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+						_.label = op[1];
+						break;
+					}
+					if (op[0] === 6 && _.label < t[1]) {
+						_.label = t[1];
+						t = op;
+						break;
+					}
+					if (t && _.label < t[2]) {
+						_.label = t[2];
+						_.ops.push(op);
+						break;
+					}
+					if (t[2]) _.ops.pop();
+					_.trys.pop();
+					continue;
+			}
+			op = body.call(thisArg, _);
+		} catch (e) {
+			op = [6, e];
+			y = 0;
+		} finally {
+			f = t = 0;
+		}
+		if (op[0] & 5) throw op[1];
+		return {
+			value: op[0] ? op[1] : void 0,
+			done: true
+		};
+	}
+}
+function _unsupported_iterable_to_array(o, minLen) {
+	if (!o) return;
+	if (typeof o === "string") return _array_like_to_array(o, minLen);
+	var n = Object.prototype.toString.call(o).slice(8, -1);
+	if (n === "Object" && o.constructor) n = o.constructor.name;
+	if (n === "Map" || n === "Set") return Array.from(o);
+	if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var _dec;
+var _init_tasks;
+var _initProto;
+_dec = (0, mobx_restful.persist)({
+	set: function set(tasks) {
+		return tasks.map(function(param) {
+			return {
+				name: param.name,
+				path: param.path
+			};
+		});
+	},
+	get: function get(list) {
+		return (list === null || list === void 0 ? void 0 : list.map(function(param) {
+			var name = param.name, path = param.path;
+			return Downloader.createTask(path, name);
+		})) || [];
+	}
+});
+var ____private_tasks_1 = /* @__PURE__ */ new WeakMap();
+var Downloader = function() {
+	"use strict";
+	function Downloader() {
+		_class_call_check(this, Downloader);
+		_class_private_field_init(this, ____private_tasks_1, {
+			writable: true,
+			value: (_initProto(this), _init_tasks(this, []))
+		});
+		(0, mobx_restful.restore)(this, "downloader");
+	}
+	_create_class(Downloader, [
+		{
+			key: "tasks",
+			get: function get() {
+				return _class_private_field_get(this, ____private_tasks_1);
+			},
+			set: function set(_v) {
+				_class_private_field_set(this, ____private_tasks_1, _v);
+			}
+		},
+		{
+			key: "unfinishedCount",
+			get: function get() {
+				return this.tasks.filter(function(param) {
+					return param.percent < 100;
+				}).length;
+			}
+		},
+		{
+			key: "executingCount",
+			get: function get() {
+				return this.tasks.filter(function(param) {
+					return param.executing;
+				}).length;
+			}
+		},
+		{
+			key: "createTask",
+			value: function createTask(path, name) {
+				var tasks = this.tasks;
+				var sameTask = tasks.find(function(task) {
+					return task.path === path;
+				});
+				if (sameTask) return sameTask;
+				var task = Downloader.createTask(path, name);
+				this.tasks = _to_consumable_array(tasks).concat([task]);
+				return task;
+			}
+		},
+		{
+			key: "destroyTask",
+			value: function destroyTask(name) {
+				return _async_to_generator(function() {
+					var tasks, index;
+					return _ts_generator(this, function(_state) {
+						switch (_state.label) {
+							case 0:
+								tasks = this.tasks;
+								index = tasks.findIndex(function(param) {
+									return param.name === name;
+								});
+								if (index < 0) throw new ReferenceError("".concat(name, " isn't found"));
+								return [4, tasks[index].destroy()];
+							case 1:
+								_state.sent();
+								this.tasks = _to_consumable_array(tasks.slice(0, index)).concat(_to_consumable_array(tasks.slice(index + 1)));
+								return [2];
+						}
+					});
+				}).call(this);
+			}
+		}
+	], [{
+		key: "createTask",
+		value: function createTask(path, name) {
+			var protocol = _sliced_to_array(path.split(":"), 1)[0];
+			var ProtocolTask = Downloader.protocolMap[protocol];
+			if (!ProtocolTask) throw new URIError("Protocol \"".concat(protocol, " has not been registered\""));
+			return new ProtocolTask(path, name);
+		}
+	}]);
+	return Downloader;
+}();
+var ref1 = _sliced_to_array(_apply_decs_2203_r(Downloader, [
+	[
+		[_dec, mobx.observable],
+		1,
+		"tasks"
+	],
+	[
+		mobx.computed,
+		3,
+		"unfinishedCount"
+	],
+	[
+		mobx.computed,
+		3,
+		"executingCount"
+	]
+], []).e, 2);
+_init_tasks = ref1[0], _initProto = ref1[1];
+_define_property(Downloader, "protocolMap", {
+	http: HTTPDownloadTask,
+	https: HTTPDownloadTask
+});
+exports.DownloadTask = DownloadTask;
+exports.Downloader = Downloader;
+exports.HTTPDownloadTask = HTTPDownloadTask;
+
+//# sourceMappingURL=index.cjs.map