MirrorMirror
/
lufi
mirror of https://framagit.org/fiat-tux/hat-softwares/lufi.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
lufi/themes/default/public/js/worker/remove.js

930 lines
30 KiB
JavaScript
Raw Blame History

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 __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
// node_modules/.deno/events@3.3.0/node_modules/events/events.js
var require_events = __commonJS({
"node_modules/.deno/events@3.3.0/node_modules/events/events.js"(exports, module) {
"use strict";
var R = typeof Reflect === "object" ? Reflect : null;
var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
return Function.prototype.apply.call(target, receiver, args);
};
var ReflectOwnKeys;
if (R && typeof R.ownKeys === "function") {
ReflectOwnKeys = R.ownKeys;
} else if (Object.getOwnPropertySymbols) {
ReflectOwnKeys = function ReflectOwnKeys2(target) {
return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
};
} else {
ReflectOwnKeys = function ReflectOwnKeys2(target) {
return Object.getOwnPropertyNames(target);
};
}
function ProcessEmitWarning(warning) {
if (console && console.warn) console.warn(warning);
}
var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
return value !== value;
};
function EventEmitter2() {
EventEmitter2.init.call(this);
}
module.exports = EventEmitter2;
module.exports.once = once;
EventEmitter2.EventEmitter = EventEmitter2;
EventEmitter2.prototype._events = void 0;
EventEmitter2.prototype._eventsCount = 0;
EventEmitter2.prototype._maxListeners = void 0;
var defaultMaxListeners = 10;
function checkListener(listener) {
if (typeof listener !== "function") {
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
}
}
Object.defineProperty(EventEmitter2, "defaultMaxListeners", {
enumerable: true,
get: function() {
return defaultMaxListeners;
},
set: function(arg) {
if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
}
defaultMaxListeners = arg;
}
});
EventEmitter2.init = function() {
if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
this._events = /* @__PURE__ */ Object.create(null);
this._eventsCount = 0;
}
this._maxListeners = this._maxListeners || void 0;
};
EventEmitter2.prototype.setMaxListeners = function setMaxListeners(n) {
if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
}
this._maxListeners = n;
return this;
};
function _getMaxListeners(that) {
if (that._maxListeners === void 0)
return EventEmitter2.defaultMaxListeners;
return that._maxListeners;
}
EventEmitter2.prototype.getMaxListeners = function getMaxListeners() {
return _getMaxListeners(this);
};
EventEmitter2.prototype.emit = function emit(type) {
var args = [];
for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
var doError = type === "error";
var events2 = this._events;
if (events2 !== void 0)
doError = doError && events2.error === void 0;
else if (!doError)
return false;
if (doError) {
var er;
if (args.length > 0)
er = args[0];
if (er instanceof Error) {
throw er;
}
var err2 = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
err2.context = er;
throw err2;
}
var handler = events2[type];
if (handler === void 0)
return false;
if (typeof handler === "function") {
ReflectApply(handler, this, args);
} else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
ReflectApply(listeners[i], this, args);
}
return true;
};
function _addListener(target, type, listener, prepend) {
var m;
var events2;
var existing;
checkListener(listener);
events2 = target._events;
if (events2 === void 0) {
events2 = target._events = /* @__PURE__ */ Object.create(null);
target._eventsCount = 0;
} else {
if (events2.newListener !== void 0) {
target.emit(
"newListener",
type,
listener.listener ? listener.listener : listener
);
events2 = target._events;
}
existing = events2[type];
}
if (existing === void 0) {
existing = events2[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === "function") {
existing = events2[type] = prepend ? [listener, existing] : [existing, listener];
} else if (prepend) {
existing.unshift(listener);
} else {
existing.push(listener);
}
m = _getMaxListeners(target);
if (m > 0 && existing.length > m && !existing.warned) {
existing.warned = true;
var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
w.name = "MaxListenersExceededWarning";
w.emitter = target;
w.type = type;
w.count = existing.length;
ProcessEmitWarning(w);
}
}
return target;
}
EventEmitter2.prototype.addListener = function addListener(type, listener) {
return _addListener(this, type, listener, false);
};
EventEmitter2.prototype.on = EventEmitter2.prototype.addListener;
EventEmitter2.prototype.prependListener = function prependListener(type, listener) {
return _addListener(this, type, listener, true);
};
function onceWrapper() {
if (!this.fired) {
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
if (arguments.length === 0)
return this.listener.call(this.target);
return this.listener.apply(this.target, arguments);
}
}
function _onceWrap(target, type, listener) {
var state = { fired: false, wrapFn: void 0, target, type, listener };
var wrapped = onceWrapper.bind(state);
wrapped.listener = listener;
state.wrapFn = wrapped;
return wrapped;
}
EventEmitter2.prototype.once = function once2(type, listener) {
checkListener(listener);
this.on(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter2.prototype.prependOnceListener = function prependOnceListener(type, listener) {
checkListener(listener);
this.prependListener(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter2.prototype.removeListener = function removeListener(type, listener) {
var list, events2, position, i, originalListener;
checkListener(listener);
events2 = this._events;
if (events2 === void 0)
return this;
list = events2[type];
if (list === void 0)
return this;
if (list === listener || list.listener === listener) {
if (--this._eventsCount === 0)
this._events = /* @__PURE__ */ Object.create(null);
else {
delete events2[type];
if (events2.removeListener)
this.emit("removeListener", type, list.listener || listener);
}
} else if (typeof list !== "function") {
position = -1;
for (i = list.length - 1; i >= 0; i--) {
if (list[i] === listener || list[i].listener === listener) {
originalListener = list[i].listener;
position = i;
break;
}
}
if (position < 0)
return this;
if (position === 0)
list.shift();
else {
spliceOne(list, position);
}
if (list.length === 1)
events2[type] = list[0];
if (events2.removeListener !== void 0)
this.emit("removeListener", type, originalListener || listener);
}
return this;
};
EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
EventEmitter2.prototype.removeAllListeners = function removeAllListeners(type) {
var listeners, events2, i;
events2 = this._events;
if (events2 === void 0)
return this;
if (events2.removeListener === void 0) {
if (arguments.length === 0) {
this._events = /* @__PURE__ */ Object.create(null);
this._eventsCount = 0;
} else if (events2[type] !== void 0) {
if (--this._eventsCount === 0)
this._events = /* @__PURE__ */ Object.create(null);
else
delete events2[type];
}
return this;
}
if (arguments.length === 0) {
var keys = Object.keys(events2);
var key;
for (i = 0; i < keys.length; ++i) {
key = keys[i];
if (key === "removeListener") continue;
this.removeAllListeners(key);
}
this.removeAllListeners("removeListener");
this._events = /* @__PURE__ */ Object.create(null);
this._eventsCount = 0;
return this;
}
listeners = events2[type];
if (typeof listeners === "function") {
this.removeListener(type, listeners);
} else if (listeners !== void 0) {
for (i = listeners.length - 1; i >= 0; i--) {
this.removeListener(type, listeners[i]);
}
}
return this;
};
function _listeners(target, type, unwrap) {
var events2 = target._events;
if (events2 === void 0)
return [];
var evlistener = events2[type];
if (evlistener === void 0)
return [];
if (typeof evlistener === "function")
return unwrap ? [evlistener.listener || evlistener] : [evlistener];
return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
}
EventEmitter2.prototype.listeners = function listeners(type) {
return _listeners(this, type, true);
};
EventEmitter2.prototype.rawListeners = function rawListeners(type) {
return _listeners(this, type, false);
};
EventEmitter2.listenerCount = function(emitter, type) {
if (typeof emitter.listenerCount === "function") {
return emitter.listenerCount(type);
} else {
return listenerCount.call(emitter, type);
}
};
EventEmitter2.prototype.listenerCount = listenerCount;
function listenerCount(type) {
var events2 = this._events;
if (events2 !== void 0) {
var evlistener = events2[type];
if (typeof evlistener === "function") {
return 1;
} else if (evlistener !== void 0) {
return evlistener.length;
}
}
return 0;
}
EventEmitter2.prototype.eventNames = function eventNames() {
return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
};
function arrayClone(arr, n) {
var copy = new Array(n);
for (var i = 0; i < n; ++i)
copy[i] = arr[i];
return copy;
}
function spliceOne(list, index) {
for (; index + 1 < list.length; index++)
list[index] = list[index + 1];
list.pop();
}
function unwrapListeners(arr) {
var ret = new Array(arr.length);
for (var i = 0; i < ret.length; ++i) {
ret[i] = arr[i].listener || arr[i];
}
return ret;
}
function once(emitter, name) {
return new Promise(function(resolve, reject) {
function errorListener(err2) {
emitter.removeListener(name, resolver);
reject(err2);
}
function resolver() {
if (typeof emitter.removeListener === "function") {
emitter.removeListener("error", errorListener);
}
resolve([].slice.call(arguments));
}
;
eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
if (name !== "error") {
addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
}
});
}
function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
if (typeof emitter.on === "function") {
eventTargetAgnosticAddListener(emitter, "error", handler, flags);
}
}
function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
if (typeof emitter.on === "function") {
if (flags.once) {
emitter.once(name, listener);
} else {
emitter.on(name, listener);
}
} else if (typeof emitter.addEventListener === "function") {
emitter.addEventListener(name, function wrapListener(arg) {
if (flags.once) {
emitter.removeEventListener(name, wrapListener);
}
listener(arg);
});
} else {
throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
}
}
}
});
// node_modules/.deno/neverthrow@8.0.0/node_modules/neverthrow/dist/index.es.js
var defaultErrorConfig = {
withStackTrace: false
};
var createNeverThrowError = (message, result, config = defaultErrorConfig) => {
const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
const maybeStack = config.withStackTrace ? new Error().stack : void 0;
return {
data,
message,
stack: maybeStack
};
};
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P ? value : new P(function(resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function(resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator["throw"](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, [])).next());
});
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function() {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
return this;
}, i;
function verb(n) {
if (g[n]) i[n] = function(v) {
return new Promise(function(a, b) {
q.push([n, v, a, b]) > 1 || resume(n, v);
});
};
}
function resume(n, v) {
try {
step(g[n](v));
} catch (e) {
settle(q[0][3], e);
}
}
function step(r) {
r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
}
function fulfill(value) {
resume("next", value);
}
function reject(value) {
resume("throw", value);
}
function settle(f, v) {
if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
}
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function(e) {
throw e;
}), verb("return"), i[Symbol.iterator] = function() {
return this;
}, i;
function verb(n, f) {
i[n] = o[n] ? function(v) {
return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v;
} : f;
}
}
function __asyncValues(o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
return this;
}, i);
function verb(n) {
i[n] = o[n] && function(v) {
return new Promise(function(resolve, reject) {
v = o[n](v), settle(resolve, reject, v.done, v.value);
});
};
}
function settle(resolve, reject, d, v) {
Promise.resolve(v).then(function(v2) {
resolve({ value: v2, done: d });
}, reject);
}
}
var ResultAsync = class _ResultAsync {
constructor(res) {
this._promise = res;
}
static fromSafePromise(promise) {
const newPromise = promise.then((value) => new Ok(value));
return new _ResultAsync(newPromise);
}
static fromPromise(promise, errorFn) {
const newPromise = promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e)));
return new _ResultAsync(newPromise);
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
static fromThrowable(fn, errorFn) {
return (...args) => {
return new _ResultAsync((() => __awaiter(this, void 0, void 0, function* () {
try {
return new Ok(yield fn(...args));
} catch (error) {
return new Err(errorFn ? errorFn(error) : error);
}
}))());
};
}
static combine(asyncResultList) {
return combineResultAsyncList(asyncResultList);
}
static combineWithAllErrors(asyncResultList) {
return combineResultAsyncListWithAllErrors(asyncResultList);
}
map(f) {
return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
if (res.isErr()) {
return new Err(res.error);
}
return new Ok(yield f(res.value));
})));
}
andThrough(f) {
return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
if (res.isErr()) {
return new Err(res.error);
}
const newRes = yield f(res.value);
if (newRes.isErr()) {
return new Err(newRes.error);
}
return new Ok(res.value);
})));
}
andTee(f) {
return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
if (res.isErr()) {
return new Err(res.error);
}
try {
yield f(res.value);
} catch (e) {
}
return new Ok(res.value);
})));
}
mapErr(f) {
return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
if (res.isOk()) {
return new Ok(res.value);
}
return new Err(yield f(res.error));
})));
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
andThen(f) {
return new _ResultAsync(this._promise.then((res) => {
if (res.isErr()) {
return new Err(res.error);
}
const newValue = f(res.value);
return newValue instanceof _ResultAsync ? newValue._promise : newValue;
}));
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
orElse(f) {
return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
if (res.isErr()) {
return f(res.error);
}
return new Ok(res.value);
})));
}
match(ok2, _err) {
return this._promise.then((res) => res.match(ok2, _err));
}
unwrapOr(t) {
return this._promise.then((res) => res.unwrapOr(t));
}
/**
* Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
*/
safeUnwrap() {
return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
});
}
// Makes ResultAsync implement PromiseLike<Result>
then(successCallback, failureCallback) {
return this._promise.then(successCallback, failureCallback);
}
};
var errAsync = (err2) => new ResultAsync(Promise.resolve(new Err(err2)));
var fromPromise = ResultAsync.fromPromise;
var fromSafePromise = ResultAsync.fromSafePromise;
var fromAsyncThrowable = ResultAsync.fromThrowable;
var combineResultList = (resultList) => {
let acc = ok([]);
for (const result of resultList) {
if (result.isErr()) {
acc = err(result.error);
break;
} else {
acc.map((list) => list.push(result.value));
}
}
return acc;
};
var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
var combineResultListWithAllErrors = (resultList) => {
let acc = ok([]);
for (const result of resultList) {
if (result.isErr() && acc.isErr()) {
acc.error.push(result.error);
} else if (result.isErr() && acc.isOk()) {
acc = err([result.error]);
} else if (result.isOk() && acc.isOk()) {
acc.value.push(result.value);
}
}
return acc;
};
var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
var Result;
(function(Result2) {
function fromThrowable2(fn, errorFn) {
return (...args) => {
try {
const result = fn(...args);
return ok(result);
} catch (e) {
return err(errorFn ? errorFn(e) : e);
}
};
}
Result2.fromThrowable = fromThrowable2;
function combine(resultList) {
return combineResultList(resultList);
}
Result2.combine = combine;
function combineWithAllErrors(resultList) {
return combineResultListWithAllErrors(resultList);
}
Result2.combineWithAllErrors = combineWithAllErrors;
})(Result || (Result = {}));
var ok = (value) => new Ok(value);
function err(err2) {
return new Err(err2);
}
var Ok = class {
constructor(value) {
this.value = value;
}
isOk() {
return true;
}
isErr() {
return !this.isOk();
}
map(f) {
return ok(f(this.value));
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
mapErr(_f) {
return ok(this.value);
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
andThen(f) {
return f(this.value);
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
andThrough(f) {
return f(this.value).map((_value) => this.value);
}
andTee(f) {
try {
f(this.value);
} catch (e) {
}
return ok(this.value);
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
orElse(_f) {
return ok(this.value);
}
asyncAndThen(f) {
return f(this.value);
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
asyncAndThrough(f) {
return f(this.value).map(() => this.value);
}
asyncMap(f) {
return ResultAsync.fromSafePromise(f(this.value));
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
unwrapOr(_v) {
return this.value;
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
match(ok2, _err) {
return ok2(this.value);
}
safeUnwrap() {
const value = this.value;
return function* () {
return value;
}();
}
_unsafeUnwrap(_) {
return this.value;
}
_unsafeUnwrapErr(config) {
throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config);
}
};
var Err = class {
constructor(error) {
this.error = error;
}
isOk() {
return false;
}
isErr() {
return !this.isOk();
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
map(_f) {
return err(this.error);
}
mapErr(f) {
return err(f(this.error));
}
andThrough(_f) {
return err(this.error);
}
andTee(_f) {
return err(this.error);
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
andThen(_f) {
return err(this.error);
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
orElse(f) {
return f(this.error);
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
asyncAndThen(_f) {
return errAsync(this.error);
}
asyncAndThrough(_f) {
return errAsync(this.error);
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
asyncMap(_f) {
return errAsync(this.error);
}
unwrapOr(v) {
return v;
}
match(_ok, err2) {
return err2(this.error);
}
safeUnwrap() {
const error = this.error;
return function* () {
yield err(error);
throw new Error("Do not use this generator out of `safeTry`");
}();
}
_unsafeUnwrap(config) {
throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
}
_unsafeUnwrapErr(_) {
return this.error;
}
};
var fromThrowable = Result.fromThrowable;
// src/utils.ts
var ensureError = (value) => {
if (value instanceof Error) return value;
let stringified = "[Unable to stringify the thrown value]";
try {
stringified = JSON.stringify(value);
} catch (_error) {
}
const error = new Error(stringified);
return error;
};
var isDenoRuntime = () => typeof Deno !== "undefined";
var workerUrl = (relativePath) => isDenoRuntime() ? new URL(`./worker/${relativePath}.ts`, new URL(".", import.meta.url).href) : new URL(
import.meta.resolve(
`./${relativePath === "main" ? `worker/${relativePath}` : relativePath}.js`
)
);
// src/worker/main.ts
var import_events = __toESM(require_events());
var events = new import_events.default();
var worker;
var isInitialized = false;
self.onmessage = (event) => {
addWorker(event);
if (!isInitialized) {
isInitialized = true;
events.once("OPERATION_FAILED" /* OPERATION_FAILED */, () => {
if (worker) {
worker.terminate();
}
});
}
};
var addWorker = (event, callback) => {
const { action } = event.data;
if (action === 5 /* PAUSE */ || action === 8 /* RESUME */) {
worker.postMessage(event.data);
} else {
switch (action) {
case 2 /* CANCEL */:
{
worker = new Worker(workerUrl("cancel"), { type: "module" });
worker.postMessage(event.data);
}
break;
case 3 /* DOWNLOAD */:
{
worker = new Worker(workerUrl("download"), { type: "module" });
worker.postMessage(event.data);
}
break;
case 4 /* INFOS */:
{
worker = new Worker(workerUrl("infos"), { type: "module" });
worker.postMessage(event.data);
}
break;
case 7 /* REMOVE */:
{
worker = worker || new Worker(workerUrl("remove"), { type: "module" });
worker.postMessage(event.data);
}
break;
case 9 /* UPLOAD */:
{
worker = worker || new Worker(workerUrl("upload"), { type: "module" });
worker.postMessage(event.data);
}
break;
default: {
console.error("Action not found");
}
}
worker.onmessage = (e) => {
if (callback) callback(e);
self.postMessage(e.data);
};
worker.onerror = (error) => {
console.error(`Error: ${error.message}`);
};
}
};
var init = () => {
events.once("SOCKET_OPENED" /* SOCKET_OPENED */, () => {
self.postMessage({
event: "SOCKET_OPENED" /* SOCKET_OPENED */
});
});
events.once("OPERATION_FAILED" /* OPERATION_FAILED */, (error) => {
self.postMessage({ event: "OPERATION_FAILED" /* OPERATION_FAILED */, error });
});
};
// src/worker/remove.ts
var isInitiated = false;
self.onmessage = (event) => {
if (!isInitiated) {
init();
isInitiated = true;
}
removeFile(event.data).map(() => {
self.postMessage({ event: "FILE_REMOVED" /* FILE_REMOVED */ });
}).mapErr((error) => {
self.postMessage({
event: "OPERATION_FAILED" /* OPERATION_FAILED */,
error
});
});
};
var removeFile = (workerMessage) => ResultAsync.fromPromise(
new Promise((resolve, reject) => {
const lufiFile = workerMessage.args.lufiFile;
fetch(
`${new URL(lufiFile.serverUrl).href}d/${lufiFile.keys.server}/${lufiFile.actionToken}`
).then((request) => request.ok ? resolve(void 0) : reject(request.statusText));
}),
(error) => ensureError(error)
);
Reference in New Issue View Git Blame Copy Permalink