3548 lines
116 KiB
JavaScript
Executable File
3548 lines
116 KiB
JavaScript
Executable File
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 __defNormalProp = (obj3, key, value) => key in obj3 ? __defProp(obj3, key, { enumerable: true, configurable: true, writable: true, value }) : obj3[key] = value;
|
|
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
|
|
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
|
|
}) : x)(function(x) {
|
|
if (typeof require !== "undefined") return require.apply(this, arguments);
|
|
throw Error('Dynamic require of "' + x + '" is not supported');
|
|
});
|
|
var __commonJS = (cb, mod) => function __require2() {
|
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
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
|
|
));
|
|
var __publicField = (obj3, key, value) => __defNormalProp(obj3, typeof key !== "symbol" ? key + "" : key, value);
|
|
|
|
// 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 EventEmitter3() {
|
|
EventEmitter3.init.call(this);
|
|
}
|
|
module.exports = EventEmitter3;
|
|
module.exports.once = once;
|
|
EventEmitter3.EventEmitter = EventEmitter3;
|
|
EventEmitter3.prototype._events = void 0;
|
|
EventEmitter3.prototype._eventsCount = 0;
|
|
EventEmitter3.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(EventEmitter3, "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;
|
|
}
|
|
});
|
|
EventEmitter3.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;
|
|
};
|
|
EventEmitter3.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 EventEmitter3.defaultMaxListeners;
|
|
return that._maxListeners;
|
|
}
|
|
EventEmitter3.prototype.getMaxListeners = function getMaxListeners() {
|
|
return _getMaxListeners(this);
|
|
};
|
|
EventEmitter3.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 err3 = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
|
|
err3.context = er;
|
|
throw err3;
|
|
}
|
|
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;
|
|
}
|
|
EventEmitter3.prototype.addListener = function addListener(type, listener) {
|
|
return _addListener(this, type, listener, false);
|
|
};
|
|
EventEmitter3.prototype.on = EventEmitter3.prototype.addListener;
|
|
EventEmitter3.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;
|
|
}
|
|
EventEmitter3.prototype.once = function once2(type, listener) {
|
|
checkListener(listener);
|
|
this.on(type, _onceWrap(this, type, listener));
|
|
return this;
|
|
};
|
|
EventEmitter3.prototype.prependOnceListener = function prependOnceListener(type, listener) {
|
|
checkListener(listener);
|
|
this.prependListener(type, _onceWrap(this, type, listener));
|
|
return this;
|
|
};
|
|
EventEmitter3.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;
|
|
};
|
|
EventEmitter3.prototype.off = EventEmitter3.prototype.removeListener;
|
|
EventEmitter3.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);
|
|
}
|
|
EventEmitter3.prototype.listeners = function listeners(type) {
|
|
return _listeners(this, type, true);
|
|
};
|
|
EventEmitter3.prototype.rawListeners = function rawListeners(type) {
|
|
return _listeners(this, type, false);
|
|
};
|
|
EventEmitter3.listenerCount = function(emitter, type) {
|
|
if (typeof emitter.listenerCount === "function") {
|
|
return emitter.listenerCount(type);
|
|
} else {
|
|
return listenerCount.call(emitter, type);
|
|
}
|
|
};
|
|
EventEmitter3.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;
|
|
}
|
|
EventEmitter3.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(err3) {
|
|
emitter.removeListener(name, resolver);
|
|
reject(err3);
|
|
}
|
|
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/sjcl@1.0.8/node_modules/sjcl/sjcl.js
|
|
var require_sjcl = __commonJS({
|
|
"node_modules/.deno/sjcl@1.0.8/node_modules/sjcl/sjcl.js"(exports, module) {
|
|
"use strict";
|
|
var sjcl2 = { cipher: {}, hash: {}, keyexchange: {}, mode: {}, misc: {}, codec: {}, exception: { corrupt: function(a) {
|
|
this.toString = function() {
|
|
return "CORRUPT: " + this.message;
|
|
};
|
|
this.message = a;
|
|
}, invalid: function(a) {
|
|
this.toString = function() {
|
|
return "INVALID: " + this.message;
|
|
};
|
|
this.message = a;
|
|
}, bug: function(a) {
|
|
this.toString = function() {
|
|
return "BUG: " + this.message;
|
|
};
|
|
this.message = a;
|
|
}, notReady: function(a) {
|
|
this.toString = function() {
|
|
return "NOT READY: " + this.message;
|
|
};
|
|
this.message = a;
|
|
} } };
|
|
sjcl2.cipher.aes = function(a) {
|
|
this.s[0][0][0] || this.O();
|
|
var b, c, d, e, f = this.s[0][4], g = this.s[1];
|
|
b = a.length;
|
|
var h = 1;
|
|
if (4 !== b && 6 !== b && 8 !== b) throw new sjcl2.exception.invalid("invalid aes key size");
|
|
this.b = [d = a.slice(0), e = []];
|
|
for (a = b; a < 4 * b + 28; a++) {
|
|
c = d[a - 1];
|
|
if (0 === a % b || 8 === b && 4 === a % b) c = f[c >>> 24] << 24 ^ f[c >> 16 & 255] << 16 ^ f[c >> 8 & 255] << 8 ^ f[c & 255], 0 === a % b && (c = c << 8 ^ c >>> 24 ^ h << 24, h = h << 1 ^ 283 * (h >> 7));
|
|
d[a] = d[a - b] ^ c;
|
|
}
|
|
for (b = 0; a; b++, a--) c = d[b & 3 ? a : a - 4], e[b] = 4 >= a || 4 > b ? c : g[0][f[c >>> 24]] ^ g[1][f[c >> 16 & 255]] ^ g[2][f[c >> 8 & 255]] ^ g[3][f[c & 255]];
|
|
};
|
|
sjcl2.cipher.aes.prototype = { encrypt: function(a) {
|
|
return t(this, a, 0);
|
|
}, decrypt: function(a) {
|
|
return t(this, a, 1);
|
|
}, s: [[[], [], [], [], []], [[], [], [], [], []]], O: function() {
|
|
var a = this.s[0], b = this.s[1], c = a[4], d = b[4], e, f, g, h = [], k = [], l, n, m, p;
|
|
for (e = 0; 256 > e; e++) k[(h[e] = e << 1 ^ 283 * (e >> 7)) ^ e] = e;
|
|
for (f = g = 0; !c[f]; f ^= l || 1, g = k[g] || 1) for (m = g ^ g << 1 ^ g << 2 ^ g << 3 ^ g << 4, m = m >> 8 ^ m & 255 ^ 99, c[f] = m, d[m] = f, n = h[e = h[l = h[f]]], p = 16843009 * n ^ 65537 * e ^ 257 * l ^ 16843008 * f, n = 257 * h[m] ^ 16843008 * m, e = 0; 4 > e; e++) a[e][f] = n = n << 24 ^ n >>> 8, b[e][m] = p = p << 24 ^ p >>> 8;
|
|
for (e = 0; 5 > e; e++) a[e] = a[e].slice(0), b[e] = b[e].slice(0);
|
|
} };
|
|
function t(a, b, c) {
|
|
if (4 !== b.length) throw new sjcl2.exception.invalid("invalid aes block size");
|
|
var d = a.b[c], e = b[0] ^ d[0], f = b[c ? 3 : 1] ^ d[1], g = b[2] ^ d[2];
|
|
b = b[c ? 1 : 3] ^ d[3];
|
|
var h, k, l, n = d.length / 4 - 2, m, p = 4, r = [0, 0, 0, 0];
|
|
h = a.s[c];
|
|
a = h[0];
|
|
var q = h[1], v = h[2], w = h[3], x = h[4];
|
|
for (m = 0; m < n; m++) h = a[e >>> 24] ^ q[f >> 16 & 255] ^ v[g >> 8 & 255] ^ w[b & 255] ^ d[p], k = a[f >>> 24] ^ q[g >> 16 & 255] ^ v[b >> 8 & 255] ^ w[e & 255] ^ d[p + 1], l = a[g >>> 24] ^ q[b >> 16 & 255] ^ v[e >> 8 & 255] ^ w[f & 255] ^ d[p + 2], b = a[b >>> 24] ^ q[e >> 16 & 255] ^ v[f >> 8 & 255] ^ w[g & 255] ^ d[p + 3], p += 4, e = h, f = k, g = l;
|
|
for (m = 0; 4 > m; m++) r[c ? 3 & -m : m] = x[e >>> 24] << 24 ^ x[f >> 16 & 255] << 16 ^ x[g >> 8 & 255] << 8 ^ x[b & 255] ^ d[p++], h = e, e = f, f = g, g = b, b = h;
|
|
return r;
|
|
}
|
|
sjcl2.bitArray = { bitSlice: function(a, b, c) {
|
|
a = sjcl2.bitArray.$(a.slice(b / 32), 32 - (b & 31)).slice(1);
|
|
return void 0 === c ? a : sjcl2.bitArray.clamp(a, c - b);
|
|
}, extract: function(a, b, c) {
|
|
var d = Math.floor(-b - c & 31);
|
|
return ((b + c - 1 ^ b) & -32 ? a[b / 32 | 0] << 32 - d ^ a[b / 32 + 1 | 0] >>> d : a[b / 32 | 0] >>> d) & (1 << c) - 1;
|
|
}, concat: function(a, b) {
|
|
if (0 === a.length || 0 === b.length) return a.concat(b);
|
|
var c = a[a.length - 1], d = sjcl2.bitArray.getPartial(c);
|
|
return 32 === d ? a.concat(b) : sjcl2.bitArray.$(b, d, c | 0, a.slice(0, a.length - 1));
|
|
}, bitLength: function(a) {
|
|
var b = a.length;
|
|
return 0 === b ? 0 : 32 * (b - 1) + sjcl2.bitArray.getPartial(a[b - 1]);
|
|
}, clamp: function(a, b) {
|
|
if (32 * a.length < b) return a;
|
|
a = a.slice(0, Math.ceil(b / 32));
|
|
var c = a.length;
|
|
b = b & 31;
|
|
0 < c && b && (a[c - 1] = sjcl2.bitArray.partial(b, a[c - 1] & 2147483648 >> b - 1, 1));
|
|
return a;
|
|
}, partial: function(a, b, c) {
|
|
return 32 === a ? b : (c ? b | 0 : b << 32 - a) + 1099511627776 * a;
|
|
}, getPartial: function(a) {
|
|
return Math.round(a / 1099511627776) || 32;
|
|
}, equal: function(a, b) {
|
|
if (sjcl2.bitArray.bitLength(a) !== sjcl2.bitArray.bitLength(b)) return false;
|
|
var c = 0, d;
|
|
for (d = 0; d < a.length; d++) c |= a[d] ^ b[d];
|
|
return 0 === c;
|
|
}, $: function(a, b, c, d) {
|
|
var e;
|
|
e = 0;
|
|
for (void 0 === d && (d = []); 32 <= b; b -= 32) d.push(c), c = 0;
|
|
if (0 === b) return d.concat(a);
|
|
for (e = 0; e < a.length; e++) d.push(c | a[e] >>> b), c = a[e] << 32 - b;
|
|
e = a.length ? a[a.length - 1] : 0;
|
|
a = sjcl2.bitArray.getPartial(e);
|
|
d.push(sjcl2.bitArray.partial(b + a & 31, 32 < b + a ? c : d.pop(), 1));
|
|
return d;
|
|
}, i: function(a, b) {
|
|
return [a[0] ^ b[0], a[1] ^ b[1], a[2] ^ b[2], a[3] ^ b[3]];
|
|
}, byteswapM: function(a) {
|
|
var b, c;
|
|
for (b = 0; b < a.length; ++b) c = a[b], a[b] = c >>> 24 | c >>> 8 & 65280 | (c & 65280) << 8 | c << 24;
|
|
return a;
|
|
} };
|
|
sjcl2.codec.utf8String = { fromBits: function(a) {
|
|
var b = "", c = sjcl2.bitArray.bitLength(a), d, e;
|
|
for (d = 0; d < c / 8; d++) 0 === (d & 3) && (e = a[d / 4]), b += String.fromCharCode(e >>> 8 >>> 8 >>> 8), e <<= 8;
|
|
return decodeURIComponent(escape(b));
|
|
}, toBits: function(a) {
|
|
a = unescape(encodeURIComponent(a));
|
|
var b = [], c, d = 0;
|
|
for (c = 0; c < a.length; c++) d = d << 8 | a.charCodeAt(c), 3 === (c & 3) && (b.push(d), d = 0);
|
|
c & 3 && b.push(sjcl2.bitArray.partial(8 * (c & 3), d));
|
|
return b;
|
|
} };
|
|
sjcl2.codec.hex = { fromBits: function(a) {
|
|
var b = "", c;
|
|
for (c = 0; c < a.length; c++) b += ((a[c] | 0) + 263882790666240).toString(16).substr(4);
|
|
return b.substr(0, sjcl2.bitArray.bitLength(a) / 4);
|
|
}, toBits: function(a) {
|
|
var b, c = [], d;
|
|
a = a.replace(/\s|0x/g, "");
|
|
d = a.length;
|
|
a = a + "00000000";
|
|
for (b = 0; b < a.length; b += 8) c.push(parseInt(a.substr(b, 8), 16) ^ 0);
|
|
return sjcl2.bitArray.clamp(c, 4 * d);
|
|
} };
|
|
sjcl2.codec.base32 = { B: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", X: "0123456789ABCDEFGHIJKLMNOPQRSTUV", BITS: 32, BASE: 5, REMAINING: 27, fromBits: function(a, b, c) {
|
|
var d = sjcl2.codec.base32.BASE, e = sjcl2.codec.base32.REMAINING, f = "", g = 0, h = sjcl2.codec.base32.B, k = 0, l = sjcl2.bitArray.bitLength(a);
|
|
c && (h = sjcl2.codec.base32.X);
|
|
for (c = 0; f.length * d < l; ) f += h.charAt((k ^ a[c] >>> g) >>> e), g < d ? (k = a[c] << d - g, g += e, c++) : (k <<= d, g -= d);
|
|
for (; f.length & 7 && !b; ) f += "=";
|
|
return f;
|
|
}, toBits: function(a, b) {
|
|
a = a.replace(/\s|=/g, "").toUpperCase();
|
|
var c = sjcl2.codec.base32.BITS, d = sjcl2.codec.base32.BASE, e = sjcl2.codec.base32.REMAINING, f = [], g, h = 0, k = sjcl2.codec.base32.B, l = 0, n, m = "base32";
|
|
b && (k = sjcl2.codec.base32.X, m = "base32hex");
|
|
for (g = 0; g < a.length; g++) {
|
|
n = k.indexOf(a.charAt(g));
|
|
if (0 > n) {
|
|
if (!b) try {
|
|
return sjcl2.codec.base32hex.toBits(a);
|
|
} catch (p) {
|
|
}
|
|
throw new sjcl2.exception.invalid("this isn't " + m + "!");
|
|
}
|
|
h > e ? (h -= e, f.push(l ^ n >>> h), l = n << c - h) : (h += d, l ^= n << c - h);
|
|
}
|
|
h & 56 && f.push(sjcl2.bitArray.partial(h & 56, l, 1));
|
|
return f;
|
|
} };
|
|
sjcl2.codec.base32hex = { fromBits: function(a, b) {
|
|
return sjcl2.codec.base32.fromBits(a, b, 1);
|
|
}, toBits: function(a) {
|
|
return sjcl2.codec.base32.toBits(a, 1);
|
|
} };
|
|
sjcl2.codec.base64 = { B: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", fromBits: function(a, b, c) {
|
|
var d = "", e = 0, f = sjcl2.codec.base64.B, g = 0, h = sjcl2.bitArray.bitLength(a);
|
|
c && (f = f.substr(0, 62) + "-_");
|
|
for (c = 0; 6 * d.length < h; ) d += f.charAt((g ^ a[c] >>> e) >>> 26), 6 > e ? (g = a[c] << 6 - e, e += 26, c++) : (g <<= 6, e -= 6);
|
|
for (; d.length & 3 && !b; ) d += "=";
|
|
return d;
|
|
}, toBits: function(a, b) {
|
|
a = a.replace(/\s|=/g, "");
|
|
var c = [], d, e = 0, f = sjcl2.codec.base64.B, g = 0, h;
|
|
b && (f = f.substr(0, 62) + "-_");
|
|
for (d = 0; d < a.length; d++) {
|
|
h = f.indexOf(a.charAt(d));
|
|
if (0 > h) throw new sjcl2.exception.invalid("this isn't base64!");
|
|
26 < e ? (e -= 26, c.push(g ^ h >>> e), g = h << 32 - e) : (e += 6, g ^= h << 32 - e);
|
|
}
|
|
e & 56 && c.push(sjcl2.bitArray.partial(e & 56, g, 1));
|
|
return c;
|
|
} };
|
|
sjcl2.codec.base64url = { fromBits: function(a) {
|
|
return sjcl2.codec.base64.fromBits(a, 1, 1);
|
|
}, toBits: function(a) {
|
|
return sjcl2.codec.base64.toBits(a, 1);
|
|
} };
|
|
sjcl2.hash.sha256 = function(a) {
|
|
this.b[0] || this.O();
|
|
a ? (this.F = a.F.slice(0), this.A = a.A.slice(0), this.l = a.l) : this.reset();
|
|
};
|
|
sjcl2.hash.sha256.hash = function(a) {
|
|
return new sjcl2.hash.sha256().update(a).finalize();
|
|
};
|
|
sjcl2.hash.sha256.prototype = { blockSize: 512, reset: function() {
|
|
this.F = this.Y.slice(0);
|
|
this.A = [];
|
|
this.l = 0;
|
|
return this;
|
|
}, update: function(a) {
|
|
"string" === typeof a && (a = sjcl2.codec.utf8String.toBits(a));
|
|
var b, c = this.A = sjcl2.bitArray.concat(this.A, a);
|
|
b = this.l;
|
|
a = this.l = b + sjcl2.bitArray.bitLength(a);
|
|
if (9007199254740991 < a) throw new sjcl2.exception.invalid("Cannot hash more than 2^53 - 1 bits");
|
|
if ("undefined" !== typeof Uint32Array) {
|
|
var d = new Uint32Array(c), e = 0;
|
|
for (b = 512 + b - (512 + b & 511); b <= a; b += 512) u(this, d.subarray(
|
|
16 * e,
|
|
16 * (e + 1)
|
|
)), e += 1;
|
|
c.splice(0, 16 * e);
|
|
} else for (b = 512 + b - (512 + b & 511); b <= a; b += 512) u(this, c.splice(0, 16));
|
|
return this;
|
|
}, finalize: function() {
|
|
var a, b = this.A, c = this.F, b = sjcl2.bitArray.concat(b, [sjcl2.bitArray.partial(1, 1)]);
|
|
for (a = b.length + 2; a & 15; a++) b.push(0);
|
|
b.push(Math.floor(this.l / 4294967296));
|
|
for (b.push(this.l | 0); b.length; ) u(this, b.splice(0, 16));
|
|
this.reset();
|
|
return c;
|
|
}, Y: [], b: [], O: function() {
|
|
function a(a2) {
|
|
return 4294967296 * (a2 - Math.floor(a2)) | 0;
|
|
}
|
|
for (var b = 0, c = 2, d, e; 64 > b; c++) {
|
|
e = true;
|
|
for (d = 2; d * d <= c; d++) if (0 === c % d) {
|
|
e = false;
|
|
break;
|
|
}
|
|
e && (8 > b && (this.Y[b] = a(Math.pow(c, 0.5))), this.b[b] = a(Math.pow(c, 1 / 3)), b++);
|
|
}
|
|
} };
|
|
function u(a, b) {
|
|
var c, d, e, f = a.F, g = a.b, h = f[0], k = f[1], l = f[2], n = f[3], m = f[4], p = f[5], r = f[6], q = f[7];
|
|
for (c = 0; 64 > c; c++) 16 > c ? d = b[c] : (d = b[c + 1 & 15], e = b[c + 14 & 15], d = b[c & 15] = (d >>> 7 ^ d >>> 18 ^ d >>> 3 ^ d << 25 ^ d << 14) + (e >>> 17 ^ e >>> 19 ^ e >>> 10 ^ e << 15 ^ e << 13) + b[c & 15] + b[c + 9 & 15] | 0), d = d + q + (m >>> 6 ^ m >>> 11 ^ m >>> 25 ^ m << 26 ^ m << 21 ^ m << 7) + (r ^ m & (p ^ r)) + g[c], q = r, r = p, p = m, m = n + d | 0, n = l, l = k, k = h, h = d + (k & l ^ n & (k ^ l)) + (k >>> 2 ^ k >>> 13 ^ k >>> 22 ^ k << 30 ^ k << 19 ^ k << 10) | 0;
|
|
f[0] = f[0] + h | 0;
|
|
f[1] = f[1] + k | 0;
|
|
f[2] = f[2] + l | 0;
|
|
f[3] = f[3] + n | 0;
|
|
f[4] = f[4] + m | 0;
|
|
f[5] = f[5] + p | 0;
|
|
f[6] = f[6] + r | 0;
|
|
f[7] = f[7] + q | 0;
|
|
}
|
|
sjcl2.mode.ccm = { name: "ccm", G: [], listenProgress: function(a) {
|
|
sjcl2.mode.ccm.G.push(a);
|
|
}, unListenProgress: function(a) {
|
|
a = sjcl2.mode.ccm.G.indexOf(a);
|
|
-1 < a && sjcl2.mode.ccm.G.splice(a, 1);
|
|
}, fa: function(a) {
|
|
var b = sjcl2.mode.ccm.G.slice(), c;
|
|
for (c = 0; c < b.length; c += 1) b[c](a);
|
|
}, encrypt: function(a, b, c, d, e) {
|
|
var f, g = b.slice(0), h = sjcl2.bitArray, k = h.bitLength(c) / 8, l = h.bitLength(g) / 8;
|
|
e = e || 64;
|
|
d = d || [];
|
|
if (7 > k) throw new sjcl2.exception.invalid("ccm: iv must be at least 7 bytes");
|
|
for (f = 2; 4 > f && l >>> 8 * f; f++) ;
|
|
f < 15 - k && (f = 15 - k);
|
|
c = h.clamp(
|
|
c,
|
|
8 * (15 - f)
|
|
);
|
|
b = sjcl2.mode.ccm.V(a, b, c, d, e, f);
|
|
g = sjcl2.mode.ccm.C(a, g, c, b, e, f);
|
|
return h.concat(g.data, g.tag);
|
|
}, decrypt: function(a, b, c, d, e) {
|
|
e = e || 64;
|
|
d = d || [];
|
|
var f = sjcl2.bitArray, g = f.bitLength(c) / 8, h = f.bitLength(b), k = f.clamp(b, h - e), l = f.bitSlice(b, h - e), h = (h - e) / 8;
|
|
if (7 > g) throw new sjcl2.exception.invalid("ccm: iv must be at least 7 bytes");
|
|
for (b = 2; 4 > b && h >>> 8 * b; b++) ;
|
|
b < 15 - g && (b = 15 - g);
|
|
c = f.clamp(c, 8 * (15 - b));
|
|
k = sjcl2.mode.ccm.C(a, k, c, l, e, b);
|
|
a = sjcl2.mode.ccm.V(a, k.data, c, d, e, b);
|
|
if (!f.equal(k.tag, a)) throw new sjcl2.exception.corrupt("ccm: tag doesn't match");
|
|
return k.data;
|
|
}, na: function(a, b, c, d, e, f) {
|
|
var g = [], h = sjcl2.bitArray, k = h.i;
|
|
d = [h.partial(8, (b.length ? 64 : 0) | d - 2 << 2 | f - 1)];
|
|
d = h.concat(d, c);
|
|
d[3] |= e;
|
|
d = a.encrypt(d);
|
|
if (b.length) for (c = h.bitLength(b) / 8, 65279 >= c ? g = [h.partial(16, c)] : 4294967295 >= c && (g = h.concat([h.partial(16, 65534)], [c])), g = h.concat(g, b), b = 0; b < g.length; b += 4) d = a.encrypt(k(d, g.slice(b, b + 4).concat([0, 0, 0])));
|
|
return d;
|
|
}, V: function(a, b, c, d, e, f) {
|
|
var g = sjcl2.bitArray, h = g.i;
|
|
e /= 8;
|
|
if (e % 2 || 4 > e || 16 < e) throw new sjcl2.exception.invalid("ccm: invalid tag length");
|
|
if (4294967295 < d.length || 4294967295 < b.length) throw new sjcl2.exception.bug("ccm: can't deal with 4GiB or more data");
|
|
c = sjcl2.mode.ccm.na(a, d, c, e, g.bitLength(b) / 8, f);
|
|
for (d = 0; d < b.length; d += 4) c = a.encrypt(h(c, b.slice(d, d + 4).concat([0, 0, 0])));
|
|
return g.clamp(c, 8 * e);
|
|
}, C: function(a, b, c, d, e, f) {
|
|
var g, h = sjcl2.bitArray;
|
|
g = h.i;
|
|
var k = b.length, l = h.bitLength(b), n = k / 50, m = n;
|
|
c = h.concat([h.partial(8, f - 1)], c).concat([0, 0, 0]).slice(0, 4);
|
|
d = h.bitSlice(g(d, a.encrypt(c)), 0, e);
|
|
if (!k) return { tag: d, data: [] };
|
|
for (g = 0; g < k; g += 4) g > n && (sjcl2.mode.ccm.fa(g / k), n += m), c[3]++, e = a.encrypt(c), b[g] ^= e[0], b[g + 1] ^= e[1], b[g + 2] ^= e[2], b[g + 3] ^= e[3];
|
|
return { tag: d, data: h.clamp(b, l) };
|
|
} };
|
|
sjcl2.mode.ocb2 = { name: "ocb2", encrypt: function(a, b, c, d, e, f) {
|
|
if (128 !== sjcl2.bitArray.bitLength(c)) throw new sjcl2.exception.invalid("ocb iv must be 128 bits");
|
|
var g, h = sjcl2.mode.ocb2.S, k = sjcl2.bitArray, l = k.i, n = [0, 0, 0, 0];
|
|
c = h(a.encrypt(c));
|
|
var m, p = [];
|
|
d = d || [];
|
|
e = e || 64;
|
|
for (g = 0; g + 4 < b.length; g += 4) m = b.slice(g, g + 4), n = l(n, m), p = p.concat(l(c, a.encrypt(l(c, m)))), c = h(c);
|
|
m = b.slice(g);
|
|
b = k.bitLength(m);
|
|
g = a.encrypt(l(c, [0, 0, 0, b]));
|
|
m = k.clamp(l(m.concat([0, 0, 0]), g), b);
|
|
n = l(n, l(m.concat([0, 0, 0]), g));
|
|
n = a.encrypt(l(n, l(c, h(c))));
|
|
d.length && (n = l(n, f ? d : sjcl2.mode.ocb2.pmac(a, d)));
|
|
return p.concat(k.concat(m, k.clamp(n, e)));
|
|
}, decrypt: function(a, b, c, d, e, f) {
|
|
if (128 !== sjcl2.bitArray.bitLength(c)) throw new sjcl2.exception.invalid("ocb iv must be 128 bits");
|
|
e = e || 64;
|
|
var g = sjcl2.mode.ocb2.S, h = sjcl2.bitArray, k = h.i, l = [0, 0, 0, 0], n = g(a.encrypt(c)), m, p, r = sjcl2.bitArray.bitLength(b) - e, q = [];
|
|
d = d || [];
|
|
for (c = 0; c + 4 < r / 32; c += 4) m = k(n, a.decrypt(k(n, b.slice(c, c + 4)))), l = k(l, m), q = q.concat(m), n = g(n);
|
|
p = r - 32 * c;
|
|
m = a.encrypt(k(n, [0, 0, 0, p]));
|
|
m = k(m, h.clamp(b.slice(c), p).concat([
|
|
0,
|
|
0,
|
|
0
|
|
]));
|
|
l = k(l, m);
|
|
l = a.encrypt(k(l, k(n, g(n))));
|
|
d.length && (l = k(l, f ? d : sjcl2.mode.ocb2.pmac(a, d)));
|
|
if (!h.equal(h.clamp(l, e), h.bitSlice(b, r))) throw new sjcl2.exception.corrupt("ocb: tag doesn't match");
|
|
return q.concat(h.clamp(m, p));
|
|
}, pmac: function(a, b) {
|
|
var c, d = sjcl2.mode.ocb2.S, e = sjcl2.bitArray, f = e.i, g = [0, 0, 0, 0], h = a.encrypt([0, 0, 0, 0]), h = f(h, d(d(h)));
|
|
for (c = 0; c + 4 < b.length; c += 4) h = d(h), g = f(g, a.encrypt(f(h, b.slice(c, c + 4))));
|
|
c = b.slice(c);
|
|
128 > e.bitLength(c) && (h = f(h, d(h)), c = e.concat(c, [-2147483648, 0, 0, 0]));
|
|
g = f(g, c);
|
|
return a.encrypt(f(d(f(h, d(h))), g));
|
|
}, S: function(a) {
|
|
return [a[0] << 1 ^ a[1] >>> 31, a[1] << 1 ^ a[2] >>> 31, a[2] << 1 ^ a[3] >>> 31, a[3] << 1 ^ 135 * (a[0] >>> 31)];
|
|
} };
|
|
sjcl2.mode.gcm = { name: "gcm", encrypt: function(a, b, c, d, e) {
|
|
var f = b.slice(0);
|
|
b = sjcl2.bitArray;
|
|
d = d || [];
|
|
a = sjcl2.mode.gcm.C(true, a, f, d, c, e || 128);
|
|
return b.concat(a.data, a.tag);
|
|
}, decrypt: function(a, b, c, d, e) {
|
|
var f = b.slice(0), g = sjcl2.bitArray, h = g.bitLength(f);
|
|
e = e || 128;
|
|
d = d || [];
|
|
e <= h ? (b = g.bitSlice(f, h - e), f = g.bitSlice(f, 0, h - e)) : (b = f, f = []);
|
|
a = sjcl2.mode.gcm.C(false, a, f, d, c, e);
|
|
if (!g.equal(a.tag, b)) throw new sjcl2.exception.corrupt("gcm: tag doesn't match");
|
|
return a.data;
|
|
}, ka: function(a, b) {
|
|
var c, d, e, f, g, h = sjcl2.bitArray.i;
|
|
e = [
|
|
0,
|
|
0,
|
|
0,
|
|
0
|
|
];
|
|
f = b.slice(0);
|
|
for (c = 0; 128 > c; c++) {
|
|
(d = 0 !== (a[Math.floor(c / 32)] & 1 << 31 - c % 32)) && (e = h(e, f));
|
|
g = 0 !== (f[3] & 1);
|
|
for (d = 3; 0 < d; d--) f[d] = f[d] >>> 1 | (f[d - 1] & 1) << 31;
|
|
f[0] >>>= 1;
|
|
g && (f[0] ^= -520093696);
|
|
}
|
|
return e;
|
|
}, j: function(a, b, c) {
|
|
var d, e = c.length;
|
|
b = b.slice(0);
|
|
for (d = 0; d < e; d += 4) b[0] ^= 4294967295 & c[d], b[1] ^= 4294967295 & c[d + 1], b[2] ^= 4294967295 & c[d + 2], b[3] ^= 4294967295 & c[d + 3], b = sjcl2.mode.gcm.ka(b, a);
|
|
return b;
|
|
}, C: function(a, b, c, d, e, f) {
|
|
var g, h, k, l, n, m, p, r, q = sjcl2.bitArray;
|
|
m = c.length;
|
|
p = q.bitLength(c);
|
|
r = q.bitLength(d);
|
|
h = q.bitLength(e);
|
|
g = b.encrypt([0, 0, 0, 0]);
|
|
96 === h ? (e = e.slice(0), e = q.concat(e, [1])) : (e = sjcl2.mode.gcm.j(g, [0, 0, 0, 0], e), e = sjcl2.mode.gcm.j(g, e, [0, 0, Math.floor(h / 4294967296), h & 4294967295]));
|
|
h = sjcl2.mode.gcm.j(g, [0, 0, 0, 0], d);
|
|
n = e.slice(0);
|
|
d = h.slice(0);
|
|
a || (d = sjcl2.mode.gcm.j(g, h, c));
|
|
for (l = 0; l < m; l += 4) n[3]++, k = b.encrypt(n), c[l] ^= k[0], c[l + 1] ^= k[1], c[l + 2] ^= k[2], c[l + 3] ^= k[3];
|
|
c = q.clamp(c, p);
|
|
a && (d = sjcl2.mode.gcm.j(g, h, c));
|
|
a = [Math.floor(r / 4294967296), r & 4294967295, Math.floor(p / 4294967296), p & 4294967295];
|
|
d = sjcl2.mode.gcm.j(g, d, a);
|
|
k = b.encrypt(e);
|
|
d[0] ^= k[0];
|
|
d[1] ^= k[1];
|
|
d[2] ^= k[2];
|
|
d[3] ^= k[3];
|
|
return { tag: q.bitSlice(d, 0, f), data: c };
|
|
} };
|
|
sjcl2.misc.hmac = function(a, b) {
|
|
this.W = b = b || sjcl2.hash.sha256;
|
|
var c = [[], []], d, e = b.prototype.blockSize / 32;
|
|
this.w = [new b(), new b()];
|
|
a.length > e && (a = b.hash(a));
|
|
for (d = 0; d < e; d++) c[0][d] = a[d] ^ 909522486, c[1][d] = a[d] ^ 1549556828;
|
|
this.w[0].update(c[0]);
|
|
this.w[1].update(c[1]);
|
|
this.R = new b(this.w[0]);
|
|
};
|
|
sjcl2.misc.hmac.prototype.encrypt = sjcl2.misc.hmac.prototype.mac = function(a) {
|
|
if (this.aa) throw new sjcl2.exception.invalid("encrypt on already updated hmac called!");
|
|
this.update(a);
|
|
return this.digest(a);
|
|
};
|
|
sjcl2.misc.hmac.prototype.reset = function() {
|
|
this.R = new this.W(this.w[0]);
|
|
this.aa = false;
|
|
};
|
|
sjcl2.misc.hmac.prototype.update = function(a) {
|
|
this.aa = true;
|
|
this.R.update(a);
|
|
};
|
|
sjcl2.misc.hmac.prototype.digest = function() {
|
|
var a = this.R.finalize(), a = new this.W(this.w[1]).update(a).finalize();
|
|
this.reset();
|
|
return a;
|
|
};
|
|
sjcl2.misc.pbkdf2 = function(a, b, c, d, e) {
|
|
c = c || 1e4;
|
|
if (0 > d || 0 > c) throw new sjcl2.exception.invalid("invalid params to pbkdf2");
|
|
"string" === typeof a && (a = sjcl2.codec.utf8String.toBits(a));
|
|
"string" === typeof b && (b = sjcl2.codec.utf8String.toBits(b));
|
|
e = e || sjcl2.misc.hmac;
|
|
a = new e(a);
|
|
var f, g, h, k, l = [], n = sjcl2.bitArray;
|
|
for (k = 1; 32 * l.length < (d || 1); k++) {
|
|
e = f = a.encrypt(n.concat(b, [k]));
|
|
for (g = 1; g < c; g++) for (f = a.encrypt(f), h = 0; h < f.length; h++) e[h] ^= f[h];
|
|
l = l.concat(e);
|
|
}
|
|
d && (l = n.clamp(l, d));
|
|
return l;
|
|
};
|
|
sjcl2.prng = function(a) {
|
|
this.c = [new sjcl2.hash.sha256()];
|
|
this.m = [0];
|
|
this.P = 0;
|
|
this.H = {};
|
|
this.N = 0;
|
|
this.U = {};
|
|
this.Z = this.f = this.o = this.ha = 0;
|
|
this.b = [0, 0, 0, 0, 0, 0, 0, 0];
|
|
this.h = [0, 0, 0, 0];
|
|
this.L = void 0;
|
|
this.M = a;
|
|
this.D = false;
|
|
this.K = { progress: {}, seeded: {} };
|
|
this.u = this.ga = 0;
|
|
this.I = 1;
|
|
this.J = 2;
|
|
this.ca = 65536;
|
|
this.T = [0, 48, 64, 96, 128, 192, 256, 384, 512, 768, 1024];
|
|
this.da = 3e4;
|
|
this.ba = 80;
|
|
};
|
|
sjcl2.prng.prototype = {
|
|
randomWords: function(a, b) {
|
|
var c = [], d;
|
|
d = this.isReady(b);
|
|
var e;
|
|
if (d === this.u) throw new sjcl2.exception.notReady("generator isn't seeded");
|
|
if (d & this.J) {
|
|
d = !(d & this.I);
|
|
e = [];
|
|
var f = 0, g;
|
|
this.Z = e[0] = (/* @__PURE__ */ new Date()).valueOf() + this.da;
|
|
for (g = 0; 16 > g; g++) e.push(4294967296 * Math.random() | 0);
|
|
for (g = 0; g < this.c.length && (e = e.concat(this.c[g].finalize()), f += this.m[g], this.m[g] = 0, d || !(this.P & 1 << g)); g++) ;
|
|
this.P >= 1 << this.c.length && (this.c.push(new sjcl2.hash.sha256()), this.m.push(0));
|
|
this.f -= f;
|
|
f > this.o && (this.o = f);
|
|
this.P++;
|
|
this.b = sjcl2.hash.sha256.hash(this.b.concat(e));
|
|
this.L = new sjcl2.cipher.aes(this.b);
|
|
for (d = 0; 4 > d && (this.h[d] = this.h[d] + 1 | 0, !this.h[d]); d++) ;
|
|
}
|
|
for (d = 0; d < a; d += 4) 0 === (d + 1) % this.ca && y(this), e = z(this), c.push(e[0], e[1], e[2], e[3]);
|
|
y(this);
|
|
return c.slice(0, a);
|
|
},
|
|
setDefaultParanoia: function(a, b) {
|
|
if (0 === a && "Setting paranoia=0 will ruin your security; use it only for testing" !== b) throw new sjcl2.exception.invalid("Setting paranoia=0 will ruin your security; use it only for testing");
|
|
this.M = a;
|
|
},
|
|
addEntropy: function(a, b, c) {
|
|
c = c || "user";
|
|
var d, e, f = (/* @__PURE__ */ new Date()).valueOf(), g = this.H[c], h = this.isReady(), k = 0;
|
|
d = this.U[c];
|
|
void 0 === d && (d = this.U[c] = this.ha++);
|
|
void 0 === g && (g = this.H[c] = 0);
|
|
this.H[c] = (this.H[c] + 1) % this.c.length;
|
|
switch (typeof a) {
|
|
case "number":
|
|
void 0 === b && (b = 1);
|
|
this.c[g].update([d, this.N++, 1, b, f, 1, a | 0]);
|
|
break;
|
|
case "object":
|
|
c = Object.prototype.toString.call(a);
|
|
if ("[object Uint32Array]" === c) {
|
|
e = [];
|
|
for (c = 0; c < a.length; c++) e.push(a[c]);
|
|
a = e;
|
|
} else for ("[object Array]" !== c && (k = 1), c = 0; c < a.length && !k; c++) "number" !== typeof a[c] && (k = 1);
|
|
if (!k) {
|
|
if (void 0 === b) for (c = b = 0; c < a.length; c++) for (e = a[c]; 0 < e; ) b++, e = e >>> 1;
|
|
this.c[g].update([d, this.N++, 2, b, f, a.length].concat(a));
|
|
}
|
|
break;
|
|
case "string":
|
|
void 0 === b && (b = a.length);
|
|
this.c[g].update([d, this.N++, 3, b, f, a.length]);
|
|
this.c[g].update(a);
|
|
break;
|
|
default:
|
|
k = 1;
|
|
}
|
|
if (k) throw new sjcl2.exception.bug("random: addEntropy only supports number, array of numbers or string");
|
|
this.m[g] += b;
|
|
this.f += b;
|
|
h === this.u && (this.isReady() !== this.u && A("seeded", Math.max(this.o, this.f)), A("progress", this.getProgress()));
|
|
},
|
|
isReady: function(a) {
|
|
a = this.T[void 0 !== a ? a : this.M];
|
|
return this.o && this.o >= a ? this.m[0] > this.ba && (/* @__PURE__ */ new Date()).valueOf() > this.Z ? this.J | this.I : this.I : this.f >= a ? this.J | this.u : this.u;
|
|
},
|
|
getProgress: function(a) {
|
|
a = this.T[a ? a : this.M];
|
|
return this.o >= a ? 1 : this.f > a ? 1 : this.f / a;
|
|
},
|
|
startCollectors: function() {
|
|
if (!this.D) {
|
|
this.a = { loadTimeCollector: B(this, this.ma), mouseCollector: B(this, this.oa), keyboardCollector: B(this, this.la), accelerometerCollector: B(this, this.ea), touchCollector: B(this, this.qa) };
|
|
if (window.addEventListener) window.addEventListener(
|
|
"load",
|
|
this.a.loadTimeCollector,
|
|
false
|
|
), window.addEventListener("mousemove", this.a.mouseCollector, false), window.addEventListener("keypress", this.a.keyboardCollector, false), window.addEventListener("devicemotion", this.a.accelerometerCollector, false), window.addEventListener("touchmove", this.a.touchCollector, false);
|
|
else if (document.attachEvent) document.attachEvent("onload", this.a.loadTimeCollector), document.attachEvent("onmousemove", this.a.mouseCollector), document.attachEvent("keypress", this.a.keyboardCollector);
|
|
else throw new sjcl2.exception.bug("can't attach event");
|
|
this.D = true;
|
|
}
|
|
},
|
|
stopCollectors: function() {
|
|
this.D && (window.removeEventListener ? (window.removeEventListener("load", this.a.loadTimeCollector, false), window.removeEventListener("mousemove", this.a.mouseCollector, false), window.removeEventListener("keypress", this.a.keyboardCollector, false), window.removeEventListener("devicemotion", this.a.accelerometerCollector, false), window.removeEventListener("touchmove", this.a.touchCollector, false)) : document.detachEvent && (document.detachEvent("onload", this.a.loadTimeCollector), document.detachEvent(
|
|
"onmousemove",
|
|
this.a.mouseCollector
|
|
), document.detachEvent("keypress", this.a.keyboardCollector)), this.D = false);
|
|
},
|
|
addEventListener: function(a, b) {
|
|
this.K[a][this.ga++] = b;
|
|
},
|
|
removeEventListener: function(a, b) {
|
|
var c, d, e = this.K[a], f = [];
|
|
for (d in e) e.hasOwnProperty(d) && e[d] === b && f.push(d);
|
|
for (c = 0; c < f.length; c++) d = f[c], delete e[d];
|
|
},
|
|
la: function() {
|
|
C(this, 1);
|
|
},
|
|
oa: function(a) {
|
|
var b, c;
|
|
try {
|
|
b = a.x || a.clientX || a.offsetX || 0, c = a.y || a.clientY || a.offsetY || 0;
|
|
} catch (d) {
|
|
c = b = 0;
|
|
}
|
|
0 != b && 0 != c && this.addEntropy([b, c], 2, "mouse");
|
|
C(this, 0);
|
|
},
|
|
qa: function(a) {
|
|
a = a.touches[0] || a.changedTouches[0];
|
|
this.addEntropy([a.pageX || a.clientX, a.pageY || a.clientY], 1, "touch");
|
|
C(this, 0);
|
|
},
|
|
ma: function() {
|
|
C(this, 2);
|
|
},
|
|
ea: function(a) {
|
|
a = a.accelerationIncludingGravity.x || a.accelerationIncludingGravity.y || a.accelerationIncludingGravity.z;
|
|
if (window.orientation) {
|
|
var b = window.orientation;
|
|
"number" === typeof b && this.addEntropy(b, 1, "accelerometer");
|
|
}
|
|
a && this.addEntropy(a, 2, "accelerometer");
|
|
C(this, 0);
|
|
}
|
|
};
|
|
function A(a, b) {
|
|
var c, d = sjcl2.random.K[a], e = [];
|
|
for (c in d) d.hasOwnProperty(c) && e.push(d[c]);
|
|
for (c = 0; c < e.length; c++) e[c](b);
|
|
}
|
|
function C(a, b) {
|
|
"undefined" !== typeof window && window.performance && "function" === typeof window.performance.now ? a.addEntropy(window.performance.now(), b, "loadtime") : a.addEntropy((/* @__PURE__ */ new Date()).valueOf(), b, "loadtime");
|
|
}
|
|
function y(a) {
|
|
a.b = z(a).concat(z(a));
|
|
a.L = new sjcl2.cipher.aes(a.b);
|
|
}
|
|
function z(a) {
|
|
for (var b = 0; 4 > b && (a.h[b] = a.h[b] + 1 | 0, !a.h[b]); b++) ;
|
|
return a.L.encrypt(a.h);
|
|
}
|
|
function B(a, b) {
|
|
return function() {
|
|
b.apply(a, arguments);
|
|
};
|
|
}
|
|
sjcl2.random = new sjcl2.prng(6);
|
|
a: try {
|
|
if (G = "undefined" !== typeof module && module.exports) {
|
|
try {
|
|
H = __require("crypto");
|
|
} catch (a) {
|
|
H = null;
|
|
}
|
|
G = E = H;
|
|
}
|
|
if (G && E.randomBytes) D = E.randomBytes(128), D = new Uint32Array(new Uint8Array(D).buffer), sjcl2.random.addEntropy(D, 1024, "crypto['randomBytes']");
|
|
else if ("undefined" !== typeof window && "undefined" !== typeof Uint32Array) {
|
|
F = new Uint32Array(32);
|
|
if (window.crypto && window.crypto.getRandomValues) window.crypto.getRandomValues(F);
|
|
else if (window.msCrypto && window.msCrypto.getRandomValues) window.msCrypto.getRandomValues(F);
|
|
else break a;
|
|
sjcl2.random.addEntropy(F, 1024, "crypto['getRandomValues']");
|
|
}
|
|
} catch (a) {
|
|
"undefined" !== typeof window && window.console && (console.log("There was an error collecting entropy from the browser:"), console.log(a));
|
|
}
|
|
var D;
|
|
var E;
|
|
var F;
|
|
var G;
|
|
var H;
|
|
sjcl2.json = { defaults: { v: 1, iter: 1e4, ks: 128, ts: 64, mode: "ccm", adata: "", cipher: "aes" }, ja: function(a, b, c, d) {
|
|
c = c || {};
|
|
d = d || {};
|
|
var e = sjcl2.json, f = e.g({ iv: sjcl2.random.randomWords(4, 0) }, e.defaults), g;
|
|
e.g(f, c);
|
|
c = f.adata;
|
|
"string" === typeof f.salt && (f.salt = sjcl2.codec.base64.toBits(f.salt));
|
|
"string" === typeof f.iv && (f.iv = sjcl2.codec.base64.toBits(f.iv));
|
|
if (!sjcl2.mode[f.mode] || !sjcl2.cipher[f.cipher] || "string" === typeof a && 100 >= f.iter || 64 !== f.ts && 96 !== f.ts && 128 !== f.ts || 128 !== f.ks && 192 !== f.ks && 256 !== f.ks || 2 > f.iv.length || 4 < f.iv.length) throw new sjcl2.exception.invalid("json encrypt: invalid parameters");
|
|
"string" === typeof a ? (g = sjcl2.misc.cachedPbkdf2(a, f), a = g.key.slice(0, f.ks / 32), f.salt = g.salt) : sjcl2.ecc && a instanceof sjcl2.ecc.elGamal.publicKey && (g = a.kem(), f.kemtag = g.tag, a = g.key.slice(0, f.ks / 32));
|
|
"string" === typeof b && (b = sjcl2.codec.utf8String.toBits(b));
|
|
"string" === typeof c && (f.adata = c = sjcl2.codec.utf8String.toBits(c));
|
|
g = new sjcl2.cipher[f.cipher](a);
|
|
e.g(d, f);
|
|
d.key = a;
|
|
f.ct = "ccm" === f.mode && sjcl2.arrayBuffer && sjcl2.arrayBuffer.ccm && b instanceof ArrayBuffer ? sjcl2.arrayBuffer.ccm.encrypt(g, b, f.iv, c, f.ts) : sjcl2.mode[f.mode].encrypt(g, b, f.iv, c, f.ts);
|
|
return f;
|
|
}, encrypt: function(a, b, c, d) {
|
|
var e = sjcl2.json, f = e.ja.apply(e, arguments);
|
|
return e.encode(f);
|
|
}, ia: function(a, b, c, d) {
|
|
c = c || {};
|
|
d = d || {};
|
|
var e = sjcl2.json;
|
|
b = e.g(e.g(e.g({}, e.defaults), b), c, true);
|
|
var f, g;
|
|
f = b.adata;
|
|
"string" === typeof b.salt && (b.salt = sjcl2.codec.base64.toBits(b.salt));
|
|
"string" === typeof b.iv && (b.iv = sjcl2.codec.base64.toBits(b.iv));
|
|
if (!sjcl2.mode[b.mode] || !sjcl2.cipher[b.cipher] || "string" === typeof a && 100 >= b.iter || 64 !== b.ts && 96 !== b.ts && 128 !== b.ts || 128 !== b.ks && 192 !== b.ks && 256 !== b.ks || !b.iv || 2 > b.iv.length || 4 < b.iv.length) throw new sjcl2.exception.invalid("json decrypt: invalid parameters");
|
|
"string" === typeof a ? (g = sjcl2.misc.cachedPbkdf2(a, b), a = g.key.slice(0, b.ks / 32), b.salt = g.salt) : sjcl2.ecc && a instanceof sjcl2.ecc.elGamal.secretKey && (a = a.unkem(sjcl2.codec.base64.toBits(b.kemtag)).slice(0, b.ks / 32));
|
|
"string" === typeof f && (f = sjcl2.codec.utf8String.toBits(f));
|
|
g = new sjcl2.cipher[b.cipher](a);
|
|
f = "ccm" === b.mode && sjcl2.arrayBuffer && sjcl2.arrayBuffer.ccm && b.ct instanceof ArrayBuffer ? sjcl2.arrayBuffer.ccm.decrypt(g, b.ct, b.iv, b.tag, f, b.ts) : sjcl2.mode[b.mode].decrypt(g, b.ct, b.iv, f, b.ts);
|
|
e.g(d, b);
|
|
d.key = a;
|
|
return 1 === c.raw ? f : sjcl2.codec.utf8String.fromBits(f);
|
|
}, decrypt: function(a, b, c, d) {
|
|
var e = sjcl2.json;
|
|
return e.ia(a, e.decode(b), c, d);
|
|
}, encode: function(a) {
|
|
var b, c = "{", d = "";
|
|
for (b in a) if (a.hasOwnProperty(b)) {
|
|
if (!b.match(/^[a-z0-9]+$/i)) throw new sjcl2.exception.invalid("json encode: invalid property name");
|
|
c += d + '"' + b + '":';
|
|
d = ",";
|
|
switch (typeof a[b]) {
|
|
case "number":
|
|
case "boolean":
|
|
c += a[b];
|
|
break;
|
|
case "string":
|
|
c += '"' + escape(a[b]) + '"';
|
|
break;
|
|
case "object":
|
|
c += '"' + sjcl2.codec.base64.fromBits(a[b], 0) + '"';
|
|
break;
|
|
default:
|
|
throw new sjcl2.exception.bug("json encode: unsupported type");
|
|
}
|
|
}
|
|
return c + "}";
|
|
}, decode: function(a) {
|
|
a = a.replace(/\s/g, "");
|
|
if (!a.match(/^\{.*\}$/)) throw new sjcl2.exception.invalid("json decode: this isn't json!");
|
|
a = a.replace(/^\{|\}$/g, "").split(/,/);
|
|
var b = {}, c, d;
|
|
for (c = 0; c < a.length; c++) {
|
|
if (!(d = a[c].match(/^\s*(?:(["']?)([a-z][a-z0-9]*)\1)\s*:\s*(?:(-?\d+)|"([a-z0-9+\/%*_.@=\-]*)"|(true|false))$/i))) throw new sjcl2.exception.invalid("json decode: this isn't json!");
|
|
null != d[3] ? b[d[2]] = parseInt(d[3], 10) : null != d[4] ? b[d[2]] = d[2].match(/^(ct|adata|salt|iv)$/) ? sjcl2.codec.base64.toBits(d[4]) : unescape(d[4]) : null != d[5] && (b[d[2]] = "true" === d[5]);
|
|
}
|
|
return b;
|
|
}, g: function(a, b, c) {
|
|
void 0 === a && (a = {});
|
|
if (void 0 === b) return a;
|
|
for (var d in b) if (b.hasOwnProperty(d)) {
|
|
if (c && void 0 !== a[d] && a[d] !== b[d]) throw new sjcl2.exception.invalid("required parameter overridden");
|
|
a[d] = b[d];
|
|
}
|
|
return a;
|
|
}, sa: function(a, b) {
|
|
var c = {}, d;
|
|
for (d in a) a.hasOwnProperty(d) && a[d] !== b[d] && (c[d] = a[d]);
|
|
return c;
|
|
}, ra: function(a, b) {
|
|
var c = {}, d;
|
|
for (d = 0; d < b.length; d++) void 0 !== a[b[d]] && (c[b[d]] = a[b[d]]);
|
|
return c;
|
|
} };
|
|
sjcl2.encrypt = sjcl2.json.encrypt;
|
|
sjcl2.decrypt = sjcl2.json.decrypt;
|
|
sjcl2.misc.pa = {};
|
|
sjcl2.misc.cachedPbkdf2 = function(a, b) {
|
|
var c = sjcl2.misc.pa, d;
|
|
b = b || {};
|
|
d = b.iter || 1e3;
|
|
c = c[a] = c[a] || {};
|
|
d = c[d] = c[d] || { firstSalt: b.salt && b.salt.length ? b.salt.slice(0) : sjcl2.random.randomWords(2, 0) };
|
|
c = void 0 === b.salt ? d.firstSalt : b.salt;
|
|
d[c] = d[c] || sjcl2.misc.pbkdf2(a, c, b.iter);
|
|
return { key: d[c].slice(0), salt: c.slice(0) };
|
|
};
|
|
"undefined" !== typeof module && module.exports && (module.exports = sjcl2);
|
|
"function" === typeof define && define([], function() {
|
|
return sjcl2;
|
|
});
|
|
}
|
|
});
|
|
|
|
// src/api/lufi.ts
|
|
var lufi_exports = {};
|
|
__export(lufi_exports, {
|
|
addFilesToArchive: () => addFilesToArchive,
|
|
cancel: () => cancel,
|
|
compress: () => compress,
|
|
decompress: () => decompress,
|
|
download: () => download,
|
|
events: () => events,
|
|
getFileIndexInQueue: () => getFileIndexInQueue,
|
|
infos: () => infos,
|
|
pause: () => pause,
|
|
remove: () => remove,
|
|
resume: () => resume,
|
|
upload: () => upload
|
|
});
|
|
var import_events2 = __toESM(require_events());
|
|
|
|
// 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 || resume2(n, v);
|
|
});
|
|
};
|
|
}
|
|
function resume2(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) {
|
|
resume2("next", value);
|
|
}
|
|
function reject(value) {
|
|
resume2("throw", value);
|
|
}
|
|
function settle(f, v) {
|
|
if (f(v), q.shift(), q.length) resume2(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 okAsync = (value) => new ResultAsync(Promise.resolve(new Ok(value)));
|
|
var errAsync = (err3) => new ResultAsync(Promise.resolve(new Err(err3)));
|
|
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(Result3) {
|
|
function fromThrowable2(fn, errorFn) {
|
|
return (...args) => {
|
|
try {
|
|
const result = fn(...args);
|
|
return ok(result);
|
|
} catch (e) {
|
|
return err(errorFn ? errorFn(e) : e);
|
|
}
|
|
};
|
|
}
|
|
Result3.fromThrowable = fromThrowable2;
|
|
function combine(resultList) {
|
|
return combineResultList(resultList);
|
|
}
|
|
Result3.combine = combine;
|
|
function combineWithAllErrors(resultList) {
|
|
return combineResultListWithAllErrors(resultList);
|
|
}
|
|
Result3.combineWithAllErrors = combineWithAllErrors;
|
|
})(Result || (Result = {}));
|
|
var ok = (value) => new Ok(value);
|
|
function err(err3) {
|
|
return new Err(err3);
|
|
}
|
|
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, err3) {
|
|
return err3(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/entities/lufi-file.ts
|
|
var LufiFile = class _LufiFile {
|
|
constructor(serverUrl, properties) {
|
|
__publicField(this, "actionToken", "");
|
|
__publicField(this, "chunksReady", 0);
|
|
__publicField(this, "createdAt", 0);
|
|
__publicField(this, "delay", 0);
|
|
__publicField(this, "delAtFirstView", false);
|
|
__publicField(this, "keys", { client: "", server: "" });
|
|
__publicField(this, "name", "");
|
|
__publicField(this, "password", "");
|
|
__publicField(this, "queueIndex", 0);
|
|
__publicField(this, "serverUrl");
|
|
__publicField(this, "size", 0);
|
|
__publicField(this, "uploadStatus", 3 /* INITIALIZED */);
|
|
__publicField(this, "totalChunks", 0);
|
|
__publicField(this, "type", "");
|
|
__publicField(this, "zipped", false);
|
|
this.serverUrl = serverUrl;
|
|
Object.assign(this, properties);
|
|
}
|
|
downloadUrl() {
|
|
const serverUrl = new URL(this.serverUrl);
|
|
return new URL(
|
|
`${serverUrl.origin + serverUrl.pathname}r/${this.keys.server}#${this.keys.client}`
|
|
);
|
|
}
|
|
removeUrl() {
|
|
const serverUrl = new URL(this.serverUrl);
|
|
return new URL(
|
|
`${serverUrl.origin + serverUrl.pathname}d/${this.keys.server}/${this.actionToken}`
|
|
);
|
|
}
|
|
static fromDownloadUrl(downloadUrl, password = "") {
|
|
const pathinfos = downloadUrl.pathname.split("r/");
|
|
const keys = {
|
|
client: downloadUrl.hash.slice(1).split("&")[0],
|
|
server: pathinfos[1]
|
|
};
|
|
return new _LufiFile(downloadUrl.origin + pathinfos[0], {
|
|
keys,
|
|
password
|
|
});
|
|
}
|
|
static fromRemoveUrl(removeUrl, password = "") {
|
|
const pathInfos = removeUrl.pathname.split("d/");
|
|
const splittedPath = pathInfos[1].split("/");
|
|
const keys = { client: "", server: splittedPath[0] };
|
|
return new _LufiFile(removeUrl.origin + pathInfos[0], {
|
|
keys,
|
|
password,
|
|
actionToken: splittedPath[1]
|
|
});
|
|
}
|
|
};
|
|
|
|
// src/entities/lufi-job.ts
|
|
var import_events = __toESM(require_events());
|
|
|
|
// src/error/base-error.ts
|
|
var BaseError = class extends Error {
|
|
constructor(message, options = {}) {
|
|
const { cause, context } = options;
|
|
super(message, { cause });
|
|
__publicField(this, "context");
|
|
this.name = this.constructor.name;
|
|
this.context = context;
|
|
}
|
|
};
|
|
|
|
// src/error/connection-error.ts
|
|
var ConnectionError = class extends BaseError {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "message", "Unable to connect. Is the computer able to access the url?");
|
|
}
|
|
};
|
|
|
|
// src/error/server-error.ts
|
|
var ServerError = class extends BaseError {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "message", "The server returned an error");
|
|
}
|
|
};
|
|
|
|
// 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 fetchServerConfig = (instanceUrl) => {
|
|
const originMatches = instanceUrl.href.match(
|
|
/(.*?)\/?(?:[dr]{1}\/|login\/?|files\/?)/
|
|
);
|
|
const urlOrigin = originMatches && originMatches[1] ? originMatches[1] : instanceUrl.origin;
|
|
return ResultAsync.fromPromise(
|
|
fetch(urlOrigin + "/about/config"),
|
|
(error) => new ConnectionError(void 0, {
|
|
cause: ensureError(error)
|
|
})
|
|
).andThen((response) => {
|
|
if (response.ok) {
|
|
return ResultAsync.fromPromise(
|
|
response.json(),
|
|
(error) => ensureError(error)
|
|
);
|
|
} else {
|
|
return errAsync(
|
|
new ServerError(void 0, { context: response.statusText })
|
|
);
|
|
}
|
|
});
|
|
};
|
|
var isDenoRuntime = () => typeof Deno !== "undefined";
|
|
var isSecureContext = () => {
|
|
return isDenoRuntime() || typeof window !== "undefined" && (window.isSecureContext || window.location.protocol === "https:");
|
|
};
|
|
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`
|
|
)
|
|
);
|
|
var hashPassword = async (password) => password ? Array.from(
|
|
new Uint8Array(
|
|
await crypto.subtle.digest(
|
|
"SHA-512",
|
|
new TextEncoder().encode(password)
|
|
)
|
|
)
|
|
).map((b) => b.toString(16).padStart(2, "0")).join("") : "";
|
|
|
|
// src/entities/lufi-job.ts
|
|
var LufiJob = class {
|
|
constructor(lufiFile) {
|
|
__publicField(this, "events", new import_events.default());
|
|
__publicField(this, "lufiFile");
|
|
__publicField(this, "status", 2 /* ONGOING */);
|
|
__publicField(this, "tmpFile");
|
|
__publicField(this, "tmpChunks", []);
|
|
__publicField(this, "worker");
|
|
__publicField(this, "isTerminated", false);
|
|
/**
|
|
* Tells the worker the job is complete
|
|
*/
|
|
__publicField(this, "complete", () => {
|
|
this.status = 0 /* COMPLETE */;
|
|
this.events.emit("JOB_TERMINATED" /* JOB_TERMINATED */);
|
|
});
|
|
__publicField(this, "hasFailed", () => this.status === 1 /* FAILED */);
|
|
__publicField(this, "onError", (callback) => {
|
|
this.worker.onerror = (event) => {
|
|
callback(event);
|
|
};
|
|
return this;
|
|
});
|
|
__publicField(this, "onMessage", (callback) => {
|
|
this.worker.onmessage = (e) => {
|
|
if (callback) {
|
|
callback(e);
|
|
}
|
|
const event = e.data.event;
|
|
if (event) {
|
|
if (event === "FILE_UPDATED" /* FILE_UPDATED */) {
|
|
Object.assign(this.lufiFile, e.data.lufiFile);
|
|
} else {
|
|
this.dispatchEvent(event, e.data.error);
|
|
}
|
|
}
|
|
};
|
|
return this;
|
|
});
|
|
__publicField(this, "onMessageError", (callback) => {
|
|
this.worker.onmessageerror = (event) => {
|
|
callback(event);
|
|
};
|
|
return this;
|
|
});
|
|
__publicField(this, "onProgress", (callback) => {
|
|
this.events.on("CHUNK_UPLOADED" /* CHUNK_UPLOADED */, () => {
|
|
callback();
|
|
});
|
|
this.events.on("CHUNK_DOWNLOADED" /* CHUNK_DOWNLOADED */, () => {
|
|
callback();
|
|
});
|
|
return this;
|
|
});
|
|
__publicField(this, "requestMessage", (msg, transferable = []) => {
|
|
this.worker.postMessage(msg, transferable);
|
|
return this;
|
|
});
|
|
__publicField(this, "terminate", () => {
|
|
this.worker.terminate();
|
|
return this;
|
|
});
|
|
__publicField(this, "waitForCompletion", () => {
|
|
if (this.isTerminated) {
|
|
if (this.status === 0 /* COMPLETE */) {
|
|
return okAsync(this);
|
|
} else {
|
|
return errAsync(ensureError("Job has failed"));
|
|
}
|
|
} else {
|
|
return ResultAsync.fromPromise(
|
|
new Promise((resolve, reject) => {
|
|
this.events.once("OPERATION_FAILED" /* OPERATION_FAILED */, (error) => {
|
|
reject(error);
|
|
});
|
|
this.events.once("JOB_TERMINATED" /* JOB_TERMINATED */, () => {
|
|
if (this.status === 0 /* COMPLETE */) {
|
|
resolve(this);
|
|
}
|
|
});
|
|
}),
|
|
(error) => ensureError(error)
|
|
);
|
|
}
|
|
});
|
|
__publicField(this, "dispatchEvent", (event, error) => {
|
|
this.events.emit(event, error);
|
|
});
|
|
this.worker = new Worker(workerUrl("main"), { type: "module" });
|
|
this.lufiFile = lufiFile;
|
|
this.events.once("JOB_TERMINATED" /* JOB_TERMINATED */, () => {
|
|
this.isTerminated = true;
|
|
this.terminate();
|
|
});
|
|
this.events.once("OPERATION_FAILED" /* OPERATION_FAILED */, (error) => {
|
|
this.status = 1 /* FAILED */;
|
|
this.lufiFile.uploadStatus = 2 /* FAILED */;
|
|
this.events.emit("JOB_TERMINATED" /* JOB_TERMINATED */, error);
|
|
});
|
|
this.onError((event) => console.error(event.error));
|
|
}
|
|
};
|
|
|
|
// src/enum/crypto-algorithm.ts
|
|
var CryptoAlgorithm = /* @__PURE__ */ ((CryptoAlgorithm2) => {
|
|
CryptoAlgorithm2[CryptoAlgorithm2["Sjcl"] = 0] = "Sjcl";
|
|
CryptoAlgorithm2[CryptoAlgorithm2["WebCrypto"] = 1] = "WebCrypto";
|
|
return CryptoAlgorithm2;
|
|
})(CryptoAlgorithm || {});
|
|
|
|
// node_modules/.deno/arraybuffer-encoding@1.1.0/node_modules/arraybuffer-encoding/dist/esm/base64/encoding.js
|
|
var Encoding = class {
|
|
/**
|
|
*
|
|
* @param charset Charset to use for base64 encoding. This must be 64-characters long.
|
|
* @param noPadding If true, encoded strings won't include padding.
|
|
*/
|
|
constructor(charset, noPadding) {
|
|
if (!charset || charset.length != 64) {
|
|
throw Error("Charset must contain 64 characters");
|
|
}
|
|
this._charset = charset;
|
|
this._noPadding = !!noPadding;
|
|
this._valid = new RegExp("^[" + this._charset.replace("-", "\\-") + "]+={0,2}$");
|
|
}
|
|
/**
|
|
* Encode an ArrayBuffer to base64 in a string.
|
|
* @param ab Data to encode to base64
|
|
* @returns Base64-encoded string
|
|
*/
|
|
Encode(ab) {
|
|
const len = ab.byteLength;
|
|
if (!len) {
|
|
return "";
|
|
}
|
|
const view = new Uint8Array(ab);
|
|
let res = "";
|
|
for (let i = 0; i < len; i += 3) {
|
|
res += this._charset[view[i] >> 2] + this._charset[(view[i] & 3) << 4 | view[i + 1] >> 4] + this._charset[(view[i + 1] & 15) << 2 | view[i + 2] >> 6] + this._charset[view[i + 2] & 63];
|
|
}
|
|
if (len % 3 == 2) {
|
|
res = res.substring(0, res.length - 1);
|
|
if (!this._noPadding) {
|
|
res += "=";
|
|
}
|
|
} else if (len % 3 == 1) {
|
|
res = res.substring(0, res.length - 2);
|
|
if (!this._noPadding) {
|
|
res += "==";
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
/**
|
|
* Decode a string from base64. Padding is always optional.
|
|
* @param str Base64-encoded string
|
|
* @returns Data decoded from the base64 string
|
|
*/
|
|
Decode(str) {
|
|
str = (str || "").replace(/[\s]/g, "");
|
|
if (!str) {
|
|
return new ArrayBuffer(0);
|
|
}
|
|
if (!this._valid.test(str)) {
|
|
throw Error("Invalid base64 input sequence");
|
|
}
|
|
let viewLen = Math.floor(str.length * 0.75);
|
|
if (str[str.length - 2] == "=") {
|
|
viewLen -= 2;
|
|
} else if (str[str.length - 1] == "=") {
|
|
viewLen--;
|
|
}
|
|
const view = new Uint8Array(viewLen);
|
|
let enc1, enc2, enc3, enc4, i = 0, j = 0;
|
|
while (i < str.length * 0.75) {
|
|
enc1 = this._charset.indexOf(str.charAt(j++));
|
|
enc2 = this._charset.indexOf(str.charAt(j++));
|
|
enc3 = this._charset.indexOf(str.charAt(j++));
|
|
enc4 = this._charset.indexOf(str.charAt(j++));
|
|
view[i++] = enc1 << 2 | enc2 >> 4;
|
|
view[i++] = (enc2 & 15) << 4 | enc3 >> 2;
|
|
view[i++] = (enc3 & 3) << 6 | enc4;
|
|
}
|
|
return view.buffer;
|
|
}
|
|
};
|
|
|
|
// node_modules/.deno/arraybuffer-encoding@1.1.0/node_modules/arraybuffer-encoding/dist/esm/base64/standard.js
|
|
var obj = new Encoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
|
|
|
|
// node_modules/.deno/arraybuffer-encoding@1.1.0/node_modules/arraybuffer-encoding/dist/esm/base64/url.js
|
|
var obj2 = new Encoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", true);
|
|
function Encode(ab) {
|
|
return obj2.Encode(ab);
|
|
}
|
|
|
|
// src/api/crypto/sjcl.ts
|
|
var import_sjcl = __toESM(require_sjcl());
|
|
|
|
// src/error/crypto/crypto-error.ts
|
|
var CryptoError = class extends BaseError {
|
|
};
|
|
|
|
// src/error/crypto/decryption-error.ts
|
|
var DecryptionError = class extends CryptoError {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "message", "Unable to decrypt the provided data");
|
|
}
|
|
};
|
|
|
|
// src/api/crypto/sjcl.ts
|
|
var generateKey = () => {
|
|
try {
|
|
return okAsync(import_sjcl.default.codec.base64.fromBits(import_sjcl.default.random.randomWords(8, 10)));
|
|
} catch (e) {
|
|
return errAsync(
|
|
new CryptoError("Unable to generate a random key", {
|
|
cause: ensureError(e)
|
|
})
|
|
);
|
|
}
|
|
};
|
|
|
|
// src/api/crypto/web.ts
|
|
var generateKey2 = () => {
|
|
return ResultAsync.fromPromise(
|
|
new Promise(
|
|
(resolve) => crypto.subtle.generateKey(
|
|
{
|
|
name: "AES-GCM",
|
|
length: 256
|
|
},
|
|
true,
|
|
["encrypt", "decrypt"]
|
|
).then(
|
|
(generatedKey) => crypto.subtle.exportKey("raw", generatedKey).then((key) => resolve(Encode(key))).catch(
|
|
(error) => errAsync(
|
|
new DecryptionError(void 0, { cause: ensureError(error) })
|
|
)
|
|
)
|
|
).catch(
|
|
(error) => errAsync(
|
|
new DecryptionError(void 0, { cause: ensureError(error) })
|
|
)
|
|
)
|
|
),
|
|
(error) => new CryptoError("Unable to base64 encode the url", {
|
|
cause: ensureError(error)
|
|
})
|
|
);
|
|
};
|
|
|
|
// src/api/crypto.ts
|
|
var generateKey3 = (algo = 1 /* WebCrypto */) => {
|
|
return algo === 0 /* Sjcl */ ? generateKey() : generateKey2();
|
|
};
|
|
|
|
// src/error/file/file-error.ts
|
|
var FileError = class extends BaseError {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "message", "An error occured while dealing with a file");
|
|
}
|
|
};
|
|
|
|
// src/error/file/file-operation-error.ts
|
|
var FileOperationError = class extends FileError {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "message", "An error occured while operating on a file");
|
|
}
|
|
};
|
|
|
|
// src/error/file/file-slicing-error.ts
|
|
var FileSlicingError = class extends FileOperationError {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "message", "An error occured while slicing a file");
|
|
}
|
|
};
|
|
|
|
// node_modules/.deno/fflate@0.8.2/node_modules/fflate/esm/browser.js
|
|
var ch2 = {};
|
|
var wk = function(c, id, msg, transfer, cb) {
|
|
var w = new Worker(ch2[id] || (ch2[id] = URL.createObjectURL(new Blob([
|
|
c + ';addEventListener("error",function(e){e=e.error;postMessage({$e$:[e.message,e.code,e.stack]})})'
|
|
], { type: "text/javascript" }))));
|
|
w.onmessage = function(e) {
|
|
var d = e.data, ed = d.$e$;
|
|
if (ed) {
|
|
var err3 = new Error(ed[0]);
|
|
err3["code"] = ed[1];
|
|
err3.stack = ed[2];
|
|
cb(err3, null);
|
|
} else
|
|
cb(null, d);
|
|
};
|
|
w.postMessage(msg, transfer);
|
|
return w;
|
|
};
|
|
var u8 = Uint8Array;
|
|
var u16 = Uint16Array;
|
|
var i32 = Int32Array;
|
|
var fleb = new u8([
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
5,
|
|
5,
|
|
5,
|
|
5,
|
|
0,
|
|
/* unused */
|
|
0,
|
|
0,
|
|
/* impossible */
|
|
0
|
|
]);
|
|
var fdeb = new u8([
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
1,
|
|
2,
|
|
2,
|
|
3,
|
|
3,
|
|
4,
|
|
4,
|
|
5,
|
|
5,
|
|
6,
|
|
6,
|
|
7,
|
|
7,
|
|
8,
|
|
8,
|
|
9,
|
|
9,
|
|
10,
|
|
10,
|
|
11,
|
|
11,
|
|
12,
|
|
12,
|
|
13,
|
|
13,
|
|
/* unused */
|
|
0,
|
|
0
|
|
]);
|
|
var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
|
|
var freb = function(eb, start) {
|
|
var b = new u16(31);
|
|
for (var i = 0; i < 31; ++i) {
|
|
b[i] = start += 1 << eb[i - 1];
|
|
}
|
|
var r = new i32(b[30]);
|
|
for (var i = 1; i < 30; ++i) {
|
|
for (var j = b[i]; j < b[i + 1]; ++j) {
|
|
r[j] = j - b[i] << 5 | i;
|
|
}
|
|
}
|
|
return { b, r };
|
|
};
|
|
var _a = freb(fleb, 2);
|
|
var fl = _a.b;
|
|
var revfl = _a.r;
|
|
fl[28] = 258, revfl[258] = 28;
|
|
var _b = freb(fdeb, 0);
|
|
var fd = _b.b;
|
|
var revfd = _b.r;
|
|
var rev = new u16(32768);
|
|
for (i = 0; i < 32768; ++i) {
|
|
x = (i & 43690) >> 1 | (i & 21845) << 1;
|
|
x = (x & 52428) >> 2 | (x & 13107) << 2;
|
|
x = (x & 61680) >> 4 | (x & 3855) << 4;
|
|
rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
|
|
}
|
|
var x;
|
|
var i;
|
|
var hMap = function(cd, mb, r) {
|
|
var s = cd.length;
|
|
var i = 0;
|
|
var l = new u16(mb);
|
|
for (; i < s; ++i) {
|
|
if (cd[i])
|
|
++l[cd[i] - 1];
|
|
}
|
|
var le = new u16(mb);
|
|
for (i = 1; i < mb; ++i) {
|
|
le[i] = le[i - 1] + l[i - 1] << 1;
|
|
}
|
|
var co;
|
|
if (r) {
|
|
co = new u16(1 << mb);
|
|
var rvb = 15 - mb;
|
|
for (i = 0; i < s; ++i) {
|
|
if (cd[i]) {
|
|
var sv = i << 4 | cd[i];
|
|
var r_1 = mb - cd[i];
|
|
var v = le[cd[i] - 1]++ << r_1;
|
|
for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
|
|
co[rev[v] >> rvb] = sv;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
co = new u16(s);
|
|
for (i = 0; i < s; ++i) {
|
|
if (cd[i]) {
|
|
co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
|
|
}
|
|
}
|
|
}
|
|
return co;
|
|
};
|
|
var flt = new u8(288);
|
|
for (i = 0; i < 144; ++i)
|
|
flt[i] = 8;
|
|
var i;
|
|
for (i = 144; i < 256; ++i)
|
|
flt[i] = 9;
|
|
var i;
|
|
for (i = 256; i < 280; ++i)
|
|
flt[i] = 7;
|
|
var i;
|
|
for (i = 280; i < 288; ++i)
|
|
flt[i] = 8;
|
|
var i;
|
|
var fdt = new u8(32);
|
|
for (i = 0; i < 32; ++i)
|
|
fdt[i] = 5;
|
|
var i;
|
|
var flm = /* @__PURE__ */ hMap(flt, 9, 0);
|
|
var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
|
|
var fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
|
|
var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
|
|
var max = function(a) {
|
|
var m = a[0];
|
|
for (var i = 1; i < a.length; ++i) {
|
|
if (a[i] > m)
|
|
m = a[i];
|
|
}
|
|
return m;
|
|
};
|
|
var bits = function(d, p, m) {
|
|
var o = p / 8 | 0;
|
|
return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
|
|
};
|
|
var bits16 = function(d, p) {
|
|
var o = p / 8 | 0;
|
|
return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
|
|
};
|
|
var shft = function(p) {
|
|
return (p + 7) / 8 | 0;
|
|
};
|
|
var slc = function(v, s, e) {
|
|
if (s == null || s < 0)
|
|
s = 0;
|
|
if (e == null || e > v.length)
|
|
e = v.length;
|
|
return new u8(v.subarray(s, e));
|
|
};
|
|
var ec = [
|
|
"unexpected EOF",
|
|
"invalid block type",
|
|
"invalid length/literal",
|
|
"invalid distance",
|
|
"stream finished",
|
|
"no stream handler",
|
|
,
|
|
"no callback",
|
|
"invalid UTF-8 data",
|
|
"extra field too long",
|
|
"date not in range 1980-2099",
|
|
"filename too long",
|
|
"stream finishing",
|
|
"invalid zip data"
|
|
// determined by unknown compression method
|
|
];
|
|
var err2 = function(ind, msg, nt) {
|
|
var e = new Error(msg || ec[ind]);
|
|
e.code = ind;
|
|
if (Error.captureStackTrace)
|
|
Error.captureStackTrace(e, err2);
|
|
if (!nt)
|
|
throw e;
|
|
return e;
|
|
};
|
|
var inflt = function(dat, st, buf, dict) {
|
|
var sl = dat.length, dl = dict ? dict.length : 0;
|
|
if (!sl || st.f && !st.l)
|
|
return buf || new u8(0);
|
|
var noBuf = !buf;
|
|
var resize = noBuf || st.i != 2;
|
|
var noSt = st.i;
|
|
if (noBuf)
|
|
buf = new u8(sl * 3);
|
|
var cbuf = function(l2) {
|
|
var bl = buf.length;
|
|
if (l2 > bl) {
|
|
var nbuf = new u8(Math.max(bl * 2, l2));
|
|
nbuf.set(buf);
|
|
buf = nbuf;
|
|
}
|
|
};
|
|
var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
|
|
var tbts = sl * 8;
|
|
do {
|
|
if (!lm) {
|
|
final = bits(dat, pos, 1);
|
|
var type = bits(dat, pos + 1, 3);
|
|
pos += 3;
|
|
if (!type) {
|
|
var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
|
|
if (t > sl) {
|
|
if (noSt)
|
|
err2(0);
|
|
break;
|
|
}
|
|
if (resize)
|
|
cbuf(bt + l);
|
|
buf.set(dat.subarray(s, t), bt);
|
|
st.b = bt += l, st.p = pos = t * 8, st.f = final;
|
|
continue;
|
|
} else if (type == 1)
|
|
lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
|
|
else if (type == 2) {
|
|
var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
|
|
var tl = hLit + bits(dat, pos + 5, 31) + 1;
|
|
pos += 14;
|
|
var ldt = new u8(tl);
|
|
var clt = new u8(19);
|
|
for (var i = 0; i < hcLen; ++i) {
|
|
clt[clim[i]] = bits(dat, pos + i * 3, 7);
|
|
}
|
|
pos += hcLen * 3;
|
|
var clb = max(clt), clbmsk = (1 << clb) - 1;
|
|
var clm = hMap(clt, clb, 1);
|
|
for (var i = 0; i < tl; ) {
|
|
var r = clm[bits(dat, pos, clbmsk)];
|
|
pos += r & 15;
|
|
var s = r >> 4;
|
|
if (s < 16) {
|
|
ldt[i++] = s;
|
|
} else {
|
|
var c = 0, n = 0;
|
|
if (s == 16)
|
|
n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
|
|
else if (s == 17)
|
|
n = 3 + bits(dat, pos, 7), pos += 3;
|
|
else if (s == 18)
|
|
n = 11 + bits(dat, pos, 127), pos += 7;
|
|
while (n--)
|
|
ldt[i++] = c;
|
|
}
|
|
}
|
|
var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
|
|
lbt = max(lt);
|
|
dbt = max(dt);
|
|
lm = hMap(lt, lbt, 1);
|
|
dm = hMap(dt, dbt, 1);
|
|
} else
|
|
err2(1);
|
|
if (pos > tbts) {
|
|
if (noSt)
|
|
err2(0);
|
|
break;
|
|
}
|
|
}
|
|
if (resize)
|
|
cbuf(bt + 131072);
|
|
var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
|
|
var lpos = pos;
|
|
for (; ; lpos = pos) {
|
|
var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
|
|
pos += c & 15;
|
|
if (pos > tbts) {
|
|
if (noSt)
|
|
err2(0);
|
|
break;
|
|
}
|
|
if (!c)
|
|
err2(2);
|
|
if (sym < 256)
|
|
buf[bt++] = sym;
|
|
else if (sym == 256) {
|
|
lpos = pos, lm = null;
|
|
break;
|
|
} else {
|
|
var add = sym - 254;
|
|
if (sym > 264) {
|
|
var i = sym - 257, b = fleb[i];
|
|
add = bits(dat, pos, (1 << b) - 1) + fl[i];
|
|
pos += b;
|
|
}
|
|
var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
|
|
if (!d)
|
|
err2(3);
|
|
pos += d & 15;
|
|
var dt = fd[dsym];
|
|
if (dsym > 3) {
|
|
var b = fdeb[dsym];
|
|
dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
|
|
}
|
|
if (pos > tbts) {
|
|
if (noSt)
|
|
err2(0);
|
|
break;
|
|
}
|
|
if (resize)
|
|
cbuf(bt + 131072);
|
|
var end = bt + add;
|
|
if (bt < dt) {
|
|
var shift = dl - dt, dend = Math.min(dt, end);
|
|
if (shift + bt < 0)
|
|
err2(3);
|
|
for (; bt < dend; ++bt)
|
|
buf[bt] = dict[shift + bt];
|
|
}
|
|
for (; bt < end; ++bt)
|
|
buf[bt] = buf[bt - dt];
|
|
}
|
|
}
|
|
st.l = lm, st.p = lpos, st.b = bt, st.f = final;
|
|
if (lm)
|
|
final = 1, st.m = lbt, st.d = dm, st.n = dbt;
|
|
} while (!final);
|
|
return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
|
|
};
|
|
var wbits = function(d, p, v) {
|
|
v <<= p & 7;
|
|
var o = p / 8 | 0;
|
|
d[o] |= v;
|
|
d[o + 1] |= v >> 8;
|
|
};
|
|
var wbits16 = function(d, p, v) {
|
|
v <<= p & 7;
|
|
var o = p / 8 | 0;
|
|
d[o] |= v;
|
|
d[o + 1] |= v >> 8;
|
|
d[o + 2] |= v >> 16;
|
|
};
|
|
var hTree = function(d, mb) {
|
|
var t = [];
|
|
for (var i = 0; i < d.length; ++i) {
|
|
if (d[i])
|
|
t.push({ s: i, f: d[i] });
|
|
}
|
|
var s = t.length;
|
|
var t2 = t.slice();
|
|
if (!s)
|
|
return { t: et, l: 0 };
|
|
if (s == 1) {
|
|
var v = new u8(t[0].s + 1);
|
|
v[t[0].s] = 1;
|
|
return { t: v, l: 1 };
|
|
}
|
|
t.sort(function(a, b) {
|
|
return a.f - b.f;
|
|
});
|
|
t.push({ s: -1, f: 25001 });
|
|
var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2;
|
|
t[0] = { s: -1, f: l.f + r.f, l, r };
|
|
while (i1 != s - 1) {
|
|
l = t[t[i0].f < t[i2].f ? i0++ : i2++];
|
|
r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++];
|
|
t[i1++] = { s: -1, f: l.f + r.f, l, r };
|
|
}
|
|
var maxSym = t2[0].s;
|
|
for (var i = 1; i < s; ++i) {
|
|
if (t2[i].s > maxSym)
|
|
maxSym = t2[i].s;
|
|
}
|
|
var tr = new u16(maxSym + 1);
|
|
var mbt = ln(t[i1 - 1], tr, 0);
|
|
if (mbt > mb) {
|
|
var i = 0, dt = 0;
|
|
var lft = mbt - mb, cst = 1 << lft;
|
|
t2.sort(function(a, b) {
|
|
return tr[b.s] - tr[a.s] || a.f - b.f;
|
|
});
|
|
for (; i < s; ++i) {
|
|
var i2_1 = t2[i].s;
|
|
if (tr[i2_1] > mb) {
|
|
dt += cst - (1 << mbt - tr[i2_1]);
|
|
tr[i2_1] = mb;
|
|
} else
|
|
break;
|
|
}
|
|
dt >>= lft;
|
|
while (dt > 0) {
|
|
var i2_2 = t2[i].s;
|
|
if (tr[i2_2] < mb)
|
|
dt -= 1 << mb - tr[i2_2]++ - 1;
|
|
else
|
|
++i;
|
|
}
|
|
for (; i >= 0 && dt; --i) {
|
|
var i2_3 = t2[i].s;
|
|
if (tr[i2_3] == mb) {
|
|
--tr[i2_3];
|
|
++dt;
|
|
}
|
|
}
|
|
mbt = mb;
|
|
}
|
|
return { t: new u8(tr), l: mbt };
|
|
};
|
|
var ln = function(n, l, d) {
|
|
return n.s == -1 ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) : l[n.s] = d;
|
|
};
|
|
var lc = function(c) {
|
|
var s = c.length;
|
|
while (s && !c[--s])
|
|
;
|
|
var cl = new u16(++s);
|
|
var cli = 0, cln = c[0], cls = 1;
|
|
var w = function(v) {
|
|
cl[cli++] = v;
|
|
};
|
|
for (var i = 1; i <= s; ++i) {
|
|
if (c[i] == cln && i != s)
|
|
++cls;
|
|
else {
|
|
if (!cln && cls > 2) {
|
|
for (; cls > 138; cls -= 138)
|
|
w(32754);
|
|
if (cls > 2) {
|
|
w(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
|
|
cls = 0;
|
|
}
|
|
} else if (cls > 3) {
|
|
w(cln), --cls;
|
|
for (; cls > 6; cls -= 6)
|
|
w(8304);
|
|
if (cls > 2)
|
|
w(cls - 3 << 5 | 8208), cls = 0;
|
|
}
|
|
while (cls--)
|
|
w(cln);
|
|
cls = 1;
|
|
cln = c[i];
|
|
}
|
|
}
|
|
return { c: cl.subarray(0, cli), n: s };
|
|
};
|
|
var clen = function(cf, cl) {
|
|
var l = 0;
|
|
for (var i = 0; i < cl.length; ++i)
|
|
l += cf[i] * cl[i];
|
|
return l;
|
|
};
|
|
var wfblk = function(out, pos, dat) {
|
|
var s = dat.length;
|
|
var o = shft(pos + 2);
|
|
out[o] = s & 255;
|
|
out[o + 1] = s >> 8;
|
|
out[o + 2] = out[o] ^ 255;
|
|
out[o + 3] = out[o + 1] ^ 255;
|
|
for (var i = 0; i < s; ++i)
|
|
out[o + i + 4] = dat[i];
|
|
return (o + 4 + s) * 8;
|
|
};
|
|
var wblk = function(dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
|
|
wbits(out, p++, final);
|
|
++lf[256];
|
|
var _a2 = hTree(lf, 15), dlt = _a2.t, mlb = _a2.l;
|
|
var _b2 = hTree(df, 15), ddt = _b2.t, mdb = _b2.l;
|
|
var _c = lc(dlt), lclt = _c.c, nlc = _c.n;
|
|
var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;
|
|
var lcfreq = new u16(19);
|
|
for (var i = 0; i < lclt.length; ++i)
|
|
++lcfreq[lclt[i] & 31];
|
|
for (var i = 0; i < lcdt.length; ++i)
|
|
++lcfreq[lcdt[i] & 31];
|
|
var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;
|
|
var nlcc = 19;
|
|
for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
|
|
;
|
|
var flen = bl + 5 << 3;
|
|
var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
|
|
var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
|
|
if (bs >= 0 && flen <= ftlen && flen <= dtlen)
|
|
return wfblk(out, p, dat.subarray(bs, bs + bl));
|
|
var lm, ll, dm, dl;
|
|
wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
|
|
if (dtlen < ftlen) {
|
|
lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
|
|
var llm = hMap(lct, mlcb, 0);
|
|
wbits(out, p, nlc - 257);
|
|
wbits(out, p + 5, ndc - 1);
|
|
wbits(out, p + 10, nlcc - 4);
|
|
p += 14;
|
|
for (var i = 0; i < nlcc; ++i)
|
|
wbits(out, p + 3 * i, lct[clim[i]]);
|
|
p += 3 * nlcc;
|
|
var lcts = [lclt, lcdt];
|
|
for (var it = 0; it < 2; ++it) {
|
|
var clct = lcts[it];
|
|
for (var i = 0; i < clct.length; ++i) {
|
|
var len = clct[i] & 31;
|
|
wbits(out, p, llm[len]), p += lct[len];
|
|
if (len > 15)
|
|
wbits(out, p, clct[i] >> 5 & 127), p += clct[i] >> 12;
|
|
}
|
|
}
|
|
} else {
|
|
lm = flm, ll = flt, dm = fdm, dl = fdt;
|
|
}
|
|
for (var i = 0; i < li; ++i) {
|
|
var sym = syms[i];
|
|
if (sym > 255) {
|
|
var len = sym >> 18 & 31;
|
|
wbits16(out, p, lm[len + 257]), p += ll[len + 257];
|
|
if (len > 7)
|
|
wbits(out, p, sym >> 23 & 31), p += fleb[len];
|
|
var dst = sym & 31;
|
|
wbits16(out, p, dm[dst]), p += dl[dst];
|
|
if (dst > 3)
|
|
wbits16(out, p, sym >> 5 & 8191), p += fdeb[dst];
|
|
} else {
|
|
wbits16(out, p, lm[sym]), p += ll[sym];
|
|
}
|
|
}
|
|
wbits16(out, p, lm[256]);
|
|
return p + ll[256];
|
|
};
|
|
var deo = /* @__PURE__ */ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
|
|
var et = /* @__PURE__ */ new u8(0);
|
|
var dflt = function(dat, lvl, plvl, pre, post, st) {
|
|
var s = st.z || dat.length;
|
|
var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7e3)) + post);
|
|
var w = o.subarray(pre, o.length - post);
|
|
var lst = st.l;
|
|
var pos = (st.r || 0) & 7;
|
|
if (lvl) {
|
|
if (pos)
|
|
w[0] = st.r >> 3;
|
|
var opt = deo[lvl - 1];
|
|
var n = opt >> 13, c = opt & 8191;
|
|
var msk_1 = (1 << plvl) - 1;
|
|
var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
|
|
var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
|
|
var hsh = function(i2) {
|
|
return (dat[i2] ^ dat[i2 + 1] << bs1_1 ^ dat[i2 + 2] << bs2_1) & msk_1;
|
|
};
|
|
var syms = new i32(25e3);
|
|
var lf = new u16(288), df = new u16(32);
|
|
var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
|
|
for (; i + 2 < s; ++i) {
|
|
var hv = hsh(i);
|
|
var imod = i & 32767, pimod = head[hv];
|
|
prev[imod] = pimod;
|
|
head[hv] = imod;
|
|
if (wi <= i) {
|
|
var rem = s - i;
|
|
if ((lc_1 > 7e3 || li > 24576) && (rem > 423 || !lst)) {
|
|
pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);
|
|
li = lc_1 = eb = 0, bs = i;
|
|
for (var j = 0; j < 286; ++j)
|
|
lf[j] = 0;
|
|
for (var j = 0; j < 30; ++j)
|
|
df[j] = 0;
|
|
}
|
|
var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
|
|
if (rem > 2 && hv == hsh(i - dif)) {
|
|
var maxn = Math.min(n, rem) - 1;
|
|
var maxd = Math.min(32767, i);
|
|
var ml = Math.min(258, rem);
|
|
while (dif <= maxd && --ch_1 && imod != pimod) {
|
|
if (dat[i + l] == dat[i + l - dif]) {
|
|
var nl = 0;
|
|
for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl)
|
|
;
|
|
if (nl > l) {
|
|
l = nl, d = dif;
|
|
if (nl > maxn)
|
|
break;
|
|
var mmd = Math.min(dif, nl - 2);
|
|
var md = 0;
|
|
for (var j = 0; j < mmd; ++j) {
|
|
var ti = i - dif + j & 32767;
|
|
var pti = prev[ti];
|
|
var cd = ti - pti & 32767;
|
|
if (cd > md)
|
|
md = cd, pimod = ti;
|
|
}
|
|
}
|
|
}
|
|
imod = pimod, pimod = prev[imod];
|
|
dif += imod - pimod & 32767;
|
|
}
|
|
}
|
|
if (d) {
|
|
syms[li++] = 268435456 | revfl[l] << 18 | revfd[d];
|
|
var lin = revfl[l] & 31, din = revfd[d] & 31;
|
|
eb += fleb[lin] + fdeb[din];
|
|
++lf[257 + lin];
|
|
++df[din];
|
|
wi = i + l;
|
|
++lc_1;
|
|
} else {
|
|
syms[li++] = dat[i];
|
|
++lf[dat[i]];
|
|
}
|
|
}
|
|
}
|
|
for (i = Math.max(i, wi); i < s; ++i) {
|
|
syms[li++] = dat[i];
|
|
++lf[dat[i]];
|
|
}
|
|
pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
|
|
if (!lst) {
|
|
st.r = pos & 7 | w[pos / 8 | 0] << 3;
|
|
pos -= 7;
|
|
st.h = head, st.p = prev, st.i = i, st.w = wi;
|
|
}
|
|
} else {
|
|
for (var i = st.w || 0; i < s + lst; i += 65535) {
|
|
var e = i + 65535;
|
|
if (e >= s) {
|
|
w[pos / 8 | 0] = lst;
|
|
e = s;
|
|
}
|
|
pos = wfblk(w, pos + 1, dat.subarray(i, e));
|
|
}
|
|
st.i = s;
|
|
}
|
|
return slc(o, 0, pre + shft(pos) + post);
|
|
};
|
|
var crct = /* @__PURE__ */ function() {
|
|
var t = new Int32Array(256);
|
|
for (var i = 0; i < 256; ++i) {
|
|
var c = i, k = 9;
|
|
while (--k)
|
|
c = (c & 1 && -306674912) ^ c >>> 1;
|
|
t[i] = c;
|
|
}
|
|
return t;
|
|
}();
|
|
var crc = function() {
|
|
var c = -1;
|
|
return {
|
|
p: function(d) {
|
|
var cr = c;
|
|
for (var i = 0; i < d.length; ++i)
|
|
cr = crct[cr & 255 ^ d[i]] ^ cr >>> 8;
|
|
c = cr;
|
|
},
|
|
d: function() {
|
|
return ~c;
|
|
}
|
|
};
|
|
};
|
|
var dopt = function(dat, opt, pre, post, st) {
|
|
if (!st) {
|
|
st = { l: 1 };
|
|
if (opt.dictionary) {
|
|
var dict = opt.dictionary.subarray(-32768);
|
|
var newDat = new u8(dict.length + dat.length);
|
|
newDat.set(dict);
|
|
newDat.set(dat, dict.length);
|
|
dat = newDat;
|
|
st.w = dict.length;
|
|
}
|
|
}
|
|
return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20 : 12 + opt.mem, pre, post, st);
|
|
};
|
|
var mrg = function(a, b) {
|
|
var o = {};
|
|
for (var k in a)
|
|
o[k] = a[k];
|
|
for (var k in b)
|
|
o[k] = b[k];
|
|
return o;
|
|
};
|
|
var wcln = function(fn, fnStr, td2) {
|
|
var dt = fn();
|
|
var st = fn.toString();
|
|
var ks = st.slice(st.indexOf("[") + 1, st.lastIndexOf("]")).replace(/\s+/g, "").split(",");
|
|
for (var i = 0; i < dt.length; ++i) {
|
|
var v = dt[i], k = ks[i];
|
|
if (typeof v == "function") {
|
|
fnStr += ";" + k + "=";
|
|
var st_1 = v.toString();
|
|
if (v.prototype) {
|
|
if (st_1.indexOf("[native code]") != -1) {
|
|
var spInd = st_1.indexOf(" ", 8) + 1;
|
|
fnStr += st_1.slice(spInd, st_1.indexOf("(", spInd));
|
|
} else {
|
|
fnStr += st_1;
|
|
for (var t in v.prototype)
|
|
fnStr += ";" + k + ".prototype." + t + "=" + v.prototype[t].toString();
|
|
}
|
|
} else
|
|
fnStr += st_1;
|
|
} else
|
|
td2[k] = v;
|
|
}
|
|
return fnStr;
|
|
};
|
|
var ch = [];
|
|
var cbfs = function(v) {
|
|
var tl = [];
|
|
for (var k in v) {
|
|
if (v[k].buffer) {
|
|
tl.push((v[k] = new v[k].constructor(v[k])).buffer);
|
|
}
|
|
}
|
|
return tl;
|
|
};
|
|
var wrkr = function(fns, init, id, cb) {
|
|
if (!ch[id]) {
|
|
var fnStr = "", td_1 = {}, m = fns.length - 1;
|
|
for (var i = 0; i < m; ++i)
|
|
fnStr = wcln(fns[i], fnStr, td_1);
|
|
ch[id] = { c: wcln(fns[m], fnStr, td_1), e: td_1 };
|
|
}
|
|
var td2 = mrg({}, ch[id].e);
|
|
return wk(ch[id].c + ";onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=" + init.toString() + "}", id, td2, cbfs(td2), cb);
|
|
};
|
|
var bInflt = function() {
|
|
return [u8, u16, i32, fleb, fdeb, clim, fl, fd, flrm, fdrm, rev, ec, hMap, max, bits, bits16, shft, slc, err2, inflt, inflateSync, pbf, gopt];
|
|
};
|
|
var bDflt = function() {
|
|
return [u8, u16, i32, fleb, fdeb, clim, revfl, revfd, flm, flt, fdm, fdt, rev, deo, et, hMap, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, shft, slc, dflt, dopt, deflateSync, pbf];
|
|
};
|
|
var pbf = function(msg) {
|
|
return postMessage(msg, [msg.buffer]);
|
|
};
|
|
var gopt = function(o) {
|
|
return o && {
|
|
out: o.size && new u8(o.size),
|
|
dictionary: o.dictionary
|
|
};
|
|
};
|
|
var cbify = function(dat, opts, fns, init, id, cb) {
|
|
var w = wrkr(fns, init, id, function(err3, dat2) {
|
|
w.terminate();
|
|
cb(err3, dat2);
|
|
});
|
|
w.postMessage([dat, opts], opts.consume ? [dat.buffer] : []);
|
|
return function() {
|
|
w.terminate();
|
|
};
|
|
};
|
|
var b2 = function(d, b) {
|
|
return d[b] | d[b + 1] << 8;
|
|
};
|
|
var b4 = function(d, b) {
|
|
return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
|
|
};
|
|
var b8 = function(d, b) {
|
|
return b4(d, b) + b4(d, b + 4) * 4294967296;
|
|
};
|
|
var wbytes = function(d, b, v) {
|
|
for (; v; ++b)
|
|
d[b] = v, v >>>= 8;
|
|
};
|
|
function deflate(data, opts, cb) {
|
|
if (!cb)
|
|
cb = opts, opts = {};
|
|
if (typeof cb != "function")
|
|
err2(7);
|
|
return cbify(data, opts, [
|
|
bDflt
|
|
], function(ev) {
|
|
return pbf(deflateSync(ev.data[0], ev.data[1]));
|
|
}, 0, cb);
|
|
}
|
|
function deflateSync(data, opts) {
|
|
return dopt(data, opts || {}, 0, 0);
|
|
}
|
|
function inflate(data, opts, cb) {
|
|
if (!cb)
|
|
cb = opts, opts = {};
|
|
if (typeof cb != "function")
|
|
err2(7);
|
|
return cbify(data, opts, [
|
|
bInflt
|
|
], function(ev) {
|
|
return pbf(inflateSync(ev.data[0], gopt(ev.data[1])));
|
|
}, 1, cb);
|
|
}
|
|
function inflateSync(data, opts) {
|
|
return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
|
|
}
|
|
var fltn = function(d, p, t, o) {
|
|
for (var k in d) {
|
|
var val = d[k], n = p + k, op = o;
|
|
if (Array.isArray(val))
|
|
op = mrg(o, val[1]), val = val[0];
|
|
if (val instanceof u8)
|
|
t[n] = [val, op];
|
|
else {
|
|
t[n += "/"] = [new u8(0), op];
|
|
fltn(val, n, t, o);
|
|
}
|
|
}
|
|
};
|
|
var te = typeof TextEncoder != "undefined" && /* @__PURE__ */ new TextEncoder();
|
|
var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
|
|
var tds = 0;
|
|
try {
|
|
td.decode(et, { stream: true });
|
|
tds = 1;
|
|
} catch (e) {
|
|
}
|
|
var dutf8 = function(d) {
|
|
for (var r = "", i = 0; ; ) {
|
|
var c = d[i++];
|
|
var eb = (c > 127) + (c > 223) + (c > 239);
|
|
if (i + eb > d.length)
|
|
return { s: r, r: slc(d, i - 1) };
|
|
if (!eb)
|
|
r += String.fromCharCode(c);
|
|
else if (eb == 3) {
|
|
c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | d[i++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
|
|
} else if (eb & 1)
|
|
r += String.fromCharCode((c & 31) << 6 | d[i++] & 63);
|
|
else
|
|
r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | d[i++] & 63);
|
|
}
|
|
};
|
|
function strToU8(str, latin1) {
|
|
if (latin1) {
|
|
var ar_1 = new u8(str.length);
|
|
for (var i = 0; i < str.length; ++i)
|
|
ar_1[i] = str.charCodeAt(i);
|
|
return ar_1;
|
|
}
|
|
if (te)
|
|
return te.encode(str);
|
|
var l = str.length;
|
|
var ar = new u8(str.length + (str.length >> 1));
|
|
var ai = 0;
|
|
var w = function(v) {
|
|
ar[ai++] = v;
|
|
};
|
|
for (var i = 0; i < l; ++i) {
|
|
if (ai + 5 > ar.length) {
|
|
var n = new u8(ai + 8 + (l - i << 1));
|
|
n.set(ar);
|
|
ar = n;
|
|
}
|
|
var c = str.charCodeAt(i);
|
|
if (c < 128 || latin1)
|
|
w(c);
|
|
else if (c < 2048)
|
|
w(192 | c >> 6), w(128 | c & 63);
|
|
else if (c > 55295 && c < 57344)
|
|
c = 65536 + (c & 1023 << 10) | str.charCodeAt(++i) & 1023, w(240 | c >> 18), w(128 | c >> 12 & 63), w(128 | c >> 6 & 63), w(128 | c & 63);
|
|
else
|
|
w(224 | c >> 12), w(128 | c >> 6 & 63), w(128 | c & 63);
|
|
}
|
|
return slc(ar, 0, ai);
|
|
}
|
|
function strFromU8(dat, latin1) {
|
|
if (latin1) {
|
|
var r = "";
|
|
for (var i = 0; i < dat.length; i += 16384)
|
|
r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));
|
|
return r;
|
|
} else if (td) {
|
|
return td.decode(dat);
|
|
} else {
|
|
var _a2 = dutf8(dat), s = _a2.s, r = _a2.r;
|
|
if (r.length)
|
|
err2(8);
|
|
return s;
|
|
}
|
|
}
|
|
var slzh = function(d, b) {
|
|
return b + 30 + b2(d, b + 26) + b2(d, b + 28);
|
|
};
|
|
var zh = function(d, b, z) {
|
|
var fnl = b2(d, b + 28), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl, bs = b4(d, b + 20);
|
|
var _a2 = z && bs == 4294967295 ? z64e(d, es) : [bs, b4(d, b + 24), b4(d, b + 42)], sc = _a2[0], su = _a2[1], off = _a2[2];
|
|
return [b2(d, b + 10), sc, su, fn, es + b2(d, b + 30) + b2(d, b + 32), off];
|
|
};
|
|
var z64e = function(d, b) {
|
|
for (; b2(d, b) != 1; b += 4 + b2(d, b + 2))
|
|
;
|
|
return [b8(d, b + 12), b8(d, b + 4), b8(d, b + 20)];
|
|
};
|
|
var exfl = function(ex) {
|
|
var le = 0;
|
|
if (ex) {
|
|
for (var k in ex) {
|
|
var l = ex[k].length;
|
|
if (l > 65535)
|
|
err2(9);
|
|
le += l + 4;
|
|
}
|
|
}
|
|
return le;
|
|
};
|
|
var wzh = function(d, b, f, fn, u, c, ce, co) {
|
|
var fl2 = fn.length, ex = f.extra, col = co && co.length;
|
|
var exl = exfl(ex);
|
|
wbytes(d, b, ce != null ? 33639248 : 67324752), b += 4;
|
|
if (ce != null)
|
|
d[b++] = 20, d[b++] = f.os;
|
|
d[b] = 20, b += 2;
|
|
d[b++] = f.flag << 1 | (c < 0 && 8), d[b++] = u && 8;
|
|
d[b++] = f.compression & 255, d[b++] = f.compression >> 8;
|
|
var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980;
|
|
if (y < 0 || y > 119)
|
|
err2(10);
|
|
wbytes(d, b, y << 25 | dt.getMonth() + 1 << 21 | dt.getDate() << 16 | dt.getHours() << 11 | dt.getMinutes() << 5 | dt.getSeconds() >> 1), b += 4;
|
|
if (c != -1) {
|
|
wbytes(d, b, f.crc);
|
|
wbytes(d, b + 4, c < 0 ? -c - 2 : c);
|
|
wbytes(d, b + 8, f.size);
|
|
}
|
|
wbytes(d, b + 12, fl2);
|
|
wbytes(d, b + 14, exl), b += 16;
|
|
if (ce != null) {
|
|
wbytes(d, b, col);
|
|
wbytes(d, b + 6, f.attrs);
|
|
wbytes(d, b + 10, ce), b += 14;
|
|
}
|
|
d.set(fn, b);
|
|
b += fl2;
|
|
if (exl) {
|
|
for (var k in ex) {
|
|
var exf = ex[k], l = exf.length;
|
|
wbytes(d, b, +k);
|
|
wbytes(d, b + 2, l);
|
|
d.set(exf, b + 4), b += 4 + l;
|
|
}
|
|
}
|
|
if (col)
|
|
d.set(co, b), b += col;
|
|
return b;
|
|
};
|
|
var wzf = function(o, b, c, d, e) {
|
|
wbytes(o, b, 101010256);
|
|
wbytes(o, b + 8, c);
|
|
wbytes(o, b + 10, c);
|
|
wbytes(o, b + 12, d);
|
|
wbytes(o, b + 16, e);
|
|
};
|
|
function zip(data, opts, cb) {
|
|
if (!cb)
|
|
cb = opts, opts = {};
|
|
if (typeof cb != "function")
|
|
err2(7);
|
|
var r = {};
|
|
fltn(data, "", r, opts);
|
|
var k = Object.keys(r);
|
|
var lft = k.length, o = 0, tot = 0;
|
|
var slft = lft, files2 = new Array(lft);
|
|
var term = [];
|
|
var tAll = function() {
|
|
for (var i2 = 0; i2 < term.length; ++i2)
|
|
term[i2]();
|
|
};
|
|
var cbd = function(a, b) {
|
|
mt(function() {
|
|
cb(a, b);
|
|
});
|
|
};
|
|
mt(function() {
|
|
cbd = cb;
|
|
});
|
|
var cbf = function() {
|
|
var out = new u8(tot + 22), oe = o, cdl = tot - o;
|
|
tot = 0;
|
|
for (var i2 = 0; i2 < slft; ++i2) {
|
|
var f = files2[i2];
|
|
try {
|
|
var l = f.c.length;
|
|
wzh(out, tot, f, f.f, f.u, l);
|
|
var badd = 30 + f.f.length + exfl(f.extra);
|
|
var loc = tot + badd;
|
|
out.set(f.c, loc);
|
|
wzh(out, o, f, f.f, f.u, l, tot, f.m), o += 16 + badd + (f.m ? f.m.length : 0), tot = loc + l;
|
|
} catch (e) {
|
|
return cbd(e, null);
|
|
}
|
|
}
|
|
wzf(out, o, files2.length, cdl, oe);
|
|
cbd(null, out);
|
|
};
|
|
if (!lft)
|
|
cbf();
|
|
var _loop_1 = function(i2) {
|
|
var fn = k[i2];
|
|
var _a2 = r[fn], file = _a2[0], p = _a2[1];
|
|
var c = crc(), size = file.length;
|
|
c.p(file);
|
|
var f = strToU8(fn), s = f.length;
|
|
var com = p.comment, m = com && strToU8(com), ms = m && m.length;
|
|
var exl = exfl(p.extra);
|
|
var compression = p.level == 0 ? 0 : 8;
|
|
var cbl = function(e, d) {
|
|
if (e) {
|
|
tAll();
|
|
cbd(e, null);
|
|
} else {
|
|
var l = d.length;
|
|
files2[i2] = mrg(p, {
|
|
size,
|
|
crc: c.d(),
|
|
c: d,
|
|
f,
|
|
m,
|
|
u: s != fn.length || m && com.length != ms,
|
|
compression
|
|
});
|
|
o += 30 + s + exl + l;
|
|
tot += 76 + 2 * (s + exl) + (ms || 0) + l;
|
|
if (!--lft)
|
|
cbf();
|
|
}
|
|
};
|
|
if (s > 65535)
|
|
cbl(err2(11, 0, 1), null);
|
|
if (!compression)
|
|
cbl(null, file);
|
|
else if (size < 16e4) {
|
|
try {
|
|
cbl(null, deflateSync(file, p));
|
|
} catch (e) {
|
|
cbl(e, null);
|
|
}
|
|
} else
|
|
term.push(deflate(file, p, cbl));
|
|
};
|
|
for (var i = 0; i < slft; ++i) {
|
|
_loop_1(i);
|
|
}
|
|
return tAll;
|
|
}
|
|
var mt = typeof queueMicrotask == "function" ? queueMicrotask : typeof setTimeout == "function" ? setTimeout : function(fn) {
|
|
fn();
|
|
};
|
|
function unzip(data, opts, cb) {
|
|
if (!cb)
|
|
cb = opts, opts = {};
|
|
if (typeof cb != "function")
|
|
err2(7);
|
|
var term = [];
|
|
var tAll = function() {
|
|
for (var i2 = 0; i2 < term.length; ++i2)
|
|
term[i2]();
|
|
};
|
|
var files2 = {};
|
|
var cbd = function(a, b) {
|
|
mt(function() {
|
|
cb(a, b);
|
|
});
|
|
};
|
|
mt(function() {
|
|
cbd = cb;
|
|
});
|
|
var e = data.length - 22;
|
|
for (; b4(data, e) != 101010256; --e) {
|
|
if (!e || data.length - e > 65558) {
|
|
cbd(err2(13, 0, 1), null);
|
|
return tAll;
|
|
}
|
|
}
|
|
;
|
|
var lft = b2(data, e + 8);
|
|
if (lft) {
|
|
var c = lft;
|
|
var o = b4(data, e + 16);
|
|
var z = o == 4294967295 || c == 65535;
|
|
if (z) {
|
|
var ze = b4(data, e - 12);
|
|
z = b4(data, ze) == 101075792;
|
|
if (z) {
|
|
c = lft = b4(data, ze + 32);
|
|
o = b4(data, ze + 48);
|
|
}
|
|
}
|
|
var fltr = opts && opts.filter;
|
|
var _loop_3 = function(i2) {
|
|
var _a2 = zh(data, o, z), c_1 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
|
|
o = no;
|
|
var cbl = function(e2, d) {
|
|
if (e2) {
|
|
tAll();
|
|
cbd(e2, null);
|
|
} else {
|
|
if (d)
|
|
files2[fn] = d;
|
|
if (!--lft)
|
|
cbd(null, files2);
|
|
}
|
|
};
|
|
if (!fltr || fltr({
|
|
name: fn,
|
|
size: sc,
|
|
originalSize: su,
|
|
compression: c_1
|
|
})) {
|
|
if (!c_1)
|
|
cbl(null, slc(data, b, b + sc));
|
|
else if (c_1 == 8) {
|
|
var infl = data.subarray(b, b + sc);
|
|
if (su < 524288 || sc > 0.8 * su) {
|
|
try {
|
|
cbl(null, inflateSync(infl, { out: new u8(su) }));
|
|
} catch (e2) {
|
|
cbl(e2, null);
|
|
}
|
|
} else
|
|
term.push(inflate(infl, { size: su }, cbl));
|
|
} else
|
|
cbl(err2(14, "unknown compression type " + c_1, 1), null);
|
|
} else
|
|
cbl(null, null);
|
|
};
|
|
for (var i = 0; i < c; ++i) {
|
|
_loop_3(i);
|
|
}
|
|
} else
|
|
cbd(null, {});
|
|
return tAll;
|
|
}
|
|
|
|
// src/api/lufi.ts
|
|
var CHUNK_LENGTH = 15e5;
|
|
var files = {};
|
|
var events = new import_events2.default();
|
|
var cancel = (uploadJob) => {
|
|
uploadJob.terminate();
|
|
const job = new LufiJob(uploadJob.lufiFile);
|
|
return ResultAsync.fromPromise(
|
|
new Promise((resolve, reject) => {
|
|
job.onMessage((event) => {
|
|
if (event.data.event === "UPLOAD_CANCELLED" /* UPLOAD_CANCELLED */) {
|
|
files[job.lufiFile.keys.client].uploadStatus = 0 /* CANCELED */;
|
|
resolve(job);
|
|
}
|
|
if (event.data.event === "OPERATION_FAILED" /* OPERATION_FAILED */) {
|
|
reject(event.data.error);
|
|
}
|
|
}).requestMessage({
|
|
action: 2 /* CANCEL */,
|
|
args: {
|
|
lufiFile: job.lufiFile
|
|
}
|
|
});
|
|
}),
|
|
(error) => ensureError(error)
|
|
);
|
|
};
|
|
var addFilesToArchive = (files2, archiveEntries = {}) => {
|
|
const asyncLoop = async (files3) => {
|
|
var _a2;
|
|
for (const file of files3) {
|
|
const nameWithExtension = ((_a2 = file.name.split("/")) == null ? void 0 : _a2.pop()) || file.name;
|
|
const nameWithoutExtension = nameWithExtension.split(".").shift();
|
|
const extension = nameWithExtension.split(".").pop();
|
|
let name = nameWithExtension;
|
|
if (archiveEntries[name] !== void 0) {
|
|
let i = 1;
|
|
do {
|
|
name = `${nameWithoutExtension}_(${i}).${extension}`;
|
|
i++;
|
|
} while (archiveEntries[name] !== void 0);
|
|
}
|
|
events.emit("ARCHIVE_ADDED_FILE" /* ARCHIVE_ADDED_FILE */, { name, size: file.size });
|
|
archiveEntries[name] = await file.bytes();
|
|
}
|
|
};
|
|
return ResultAsync.fromPromise(
|
|
asyncLoop(files2),
|
|
(error) => ensureError(error)
|
|
).andThen(() => okAsync(archiveEntries));
|
|
};
|
|
var compress = (archiveEntries, archiveName) => {
|
|
const promiseZip = () => new Promise((resolve, reject) => {
|
|
zip(archiveEntries, (error, data) => {
|
|
if (error) reject(error);
|
|
resolve(data);
|
|
});
|
|
});
|
|
return ResultAsync.fromPromise(
|
|
promiseZip(),
|
|
(error) => ensureError(error)
|
|
).andThen((bytes) => {
|
|
return okAsync(
|
|
new File(
|
|
[new Blob([bytes])],
|
|
archiveName,
|
|
{
|
|
type: "application/zip"
|
|
}
|
|
)
|
|
);
|
|
}).orElse((error) => errAsync(error));
|
|
};
|
|
var decompress = (zipFile) => {
|
|
const unzipPromise = async () => {
|
|
const fileBytes = await zipFile.bytes();
|
|
return new Promise((resolve, reject) => {
|
|
unzip(fileBytes, (error, files2) => {
|
|
if (error) reject(error);
|
|
resolve(files2);
|
|
});
|
|
});
|
|
};
|
|
return ResultAsync.fromPromise(unzipPromise(), (error) => ensureError(error)).andThen((files2) => {
|
|
const unzippedFiles = [];
|
|
for (const path in files2) {
|
|
unzippedFiles.push(new File([new Blob([files2[path]])], path));
|
|
}
|
|
return okAsync(unzippedFiles);
|
|
});
|
|
};
|
|
var download = (downloadUrl, password) => {
|
|
let lufiResult;
|
|
if (password) {
|
|
lufiResult = fetchServerConfig(downloadUrl).andThen((config) => {
|
|
if (config.version.tag > "0.07.0") {
|
|
return ResultAsync.fromPromise(
|
|
hashPassword(password).then((hashedPassword) => {
|
|
return LufiFile.fromDownloadUrl(downloadUrl, hashedPassword);
|
|
}),
|
|
(error) => ensureError(error)
|
|
);
|
|
} else {
|
|
return okAsync(LufiFile.fromDownloadUrl(downloadUrl, password));
|
|
}
|
|
});
|
|
} else {
|
|
lufiResult = okAsync(LufiFile.fromDownloadUrl(downloadUrl));
|
|
}
|
|
return lufiResult.andThen((lufiFile) => {
|
|
const job = new LufiJob(lufiFile);
|
|
return ResultAsync.fromPromise(
|
|
new Promise(
|
|
(resolve, reject) => job.onMessage((event) => {
|
|
handleSocketResults(resolve, reject, job, event);
|
|
if (event.data.event === "CHUNK_DOWNLOADED" /* CHUNK_DOWNLOADED */) {
|
|
job.tmpChunks[event.data.chunk.index] = new Blob([
|
|
event.data.chunk.buffer
|
|
]);
|
|
}
|
|
if (event.data.event === "DOWNLOAD_COMPLETE" /* DOWNLOAD_COMPLETE */) {
|
|
job.tmpFile = new Blob(job.tmpChunks, { type: lufiFile.type });
|
|
job.tmpChunks = [];
|
|
job.complete();
|
|
}
|
|
}).requestMessage({
|
|
action: 3 /* DOWNLOAD */,
|
|
args: {
|
|
lufiFile
|
|
}
|
|
})
|
|
),
|
|
(error) => ensureError(error)
|
|
);
|
|
});
|
|
};
|
|
var infos = (downloadUrl, password) => {
|
|
let lufiResult;
|
|
if (password) {
|
|
lufiResult = fetchServerConfig(downloadUrl).andThen((config) => {
|
|
if (config.version.tag > "0.07.0") {
|
|
return ResultAsync.fromPromise(
|
|
hashPassword(password).then((hashedPassword) => {
|
|
return LufiFile.fromDownloadUrl(downloadUrl, hashedPassword);
|
|
}),
|
|
(error) => ensureError(error)
|
|
);
|
|
} else {
|
|
return okAsync(LufiFile.fromDownloadUrl(downloadUrl, password));
|
|
}
|
|
});
|
|
} else {
|
|
lufiResult = okAsync(LufiFile.fromDownloadUrl(downloadUrl));
|
|
}
|
|
return lufiResult.andThen((lufiFile) => okAsync(new LufiJob(lufiFile))).andThen(
|
|
(job) => ResultAsync.fromPromise(
|
|
new Promise((resolve, reject) => {
|
|
job.onMessage((event) => {
|
|
if (event.data.event === "INFOS_RETRIEVED" /* INFOS_RETRIEVED */) {
|
|
job.complete();
|
|
resolve(job);
|
|
}
|
|
if (event.data.event === "OPERATION_FAILED" /* OPERATION_FAILED */) {
|
|
reject(event.data.error);
|
|
}
|
|
}).requestMessage({
|
|
action: 4 /* INFOS */,
|
|
args: { lufiFile: job.lufiFile }
|
|
});
|
|
}),
|
|
(error) => ensureError(error)
|
|
)
|
|
);
|
|
};
|
|
var pause = (job) => {
|
|
job.status = 3 /* PAUSED */;
|
|
return okAsync(
|
|
job.requestMessage({
|
|
action: 5 /* PAUSE */,
|
|
args: { lufiFile: job.lufiFile }
|
|
})
|
|
);
|
|
};
|
|
var remove = (removeUrl, password) => {
|
|
const lufiFile = LufiFile.fromRemoveUrl(removeUrl, password);
|
|
const job = new LufiJob(lufiFile);
|
|
return ResultAsync.fromPromise(
|
|
new Promise((resolve, reject) => {
|
|
job.onMessage((event) => {
|
|
if (event.data.event === "FILE_REMOVED" /* FILE_REMOVED */) {
|
|
job.complete();
|
|
resolve(job);
|
|
}
|
|
if (event.data.event === "OPERATION_FAILED" /* OPERATION_FAILED */) {
|
|
reject(event.data.error);
|
|
}
|
|
}).requestMessage({ action: 7 /* REMOVE */, args: { lufiFile } });
|
|
}),
|
|
(error) => ensureError(error)
|
|
);
|
|
};
|
|
var resume = (job) => {
|
|
job.status = 2 /* ONGOING */;
|
|
return okAsync(
|
|
job.requestMessage({
|
|
action: 8 /* RESUME */,
|
|
args: { lufiFile: job.lufiFile }
|
|
})
|
|
);
|
|
};
|
|
var slice = (file, clientKey, chunkLength = CHUNK_LENGTH) => {
|
|
const totalChunks = Math.ceil(file.size / chunkLength);
|
|
files[clientKey].totalChunks = totalChunks;
|
|
if (totalChunks > 0) {
|
|
const chunks = [];
|
|
for (let i = 0; i < totalChunks; i++) {
|
|
const start = i * chunkLength;
|
|
const end = Math.min(start + chunkLength, file.size);
|
|
chunks.push(file.slice(start, end, file.type));
|
|
}
|
|
return ok(chunks);
|
|
} else {
|
|
return err(new FileSlicingError());
|
|
}
|
|
};
|
|
var upload = (serverUrl, filesToUpload, delay = 0, delAtFirstView = false, zipped = false, zipName = "documents.zip", password = "", algo = 1 /* WebCrypto */) => {
|
|
const operations = [];
|
|
if (!zipped) {
|
|
filesToUpload.forEach((file) => {
|
|
operations.push(startUpload(
|
|
serverUrl,
|
|
file,
|
|
delay,
|
|
delAtFirstView,
|
|
zipped,
|
|
password,
|
|
algo
|
|
));
|
|
});
|
|
} else {
|
|
if (filesToUpload.length === 1 && filesToUpload[0].type === "application/zip") {
|
|
operations.push(
|
|
startUpload(
|
|
serverUrl,
|
|
filesToUpload[0],
|
|
delay,
|
|
delAtFirstView,
|
|
zipped,
|
|
password,
|
|
algo
|
|
)
|
|
);
|
|
} else {
|
|
operations.push(
|
|
addFilesToArchive(filesToUpload).andThen(
|
|
(archiveEntries) => compress(archiveEntries, zipName).andThen((file) => {
|
|
events.emit("ARCHIVE_CREATED" /* ARCHIVE_CREATED */, file);
|
|
return startUpload(
|
|
serverUrl,
|
|
file,
|
|
delay,
|
|
delAtFirstView,
|
|
zipped,
|
|
password,
|
|
algo
|
|
);
|
|
})
|
|
)
|
|
);
|
|
}
|
|
}
|
|
return ResultAsync.combine(operations);
|
|
};
|
|
var startUpload = (serverUrl, file, delay, delAtFirstView, zipped, password, algo) => generateKey3(
|
|
algo
|
|
).andThen(
|
|
(clientKey) => {
|
|
return ResultAsync.fromPromise(
|
|
hashPassword(password).then((hashedPassword) => {
|
|
files[clientKey] = new LufiFile(serverUrl.toString(), {
|
|
delay,
|
|
delAtFirstView,
|
|
zipped,
|
|
password: hashedPassword,
|
|
name: file.name.split("/").pop(),
|
|
// Remove path from filename
|
|
size: file.size,
|
|
type: file.type,
|
|
keys: { client: clientKey, server: "" }
|
|
});
|
|
return clientKey;
|
|
}),
|
|
(error) => ensureError(error)
|
|
);
|
|
}
|
|
).andThen((clientKey) => {
|
|
const job = new LufiJob(files[clientKey]);
|
|
return slice(file, clientKey).asyncAndThen((chunks) => {
|
|
files[clientKey].uploadStatus = 4 /* QUEUED */;
|
|
const resultPromise = new Promise((resolve, reject) => {
|
|
job.onMessage((event) => {
|
|
handleSocketResults(resolve, reject, job, event);
|
|
switch (event.data.event) {
|
|
case "UPLOAD_COMPLETE" /* UPLOAD_COMPLETE */:
|
|
{
|
|
job.complete();
|
|
job.lufiFile.uploadStatus = 1 /* COMPLETE */;
|
|
}
|
|
break;
|
|
}
|
|
});
|
|
});
|
|
const sendChunks = async (chunks2) => {
|
|
for (const [index, chunk] of chunks2.entries()) {
|
|
const buffer = await chunk.arrayBuffer();
|
|
job.requestMessage(
|
|
{
|
|
action: 9 /* UPLOAD */,
|
|
args: {
|
|
chunk: { buffer, index },
|
|
lufiFile: files[clientKey],
|
|
algo
|
|
}
|
|
},
|
|
[buffer]
|
|
);
|
|
}
|
|
};
|
|
return ResultAsync.fromPromise(
|
|
sendChunks(chunks),
|
|
(error) => ensureError(error)
|
|
).andThen(
|
|
() => ResultAsync.fromPromise(resultPromise, (error) => ensureError(error))
|
|
);
|
|
}).orElse((error) => errAsync(error));
|
|
});
|
|
var handleSocketResults = (resolve, reject, job, event) => {
|
|
if (event.data.event === "SOCKET_OPENED" /* SOCKET_OPENED */) {
|
|
resolve(job);
|
|
}
|
|
if (event.data.event === "OPERATION_FAILED" /* OPERATION_FAILED */) {
|
|
reject(event.data.error);
|
|
}
|
|
};
|
|
var getFilesQueued = () => Object.values(files).filter(
|
|
(file) => file.uploadStatus === 4 /* QUEUED */
|
|
);
|
|
var getFileIndexInQueue = (clientKey) => Object.keys(getFilesQueued()).indexOf(clientKey);
|
|
export {
|
|
CryptoAlgorithm,
|
|
ResultAsync,
|
|
err,
|
|
errAsync,
|
|
isSecureContext,
|
|
lufi_exports as lufi,
|
|
ok,
|
|
okAsync
|
|
};
|