vue-pdf-next
Version:
基于vite+vue3+pdfjs的pdf预览插件
1,226 lines • 3.39 MB
JavaScript
import './style.css';
var Cs = Object.defineProperty;
var Es = (xe, Q, re) => Q in xe ? Cs(xe, Q, { enumerable: !0, configurable: !0, writable: !0, value: re }) : xe[Q] = re;
var tn = (xe, Q, re) => (Es(xe, typeof Q != "symbol" ? Q + "" : Q, re), re), ii = (xe, Q, re) => {
if (!Q.has(xe))
throw TypeError("Cannot " + re);
};
var Te = (xe, Q, re) => (ii(xe, Q, "read from private field"), re ? re.call(xe) : Q.get(xe)), ze = (xe, Q, re) => {
if (Q.has(xe))
throw TypeError("Cannot add the same private member more than once");
Q instanceof WeakSet ? Q.add(xe) : Q.set(xe, re);
}, ft = (xe, Q, re, J) => (ii(xe, Q, "write to private field"), J ? J.call(xe, re) : Q.set(xe, re), re);
var ai = (xe, Q, re, J) => ({
set _(ie) {
ft(xe, Q, ie, re);
},
get _() {
return Te(xe, Q, J);
}
}), Ye = (xe, Q, re) => (ii(xe, Q, "access private method"), re);
import { getCurrentScope, onScopeDispose, unref, watch, defineComponent, shallowRef, ref, onMounted, openBlock, createElementBlock, createElementVNode } from "vue";
var commonjsGlobal = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
function getAugmentedNamespace(xe) {
if (xe.__esModule)
return xe;
var Q = xe.default;
if (typeof Q == "function") {
var re = function J() {
return this instanceof J ? Reflect.construct(Q, arguments, this.constructor) : Q.apply(this, arguments);
};
re.prototype = Q.prototype;
} else
re = {};
return Object.defineProperty(re, "__esModule", { value: !0 }), Object.keys(xe).forEach(function(J) {
var ie = Object.getOwnPropertyDescriptor(xe, J);
Object.defineProperty(re, J, ie.get ? ie : {
enumerable: !0,
get: function() {
return xe[J];
}
});
}), re;
}
function commonjsRequire(xe) {
throw new Error('Could not dynamically require "' + xe + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
}
var pdf$1 = { exports: {} }, dommatrix = { exports: {} };
/*!
* DOMMatrix v1.0.3 (https://thednp.github.io/dommatrix/)
* Copyright 2022 © thednp
* Licensed under MIT (https://github.com/thednp/DOMMatrix/blob/master/LICENSE)
*/
var hasRequiredDommatrix;
function requireDommatrix() {
return hasRequiredDommatrix || (hasRequiredDommatrix = 1, function(xe, Q) {
(function(re, J) {
xe.exports = J();
})(commonjsGlobal, function() {
function re(u) {
var l = new b(), n = Array.from(u);
if (!n.every(function(H) {
return !Number.isNaN(H);
}))
throw TypeError('CSSMatrix: "' + u + '" must only have numbers.');
if (n.length === 16) {
var r = n[0], i = n[1], s = n[2], c = n[3], y = n[4], d = n[5], S = n[6], X = n[7], M = n[8], U = n[9], C = n[10], w = n[11], E = n[12], h = n[13], m = n[14], $ = n[15];
l.m11 = r, l.a = r, l.m21 = y, l.c = y, l.m31 = M, l.m41 = E, l.e = E, l.m12 = i, l.b = i, l.m22 = d, l.d = d, l.m32 = U, l.m42 = h, l.f = h, l.m13 = s, l.m23 = S, l.m33 = C, l.m43 = m, l.m14 = c, l.m24 = X, l.m34 = w, l.m44 = $;
} else if (n.length === 6) {
var D = n[0], R = n[1], N = n[2], T = n[3], v = n[4], F = n[5];
l.m11 = D, l.a = D, l.m12 = R, l.b = R, l.m21 = N, l.c = N, l.m22 = T, l.d = T, l.m41 = v, l.e = v, l.m42 = F, l.f = F;
} else
throw new TypeError("CSSMatrix: expecting an Array of 6/16 values.");
return l;
}
function J(u) {
var l = Object.keys(new b());
if (typeof u == "object" && l.every(function(n) {
return n in u;
}))
return re(
[
u.m11,
u.m12,
u.m13,
u.m14,
u.m21,
u.m22,
u.m23,
u.m24,
u.m31,
u.m32,
u.m33,
u.m34,
u.m41,
u.m42,
u.m43,
u.m44
]
);
throw TypeError('CSSMatrix: "' + JSON.stringify(u) + '" is not a DOMMatrix / CSSMatrix / JSON compatible object.');
}
function ie(u) {
if (typeof u != "string")
throw TypeError('CSSMatrix: "' + u + '" is not a string.');
var l = String(u).replace(/\s/g, ""), n = new b(), r = 'CSSMatrix: invalid transform string "' + u + '"';
return l.split(")").filter(function(i) {
return i;
}).forEach(function(i) {
var s = i.split("("), c = s[0], y = s[1];
if (!y)
throw TypeError(r);
var d = y.split(",").map(function(v) {
return v.includes("rad") ? parseFloat(v) * (180 / Math.PI) : parseFloat(v);
}), S = d[0], X = d[1], M = d[2], U = d[3], C = [S, X, M], w = [S, X, M, U];
if (c === "perspective" && S && [X, M].every(function(v) {
return v === void 0;
}))
n.m34 = -1 / S;
else if (c.includes("matrix") && [6, 16].includes(d.length) && d.every(function(v) {
return !Number.isNaN(+v);
})) {
var E = d.map(function(v) {
return Math.abs(v) < 1e-6 ? 0 : v;
});
n = n.multiply(re(E));
} else if (c === "translate3d" && C.every(function(v) {
return !Number.isNaN(+v);
}))
n = n.translate(S, X, M);
else if (c === "translate" && S && M === void 0)
n = n.translate(S, X || 0, 0);
else if (c === "rotate3d" && w.every(function(v) {
return !Number.isNaN(+v);
}) && U)
n = n.rotateAxisAngle(S, X, M, U);
else if (c === "rotate" && S && [X, M].every(function(v) {
return v === void 0;
}))
n = n.rotate(0, 0, S);
else if (c === "scale3d" && C.every(function(v) {
return !Number.isNaN(+v);
}) && C.some(function(v) {
return v !== 1;
}))
n = n.scale(S, X, M);
else if (c === "scale" && !Number.isNaN(S) && S !== 1 && M === void 0) {
var h = Number.isNaN(+X), m = h ? S : X;
n = n.scale(S, m, 1);
} else if (c === "skew" && (S || !Number.isNaN(S) && X) && M === void 0)
n = n.skew(S, X || 0);
else if (/[XYZ]/.test(c) && S && [X, M].every(function(v) {
return v === void 0;
}) && ["translate", "rotate", "scale", "skew"].some(function(v) {
return c.includes(v);
}))
if (["skewX", "skewY"].includes(c))
n = n[c](S);
else {
var $ = c.replace(/[XYZ]/, ""), D = c.replace($, ""), R = ["X", "Y", "Z"].indexOf(D), N = $ === "scale" ? 1 : 0, T = [
R === 0 ? S : N,
R === 1 ? S : N,
R === 2 ? S : N
];
n = n[$].apply(n, T);
}
else
throw TypeError(r);
}), n;
}
function he(u, l) {
return l ? [u.a, u.b, u.c, u.d, u.e, u.f] : [
u.m11,
u.m12,
u.m13,
u.m14,
u.m21,
u.m22,
u.m23,
u.m24,
u.m31,
u.m32,
u.m33,
u.m34,
u.m41,
u.m42,
u.m43,
u.m44
];
}
function te(u, l, n) {
var r = new b();
return r.m41 = u, r.e = u, r.m42 = l, r.f = l, r.m43 = n, r;
}
function g(u, l, n) {
var r = new b(), i = Math.PI / 180, s = u * i, c = l * i, y = n * i, d = Math.cos(s), S = -Math.sin(s), X = Math.cos(c), M = -Math.sin(c), U = Math.cos(y), C = -Math.sin(y), w = X * U, E = -X * C;
r.m11 = w, r.a = w, r.m12 = E, r.b = E, r.m13 = M;
var h = S * M * U + d * C;
r.m21 = h, r.c = h;
var m = d * U - S * M * C;
return r.m22 = m, r.d = m, r.m23 = -S * X, r.m31 = S * C - d * M * U, r.m32 = S * U + d * M * C, r.m33 = d * X, r;
}
function A(u, l, n, r) {
var i = new b(), s = Math.sqrt(u * u + l * l + n * n);
if (s === 0)
return i;
var c = u / s, y = l / s, d = n / s, S = r * (Math.PI / 360), X = Math.sin(S), M = Math.cos(S), U = X * X, C = c * c, w = y * y, E = d * d, h = 1 - 2 * (w + E) * U;
i.m11 = h, i.a = h;
var m = 2 * (c * y * U + d * X * M);
i.m12 = m, i.b = m, i.m13 = 2 * (c * d * U - y * X * M);
var $ = 2 * (y * c * U - d * X * M);
i.m21 = $, i.c = $;
var D = 1 - 2 * (E + C) * U;
return i.m22 = D, i.d = D, i.m23 = 2 * (y * d * U + c * X * M), i.m31 = 2 * (d * c * U + y * X * M), i.m32 = 2 * (d * y * U - c * X * M), i.m33 = 1 - 2 * (C + w) * U, i;
}
function t(u, l, n) {
var r = new b();
return r.m11 = u, r.a = u, r.m22 = l, r.d = l, r.m33 = n, r;
}
function a(u, l) {
var n = new b();
if (u) {
var r = u * Math.PI / 180, i = Math.tan(r);
n.m21 = i, n.c = i;
}
if (l) {
var s = l * Math.PI / 180, c = Math.tan(s);
n.m12 = c, n.b = c;
}
return n;
}
function P(u) {
return a(u, 0);
}
function p(u) {
return a(0, u);
}
function e(u, l) {
var n = l.m11 * u.m11 + l.m12 * u.m21 + l.m13 * u.m31 + l.m14 * u.m41, r = l.m11 * u.m12 + l.m12 * u.m22 + l.m13 * u.m32 + l.m14 * u.m42, i = l.m11 * u.m13 + l.m12 * u.m23 + l.m13 * u.m33 + l.m14 * u.m43, s = l.m11 * u.m14 + l.m12 * u.m24 + l.m13 * u.m34 + l.m14 * u.m44, c = l.m21 * u.m11 + l.m22 * u.m21 + l.m23 * u.m31 + l.m24 * u.m41, y = l.m21 * u.m12 + l.m22 * u.m22 + l.m23 * u.m32 + l.m24 * u.m42, d = l.m21 * u.m13 + l.m22 * u.m23 + l.m23 * u.m33 + l.m24 * u.m43, S = l.m21 * u.m14 + l.m22 * u.m24 + l.m23 * u.m34 + l.m24 * u.m44, X = l.m31 * u.m11 + l.m32 * u.m21 + l.m33 * u.m31 + l.m34 * u.m41, M = l.m31 * u.m12 + l.m32 * u.m22 + l.m33 * u.m32 + l.m34 * u.m42, U = l.m31 * u.m13 + l.m32 * u.m23 + l.m33 * u.m33 + l.m34 * u.m43, C = l.m31 * u.m14 + l.m32 * u.m24 + l.m33 * u.m34 + l.m34 * u.m44, w = l.m41 * u.m11 + l.m42 * u.m21 + l.m43 * u.m31 + l.m44 * u.m41, E = l.m41 * u.m12 + l.m42 * u.m22 + l.m43 * u.m32 + l.m44 * u.m42, h = l.m41 * u.m13 + l.m42 * u.m23 + l.m43 * u.m33 + l.m44 * u.m43, m = l.m41 * u.m14 + l.m42 * u.m24 + l.m43 * u.m34 + l.m44 * u.m44;
return re(
[
n,
r,
i,
s,
c,
y,
d,
S,
X,
M,
U,
C,
w,
E,
h,
m
]
);
}
var b = function() {
for (var l = [], n = arguments.length; n--; )
l[n] = arguments[n];
var r = this;
if (r.a = 1, r.b = 0, r.c = 0, r.d = 1, r.e = 0, r.f = 0, r.m11 = 1, r.m12 = 0, r.m13 = 0, r.m14 = 0, r.m21 = 0, r.m22 = 1, r.m23 = 0, r.m24 = 0, r.m31 = 0, r.m32 = 0, r.m33 = 1, r.m34 = 0, r.m41 = 0, r.m42 = 0, r.m43 = 0, r.m44 = 1, l.length) {
var i = [16, 6].some(function(s) {
return s === l.length;
}) ? l : l[0];
return r.setMatrixValue(i);
}
return r;
}, o = { isIdentity: { configurable: !0 }, is2D: { configurable: !0 } };
o.isIdentity.get = function() {
var u = this;
return u.m11 === 1 && u.m12 === 0 && u.m13 === 0 && u.m14 === 0 && u.m21 === 0 && u.m22 === 1 && u.m23 === 0 && u.m24 === 0 && u.m31 === 0 && u.m32 === 0 && u.m33 === 1 && u.m34 === 0 && u.m41 === 0 && u.m42 === 0 && u.m43 === 0 && u.m44 === 1;
}, o.is2D.get = function() {
var u = this;
return u.m31 === 0 && u.m32 === 0 && u.m33 === 1 && u.m34 === 0 && u.m43 === 0 && u.m44 === 1;
}, b.prototype.setMatrixValue = function(l) {
var n = this;
return typeof l == "string" && l.length && l !== "none" ? ie(l) : [Array, Float64Array, Float32Array].some(function(r) {
return l instanceof r;
}) ? re(l) : [b, DOMMatrix, Object].some(function(r) {
return l instanceof r;
}) ? J(l) : n;
}, b.prototype.toFloat32Array = function(l) {
return Float32Array.from(he(this, l));
}, b.prototype.toFloat64Array = function(l) {
return Float64Array.from(he(this, l));
}, b.prototype.toString = function() {
var l = this, n = l.is2D, r = l.toFloat64Array(n).join(", "), i = n ? "matrix" : "matrix3d";
return i + "(" + r + ")";
}, b.prototype.toJSON = function() {
var l = this, n = l.is2D, r = l.isIdentity;
return Object.assign({}, l, { is2D: n, isIdentity: r });
}, b.prototype.multiply = function(l) {
return e(this, l);
}, b.prototype.translate = function(l, n, r) {
var i = l, s = n, c = r;
return s === void 0 && (s = 0), c === void 0 && (c = 0), e(this, te(i, s, c));
}, b.prototype.scale = function(l, n, r) {
var i = l, s = n, c = r;
return s === void 0 && (s = l), c === void 0 && (c = 1), e(this, t(i, s, c));
}, b.prototype.rotate = function(l, n, r) {
var i = l, s = n || 0, c = r || 0;
return typeof l == "number" && n === void 0 && r === void 0 && (c = i, i = 0, s = 0), e(this, g(i, s, c));
}, b.prototype.rotateAxisAngle = function(l, n, r, i) {
if ([l, n, r, i].some(function(s) {
return Number.isNaN(+s);
}))
throw new TypeError("CSSMatrix: expecting 4 values");
return e(this, A(l, n, r, i));
}, b.prototype.skewX = function(l) {
return e(this, P(l));
}, b.prototype.skewY = function(l) {
return e(this, p(l));
}, b.prototype.skew = function(l, n) {
return e(this, a(l, n));
}, b.prototype.transformPoint = function(l) {
var n = this, r = n.m11 * l.x + n.m21 * l.y + n.m31 * l.z + n.m41 * l.w, i = n.m12 * l.x + n.m22 * l.y + n.m32 * l.z + n.m42 * l.w, s = n.m13 * l.x + n.m23 * l.y + n.m33 * l.z + n.m43 * l.w, c = n.m14 * l.x + n.m24 * l.y + n.m34 * l.z + n.m44 * l.w;
return l instanceof DOMPoint ? new DOMPoint(r, i, s, c) : {
x: r,
y: i,
z: s,
w: c
};
}, Object.defineProperties(b.prototype, o), Object.assign(b, {
Translate: te,
Rotate: g,
RotateAxisAngle: A,
Scale: t,
SkewX: P,
SkewY: p,
Skew: a,
Multiply: e,
fromArray: re,
fromMatrix: J,
fromString: ie,
toArray: he
});
var f = "1.0.3", x = f;
return Object.assign(b, { Version: x }), b;
});
}(dommatrix)), dommatrix.exports;
}
var ponyfill = { exports: {} }, hasRequiredPonyfill;
function requirePonyfill() {
return hasRequiredPonyfill || (hasRequiredPonyfill = 1, function(xe, Q) {
(function(re, J) {
J(Q);
})(commonjsGlobal, function(re) {
var J = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? Symbol : function(ne) {
return "Symbol(" + ne + ")";
};
function ie() {
}
function he() {
if (typeof self < "u")
return self;
if (typeof window < "u")
return window;
if (typeof commonjsGlobal < "u")
return commonjsGlobal;
}
var te = he();
function g(ne) {
return typeof ne == "object" && ne !== null || typeof ne == "function";
}
var A = ie, t = Promise, a = Promise.prototype.then, P = Promise.resolve.bind(t), p = Promise.reject.bind(t);
function e(ne) {
return new t(ne);
}
function b(ne) {
return P(ne);
}
function o(ne) {
return p(ne);
}
function f(ne, ue, ke) {
return a.call(ne, ue, ke);
}
function x(ne, ue, ke) {
f(f(ne, ue, ke), void 0, A);
}
function u(ne, ue) {
x(ne, ue);
}
function l(ne, ue) {
x(ne, void 0, ue);
}
function n(ne, ue, ke) {
return f(ne, ue, ke);
}
function r(ne) {
f(ne, void 0, A);
}
var i = function() {
var ne = te && te.queueMicrotask;
if (typeof ne == "function")
return ne;
var ue = b(void 0);
return function(ke) {
return f(ue, ke);
};
}();
function s(ne, ue, ke) {
if (typeof ne != "function")
throw new TypeError("Argument is not a function");
return Function.prototype.apply.call(ne, ue, ke);
}
function c(ne, ue, ke) {
try {
return b(s(ne, ue, ke));
} catch (Ne) {
return o(Ne);
}
}
var y = 16384, d = (
/** @class */
function() {
function ne() {
this._cursor = 0, this._size = 0, this._front = {
_elements: [],
_next: void 0
}, this._back = this._front, this._cursor = 0, this._size = 0;
}
return Object.defineProperty(ne.prototype, "length", {
get: function() {
return this._size;
},
enumerable: !1,
configurable: !0
}), ne.prototype.push = function(ue) {
var ke = this._back, Ne = ke;
ke._elements.length === y - 1 && (Ne = {
_elements: [],
_next: void 0
}), ke._elements.push(ue), Ne !== ke && (this._back = Ne, ke._next = Ne), ++this._size;
}, ne.prototype.shift = function() {
var ue = this._front, ke = ue, Ne = this._cursor, qe = Ne + 1, lt = ue._elements, gt = lt[Ne];
return qe === y && (ke = ue._next, qe = 0), --this._size, this._cursor = qe, ue !== ke && (this._front = ke), lt[Ne] = void 0, gt;
}, ne.prototype.forEach = function(ue) {
for (var ke = this._cursor, Ne = this._front, qe = Ne._elements; (ke !== qe.length || Ne._next !== void 0) && !(ke === qe.length && (Ne = Ne._next, qe = Ne._elements, ke = 0, qe.length === 0)); )
ue(qe[ke]), ++ke;
}, ne.prototype.peek = function() {
var ue = this._front, ke = this._cursor;
return ue._elements[ke];
}, ne;
}()
);
function S(ne, ue) {
ne._ownerReadableStream = ue, ue._reader = ne, ue._state === "readable" ? C(ne) : ue._state === "closed" ? E(ne) : w(ne, ue._storedError);
}
function X(ne, ue) {
var ke = ne._ownerReadableStream;
return dn(ke, ue);
}
function M(ne) {
ne._ownerReadableStream._state === "readable" ? h(ne, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")) : m(ne, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")), ne._ownerReadableStream._reader = void 0, ne._ownerReadableStream = void 0;
}
function U(ne) {
return new TypeError("Cannot " + ne + " a stream using a released reader");
}
function C(ne) {
ne._closedPromise = e(function(ue, ke) {
ne._closedPromise_resolve = ue, ne._closedPromise_reject = ke;
});
}
function w(ne, ue) {
C(ne), h(ne, ue);
}
function E(ne) {
C(ne), $(ne);
}
function h(ne, ue) {
ne._closedPromise_reject !== void 0 && (r(ne._closedPromise), ne._closedPromise_reject(ue), ne._closedPromise_resolve = void 0, ne._closedPromise_reject = void 0);
}
function m(ne, ue) {
w(ne, ue);
}
function $(ne) {
ne._closedPromise_resolve !== void 0 && (ne._closedPromise_resolve(void 0), ne._closedPromise_resolve = void 0, ne._closedPromise_reject = void 0);
}
var D = J("[[AbortSteps]]"), R = J("[[ErrorSteps]]"), N = J("[[CancelSteps]]"), T = J("[[PullSteps]]"), v = Number.isFinite || function(ne) {
return typeof ne == "number" && isFinite(ne);
}, F = Math.trunc || function(ne) {
return ne < 0 ? Math.ceil(ne) : Math.floor(ne);
};
function H(ne) {
return typeof ne == "object" || typeof ne == "function";
}
function j(ne, ue) {
if (ne !== void 0 && !H(ne))
throw new TypeError(ue + " is not an object.");
}
function I(ne, ue) {
if (typeof ne != "function")
throw new TypeError(ue + " is not a function.");
}
function B(ne) {
return typeof ne == "object" && ne !== null || typeof ne == "function";
}
function O(ne, ue) {
if (!B(ne))
throw new TypeError(ue + " is not an object.");
}
function k(ne, ue, ke) {
if (ne === void 0)
throw new TypeError("Parameter " + ue + " is required in '" + ke + "'.");
}
function L(ne, ue, ke) {
if (ne === void 0)
throw new TypeError(ue + " is required in '" + ke + "'.");
}
function z(ne) {
return Number(ne);
}
function K(ne) {
return ne === 0 ? 0 : ne;
}
function q(ne) {
return K(F(ne));
}
function W(ne, ue) {
var ke = 0, Ne = Number.MAX_SAFE_INTEGER, qe = Number(ne);
if (qe = K(qe), !v(qe))
throw new TypeError(ue + " is not a finite number");
if (qe = q(qe), qe < ke || qe > Ne)
throw new TypeError(ue + " is outside the accepted range of " + ke + " to " + Ne + ", inclusive");
return !v(qe) || qe === 0 ? 0 : qe;
}
function Y(ne, ue) {
if (!Mn(ne))
throw new TypeError(ue + " is not a ReadableStream.");
}
function V(ne) {
return new G(ne);
}
function ee(ne, ue) {
ne._reader._readRequests.push(ue);
}
function ae(ne, ue, ke) {
var Ne = ne._reader, qe = Ne._readRequests.shift();
ke ? qe._closeSteps() : qe._chunkSteps(ue);
}
function oe(ne) {
return ne._reader._readRequests.length;
}
function Z(ne) {
var ue = ne._reader;
return !(ue === void 0 || !se(ue));
}
var G = (
/** @class */
function() {
function ne(ue) {
if (k(ue, 1, "ReadableStreamDefaultReader"), Y(ue, "First parameter"), Dn(ue))
throw new TypeError("This stream has already been locked for exclusive reading by another reader");
S(this, ue), this._readRequests = new d();
}
return Object.defineProperty(ne.prototype, "closed", {
/**
* Returns a promise that will be fulfilled when the stream becomes closed,
* or rejected if the stream ever errors or the reader's lock is released before the stream finishes closing.
*/
get: function() {
return se(this) ? this._closedPromise : o(ge("closed"));
},
enumerable: !1,
configurable: !0
}), ne.prototype.cancel = function(ue) {
return ue === void 0 && (ue = void 0), se(this) ? this._ownerReadableStream === void 0 ? o(U("cancel")) : X(this, ue) : o(ge("cancel"));
}, ne.prototype.read = function() {
if (!se(this))
return o(ge("read"));
if (this._ownerReadableStream === void 0)
return o(U("read from"));
var ue, ke, Ne = e(function(lt, gt) {
ue = lt, ke = gt;
}), qe = {
_chunkSteps: function(lt) {
return ue({ value: lt, done: !1 });
},
_closeSteps: function() {
return ue({ value: void 0, done: !0 });
},
_errorSteps: function(lt) {
return ke(lt);
}
};
return le(this, qe), Ne;
}, ne.prototype.releaseLock = function() {
if (!se(this))
throw ge("releaseLock");
if (this._ownerReadableStream !== void 0) {
if (this._readRequests.length > 0)
throw new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled");
M(this);
}
}, ne;
}()
);
Object.defineProperties(G.prototype, {
cancel: { enumerable: !0 },
read: { enumerable: !0 },
releaseLock: { enumerable: !0 },
closed: { enumerable: !0 }
}), typeof J.toStringTag == "symbol" && Object.defineProperty(G.prototype, J.toStringTag, {
value: "ReadableStreamDefaultReader",
configurable: !0
});
function se(ne) {
return !g(ne) || !Object.prototype.hasOwnProperty.call(ne, "_readRequests") ? !1 : ne instanceof G;
}
function le(ne, ue) {
var ke = ne._ownerReadableStream;
ke._disturbed = !0, ke._state === "closed" ? ue._closeSteps() : ke._state === "errored" ? ue._errorSteps(ke._storedError) : ke._readableStreamController[T](ue);
}
function ge(ne) {
return new TypeError("ReadableStreamDefaultReader.prototype." + ne + " can only be used on a ReadableStreamDefaultReader");
}
var de, pe;
typeof J.asyncIterator == "symbol" && (pe = (de = {}, // 25.1.3.1 %AsyncIteratorPrototype% [ @@asyncIterator ] ( )
// https://tc39.github.io/ecma262/#sec-asynciteratorprototype-asynciterator
de[J.asyncIterator] = function() {
return this;
}, de), Object.defineProperty(pe, J.asyncIterator, { enumerable: !1 }));
var Fe = (
/** @class */
function() {
function ne(ue, ke) {
this._ongoingPromise = void 0, this._isFinished = !1, this._reader = ue, this._preventCancel = ke;
}
return ne.prototype.next = function() {
var ue = this, ke = function() {
return ue._nextSteps();
};
return this._ongoingPromise = this._ongoingPromise ? n(this._ongoingPromise, ke, ke) : ke(), this._ongoingPromise;
}, ne.prototype.return = function(ue) {
var ke = this, Ne = function() {
return ke._returnSteps(ue);
};
return this._ongoingPromise ? n(this._ongoingPromise, Ne, Ne) : Ne();
}, ne.prototype._nextSteps = function() {
var ue = this;
if (this._isFinished)
return Promise.resolve({ value: void 0, done: !0 });
var ke = this._reader;
if (ke._ownerReadableStream === void 0)
return o(U("iterate"));
var Ne, qe, lt = e(function(Tt, Ut) {
Ne = Tt, qe = Ut;
}), gt = {
_chunkSteps: function(Tt) {
ue._ongoingPromise = void 0, i(function() {
return Ne({ value: Tt, done: !1 });
});
},
_closeSteps: function() {
ue._ongoingPromise = void 0, ue._isFinished = !0, M(ke), Ne({ value: void 0, done: !0 });
},
_errorSteps: function(Tt) {
ue._ongoingPromise = void 0, ue._isFinished = !0, M(ke), qe(Tt);
}
};
return le(ke, gt), lt;
}, ne.prototype._returnSteps = function(ue) {
if (this._isFinished)
return Promise.resolve({ value: ue, done: !0 });
this._isFinished = !0;
var ke = this._reader;
if (ke._ownerReadableStream === void 0)
return o(U("finish iterating"));
if (!this._preventCancel) {
var Ne = X(ke, ue);
return M(ke), n(Ne, function() {
return { value: ue, done: !0 };
});
}
return M(ke), b({ value: ue, done: !0 });
}, ne;
}()
), Ae = {
next: function() {
return Ie(this) ? this._asyncIteratorImpl.next() : o(Me("next"));
},
return: function(ne) {
return Ie(this) ? this._asyncIteratorImpl.return(ne) : o(Me("return"));
}
};
pe !== void 0 && Object.setPrototypeOf(Ae, pe);
function Pe(ne, ue) {
var ke = V(ne), Ne = new Fe(ke, ue), qe = Object.create(Ae);
return qe._asyncIteratorImpl = Ne, qe;
}
function Ie(ne) {
if (!g(ne) || !Object.prototype.hasOwnProperty.call(ne, "_asyncIteratorImpl"))
return !1;
try {
return ne._asyncIteratorImpl instanceof Fe;
} catch {
return !1;
}
}
function Me(ne) {
return new TypeError("ReadableStreamAsyncIterator." + ne + " can only be used on a ReadableSteamAsyncIterator");
}
var Oe = Number.isNaN || function(ne) {
return ne !== ne;
};
function Se(ne) {
return ne.slice();
}
function Ce(ne, ue, ke, Ne, qe) {
new Uint8Array(ne).set(new Uint8Array(ke, Ne, qe), ue);
}
function me(ne) {
return ne;
}
function fe(ne) {
return !1;
}
function be(ne, ue, ke) {
if (ne.slice)
return ne.slice(ue, ke);
var Ne = ke - ue, qe = new ArrayBuffer(Ne);
return Ce(qe, 0, ne, ue, Ne), qe;
}
function ye(ne) {
return !(typeof ne != "number" || Oe(ne) || ne < 0);
}
function _e(ne) {
var ue = be(ne.buffer, ne.byteOffset, ne.byteOffset + ne.byteLength);
return new Uint8Array(ue);
}
function De(ne) {
var ue = ne._queue.shift();
return ne._queueTotalSize -= ue.size, ne._queueTotalSize < 0 && (ne._queueTotalSize = 0), ue.value;
}
function Ee(ne, ue, ke) {
if (!ye(ke) || ke === 1 / 0)
throw new RangeError("Size must be a finite, non-NaN, non-negative number.");
ne._queue.push({ value: ue, size: ke }), ne._queueTotalSize += ke;
}
function ve(ne) {
var ue = ne._queue.peek();
return ue.value;
}
function we(ne) {
ne._queue = new d(), ne._queueTotalSize = 0;
}
var Re = (
/** @class */
function() {
function ne() {
throw new TypeError("Illegal constructor");
}
return Object.defineProperty(ne.prototype, "view", {
/**
* Returns the view for writing in to, or `null` if the BYOB request has already been responded to.
*/
get: function() {
if (!Ge(this))
throw Qe("view");
return this._view;
},
enumerable: !1,
configurable: !0
}), ne.prototype.respond = function(ue) {
if (!Ge(this))
throw Qe("respond");
if (k(ue, 1, "respond"), ue = W(ue, "First parameter"), this._associatedReadableByteStreamController === void 0)
throw new TypeError("This BYOB request has been invalidated");
fe(this._view.buffer), Ot(this._associatedReadableByteStreamController, ue);
}, ne.prototype.respondWithNewView = function(ue) {
if (!Ge(this))
throw Qe("respondWithNewView");
if (k(ue, 1, "respondWithNewView"), !ArrayBuffer.isView(ue))
throw new TypeError("You can only respond with array buffer views");
if (this._associatedReadableByteStreamController === void 0)
throw new TypeError("This BYOB request has been invalidated");
fe(ue.buffer), Ft(this._associatedReadableByteStreamController, ue);
}, ne;
}()
);
Object.defineProperties(Re.prototype, {
respond: { enumerable: !0 },
respondWithNewView: { enumerable: !0 },
view: { enumerable: !0 }
}), typeof J.toStringTag == "symbol" && Object.defineProperty(Re.prototype, J.toStringTag, {
value: "ReadableStreamBYOBRequest",
configurable: !0
});
var Ue = (
/** @class */
function() {
function ne() {
throw new TypeError("Illegal constructor");
}
return Object.defineProperty(ne.prototype, "byobRequest", {
/**
* Returns the current BYOB pull request, or `null` if there isn't one.
*/
get: function() {
if (!Be(this))
throw Je("byobRequest");
return At(this);
},
enumerable: !1,
configurable: !0
}), Object.defineProperty(ne.prototype, "desiredSize", {
/**
* Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
* over-full. An underlying byte source ought to use this information to determine when and how to apply backpressure.
*/
get: function() {
if (!Be(this))
throw Je("desiredSize");
return bt(this);
},
enumerable: !1,
configurable: !0
}), ne.prototype.close = function() {
if (!Be(this))
throw Je("close");
if (this._closeRequested)
throw new TypeError("The stream has already been closed; do not close it again!");
var ue = this._controlledReadableByteStream._state;
if (ue !== "readable")
throw new TypeError("The stream (in " + ue + " state) is not in the readable state and cannot be closed");
mt(this);
}, ne.prototype.enqueue = function(ue) {
if (!Be(this))
throw Je("enqueue");
if (k(ue, 1, "enqueue"), !ArrayBuffer.isView(ue))
throw new TypeError("chunk must be an array buffer view");
if (ue.byteLength === 0)
throw new TypeError("chunk must have non-zero byteLength");
if (ue.buffer.byteLength === 0)
throw new TypeError("chunk's buffer must have non-zero byteLength");
if (this._closeRequested)
throw new TypeError("stream is closed or draining");
var ke = this._controlledReadableByteStream._state;
if (ke !== "readable")
throw new TypeError("The stream (in " + ke + " state) is not in the readable state and cannot be enqueued to");
St(this, ue);
}, ne.prototype.error = function(ue) {
if (ue === void 0 && (ue = void 0), !Be(this))
throw Je("error");
nt(this, ue);
}, ne.prototype[N] = function(ue) {
$e(this), we(this);
var ke = this._cancelAlgorithm(ue);
return dt(this), ke;
}, ne.prototype[T] = function(ue) {
var ke = this._controlledReadableByteStream;
if (this._queueTotalSize > 0) {
var Ne = this._queue.shift();
this._queueTotalSize -= Ne.byteLength, st(this);
var qe = new Uint8Array(Ne.buffer, Ne.byteOffset, Ne.byteLength);
ue._chunkSteps(qe);
return;
}
var lt = this._autoAllocateChunkSize;
if (lt !== void 0) {
var gt = void 0;
try {
gt = new ArrayBuffer(lt);
} catch (Ut) {
ue._errorSteps(Ut);
return;
}
var Tt = {
buffer: gt,
bufferByteLength: lt,
byteOffset: 0,
byteLength: lt,
bytesFilled: 0,
elementSize: 1,
viewConstructor: Uint8Array,
readerType: "default"
};
this._pendingPullIntos.push(Tt);
}
ee(ke, ue), tt(this);
}, ne;
}()
);
Object.defineProperties(Ue.prototype, {
close: { enumerable: !0 },
enqueue: { enumerable: !0 },
error: { enumerable: !0 },
byobRequest: { enumerable: !0 },
desiredSize: { enumerable: !0 }
}), typeof J.toStringTag == "symbol" && Object.defineProperty(Ue.prototype, J.toStringTag, {
value: "ReadableByteStreamController",
configurable: !0
});
function Be(ne) {
return !g(ne) || !Object.prototype.hasOwnProperty.call(ne, "_controlledReadableByteStream") ? !1 : ne instanceof Ue;
}
function Ge(ne) {
return !g(ne) || !Object.prototype.hasOwnProperty.call(ne, "_associatedReadableByteStreamController") ? !1 : ne instanceof Re;
}
function tt(ne) {
var ue = et(ne);
if (ue) {
if (ne._pulling) {
ne._pullAgain = !0;
return;
}
ne._pulling = !0;
var ke = ne._pullAlgorithm();
x(ke, function() {
ne._pulling = !1, ne._pullAgain && (ne._pullAgain = !1, tt(ne));
}, function(Ne) {
nt(ne, Ne);
});
}
}
function $e(ne) {
pt(ne), ne._pendingPullIntos = new d();
}
function rt(ne, ue) {
var ke = !1;
ne._state === "closed" && (ke = !0);
var Ne = ht(ue);
ue.readerType === "default" ? ae(ne, Ne, ke) : Ht(ne, Ne, ke);
}
function ht(ne) {
var ue = ne.bytesFilled, ke = ne.elementSize;
return new ne.viewConstructor(ne.buffer, ne.byteOffset, ue / ke);
}
function He(ne, ue, ke, Ne) {
ne._queue.push({ buffer: ue, byteOffset: ke, byteLength: Ne }), ne._queueTotalSize += Ne;
}
function ct(ne, ue) {
var ke = ue.elementSize, Ne = ue.bytesFilled - ue.bytesFilled % ke, qe = Math.min(ne._queueTotalSize, ue.byteLength - ue.bytesFilled), lt = ue.bytesFilled + qe, gt = lt - lt % ke, Tt = qe, Ut = !1;
gt > Ne && (Tt = gt - ue.bytesFilled, Ut = !0);
for (var jt = ne._queue; Tt > 0; ) {
var Wt = jt.peek(), Vt = Math.min(Tt, Wt.byteLength), nn = ue.byteOffset + ue.bytesFilled;
Ce(ue.buffer, nn, Wt.buffer, Wt.byteOffset, Vt), Wt.byteLength === Vt ? jt.shift() : (Wt.byteOffset += Vt, Wt.byteLength -= Vt), ne._queueTotalSize -= Vt, at(ne, Vt, ue), Tt -= Vt;
}
return Ut;
}
function at(ne, ue, ke) {
ke.bytesFilled += ue;
}
function st(ne) {
ne._queueTotalSize === 0 && ne._closeRequested ? (dt(ne), pr(ne._controlledReadableByteStream)) : tt(ne);
}
function pt(ne) {
ne._byobRequest !== null && (ne._byobRequest._associatedReadableByteStreamController = void 0, ne._byobRequest._view = null, ne._byobRequest = null);
}
function vt(ne) {
for (; ne._pendingPullIntos.length > 0; ) {
if (ne._queueTotalSize === 0)
return;
var ue = ne._pendingPullIntos.peek();
ct(ne, ue) && (it(ne), rt(ne._controlledReadableByteStream, ue));
}
}
function xt(ne, ue, ke) {
var Ne = ne._controlledReadableByteStream, qe = 1;
ue.constructor !== DataView && (qe = ue.constructor.BYTES_PER_ELEMENT);
var lt = ue.constructor, gt = ue.buffer, Tt = {
buffer: gt,
bufferByteLength: gt.byteLength,
byteOffset: ue.byteOffset,
byteLength: ue.byteLength,
bytesFilled: 0,
elementSize: qe,
viewConstructor: lt,
readerType: "byob"
};
if (ne._pendingPullIntos.length > 0) {
ne._pendingPullIntos.push(Tt), kt(Ne, ke);
return;
}
if (Ne._state === "closed") {
var Ut = new lt(Tt.buffer, Tt.byteOffset, 0);
ke._closeSteps(Ut);
return;
}
if (ne._queueTotalSize > 0) {
if (ct(ne, Tt)) {
var jt = ht(Tt);
st(ne), ke._chunkSteps(jt);
return;
}
if (ne._closeRequested) {
var Wt = new TypeError("Insufficient bytes to fill elements in the given buffer");
nt(ne, Wt), ke._errorSteps(Wt);
return;
}
}
ne._pendingPullIntos.push(Tt), kt(Ne, ke), tt(ne);
}
function Xt(ne, ue) {
var ke = ne._controlledReadableByteStream;
if (_t(ke))
for (; Pt(ke) > 0; ) {
var Ne = it(ne);
rt(ke, Ne);
}
}
function Ze(ne, ue, ke) {
if (at(ne, ue, ke), !(ke.bytesFilled < ke.elementSize)) {
it(ne);
var Ne = ke.bytesFilled % ke.elementSize;
if (Ne > 0) {
var qe = ke.byteOffset + ke.bytesFilled, lt = be(ke.buffer, qe - Ne, qe);
He(ne, lt, 0, lt.byteLength);
}
ke.bytesFilled -= Ne, rt(ne._controlledReadableByteStream, ke), vt(ne);
}
}
function Ve(ne, ue) {
var ke = ne._pendingPullIntos.peek();
pt(ne);
var Ne = ne._controlledReadableByteStream._state;
Ne === "closed" ? Xt(ne) : Ze(ne, ue, ke), tt(ne);
}
function it(ne) {
var ue = ne._pendingPullIntos.shift();
return ue;
}
function et(ne) {
var ue = ne._controlledReadableByteStream;
if (ue._state !== "readable" || ne._closeRequested || !ne._started)
return !1;
if (Z(ue) && oe(ue) > 0 || _t(ue) && Pt(ue) > 0)
return !0;
var ke = bt(ne);
return ke > 0;
}
function dt(ne) {
ne._pullAlgorithm = void 0, ne._cancelAlgorithm = void 0;
}
function mt(ne) {
var ue = ne._controlledReadableByteStream;
if (!(ne._closeRequested || ue._state !== "readable")) {
if (ne._queueTotalSize > 0) {
ne._closeRequested = !0;
return;
}
if (ne._pendingPullIntos.length > 0) {
var ke = ne._pendingPullIntos.peek();
if (ke.bytesFilled > 0) {
var Ne = new TypeError("Insufficient bytes to fill elements in the given buffer");
throw nt(ne, Ne), Ne;
}
}
dt(ne), pr(ue);
}
}
function St(ne, ue) {
var ke = ne._controlledReadableByteStream;
if (!(ne._closeRequested || ke._state !== "readable")) {
var Ne = ue.buffer, qe = ue.byteOffset, lt = ue.byteLength, gt = Ne;
if (ne._pendingPullIntos.length > 0) {
var Tt = ne._pendingPullIntos.peek();
fe(Tt.buffer), Tt.buffer = Tt.buffer;
}
if (pt(ne), Z(ke))
if (oe(ke) === 0)
He(ne, gt, qe, lt);
else {
ne._pendingPullIntos.length > 0 && it(ne);
var Ut = new Uint8Array(gt, qe, lt);
ae(ke, Ut, !1);
}
else
_t(ke) ? (He(ne, gt, qe, lt), vt(ne)) : He(ne, gt, qe, lt);
tt(ne);
}
}
function nt(ne, ue) {
var ke = ne._controlledReadableByteStream;
ke._state === "readable" && ($e(ne), we(ne), dt(ne), Xi(ke, ue));
}
function At(ne) {
if (ne._byobRequest === null && ne._pendingPullIntos.length > 0) {
var ue = ne._pendingPullIntos.peek(), ke = new Uint8Array(ue.buffer, ue.byteOffset + ue.bytesFilled, ue.byteLength - ue.bytesFilled), Ne = Object.create(Re.prototype);
We(Ne, ne, ke), ne._byobRequest = Ne;
}
return ne._byobRequest;
}
function bt(ne) {
var ue = ne._controlledReadableByteStream._state;
return ue === "errored" ? null : ue === "closed" ? 0 : ne._strategyHWM - ne._queueTotalSize;
}
function Ot(ne, ue) {
var ke = ne._pendingPullIntos.peek(), Ne = ne._controlledReadableByteStream._state;
if (Ne === "closed") {
if (ue !== 0)
throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream");
} else {
if (ue === 0)
throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");
if (ke.bytesFilled + ue > ke.byteLength)
throw new RangeError("bytesWritten out of range");
}
ke.buffer = ke.buffer, Ve(ne, ue);
}
function Ft(ne, ue) {
var ke = ne._pendingPullIntos.peek(), Ne = ne._controlledReadableByteStream._state;
if (Ne === "closed") {
if (ue.byteLength !== 0)
throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream");
} else if (ue.byteLength === 0)
throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");
if (ke.byteOffset + ke.bytesFilled !== ue.byteOffset)
throw new RangeError("The region specified by view does not match byobRequest");
if (ke.bufferByteLength !== ue.buffer.byteLength)
throw new RangeError("The buffer of view has different capacity than byobRequest");
if (ke.bytesFilled + ue.byteLength > ke.byteLength)
throw new RangeError("The region specified by view is larger than byobRequest");
var qe = ue.byteLength;
ke.buffer = ue.buffer, Ve(ne, qe);
}
function wt(ne, ue, ke, Ne, qe, lt, gt) {
ue._controlledReadableByteStream = ne, ue._pullAgain = !1, ue._pulling = !1, ue._byobRequest = null, ue._queue = ue._queueTotalSize = void 0, we(ue), ue._closeRequested = !1, ue._started = !1, ue._strategyHWM = lt, ue._pullAlgorithm = Ne, ue._cancelAlgorithm = qe, ue._autoAllocateChunkSize = gt, ue._pendingPullIntos = new d(), ne._readableStreamController = ue;
var Tt = ke();
x(b(Tt), function() {
ue._started = !0, tt(ue);
}, function(Ut) {
nt(ue, Ut);
});
}
function Le(ne, ue, ke) {
var Ne = Object.create(Ue.prototype), qe = function() {
}, lt = function() {
return b(void 0);
}, gt = function() {
return b(void 0);
};
ue.start !== void 0 && (qe = function() {
return ue.start(Ne);
}), ue.pull !== void 0 && (lt = function() {
return ue.pull(Ne);
}), ue.cancel !== void 0 && (gt = function(Ut) {
return ue.cancel(Ut);
});
var Tt = ue.autoAllocateChunkSize;
if (Tt === 0)
throw new TypeError("autoAllocateChunkSize must be greater than 0");
wt(ne, Ne, qe, lt, gt, ke, Tt);
}
function We(ne, ue, ke) {
ne._associatedReadableByteStreamController = ue, ne._view = ke;
}
function Qe(ne) {
return new TypeError("ReadableStreamBYOBRequest.prototype." + ne + " can only be used on a ReadableStreamBYOBRequest");
}
function Je(ne) {
return new TypeError("ReadableByteStreamController.prototype." + ne + " can only be used on a ReadableByteStreamController");
}
function ut(ne) {
return new $t(ne);
}
function kt(ne, ue) {
ne._reader._readIntoRequests.push(ue);
}
function Ht(ne, ue, ke) {
var Ne = ne._reader, qe = Ne._readIntoRequests.shift();
ke ? qe._closeSteps(ue) : qe._chunkSteps(ue);
}
function Pt(ne) {
return ne._reader._readIntoRequests.length;
}
function _t(ne) {
var ue = ne._reader;
return !(ue === void 0 || !qt(ue));
}
var $t = (
/** @class */
function() {
function ne(ue) {
if (k(ue, 1, "ReadableStreamBYOBReader"), Y(ue, "First parameter"), Dn(ue))
throw new TypeError("This stream has already been locked for exclusive reading by another reader");
if (!Be(ue._readableStreamController))
throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");
S(this, ue), this._readIntoRequests = new d();
}
return Object.defineProperty(ne.prototype, "closed", {
/**
* Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or
* the reader's lock is released before the stream finishes closing.
*/
get: function() {
return qt(this) ? this._closedPromise : o(Fn("closed"));
},
enumerable: !1,
configurable: !0
}), ne.prototype.cancel = function(ue) {
return ue === void 0 && (ue = void 0), qt(this) ? this._ownerReadableStream === void 0 ? o(U("cancel")) : X(this, ue) : o(Fn("cancel"));
}, ne.prototype.read = function(ue) {
if (!qt(this))
return o(Fn("read"));
if (!ArrayBuffer.isView(ue))
return o(new TypeError("view must be an array buffer view"));
if (ue.byteLength === 0)
return o(new TypeError("view must have non-zero byteLength"));
if (ue.buffer.byteLength === 0)
return o(new TypeError("view's buffer must have non-zero byteLength"));
if (fe(ue.buffer), this._ownerReadableStream === void 0)
return o(U("read from"));
var ke, Ne, qe = e(function(gt, Tt) {
ke = gt, Ne = Tt;
}), lt = {
_chunkSteps: function(gt) {
return ke({ value: gt, done: !1 });
},
_closeSteps: function(gt) {
return ke({ value: gt, done: !0 });
},
_errorSteps: function(gt) {
return Ne(gt);
}
};
return ln(this, ue, lt), qe;
}, ne.prototype.releaseLock = function() {
if (!qt(this))
throw Fn("releaseLock");
if (this._ownerReadableStream !== void 0) {
if (this._readIntoRequests.leng