barcode-detector 3.0.5 → 3.0.7
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +1 -1
- package/dist/cjs/ponyfill.js +1 -1
- package/dist/es/ponyfill.js +1197 -1254
- package/dist/iife/index.js +1 -1
- package/dist/iife/polyfill.js +1 -1
- package/dist/iife/ponyfill.js +1 -1
- package/package.json +22 -21
package/dist/es/ponyfill.js
CHANGED
|
@@ -1,9 +1,9 @@
|
|
|
1
|
-
var
|
|
1
|
+
var Ue = (o) => {
|
|
2
2
|
throw TypeError(o);
|
|
3
3
|
};
|
|
4
|
-
var
|
|
5
|
-
var
|
|
6
|
-
const
|
|
4
|
+
var Ve = (o, l, h) => l.has(o) || Ue("Cannot " + h);
|
|
5
|
+
var We = (o, l, h) => (Ve(o, l, "read from private field"), h ? h.call(o) : l.get(o)), He = (o, l, h) => l.has(o) ? Ue("Cannot add the same private member more than once") : l instanceof WeakSet ? l.add(o) : l.set(o, h), ke = (o, l, h, b) => (Ve(o, l, "write to private field"), b ? b.call(o, h) : l.set(o, h), h);
|
|
6
|
+
const Dt = [
|
|
7
7
|
["Aztec", "M"],
|
|
8
8
|
["Codabar", "L"],
|
|
9
9
|
["Code39", "L"],
|
|
@@ -24,44 +24,44 @@ const Ft = [
|
|
|
24
24
|
["rMQRCode", "M"],
|
|
25
25
|
["DXFilmEdge", "L"],
|
|
26
26
|
["DataBarLimited", "L"]
|
|
27
|
-
],
|
|
28
|
-
(o, l) =>
|
|
29
|
-
),
|
|
30
|
-
(o, l) =>
|
|
27
|
+
], Mt = Dt.map(([o]) => o), Ma = Mt.filter(
|
|
28
|
+
(o, l) => Dt[l][1] === "L"
|
|
29
|
+
), Aa = Mt.filter(
|
|
30
|
+
(o, l) => Dt[l][1] === "M"
|
|
31
31
|
);
|
|
32
|
-
function
|
|
32
|
+
function qt(o) {
|
|
33
33
|
switch (o) {
|
|
34
34
|
case "Linear-Codes":
|
|
35
|
-
return
|
|
35
|
+
return Ma.reduce((l, h) => l | qt(h), 0);
|
|
36
36
|
case "Matrix-Codes":
|
|
37
|
-
return
|
|
37
|
+
return Aa.reduce((l, h) => l | qt(h), 0);
|
|
38
38
|
case "Any":
|
|
39
|
-
return (1 <<
|
|
39
|
+
return (1 << Dt.length) - 1;
|
|
40
40
|
case "None":
|
|
41
41
|
return 0;
|
|
42
42
|
default:
|
|
43
|
-
return 1 <<
|
|
43
|
+
return 1 << Mt.indexOf(o);
|
|
44
44
|
}
|
|
45
45
|
}
|
|
46
|
-
function
|
|
46
|
+
function Fa(o) {
|
|
47
47
|
if (o === 0)
|
|
48
48
|
return "None";
|
|
49
49
|
const l = 31 - Math.clz32(o);
|
|
50
|
-
return
|
|
50
|
+
return Mt[l];
|
|
51
51
|
}
|
|
52
|
-
function
|
|
53
|
-
return o.reduce((l, h) => l |
|
|
52
|
+
function Ra(o) {
|
|
53
|
+
return o.reduce((l, h) => l | qt(h), 0);
|
|
54
54
|
}
|
|
55
|
-
const
|
|
55
|
+
const La = [
|
|
56
56
|
"LocalAverage",
|
|
57
57
|
"GlobalHistogram",
|
|
58
58
|
"FixedThreshold",
|
|
59
59
|
"BoolCast"
|
|
60
60
|
];
|
|
61
|
-
function
|
|
62
|
-
return
|
|
61
|
+
function ja(o) {
|
|
62
|
+
return La.indexOf(o);
|
|
63
63
|
}
|
|
64
|
-
const
|
|
64
|
+
const Ne = [
|
|
65
65
|
"Unknown",
|
|
66
66
|
"ASCII",
|
|
67
67
|
"ISO8859_1",
|
|
@@ -101,10 +101,10 @@ const Le = [
|
|
|
101
101
|
"UTF32LE",
|
|
102
102
|
"BINARY"
|
|
103
103
|
];
|
|
104
|
-
function
|
|
105
|
-
return o === "UnicodeBig" ?
|
|
104
|
+
function Ba(o) {
|
|
105
|
+
return o === "UnicodeBig" ? Ne.indexOf("UTF16BE") : Ne.indexOf(o);
|
|
106
106
|
}
|
|
107
|
-
const
|
|
107
|
+
const Ua = [
|
|
108
108
|
"Text",
|
|
109
109
|
"Binary",
|
|
110
110
|
"Mixed",
|
|
@@ -112,18 +112,18 @@ const za = [
|
|
|
112
112
|
"ISO15434",
|
|
113
113
|
"UnknownECI"
|
|
114
114
|
];
|
|
115
|
-
function
|
|
116
|
-
return
|
|
115
|
+
function Va(o) {
|
|
116
|
+
return Ua[o];
|
|
117
117
|
}
|
|
118
|
-
const
|
|
119
|
-
function
|
|
120
|
-
return
|
|
118
|
+
const Wa = ["Ignore", "Read", "Require"];
|
|
119
|
+
function Ha(o) {
|
|
120
|
+
return Wa.indexOf(o);
|
|
121
121
|
}
|
|
122
|
-
const
|
|
123
|
-
function
|
|
124
|
-
return
|
|
122
|
+
const ka = ["Plain", "ECI", "HRI", "Hex", "Escaped"];
|
|
123
|
+
function Na(o) {
|
|
124
|
+
return ka.indexOf(o);
|
|
125
125
|
}
|
|
126
|
-
const
|
|
126
|
+
const It = {
|
|
127
127
|
formats: [],
|
|
128
128
|
tryHarder: !0,
|
|
129
129
|
tryRotate: !0,
|
|
@@ -142,804 +142,786 @@ const Mt = {
|
|
|
142
142
|
textMode: "HRI",
|
|
143
143
|
characterSet: "Unknown"
|
|
144
144
|
};
|
|
145
|
-
function
|
|
145
|
+
function ze(o) {
|
|
146
146
|
return {
|
|
147
147
|
...o,
|
|
148
|
-
formats:
|
|
149
|
-
binarizer:
|
|
150
|
-
eanAddOnSymbol:
|
|
151
|
-
textMode:
|
|
152
|
-
characterSet:
|
|
148
|
+
formats: Ra(o.formats),
|
|
149
|
+
binarizer: ja(o.binarizer),
|
|
150
|
+
eanAddOnSymbol: Ha(o.eanAddOnSymbol),
|
|
151
|
+
textMode: Na(o.textMode),
|
|
152
|
+
characterSet: Ba(o.characterSet)
|
|
153
153
|
};
|
|
154
154
|
}
|
|
155
|
-
function
|
|
155
|
+
function za(o) {
|
|
156
156
|
return {
|
|
157
157
|
...o,
|
|
158
|
-
format:
|
|
159
|
-
contentType:
|
|
158
|
+
format: Fa(o.format),
|
|
159
|
+
contentType: Va(o.contentType),
|
|
160
160
|
eccLevel: o.ecLevel
|
|
161
161
|
};
|
|
162
162
|
}
|
|
163
|
-
const
|
|
163
|
+
const vo = "2.2.3", yo = "fba4e9503fee4518ca2e89510baeea9bcc36dc8d", Ga = {
|
|
164
164
|
locateFile: (o, l) => {
|
|
165
165
|
const h = o.match(/_(.+?)\.wasm$/);
|
|
166
|
-
return h ? `https://fastly.jsdelivr.net/npm/zxing-wasm@2.2.
|
|
166
|
+
return h ? `https://fastly.jsdelivr.net/npm/zxing-wasm@2.2.3/dist/${h[1]}/${o}` : l + o;
|
|
167
167
|
}
|
|
168
|
-
},
|
|
169
|
-
function
|
|
168
|
+
}, St = /* @__PURE__ */ new WeakMap();
|
|
169
|
+
function Xa(o, l) {
|
|
170
170
|
return Object.is(o, l) || Object.keys(o).length === Object.keys(l).length && Object.keys(o).every(
|
|
171
171
|
(h) => Object.hasOwn(l, h) && o[h] === l[h]
|
|
172
172
|
);
|
|
173
173
|
}
|
|
174
|
-
function
|
|
174
|
+
function Xe(o, {
|
|
175
175
|
overrides: l,
|
|
176
|
-
equalityFn: h =
|
|
177
|
-
fireImmediately:
|
|
176
|
+
equalityFn: h = Xa,
|
|
177
|
+
fireImmediately: b = !1
|
|
178
178
|
} = {}) {
|
|
179
|
-
var
|
|
180
|
-
const [
|
|
181
|
-
let
|
|
182
|
-
if (
|
|
183
|
-
if (
|
|
184
|
-
return
|
|
185
|
-
const
|
|
186
|
-
...
|
|
179
|
+
var f;
|
|
180
|
+
const [I, D] = (f = St.get(o)) != null ? f : [Ga], M = l != null ? l : I;
|
|
181
|
+
let _;
|
|
182
|
+
if (b) {
|
|
183
|
+
if (D && (_ = h(I, M)))
|
|
184
|
+
return D;
|
|
185
|
+
const A = o({
|
|
186
|
+
...M
|
|
187
187
|
});
|
|
188
|
-
return
|
|
188
|
+
return St.set(o, [M, A]), A;
|
|
189
189
|
}
|
|
190
|
-
(
|
|
190
|
+
(_ != null ? _ : h(I, M)) || St.set(o, [M]);
|
|
191
191
|
}
|
|
192
|
-
function
|
|
193
|
-
|
|
192
|
+
function qa(o) {
|
|
193
|
+
St.delete(o);
|
|
194
194
|
}
|
|
195
|
-
async function
|
|
196
|
-
const
|
|
197
|
-
...
|
|
195
|
+
async function Ya(o, l, h = It) {
|
|
196
|
+
const b = {
|
|
197
|
+
...It,
|
|
198
198
|
...h
|
|
199
|
-
},
|
|
199
|
+
}, f = await Xe(o, {
|
|
200
200
|
fireImmediately: !0
|
|
201
201
|
});
|
|
202
|
-
let
|
|
202
|
+
let I, D;
|
|
203
203
|
if ("width" in l && "height" in l && "data" in l) {
|
|
204
204
|
const {
|
|
205
|
-
data:
|
|
206
|
-
data: { byteLength:
|
|
207
|
-
width:
|
|
205
|
+
data: _,
|
|
206
|
+
data: { byteLength: A },
|
|
207
|
+
width: U,
|
|
208
208
|
height: X
|
|
209
209
|
} = l;
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
210
|
+
D = f._malloc(A), f.HEAPU8.set(_, D), I = f.readBarcodesFromPixmap(
|
|
211
|
+
D,
|
|
212
|
+
U,
|
|
213
213
|
X,
|
|
214
|
-
|
|
214
|
+
ze(b)
|
|
215
215
|
);
|
|
216
216
|
} else {
|
|
217
|
-
let
|
|
217
|
+
let _, A;
|
|
218
218
|
if ("buffer" in l)
|
|
219
|
-
[
|
|
219
|
+
[_, A] = [l.byteLength, l];
|
|
220
220
|
else if ("byteLength" in l)
|
|
221
|
-
[
|
|
221
|
+
[_, A] = [l.byteLength, new Uint8Array(l)];
|
|
222
222
|
else if ("size" in l)
|
|
223
|
-
[
|
|
223
|
+
[_, A] = [l.size, new Uint8Array(await l.arrayBuffer())];
|
|
224
224
|
else
|
|
225
225
|
throw new TypeError("Invalid input type");
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
226
|
+
D = f._malloc(_), f.HEAPU8.set(A, D), I = f.readBarcodesFromImage(
|
|
227
|
+
D,
|
|
228
|
+
_,
|
|
229
|
+
ze(b)
|
|
230
230
|
);
|
|
231
231
|
}
|
|
232
|
-
|
|
233
|
-
const
|
|
234
|
-
for (let
|
|
235
|
-
|
|
236
|
-
|
|
232
|
+
f._free(D);
|
|
233
|
+
const M = [];
|
|
234
|
+
for (let _ = 0; _ < I.size(); ++_)
|
|
235
|
+
M.push(
|
|
236
|
+
za(I.get(_))
|
|
237
237
|
);
|
|
238
|
-
return
|
|
238
|
+
return M;
|
|
239
239
|
}
|
|
240
240
|
({
|
|
241
|
-
...
|
|
242
|
-
formats: [...
|
|
241
|
+
...It,
|
|
242
|
+
formats: [...It.formats]
|
|
243
243
|
});
|
|
244
|
-
|
|
245
|
-
var l, h, f = o,
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
var st, et;
|
|
254
|
-
if (j || M || x) {
|
|
244
|
+
async function Zt(o = {}) {
|
|
245
|
+
var l, h, b, f = o, I = !!globalThis.window, D = typeof Bun < "u", M = !!globalThis.WorkerGlobalScope;
|
|
246
|
+
!((h = globalThis.process) === null || h === void 0 || (h = h.versions) === null || h === void 0) && h.node && ((b = globalThis.process) === null || b === void 0 ? void 0 : b.type) != "renderer";
|
|
247
|
+
var _ = "./this.program", A, U = "";
|
|
248
|
+
function X(t) {
|
|
249
|
+
return f.locateFile ? f.locateFile(t, U) : U + t;
|
|
250
|
+
}
|
|
251
|
+
var tt, q;
|
|
252
|
+
if (I || M || D) {
|
|
255
253
|
try {
|
|
256
|
-
|
|
254
|
+
U = new URL(".", A).href;
|
|
257
255
|
} catch {
|
|
258
256
|
}
|
|
259
|
-
M && (
|
|
260
|
-
var
|
|
261
|
-
return
|
|
262
|
-
}),
|
|
263
|
-
var
|
|
257
|
+
M && (q = (t) => {
|
|
258
|
+
var e = new XMLHttpRequest();
|
|
259
|
+
return e.open("GET", t, !1), e.responseType = "arraybuffer", e.send(null), new Uint8Array(e.response);
|
|
260
|
+
}), tt = async (t) => {
|
|
261
|
+
var e = await fetch(t, {
|
|
264
262
|
credentials: "same-origin"
|
|
265
263
|
});
|
|
266
|
-
if (
|
|
267
|
-
return
|
|
268
|
-
throw new Error(
|
|
264
|
+
if (e.ok)
|
|
265
|
+
return e.arrayBuffer();
|
|
266
|
+
throw new Error(e.status + " : " + e.url);
|
|
269
267
|
};
|
|
270
268
|
}
|
|
271
|
-
var
|
|
272
|
-
function
|
|
273
|
-
var
|
|
274
|
-
|
|
269
|
+
var nt = console.log.bind(console), V = console.error.bind(console), Y, ht = !1, Qt, Jt, Z, W, dt, at, ot, P, Kt, te, ee = !1;
|
|
270
|
+
function re() {
|
|
271
|
+
var t = Pt.buffer;
|
|
272
|
+
Z = new Int8Array(t), dt = new Int16Array(t), f.HEAPU8 = W = new Uint8Array(t), at = new Uint16Array(t), ot = new Int32Array(t), P = new Uint32Array(t), Kt = new Float32Array(t), te = new Float64Array(t);
|
|
275
273
|
}
|
|
276
|
-
function
|
|
274
|
+
function ar() {
|
|
277
275
|
if (f.preRun)
|
|
278
276
|
for (typeof f.preRun == "function" && (f.preRun = [f.preRun]); f.preRun.length; )
|
|
279
|
-
|
|
280
|
-
|
|
277
|
+
vr(f.preRun.shift());
|
|
278
|
+
ne(oe);
|
|
281
279
|
}
|
|
282
|
-
function
|
|
283
|
-
|
|
280
|
+
function or() {
|
|
281
|
+
ee = !0, lt.xa();
|
|
284
282
|
}
|
|
285
|
-
function
|
|
283
|
+
function ir() {
|
|
286
284
|
if (f.postRun)
|
|
287
285
|
for (typeof f.postRun == "function" && (f.postRun = [f.postRun]); f.postRun.length; )
|
|
288
|
-
|
|
289
|
-
ae
|
|
290
|
-
}
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
var r = new WebAssembly.RuntimeError(e);
|
|
307
|
-
throw O(r), r;
|
|
308
|
-
}
|
|
309
|
-
var gt;
|
|
310
|
-
function rr() {
|
|
311
|
-
return it("zxing_reader.wasm");
|
|
312
|
-
}
|
|
313
|
-
function nr(e) {
|
|
314
|
-
if (e == gt && ut)
|
|
315
|
-
return new Uint8Array(ut);
|
|
316
|
-
if (et)
|
|
317
|
-
return et(e);
|
|
286
|
+
pr(f.postRun.shift());
|
|
287
|
+
ne(ae);
|
|
288
|
+
}
|
|
289
|
+
function At(t) {
|
|
290
|
+
var e, r;
|
|
291
|
+
(e = f.onAbort) === null || e === void 0 || e.call(f, t), t = "Aborted(" + t + ")", V(t), ht = !0, t += ". Build with -sASSERTIONS for more info.";
|
|
292
|
+
var n = new WebAssembly.RuntimeError(t);
|
|
293
|
+
throw (r = Jt) === null || r === void 0 || r(n), n;
|
|
294
|
+
}
|
|
295
|
+
var pt;
|
|
296
|
+
function sr() {
|
|
297
|
+
return X("zxing_reader.wasm");
|
|
298
|
+
}
|
|
299
|
+
function ur(t) {
|
|
300
|
+
if (t == pt && Y)
|
|
301
|
+
return new Uint8Array(Y);
|
|
302
|
+
if (q)
|
|
303
|
+
return q(t);
|
|
318
304
|
throw "both async and sync fetching of the wasm failed";
|
|
319
305
|
}
|
|
320
|
-
async function
|
|
321
|
-
if (!
|
|
306
|
+
async function cr(t) {
|
|
307
|
+
if (!Y)
|
|
322
308
|
try {
|
|
323
|
-
var
|
|
324
|
-
return new Uint8Array(
|
|
309
|
+
var e = await tt(t);
|
|
310
|
+
return new Uint8Array(e);
|
|
325
311
|
} catch {
|
|
326
312
|
}
|
|
327
|
-
return
|
|
313
|
+
return ur(t);
|
|
328
314
|
}
|
|
329
|
-
async function
|
|
315
|
+
async function lr(t, e) {
|
|
330
316
|
try {
|
|
331
|
-
var r = await
|
|
317
|
+
var r = await cr(t), n = await WebAssembly.instantiate(r, e);
|
|
332
318
|
return n;
|
|
333
319
|
} catch (a) {
|
|
334
|
-
|
|
320
|
+
V(`failed to asynchronously prepare wasm: ${a}`), At(a);
|
|
335
321
|
}
|
|
336
322
|
}
|
|
337
|
-
async function
|
|
338
|
-
if (!
|
|
323
|
+
async function fr(t, e, r) {
|
|
324
|
+
if (!t && WebAssembly.instantiateStreaming)
|
|
339
325
|
try {
|
|
340
|
-
var n = fetch(
|
|
326
|
+
var n = fetch(e, {
|
|
341
327
|
credentials: "same-origin"
|
|
342
328
|
}), a = await WebAssembly.instantiateStreaming(n, r);
|
|
343
329
|
return a;
|
|
344
330
|
} catch (i) {
|
|
345
|
-
|
|
331
|
+
V(`wasm streaming compile failed: ${i}`), V("falling back to ArrayBuffer instantiation");
|
|
346
332
|
}
|
|
347
|
-
return
|
|
333
|
+
return lr(e, r);
|
|
348
334
|
}
|
|
349
|
-
function
|
|
350
|
-
|
|
351
|
-
a:
|
|
335
|
+
function hr() {
|
|
336
|
+
var t = {
|
|
337
|
+
a: qn
|
|
352
338
|
};
|
|
339
|
+
return t;
|
|
353
340
|
}
|
|
354
|
-
async function
|
|
355
|
-
function
|
|
356
|
-
return
|
|
341
|
+
async function dr() {
|
|
342
|
+
function t(i, s) {
|
|
343
|
+
return lt = i.exports, Xn(lt), re(), lt;
|
|
357
344
|
}
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
return e(i.instance);
|
|
345
|
+
function e(i) {
|
|
346
|
+
return t(i.instance);
|
|
361
347
|
}
|
|
362
|
-
var r =
|
|
348
|
+
var r = hr();
|
|
363
349
|
if (f.instantiateWasm)
|
|
364
|
-
return new Promise((i,
|
|
365
|
-
f.instantiateWasm(r, (
|
|
366
|
-
i(
|
|
350
|
+
return new Promise((i, s) => {
|
|
351
|
+
f.instantiateWasm(r, (u, c) => {
|
|
352
|
+
i(t(u));
|
|
367
353
|
});
|
|
368
354
|
});
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
}
|
|
377
|
-
|
|
378
|
-
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
var t =
|
|
382
|
-
|
|
383
|
-
}, V = 0, dr = () => {
|
|
384
|
-
y(0, 0);
|
|
385
|
-
var e = wt.pop();
|
|
386
|
-
Zn(e.excPtr), V = 0;
|
|
355
|
+
pt != null || (pt = sr());
|
|
356
|
+
var n = await fr(Y, pt, r), a = e(n);
|
|
357
|
+
return a;
|
|
358
|
+
}
|
|
359
|
+
var ne = (t) => {
|
|
360
|
+
for (; t.length > 0; )
|
|
361
|
+
t.shift()(f);
|
|
362
|
+
}, ae = [], pr = (t) => ae.push(t), oe = [], vr = (t) => oe.push(t), g = (t) => _e(t), w = () => xe(), vt = [], yt = 0, yr = (t) => {
|
|
363
|
+
var e = new Ft(t);
|
|
364
|
+
return e.get_caught() || (e.set_caught(!0), yt--), e.set_rethrown(!1), vt.push(e), Ie(t), Pe(t);
|
|
365
|
+
}, H = 0, mr = () => {
|
|
366
|
+
m(0, 0);
|
|
367
|
+
var t = vt.pop();
|
|
368
|
+
Se(t.excPtr), H = 0;
|
|
387
369
|
};
|
|
388
|
-
class
|
|
389
|
-
constructor(
|
|
390
|
-
this.excPtr =
|
|
370
|
+
class Ft {
|
|
371
|
+
constructor(e) {
|
|
372
|
+
this.excPtr = e, this.ptr = e - 24;
|
|
391
373
|
}
|
|
392
|
-
set_type(
|
|
393
|
-
P[this.ptr + 4 >> 2] =
|
|
374
|
+
set_type(e) {
|
|
375
|
+
P[this.ptr + 4 >> 2] = e;
|
|
394
376
|
}
|
|
395
377
|
get_type() {
|
|
396
378
|
return P[this.ptr + 4 >> 2];
|
|
397
379
|
}
|
|
398
|
-
set_destructor(
|
|
399
|
-
P[this.ptr + 8 >> 2] =
|
|
380
|
+
set_destructor(e) {
|
|
381
|
+
P[this.ptr + 8 >> 2] = e;
|
|
400
382
|
}
|
|
401
383
|
get_destructor() {
|
|
402
384
|
return P[this.ptr + 8 >> 2];
|
|
403
385
|
}
|
|
404
|
-
set_caught(
|
|
405
|
-
|
|
386
|
+
set_caught(e) {
|
|
387
|
+
e = e ? 1 : 0, Z[this.ptr + 12] = e;
|
|
406
388
|
}
|
|
407
389
|
get_caught() {
|
|
408
|
-
return
|
|
390
|
+
return Z[this.ptr + 12] != 0;
|
|
409
391
|
}
|
|
410
|
-
set_rethrown(
|
|
411
|
-
|
|
392
|
+
set_rethrown(e) {
|
|
393
|
+
e = e ? 1 : 0, Z[this.ptr + 13] = e;
|
|
412
394
|
}
|
|
413
395
|
get_rethrown() {
|
|
414
|
-
return
|
|
396
|
+
return Z[this.ptr + 13] != 0;
|
|
415
397
|
}
|
|
416
|
-
init(
|
|
417
|
-
this.set_adjusted_ptr(0), this.set_type(
|
|
398
|
+
init(e, r) {
|
|
399
|
+
this.set_adjusted_ptr(0), this.set_type(e), this.set_destructor(r);
|
|
418
400
|
}
|
|
419
|
-
set_adjusted_ptr(
|
|
420
|
-
P[this.ptr + 16 >> 2] =
|
|
401
|
+
set_adjusted_ptr(e) {
|
|
402
|
+
P[this.ptr + 16 >> 2] = e;
|
|
421
403
|
}
|
|
422
404
|
get_adjusted_ptr() {
|
|
423
405
|
return P[this.ptr + 16 >> 2];
|
|
424
406
|
}
|
|
425
407
|
}
|
|
426
|
-
var
|
|
427
|
-
var
|
|
428
|
-
if (!
|
|
429
|
-
return
|
|
430
|
-
var r = new
|
|
431
|
-
r.set_adjusted_ptr(
|
|
408
|
+
var mt = (t) => Oe(t), Rt = (t) => {
|
|
409
|
+
var e = H;
|
|
410
|
+
if (!e)
|
|
411
|
+
return mt(0), 0;
|
|
412
|
+
var r = new Ft(e);
|
|
413
|
+
r.set_adjusted_ptr(e);
|
|
432
414
|
var n = r.get_type();
|
|
433
415
|
if (!n)
|
|
434
|
-
return
|
|
435
|
-
for (var a of
|
|
416
|
+
return mt(0), e;
|
|
417
|
+
for (var a of t) {
|
|
436
418
|
if (a === 0 || a === n)
|
|
437
419
|
break;
|
|
438
420
|
var i = r.ptr + 16;
|
|
439
|
-
if (
|
|
440
|
-
return
|
|
441
|
-
}
|
|
442
|
-
return
|
|
443
|
-
},
|
|
444
|
-
var
|
|
445
|
-
|
|
446
|
-
var
|
|
447
|
-
throw
|
|
448
|
-
},
|
|
449
|
-
var n = new
|
|
450
|
-
throw n.init(
|
|
451
|
-
},
|
|
452
|
-
throw
|
|
453
|
-
},
|
|
454
|
-
for (;
|
|
455
|
-
var
|
|
456
|
-
r(
|
|
421
|
+
if (De(a, n, i))
|
|
422
|
+
return mt(a), e;
|
|
423
|
+
}
|
|
424
|
+
return mt(n), e;
|
|
425
|
+
}, gr = () => Rt([]), wr = (t) => Rt([t]), $r = (t, e) => Rt([t, e]), br = () => {
|
|
426
|
+
var t = vt.pop();
|
|
427
|
+
t || At("no exception to throw");
|
|
428
|
+
var e = t.excPtr;
|
|
429
|
+
throw t.get_rethrown() || (vt.push(t), t.set_rethrown(!0), t.set_caught(!1), yt++), H = e, H;
|
|
430
|
+
}, Cr = (t, e, r) => {
|
|
431
|
+
var n = new Ft(t);
|
|
432
|
+
throw n.init(e, r), H = t, yt++, H;
|
|
433
|
+
}, Tr = () => yt, Er = (t) => {
|
|
434
|
+
throw H || (H = t), H;
|
|
435
|
+
}, Pr = () => At(""), gt = {}, Lt = (t) => {
|
|
436
|
+
for (; t.length; ) {
|
|
437
|
+
var e = t.pop(), r = t.pop();
|
|
438
|
+
r(e);
|
|
457
439
|
}
|
|
458
440
|
};
|
|
459
|
-
function
|
|
460
|
-
return this.fromWireType(P[
|
|
441
|
+
function it(t) {
|
|
442
|
+
return this.fromWireType(P[t >> 2]);
|
|
461
443
|
}
|
|
462
|
-
var
|
|
463
|
-
constructor(
|
|
464
|
-
super(
|
|
465
|
-
}
|
|
466
|
-
},
|
|
467
|
-
throw new
|
|
468
|
-
}, J = (
|
|
469
|
-
|
|
470
|
-
function n(
|
|
471
|
-
var c = r(
|
|
472
|
-
c.length !==
|
|
473
|
-
for (var d = 0; d <
|
|
474
|
-
|
|
475
|
-
}
|
|
476
|
-
var a = new Array(
|
|
477
|
-
|
|
478
|
-
Q.hasOwnProperty(
|
|
479
|
-
a[
|
|
444
|
+
var et = {}, Q = {}, wt = {}, Or = class extends Error {
|
|
445
|
+
constructor(t) {
|
|
446
|
+
super(t), this.name = "InternalError";
|
|
447
|
+
}
|
|
448
|
+
}, $t = (t) => {
|
|
449
|
+
throw new Or(t);
|
|
450
|
+
}, J = (t, e, r) => {
|
|
451
|
+
t.forEach((u) => wt[u] = e);
|
|
452
|
+
function n(u) {
|
|
453
|
+
var c = r(u);
|
|
454
|
+
c.length !== t.length && $t("Mismatched type converter count");
|
|
455
|
+
for (var d = 0; d < t.length; ++d)
|
|
456
|
+
j(t[d], c[d]);
|
|
457
|
+
}
|
|
458
|
+
var a = new Array(e.length), i = [], s = 0;
|
|
459
|
+
for (let [u, c] of e.entries())
|
|
460
|
+
Q.hasOwnProperty(c) ? a[u] = Q[c] : (i.push(c), et.hasOwnProperty(c) || (et[c] = []), et[c].push(() => {
|
|
461
|
+
a[u] = Q[c], ++s, s === i.length && n(a);
|
|
480
462
|
}));
|
|
481
|
-
|
|
482
|
-
},
|
|
483
|
-
var
|
|
484
|
-
delete
|
|
485
|
-
var r =
|
|
486
|
-
J([
|
|
487
|
-
var
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
|
|
491
|
-
read: (
|
|
492
|
-
write: (
|
|
493
|
-
var
|
|
494
|
-
|
|
463
|
+
i.length === 0 && n(a);
|
|
464
|
+
}, _r = (t) => {
|
|
465
|
+
var e = gt[t];
|
|
466
|
+
delete gt[t];
|
|
467
|
+
var r = e.rawConstructor, n = e.rawDestructor, a = e.fields, i = a.map((s) => s.getterReturnType).concat(a.map((s) => s.setterArgumentType));
|
|
468
|
+
J([t], i, (s) => {
|
|
469
|
+
var u = {};
|
|
470
|
+
for (var [c, d] of a.entries()) {
|
|
471
|
+
const p = s[c], v = d.getter, y = d.getterContext, T = s[c + a.length], S = d.setter, x = d.setterContext;
|
|
472
|
+
u[d.fieldName] = {
|
|
473
|
+
read: (E) => p.fromWireType(v(y, E)),
|
|
474
|
+
write: (E, O) => {
|
|
475
|
+
var G = [];
|
|
476
|
+
S(x, E, T.toWireType(G, O)), Lt(G);
|
|
495
477
|
},
|
|
496
|
-
optional:
|
|
478
|
+
optional: p.optional
|
|
497
479
|
};
|
|
498
|
-
}
|
|
499
|
-
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
|
|
480
|
+
}
|
|
481
|
+
return [{
|
|
482
|
+
name: e.name,
|
|
483
|
+
fromWireType: (p) => {
|
|
484
|
+
var v = {};
|
|
485
|
+
for (var y in u)
|
|
486
|
+
v[y] = u[y].read(p);
|
|
487
|
+
return n(p), v;
|
|
505
488
|
},
|
|
506
|
-
toWireType: (
|
|
507
|
-
for (var
|
|
508
|
-
if (!(
|
|
509
|
-
throw new TypeError(`Missing field: "${
|
|
510
|
-
var
|
|
511
|
-
for (
|
|
512
|
-
|
|
513
|
-
return
|
|
489
|
+
toWireType: (p, v) => {
|
|
490
|
+
for (var y in u)
|
|
491
|
+
if (!(y in v) && !u[y].optional)
|
|
492
|
+
throw new TypeError(`Missing field: "${y}"`);
|
|
493
|
+
var T = r();
|
|
494
|
+
for (y in u)
|
|
495
|
+
u[y].write(T, v[y]);
|
|
496
|
+
return p !== null && p.push(n, T), T;
|
|
514
497
|
},
|
|
515
|
-
|
|
516
|
-
readValueFromPointer: lt,
|
|
498
|
+
readValueFromPointer: it,
|
|
517
499
|
destructorFunction: n
|
|
518
500
|
}];
|
|
519
501
|
});
|
|
520
|
-
},
|
|
521
|
-
},
|
|
522
|
-
for (var e =
|
|
523
|
-
|
|
524
|
-
|
|
525
|
-
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
constructor(e) {
|
|
531
|
-
super(e), this.name = "BindingError";
|
|
502
|
+
}, xr = (t, e, r, n, a) => {
|
|
503
|
+
}, F = (t) => {
|
|
504
|
+
for (var e = ""; ; ) {
|
|
505
|
+
var r = W[t++];
|
|
506
|
+
if (!r) return e;
|
|
507
|
+
e += String.fromCharCode(r);
|
|
508
|
+
}
|
|
509
|
+
}, st = class extends Error {
|
|
510
|
+
constructor(t) {
|
|
511
|
+
super(t), this.name = "BindingError";
|
|
532
512
|
}
|
|
533
|
-
},
|
|
534
|
-
throw new
|
|
513
|
+
}, C = (t) => {
|
|
514
|
+
throw new st(t);
|
|
535
515
|
};
|
|
536
|
-
function
|
|
516
|
+
function Sr(t, e) {
|
|
537
517
|
let r = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
|
|
538
|
-
var n =
|
|
539
|
-
if (
|
|
518
|
+
var n = e.name;
|
|
519
|
+
if (t || C(`type "${n}" must have a positive integer typeid pointer`), Q.hasOwnProperty(t)) {
|
|
540
520
|
if (r.ignoreDuplicateRegistrations)
|
|
541
521
|
return;
|
|
542
|
-
|
|
522
|
+
C(`Cannot register type '${n}' twice`);
|
|
543
523
|
}
|
|
544
|
-
if (Q[
|
|
545
|
-
var a =
|
|
546
|
-
delete
|
|
524
|
+
if (Q[t] = e, delete wt[t], et.hasOwnProperty(t)) {
|
|
525
|
+
var a = et[t];
|
|
526
|
+
delete et[t], a.forEach((i) => i());
|
|
547
527
|
}
|
|
548
528
|
}
|
|
549
|
-
function
|
|
529
|
+
function j(t, e) {
|
|
550
530
|
let r = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
|
|
551
|
-
return
|
|
531
|
+
return Sr(t, e, r);
|
|
552
532
|
}
|
|
553
|
-
var
|
|
554
|
-
|
|
555
|
-
name:
|
|
533
|
+
var Ir = (t, e, r, n) => {
|
|
534
|
+
e = F(e), j(t, {
|
|
535
|
+
name: e,
|
|
556
536
|
fromWireType: function(a) {
|
|
557
537
|
return !!a;
|
|
558
538
|
},
|
|
559
539
|
toWireType: function(a, i) {
|
|
560
540
|
return i ? r : n;
|
|
561
541
|
},
|
|
562
|
-
argPackAdvance: k,
|
|
563
542
|
readValueFromPointer: function(a) {
|
|
564
|
-
return this.fromWireType(
|
|
543
|
+
return this.fromWireType(W[a]);
|
|
565
544
|
},
|
|
566
545
|
destructorFunction: null
|
|
567
546
|
});
|
|
568
|
-
},
|
|
569
|
-
count:
|
|
570
|
-
deleteScheduled:
|
|
571
|
-
preservePointerOnDelete:
|
|
572
|
-
ptr:
|
|
573
|
-
ptrType:
|
|
574
|
-
smartPtr:
|
|
575
|
-
smartPtrType:
|
|
576
|
-
}),
|
|
577
|
-
function
|
|
547
|
+
}, Dr = (t) => ({
|
|
548
|
+
count: t.count,
|
|
549
|
+
deleteScheduled: t.deleteScheduled,
|
|
550
|
+
preservePointerOnDelete: t.preservePointerOnDelete,
|
|
551
|
+
ptr: t.ptr,
|
|
552
|
+
ptrType: t.ptrType,
|
|
553
|
+
smartPtr: t.smartPtr,
|
|
554
|
+
smartPtrType: t.smartPtrType
|
|
555
|
+
}), jt = (t) => {
|
|
556
|
+
function e(r) {
|
|
578
557
|
return r.$$.ptrType.registeredClass.name;
|
|
579
558
|
}
|
|
580
|
-
|
|
581
|
-
},
|
|
582
|
-
},
|
|
583
|
-
|
|
584
|
-
},
|
|
585
|
-
|
|
586
|
-
var
|
|
587
|
-
|
|
588
|
-
},
|
|
589
|
-
|
|
590
|
-
}),
|
|
591
|
-
var r =
|
|
559
|
+
C(e(t) + " instance already deleted");
|
|
560
|
+
}, Bt = !1, ie = (t) => {
|
|
561
|
+
}, Mr = (t) => {
|
|
562
|
+
t.smartPtr ? t.smartPtrType.rawDestructor(t.smartPtr) : t.ptrType.registeredClass.rawDestructor(t.ptr);
|
|
563
|
+
}, se = (t) => {
|
|
564
|
+
t.count.value -= 1;
|
|
565
|
+
var e = t.count.value === 0;
|
|
566
|
+
e && Mr(t);
|
|
567
|
+
}, ut = (t) => globalThis.FinalizationRegistry ? (Bt = new FinalizationRegistry((e) => {
|
|
568
|
+
se(e.$$);
|
|
569
|
+
}), ut = (e) => {
|
|
570
|
+
var r = e.$$, n = !!r.smartPtr;
|
|
592
571
|
if (n) {
|
|
593
572
|
var a = {
|
|
594
573
|
$$: r
|
|
595
574
|
};
|
|
596
|
-
|
|
575
|
+
Bt.register(e, a, e);
|
|
597
576
|
}
|
|
598
|
-
return
|
|
599
|
-
},
|
|
600
|
-
let
|
|
601
|
-
Object.assign(
|
|
577
|
+
return e;
|
|
578
|
+
}, ie = (e) => Bt.unregister(e), ut(t)) : (ut = (e) => e, t), Ar = () => {
|
|
579
|
+
let t = bt.prototype;
|
|
580
|
+
Object.assign(t, {
|
|
602
581
|
isAliasOf(r) {
|
|
603
|
-
if (!(this instanceof
|
|
582
|
+
if (!(this instanceof bt) || !(r instanceof bt))
|
|
604
583
|
return !1;
|
|
605
584
|
var n = this.$$.ptrType.registeredClass, a = this.$$.ptr;
|
|
606
585
|
r.$$ = r.$$;
|
|
607
|
-
for (var i = r.$$.ptrType.registeredClass,
|
|
586
|
+
for (var i = r.$$.ptrType.registeredClass, s = r.$$.ptr; n.baseClass; )
|
|
608
587
|
a = n.upcast(a), n = n.baseClass;
|
|
609
588
|
for (; i.baseClass; )
|
|
610
|
-
|
|
611
|
-
return n === i && a ===
|
|
589
|
+
s = i.upcast(s), i = i.baseClass;
|
|
590
|
+
return n === i && a === s;
|
|
612
591
|
},
|
|
613
592
|
clone() {
|
|
614
|
-
if (this.$$.ptr ||
|
|
593
|
+
if (this.$$.ptr || jt(this), this.$$.preservePointerOnDelete)
|
|
615
594
|
return this.$$.count.value += 1, this;
|
|
616
|
-
var r =
|
|
595
|
+
var r = ut(Object.create(Object.getPrototypeOf(this), {
|
|
617
596
|
$$: {
|
|
618
|
-
value:
|
|
597
|
+
value: Dr(this.$$)
|
|
619
598
|
}
|
|
620
599
|
}));
|
|
621
600
|
return r.$$.count.value += 1, r.$$.deleteScheduled = !1, r;
|
|
622
601
|
},
|
|
623
602
|
delete() {
|
|
624
|
-
this.$$.ptr ||
|
|
603
|
+
this.$$.ptr || jt(this), this.$$.deleteScheduled && !this.$$.preservePointerOnDelete && C("Object already scheduled for deletion"), ie(this), se(this.$$), this.$$.preservePointerOnDelete || (this.$$.smartPtr = void 0, this.$$.ptr = void 0);
|
|
625
604
|
},
|
|
626
605
|
isDeleted() {
|
|
627
606
|
return !this.$$.ptr;
|
|
628
607
|
},
|
|
629
608
|
deleteLater() {
|
|
630
|
-
return this.$$.ptr ||
|
|
609
|
+
return this.$$.ptr || jt(this), this.$$.deleteScheduled && !this.$$.preservePointerOnDelete && C("Object already scheduled for deletion"), this.$$.deleteScheduled = !0, this;
|
|
631
610
|
}
|
|
632
611
|
});
|
|
633
|
-
const
|
|
634
|
-
|
|
612
|
+
const e = Symbol.dispose;
|
|
613
|
+
e && (t[e] = t.delete);
|
|
635
614
|
};
|
|
636
|
-
function
|
|
637
|
-
}
|
|
638
|
-
var
|
|
639
|
-
value:
|
|
640
|
-
}),
|
|
641
|
-
if (e
|
|
642
|
-
var n = e
|
|
643
|
-
e
|
|
644
|
-
for (var a = arguments.length, i = new Array(a),
|
|
645
|
-
i[
|
|
646
|
-
return e
|
|
647
|
-
}, e
|
|
648
|
-
}
|
|
649
|
-
},
|
|
650
|
-
f.hasOwnProperty(
|
|
651
|
-
},
|
|
652
|
-
|
|
653
|
-
var
|
|
654
|
-
return
|
|
615
|
+
function bt() {
|
|
616
|
+
}
|
|
617
|
+
var Ut = (t, e) => Object.defineProperty(e, "name", {
|
|
618
|
+
value: t
|
|
619
|
+
}), ue = {}, ce = (t, e, r) => {
|
|
620
|
+
if (t[e].overloadTable === void 0) {
|
|
621
|
+
var n = t[e];
|
|
622
|
+
t[e] = function() {
|
|
623
|
+
for (var a = arguments.length, i = new Array(a), s = 0; s < a; s++)
|
|
624
|
+
i[s] = arguments[s];
|
|
625
|
+
return t[e].overloadTable.hasOwnProperty(i.length) || C(`Function '${r}' called with an invalid number of arguments (${i.length}) - expects one of (${t[e].overloadTable})!`), t[e].overloadTable[i.length].apply(this, i);
|
|
626
|
+
}, t[e].overloadTable = [], t[e].overloadTable[n.argCount] = n;
|
|
627
|
+
}
|
|
628
|
+
}, le = (t, e, r) => {
|
|
629
|
+
f.hasOwnProperty(t) ? ((r === void 0 || f[t].overloadTable !== void 0 && f[t].overloadTable[r] !== void 0) && C(`Cannot register public name '${t}' twice`), ce(f, t, t), f[t].overloadTable.hasOwnProperty(r) && C(`Cannot register multiple overloads of a function with the same number of arguments (${r})!`), f[t].overloadTable[r] = e) : (f[t] = e, f[t].argCount = r);
|
|
630
|
+
}, Fr = 48, Rr = 57, Lr = (t) => {
|
|
631
|
+
t = t.replace(/[^a-zA-Z0-9_]/g, "$");
|
|
632
|
+
var e = t.charCodeAt(0);
|
|
633
|
+
return e >= Fr && e <= Rr ? `_${t}` : t;
|
|
655
634
|
};
|
|
656
|
-
function
|
|
657
|
-
this.name =
|
|
635
|
+
function jr(t, e, r, n, a, i, s, u) {
|
|
636
|
+
this.name = t, this.constructor = e, this.instancePrototype = r, this.rawDestructor = n, this.baseClass = a, this.getActualType = i, this.upcast = s, this.downcast = u, this.pureVirtualFunctions = [];
|
|
658
637
|
}
|
|
659
|
-
var
|
|
660
|
-
for (;
|
|
661
|
-
|
|
662
|
-
return
|
|
663
|
-
},
|
|
664
|
-
if (
|
|
638
|
+
var Vt = (t, e, r) => {
|
|
639
|
+
for (; e !== r; )
|
|
640
|
+
e.upcast || C(`Expected null or instance of ${r.name}, got an instance of ${e.name}`), t = e.upcast(t), e = e.baseClass;
|
|
641
|
+
return t;
|
|
642
|
+
}, Wt = (t) => {
|
|
643
|
+
if (t === null)
|
|
665
644
|
return "null";
|
|
666
|
-
var
|
|
667
|
-
return
|
|
645
|
+
var e = typeof t;
|
|
646
|
+
return e === "object" || e === "array" || e === "function" ? t.toString() : "" + t;
|
|
668
647
|
};
|
|
669
|
-
function
|
|
670
|
-
if (
|
|
671
|
-
return this.isReference &&
|
|
672
|
-
|
|
673
|
-
var r =
|
|
648
|
+
function Br(t, e) {
|
|
649
|
+
if (e === null)
|
|
650
|
+
return this.isReference && C(`null is not a valid ${this.name}`), 0;
|
|
651
|
+
e.$$ || C(`Cannot pass "${Wt(e)}" as a ${this.name}`), e.$$.ptr || C(`Cannot pass deleted object as a pointer of type ${this.name}`);
|
|
652
|
+
var r = e.$$.ptrType.registeredClass, n = Vt(e.$$.ptr, r, this.registeredClass);
|
|
674
653
|
return n;
|
|
675
654
|
}
|
|
676
|
-
function
|
|
655
|
+
function Ur(t, e) {
|
|
677
656
|
var r;
|
|
678
|
-
if (
|
|
679
|
-
return this.isReference &&
|
|
680
|
-
(!
|
|
681
|
-
var n =
|
|
682
|
-
if (r =
|
|
683
|
-
switch (
|
|
657
|
+
if (e === null)
|
|
658
|
+
return this.isReference && C(`null is not a valid ${this.name}`), this.isSmartPointer ? (r = this.rawConstructor(), t !== null && t.push(this.rawDestructor, r), r) : 0;
|
|
659
|
+
(!e || !e.$$) && C(`Cannot pass "${Wt(e)}" as a ${this.name}`), e.$$.ptr || C(`Cannot pass deleted object as a pointer of type ${this.name}`), !this.isConst && e.$$.ptrType.isConst && C(`Cannot convert argument of type ${e.$$.smartPtrType ? e.$$.smartPtrType.name : e.$$.ptrType.name} to parameter type ${this.name}`);
|
|
660
|
+
var n = e.$$.ptrType.registeredClass;
|
|
661
|
+
if (r = Vt(e.$$.ptr, n, this.registeredClass), this.isSmartPointer)
|
|
662
|
+
switch (e.$$.smartPtr === void 0 && C("Passing raw pointer to smart pointer is illegal"), this.sharingPolicy) {
|
|
684
663
|
case 0:
|
|
685
|
-
|
|
664
|
+
e.$$.smartPtrType === this ? r = e.$$.smartPtr : C(`Cannot convert argument of type ${e.$$.smartPtrType ? e.$$.smartPtrType.name : e.$$.ptrType.name} to parameter type ${this.name}`);
|
|
686
665
|
break;
|
|
687
666
|
case 1:
|
|
688
|
-
r =
|
|
667
|
+
r = e.$$.smartPtr;
|
|
689
668
|
break;
|
|
690
669
|
case 2:
|
|
691
|
-
if (
|
|
692
|
-
r =
|
|
670
|
+
if (e.$$.smartPtrType === this)
|
|
671
|
+
r = e.$$.smartPtr;
|
|
693
672
|
else {
|
|
694
|
-
var a =
|
|
695
|
-
r = this.rawShare(r,
|
|
673
|
+
var a = e.clone();
|
|
674
|
+
r = this.rawShare(r, B.toHandle(() => a.delete())), t !== null && t.push(this.rawDestructor, r);
|
|
696
675
|
}
|
|
697
676
|
break;
|
|
698
677
|
default:
|
|
699
|
-
|
|
678
|
+
C("Unsupporting sharing policy");
|
|
700
679
|
}
|
|
701
680
|
return r;
|
|
702
681
|
}
|
|
703
|
-
function
|
|
704
|
-
if (
|
|
705
|
-
return this.isReference &&
|
|
706
|
-
|
|
707
|
-
var r =
|
|
682
|
+
function Vr(t, e) {
|
|
683
|
+
if (e === null)
|
|
684
|
+
return this.isReference && C(`null is not a valid ${this.name}`), 0;
|
|
685
|
+
e.$$ || C(`Cannot pass "${Wt(e)}" as a ${this.name}`), e.$$.ptr || C(`Cannot pass deleted object as a pointer of type ${this.name}`), e.$$.ptrType.isConst && C(`Cannot convert argument of type ${e.$$.ptrType.name} to parameter type ${this.name}`);
|
|
686
|
+
var r = e.$$.ptrType.registeredClass, n = Vt(e.$$.ptr, r, this.registeredClass);
|
|
708
687
|
return n;
|
|
709
688
|
}
|
|
710
|
-
var
|
|
711
|
-
if (
|
|
712
|
-
return
|
|
689
|
+
var fe = (t, e, r) => {
|
|
690
|
+
if (e === r)
|
|
691
|
+
return t;
|
|
713
692
|
if (r.baseClass === void 0)
|
|
714
693
|
return null;
|
|
715
|
-
var n =
|
|
694
|
+
var n = fe(t, e, r.baseClass);
|
|
716
695
|
return n === null ? null : r.downcast(n);
|
|
717
|
-
},
|
|
718
|
-
for (
|
|
719
|
-
|
|
720
|
-
return
|
|
721
|
-
},
|
|
722
|
-
(!
|
|
723
|
-
var r = !!
|
|
724
|
-
return r !== n &&
|
|
696
|
+
}, Wr = {}, Hr = (t, e) => {
|
|
697
|
+
for (e === void 0 && C("ptr should not be undefined"); t.baseClass; )
|
|
698
|
+
e = t.upcast(e), t = t.baseClass;
|
|
699
|
+
return e;
|
|
700
|
+
}, kr = (t, e) => (e = Hr(t, e), Wr[e]), Ct = (t, e) => {
|
|
701
|
+
(!e.ptrType || !e.ptr) && $t("makeClassHandle requires ptr and ptrType");
|
|
702
|
+
var r = !!e.smartPtrType, n = !!e.smartPtr;
|
|
703
|
+
return r !== n && $t("Both smartPtrType and smartPtr must be specified"), e.count = {
|
|
725
704
|
value: 1
|
|
726
|
-
},
|
|
705
|
+
}, ut(Object.create(t, {
|
|
727
706
|
$$: {
|
|
728
|
-
value:
|
|
707
|
+
value: e,
|
|
729
708
|
writable: !0
|
|
730
709
|
}
|
|
731
710
|
}));
|
|
732
711
|
};
|
|
733
|
-
function
|
|
734
|
-
var
|
|
735
|
-
if (!
|
|
736
|
-
return this.destructor(
|
|
737
|
-
var r =
|
|
712
|
+
function Nr(t) {
|
|
713
|
+
var e = this.getPointee(t);
|
|
714
|
+
if (!e)
|
|
715
|
+
return this.destructor(t), null;
|
|
716
|
+
var r = kr(this.registeredClass, e);
|
|
738
717
|
if (r !== void 0) {
|
|
739
718
|
if (r.$$.count.value === 0)
|
|
740
|
-
return r.$$.ptr =
|
|
719
|
+
return r.$$.ptr = e, r.$$.smartPtr = t, r.clone();
|
|
741
720
|
var n = r.clone();
|
|
742
|
-
return this.destructor(
|
|
721
|
+
return this.destructor(t), n;
|
|
743
722
|
}
|
|
744
723
|
function a() {
|
|
745
|
-
return this.isSmartPointer ?
|
|
724
|
+
return this.isSmartPointer ? Ct(this.registeredClass.instancePrototype, {
|
|
746
725
|
ptrType: this.pointeeType,
|
|
747
|
-
ptr:
|
|
726
|
+
ptr: e,
|
|
748
727
|
smartPtrType: this,
|
|
749
|
-
smartPtr:
|
|
750
|
-
}) :
|
|
728
|
+
smartPtr: t
|
|
729
|
+
}) : Ct(this.registeredClass.instancePrototype, {
|
|
751
730
|
ptrType: this,
|
|
752
|
-
ptr:
|
|
731
|
+
ptr: t
|
|
753
732
|
});
|
|
754
733
|
}
|
|
755
|
-
var i = this.registeredClass.getActualType(
|
|
756
|
-
if (!
|
|
734
|
+
var i = this.registeredClass.getActualType(e), s = ue[i];
|
|
735
|
+
if (!s)
|
|
757
736
|
return a.call(this);
|
|
758
|
-
var
|
|
759
|
-
this.isConst ?
|
|
760
|
-
var c =
|
|
761
|
-
return c === null ? a.call(this) : this.isSmartPointer ?
|
|
762
|
-
ptrType:
|
|
737
|
+
var u;
|
|
738
|
+
this.isConst ? u = s.constPointerType : u = s.pointerType;
|
|
739
|
+
var c = fe(e, this.registeredClass, u.registeredClass);
|
|
740
|
+
return c === null ? a.call(this) : this.isSmartPointer ? Ct(u.registeredClass.instancePrototype, {
|
|
741
|
+
ptrType: u,
|
|
763
742
|
ptr: c,
|
|
764
743
|
smartPtrType: this,
|
|
765
|
-
smartPtr:
|
|
766
|
-
}) :
|
|
767
|
-
ptrType:
|
|
744
|
+
smartPtr: t
|
|
745
|
+
}) : Ct(u.registeredClass.instancePrototype, {
|
|
746
|
+
ptrType: u,
|
|
768
747
|
ptr: c
|
|
769
748
|
});
|
|
770
749
|
}
|
|
771
|
-
var
|
|
772
|
-
Object.assign(
|
|
773
|
-
getPointee(
|
|
774
|
-
return this.rawGetPointee && (
|
|
750
|
+
var zr = () => {
|
|
751
|
+
Object.assign(Tt.prototype, {
|
|
752
|
+
getPointee(t) {
|
|
753
|
+
return this.rawGetPointee && (t = this.rawGetPointee(t)), t;
|
|
775
754
|
},
|
|
776
|
-
destructor(
|
|
777
|
-
var
|
|
778
|
-
(
|
|
755
|
+
destructor(t) {
|
|
756
|
+
var e;
|
|
757
|
+
(e = this.rawDestructor) === null || e === void 0 || e.call(this, t);
|
|
779
758
|
},
|
|
780
|
-
|
|
781
|
-
|
|
782
|
-
fromWireType: Ur
|
|
759
|
+
readValueFromPointer: it,
|
|
760
|
+
fromWireType: Nr
|
|
783
761
|
});
|
|
784
762
|
};
|
|
785
|
-
function
|
|
786
|
-
this.name =
|
|
787
|
-
}
|
|
788
|
-
var
|
|
789
|
-
f.hasOwnProperty(
|
|
790
|
-
},
|
|
791
|
-
|
|
792
|
-
|
|
793
|
-
|
|
763
|
+
function Tt(t, e, r, n, a, i, s, u, c, d, p) {
|
|
764
|
+
this.name = t, this.registeredClass = e, this.isReference = r, this.isConst = n, this.isSmartPointer = a, this.pointeeType = i, this.sharingPolicy = s, this.rawGetPointee = u, this.rawConstructor = c, this.rawShare = d, this.rawDestructor = p, !a && e.baseClass === void 0 ? n ? (this.toWireType = Br, this.destructorFunction = null) : (this.toWireType = Vr, this.destructorFunction = null) : this.toWireType = Ur;
|
|
765
|
+
}
|
|
766
|
+
var he = (t, e, r) => {
|
|
767
|
+
f.hasOwnProperty(t) || $t("Replacing nonexistent public symbol"), f[t].overloadTable !== void 0 && r !== void 0 ? f[t].overloadTable[r] = e : (f[t] = e, f[t].argCount = r);
|
|
768
|
+
}, N = {}, Gr = (t, e, r) => {
|
|
769
|
+
t = t.replace(/p/g, "i");
|
|
770
|
+
var n = N[t];
|
|
771
|
+
return n(e, ...r);
|
|
772
|
+
}, de = [], $ = (t) => {
|
|
773
|
+
var e = de[t];
|
|
774
|
+
return e || (de[t] = e = Fe.get(t)), e;
|
|
775
|
+
}, Xr = function(t, e) {
|
|
794
776
|
let r = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
|
|
795
|
-
if (
|
|
796
|
-
return
|
|
797
|
-
var n =
|
|
777
|
+
if (t.includes("j"))
|
|
778
|
+
return Gr(t, e, r);
|
|
779
|
+
var n = $(e), a = n(...r);
|
|
798
780
|
return a;
|
|
799
|
-
},
|
|
781
|
+
}, qr = function(t, e) {
|
|
800
782
|
let r = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : !1;
|
|
801
783
|
return function() {
|
|
802
784
|
for (var n = arguments.length, a = new Array(n), i = 0; i < n; i++)
|
|
803
785
|
a[i] = arguments[i];
|
|
804
|
-
return
|
|
786
|
+
return Xr(t, e, a, r);
|
|
805
787
|
};
|
|
806
|
-
},
|
|
807
|
-
|
|
788
|
+
}, L = function(t, e) {
|
|
789
|
+
t = F(t);
|
|
808
790
|
function r() {
|
|
809
|
-
if (
|
|
810
|
-
return
|
|
811
|
-
var a =
|
|
791
|
+
if (t.includes("j"))
|
|
792
|
+
return qr(t, e);
|
|
793
|
+
var a = $(e);
|
|
812
794
|
return a;
|
|
813
795
|
}
|
|
814
796
|
var n = r();
|
|
815
|
-
return typeof n != "function" &&
|
|
797
|
+
return typeof n != "function" && C(`unknown function pointer with signature ${t}: ${e}`), n;
|
|
816
798
|
};
|
|
817
|
-
class
|
|
799
|
+
class Yr extends Error {
|
|
818
800
|
}
|
|
819
|
-
var
|
|
820
|
-
var
|
|
821
|
-
return
|
|
822
|
-
},
|
|
801
|
+
var pe = (t) => {
|
|
802
|
+
var e = Ee(t), r = F(e);
|
|
803
|
+
return z(e), r;
|
|
804
|
+
}, Et = (t, e) => {
|
|
823
805
|
var r = [], n = {};
|
|
824
806
|
function a(i) {
|
|
825
807
|
if (!n[i] && !Q[i]) {
|
|
826
|
-
if (
|
|
827
|
-
|
|
808
|
+
if (wt[i]) {
|
|
809
|
+
wt[i].forEach(a);
|
|
828
810
|
return;
|
|
829
811
|
}
|
|
830
812
|
r.push(i), n[i] = !0;
|
|
831
813
|
}
|
|
832
814
|
}
|
|
833
|
-
throw
|
|
834
|
-
},
|
|
835
|
-
p = F(p), i =
|
|
836
|
-
var
|
|
837
|
-
|
|
838
|
-
|
|
839
|
-
}), J([
|
|
840
|
-
|
|
841
|
-
var
|
|
842
|
-
n ? (
|
|
843
|
-
var
|
|
844
|
-
if (Object.getPrototypeOf(this) !==
|
|
845
|
-
throw new
|
|
815
|
+
throw e.forEach(a), new Yr(`${t}: ` + r.map(pe).join([", "]));
|
|
816
|
+
}, Zr = (t, e, r, n, a, i, s, u, c, d, p, v, y) => {
|
|
817
|
+
p = F(p), i = L(a, i), u && (u = L(s, u)), d && (d = L(c, d)), y = L(v, y);
|
|
818
|
+
var T = Lr(p);
|
|
819
|
+
le(T, function() {
|
|
820
|
+
Et(`Cannot construct ${p} due to unbound types`, [n]);
|
|
821
|
+
}), J([t, e, r], n ? [n] : [], (S) => {
|
|
822
|
+
S = S[0];
|
|
823
|
+
var x, E;
|
|
824
|
+
n ? (x = S.registeredClass, E = x.instancePrototype) : E = bt.prototype;
|
|
825
|
+
var O = Ut(p, function() {
|
|
826
|
+
if (Object.getPrototypeOf(this) !== G)
|
|
827
|
+
throw new st(`Use 'new' to construct ${p}`);
|
|
846
828
|
if (R.constructor_body === void 0)
|
|
847
|
-
throw new
|
|
848
|
-
for (var
|
|
849
|
-
|
|
850
|
-
var
|
|
851
|
-
if (
|
|
852
|
-
throw new
|
|
853
|
-
return
|
|
854
|
-
}),
|
|
829
|
+
throw new st(`${p} has no accessible constructor`);
|
|
830
|
+
for (var je = arguments.length, _t = new Array(je), xt = 0; xt < je; xt++)
|
|
831
|
+
_t[xt] = arguments[xt];
|
|
832
|
+
var Be = R.constructor_body[_t.length];
|
|
833
|
+
if (Be === void 0)
|
|
834
|
+
throw new st(`Tried to invoke ctor of ${p} with invalid number of parameters (${_t.length}) - expected (${Object.keys(R.constructor_body).toString()}) parameters instead!`);
|
|
835
|
+
return Be.apply(this, _t);
|
|
836
|
+
}), G = Object.create(E, {
|
|
855
837
|
constructor: {
|
|
856
|
-
value:
|
|
838
|
+
value: O
|
|
857
839
|
}
|
|
858
840
|
});
|
|
859
|
-
|
|
860
|
-
var R = new
|
|
841
|
+
O.prototype = G;
|
|
842
|
+
var R = new jr(p, O, G, y, x, i, u, d);
|
|
861
843
|
if (R.baseClass) {
|
|
862
|
-
var
|
|
863
|
-
(
|
|
844
|
+
var k, Ot;
|
|
845
|
+
(Ot = (k = R.baseClass).__derivedClasses) !== null && Ot !== void 0 || (k.__derivedClasses = []), R.baseClass.__derivedClasses.push(R);
|
|
864
846
|
}
|
|
865
|
-
var
|
|
866
|
-
return
|
|
867
|
-
pointerType:
|
|
868
|
-
constPointerType:
|
|
869
|
-
},
|
|
847
|
+
var Da = new Tt(p, R, !0, !1, !1), Re = new Tt(p + "*", R, !1, !1, !1), Le = new Tt(p + " const*", R, !1, !0, !1);
|
|
848
|
+
return ue[t] = {
|
|
849
|
+
pointerType: Re,
|
|
850
|
+
constPointerType: Le
|
|
851
|
+
}, he(T, O), [Da, Re, Le];
|
|
870
852
|
});
|
|
871
|
-
},
|
|
872
|
-
for (var r = [], n = 0; n <
|
|
873
|
-
r.push(P[
|
|
853
|
+
}, Ht = (t, e) => {
|
|
854
|
+
for (var r = [], n = 0; n < t; n++)
|
|
855
|
+
r.push(P[e + n * 4 >> 2]);
|
|
874
856
|
return r;
|
|
875
857
|
};
|
|
876
|
-
function
|
|
877
|
-
for (var
|
|
878
|
-
if (e
|
|
858
|
+
function Qr(t) {
|
|
859
|
+
for (var e = 1; e < t.length; ++e)
|
|
860
|
+
if (t[e] !== null && t[e].destructorFunction === void 0)
|
|
879
861
|
return !0;
|
|
880
862
|
return !1;
|
|
881
863
|
}
|
|
882
|
-
function
|
|
883
|
-
var
|
|
884
|
-
|
|
885
|
-
var
|
|
886
|
-
|
|
887
|
-
var
|
|
888
|
-
|
|
889
|
-
for (var
|
|
890
|
-
v[
|
|
891
|
-
var
|
|
892
|
-
function
|
|
864
|
+
function kt(t, e, r, n, a, i) {
|
|
865
|
+
var s = e.length;
|
|
866
|
+
s < 2 && C("argTypes array size mismatch! Must at least get return value and 'this' types!");
|
|
867
|
+
var u = e[1] !== null && r !== null, c = Qr(e), d = !e[0].isVoid, p = s - 2, v = new Array(p), y = [], T = [], S = function() {
|
|
868
|
+
T.length = 0;
|
|
869
|
+
var x;
|
|
870
|
+
y.length = u ? 2 : 1, y[0] = a, u && (x = e[1].toWireType(T, this), y[1] = x);
|
|
871
|
+
for (var E = 0; E < p; ++E)
|
|
872
|
+
v[E] = e[E + 2].toWireType(T, E < 0 || arguments.length <= E ? void 0 : arguments[E]), y.push(v[E]);
|
|
873
|
+
var O = n(...y);
|
|
874
|
+
function G(R) {
|
|
893
875
|
if (c)
|
|
894
|
-
|
|
876
|
+
Lt(T);
|
|
895
877
|
else
|
|
896
|
-
for (var
|
|
897
|
-
var
|
|
898
|
-
|
|
878
|
+
for (var k = u ? 1 : 2; k < e.length; k++) {
|
|
879
|
+
var Ot = k === 1 ? x : v[k - 2];
|
|
880
|
+
e[k].destructorFunction !== null && e[k].destructorFunction(Ot);
|
|
899
881
|
}
|
|
900
882
|
if (d)
|
|
901
|
-
return
|
|
883
|
+
return e[0].fromWireType(R);
|
|
902
884
|
}
|
|
903
|
-
return
|
|
885
|
+
return G(O);
|
|
904
886
|
};
|
|
905
|
-
return
|
|
906
|
-
}
|
|
907
|
-
var
|
|
908
|
-
var
|
|
909
|
-
a =
|
|
910
|
-
|
|
911
|
-
var c = `constructor ${
|
|
912
|
-
if (
|
|
913
|
-
throw new
|
|
914
|
-
return
|
|
915
|
-
|
|
916
|
-
}, J([],
|
|
887
|
+
return Ut(t, S);
|
|
888
|
+
}
|
|
889
|
+
var Jr = (t, e, r, n, a, i) => {
|
|
890
|
+
var s = Ht(e, r);
|
|
891
|
+
a = L(n, a), J([], [t], (u) => {
|
|
892
|
+
u = u[0];
|
|
893
|
+
var c = `constructor ${u.name}`;
|
|
894
|
+
if (u.registeredClass.constructor_body === void 0 && (u.registeredClass.constructor_body = []), u.registeredClass.constructor_body[e - 1] !== void 0)
|
|
895
|
+
throw new st(`Cannot register multiple constructors with identical number of parameters (${e - 1}) for class '${u.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`);
|
|
896
|
+
return u.registeredClass.constructor_body[e - 1] = () => {
|
|
897
|
+
Et(`Cannot construct ${u.name} due to unbound types`, s);
|
|
898
|
+
}, J([], s, (d) => (d.splice(1, 0, null), u.registeredClass.constructor_body[e - 1] = kt(c, d, null, a, i), [])), [];
|
|
917
899
|
});
|
|
918
|
-
},
|
|
919
|
-
|
|
920
|
-
const
|
|
921
|
-
return
|
|
922
|
-
},
|
|
923
|
-
var p =
|
|
924
|
-
|
|
900
|
+
}, ve = (t) => {
|
|
901
|
+
t = t.trim();
|
|
902
|
+
const e = t.indexOf("(");
|
|
903
|
+
return e === -1 ? t : t.slice(0, e);
|
|
904
|
+
}, Kr = (t, e, r, n, a, i, s, u, c, d) => {
|
|
905
|
+
var p = Ht(r, n);
|
|
906
|
+
e = F(e), e = ve(e), i = L(a, i), J([], [t], (v) => {
|
|
925
907
|
v = v[0];
|
|
926
|
-
var
|
|
927
|
-
|
|
928
|
-
function
|
|
929
|
-
|
|
908
|
+
var y = `${v.name}.${e}`;
|
|
909
|
+
e.startsWith("@@") && (e = Symbol[e.substring(2)]), u && v.registeredClass.pureVirtualFunctions.push(e);
|
|
910
|
+
function T() {
|
|
911
|
+
Et(`Cannot call ${y} due to unbound types`, p);
|
|
930
912
|
}
|
|
931
|
-
var
|
|
932
|
-
return
|
|
933
|
-
var
|
|
934
|
-
return
|
|
913
|
+
var S = v.registeredClass.instancePrototype, x = S[e];
|
|
914
|
+
return x === void 0 || x.overloadTable === void 0 && x.className !== v.name && x.argCount === r - 2 ? (T.argCount = r - 2, T.className = v.name, S[e] = T) : (ce(S, e, y), S[e].overloadTable[r - 2] = T), J([], p, (E) => {
|
|
915
|
+
var O = kt(y, E, v, i, s);
|
|
916
|
+
return S[e].overloadTable === void 0 ? (O.argCount = r - 2, S[e] = O) : S[e].overloadTable[r - 2] = O, [];
|
|
935
917
|
}), [];
|
|
936
918
|
});
|
|
937
|
-
},
|
|
938
|
-
|
|
939
|
-
},
|
|
940
|
-
toValue: (
|
|
941
|
-
toHandle: (
|
|
942
|
-
switch (
|
|
919
|
+
}, ye = [], K = [0, 1, , 1, null, 1, !0, 1, !1, 1], Nt = (t) => {
|
|
920
|
+
t > 9 && --K[t + 1] === 0 && (K[t] = void 0, ye.push(t));
|
|
921
|
+
}, B = {
|
|
922
|
+
toValue: (t) => (t || C(`Cannot use deleted val. handle = ${t}`), K[t]),
|
|
923
|
+
toHandle: (t) => {
|
|
924
|
+
switch (t) {
|
|
943
925
|
case void 0:
|
|
944
926
|
return 2;
|
|
945
927
|
case null:
|
|
@@ -949,841 +931,802 @@ var Kt = async function(o = {}) {
|
|
|
949
931
|
case !1:
|
|
950
932
|
return 8;
|
|
951
933
|
default: {
|
|
952
|
-
const
|
|
953
|
-
return K[
|
|
934
|
+
const e = ye.pop() || K.length;
|
|
935
|
+
return K[e] = t, K[e + 1] = 1, e;
|
|
954
936
|
}
|
|
955
937
|
}
|
|
956
938
|
}
|
|
957
|
-
},
|
|
939
|
+
}, me = {
|
|
958
940
|
name: "emscripten::val",
|
|
959
|
-
fromWireType: (
|
|
960
|
-
var
|
|
961
|
-
return
|
|
941
|
+
fromWireType: (t) => {
|
|
942
|
+
var e = B.toValue(t);
|
|
943
|
+
return Nt(t), e;
|
|
962
944
|
},
|
|
963
|
-
toWireType: (
|
|
964
|
-
|
|
965
|
-
readValueFromPointer: lt,
|
|
945
|
+
toWireType: (t, e) => B.toHandle(e),
|
|
946
|
+
readValueFromPointer: it,
|
|
966
947
|
destructorFunction: null
|
|
967
|
-
},
|
|
968
|
-
switch (
|
|
948
|
+
}, tn = (t) => j(t, me), en = (t, e) => {
|
|
949
|
+
switch (e) {
|
|
969
950
|
case 4:
|
|
970
951
|
return function(r) {
|
|
971
|
-
return this.fromWireType(
|
|
952
|
+
return this.fromWireType(Kt[r >> 2]);
|
|
972
953
|
};
|
|
973
954
|
case 8:
|
|
974
955
|
return function(r) {
|
|
975
|
-
return this.fromWireType(
|
|
956
|
+
return this.fromWireType(te[r >> 3]);
|
|
976
957
|
};
|
|
977
958
|
default:
|
|
978
|
-
throw new TypeError(`invalid float width (${
|
|
959
|
+
throw new TypeError(`invalid float width (${e}): ${t}`);
|
|
979
960
|
}
|
|
980
|
-
},
|
|
981
|
-
|
|
982
|
-
name:
|
|
961
|
+
}, rn = (t, e, r) => {
|
|
962
|
+
e = F(e), j(t, {
|
|
963
|
+
name: e,
|
|
983
964
|
fromWireType: (n) => n,
|
|
984
965
|
toWireType: (n, a) => a,
|
|
985
|
-
|
|
986
|
-
readValueFromPointer: Zr(t, r),
|
|
966
|
+
readValueFromPointer: en(e, r),
|
|
987
967
|
destructorFunction: null
|
|
988
968
|
});
|
|
989
|
-
},
|
|
990
|
-
var c =
|
|
991
|
-
|
|
992
|
-
|
|
993
|
-
},
|
|
969
|
+
}, nn = (t, e, r, n, a, i, s, u) => {
|
|
970
|
+
var c = Ht(e, r);
|
|
971
|
+
t = F(t), t = ve(t), a = L(n, a), le(t, function() {
|
|
972
|
+
Et(`Cannot call ${t} due to unbound types`, c);
|
|
973
|
+
}, e - 1), J([], c, (d) => {
|
|
994
974
|
var p = [d[0], null].concat(d.slice(1));
|
|
995
|
-
return
|
|
975
|
+
return he(t, kt(t, p, null, a, i), e - 1), [];
|
|
996
976
|
});
|
|
997
|
-
},
|
|
998
|
-
switch (
|
|
977
|
+
}, an = (t, e, r) => {
|
|
978
|
+
switch (e) {
|
|
999
979
|
case 1:
|
|
1000
|
-
return r ? (n) =>
|
|
980
|
+
return r ? (n) => Z[n] : (n) => W[n];
|
|
1001
981
|
case 2:
|
|
1002
|
-
return r ? (n) =>
|
|
982
|
+
return r ? (n) => dt[n >> 1] : (n) => at[n >> 1];
|
|
1003
983
|
case 4:
|
|
1004
|
-
return r ? (n) =>
|
|
984
|
+
return r ? (n) => ot[n >> 2] : (n) => P[n >> 2];
|
|
1005
985
|
default:
|
|
1006
|
-
throw new TypeError(`invalid integer width (${
|
|
986
|
+
throw new TypeError(`invalid integer width (${e}): ${t}`);
|
|
1007
987
|
}
|
|
1008
|
-
},
|
|
1009
|
-
|
|
988
|
+
}, on = (t, e, r, n, a) => {
|
|
989
|
+
e = F(e);
|
|
1010
990
|
const i = n === 0;
|
|
1011
|
-
let
|
|
991
|
+
let s = (c) => c;
|
|
1012
992
|
if (i) {
|
|
1013
|
-
var
|
|
1014
|
-
|
|
993
|
+
var u = 32 - 8 * r;
|
|
994
|
+
s = (c) => c << u >>> u, a = s(a);
|
|
1015
995
|
}
|
|
1016
|
-
|
|
1017
|
-
name:
|
|
1018
|
-
fromWireType:
|
|
996
|
+
j(t, {
|
|
997
|
+
name: e,
|
|
998
|
+
fromWireType: s,
|
|
1019
999
|
toWireType: (c, d) => d,
|
|
1020
|
-
|
|
1021
|
-
readValueFromPointer: Kr(t, r, n !== 0),
|
|
1000
|
+
readValueFromPointer: an(e, r, n !== 0),
|
|
1022
1001
|
destructorFunction: null
|
|
1023
1002
|
});
|
|
1024
|
-
},
|
|
1025
|
-
var n = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array], a = n[
|
|
1026
|
-
function i(
|
|
1027
|
-
var
|
|
1028
|
-
return new a(
|
|
1003
|
+
}, sn = (t, e, r) => {
|
|
1004
|
+
var n = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array], a = n[e];
|
|
1005
|
+
function i(s) {
|
|
1006
|
+
var u = P[s >> 2], c = P[s + 4 >> 2];
|
|
1007
|
+
return new a(Z.buffer, c, u);
|
|
1029
1008
|
}
|
|
1030
|
-
r = F(r),
|
|
1009
|
+
r = F(r), j(t, {
|
|
1031
1010
|
name: r,
|
|
1032
1011
|
fromWireType: i,
|
|
1033
|
-
argPackAdvance: k,
|
|
1034
1012
|
readValueFromPointer: i
|
|
1035
1013
|
}, {
|
|
1036
1014
|
ignoreDuplicateRegistrations: !0
|
|
1037
1015
|
});
|
|
1038
|
-
},
|
|
1016
|
+
}, un = Object.assign({
|
|
1039
1017
|
optional: !0
|
|
1040
|
-
},
|
|
1041
|
-
|
|
1042
|
-
},
|
|
1018
|
+
}, me), cn = (t, e) => {
|
|
1019
|
+
j(t, un);
|
|
1020
|
+
}, ln = (t, e, r, n) => {
|
|
1043
1021
|
if (!(n > 0)) return 0;
|
|
1044
|
-
for (var a = r, i = r + n - 1,
|
|
1045
|
-
var
|
|
1046
|
-
if (
|
|
1047
|
-
var c = e.charCodeAt(++u);
|
|
1048
|
-
s = 65536 + ((s & 1023) << 10) | c & 1023;
|
|
1049
|
-
}
|
|
1050
|
-
if (s <= 127) {
|
|
1022
|
+
for (var a = r, i = r + n - 1, s = 0; s < t.length; ++s) {
|
|
1023
|
+
var u = t.codePointAt(s);
|
|
1024
|
+
if (u <= 127) {
|
|
1051
1025
|
if (r >= i) break;
|
|
1052
|
-
|
|
1053
|
-
} else if (
|
|
1026
|
+
e[r++] = u;
|
|
1027
|
+
} else if (u <= 2047) {
|
|
1054
1028
|
if (r + 1 >= i) break;
|
|
1055
|
-
|
|
1056
|
-
} else if (
|
|
1029
|
+
e[r++] = 192 | u >> 6, e[r++] = 128 | u & 63;
|
|
1030
|
+
} else if (u <= 65535) {
|
|
1057
1031
|
if (r + 2 >= i) break;
|
|
1058
|
-
|
|
1032
|
+
e[r++] = 224 | u >> 12, e[r++] = 128 | u >> 6 & 63, e[r++] = 128 | u & 63;
|
|
1059
1033
|
} else {
|
|
1060
1034
|
if (r + 3 >= i) break;
|
|
1061
|
-
|
|
1035
|
+
e[r++] = 240 | u >> 18, e[r++] = 128 | u >> 12 & 63, e[r++] = 128 | u >> 6 & 63, e[r++] = 128 | u & 63, s++;
|
|
1062
1036
|
}
|
|
1063
1037
|
}
|
|
1064
|
-
return
|
|
1065
|
-
},
|
|
1066
|
-
for (var
|
|
1067
|
-
var n =
|
|
1068
|
-
n <= 127 ?
|
|
1038
|
+
return e[r] = 0, r - a;
|
|
1039
|
+
}, rt = (t, e, r) => ln(t, W, e, r), ge = (t) => {
|
|
1040
|
+
for (var e = 0, r = 0; r < t.length; ++r) {
|
|
1041
|
+
var n = t.charCodeAt(r);
|
|
1042
|
+
n <= 127 ? e++ : n <= 2047 ? e += 2 : n >= 55296 && n <= 57343 ? (e += 4, ++r) : e += 3;
|
|
1069
1043
|
}
|
|
1070
|
-
return
|
|
1071
|
-
},
|
|
1072
|
-
|
|
1073
|
-
|
|
1074
|
-
|
|
1075
|
-
|
|
1076
|
-
|
|
1077
|
-
|
|
1078
|
-
|
|
1079
|
-
|
|
1044
|
+
return e;
|
|
1045
|
+
}, we = globalThis.TextDecoder && new TextDecoder(), $e = (t, e, r, n) => {
|
|
1046
|
+
var a = e + r;
|
|
1047
|
+
if (n) return a;
|
|
1048
|
+
for (; t[e] && !(e >= a); ) ++e;
|
|
1049
|
+
return e;
|
|
1050
|
+
}, be = function(t) {
|
|
1051
|
+
let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0, r = arguments.length > 2 ? arguments[2] : void 0, n = arguments.length > 3 ? arguments[3] : void 0;
|
|
1052
|
+
var a = $e(t, e, r, n);
|
|
1053
|
+
if (a - e > 16 && t.buffer && we)
|
|
1054
|
+
return we.decode(t.subarray(e, a));
|
|
1055
|
+
for (var i = ""; e < a; ) {
|
|
1056
|
+
var s = t[e++];
|
|
1057
|
+
if (!(s & 128)) {
|
|
1058
|
+
i += String.fromCharCode(s);
|
|
1080
1059
|
continue;
|
|
1081
1060
|
}
|
|
1082
|
-
var
|
|
1083
|
-
if ((
|
|
1084
|
-
i += String.fromCharCode((
|
|
1061
|
+
var u = t[e++] & 63;
|
|
1062
|
+
if ((s & 224) == 192) {
|
|
1063
|
+
i += String.fromCharCode((s & 31) << 6 | u);
|
|
1085
1064
|
continue;
|
|
1086
1065
|
}
|
|
1087
|
-
var c = e
|
|
1088
|
-
if ((
|
|
1089
|
-
i += String.fromCharCode(
|
|
1066
|
+
var c = t[e++] & 63;
|
|
1067
|
+
if ((s & 240) == 224 ? s = (s & 15) << 12 | u << 6 | c : s = (s & 7) << 18 | u << 12 | c << 6 | t[e++] & 63, s < 65536)
|
|
1068
|
+
i += String.fromCharCode(s);
|
|
1090
1069
|
else {
|
|
1091
|
-
var d =
|
|
1070
|
+
var d = s - 65536;
|
|
1092
1071
|
i += String.fromCharCode(55296 | d >> 10, 56320 | d & 1023);
|
|
1093
1072
|
}
|
|
1094
1073
|
}
|
|
1095
1074
|
return i;
|
|
1096
|
-
},
|
|
1097
|
-
|
|
1098
|
-
name:
|
|
1075
|
+
}, fn = (t, e, r) => t ? be(W, t, e, r) : "", hn = (t, e) => {
|
|
1076
|
+
e = F(e), j(t, {
|
|
1077
|
+
name: e,
|
|
1099
1078
|
fromWireType(r) {
|
|
1100
|
-
|
|
1101
|
-
|
|
1102
|
-
if (s == n || B[c] == 0) {
|
|
1103
|
-
var d = c - u, p = on(u, d);
|
|
1104
|
-
i === void 0 ? i = p : (i += "\0", i += p), u = c + 1;
|
|
1105
|
-
}
|
|
1106
|
-
}
|
|
1107
|
-
return tt(r), i;
|
|
1079
|
+
var n = P[r >> 2], a = r + 4, i;
|
|
1080
|
+
return i = fn(a, n, !0), z(r), i;
|
|
1108
1081
|
},
|
|
1109
1082
|
toWireType(r, n) {
|
|
1110
1083
|
n instanceof ArrayBuffer && (n = new Uint8Array(n));
|
|
1111
1084
|
var a, i = typeof n == "string";
|
|
1112
|
-
i || ArrayBuffer.isView(n) && n.BYTES_PER_ELEMENT == 1 ||
|
|
1113
|
-
var
|
|
1114
|
-
return P[
|
|
1085
|
+
i || ArrayBuffer.isView(n) && n.BYTES_PER_ELEMENT == 1 || C("Cannot pass non-string to std::string"), i ? a = ge(n) : a = n.length;
|
|
1086
|
+
var s = Xt(4 + a + 1), u = s + 4;
|
|
1087
|
+
return P[s >> 2] = a, i ? rt(n, u, a + 1) : W.set(n, u), r !== null && r.push(z, s), s;
|
|
1115
1088
|
},
|
|
1116
|
-
|
|
1117
|
-
readValueFromPointer: lt,
|
|
1089
|
+
readValueFromPointer: it,
|
|
1118
1090
|
destructorFunction(r) {
|
|
1119
|
-
|
|
1091
|
+
z(r);
|
|
1120
1092
|
}
|
|
1121
1093
|
});
|
|
1122
|
-
},
|
|
1123
|
-
|
|
1124
|
-
if (a -
|
|
1125
|
-
for (var i = "",
|
|
1126
|
-
var
|
|
1127
|
-
|
|
1128
|
-
i += String.fromCharCode(s);
|
|
1094
|
+
}, Ce = globalThis.TextDecoder ? new TextDecoder("utf-16le") : void 0, dn = (t, e, r) => {
|
|
1095
|
+
var n = t >> 1, a = $e(at, n, e / 2, r);
|
|
1096
|
+
if (a - n > 16 && Ce) return Ce.decode(at.subarray(n, a));
|
|
1097
|
+
for (var i = "", s = n; s < a; ++s) {
|
|
1098
|
+
var u = at[s];
|
|
1099
|
+
i += String.fromCharCode(u);
|
|
1129
1100
|
}
|
|
1130
1101
|
return i;
|
|
1131
|
-
},
|
|
1102
|
+
}, pn = (t, e, r) => {
|
|
1132
1103
|
if (r != null || (r = 2147483647), r < 2) return 0;
|
|
1133
1104
|
r -= 2;
|
|
1134
|
-
for (var n =
|
|
1135
|
-
var
|
|
1136
|
-
|
|
1137
|
-
}
|
|
1138
|
-
return
|
|
1139
|
-
},
|
|
1140
|
-
for (var
|
|
1141
|
-
var
|
|
1142
|
-
if (
|
|
1143
|
-
|
|
1144
|
-
var i = a - 65536;
|
|
1145
|
-
n += String.fromCharCode(55296 | i >> 10, 56320 | i & 1023);
|
|
1146
|
-
} else
|
|
1147
|
-
n += String.fromCharCode(a);
|
|
1105
|
+
for (var n = e, a = r < t.length * 2 ? r / 2 : t.length, i = 0; i < a; ++i) {
|
|
1106
|
+
var s = t.charCodeAt(i);
|
|
1107
|
+
dt[e >> 1] = s, e += 2;
|
|
1108
|
+
}
|
|
1109
|
+
return dt[e >> 1] = 0, e - n;
|
|
1110
|
+
}, vn = (t) => t.length * 2, yn = (t, e, r) => {
|
|
1111
|
+
for (var n = "", a = t >> 2, i = 0; !(i >= e / 4); i++) {
|
|
1112
|
+
var s = P[a + i];
|
|
1113
|
+
if (!s && !r) break;
|
|
1114
|
+
n += String.fromCodePoint(s);
|
|
1148
1115
|
}
|
|
1149
1116
|
return n;
|
|
1150
|
-
},
|
|
1117
|
+
}, mn = (t, e, r) => {
|
|
1151
1118
|
if (r != null || (r = 2147483647), r < 4) return 0;
|
|
1152
|
-
for (var n =
|
|
1153
|
-
var
|
|
1154
|
-
if (
|
|
1155
|
-
var s = e.charCodeAt(++i);
|
|
1156
|
-
u = 65536 + ((u & 1023) << 10) | s & 1023;
|
|
1157
|
-
}
|
|
1158
|
-
if (nt[t >> 2] = u, t += 4, t + 4 > a) break;
|
|
1119
|
+
for (var n = e, a = n + r - 4, i = 0; i < t.length; ++i) {
|
|
1120
|
+
var s = t.codePointAt(i);
|
|
1121
|
+
if (s > 65535 && i++, ot[e >> 2] = s, e += 4, e + 4 > a) break;
|
|
1159
1122
|
}
|
|
1160
|
-
return
|
|
1161
|
-
},
|
|
1162
|
-
for (var
|
|
1163
|
-
var n =
|
|
1164
|
-
n
|
|
1123
|
+
return ot[e >> 2] = 0, e - n;
|
|
1124
|
+
}, gn = (t) => {
|
|
1125
|
+
for (var e = 0, r = 0; r < t.length; ++r) {
|
|
1126
|
+
var n = t.codePointAt(r);
|
|
1127
|
+
n > 65535 && r++, e += 4;
|
|
1165
1128
|
}
|
|
1166
|
-
return
|
|
1167
|
-
},
|
|
1129
|
+
return e;
|
|
1130
|
+
}, wn = (t, e, r) => {
|
|
1168
1131
|
r = F(r);
|
|
1169
|
-
var n, a, i
|
|
1170
|
-
|
|
1132
|
+
var n, a, i;
|
|
1133
|
+
e === 2 ? (n = dn, a = pn, i = vn) : (n = yn, a = mn, i = gn), j(t, {
|
|
1171
1134
|
name: r,
|
|
1172
1135
|
fromWireType: (s) => {
|
|
1173
|
-
|
|
1174
|
-
|
|
1175
|
-
if (v == c || i($) == 0) {
|
|
1176
|
-
var b = $ - p, E = n(p, b);
|
|
1177
|
-
d === void 0 ? d = E : (d += "\0", d += E), p = $ + t;
|
|
1178
|
-
}
|
|
1179
|
-
}
|
|
1180
|
-
return tt(s), d;
|
|
1136
|
+
var u = P[s >> 2], c = n(s + 4, u * e, !0);
|
|
1137
|
+
return z(s), c;
|
|
1181
1138
|
},
|
|
1182
|
-
toWireType: (s,
|
|
1183
|
-
typeof
|
|
1184
|
-
var
|
|
1185
|
-
return P[
|
|
1139
|
+
toWireType: (s, u) => {
|
|
1140
|
+
typeof u != "string" && C(`Cannot pass non-string to C++ string type ${r}`);
|
|
1141
|
+
var c = i(u), d = Xt(4 + c + e);
|
|
1142
|
+
return P[d >> 2] = c / e, a(u, d + 4, c + e), s !== null && s.push(z, d), d;
|
|
1186
1143
|
},
|
|
1187
|
-
|
|
1188
|
-
readValueFromPointer: lt,
|
|
1144
|
+
readValueFromPointer: it,
|
|
1189
1145
|
destructorFunction(s) {
|
|
1190
|
-
|
|
1146
|
+
z(s);
|
|
1191
1147
|
}
|
|
1192
1148
|
});
|
|
1193
|
-
},
|
|
1194
|
-
|
|
1195
|
-
name: F(
|
|
1196
|
-
rawConstructor:
|
|
1197
|
-
rawDestructor:
|
|
1149
|
+
}, $n = (t, e, r, n, a, i) => {
|
|
1150
|
+
gt[t] = {
|
|
1151
|
+
name: F(e),
|
|
1152
|
+
rawConstructor: L(r, n),
|
|
1153
|
+
rawDestructor: L(a, i),
|
|
1198
1154
|
fields: []
|
|
1199
1155
|
};
|
|
1200
|
-
},
|
|
1201
|
-
|
|
1202
|
-
fieldName: F(
|
|
1156
|
+
}, bn = (t, e, r, n, a, i, s, u, c, d) => {
|
|
1157
|
+
gt[t].fields.push({
|
|
1158
|
+
fieldName: F(e),
|
|
1203
1159
|
getterReturnType: r,
|
|
1204
|
-
getter:
|
|
1160
|
+
getter: L(n, a),
|
|
1205
1161
|
getterContext: i,
|
|
1206
|
-
setterArgumentType:
|
|
1207
|
-
setter:
|
|
1162
|
+
setterArgumentType: s,
|
|
1163
|
+
setter: L(u, c),
|
|
1208
1164
|
setterContext: d
|
|
1209
1165
|
});
|
|
1210
|
-
},
|
|
1211
|
-
|
|
1166
|
+
}, Cn = (t, e) => {
|
|
1167
|
+
e = F(e), j(t, {
|
|
1212
1168
|
isVoid: !0,
|
|
1213
|
-
name:
|
|
1214
|
-
argPackAdvance: 0,
|
|
1169
|
+
name: e,
|
|
1215
1170
|
fromWireType: () => {
|
|
1216
1171
|
},
|
|
1217
1172
|
toWireType: (r, n) => {
|
|
1218
1173
|
}
|
|
1219
1174
|
});
|
|
1220
|
-
},
|
|
1221
|
-
var
|
|
1222
|
-
return t
|
|
1223
|
-
},
|
|
1224
|
-
|
|
1225
|
-
|
|
1226
|
-
|
|
1227
|
-
|
|
1228
|
-
|
|
1229
|
-
return r || delete t.$$$embind_global$$$, r;
|
|
1230
|
-
}
|
|
1231
|
-
if (typeof $$$embind_global$$$ == "object" || (typeof global == "object" && e(global) ? $$$embind_global$$$ = global : typeof self == "object" && e(self) && ($$$embind_global$$$ = self), typeof $$$embind_global$$$ == "object"))
|
|
1232
|
-
return $$$embind_global$$$;
|
|
1233
|
-
throw Error("unable to get global object.");
|
|
1234
|
-
}, bn = (e) => e === 0 ? H.toHandle(_e()) : (e = $n(e), H.toHandle(_e()[e])), Cn = (e) => {
|
|
1235
|
-
var t = qt.length;
|
|
1236
|
-
return qt.push(e), t;
|
|
1237
|
-
}, Ee = (e, t) => {
|
|
1238
|
-
var r = Q[e];
|
|
1239
|
-
return r === void 0 && T(`${t} has unknown type ${me(e)}`), r;
|
|
1240
|
-
}, Tn = (e, t) => {
|
|
1241
|
-
for (var r = new Array(e), n = 0; n < e; ++n)
|
|
1242
|
-
r[n] = Ee(P[t + n * 4 >> 2], `parameter ${n}`);
|
|
1175
|
+
}, zt = [], Tn = (t) => {
|
|
1176
|
+
var e = zt.length;
|
|
1177
|
+
return zt.push(t), e;
|
|
1178
|
+
}, En = (t, e) => {
|
|
1179
|
+
var r = Q[t];
|
|
1180
|
+
return r === void 0 && C(`${e} has unknown type ${pe(t)}`), r;
|
|
1181
|
+
}, Pn = (t, e) => {
|
|
1182
|
+
for (var r = new Array(t), n = 0; n < t; ++n)
|
|
1183
|
+
r[n] = En(P[e + n * 4 >> 2], `parameter ${n}`);
|
|
1243
1184
|
return r;
|
|
1244
|
-
},
|
|
1245
|
-
var n = [], a =
|
|
1246
|
-
return n.length && (P[
|
|
1247
|
-
}, _n =
|
|
1248
|
-
var
|
|
1249
|
-
e
|
|
1250
|
-
|
|
1251
|
-
|
|
1252
|
-
|
|
1253
|
-
|
|
1254
|
-
|
|
1255
|
-
|
|
1256
|
-
|
|
1257
|
-
|
|
1258
|
-
|
|
1259
|
-
|
|
1260
|
-
|
|
1261
|
-
|
|
1262
|
-
|
|
1263
|
-
|
|
1264
|
-
|
|
1265
|
-
|
|
1266
|
-
|
|
1267
|
-
|
|
1268
|
-
|
|
1269
|
-
|
|
1270
|
-
|
|
1271
|
-
return
|
|
1272
|
-
},
|
|
1273
|
-
|
|
1274
|
-
},
|
|
1275
|
-
|
|
1185
|
+
}, On = (t, e, r) => {
|
|
1186
|
+
var n = [], a = t(n, r);
|
|
1187
|
+
return n.length && (P[e >> 2] = B.toHandle(n)), a;
|
|
1188
|
+
}, _n = {}, Te = (t) => {
|
|
1189
|
+
var e = _n[t];
|
|
1190
|
+
return e === void 0 ? F(t) : e;
|
|
1191
|
+
}, xn = (t, e, r) => {
|
|
1192
|
+
var n = 8, [a, ...i] = Pn(t, e), s = a.toWireType.bind(a), u = i.map((v) => v.readValueFromPointer.bind(v));
|
|
1193
|
+
t--;
|
|
1194
|
+
var c = new Array(t), d = (v, y, T, S) => {
|
|
1195
|
+
for (var x = 0, E = 0; E < t; ++E)
|
|
1196
|
+
c[E] = u[E](S + x), x += n;
|
|
1197
|
+
var O;
|
|
1198
|
+
switch (r) {
|
|
1199
|
+
case 0:
|
|
1200
|
+
O = B.toValue(v).apply(null, c);
|
|
1201
|
+
break;
|
|
1202
|
+
case 2:
|
|
1203
|
+
O = Reflect.construct(B.toValue(v), c);
|
|
1204
|
+
break;
|
|
1205
|
+
case 3:
|
|
1206
|
+
O = c[0];
|
|
1207
|
+
break;
|
|
1208
|
+
case 1:
|
|
1209
|
+
O = B.toValue(v)[Te(y)](...c);
|
|
1210
|
+
break;
|
|
1211
|
+
}
|
|
1212
|
+
return On(s, T, O);
|
|
1213
|
+
}, p = `methodCaller<(${i.map((v) => v.name)}) => ${a.name}>`;
|
|
1214
|
+
return Tn(Ut(p, d));
|
|
1215
|
+
}, Sn = (t) => t ? (t = Te(t), B.toHandle(globalThis[t])) : B.toHandle(globalThis), In = (t) => {
|
|
1216
|
+
t > 9 && (K[t + 1] += 1);
|
|
1217
|
+
}, Dn = (t, e, r, n, a) => zt[t](e, r, n, a), Mn = (t) => {
|
|
1218
|
+
var e = B.toValue(t);
|
|
1219
|
+
Lt(e), Nt(t);
|
|
1220
|
+
}, An = (t, e, r, n) => {
|
|
1221
|
+
var a = (/* @__PURE__ */ new Date()).getFullYear(), i = new Date(a, 0, 1), s = new Date(a, 6, 1), u = i.getTimezoneOffset(), c = s.getTimezoneOffset(), d = Math.max(u, c);
|
|
1222
|
+
P[t >> 2] = d * 60, ot[e >> 2] = +(u != c);
|
|
1223
|
+
var p = (T) => {
|
|
1224
|
+
var S = T >= 0 ? "-" : "+", x = Math.abs(T), E = String(Math.floor(x / 60)).padStart(2, "0"), O = String(x % 60).padStart(2, "0");
|
|
1225
|
+
return `UTC${S}${E}${O}`;
|
|
1226
|
+
}, v = p(u), y = p(c);
|
|
1227
|
+
c < u ? (rt(v, r, 17), rt(y, n, 17)) : (rt(v, n, 17), rt(y, r, 17));
|
|
1228
|
+
}, Fn = () => 2147483648, Rn = (t, e) => Math.ceil(t / e) * e, Ln = (t) => {
|
|
1229
|
+
var e = Pt.buffer.byteLength, r = (t - e + 65535) / 65536 | 0;
|
|
1276
1230
|
try {
|
|
1277
|
-
return
|
|
1231
|
+
return Pt.grow(r), re(), 1;
|
|
1278
1232
|
} catch {
|
|
1279
1233
|
}
|
|
1280
|
-
},
|
|
1281
|
-
var
|
|
1282
|
-
|
|
1283
|
-
var r =
|
|
1284
|
-
if (
|
|
1234
|
+
}, jn = (t) => {
|
|
1235
|
+
var e = W.length;
|
|
1236
|
+
t >>>= 0;
|
|
1237
|
+
var r = Fn();
|
|
1238
|
+
if (t > r)
|
|
1285
1239
|
return !1;
|
|
1286
1240
|
for (var n = 1; n <= 4; n *= 2) {
|
|
1287
|
-
var a =
|
|
1288
|
-
a = Math.min(a,
|
|
1289
|
-
var i = Math.min(r,
|
|
1290
|
-
if (
|
|
1241
|
+
var a = e * (1 + 0.2 / n);
|
|
1242
|
+
a = Math.min(a, t + 100663296);
|
|
1243
|
+
var i = Math.min(r, Rn(Math.max(t, a), 65536)), s = Ln(i);
|
|
1244
|
+
if (s)
|
|
1291
1245
|
return !0;
|
|
1292
1246
|
}
|
|
1293
1247
|
return !1;
|
|
1294
|
-
},
|
|
1295
|
-
if (!
|
|
1296
|
-
var
|
|
1248
|
+
}, Gt = {}, Bn = () => _ || "./this.program", ct = () => {
|
|
1249
|
+
if (!ct.strings) {
|
|
1250
|
+
var t = (typeof navigator == "object" && navigator.language || "C").replace("-", "_") + ".UTF-8", e = {
|
|
1297
1251
|
USER: "web_user",
|
|
1298
1252
|
LOGNAME: "web_user",
|
|
1299
1253
|
PATH: "/",
|
|
1300
1254
|
PWD: "/",
|
|
1301
1255
|
HOME: "/home/web_user",
|
|
1302
|
-
LANG:
|
|
1303
|
-
_:
|
|
1256
|
+
LANG: t,
|
|
1257
|
+
_: Bn()
|
|
1304
1258
|
};
|
|
1305
|
-
for (var r in
|
|
1306
|
-
|
|
1259
|
+
for (var r in Gt)
|
|
1260
|
+
Gt[r] === void 0 ? delete e[r] : e[r] = Gt[r];
|
|
1307
1261
|
var n = [];
|
|
1308
|
-
for (var r in
|
|
1309
|
-
n.push(`${r}=${
|
|
1310
|
-
|
|
1262
|
+
for (var r in e)
|
|
1263
|
+
n.push(`${r}=${e[r]}`);
|
|
1264
|
+
ct.strings = n;
|
|
1311
1265
|
}
|
|
1312
|
-
return
|
|
1313
|
-
},
|
|
1266
|
+
return ct.strings;
|
|
1267
|
+
}, Un = (t, e) => {
|
|
1314
1268
|
var r = 0, n = 0;
|
|
1315
|
-
for (var a of
|
|
1316
|
-
var i =
|
|
1317
|
-
P[
|
|
1269
|
+
for (var a of ct()) {
|
|
1270
|
+
var i = e + r;
|
|
1271
|
+
P[t + n >> 2] = i, r += rt(a, i, 1 / 0) + 1, n += 4;
|
|
1318
1272
|
}
|
|
1319
1273
|
return 0;
|
|
1320
|
-
},
|
|
1321
|
-
var r =
|
|
1322
|
-
P[
|
|
1274
|
+
}, Vn = (t, e) => {
|
|
1275
|
+
var r = ct();
|
|
1276
|
+
P[t >> 2] = r.length;
|
|
1323
1277
|
var n = 0;
|
|
1324
1278
|
for (var a of r)
|
|
1325
|
-
n +=
|
|
1326
|
-
return P[
|
|
1327
|
-
},
|
|
1328
|
-
function
|
|
1279
|
+
n += ge(a) + 1;
|
|
1280
|
+
return P[e >> 2] = n, 0;
|
|
1281
|
+
}, Wn = (t) => 52;
|
|
1282
|
+
function Hn(t, e, r, n, a) {
|
|
1329
1283
|
return 70;
|
|
1330
1284
|
}
|
|
1331
|
-
var
|
|
1332
|
-
var r =
|
|
1333
|
-
|
|
1334
|
-
},
|
|
1285
|
+
var kn = [null, [], []], Nn = (t, e) => {
|
|
1286
|
+
var r = kn[t];
|
|
1287
|
+
e === 0 || e === 10 ? ((t === 1 ? nt : V)(be(r)), r.length = 0) : r.push(e);
|
|
1288
|
+
}, zn = (t, e, r, n) => {
|
|
1335
1289
|
for (var a = 0, i = 0; i < r; i++) {
|
|
1336
|
-
var
|
|
1337
|
-
|
|
1338
|
-
for (var c = 0; c <
|
|
1339
|
-
|
|
1340
|
-
a +=
|
|
1290
|
+
var s = P[e >> 2], u = P[e + 4 >> 2];
|
|
1291
|
+
e += 8;
|
|
1292
|
+
for (var c = 0; c < u; c++)
|
|
1293
|
+
Nn(t, W[s + c]);
|
|
1294
|
+
a += u;
|
|
1341
1295
|
}
|
|
1342
1296
|
return P[n >> 2] = a, 0;
|
|
1343
|
-
},
|
|
1344
|
-
|
|
1345
|
-
|
|
1346
|
-
|
|
1347
|
-
|
|
1348
|
-
|
|
1349
|
-
|
|
1350
|
-
|
|
1351
|
-
|
|
1352
|
-
|
|
1353
|
-
|
|
1354
|
-
|
|
1355
|
-
|
|
1356
|
-
|
|
1357
|
-
|
|
1358
|
-
|
|
1359
|
-
|
|
1360
|
-
|
|
1361
|
-
|
|
1362
|
-
|
|
1363
|
-
|
|
1364
|
-
|
|
1365
|
-
|
|
1366
|
-
|
|
1367
|
-
|
|
1368
|
-
|
|
1369
|
-
|
|
1370
|
-
|
|
1371
|
-
|
|
1372
|
-
|
|
1373
|
-
|
|
1374
|
-
|
|
1375
|
-
|
|
1376
|
-
|
|
1377
|
-
|
|
1378
|
-
|
|
1379
|
-
|
|
1380
|
-
|
|
1381
|
-
|
|
1382
|
-
|
|
1383
|
-
|
|
1384
|
-
ia:
|
|
1385
|
-
|
|
1386
|
-
|
|
1387
|
-
|
|
1388
|
-
|
|
1389
|
-
|
|
1390
|
-
|
|
1391
|
-
|
|
1392
|
-
|
|
1393
|
-
|
|
1394
|
-
|
|
1395
|
-
|
|
1396
|
-
|
|
1397
|
-
|
|
1398
|
-
|
|
1399
|
-
|
|
1400
|
-
|
|
1401
|
-
|
|
1402
|
-
|
|
1403
|
-
|
|
1404
|
-
|
|
1405
|
-
|
|
1406
|
-
|
|
1407
|
-
|
|
1408
|
-
|
|
1409
|
-
|
|
1410
|
-
|
|
1411
|
-
|
|
1412
|
-
|
|
1413
|
-
|
|
1414
|
-
|
|
1415
|
-
|
|
1416
|
-
|
|
1417
|
-
|
|
1418
|
-
|
|
1419
|
-
|
|
1420
|
-
|
|
1421
|
-
|
|
1422
|
-
|
|
1423
|
-
|
|
1424
|
-
|
|
1425
|
-
|
|
1426
|
-
|
|
1427
|
-
|
|
1428
|
-
|
|
1429
|
-
|
|
1430
|
-
|
|
1431
|
-
function ea(e, t) {
|
|
1432
|
-
var r = g();
|
|
1297
|
+
}, Gn = (t) => t;
|
|
1298
|
+
if (Ar(), zr(), f.noExitRuntime && f.noExitRuntime, f.print && (nt = f.print), f.printErr && (V = f.printErr), f.wasmBinary && (Y = f.wasmBinary), f.arguments && f.arguments, f.thisProgram && (_ = f.thisProgram), f.preInit)
|
|
1299
|
+
for (typeof f.preInit == "function" && (f.preInit = [f.preInit]); f.preInit.length > 0; )
|
|
1300
|
+
f.preInit.shift()();
|
|
1301
|
+
var Ee, z, Xt, Pe, m, Oe, _e, xe, Se, Ie, De, Me, Ae, Pt, Fe;
|
|
1302
|
+
function Xn(t) {
|
|
1303
|
+
Ee = t.ya, z = f._free = t.za, Xt = f._malloc = t.Ba, Pe = t.Ca, m = t.Da, Oe = t.Ea, _e = t.Fa, xe = t.Ga, Se = t.Ha, Ie = t.Ia, De = t.Ja, N.viijii = t.Ka, Me = N.iiijj = t.La, N.jiji = t.Ma, Ae = N.jiiii = t.Na, N.iiiiij = t.Oa, N.iiiiijj = t.Pa, N.iiiiiijj = t.Qa, Pt = t.wa, Fe = t.Aa;
|
|
1304
|
+
}
|
|
1305
|
+
var qn = {
|
|
1306
|
+
s: yr,
|
|
1307
|
+
w: mr,
|
|
1308
|
+
a: gr,
|
|
1309
|
+
j: wr,
|
|
1310
|
+
m: $r,
|
|
1311
|
+
Q: br,
|
|
1312
|
+
p: Cr,
|
|
1313
|
+
U: Tr,
|
|
1314
|
+
d: Er,
|
|
1315
|
+
ca: Pr,
|
|
1316
|
+
ta: _r,
|
|
1317
|
+
ba: xr,
|
|
1318
|
+
oa: Ir,
|
|
1319
|
+
ra: Zr,
|
|
1320
|
+
qa: Jr,
|
|
1321
|
+
H: Kr,
|
|
1322
|
+
ma: tn,
|
|
1323
|
+
X: rn,
|
|
1324
|
+
Y: nn,
|
|
1325
|
+
x: on,
|
|
1326
|
+
t: sn,
|
|
1327
|
+
sa: cn,
|
|
1328
|
+
na: hn,
|
|
1329
|
+
R: wn,
|
|
1330
|
+
I: $n,
|
|
1331
|
+
ua: bn,
|
|
1332
|
+
pa: Cn,
|
|
1333
|
+
N: xn,
|
|
1334
|
+
va: Nt,
|
|
1335
|
+
D: Sn,
|
|
1336
|
+
S: In,
|
|
1337
|
+
M: Dn,
|
|
1338
|
+
ia: Mn,
|
|
1339
|
+
da: An,
|
|
1340
|
+
ga: jn,
|
|
1341
|
+
ea: Un,
|
|
1342
|
+
fa: Vn,
|
|
1343
|
+
ha: Wn,
|
|
1344
|
+
$: Hn,
|
|
1345
|
+
V: zn,
|
|
1346
|
+
K: ma,
|
|
1347
|
+
C: $a,
|
|
1348
|
+
Z: ea,
|
|
1349
|
+
T: Oa,
|
|
1350
|
+
r: da,
|
|
1351
|
+
b: Kn,
|
|
1352
|
+
E: ya,
|
|
1353
|
+
ka: Ca,
|
|
1354
|
+
c: ra,
|
|
1355
|
+
ja: Ta,
|
|
1356
|
+
h: ta,
|
|
1357
|
+
i: oa,
|
|
1358
|
+
q: ca,
|
|
1359
|
+
P: va,
|
|
1360
|
+
v: fa,
|
|
1361
|
+
F: ha,
|
|
1362
|
+
L: pa,
|
|
1363
|
+
z: ba,
|
|
1364
|
+
J: _a,
|
|
1365
|
+
aa: xa,
|
|
1366
|
+
_: Sa,
|
|
1367
|
+
f: na,
|
|
1368
|
+
l: Yn,
|
|
1369
|
+
e: Jn,
|
|
1370
|
+
g: Qn,
|
|
1371
|
+
O: Pa,
|
|
1372
|
+
k: Zn,
|
|
1373
|
+
la: ga,
|
|
1374
|
+
o: la,
|
|
1375
|
+
B: ia,
|
|
1376
|
+
u: wa,
|
|
1377
|
+
W: ua,
|
|
1378
|
+
A: Ea,
|
|
1379
|
+
n: aa,
|
|
1380
|
+
G: sa,
|
|
1381
|
+
y: Gn
|
|
1382
|
+
};
|
|
1383
|
+
function Yn(t, e) {
|
|
1384
|
+
var r = w();
|
|
1433
1385
|
try {
|
|
1434
|
-
|
|
1386
|
+
$(t)(e);
|
|
1435
1387
|
} catch (n) {
|
|
1436
|
-
if (
|
|
1437
|
-
|
|
1438
|
-
}
|
|
1439
|
-
}
|
|
1440
|
-
function ra(e, t, r, n) {
|
|
1441
|
-
var a = g();
|
|
1442
|
-
try {
|
|
1443
|
-
return w(e)(t, r, n);
|
|
1444
|
-
} catch (i) {
|
|
1445
|
-
if (m(a), i !== i + 0) throw i;
|
|
1446
|
-
y(1, 0);
|
|
1388
|
+
if (g(r), n !== n + 0) throw n;
|
|
1389
|
+
m(1, 0);
|
|
1447
1390
|
}
|
|
1448
1391
|
}
|
|
1449
|
-
function
|
|
1450
|
-
var i =
|
|
1392
|
+
function Zn(t, e, r, n, a) {
|
|
1393
|
+
var i = w();
|
|
1451
1394
|
try {
|
|
1452
|
-
|
|
1453
|
-
} catch (
|
|
1454
|
-
if (
|
|
1455
|
-
|
|
1395
|
+
$(t)(e, r, n, a);
|
|
1396
|
+
} catch (s) {
|
|
1397
|
+
if (g(i), s !== s + 0) throw s;
|
|
1398
|
+
m(1, 0);
|
|
1456
1399
|
}
|
|
1457
1400
|
}
|
|
1458
|
-
function
|
|
1459
|
-
var a =
|
|
1401
|
+
function Qn(t, e, r, n) {
|
|
1402
|
+
var a = w();
|
|
1460
1403
|
try {
|
|
1461
|
-
|
|
1404
|
+
$(t)(e, r, n);
|
|
1462
1405
|
} catch (i) {
|
|
1463
|
-
if (
|
|
1464
|
-
|
|
1406
|
+
if (g(a), i !== i + 0) throw i;
|
|
1407
|
+
m(1, 0);
|
|
1465
1408
|
}
|
|
1466
1409
|
}
|
|
1467
|
-
function
|
|
1468
|
-
var n =
|
|
1410
|
+
function Jn(t, e, r) {
|
|
1411
|
+
var n = w();
|
|
1469
1412
|
try {
|
|
1470
|
-
|
|
1413
|
+
$(t)(e, r);
|
|
1471
1414
|
} catch (a) {
|
|
1472
|
-
if (
|
|
1473
|
-
|
|
1415
|
+
if (g(n), a !== a + 0) throw a;
|
|
1416
|
+
m(1, 0);
|
|
1474
1417
|
}
|
|
1475
1418
|
}
|
|
1476
|
-
function
|
|
1477
|
-
var r =
|
|
1419
|
+
function Kn(t, e) {
|
|
1420
|
+
var r = w();
|
|
1478
1421
|
try {
|
|
1479
|
-
return
|
|
1422
|
+
return $(t)(e);
|
|
1480
1423
|
} catch (n) {
|
|
1481
|
-
if (
|
|
1482
|
-
|
|
1424
|
+
if (g(r), n !== n + 0) throw n;
|
|
1425
|
+
m(1, 0);
|
|
1483
1426
|
}
|
|
1484
1427
|
}
|
|
1485
|
-
function
|
|
1486
|
-
var
|
|
1428
|
+
function ta(t, e, r, n) {
|
|
1429
|
+
var a = w();
|
|
1487
1430
|
try {
|
|
1488
|
-
return
|
|
1489
|
-
} catch (
|
|
1490
|
-
if (
|
|
1491
|
-
|
|
1431
|
+
return $(t)(e, r, n);
|
|
1432
|
+
} catch (i) {
|
|
1433
|
+
if (g(a), i !== i + 0) throw i;
|
|
1434
|
+
m(1, 0);
|
|
1492
1435
|
}
|
|
1493
1436
|
}
|
|
1494
|
-
function
|
|
1495
|
-
var
|
|
1437
|
+
function ea(t, e, r, n, a, i) {
|
|
1438
|
+
var s = w();
|
|
1496
1439
|
try {
|
|
1497
|
-
|
|
1498
|
-
} catch (
|
|
1499
|
-
if (
|
|
1500
|
-
|
|
1440
|
+
return $(t)(e, r, n, a, i);
|
|
1441
|
+
} catch (u) {
|
|
1442
|
+
if (g(s), u !== u + 0) throw u;
|
|
1443
|
+
m(1, 0);
|
|
1501
1444
|
}
|
|
1502
1445
|
}
|
|
1503
|
-
function
|
|
1504
|
-
var
|
|
1446
|
+
function ra(t, e, r) {
|
|
1447
|
+
var n = w();
|
|
1505
1448
|
try {
|
|
1506
|
-
|
|
1507
|
-
} catch (
|
|
1508
|
-
if (
|
|
1509
|
-
|
|
1449
|
+
return $(t)(e, r);
|
|
1450
|
+
} catch (a) {
|
|
1451
|
+
if (g(n), a !== a + 0) throw a;
|
|
1452
|
+
m(1, 0);
|
|
1510
1453
|
}
|
|
1511
1454
|
}
|
|
1512
|
-
function
|
|
1513
|
-
var
|
|
1455
|
+
function na(t) {
|
|
1456
|
+
var e = w();
|
|
1514
1457
|
try {
|
|
1515
|
-
|
|
1516
|
-
} catch (
|
|
1517
|
-
if (
|
|
1518
|
-
|
|
1458
|
+
$(t)();
|
|
1459
|
+
} catch (r) {
|
|
1460
|
+
if (g(e), r !== r + 0) throw r;
|
|
1461
|
+
m(1, 0);
|
|
1519
1462
|
}
|
|
1520
1463
|
}
|
|
1521
|
-
function
|
|
1522
|
-
var
|
|
1464
|
+
function aa(t, e, r, n, a, i, s, u, c, d, p) {
|
|
1465
|
+
var v = w();
|
|
1523
1466
|
try {
|
|
1524
|
-
|
|
1525
|
-
} catch (
|
|
1526
|
-
if (
|
|
1527
|
-
|
|
1467
|
+
$(t)(e, r, n, a, i, s, u, c, d, p);
|
|
1468
|
+
} catch (y) {
|
|
1469
|
+
if (g(v), y !== y + 0) throw y;
|
|
1470
|
+
m(1, 0);
|
|
1528
1471
|
}
|
|
1529
1472
|
}
|
|
1530
|
-
function
|
|
1531
|
-
var
|
|
1473
|
+
function oa(t, e, r, n, a) {
|
|
1474
|
+
var i = w();
|
|
1532
1475
|
try {
|
|
1533
|
-
|
|
1534
|
-
} catch (
|
|
1535
|
-
if (
|
|
1536
|
-
|
|
1476
|
+
return $(t)(e, r, n, a);
|
|
1477
|
+
} catch (s) {
|
|
1478
|
+
if (g(i), s !== s + 0) throw s;
|
|
1479
|
+
m(1, 0);
|
|
1537
1480
|
}
|
|
1538
1481
|
}
|
|
1539
|
-
function
|
|
1540
|
-
var
|
|
1482
|
+
function ia(t, e, r, n, a, i, s) {
|
|
1483
|
+
var u = w();
|
|
1541
1484
|
try {
|
|
1542
|
-
|
|
1543
|
-
} catch (
|
|
1544
|
-
if (
|
|
1545
|
-
|
|
1485
|
+
$(t)(e, r, n, a, i, s);
|
|
1486
|
+
} catch (c) {
|
|
1487
|
+
if (g(u), c !== c + 0) throw c;
|
|
1488
|
+
m(1, 0);
|
|
1546
1489
|
}
|
|
1547
1490
|
}
|
|
1548
|
-
function
|
|
1549
|
-
var
|
|
1491
|
+
function sa(t, e, r, n, a, i, s, u, c, d, p, v, y, T, S, x) {
|
|
1492
|
+
var E = w();
|
|
1550
1493
|
try {
|
|
1551
|
-
|
|
1552
|
-
} catch (
|
|
1553
|
-
if (
|
|
1554
|
-
|
|
1494
|
+
$(t)(e, r, n, a, i, s, u, c, d, p, v, y, T, S, x);
|
|
1495
|
+
} catch (O) {
|
|
1496
|
+
if (g(E), O !== O + 0) throw O;
|
|
1497
|
+
m(1, 0);
|
|
1555
1498
|
}
|
|
1556
1499
|
}
|
|
1557
|
-
function
|
|
1558
|
-
var
|
|
1500
|
+
function ua(t, e, r, n, a, i, s, u, c) {
|
|
1501
|
+
var d = w();
|
|
1559
1502
|
try {
|
|
1560
|
-
|
|
1561
|
-
} catch (
|
|
1562
|
-
if (
|
|
1563
|
-
|
|
1503
|
+
$(t)(e, r, n, a, i, s, u, c);
|
|
1504
|
+
} catch (p) {
|
|
1505
|
+
if (g(d), p !== p + 0) throw p;
|
|
1506
|
+
m(1, 0);
|
|
1564
1507
|
}
|
|
1565
1508
|
}
|
|
1566
|
-
function
|
|
1567
|
-
var
|
|
1509
|
+
function ca(t, e, r, n, a, i) {
|
|
1510
|
+
var s = w();
|
|
1568
1511
|
try {
|
|
1569
|
-
|
|
1570
|
-
} catch (
|
|
1571
|
-
if (
|
|
1572
|
-
|
|
1512
|
+
return $(t)(e, r, n, a, i);
|
|
1513
|
+
} catch (u) {
|
|
1514
|
+
if (g(s), u !== u + 0) throw u;
|
|
1515
|
+
m(1, 0);
|
|
1573
1516
|
}
|
|
1574
1517
|
}
|
|
1575
|
-
function
|
|
1576
|
-
var s =
|
|
1518
|
+
function la(t, e, r, n, a, i) {
|
|
1519
|
+
var s = w();
|
|
1577
1520
|
try {
|
|
1578
|
-
|
|
1579
|
-
} catch (
|
|
1580
|
-
if (
|
|
1581
|
-
|
|
1521
|
+
$(t)(e, r, n, a, i);
|
|
1522
|
+
} catch (u) {
|
|
1523
|
+
if (g(s), u !== u + 0) throw u;
|
|
1524
|
+
m(1, 0);
|
|
1582
1525
|
}
|
|
1583
1526
|
}
|
|
1584
|
-
function
|
|
1585
|
-
var
|
|
1527
|
+
function fa(t, e, r, n, a, i, s) {
|
|
1528
|
+
var u = w();
|
|
1586
1529
|
try {
|
|
1587
|
-
|
|
1588
|
-
} catch (
|
|
1589
|
-
if (
|
|
1590
|
-
|
|
1530
|
+
return $(t)(e, r, n, a, i, s);
|
|
1531
|
+
} catch (c) {
|
|
1532
|
+
if (g(u), c !== c + 0) throw c;
|
|
1533
|
+
m(1, 0);
|
|
1591
1534
|
}
|
|
1592
1535
|
}
|
|
1593
|
-
function
|
|
1594
|
-
var c =
|
|
1536
|
+
function ha(t, e, r, n, a, i, s, u) {
|
|
1537
|
+
var c = w();
|
|
1595
1538
|
try {
|
|
1596
|
-
return
|
|
1539
|
+
return $(t)(e, r, n, a, i, s, u);
|
|
1597
1540
|
} catch (d) {
|
|
1598
|
-
if (
|
|
1599
|
-
|
|
1541
|
+
if (g(c), d !== d + 0) throw d;
|
|
1542
|
+
m(1, 0);
|
|
1600
1543
|
}
|
|
1601
1544
|
}
|
|
1602
|
-
function
|
|
1603
|
-
var
|
|
1545
|
+
function da(t) {
|
|
1546
|
+
var e = w();
|
|
1604
1547
|
try {
|
|
1605
|
-
return
|
|
1548
|
+
return $(t)();
|
|
1606
1549
|
} catch (r) {
|
|
1607
|
-
if (
|
|
1608
|
-
|
|
1550
|
+
if (g(e), r !== r + 0) throw r;
|
|
1551
|
+
m(1, 0);
|
|
1609
1552
|
}
|
|
1610
1553
|
}
|
|
1611
|
-
function
|
|
1612
|
-
var d =
|
|
1554
|
+
function pa(t, e, r, n, a, i, s, u, c) {
|
|
1555
|
+
var d = w();
|
|
1613
1556
|
try {
|
|
1614
|
-
return
|
|
1557
|
+
return $(t)(e, r, n, a, i, s, u, c);
|
|
1615
1558
|
} catch (p) {
|
|
1616
|
-
if (
|
|
1617
|
-
|
|
1559
|
+
if (g(d), p !== p + 0) throw p;
|
|
1560
|
+
m(1, 0);
|
|
1618
1561
|
}
|
|
1619
1562
|
}
|
|
1620
|
-
function
|
|
1621
|
-
var
|
|
1563
|
+
function va(t, e, r, n, a, i, s) {
|
|
1564
|
+
var u = w();
|
|
1622
1565
|
try {
|
|
1623
|
-
return
|
|
1566
|
+
return $(t)(e, r, n, a, i, s);
|
|
1624
1567
|
} catch (c) {
|
|
1625
|
-
if (
|
|
1626
|
-
|
|
1568
|
+
if (g(u), c !== c + 0) throw c;
|
|
1569
|
+
m(1, 0);
|
|
1627
1570
|
}
|
|
1628
1571
|
}
|
|
1629
|
-
function
|
|
1630
|
-
var a =
|
|
1572
|
+
function ya(t, e, r, n) {
|
|
1573
|
+
var a = w();
|
|
1631
1574
|
try {
|
|
1632
|
-
return
|
|
1575
|
+
return $(t)(e, r, n);
|
|
1633
1576
|
} catch (i) {
|
|
1634
|
-
if (
|
|
1635
|
-
|
|
1577
|
+
if (g(a), i !== i + 0) throw i;
|
|
1578
|
+
m(1, 0);
|
|
1636
1579
|
}
|
|
1637
1580
|
}
|
|
1638
|
-
function
|
|
1639
|
-
var a =
|
|
1581
|
+
function ma(t, e, r, n) {
|
|
1582
|
+
var a = w();
|
|
1640
1583
|
try {
|
|
1641
|
-
return
|
|
1584
|
+
return $(t)(e, r, n);
|
|
1642
1585
|
} catch (i) {
|
|
1643
|
-
if (
|
|
1644
|
-
|
|
1586
|
+
if (g(a), i !== i + 0) throw i;
|
|
1587
|
+
m(1, 0);
|
|
1645
1588
|
}
|
|
1646
1589
|
}
|
|
1647
|
-
function
|
|
1648
|
-
var c =
|
|
1590
|
+
function ga(t, e, r, n, a, i, s, u) {
|
|
1591
|
+
var c = w();
|
|
1649
1592
|
try {
|
|
1650
|
-
|
|
1593
|
+
$(t)(e, r, n, a, i, s, u);
|
|
1651
1594
|
} catch (d) {
|
|
1652
|
-
if (
|
|
1653
|
-
|
|
1595
|
+
if (g(c), d !== d + 0) throw d;
|
|
1596
|
+
m(1, 0);
|
|
1654
1597
|
}
|
|
1655
1598
|
}
|
|
1656
|
-
function
|
|
1657
|
-
var
|
|
1599
|
+
function wa(t, e, r, n, a, i, s, u) {
|
|
1600
|
+
var c = w();
|
|
1658
1601
|
try {
|
|
1659
|
-
|
|
1660
|
-
} catch (
|
|
1661
|
-
if (
|
|
1662
|
-
|
|
1602
|
+
$(t)(e, r, n, a, i, s, u);
|
|
1603
|
+
} catch (d) {
|
|
1604
|
+
if (g(c), d !== d + 0) throw d;
|
|
1605
|
+
m(1, 0);
|
|
1606
|
+
}
|
|
1607
|
+
}
|
|
1608
|
+
function $a(t, e, r, n, a, i) {
|
|
1609
|
+
var s = w();
|
|
1610
|
+
try {
|
|
1611
|
+
return $(t)(e, r, n, a, i);
|
|
1612
|
+
} catch (u) {
|
|
1613
|
+
if (g(s), u !== u + 0) throw u;
|
|
1614
|
+
m(1, 0);
|
|
1663
1615
|
}
|
|
1664
1616
|
}
|
|
1665
|
-
function
|
|
1666
|
-
var p =
|
|
1617
|
+
function ba(t, e, r, n, a, i, s, u, c, d) {
|
|
1618
|
+
var p = w();
|
|
1667
1619
|
try {
|
|
1668
|
-
return
|
|
1620
|
+
return $(t)(e, r, n, a, i, s, u, c, d);
|
|
1669
1621
|
} catch (v) {
|
|
1670
|
-
if (
|
|
1671
|
-
|
|
1622
|
+
if (g(p), v !== v + 0) throw v;
|
|
1623
|
+
m(1, 0);
|
|
1672
1624
|
}
|
|
1673
1625
|
}
|
|
1674
|
-
function
|
|
1675
|
-
var n =
|
|
1626
|
+
function Ca(t, e, r) {
|
|
1627
|
+
var n = w();
|
|
1676
1628
|
try {
|
|
1677
|
-
return
|
|
1629
|
+
return $(t)(e, r);
|
|
1678
1630
|
} catch (a) {
|
|
1679
|
-
if (
|
|
1680
|
-
|
|
1631
|
+
if (g(n), a !== a + 0) throw a;
|
|
1632
|
+
m(1, 0);
|
|
1681
1633
|
}
|
|
1682
1634
|
}
|
|
1683
|
-
function
|
|
1684
|
-
var i =
|
|
1635
|
+
function Ta(t, e, r, n, a) {
|
|
1636
|
+
var i = w();
|
|
1685
1637
|
try {
|
|
1686
|
-
return
|
|
1687
|
-
} catch (
|
|
1688
|
-
if (
|
|
1689
|
-
|
|
1638
|
+
return $(t)(e, r, n, a);
|
|
1639
|
+
} catch (s) {
|
|
1640
|
+
if (g(i), s !== s + 0) throw s;
|
|
1641
|
+
m(1, 0);
|
|
1690
1642
|
}
|
|
1691
1643
|
}
|
|
1692
|
-
function
|
|
1693
|
-
var p =
|
|
1644
|
+
function Ea(t, e, r, n, a, i, s, u, c, d) {
|
|
1645
|
+
var p = w();
|
|
1694
1646
|
try {
|
|
1695
|
-
|
|
1647
|
+
$(t)(e, r, n, a, i, s, u, c, d);
|
|
1696
1648
|
} catch (v) {
|
|
1697
|
-
if (
|
|
1698
|
-
|
|
1649
|
+
if (g(p), v !== v + 0) throw v;
|
|
1650
|
+
m(1, 0);
|
|
1699
1651
|
}
|
|
1700
1652
|
}
|
|
1701
|
-
function
|
|
1702
|
-
var
|
|
1653
|
+
function Pa(t, e, r, n, a, i, s) {
|
|
1654
|
+
var u = w();
|
|
1703
1655
|
try {
|
|
1704
|
-
|
|
1656
|
+
$(t)(e, r, n, a, i, s);
|
|
1705
1657
|
} catch (c) {
|
|
1706
|
-
if (
|
|
1707
|
-
|
|
1658
|
+
if (g(u), c !== c + 0) throw c;
|
|
1659
|
+
m(1, 0);
|
|
1708
1660
|
}
|
|
1709
1661
|
}
|
|
1710
|
-
function
|
|
1711
|
-
var a =
|
|
1662
|
+
function Oa(t, e, r, n) {
|
|
1663
|
+
var a = w();
|
|
1712
1664
|
try {
|
|
1713
|
-
return
|
|
1665
|
+
return $(t)(e, r, n);
|
|
1714
1666
|
} catch (i) {
|
|
1715
|
-
if (
|
|
1716
|
-
|
|
1667
|
+
if (g(a), i !== i + 0) throw i;
|
|
1668
|
+
m(1, 0);
|
|
1717
1669
|
}
|
|
1718
1670
|
}
|
|
1719
|
-
function
|
|
1720
|
-
var
|
|
1671
|
+
function _a(t, e, r, n, a, i, s, u, c, d, p, v) {
|
|
1672
|
+
var y = w();
|
|
1721
1673
|
try {
|
|
1722
|
-
return
|
|
1723
|
-
} catch (
|
|
1724
|
-
if (
|
|
1725
|
-
|
|
1674
|
+
return $(t)(e, r, n, a, i, s, u, c, d, p, v);
|
|
1675
|
+
} catch (T) {
|
|
1676
|
+
if (g(y), T !== T + 0) throw T;
|
|
1677
|
+
m(1, 0);
|
|
1726
1678
|
}
|
|
1727
1679
|
}
|
|
1728
|
-
function
|
|
1729
|
-
var
|
|
1680
|
+
function xa(t, e, r, n, a, i, s) {
|
|
1681
|
+
var u = w();
|
|
1730
1682
|
try {
|
|
1731
|
-
return
|
|
1683
|
+
return Me(t, e, r, n, a, i, s);
|
|
1732
1684
|
} catch (c) {
|
|
1733
|
-
if (
|
|
1734
|
-
|
|
1685
|
+
if (g(u), c !== c + 0) throw c;
|
|
1686
|
+
m(1, 0);
|
|
1735
1687
|
}
|
|
1736
1688
|
}
|
|
1737
|
-
function
|
|
1738
|
-
var i =
|
|
1689
|
+
function Sa(t, e, r, n, a) {
|
|
1690
|
+
var i = w();
|
|
1739
1691
|
try {
|
|
1740
|
-
return
|
|
1741
|
-
} catch (
|
|
1742
|
-
if (
|
|
1743
|
-
|
|
1692
|
+
return Ae(t, e, r, n, a);
|
|
1693
|
+
} catch (s) {
|
|
1694
|
+
if (g(i), s !== s + 0) throw s;
|
|
1695
|
+
m(1, 0);
|
|
1744
1696
|
}
|
|
1745
1697
|
}
|
|
1746
|
-
function
|
|
1747
|
-
|
|
1748
|
-
|
|
1749
|
-
|
|
1750
|
-
|
|
1751
|
-
if (Qe(), Z > 0) {
|
|
1752
|
-
ct = Zt;
|
|
1753
|
-
return;
|
|
1754
|
-
}
|
|
1755
|
-
function e() {
|
|
1756
|
-
var t;
|
|
1757
|
-
f.calledRun = !0, !te && (Je(), C(f), (t = f.onRuntimeInitialized) === null || t === void 0 || t.call(f), Ke());
|
|
1698
|
+
function Ia() {
|
|
1699
|
+
ar();
|
|
1700
|
+
function t() {
|
|
1701
|
+
var e, r;
|
|
1702
|
+
f.calledRun = !0, !ht && (or(), (e = Qt) === null || e === void 0 || e(f), (r = f.onRuntimeInitialized) === null || r === void 0 || r.call(f), ir());
|
|
1758
1703
|
}
|
|
1759
1704
|
f.setStatus ? (f.setStatus("Running..."), setTimeout(() => {
|
|
1760
|
-
setTimeout(() => f.setStatus(""), 1),
|
|
1761
|
-
}, 1)) :
|
|
1705
|
+
setTimeout(() => f.setStatus(""), 1), t();
|
|
1706
|
+
}, 1)) : t();
|
|
1762
1707
|
}
|
|
1763
|
-
|
|
1764
|
-
|
|
1765
|
-
|
|
1766
|
-
|
|
1767
|
-
}
|
|
1768
|
-
return Ra(), Zt(), l = I, l;
|
|
1769
|
-
};
|
|
1770
|
-
function Ve(o) {
|
|
1771
|
-
return Ue(Kt, o);
|
|
1708
|
+
var lt;
|
|
1709
|
+
return lt = await dr(), Ia(), ee ? l = f : l = new Promise((t, e) => {
|
|
1710
|
+
Qt = t, Jt = e;
|
|
1711
|
+
}), l;
|
|
1772
1712
|
}
|
|
1773
|
-
function
|
|
1774
|
-
return
|
|
1713
|
+
function qe(o) {
|
|
1714
|
+
return Xe(Zt, o);
|
|
1715
|
+
}
|
|
1716
|
+
function mo() {
|
|
1717
|
+
return qa(Zt);
|
|
1775
1718
|
}
|
|
1776
|
-
function
|
|
1777
|
-
|
|
1719
|
+
function go(o) {
|
|
1720
|
+
qe({
|
|
1778
1721
|
overrides: o,
|
|
1779
1722
|
equalityFn: Object.is,
|
|
1780
1723
|
fireImmediately: !1
|
|
1781
1724
|
});
|
|
1782
1725
|
}
|
|
1783
|
-
async function
|
|
1784
|
-
return
|
|
1726
|
+
async function Za(o, l) {
|
|
1727
|
+
return Ya(Zt, o, l);
|
|
1785
1728
|
}
|
|
1786
|
-
const
|
|
1729
|
+
const wo = "85d46f55d7c86a4d09bb04273367408b19c324f582d040d018aecb25a9a82942", Ye = [
|
|
1787
1730
|
["aztec", "Aztec"],
|
|
1788
1731
|
["code_128", "Code128"],
|
|
1789
1732
|
["code_39", "Code39"],
|
|
@@ -1807,47 +1750,47 @@ const _o = "68d20eb8c486afabf49fab6d9fbc5f118df8648ec6200e8039ef8912a169c00c", k
|
|
|
1807
1750
|
["linear_codes", "Linear-Codes"],
|
|
1808
1751
|
["matrix_codes", "Matrix-Codes"],
|
|
1809
1752
|
["any", "Any"]
|
|
1810
|
-
],
|
|
1811
|
-
|
|
1753
|
+
], Qa = [...Ye, ["unknown"]].map((o) => o[0]), Yt = new Map(
|
|
1754
|
+
Ye
|
|
1812
1755
|
);
|
|
1813
|
-
function
|
|
1814
|
-
for (const [l, h] of
|
|
1756
|
+
function Ja(o) {
|
|
1757
|
+
for (const [l, h] of Yt)
|
|
1815
1758
|
if (o === h)
|
|
1816
1759
|
return l;
|
|
1817
1760
|
return "unknown";
|
|
1818
1761
|
}
|
|
1819
|
-
function
|
|
1820
|
-
if (
|
|
1762
|
+
function Ka(o) {
|
|
1763
|
+
if (Ze(o))
|
|
1821
1764
|
return {
|
|
1822
1765
|
width: o.naturalWidth,
|
|
1823
1766
|
height: o.naturalHeight
|
|
1824
1767
|
};
|
|
1825
|
-
if (
|
|
1768
|
+
if (Qe(o))
|
|
1826
1769
|
return {
|
|
1827
1770
|
width: o.width.baseVal.value,
|
|
1828
1771
|
height: o.height.baseVal.value
|
|
1829
1772
|
};
|
|
1830
|
-
if (
|
|
1773
|
+
if (Je(o))
|
|
1831
1774
|
return {
|
|
1832
1775
|
width: o.videoWidth,
|
|
1833
1776
|
height: o.videoHeight
|
|
1834
1777
|
};
|
|
1835
|
-
if (
|
|
1778
|
+
if (tr(o))
|
|
1836
1779
|
return {
|
|
1837
1780
|
width: o.width,
|
|
1838
1781
|
height: o.height
|
|
1839
1782
|
};
|
|
1840
|
-
if (
|
|
1783
|
+
if (rr(o))
|
|
1841
1784
|
return {
|
|
1842
1785
|
width: o.displayWidth,
|
|
1843
1786
|
height: o.displayHeight
|
|
1844
1787
|
};
|
|
1845
|
-
if (
|
|
1788
|
+
if (Ke(o))
|
|
1846
1789
|
return {
|
|
1847
1790
|
width: o.width,
|
|
1848
1791
|
height: o.height
|
|
1849
1792
|
};
|
|
1850
|
-
if (
|
|
1793
|
+
if (er(o))
|
|
1851
1794
|
return {
|
|
1852
1795
|
width: o.width,
|
|
1853
1796
|
height: o.height
|
|
@@ -1856,7 +1799,7 @@ function oo(o) {
|
|
|
1856
1799
|
"The provided value is not of type '(Blob or HTMLCanvasElement or HTMLImageElement or HTMLVideoElement or ImageBitmap or ImageData or OffscreenCanvas or SVGImageElement or VideoFrame)'."
|
|
1857
1800
|
);
|
|
1858
1801
|
}
|
|
1859
|
-
function
|
|
1802
|
+
function Ze(o) {
|
|
1860
1803
|
var l, h;
|
|
1861
1804
|
try {
|
|
1862
1805
|
return o instanceof ((h = (l = o == null ? void 0 : o.ownerDocument) == null ? void 0 : l.defaultView) == null ? void 0 : h.HTMLImageElement);
|
|
@@ -1864,7 +1807,7 @@ function He(o) {
|
|
|
1864
1807
|
return !1;
|
|
1865
1808
|
}
|
|
1866
1809
|
}
|
|
1867
|
-
function
|
|
1810
|
+
function Qe(o) {
|
|
1868
1811
|
var l, h;
|
|
1869
1812
|
try {
|
|
1870
1813
|
return o instanceof ((h = (l = o == null ? void 0 : o.ownerDocument) == null ? void 0 : l.defaultView) == null ? void 0 : h.SVGImageElement);
|
|
@@ -1872,7 +1815,7 @@ function Ne(o) {
|
|
|
1872
1815
|
return !1;
|
|
1873
1816
|
}
|
|
1874
1817
|
}
|
|
1875
|
-
function
|
|
1818
|
+
function Je(o) {
|
|
1876
1819
|
var l, h;
|
|
1877
1820
|
try {
|
|
1878
1821
|
return o instanceof ((h = (l = o == null ? void 0 : o.ownerDocument) == null ? void 0 : l.defaultView) == null ? void 0 : h.HTMLVideoElement);
|
|
@@ -1880,7 +1823,7 @@ function ze(o) {
|
|
|
1880
1823
|
return !1;
|
|
1881
1824
|
}
|
|
1882
1825
|
}
|
|
1883
|
-
function
|
|
1826
|
+
function Ke(o) {
|
|
1884
1827
|
var l, h;
|
|
1885
1828
|
try {
|
|
1886
1829
|
return o instanceof ((h = (l = o == null ? void 0 : o.ownerDocument) == null ? void 0 : l.defaultView) == null ? void 0 : h.HTMLCanvasElement);
|
|
@@ -1888,42 +1831,42 @@ function Ge(o) {
|
|
|
1888
1831
|
return !1;
|
|
1889
1832
|
}
|
|
1890
1833
|
}
|
|
1891
|
-
function
|
|
1834
|
+
function tr(o) {
|
|
1892
1835
|
try {
|
|
1893
1836
|
return o instanceof ImageBitmap || Object.prototype.toString.call(o) === "[object ImageBitmap]";
|
|
1894
1837
|
} catch {
|
|
1895
1838
|
return !1;
|
|
1896
1839
|
}
|
|
1897
1840
|
}
|
|
1898
|
-
function
|
|
1841
|
+
function er(o) {
|
|
1899
1842
|
try {
|
|
1900
1843
|
return o instanceof OffscreenCanvas || Object.prototype.toString.call(o) === "[object OffscreenCanvas]";
|
|
1901
1844
|
} catch {
|
|
1902
1845
|
return !1;
|
|
1903
1846
|
}
|
|
1904
1847
|
}
|
|
1905
|
-
function
|
|
1848
|
+
function rr(o) {
|
|
1906
1849
|
try {
|
|
1907
1850
|
return o instanceof VideoFrame || Object.prototype.toString.call(o) === "[object VideoFrame]";
|
|
1908
1851
|
} catch {
|
|
1909
1852
|
return !1;
|
|
1910
1853
|
}
|
|
1911
1854
|
}
|
|
1912
|
-
function
|
|
1855
|
+
function to(o) {
|
|
1913
1856
|
try {
|
|
1914
1857
|
return o instanceof Blob || Object.prototype.toString.call(o) === "[object Blob]";
|
|
1915
1858
|
} catch {
|
|
1916
1859
|
return !1;
|
|
1917
1860
|
}
|
|
1918
1861
|
}
|
|
1919
|
-
function
|
|
1862
|
+
function eo(o) {
|
|
1920
1863
|
try {
|
|
1921
1864
|
return o instanceof ImageData || Object.prototype.toString.call(o) === "[object ImageData]";
|
|
1922
1865
|
} catch {
|
|
1923
1866
|
return !1;
|
|
1924
1867
|
}
|
|
1925
1868
|
}
|
|
1926
|
-
function
|
|
1869
|
+
function ro(o, l) {
|
|
1927
1870
|
try {
|
|
1928
1871
|
const h = new OffscreenCanvas(o, l);
|
|
1929
1872
|
if (h.getContext("2d") instanceof OffscreenCanvasRenderingContext2D)
|
|
@@ -1934,38 +1877,38 @@ function uo(o, l) {
|
|
|
1934
1877
|
return h.width = o, h.height = l, h;
|
|
1935
1878
|
}
|
|
1936
1879
|
}
|
|
1937
|
-
async function
|
|
1938
|
-
if (
|
|
1880
|
+
async function nr(o) {
|
|
1881
|
+
if (Ze(o) && !await io(o))
|
|
1939
1882
|
throw new DOMException(
|
|
1940
1883
|
"Failed to load or decode HTMLImageElement.",
|
|
1941
1884
|
"InvalidStateError"
|
|
1942
1885
|
);
|
|
1943
|
-
if (
|
|
1886
|
+
if (Qe(o) && !await so(o))
|
|
1944
1887
|
throw new DOMException(
|
|
1945
1888
|
"Failed to load or decode SVGImageElement.",
|
|
1946
1889
|
"InvalidStateError"
|
|
1947
1890
|
);
|
|
1948
|
-
if (
|
|
1891
|
+
if (rr(o) && uo(o))
|
|
1949
1892
|
throw new DOMException("VideoFrame is closed.", "InvalidStateError");
|
|
1950
|
-
if (
|
|
1893
|
+
if (Je(o) && (o.readyState === 0 || o.readyState === 1))
|
|
1951
1894
|
throw new DOMException("Invalid element or state.", "InvalidStateError");
|
|
1952
|
-
if (
|
|
1895
|
+
if (tr(o) && lo(o))
|
|
1953
1896
|
throw new DOMException(
|
|
1954
1897
|
"The image source is detached.",
|
|
1955
1898
|
"InvalidStateError"
|
|
1956
1899
|
);
|
|
1957
|
-
const { width: l, height: h } =
|
|
1900
|
+
const { width: l, height: h } = Ka(o);
|
|
1958
1901
|
if (l === 0 || h === 0)
|
|
1959
1902
|
return null;
|
|
1960
|
-
const
|
|
1961
|
-
|
|
1903
|
+
const f = ro(l, h).getContext("2d");
|
|
1904
|
+
f.drawImage(o, 0, 0);
|
|
1962
1905
|
try {
|
|
1963
|
-
return
|
|
1906
|
+
return f.getImageData(0, 0, l, h);
|
|
1964
1907
|
} catch {
|
|
1965
1908
|
throw new DOMException("Source would taint origin.", "SecurityError");
|
|
1966
1909
|
}
|
|
1967
1910
|
}
|
|
1968
|
-
async function
|
|
1911
|
+
async function no(o) {
|
|
1969
1912
|
let l;
|
|
1970
1913
|
try {
|
|
1971
1914
|
l = await createImageBitmap(o);
|
|
@@ -1973,11 +1916,11 @@ async function co(o) {
|
|
|
1973
1916
|
try {
|
|
1974
1917
|
if (globalThis.Image) {
|
|
1975
1918
|
l = new Image();
|
|
1976
|
-
let
|
|
1919
|
+
let f = "";
|
|
1977
1920
|
try {
|
|
1978
|
-
|
|
1921
|
+
f = URL.createObjectURL(o), l.src = f, await l.decode();
|
|
1979
1922
|
} finally {
|
|
1980
|
-
URL.revokeObjectURL(
|
|
1923
|
+
URL.revokeObjectURL(f);
|
|
1981
1924
|
}
|
|
1982
1925
|
} else
|
|
1983
1926
|
return o;
|
|
@@ -1988,40 +1931,40 @@ async function co(o) {
|
|
|
1988
1931
|
);
|
|
1989
1932
|
}
|
|
1990
1933
|
}
|
|
1991
|
-
return await
|
|
1934
|
+
return await nr(l);
|
|
1992
1935
|
}
|
|
1993
|
-
function
|
|
1936
|
+
function ao(o) {
|
|
1994
1937
|
const { width: l, height: h } = o;
|
|
1995
1938
|
if (l === 0 || h === 0)
|
|
1996
1939
|
return null;
|
|
1997
|
-
const
|
|
1940
|
+
const b = o.getContext("2d");
|
|
1998
1941
|
try {
|
|
1999
|
-
return
|
|
1942
|
+
return b.getImageData(0, 0, l, h);
|
|
2000
1943
|
} catch {
|
|
2001
1944
|
throw new DOMException("Source would taint origin.", "SecurityError");
|
|
2002
1945
|
}
|
|
2003
1946
|
}
|
|
2004
|
-
async function
|
|
2005
|
-
if (
|
|
2006
|
-
return await
|
|
2007
|
-
if (
|
|
2008
|
-
if (
|
|
1947
|
+
async function oo(o) {
|
|
1948
|
+
if (to(o))
|
|
1949
|
+
return await no(o);
|
|
1950
|
+
if (eo(o)) {
|
|
1951
|
+
if (co(o))
|
|
2009
1952
|
throw new DOMException(
|
|
2010
1953
|
"The image data has been detached.",
|
|
2011
1954
|
"InvalidStateError"
|
|
2012
1955
|
);
|
|
2013
1956
|
return o;
|
|
2014
1957
|
}
|
|
2015
|
-
return
|
|
1958
|
+
return Ke(o) || er(o) ? ao(o) : await nr(o);
|
|
2016
1959
|
}
|
|
2017
|
-
async function
|
|
1960
|
+
async function io(o) {
|
|
2018
1961
|
try {
|
|
2019
1962
|
return await o.decode(), !0;
|
|
2020
1963
|
} catch {
|
|
2021
1964
|
return !1;
|
|
2022
1965
|
}
|
|
2023
1966
|
}
|
|
2024
|
-
async function
|
|
1967
|
+
async function so(o) {
|
|
2025
1968
|
var l;
|
|
2026
1969
|
try {
|
|
2027
1970
|
return await ((l = o.decode) == null ? void 0 : l.call(o)), !0;
|
|
@@ -2029,122 +1972,122 @@ async function po(o) {
|
|
|
2029
1972
|
return !1;
|
|
2030
1973
|
}
|
|
2031
1974
|
}
|
|
2032
|
-
function
|
|
1975
|
+
function uo(o) {
|
|
2033
1976
|
return o.format === null;
|
|
2034
1977
|
}
|
|
2035
|
-
function
|
|
1978
|
+
function co(o) {
|
|
2036
1979
|
return o.data.buffer.byteLength === 0;
|
|
2037
1980
|
}
|
|
2038
|
-
function
|
|
1981
|
+
function lo(o) {
|
|
2039
1982
|
return o.width === 0 && o.height === 0;
|
|
2040
1983
|
}
|
|
2041
|
-
function
|
|
2042
|
-
return
|
|
1984
|
+
function Ge(o, l) {
|
|
1985
|
+
return fo(o) ? new DOMException(`${l}: ${o.message}`, o.name) : ho(o) ? new o.constructor(`${l}: ${o.message}`) : new Error(`${l}: ${o}`);
|
|
2043
1986
|
}
|
|
2044
|
-
function
|
|
1987
|
+
function fo(o) {
|
|
2045
1988
|
return o instanceof DOMException || Object.prototype.toString.call(o) === "[object DOMException]";
|
|
2046
1989
|
}
|
|
2047
|
-
function
|
|
1990
|
+
function ho(o) {
|
|
2048
1991
|
return o instanceof Error || Object.prototype.toString.call(o) === "[object Error]";
|
|
2049
1992
|
}
|
|
2050
|
-
var
|
|
2051
|
-
class
|
|
1993
|
+
var ft;
|
|
1994
|
+
class $o {
|
|
2052
1995
|
constructor(l = {}) {
|
|
2053
|
-
|
|
1996
|
+
He(this, ft);
|
|
2054
1997
|
var h;
|
|
2055
1998
|
try {
|
|
2056
|
-
const
|
|
2057
|
-
(
|
|
1999
|
+
const b = (h = l == null ? void 0 : l.formats) == null ? void 0 : h.filter(
|
|
2000
|
+
(f) => f !== "unknown"
|
|
2058
2001
|
);
|
|
2059
|
-
if ((
|
|
2002
|
+
if ((b == null ? void 0 : b.length) === 0)
|
|
2060
2003
|
throw new TypeError("Hint option provided, but is empty.");
|
|
2061
|
-
for (const
|
|
2062
|
-
if (!
|
|
2004
|
+
for (const f of b != null ? b : [])
|
|
2005
|
+
if (!Yt.has(f))
|
|
2063
2006
|
throw new TypeError(
|
|
2064
|
-
`Failed to read the 'formats' property from 'BarcodeDetectorOptions': The provided value '${
|
|
2007
|
+
`Failed to read the 'formats' property from 'BarcodeDetectorOptions': The provided value '${f}' is not a valid enum value of type BarcodeFormat.`
|
|
2065
2008
|
);
|
|
2066
|
-
|
|
2009
|
+
ke(this, ft, b != null ? b : []), qe({ fireImmediately: !0 }).catch(() => {
|
|
2067
2010
|
});
|
|
2068
|
-
} catch (
|
|
2069
|
-
throw
|
|
2070
|
-
|
|
2011
|
+
} catch (b) {
|
|
2012
|
+
throw Ge(
|
|
2013
|
+
b,
|
|
2071
2014
|
"Failed to construct 'BarcodeDetector'"
|
|
2072
2015
|
);
|
|
2073
2016
|
}
|
|
2074
2017
|
}
|
|
2075
2018
|
static async getSupportedFormats() {
|
|
2076
|
-
return
|
|
2019
|
+
return Qa.filter((l) => l !== "unknown");
|
|
2077
2020
|
}
|
|
2078
2021
|
async detect(l) {
|
|
2079
2022
|
try {
|
|
2080
|
-
const h = await
|
|
2023
|
+
const h = await oo(l);
|
|
2081
2024
|
if (h === null)
|
|
2082
2025
|
return [];
|
|
2083
|
-
let
|
|
2084
|
-
const
|
|
2026
|
+
let b;
|
|
2027
|
+
const f = {
|
|
2085
2028
|
tryCode39ExtendedMode: !1,
|
|
2086
2029
|
textMode: "Plain",
|
|
2087
|
-
formats:
|
|
2030
|
+
formats: We(this, ft).map((I) => Yt.get(I))
|
|
2088
2031
|
};
|
|
2089
2032
|
try {
|
|
2090
|
-
|
|
2091
|
-
} catch (
|
|
2092
|
-
throw console.error(
|
|
2033
|
+
b = await Za(h, f);
|
|
2034
|
+
} catch (I) {
|
|
2035
|
+
throw console.error(I), new DOMException(
|
|
2093
2036
|
"Barcode detection service unavailable.",
|
|
2094
2037
|
"NotSupportedError"
|
|
2095
2038
|
);
|
|
2096
2039
|
}
|
|
2097
|
-
return
|
|
2040
|
+
return b.map((I) => {
|
|
2098
2041
|
const {
|
|
2099
|
-
topLeft: { x:
|
|
2100
|
-
topRight: { x, y:
|
|
2101
|
-
bottomLeft: { x:
|
|
2102
|
-
bottomRight: { x:
|
|
2103
|
-
} =
|
|
2042
|
+
topLeft: { x: D, y: M },
|
|
2043
|
+
topRight: { x: _, y: A },
|
|
2044
|
+
bottomLeft: { x: U, y: X },
|
|
2045
|
+
bottomRight: { x: tt, y: q }
|
|
2046
|
+
} = I.position, nt = Math.min(D, _, U, tt), V = Math.min(M, A, X, q), Y = Math.max(D, _, U, tt), ht = Math.max(M, A, X, q);
|
|
2104
2047
|
return {
|
|
2105
2048
|
boundingBox: new DOMRectReadOnly(
|
|
2106
|
-
|
|
2107
|
-
|
|
2108
|
-
|
|
2109
|
-
|
|
2049
|
+
nt,
|
|
2050
|
+
V,
|
|
2051
|
+
Y - nt,
|
|
2052
|
+
ht - V
|
|
2110
2053
|
),
|
|
2111
|
-
rawValue:
|
|
2112
|
-
format:
|
|
2054
|
+
rawValue: I.text,
|
|
2055
|
+
format: Ja(I.format),
|
|
2113
2056
|
cornerPoints: [
|
|
2114
2057
|
{
|
|
2115
|
-
x:
|
|
2116
|
-
y:
|
|
2058
|
+
x: D,
|
|
2059
|
+
y: M
|
|
2117
2060
|
},
|
|
2118
2061
|
{
|
|
2119
|
-
x,
|
|
2120
|
-
y:
|
|
2062
|
+
x: _,
|
|
2063
|
+
y: A
|
|
2121
2064
|
},
|
|
2122
2065
|
{
|
|
2123
|
-
x:
|
|
2124
|
-
y:
|
|
2066
|
+
x: tt,
|
|
2067
|
+
y: q
|
|
2125
2068
|
},
|
|
2126
2069
|
{
|
|
2127
|
-
x:
|
|
2070
|
+
x: U,
|
|
2128
2071
|
y: X
|
|
2129
2072
|
}
|
|
2130
2073
|
]
|
|
2131
2074
|
};
|
|
2132
2075
|
});
|
|
2133
2076
|
} catch (h) {
|
|
2134
|
-
throw
|
|
2077
|
+
throw Ge(
|
|
2135
2078
|
h,
|
|
2136
2079
|
"Failed to execute 'detect' on 'BarcodeDetector'"
|
|
2137
2080
|
);
|
|
2138
2081
|
}
|
|
2139
2082
|
}
|
|
2140
2083
|
}
|
|
2141
|
-
|
|
2084
|
+
ft = new WeakMap();
|
|
2142
2085
|
export {
|
|
2143
|
-
|
|
2144
|
-
|
|
2145
|
-
|
|
2146
|
-
|
|
2147
|
-
|
|
2148
|
-
|
|
2149
|
-
|
|
2086
|
+
$o as BarcodeDetector,
|
|
2087
|
+
yo as ZXING_CPP_COMMIT,
|
|
2088
|
+
wo as ZXING_WASM_SHA256,
|
|
2089
|
+
vo as ZXING_WASM_VERSION,
|
|
2090
|
+
qe as prepareZXingModule,
|
|
2091
|
+
mo as purgeZXingModule,
|
|
2092
|
+
go as setZXingModuleOverrides
|
|
2150
2093
|
};
|