libav-wasm 0.6.1 → 0.7.0
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 +61 -61
- package/build/index.js +1 -1
- package/build/libav.wasm +0 -0
- package/build/worker.js +1661 -1475
- package/package.json +41 -41
package/build/worker.js
CHANGED
|
@@ -1,406 +1,592 @@
|
|
|
1
|
-
const
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
return
|
|
28
|
-
},
|
|
29
|
-
const
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
const
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
1
|
+
const Ke = "__OSRA_KEY__", Ca = "__OSRA_DEFAULT_KEY__", qe = "__OSRA_BOX__", Ta = () => {
|
|
2
|
+
const n = /* @__PURE__ */ new Map(), c = {
|
|
3
|
+
getUniqueUuid: () => {
|
|
4
|
+
let f = globalThis.crypto.randomUUID();
|
|
5
|
+
for (; n.has(f); )
|
|
6
|
+
f = globalThis.crypto.randomUUID();
|
|
7
|
+
return f;
|
|
8
|
+
},
|
|
9
|
+
set: (f, y) => {
|
|
10
|
+
n.set(f, { uuid: f, ...y });
|
|
11
|
+
},
|
|
12
|
+
alloc: (f = c.getUniqueUuid(), y) => {
|
|
13
|
+
if (y)
|
|
14
|
+
return n.set(f, { uuid: f, ...y }), { uuid: f, ...y };
|
|
15
|
+
const b = new MessageChannel(), m = {
|
|
16
|
+
uuid: f,
|
|
17
|
+
port1: b.port1,
|
|
18
|
+
port2: b.port2
|
|
19
|
+
};
|
|
20
|
+
return n.set(f, m), m;
|
|
21
|
+
},
|
|
22
|
+
has: (f) => n.has(f),
|
|
23
|
+
get: (f) => n.get(f),
|
|
24
|
+
free: (f) => n.delete(f),
|
|
25
|
+
getOrAlloc: (f = c.getUniqueUuid(), y) => c.get(f) || c.alloc(f, y)
|
|
26
|
+
};
|
|
27
|
+
return c;
|
|
28
|
+
}, mr = (n, c) => Pa(n) && n[Ke] === c, Ea = ({ listener: n, transport: c, remoteName: f, key: y = Ke, unregisterSignal: b }) => {
|
|
29
|
+
const m = (a) => {
|
|
30
|
+
if (typeof a == "function")
|
|
31
|
+
a(n);
|
|
32
|
+
else if (Qe(a) || mt(a) || ht(a)) {
|
|
33
|
+
const M = (F, H) => {
|
|
34
|
+
const O = (j, V) => {
|
|
35
|
+
mr(j, y) && (f && j.name !== f || n(j, { port: H, sender: V }));
|
|
36
|
+
};
|
|
37
|
+
F.addListener(O), b && b.addEventListener(
|
|
38
|
+
"abort",
|
|
39
|
+
() => F.removeListener(O)
|
|
40
|
+
);
|
|
41
|
+
};
|
|
42
|
+
if (mt(a)) {
|
|
43
|
+
const F = (H) => {
|
|
44
|
+
M(H.onMessage, H);
|
|
45
|
+
};
|
|
46
|
+
a.addListener(F), b && b.addEventListener(
|
|
47
|
+
"abort",
|
|
48
|
+
() => a.removeListener(F)
|
|
49
|
+
);
|
|
50
|
+
} else ht(a) ? M(a) : M(a.onMessage);
|
|
51
|
+
} else {
|
|
52
|
+
const M = (F) => {
|
|
53
|
+
mr(F.data, y) && (f && F.data.name !== f || n(F.data, { receiveTransport: a, source: F.source }));
|
|
54
|
+
};
|
|
55
|
+
a.addEventListener("message", M), b && b.addEventListener(
|
|
56
|
+
"abort",
|
|
57
|
+
() => a.removeEventListener("message", M)
|
|
58
|
+
);
|
|
59
|
+
}
|
|
60
|
+
};
|
|
61
|
+
Pt(c) ? m(c.receive) : m(c);
|
|
62
|
+
}, Aa = (n, c, f = "*", y = []) => {
|
|
63
|
+
const b = (m) => {
|
|
64
|
+
typeof m == "function" ? m(c, y) : Qe(m) ? m.postMessage(c) : $t(m) ? m.postMessage(c, f, y) : Tt(m) ? m.send(JSON.stringify(c)) : Et(m) ? m.port.postMessage(c, y) : m.postMessage(c, y);
|
|
65
|
+
};
|
|
66
|
+
Pt(n) ? b(n.emit) : b(n);
|
|
67
|
+
}, Sa = [
|
|
68
|
+
Int8Array,
|
|
69
|
+
Uint8Array,
|
|
70
|
+
Uint8ClampedArray,
|
|
71
|
+
Int16Array,
|
|
72
|
+
Uint16Array,
|
|
73
|
+
Int32Array,
|
|
74
|
+
Uint32Array,
|
|
75
|
+
Float16Array,
|
|
76
|
+
Float32Array,
|
|
77
|
+
Float64Array,
|
|
78
|
+
BigInt64Array,
|
|
79
|
+
BigUint64Array
|
|
80
|
+
];
|
|
81
|
+
new Float16Array(), new BigInt64Array(), new BigUint64Array();
|
|
82
|
+
const Fa = (n) => {
|
|
83
|
+
const c = n instanceof Int8Array ? "Int8Array" : n instanceof Uint8Array ? "Uint8Array" : n instanceof Uint8ClampedArray ? "Uint8ClampedArray" : n instanceof Int16Array ? "Int16Array" : n instanceof Uint16Array ? "Uint16Array" : n instanceof Int32Array ? "Int32Array" : n instanceof Uint32Array ? "Uint32Array" : n instanceof Float16Array ? "Float16Array" : n instanceof Float32Array ? "Float32Array" : n instanceof Float64Array ? "Float64Array" : n instanceof BigInt64Array ? "BigInt64Array" : n instanceof BigUint64Array ? "BigUint64Array" : void 0;
|
|
84
|
+
if (c === void 0) throw new Error("Unknown typed array type");
|
|
85
|
+
return c;
|
|
86
|
+
}, Ia = (n) => {
|
|
87
|
+
const c = n === "Int8Array" ? Int8Array : n === "Uint8Array" ? Uint8Array : n === "Uint8ClampedArray" ? Uint8ClampedArray : n === "Int16Array" ? Int16Array : n === "Uint16Array" ? Uint16Array : n === "Int32Array" ? Int32Array : n === "Uint32Array" ? Uint32Array : n === "Float16Array" ? Float16Array : n === "Float32Array" ? Float32Array : n === "Float64Array" ? Float64Array : n === "BigInt64Array" ? BigInt64Array : n === "BigUint64Array" ? BigUint64Array : void 0;
|
|
88
|
+
if (c === void 0) throw new Error("Unknown typed array type");
|
|
89
|
+
return c;
|
|
90
|
+
}, Ct = (n) => Sa.some((c) => n instanceof c), Tt = (n) => n instanceof WebSocket, br = (n) => globalThis.ServiceWorkerContainer && n instanceof ServiceWorkerContainer, wr = (n) => n instanceof Worker, Cr = (n) => globalThis.DedicatedWorkerGlobalScope && n instanceof DedicatedWorkerGlobalScope, Et = (n) => globalThis.SharedWorker && n instanceof SharedWorker, Me = (n) => n instanceof MessagePort, At = (n) => n instanceof Promise, St = (n) => typeof n == "function", _t = (n) => n instanceof ArrayBuffer, Ue = (n) => n instanceof ReadableStream, Ft = (n) => n instanceof Date, It = (n) => n instanceof Error, $a = (n) => St(n) || At(n) || Ct(n) || Ft(n) || It(n), Pa = (n) => !!(n && typeof n == "object" && n[Ke]), ka = (n) => !!(globalThis.SharedArrayBuffer && n instanceof globalThis.SharedArrayBuffer), Tr = (n) => globalThis.ArrayBuffer && n instanceof globalThis.ArrayBuffer || globalThis.MessagePort && n instanceof globalThis.MessagePort || globalThis.ReadableStream && n instanceof globalThis.ReadableStream || globalThis.WritableStream && n instanceof globalThis.WritableStream || globalThis.TransformStream && n instanceof globalThis.TransformStream ? !0 : !!(globalThis.ImageBitmap && n instanceof globalThis.ImageBitmap), Qe = (n, c = !1) => !!(n && typeof n == "object" && n.name && n.disconnect && n.postMessage && (!c || n.sender && n.onMessage && n.onDisconnect)), mt = (n) => !!(n && typeof n == "object" && n.addListener && n.hasListener && n.removeListener), ht = (n) => !!(n && typeof n == "object" && n.addListener && n.hasListener && n.removeListener), $t = (n) => !!(n && typeof n == "object" && n.document && n.location && n.navigator && n.screen && n.history), Er = (n) => Tt(n) || Qe(n), Ar = (n) => Tt(n) || Qe(n) || mt(n) || ht(n), Ua = (n) => Er(n) || Ar(n), Je = (n) => Er(n) || $t(n) || br(n) || wr(n) || Cr(n) || Et(n) || Me(n) || Sr(n), bt = (n) => Ar(n) || $t(n) || br(n) || wr(n) || Cr(n) || Et(n) || Me(n) || Fr(n), Sr = (n) => !!(n && typeof n == "object" && "emit" in n && (Je(n.emit) || typeof n.emit == "function")), Fr = (n) => !!(n && typeof n == "object" && "receive" in n && (bt(n.receive) || typeof n.receive == "function")), Pt = (n) => Sr(n) || Fr(n), Ir = (n) => Me(n) || St(n) || At(n) || Ct(n) || _t(n) || Ue(n) || Ft(n) || It(n), q = (n) => n && typeof n == "object" && qe in n && n[qe] === "revivable", Ma = (n) => q(n) && n.type === "messagePort", kt = (n) => q(n) && n.type === "promise", Ra = (n) => q(n) && n.type === "function", Da = (n) => q(n) && n.type === "typedArray", La = (n) => q(n) && n.type === "arrayBuffer", Oa = (n) => q(n) && n.type === "readableStream", xa = (n) => q(n) && n.type === "error", ja = (n) => q(n) && n.type === "date", ce = (n) => {
|
|
91
|
+
const c = [], f = (y) => ka(y) ? void 0 : Tr(y) ? c.push(y) : Array.isArray(y) ? y.map(f) : y && typeof y == "object" ? Object.values(y).map(f) : void 0;
|
|
92
|
+
return f(n), c;
|
|
93
|
+
}, Xe = (n, c = !1) => {
|
|
94
|
+
const { port1: f, port2: y } = new MessageChannel(), b = new Promise(
|
|
95
|
+
(m) => f.addEventListener(
|
|
96
|
+
"message",
|
|
97
|
+
(a) => m(a.data)
|
|
98
|
+
)
|
|
99
|
+
);
|
|
100
|
+
return f.start(), y.postMessage(n, c ? ce(n) : []), b;
|
|
101
|
+
}, Na = async () => {
|
|
102
|
+
const { port1: n } = new MessageChannel();
|
|
103
|
+
return await Xe(n, !0) instanceof MessagePort;
|
|
104
|
+
}, Wa = async () => {
|
|
105
|
+
const n = new ArrayBuffer(1);
|
|
106
|
+
return await Xe(n) instanceof ArrayBuffer;
|
|
107
|
+
}, Ba = async () => {
|
|
108
|
+
const n = new ArrayBuffer(1);
|
|
109
|
+
return await Xe(n, !0) instanceof ArrayBuffer;
|
|
110
|
+
}, Ha = async () => {
|
|
111
|
+
const n = new ReadableStream({
|
|
112
|
+
start(c) {
|
|
113
|
+
c.enqueue(new Uint8Array(1)), c.close();
|
|
114
|
+
}
|
|
38
115
|
});
|
|
39
|
-
return
|
|
40
|
-
},
|
|
41
|
-
const
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
116
|
+
return await Xe(n, !0) instanceof ReadableStream;
|
|
117
|
+
}, Va = async () => {
|
|
118
|
+
const [
|
|
119
|
+
n,
|
|
120
|
+
c,
|
|
121
|
+
f,
|
|
122
|
+
y
|
|
123
|
+
] = await Promise.all([
|
|
124
|
+
Na().catch(() => !1),
|
|
125
|
+
Wa().catch(() => !1),
|
|
126
|
+
Ba().catch(() => !1),
|
|
127
|
+
Ha().catch(() => !1)
|
|
128
|
+
]);
|
|
129
|
+
return {
|
|
130
|
+
jsonOnly: !n && !c && !f && !y,
|
|
131
|
+
messagePort: n,
|
|
132
|
+
arrayBuffer: c,
|
|
133
|
+
transferable: f,
|
|
134
|
+
transferableStream: y
|
|
50
135
|
};
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
stack: c.stack
|
|
71
|
-
}), la = (c, _) => ({
|
|
72
|
-
[be]: !0,
|
|
73
|
-
type: "messagePort",
|
|
74
|
-
..._.envCheck.supportsPorts ? { port: c } : { portId: _.addOutgoingProxiedMessagePort(c) }
|
|
75
|
-
}), da = (c, _) => {
|
|
76
|
-
const { port1: u, port2: b } = new MessageChannel(), R = (D) => {
|
|
77
|
-
const n = ye(D, _), N = Ge(n);
|
|
78
|
-
u.postMessage(n, { transfer: N }), u.close();
|
|
136
|
+
}, Ya = (n, c) => {
|
|
137
|
+
const f = n, { uuid: y } = c.messageChannels.alloc(void 0, { port1: f });
|
|
138
|
+
return f.addEventListener("message", ({ data: b }) => {
|
|
139
|
+
c.sendMessage({
|
|
140
|
+
type: "message",
|
|
141
|
+
remoteUuid: c.remoteUuid,
|
|
142
|
+
data: q(b) ? b : re(b, c),
|
|
143
|
+
portId: y
|
|
144
|
+
});
|
|
145
|
+
}), f.start(), c.eventTarget.addEventListener("message", function b({ detail: m }) {
|
|
146
|
+
if (m.type === "message-port-close") {
|
|
147
|
+
if (m.portId !== y) return;
|
|
148
|
+
c.eventTarget.removeEventListener("message", b), f.close(), c.messageChannels.free(y);
|
|
149
|
+
return;
|
|
150
|
+
}
|
|
151
|
+
m.type !== "message" || m.portId !== y || f.postMessage(m.data, ce(m.data));
|
|
152
|
+
}), {
|
|
153
|
+
type: "messagePort",
|
|
154
|
+
portId: y
|
|
79
155
|
};
|
|
80
|
-
|
|
81
|
-
|
|
156
|
+
}, za = (n, c) => {
|
|
157
|
+
const { port1: f, port2: y } = new MessageChannel();
|
|
158
|
+
y.addEventListener("message", ({ data: a }) => {
|
|
159
|
+
c.sendMessage({
|
|
160
|
+
type: "message",
|
|
161
|
+
remoteUuid: c.remoteUuid,
|
|
162
|
+
data: q(a) ? a : re(a, c),
|
|
163
|
+
portId: n.portId
|
|
164
|
+
});
|
|
165
|
+
}), y.start();
|
|
166
|
+
const b = c.messageChannels.get(n.portId), { port1: m } = b || c.messageChannels.alloc(n.portId);
|
|
167
|
+
return m.addEventListener("message", function a({ data: M }) {
|
|
168
|
+
if (M.type === "message-port-close") {
|
|
169
|
+
if (M.portId !== n.portId) return;
|
|
170
|
+
m.removeEventListener("message", a), y.close(), c.messageChannels.free(n.portId);
|
|
171
|
+
return;
|
|
172
|
+
}
|
|
173
|
+
if (!(M.type !== "message" || M.portId !== n.portId))
|
|
174
|
+
if (c.messagePorts.has(f))
|
|
175
|
+
y.postMessage(M.data);
|
|
176
|
+
else {
|
|
177
|
+
const F = le(M.data, c);
|
|
178
|
+
y.postMessage(F, ce(F));
|
|
179
|
+
}
|
|
180
|
+
}), m.start(), f;
|
|
181
|
+
}, Ga = (n, c) => {
|
|
182
|
+
const { port1: f, port2: y } = new MessageChannel();
|
|
183
|
+
c.messagePorts.add(y);
|
|
184
|
+
const b = (m) => {
|
|
185
|
+
const a = re(m, c);
|
|
186
|
+
f.postMessage(a, ce(a)), f.close();
|
|
187
|
+
};
|
|
188
|
+
return n.then((m) => b({ type: "resolve", data: m })).catch((m) => b({ type: "reject", error: m.stack })), {
|
|
82
189
|
type: "promise",
|
|
83
|
-
port:
|
|
190
|
+
port: y
|
|
84
191
|
};
|
|
85
|
-
},
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
192
|
+
}, Ja = (n, c) => (c.messagePorts.add(n.port), new Promise((f, y) => {
|
|
193
|
+
n.port.addEventListener("message", ({ data: b }) => {
|
|
194
|
+
const m = le(b, c);
|
|
195
|
+
m.type === "resolve" ? f(m.data) : y(m.error), n.port.close();
|
|
196
|
+
}, { once: !0 }), n.port.start();
|
|
197
|
+
})), qa = (n, c) => {
|
|
198
|
+
const { port1: f, port2: y } = new MessageChannel();
|
|
199
|
+
return c.messagePorts.add(y), f.addEventListener("message", ({ data: b }) => {
|
|
200
|
+
const [m, a] = le(b, c), M = (async () => n(...a))(), F = re(M, c);
|
|
201
|
+
m.postMessage(F, ce(F));
|
|
202
|
+
}), f.start(), {
|
|
92
203
|
type: "function",
|
|
93
|
-
port:
|
|
204
|
+
port: y
|
|
205
|
+
};
|
|
206
|
+
}, Ka = (n, c) => (...f) => new Promise((y, b) => {
|
|
207
|
+
const { port1: m, port2: a } = new MessageChannel();
|
|
208
|
+
c.messagePorts.add(a);
|
|
209
|
+
const M = re([a, f], c);
|
|
210
|
+
n.port.postMessage(M, ce(M)), m.addEventListener("message", ({ data: F }) => {
|
|
211
|
+
if (!kt(F)) throw new Error("Proxied function did not return a promise");
|
|
212
|
+
le(F, c).then(y).catch(b).finally(() => m.close());
|
|
213
|
+
}), m.start();
|
|
214
|
+
}), Qa = (n, c) => ({
|
|
215
|
+
type: "typedArray",
|
|
216
|
+
typedArrayType: Fa(n),
|
|
217
|
+
arrayBuffer: n.buffer
|
|
218
|
+
}), Xa = (n, c) => {
|
|
219
|
+
const f = Ia(n.typedArrayType);
|
|
220
|
+
return new f(n.arrayBuffer);
|
|
221
|
+
}, Za = (n, c) => ({
|
|
222
|
+
type: "arrayBuffer",
|
|
223
|
+
base64Buffer: new Uint8Array(n).toBase64()
|
|
224
|
+
}), eo = (n, c) => Uint8Array.fromBase64(n.base64Buffer).buffer, to = (n, c) => ({
|
|
225
|
+
type: "error",
|
|
226
|
+
message: n.message,
|
|
227
|
+
stack: n.stack || n.toString()
|
|
228
|
+
}), ro = (n, c) => new Error(n.message, { cause: n.stack }), hr = (n, c) => {
|
|
229
|
+
const { port1: f, port2: y } = new MessageChannel();
|
|
230
|
+
c.messagePorts.add(y);
|
|
231
|
+
const b = n.getReader();
|
|
232
|
+
return f.addEventListener("message", async ({ data: m }) => {
|
|
233
|
+
const { type: a } = le(m, c);
|
|
234
|
+
if (a === "pull") {
|
|
235
|
+
const M = b.read(), F = re(M, c);
|
|
236
|
+
f.postMessage(F, ce(F));
|
|
237
|
+
} else
|
|
238
|
+
b.cancel(), f.close();
|
|
239
|
+
}), f.start(), {
|
|
240
|
+
type: "readableStream",
|
|
241
|
+
port: y
|
|
94
242
|
};
|
|
95
|
-
},
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
(
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
243
|
+
}, no = (n, c) => (c.messagePorts.add(n.port), n.port.start(), new ReadableStream({
|
|
244
|
+
start(f) {
|
|
245
|
+
},
|
|
246
|
+
pull(f) {
|
|
247
|
+
return new Promise((y, b) => {
|
|
248
|
+
n.port.addEventListener("message", async ({ data: m }) => {
|
|
249
|
+
if (!kt(m)) throw new Error("Proxied function did not return a promise");
|
|
250
|
+
le(m, c).then((a) => {
|
|
251
|
+
a.done ? f.close() : f.enqueue(a.value), y();
|
|
252
|
+
}).catch(b);
|
|
253
|
+
}, { once: !0 }), n.port.postMessage(re({ type: "pull" }, c));
|
|
254
|
+
});
|
|
255
|
+
},
|
|
256
|
+
cancel() {
|
|
257
|
+
n.port.postMessage(re({ type: "cancel" }, c)), n.port.close();
|
|
108
258
|
}
|
|
109
|
-
),
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
]
|
|
114
|
-
) : c,
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
259
|
+
})), io = (n, c) => ({
|
|
260
|
+
type: "date",
|
|
261
|
+
ISOString: n.toISOString()
|
|
262
|
+
}), ao = (n, c) => new Date(n.ISOString), oo = (n, c) => $a(n) || Ue(n) && !c.platformCapabilities.transferableStream ? {
|
|
263
|
+
[qe]: "revivable",
|
|
264
|
+
...St(n) ? qa(n, c) : At(n) ? Ga(n, c) : Ct(n) ? Qa(n) : Ue(n) ? hr(n, c) : Ft(n) ? io(n) : It(n) ? to(n) : n
|
|
265
|
+
} : {
|
|
266
|
+
[qe]: "revivable",
|
|
267
|
+
..."isJson" in c.transport && c.transport.isJson ? Me(n) ? Ya(n, c) : _t(n) ? Za(n) : Ue(n) ? hr(n, c) : { type: "unknown", value: n } : {
|
|
268
|
+
type: Me(n) ? "messagePort" : _t(n) ? "arrayBuffer" : Ue(n) ? "readableStream" : "unknown",
|
|
269
|
+
value: n
|
|
270
|
+
}
|
|
271
|
+
}, re = (n, c) => {
|
|
272
|
+
const f = Ir(n) ? oo(n, c) : n;
|
|
273
|
+
return Array.isArray(f) ? f.map((y) => re(y, c)) : f && typeof f == "object" && Object.getPrototypeOf(f) === Object.prototype ? Object.fromEntries(
|
|
274
|
+
Object.entries(f).map(([y, b]) => [
|
|
275
|
+
y,
|
|
276
|
+
q(f) && f.type === "messagePort" && f.value instanceof MessagePort || q(f) && f.type === "arrayBuffer" && f.value instanceof ArrayBuffer || q(f) && f.type === "readableStream" && f.value instanceof ReadableStream ? b : re(b, c)
|
|
277
|
+
])
|
|
278
|
+
) : f;
|
|
279
|
+
}, so = (n, c) => Ir(n.value) ? n.value : Ma(n) ? za(n, c) : Ra(n) ? Ka(n, c) : kt(n) ? Ja(n, c) : xa(n) ? ro(n) : Da(n) ? Xa(n) : La(n) ? eo(n) : Oa(n) ? no(n, c) : ja(n) ? ao(n) : n, le = (n, c) => {
|
|
280
|
+
const f = Tr(n) ? n : Array.isArray(n) ? n.map((y) => le(y, c)) : n && typeof n == "object" ? Object.fromEntries(
|
|
281
|
+
Object.entries(n).map(([y, b]) => [
|
|
282
|
+
y,
|
|
283
|
+
le(b, c)
|
|
284
|
+
])
|
|
285
|
+
) : n;
|
|
286
|
+
return q(f) ? so(f, c) : f;
|
|
287
|
+
}, lo = ({ transport: n, value: c, uuid: f, remoteUuid: y, platformCapabilities: b, eventTarget: m, send: a, close: M }) => {
|
|
288
|
+
const F = {
|
|
289
|
+
platformCapabilities: b,
|
|
290
|
+
transport: n,
|
|
291
|
+
remoteUuid: y,
|
|
292
|
+
messagePorts: /* @__PURE__ */ new Set(),
|
|
293
|
+
messageChannels: Ta(),
|
|
294
|
+
sendMessage: a,
|
|
295
|
+
eventTarget: m
|
|
130
296
|
};
|
|
131
|
-
|
|
132
|
-
const
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
297
|
+
let H;
|
|
298
|
+
const O = new Promise((j, V) => {
|
|
299
|
+
H = j;
|
|
300
|
+
});
|
|
301
|
+
return m.addEventListener("message", ({ detail: j }) => {
|
|
302
|
+
if (j.type === "init") {
|
|
303
|
+
H(j);
|
|
304
|
+
return;
|
|
305
|
+
} else j.type === "message" && F.messageChannels.getOrAlloc(j.portId).port2?.postMessage(j);
|
|
306
|
+
}), a({
|
|
307
|
+
type: "init",
|
|
308
|
+
remoteUuid: y,
|
|
309
|
+
data: re(c, F)
|
|
310
|
+
}), {
|
|
311
|
+
revivableContext: F,
|
|
312
|
+
close: () => {
|
|
137
313
|
},
|
|
138
|
-
|
|
139
|
-
free: (u) => {
|
|
140
|
-
_.delete(u), c.free(u);
|
|
141
|
-
}
|
|
314
|
+
remoteValue: O.then((j) => le(j.data, F))
|
|
142
315
|
};
|
|
143
|
-
},
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
316
|
+
}, co = ({ value: n, uuid: c, platformCapabilities: f, send: y, close: b }) => ({
|
|
317
|
+
close: () => {
|
|
318
|
+
},
|
|
319
|
+
remoteValueProxy: new Proxy(
|
|
320
|
+
new Function(),
|
|
321
|
+
{
|
|
322
|
+
apply: (m, a, M) => {
|
|
323
|
+
},
|
|
324
|
+
get: (m, a) => {
|
|
325
|
+
}
|
|
326
|
+
}
|
|
327
|
+
)
|
|
328
|
+
});
|
|
329
|
+
var uo = class extends EventTarget {
|
|
330
|
+
dispatchTypedEvent(n, c) {
|
|
331
|
+
return super.dispatchEvent(c);
|
|
332
|
+
}
|
|
333
|
+
};
|
|
334
|
+
const fo = async (n, {
|
|
335
|
+
transport: c,
|
|
336
|
+
name: f,
|
|
337
|
+
remoteName: y,
|
|
338
|
+
key: b = Ca,
|
|
339
|
+
origin: m = "*",
|
|
340
|
+
unregisterSignal: a,
|
|
341
|
+
platformCapabilities: M,
|
|
342
|
+
transferAll: F,
|
|
343
|
+
logger: H
|
|
148
344
|
}) => {
|
|
149
|
-
const
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
}
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
[Re]: !0,
|
|
166
|
-
key: b,
|
|
167
|
-
type: "message",
|
|
168
|
-
portId: `${D}/${O}`,
|
|
169
|
-
data: ye(f.data, E())
|
|
170
|
-
},
|
|
171
|
-
[]
|
|
172
|
-
);
|
|
173
|
-
}), T.addEventListener("close", () => {
|
|
174
|
-
W.free(O), L(
|
|
175
|
-
{
|
|
176
|
-
[Re]: !0,
|
|
177
|
-
key: b,
|
|
178
|
-
type: "port-closed",
|
|
179
|
-
portId: `${D}/${O}`
|
|
180
|
-
},
|
|
181
|
-
[]
|
|
182
|
-
);
|
|
183
|
-
}), `${D}/${O}`;
|
|
184
|
-
}, E = () => {
|
|
185
|
-
if (!n) throw new Error("Osra context was accessed before the ready message was received.");
|
|
186
|
-
return {
|
|
187
|
-
addIncomingProxiedMessagePort: ae,
|
|
188
|
-
addOutgoingProxiedMessagePort: de,
|
|
189
|
-
envCheck: n,
|
|
190
|
-
finalizationRegistry: N
|
|
191
|
-
};
|
|
192
|
-
};
|
|
193
|
-
let h;
|
|
194
|
-
const $ = new Promise((T, O) => {
|
|
195
|
-
h = T;
|
|
196
|
-
}), I = () => {
|
|
197
|
-
const T = new ArrayBuffer(1), { port1: O } = new MessageChannel();
|
|
198
|
-
L(
|
|
345
|
+
const O = {
|
|
346
|
+
isJson: "isJson" in c && c.isJson !== void 0 ? c.isJson : Ua(c),
|
|
347
|
+
...Pt(c) ? c : {
|
|
348
|
+
emit: c,
|
|
349
|
+
receive: c
|
|
350
|
+
}
|
|
351
|
+
}, j = M ?? await Va(), V = /* @__PURE__ */ new Map();
|
|
352
|
+
let P;
|
|
353
|
+
const T = new Promise((C) => {
|
|
354
|
+
P = C;
|
|
355
|
+
});
|
|
356
|
+
let A = globalThis.crypto.randomUUID();
|
|
357
|
+
const I = (C, W) => {
|
|
358
|
+
const N = ce(W);
|
|
359
|
+
Aa(
|
|
360
|
+
C,
|
|
199
361
|
{
|
|
200
|
-
[
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
362
|
+
[Ke]: b,
|
|
363
|
+
name: f,
|
|
364
|
+
uuid: A,
|
|
365
|
+
...W
|
|
204
366
|
},
|
|
205
|
-
|
|
367
|
+
m,
|
|
368
|
+
N
|
|
206
369
|
);
|
|
207
|
-
}
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
} else
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
370
|
+
}, $ = async (C, W) => {
|
|
371
|
+
if (C.uuid !== A) {
|
|
372
|
+
if (!Je(O))
|
|
373
|
+
throw new Error("Unidirectional receiving mode not implemented");
|
|
374
|
+
if (C.type === "announce") {
|
|
375
|
+
if (!C.remoteUuid) {
|
|
376
|
+
I(O, { type: "announce", remoteUuid: C.uuid });
|
|
377
|
+
return;
|
|
378
|
+
}
|
|
379
|
+
if (C.remoteUuid !== A) return;
|
|
380
|
+
if (V.has(C.uuid)) {
|
|
381
|
+
I(
|
|
382
|
+
O,
|
|
383
|
+
{ type: "reject-uuid-taken", remoteUuid: C.uuid }
|
|
384
|
+
);
|
|
385
|
+
return;
|
|
386
|
+
}
|
|
387
|
+
const N = new uo(), Re = {
|
|
388
|
+
type: "bidirectional",
|
|
389
|
+
eventTarget: N,
|
|
390
|
+
connection: lo({
|
|
391
|
+
transport: O,
|
|
392
|
+
value: n,
|
|
393
|
+
uuid: A,
|
|
394
|
+
remoteUuid: C.uuid,
|
|
395
|
+
platformCapabilities: j,
|
|
396
|
+
eventTarget: N,
|
|
397
|
+
send: (g) => I(O, g),
|
|
398
|
+
close: () => void V.delete(C.uuid)
|
|
399
|
+
})
|
|
400
|
+
};
|
|
401
|
+
V.set(C.uuid, Re), Re.connection.remoteValue.then(
|
|
402
|
+
(g) => P(g)
|
|
403
|
+
);
|
|
404
|
+
} else if (C.type === "reject-uuid-taken") {
|
|
405
|
+
if (C.remoteUuid !== A) return;
|
|
406
|
+
A = globalThis.crypto.randomUUID(), I(O, { type: "announce" });
|
|
407
|
+
} else if (C.type === "close") {
|
|
408
|
+
if (C.remoteUuid !== A) return;
|
|
409
|
+
const N = V.get(C.uuid);
|
|
410
|
+
if (!N) {
|
|
411
|
+
console.warn(`Connection not found for remoteUuid: ${C.uuid}`);
|
|
412
|
+
return;
|
|
413
|
+
}
|
|
414
|
+
N.connection.close(), V.delete(C.uuid);
|
|
415
|
+
} else {
|
|
416
|
+
if (C.remoteUuid !== A) return;
|
|
417
|
+
const N = V.get(C.uuid);
|
|
418
|
+
if (!N) {
|
|
419
|
+
console.warn(`Connection not found for remoteUuid: ${C.uuid}`);
|
|
420
|
+
return;
|
|
421
|
+
}
|
|
422
|
+
N.type !== "unidirectional-emitting" && N.eventTarget.dispatchTypedEvent(
|
|
423
|
+
"message",
|
|
424
|
+
new CustomEvent("message", { detail: C })
|
|
425
|
+
);
|
|
256
426
|
}
|
|
257
427
|
}
|
|
258
|
-
}
|
|
259
|
-
|
|
428
|
+
};
|
|
429
|
+
if (bt(O) && Ea({
|
|
430
|
+
listener: $,
|
|
431
|
+
transport: O,
|
|
432
|
+
remoteName: y,
|
|
433
|
+
key: b,
|
|
434
|
+
unregisterSignal: a
|
|
435
|
+
}), Je(O) && I(O, { type: "announce" }), Je(O) && !bt(O)) {
|
|
436
|
+
const { remoteValueProxy: C } = co({
|
|
437
|
+
value: n,
|
|
438
|
+
uuid: A,
|
|
439
|
+
platformCapabilities: j,
|
|
440
|
+
send: (W) => I(O, W),
|
|
441
|
+
close: () => V.delete(A)
|
|
442
|
+
});
|
|
443
|
+
return C;
|
|
444
|
+
}
|
|
445
|
+
return T;
|
|
260
446
|
};
|
|
261
|
-
var
|
|
447
|
+
var wt = {}, po = {
|
|
262
448
|
get exports() {
|
|
263
|
-
return
|
|
449
|
+
return wt;
|
|
264
450
|
},
|
|
265
|
-
set exports(
|
|
266
|
-
|
|
451
|
+
set exports(n) {
|
|
452
|
+
wt = n;
|
|
267
453
|
}
|
|
268
454
|
};
|
|
269
|
-
(function(
|
|
270
|
-
var
|
|
271
|
-
var
|
|
272
|
-
return async function(
|
|
273
|
-
var
|
|
274
|
-
|
|
275
|
-
}),
|
|
276
|
-
throw
|
|
277
|
-
},
|
|
278
|
-
function
|
|
279
|
-
return
|
|
455
|
+
(function(n, c) {
|
|
456
|
+
var f = (() => {
|
|
457
|
+
var y = typeof document < "u" ? document.currentScript?.src : void 0;
|
|
458
|
+
return async function(b = {}) {
|
|
459
|
+
var m, a = b, M, F, H = new Promise((e, t) => {
|
|
460
|
+
M = e, F = t;
|
|
461
|
+
}), O = Object.assign({}, a), j = "./this.program", V = (e, t) => {
|
|
462
|
+
throw t;
|
|
463
|
+
}, P = "";
|
|
464
|
+
function T(e) {
|
|
465
|
+
return a.locateFile ? a.locateFile(e, P) : P + e;
|
|
280
466
|
}
|
|
281
|
-
var
|
|
467
|
+
var A;
|
|
282
468
|
{
|
|
283
|
-
if (typeof document < "u" && document.currentScript && (
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
var
|
|
287
|
-
if (
|
|
288
|
-
return
|
|
289
|
-
throw new Error(
|
|
469
|
+
if (typeof document < "u" && document.currentScript && (P = document.currentScript.src), y && (P = y), P.startsWith("blob:") ? P = "" : P = P.slice(0, P.replace(/[?#].*/, "").lastIndexOf("/") + 1), !(typeof window == "object" || typeof WorkerGlobalScope < "u")) throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
|
|
470
|
+
A = async (e) => {
|
|
471
|
+
g(!Dt(e), "readAsync does not work with file:// URLs");
|
|
472
|
+
var t = await fetch(e, { credentials: "same-origin" });
|
|
473
|
+
if (t.ok)
|
|
474
|
+
return t.arrayBuffer();
|
|
475
|
+
throw new Error(t.status + " : " + t.url);
|
|
290
476
|
};
|
|
291
477
|
}
|
|
292
|
-
var I =
|
|
293
|
-
Object.assign(
|
|
294
|
-
var
|
|
295
|
-
ue("wasmBinary", "wasmBinary"), typeof WebAssembly != "object" &&
|
|
296
|
-
var
|
|
297
|
-
function
|
|
298
|
-
e ||
|
|
478
|
+
var I = a.print || console.log.bind(console), $ = a.printErr || console.error.bind(console);
|
|
479
|
+
Object.assign(a, O), O = null, da(), a.arguments && a.arguments, ue("arguments", "arguments_"), a.thisProgram && (j = a.thisProgram), ue("thisProgram", "thisProgram"), g(typeof a.memoryInitializerPrefixURL > "u", "Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead"), g(typeof a.pthreadMainPrefixURL > "u", "Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead"), g(typeof a.cdInitializerPrefixURL > "u", "Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead"), g(typeof a.filePackagePrefixURL > "u", "Module.filePackagePrefixURL option was removed, use Module.locateFile instead"), g(typeof a.read > "u", "Module.read option was removed"), g(typeof a.readAsync > "u", "Module.readAsync option was removed (modify readAsync in JS)"), g(typeof a.readBinary > "u", "Module.readBinary option was removed (modify readBinary in JS)"), g(typeof a.setWindowTitle > "u", "Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)"), g(typeof a.TOTAL_MEMORY > "u", "Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY"), ue("asm", "wasmExports"), ue("readAsync", "readAsync"), ue("readBinary", "readBinary"), ue("setWindowTitle", "setWindowTitle"), g(!0, "worker environment detected but not enabled at build time. Add `worker` to `-sENVIRONMENT` to enable."), g(!0, "node environment detected but not enabled at build time. Add `node` to `-sENVIRONMENT` to enable."), g(!0, "shell environment detected but not enabled at build time. Add `shell` to `-sENVIRONMENT` to enable.");
|
|
480
|
+
var C = a.wasmBinary;
|
|
481
|
+
ue("wasmBinary", "wasmBinary"), typeof WebAssembly != "object" && $("no native wasm support detected");
|
|
482
|
+
var W, N = !1, Re;
|
|
483
|
+
function g(e, t) {
|
|
484
|
+
e || L("Assertion failed" + (t ? ": " + t : ""));
|
|
299
485
|
}
|
|
300
|
-
var
|
|
301
|
-
function
|
|
302
|
-
var e =
|
|
303
|
-
|
|
486
|
+
var ne, K, ge, De, E, k, Ut, be, Mt, Rt, Ze = !1, Dt = (e) => e.startsWith("file://");
|
|
487
|
+
function $r() {
|
|
488
|
+
var e = Ge();
|
|
489
|
+
g((e & 3) == 0), e == 0 && (e += 4), k[e >> 2] = 34821223, S(34821223), k[e + 4 >> 2] = 2310721022, S(2310721022), k[0] = 1668509029, S(1668509029);
|
|
304
490
|
}
|
|
305
|
-
function
|
|
306
|
-
if (!
|
|
307
|
-
var e =
|
|
491
|
+
function Le() {
|
|
492
|
+
if (!N) {
|
|
493
|
+
var e = Ge();
|
|
308
494
|
e == 0 && (e += 4);
|
|
309
|
-
var
|
|
310
|
-
(
|
|
495
|
+
var t = k[e >> 2], r = k[e + 4 >> 2];
|
|
496
|
+
(t != 34821223 || r != 2310721022) && L(`Stack overflow! Stack cookie has been overwritten at ${oe(e)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${oe(r)} ${oe(t)}`), k[0] != 1668509029 && L("Runtime error: The application has corrupted its heap memory area (address zero)!");
|
|
311
497
|
}
|
|
312
498
|
}
|
|
313
499
|
if ((() => {
|
|
314
|
-
var e = new Int16Array(1),
|
|
315
|
-
if (e[0] = 25459,
|
|
316
|
-
})(),
|
|
500
|
+
var e = new Int16Array(1), t = new Int8Array(e.buffer);
|
|
501
|
+
if (e[0] = 25459, t[0] !== 115 || t[1] !== 99) throw "Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)";
|
|
502
|
+
})(), a.ENVIRONMENT)
|
|
317
503
|
throw new Error("Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)");
|
|
318
|
-
function ue(e,
|
|
319
|
-
Object.getOwnPropertyDescriptor(
|
|
504
|
+
function ue(e, t, r = !0) {
|
|
505
|
+
Object.getOwnPropertyDescriptor(a, e) || Object.defineProperty(a, e, {
|
|
320
506
|
configurable: !0,
|
|
321
507
|
get() {
|
|
322
|
-
let i =
|
|
323
|
-
|
|
508
|
+
let i = r ? " (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)" : "";
|
|
509
|
+
L(`\`Module.${e}\` has been replaced by \`${t}\`` + i);
|
|
324
510
|
}
|
|
325
511
|
});
|
|
326
512
|
}
|
|
327
|
-
function
|
|
328
|
-
Object.getOwnPropertyDescriptor(
|
|
513
|
+
function Pr(e) {
|
|
514
|
+
Object.getOwnPropertyDescriptor(a, e) && L(`\`Module.${e}\` was supplied but \`${e}\` not included in INCOMING_MODULE_JS_API`);
|
|
329
515
|
}
|
|
330
|
-
function
|
|
516
|
+
function kr(e) {
|
|
331
517
|
return e === "FS_createPath" || e === "FS_createDataFile" || e === "FS_createPreloadedFile" || e === "FS_unlink" || e === "addRunDependency" || // The old FS has some functionality that WasmFS lacks.
|
|
332
518
|
e === "FS_createLazyFile" || e === "FS_createDevice" || e === "removeRunDependency";
|
|
333
519
|
}
|
|
334
|
-
function
|
|
335
|
-
|
|
520
|
+
function Ur(e) {
|
|
521
|
+
Lt(e);
|
|
336
522
|
}
|
|
337
|
-
function
|
|
338
|
-
Object.getOwnPropertyDescriptor(
|
|
523
|
+
function Lt(e) {
|
|
524
|
+
Object.getOwnPropertyDescriptor(a, e) || Object.defineProperty(a, e, {
|
|
339
525
|
configurable: !0,
|
|
340
526
|
get() {
|
|
341
|
-
var
|
|
342
|
-
|
|
527
|
+
var t = `'${e}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`;
|
|
528
|
+
kr(e) && (t += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you"), L(t);
|
|
343
529
|
}
|
|
344
530
|
});
|
|
345
531
|
}
|
|
346
|
-
var
|
|
347
|
-
function
|
|
348
|
-
|
|
532
|
+
var Mr = 2 ** 8 - 1, Rr = 2 ** 16 - 1, Dr = 2 ** 32 - 1, Lr = 2 ** 64 - 1, Or = -128, xr = -32768, jr = -2147483648, Nr = -9223372036854776e3;
|
|
533
|
+
function Oe(e, t, r, i) {
|
|
534
|
+
g(Number.isInteger(Number(e)), `attempt to write non-integer (${e}) into integer heap`), g(e <= i, `value (${e}) too large to write as ${t}-bit value`), g(e >= r, `value (${e}) too small to write as ${t}-bit value`);
|
|
349
535
|
}
|
|
350
|
-
var
|
|
351
|
-
function
|
|
536
|
+
var we = (e) => Oe(e, 8, Or, Mr), et = (e) => Oe(e, 16, xr, Rr), S = (e) => Oe(e, 32, jr, Dr), tt = (e) => Oe(e, 64, Nr, Lr);
|
|
537
|
+
function Wr(...e) {
|
|
352
538
|
console.warn(...e);
|
|
353
539
|
}
|
|
354
|
-
function
|
|
355
|
-
var e =
|
|
356
|
-
|
|
540
|
+
function Ot() {
|
|
541
|
+
var e = W.buffer;
|
|
542
|
+
a.HEAP8 = ne = new Int8Array(e), a.HEAP16 = ge = new Int16Array(e), a.HEAPU8 = K = new Uint8Array(e), a.HEAPU16 = De = new Uint16Array(e), a.HEAP32 = E = new Int32Array(e), a.HEAPU32 = k = new Uint32Array(e), a.HEAPF32 = Ut = new Float32Array(e), a.HEAPF64 = Rt = new Float64Array(e), a.HEAP64 = be = new BigInt64Array(e), a.HEAPU64 = Mt = new BigUint64Array(e);
|
|
357
543
|
}
|
|
358
|
-
|
|
544
|
+
g(!a.STACK_SIZE, "STACK_SIZE can no longer be set at runtime. Use -sSTACK_SIZE at link time"), g(
|
|
359
545
|
typeof Int32Array < "u" && typeof Float64Array < "u" && Int32Array.prototype.subarray != null && Int32Array.prototype.set != null,
|
|
360
546
|
"JS engine does not provide full typed array support"
|
|
361
|
-
),
|
|
362
|
-
function
|
|
363
|
-
if (
|
|
364
|
-
for (typeof
|
|
365
|
-
|
|
366
|
-
|
|
547
|
+
), g(!a.wasmMemory, "Use of `wasmMemory` detected. Use -sIMPORTED_MEMORY to define wasmMemory externally"), g(!a.INITIAL_MEMORY, "Detected runtime INITIAL_MEMORY setting. Use -sIMPORTED_MEMORY to define wasmMemory dynamically");
|
|
548
|
+
function Br() {
|
|
549
|
+
if (a.preRun)
|
|
550
|
+
for (typeof a.preRun == "function" && (a.preRun = [a.preRun]); a.preRun.length; )
|
|
551
|
+
rn(a.preRun.shift());
|
|
552
|
+
xt(Nt);
|
|
367
553
|
}
|
|
368
|
-
function
|
|
369
|
-
|
|
554
|
+
function Hr() {
|
|
555
|
+
g(!Ze), Ze = !0, Le(), nn(), B.__wasm_call_ctors();
|
|
370
556
|
}
|
|
371
|
-
function
|
|
372
|
-
if (
|
|
373
|
-
for (typeof
|
|
374
|
-
|
|
375
|
-
|
|
557
|
+
function Vr() {
|
|
558
|
+
if (Le(), a.postRun)
|
|
559
|
+
for (typeof a.postRun == "function" && (a.postRun = [a.postRun]); a.postRun.length; )
|
|
560
|
+
tn(a.postRun.shift());
|
|
561
|
+
xt(jt);
|
|
376
562
|
}
|
|
377
|
-
var fe = 0,
|
|
378
|
-
function
|
|
379
|
-
fe++,
|
|
380
|
-
if (
|
|
381
|
-
clearInterval(
|
|
563
|
+
var fe = 0, Ce = null, Te = {}, pe = null;
|
|
564
|
+
function Yr(e) {
|
|
565
|
+
fe++, a.monitorRunDependencies?.(fe), g(!Te[e]), Te[e] = 1, pe === null && typeof setInterval < "u" && (pe = setInterval(() => {
|
|
566
|
+
if (N) {
|
|
567
|
+
clearInterval(pe), pe = null;
|
|
382
568
|
return;
|
|
383
569
|
}
|
|
384
|
-
var
|
|
385
|
-
for (var
|
|
386
|
-
|
|
387
|
-
|
|
570
|
+
var t = !1;
|
|
571
|
+
for (var r in Te)
|
|
572
|
+
t || (t = !0, $("still waiting on run dependencies:")), $(`dependency: ${r}`);
|
|
573
|
+
t && $("(end of list)");
|
|
388
574
|
}, 1e4));
|
|
389
575
|
}
|
|
390
|
-
function
|
|
391
|
-
if (fe--,
|
|
392
|
-
var
|
|
393
|
-
|
|
576
|
+
function zr(e) {
|
|
577
|
+
if (fe--, a.monitorRunDependencies?.(fe), g(Te[e]), delete Te[e], fe == 0 && (pe !== null && (clearInterval(pe), pe = null), Ce)) {
|
|
578
|
+
var t = Ce;
|
|
579
|
+
Ce = null, t();
|
|
394
580
|
}
|
|
395
581
|
}
|
|
396
|
-
function
|
|
397
|
-
|
|
398
|
-
var
|
|
399
|
-
throw
|
|
582
|
+
function L(e) {
|
|
583
|
+
a.onAbort?.(e), e = "Aborted(" + e + ")", $(e), N = !0, e.indexOf("RuntimeError: unreachable") >= 0 && (e += '. "unreachable" may be due to ASYNCIFY_STACK_SIZE not being large enough (try increasing it)');
|
|
584
|
+
var t = new WebAssembly.RuntimeError(e);
|
|
585
|
+
throw F(t), t;
|
|
400
586
|
}
|
|
401
587
|
var Z = {
|
|
402
588
|
error() {
|
|
403
|
-
|
|
589
|
+
L("Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with -sFORCE_FILESYSTEM");
|
|
404
590
|
},
|
|
405
591
|
init() {
|
|
406
592
|
Z.error();
|
|
@@ -430,370 +616,370 @@ var pr = {}, pa = {
|
|
|
430
616
|
Z.error();
|
|
431
617
|
}
|
|
432
618
|
};
|
|
433
|
-
|
|
434
|
-
function
|
|
435
|
-
return (...
|
|
436
|
-
|
|
437
|
-
var i =
|
|
438
|
-
return
|
|
619
|
+
a.FS_createDataFile = Z.createDataFile, a.FS_createPreloadedFile = Z.createPreloadedFile;
|
|
620
|
+
function p(e, t) {
|
|
621
|
+
return (...r) => {
|
|
622
|
+
g(Ze, `native function \`${e}\` called before runtime initialization`);
|
|
623
|
+
var i = B[e];
|
|
624
|
+
return g(i, `exported native function \`${e}\` not found`), g(r.length <= t, `native function \`${e}\` called with ${r.length} args but expects ${t}`), i(...r);
|
|
439
625
|
};
|
|
440
626
|
}
|
|
441
|
-
var
|
|
442
|
-
function
|
|
443
|
-
return
|
|
627
|
+
var Ee;
|
|
628
|
+
function Gr() {
|
|
629
|
+
return T("libav.wasm");
|
|
444
630
|
}
|
|
445
|
-
function
|
|
446
|
-
if (e ==
|
|
447
|
-
return new Uint8Array(
|
|
631
|
+
function Jr(e) {
|
|
632
|
+
if (e == Ee && C)
|
|
633
|
+
return new Uint8Array(C);
|
|
448
634
|
throw "both async and sync fetching of the wasm failed";
|
|
449
635
|
}
|
|
450
|
-
async function
|
|
451
|
-
if (!
|
|
636
|
+
async function qr(e) {
|
|
637
|
+
if (!C)
|
|
452
638
|
try {
|
|
453
|
-
var
|
|
454
|
-
return new Uint8Array(
|
|
639
|
+
var t = await A(e);
|
|
640
|
+
return new Uint8Array(t);
|
|
455
641
|
} catch {
|
|
456
642
|
}
|
|
457
|
-
return
|
|
643
|
+
return Jr(e);
|
|
458
644
|
}
|
|
459
|
-
async function
|
|
645
|
+
async function Kr(e, t) {
|
|
460
646
|
try {
|
|
461
|
-
var
|
|
647
|
+
var r = await qr(e), i = await WebAssembly.instantiate(r, t);
|
|
462
648
|
return i;
|
|
463
|
-
} catch (
|
|
464
|
-
|
|
649
|
+
} catch (o) {
|
|
650
|
+
$(`failed to asynchronously prepare wasm: ${o}`), Dt(Ee) && $(`warning: Loading from a file URI (${Ee}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`), L(o);
|
|
465
651
|
}
|
|
466
652
|
}
|
|
467
|
-
async function
|
|
653
|
+
async function Qr(e, t, r) {
|
|
468
654
|
if (!e && typeof WebAssembly.instantiateStreaming == "function")
|
|
469
655
|
try {
|
|
470
|
-
var i = fetch(
|
|
471
|
-
return
|
|
472
|
-
} catch (
|
|
473
|
-
|
|
656
|
+
var i = fetch(t, { credentials: "same-origin" }), o = await WebAssembly.instantiateStreaming(i, r);
|
|
657
|
+
return o;
|
|
658
|
+
} catch (l) {
|
|
659
|
+
$(`wasm streaming compile failed: ${l}`), $("falling back to ArrayBuffer instantiation");
|
|
474
660
|
}
|
|
475
|
-
return
|
|
661
|
+
return Kr(t, r);
|
|
476
662
|
}
|
|
477
|
-
function
|
|
478
|
-
return
|
|
479
|
-
env:
|
|
480
|
-
wasi_snapshot_preview1:
|
|
663
|
+
function Xr() {
|
|
664
|
+
return h.instrumentWasmImports(pt), {
|
|
665
|
+
env: pt,
|
|
666
|
+
wasi_snapshot_preview1: pt
|
|
481
667
|
};
|
|
482
668
|
}
|
|
483
|
-
async function
|
|
484
|
-
function e(
|
|
485
|
-
return
|
|
669
|
+
async function Zr() {
|
|
670
|
+
function e(d, s) {
|
|
671
|
+
return B = d.exports, B = h.instrumentWasmExports(B), W = B.memory, g(W, "memory not found in wasm exports"), Ot(), Xt = B.__indirect_function_table, g(Xt, "table not found in wasm exports"), zr("wasm-instantiate"), B;
|
|
486
672
|
}
|
|
487
|
-
|
|
488
|
-
var
|
|
489
|
-
function
|
|
490
|
-
return
|
|
673
|
+
Yr("wasm-instantiate");
|
|
674
|
+
var t = a;
|
|
675
|
+
function r(d) {
|
|
676
|
+
return g(a === t, "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?"), t = null, e(d.instance);
|
|
491
677
|
}
|
|
492
|
-
var i =
|
|
493
|
-
if (
|
|
494
|
-
return new Promise((
|
|
678
|
+
var i = Xr();
|
|
679
|
+
if (a.instantiateWasm)
|
|
680
|
+
return new Promise((d, s) => {
|
|
495
681
|
try {
|
|
496
|
-
|
|
497
|
-
e(
|
|
682
|
+
a.instantiateWasm(i, (u, v) => {
|
|
683
|
+
e(u, v), d(u.exports);
|
|
498
684
|
});
|
|
499
|
-
} catch (
|
|
500
|
-
|
|
685
|
+
} catch (u) {
|
|
686
|
+
$(`Module.instantiateWasm callback failed with error: ${u}`), s(u);
|
|
501
687
|
}
|
|
502
688
|
});
|
|
503
|
-
|
|
689
|
+
Ee ??= Gr();
|
|
504
690
|
try {
|
|
505
|
-
var
|
|
506
|
-
return
|
|
507
|
-
} catch (
|
|
508
|
-
return
|
|
691
|
+
var o = await Qr(C, Ee, i), l = r(o);
|
|
692
|
+
return l;
|
|
693
|
+
} catch (d) {
|
|
694
|
+
return F(d), Promise.reject(d);
|
|
509
695
|
}
|
|
510
696
|
}
|
|
511
|
-
class
|
|
697
|
+
class en {
|
|
512
698
|
name = "ExitStatus";
|
|
513
|
-
constructor(
|
|
514
|
-
this.message = `Program terminated with exit(${
|
|
699
|
+
constructor(t) {
|
|
700
|
+
this.message = `Program terminated with exit(${t})`, this.status = t;
|
|
515
701
|
}
|
|
516
702
|
}
|
|
517
|
-
var
|
|
703
|
+
var xt = (e) => {
|
|
518
704
|
for (; e.length > 0; )
|
|
519
|
-
e.shift()(
|
|
520
|
-
},
|
|
521
|
-
|
|
522
|
-
var
|
|
523
|
-
var e =
|
|
524
|
-
|
|
525
|
-
},
|
|
526
|
-
|
|
527
|
-
},
|
|
528
|
-
for (var i =
|
|
529
|
-
if (
|
|
530
|
-
return
|
|
531
|
-
for (var
|
|
532
|
-
var
|
|
533
|
-
if (!(
|
|
534
|
-
|
|
705
|
+
e.shift()(a);
|
|
706
|
+
}, jt = [], tn = (e) => jt.unshift(e), Nt = [], rn = (e) => Nt.unshift(e);
|
|
707
|
+
a.noExitRuntime;
|
|
708
|
+
var oe = (e) => (g(typeof e == "number"), e >>>= 0, "0x" + e.toString(16).padStart(8, "0")), nn = () => {
|
|
709
|
+
var e = pr(), t = Ge();
|
|
710
|
+
pa(e, t);
|
|
711
|
+
}, Ae = (e) => {
|
|
712
|
+
Ae.shown ||= {}, Ae.shown[e] || (Ae.shown[e] = 1, $(e));
|
|
713
|
+
}, Wt = typeof TextDecoder < "u" ? new TextDecoder() : void 0, Bt = (e, t = 0, r = NaN) => {
|
|
714
|
+
for (var i = t + r, o = t; e[o] && !(o >= i); ) ++o;
|
|
715
|
+
if (o - t > 16 && e.buffer && Wt)
|
|
716
|
+
return Wt.decode(e.subarray(t, o));
|
|
717
|
+
for (var l = ""; t < o; ) {
|
|
718
|
+
var d = e[t++];
|
|
719
|
+
if (!(d & 128)) {
|
|
720
|
+
l += String.fromCharCode(d);
|
|
535
721
|
continue;
|
|
536
722
|
}
|
|
537
|
-
var
|
|
538
|
-
if ((
|
|
539
|
-
|
|
723
|
+
var s = e[t++] & 63;
|
|
724
|
+
if ((d & 224) == 192) {
|
|
725
|
+
l += String.fromCharCode((d & 31) << 6 | s);
|
|
540
726
|
continue;
|
|
541
727
|
}
|
|
542
|
-
var
|
|
543
|
-
if ((
|
|
544
|
-
|
|
728
|
+
var u = e[t++] & 63;
|
|
729
|
+
if ((d & 240) == 224 ? d = (d & 15) << 12 | s << 6 | u : ((d & 248) != 240 && Ae("Invalid UTF-8 leading byte " + oe(d) + " encountered when deserializing a UTF-8 string in wasm memory to a JS string!"), d = (d & 7) << 18 | s << 12 | u << 6 | e[t++] & 63), d < 65536)
|
|
730
|
+
l += String.fromCharCode(d);
|
|
545
731
|
else {
|
|
546
|
-
var
|
|
547
|
-
|
|
732
|
+
var v = d - 65536;
|
|
733
|
+
l += String.fromCharCode(55296 | v >> 10, 56320 | v & 1023);
|
|
548
734
|
}
|
|
549
735
|
}
|
|
550
|
-
return
|
|
551
|
-
}, xe = (e,
|
|
552
|
-
class
|
|
736
|
+
return l;
|
|
737
|
+
}, xe = (e, t) => (g(typeof e == "number", `UTF8ToString expects a number (got ${typeof e})`), e ? Bt(K, e, t) : ""), an = (e, t, r, i) => L(`Assertion failed: ${xe(e)}, at: ` + [t ? xe(t) : "unknown filename", r, i ? xe(i) : "unknown function"]);
|
|
738
|
+
class on {
|
|
553
739
|
// excPtr - Thrown object pointer to wrap. Metadata pointer is calculated from it.
|
|
554
|
-
constructor(
|
|
555
|
-
this.excPtr =
|
|
740
|
+
constructor(t) {
|
|
741
|
+
this.excPtr = t, this.ptr = t - 24;
|
|
556
742
|
}
|
|
557
|
-
set_type(
|
|
558
|
-
|
|
743
|
+
set_type(t) {
|
|
744
|
+
k[this.ptr + 4 >> 2] = t;
|
|
559
745
|
}
|
|
560
746
|
get_type() {
|
|
561
|
-
return
|
|
747
|
+
return k[this.ptr + 4 >> 2];
|
|
562
748
|
}
|
|
563
|
-
set_destructor(
|
|
564
|
-
|
|
749
|
+
set_destructor(t) {
|
|
750
|
+
k[this.ptr + 8 >> 2] = t;
|
|
565
751
|
}
|
|
566
752
|
get_destructor() {
|
|
567
|
-
return
|
|
753
|
+
return k[this.ptr + 8 >> 2];
|
|
568
754
|
}
|
|
569
|
-
set_caught(
|
|
570
|
-
|
|
755
|
+
set_caught(t) {
|
|
756
|
+
t = t ? 1 : 0, ne[this.ptr + 12] = t, we(t);
|
|
571
757
|
}
|
|
572
758
|
get_caught() {
|
|
573
|
-
return
|
|
759
|
+
return ne[this.ptr + 12] != 0;
|
|
574
760
|
}
|
|
575
|
-
set_rethrown(
|
|
576
|
-
|
|
761
|
+
set_rethrown(t) {
|
|
762
|
+
t = t ? 1 : 0, ne[this.ptr + 13] = t, we(t);
|
|
577
763
|
}
|
|
578
764
|
get_rethrown() {
|
|
579
|
-
return
|
|
765
|
+
return ne[this.ptr + 13] != 0;
|
|
580
766
|
}
|
|
581
767
|
// Initialize native structure fields. Should be called once after allocated.
|
|
582
|
-
init(
|
|
583
|
-
this.set_adjusted_ptr(0), this.set_type(
|
|
768
|
+
init(t, r) {
|
|
769
|
+
this.set_adjusted_ptr(0), this.set_type(t), this.set_destructor(r);
|
|
584
770
|
}
|
|
585
|
-
set_adjusted_ptr(
|
|
586
|
-
|
|
771
|
+
set_adjusted_ptr(t) {
|
|
772
|
+
k[this.ptr + 16 >> 2] = t;
|
|
587
773
|
}
|
|
588
774
|
get_adjusted_ptr() {
|
|
589
|
-
return
|
|
775
|
+
return k[this.ptr + 16 >> 2];
|
|
590
776
|
}
|
|
591
777
|
}
|
|
592
|
-
var
|
|
593
|
-
var i = new
|
|
594
|
-
i.init(
|
|
595
|
-
},
|
|
596
|
-
var
|
|
597
|
-
|
|
598
|
-
},
|
|
599
|
-
|
|
778
|
+
var sn = (e, t, r) => {
|
|
779
|
+
var i = new on(e);
|
|
780
|
+
i.init(t, r), g(!1, "Exception thrown, but exception catching is not enabled. Compile with -sNO_DISABLE_EXCEPTION_CATCHING or -sEXCEPTION_CATCHING_ALLOWED=[..] to catch.");
|
|
781
|
+
}, ln = (e) => {
|
|
782
|
+
var t = pr(), r = Ge();
|
|
783
|
+
L(`stack overflow (Attempt to set SP to ${oe(e)}, with stack limits [${oe(r)} - ${oe(t)}]). If you require more stack space build with -sSTACK_SIZE=<bytes>`);
|
|
784
|
+
}, dn = (e, t, r, i) => {
|
|
785
|
+
L("it should not be possible to operate on streams when !SYSCALLS_REQUIRE_FILESYSTEM");
|
|
600
786
|
};
|
|
601
|
-
function
|
|
787
|
+
function cn(e, t, r) {
|
|
602
788
|
return 0;
|
|
603
789
|
}
|
|
604
|
-
var
|
|
605
|
-
|
|
606
|
-
},
|
|
607
|
-
if (
|
|
790
|
+
var un = (e, t) => {
|
|
791
|
+
L("it should not be possible to operate on streams when !SYSCALLS_REQUIRE_FILESYSTEM");
|
|
792
|
+
}, fn = (e, t, r, i) => {
|
|
793
|
+
if (g(typeof e == "string", `stringToUTF8Array expects a string (got ${typeof e})`), !(i > 0))
|
|
608
794
|
return 0;
|
|
609
|
-
for (var
|
|
610
|
-
var
|
|
611
|
-
if (
|
|
612
|
-
var
|
|
613
|
-
|
|
795
|
+
for (var o = r, l = r + i - 1, d = 0; d < e.length; ++d) {
|
|
796
|
+
var s = e.charCodeAt(d);
|
|
797
|
+
if (s >= 55296 && s <= 57343) {
|
|
798
|
+
var u = e.charCodeAt(++d);
|
|
799
|
+
s = 65536 + ((s & 1023) << 10) | u & 1023;
|
|
614
800
|
}
|
|
615
|
-
if (
|
|
616
|
-
if (
|
|
617
|
-
r
|
|
618
|
-
} else if (
|
|
619
|
-
if (
|
|
620
|
-
r
|
|
621
|
-
} else if (
|
|
622
|
-
if (
|
|
623
|
-
r
|
|
801
|
+
if (s <= 127) {
|
|
802
|
+
if (r >= l) break;
|
|
803
|
+
t[r++] = s;
|
|
804
|
+
} else if (s <= 2047) {
|
|
805
|
+
if (r + 1 >= l) break;
|
|
806
|
+
t[r++] = 192 | s >> 6, t[r++] = 128 | s & 63;
|
|
807
|
+
} else if (s <= 65535) {
|
|
808
|
+
if (r + 2 >= l) break;
|
|
809
|
+
t[r++] = 224 | s >> 12, t[r++] = 128 | s >> 6 & 63, t[r++] = 128 | s & 63;
|
|
624
810
|
} else {
|
|
625
|
-
if (
|
|
626
|
-
|
|
811
|
+
if (r + 3 >= l) break;
|
|
812
|
+
s > 1114111 && Ae("Invalid Unicode code point " + oe(s) + " encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF)."), t[r++] = 240 | s >> 18, t[r++] = 128 | s >> 12 & 63, t[r++] = 128 | s >> 6 & 63, t[r++] = 128 | s & 63;
|
|
627
813
|
}
|
|
628
814
|
}
|
|
629
|
-
return r
|
|
630
|
-
},
|
|
631
|
-
|
|
815
|
+
return t[r] = 0, r - o;
|
|
816
|
+
}, Se = (e, t, r) => (g(typeof r == "number", "stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!"), fn(e, K, t, r)), pn = (e, t, r) => {
|
|
817
|
+
L("it should not be possible to operate on streams when !SYSCALLS_REQUIRE_FILESYSTEM");
|
|
632
818
|
};
|
|
633
|
-
function
|
|
819
|
+
function vn(e, t, r) {
|
|
634
820
|
return 0;
|
|
635
821
|
}
|
|
636
|
-
var
|
|
637
|
-
|
|
638
|
-
},
|
|
639
|
-
|
|
640
|
-
},
|
|
641
|
-
|
|
822
|
+
var yn = (e, t) => {
|
|
823
|
+
L("it should not be possible to operate on streams when !SYSCALLS_REQUIRE_FILESYSTEM");
|
|
824
|
+
}, gn = (e, t, r) => {
|
|
825
|
+
L("it should not be possible to operate on streams when !SYSCALLS_REQUIRE_FILESYSTEM");
|
|
826
|
+
}, _n = (e, t, r, i) => {
|
|
827
|
+
L("it should not be possible to operate on streams when !SYSCALLS_REQUIRE_FILESYSTEM");
|
|
642
828
|
};
|
|
643
|
-
function
|
|
644
|
-
|
|
829
|
+
function mn(e, t, r, i) {
|
|
830
|
+
L("it should not be possible to operate on streams when !SYSCALLS_REQUIRE_FILESYSTEM");
|
|
645
831
|
}
|
|
646
|
-
var
|
|
647
|
-
|
|
648
|
-
},
|
|
649
|
-
|
|
650
|
-
},
|
|
651
|
-
|
|
652
|
-
},
|
|
653
|
-
|
|
654
|
-
},
|
|
832
|
+
var hn = (e, t, r, i) => {
|
|
833
|
+
L("it should not be possible to operate on streams when !SYSCALLS_REQUIRE_FILESYSTEM");
|
|
834
|
+
}, bn = (e) => {
|
|
835
|
+
L("it should not be possible to operate on streams when !SYSCALLS_REQUIRE_FILESYSTEM");
|
|
836
|
+
}, wn = (e, t) => {
|
|
837
|
+
L("it should not be possible to operate on streams when !SYSCALLS_REQUIRE_FILESYSTEM");
|
|
838
|
+
}, Cn = (e, t, r) => {
|
|
839
|
+
L("it should not be possible to operate on streams when !SYSCALLS_REQUIRE_FILESYSTEM");
|
|
840
|
+
}, Tn = () => L("native code called abort()"), je = {}, rt = (e) => {
|
|
655
841
|
for (; e.length; ) {
|
|
656
|
-
var
|
|
657
|
-
t
|
|
842
|
+
var t = e.pop(), r = e.pop();
|
|
843
|
+
r(t);
|
|
658
844
|
}
|
|
659
845
|
};
|
|
660
|
-
function
|
|
661
|
-
return this.fromWireType(
|
|
846
|
+
function Fe(e) {
|
|
847
|
+
return this.fromWireType(k[e >> 2]);
|
|
662
848
|
}
|
|
663
|
-
var
|
|
664
|
-
throw new
|
|
665
|
-
}, me = (e,
|
|
666
|
-
e.forEach((
|
|
667
|
-
function i(
|
|
668
|
-
var
|
|
669
|
-
|
|
670
|
-
for (var
|
|
671
|
-
ee(e[
|
|
849
|
+
var _e = {}, ve = {}, Ne = {}, Ht, We = (e) => {
|
|
850
|
+
throw new Ht(e);
|
|
851
|
+
}, me = (e, t, r) => {
|
|
852
|
+
e.forEach((s) => Ne[s] = t);
|
|
853
|
+
function i(s) {
|
|
854
|
+
var u = r(s);
|
|
855
|
+
u.length !== e.length && We("Mismatched type converter count");
|
|
856
|
+
for (var v = 0; v < e.length; ++v)
|
|
857
|
+
ee(e[v], u[v]);
|
|
672
858
|
}
|
|
673
|
-
var
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
|
|
859
|
+
var o = new Array(t.length), l = [], d = 0;
|
|
860
|
+
t.forEach((s, u) => {
|
|
861
|
+
ve.hasOwnProperty(s) ? o[u] = ve[s] : (l.push(s), _e.hasOwnProperty(s) || (_e[s] = []), _e[s].push(() => {
|
|
862
|
+
o[u] = ve[s], ++d, d === l.length && i(o);
|
|
677
863
|
}));
|
|
678
|
-
}),
|
|
679
|
-
},
|
|
680
|
-
var
|
|
681
|
-
delete
|
|
682
|
-
var
|
|
683
|
-
me([e],
|
|
684
|
-
var
|
|
685
|
-
return
|
|
686
|
-
var
|
|
687
|
-
|
|
688
|
-
read: (
|
|
689
|
-
write: (
|
|
690
|
-
var
|
|
691
|
-
|
|
864
|
+
}), l.length === 0 && i(o);
|
|
865
|
+
}, En = (e) => {
|
|
866
|
+
var t = je[e];
|
|
867
|
+
delete je[e];
|
|
868
|
+
var r = t.rawConstructor, i = t.rawDestructor, o = t.fields, l = o.map((d) => d.getterReturnType).concat(o.map((d) => d.setterArgumentType));
|
|
869
|
+
me([e], l, (d) => {
|
|
870
|
+
var s = {};
|
|
871
|
+
return o.forEach((u, v) => {
|
|
872
|
+
var _ = u.fieldName, w = d[v], U = u.getter, D = u.getterContext, x = d[v + o.length], z = u.setter, te = u.setterContext;
|
|
873
|
+
s[_] = {
|
|
874
|
+
read: (J) => w.fromWireType(U(D, J)),
|
|
875
|
+
write: (J, ke) => {
|
|
876
|
+
var Q = [];
|
|
877
|
+
z(te, J, x.toWireType(Q, ke)), rt(Q);
|
|
692
878
|
}
|
|
693
879
|
};
|
|
694
880
|
}), [{
|
|
695
|
-
name:
|
|
696
|
-
fromWireType: (
|
|
697
|
-
var
|
|
698
|
-
for (var
|
|
699
|
-
|
|
700
|
-
return i(
|
|
881
|
+
name: t.name,
|
|
882
|
+
fromWireType: (u) => {
|
|
883
|
+
var v = {};
|
|
884
|
+
for (var _ in s)
|
|
885
|
+
v[_] = s[_].read(u);
|
|
886
|
+
return i(u), v;
|
|
701
887
|
},
|
|
702
|
-
toWireType: (
|
|
703
|
-
for (var
|
|
704
|
-
if (!(
|
|
705
|
-
throw new TypeError(`Missing field: "${
|
|
706
|
-
var
|
|
707
|
-
for (
|
|
708
|
-
|
|
709
|
-
return
|
|
888
|
+
toWireType: (u, v) => {
|
|
889
|
+
for (var _ in s)
|
|
890
|
+
if (!(_ in v))
|
|
891
|
+
throw new TypeError(`Missing field: "${_}"`);
|
|
892
|
+
var w = r();
|
|
893
|
+
for (_ in s)
|
|
894
|
+
s[_].write(w, v[_]);
|
|
895
|
+
return u !== null && u.push(i, w), w;
|
|
710
896
|
},
|
|
711
897
|
argPackAdvance: ie,
|
|
712
|
-
readValueFromPointer:
|
|
898
|
+
readValueFromPointer: Fe,
|
|
713
899
|
destructorFunction: i
|
|
714
900
|
}];
|
|
715
901
|
});
|
|
716
|
-
},
|
|
902
|
+
}, de = (e) => {
|
|
717
903
|
if (e === null)
|
|
718
904
|
return "null";
|
|
719
|
-
var
|
|
720
|
-
return
|
|
721
|
-
},
|
|
722
|
-
for (var e = new Array(256),
|
|
723
|
-
e[
|
|
724
|
-
|
|
725
|
-
},
|
|
726
|
-
for (var
|
|
727
|
-
|
|
728
|
-
return
|
|
729
|
-
}, he,
|
|
905
|
+
var t = typeof e;
|
|
906
|
+
return t === "object" || t === "array" || t === "function" ? e.toString() : "" + e;
|
|
907
|
+
}, An = () => {
|
|
908
|
+
for (var e = new Array(256), t = 0; t < 256; ++t)
|
|
909
|
+
e[t] = String.fromCharCode(t);
|
|
910
|
+
Vt = e;
|
|
911
|
+
}, Vt, Y = (e) => {
|
|
912
|
+
for (var t = "", r = e; K[r]; )
|
|
913
|
+
t += Vt[K[r++]];
|
|
914
|
+
return t;
|
|
915
|
+
}, he, R = (e) => {
|
|
730
916
|
throw new he(e);
|
|
731
917
|
};
|
|
732
|
-
function
|
|
733
|
-
var i =
|
|
734
|
-
if (e ||
|
|
735
|
-
if (
|
|
918
|
+
function Sn(e, t, r = {}) {
|
|
919
|
+
var i = t.name;
|
|
920
|
+
if (e || R(`type "${i}" must have a positive integer typeid pointer`), ve.hasOwnProperty(e)) {
|
|
921
|
+
if (r.ignoreDuplicateRegistrations)
|
|
736
922
|
return;
|
|
737
|
-
|
|
923
|
+
R(`Cannot register type '${i}' twice`);
|
|
738
924
|
}
|
|
739
|
-
if (
|
|
740
|
-
var
|
|
741
|
-
delete
|
|
925
|
+
if (ve[e] = t, delete Ne[e], _e.hasOwnProperty(e)) {
|
|
926
|
+
var o = _e[e];
|
|
927
|
+
delete _e[e], o.forEach((l) => l());
|
|
742
928
|
}
|
|
743
929
|
}
|
|
744
|
-
function ee(e,
|
|
745
|
-
if (
|
|
930
|
+
function ee(e, t, r = {}) {
|
|
931
|
+
if (t.argPackAdvance === void 0)
|
|
746
932
|
throw new TypeError("registerType registeredInstance requires argPackAdvance");
|
|
747
|
-
return
|
|
933
|
+
return Sn(e, t, r);
|
|
748
934
|
}
|
|
749
|
-
var
|
|
750
|
-
switch (
|
|
935
|
+
var Yt = (e, t, r) => {
|
|
936
|
+
switch (t) {
|
|
751
937
|
case 1:
|
|
752
|
-
return
|
|
938
|
+
return r ? (i) => ne[i] : (i) => K[i];
|
|
753
939
|
case 2:
|
|
754
|
-
return
|
|
940
|
+
return r ? (i) => ge[i >> 1] : (i) => De[i >> 1];
|
|
755
941
|
case 4:
|
|
756
|
-
return
|
|
942
|
+
return r ? (i) => E[i >> 2] : (i) => k[i >> 2];
|
|
757
943
|
case 8:
|
|
758
|
-
return
|
|
944
|
+
return r ? (i) => be[i >> 3] : (i) => Mt[i >> 3];
|
|
759
945
|
default:
|
|
760
|
-
throw new TypeError(`invalid integer width (${
|
|
946
|
+
throw new TypeError(`invalid integer width (${t}): ${e}`);
|
|
761
947
|
}
|
|
762
|
-
},
|
|
763
|
-
|
|
764
|
-
var
|
|
765
|
-
|
|
766
|
-
name:
|
|
767
|
-
fromWireType: (
|
|
768
|
-
toWireType: function(
|
|
769
|
-
if (typeof
|
|
770
|
-
throw new TypeError(`Cannot convert "${
|
|
771
|
-
if (typeof
|
|
772
|
-
throw new TypeError(`Passing a number "${
|
|
773
|
-
return
|
|
948
|
+
}, Fn = (e, t, r, i, o) => {
|
|
949
|
+
t = Y(t);
|
|
950
|
+
var l = t.indexOf("u") != -1;
|
|
951
|
+
l && (o = (1n << 64n) - 1n), ee(e, {
|
|
952
|
+
name: t,
|
|
953
|
+
fromWireType: (d) => d,
|
|
954
|
+
toWireType: function(d, s) {
|
|
955
|
+
if (typeof s != "bigint" && typeof s != "number")
|
|
956
|
+
throw new TypeError(`Cannot convert "${de(s)}" to ${this.name}`);
|
|
957
|
+
if (typeof s == "number" && (s = BigInt(s)), s < i || s > o)
|
|
958
|
+
throw new TypeError(`Passing a number "${de(s)}" from JS side to C/C++ side to an argument of type "${t}", which is outside the valid range [${i}, ${o}]!`);
|
|
959
|
+
return s;
|
|
774
960
|
},
|
|
775
961
|
argPackAdvance: ie,
|
|
776
|
-
readValueFromPointer:
|
|
962
|
+
readValueFromPointer: Yt(t, r, !l),
|
|
777
963
|
destructorFunction: null
|
|
778
964
|
// This type does not need a destructor
|
|
779
965
|
});
|
|
780
|
-
}, ie = 8,
|
|
781
|
-
|
|
782
|
-
name:
|
|
783
|
-
fromWireType: function(
|
|
784
|
-
return !!
|
|
966
|
+
}, ie = 8, In = (e, t, r, i) => {
|
|
967
|
+
t = Y(t), ee(e, {
|
|
968
|
+
name: t,
|
|
969
|
+
fromWireType: function(o) {
|
|
970
|
+
return !!o;
|
|
785
971
|
},
|
|
786
|
-
toWireType: function(
|
|
787
|
-
return
|
|
972
|
+
toWireType: function(o, l) {
|
|
973
|
+
return l ? r : i;
|
|
788
974
|
},
|
|
789
975
|
argPackAdvance: ie,
|
|
790
|
-
readValueFromPointer: function(
|
|
791
|
-
return this.fromWireType(
|
|
976
|
+
readValueFromPointer: function(o) {
|
|
977
|
+
return this.fromWireType(K[o]);
|
|
792
978
|
},
|
|
793
979
|
destructorFunction: null
|
|
794
980
|
// This type does not need a destructor
|
|
795
981
|
});
|
|
796
|
-
},
|
|
982
|
+
}, $n = (e) => ({
|
|
797
983
|
count: e.count,
|
|
798
984
|
deleteScheduled: e.deleteScheduled,
|
|
799
985
|
preservePointerOnDelete: e.preservePointerOnDelete,
|
|
@@ -801,200 +987,200 @@ var pr = {}, pa = {
|
|
|
801
987
|
ptrType: e.ptrType,
|
|
802
988
|
smartPtr: e.smartPtr,
|
|
803
989
|
smartPtrType: e.smartPtrType
|
|
804
|
-
}),
|
|
805
|
-
function r
|
|
806
|
-
return
|
|
990
|
+
}), nt = (e) => {
|
|
991
|
+
function t(r) {
|
|
992
|
+
return r.$$.ptrType.registeredClass.name;
|
|
807
993
|
}
|
|
808
|
-
|
|
809
|
-
},
|
|
810
|
-
},
|
|
994
|
+
R(t(e) + " instance already deleted");
|
|
995
|
+
}, it = !1, zt = (e) => {
|
|
996
|
+
}, Pn = (e) => {
|
|
811
997
|
e.smartPtr ? e.smartPtrType.rawDestructor(e.smartPtr) : e.ptrType.registeredClass.rawDestructor(e.ptr);
|
|
812
|
-
},
|
|
998
|
+
}, Gt = (e) => {
|
|
813
999
|
e.count.value -= 1;
|
|
814
|
-
var
|
|
815
|
-
|
|
816
|
-
},
|
|
817
|
-
if (
|
|
1000
|
+
var t = e.count.value === 0;
|
|
1001
|
+
t && Pn(e);
|
|
1002
|
+
}, Jt = (e, t, r) => {
|
|
1003
|
+
if (t === r)
|
|
818
1004
|
return e;
|
|
819
|
-
if (
|
|
1005
|
+
if (r.baseClass === void 0)
|
|
820
1006
|
return null;
|
|
821
|
-
var i =
|
|
822
|
-
return i === null ? null :
|
|
823
|
-
},
|
|
824
|
-
for (
|
|
825
|
-
|
|
826
|
-
return
|
|
827
|
-
},
|
|
828
|
-
(!
|
|
829
|
-
var
|
|
830
|
-
return
|
|
1007
|
+
var i = Jt(e, t, r.baseClass);
|
|
1008
|
+
return i === null ? null : r.downcast(i);
|
|
1009
|
+
}, qt = {}, kn = {}, Un = (e, t) => {
|
|
1010
|
+
for (t === void 0 && R("ptr should not be undefined"); e.baseClass; )
|
|
1011
|
+
t = e.upcast(t), e = e.baseClass;
|
|
1012
|
+
return t;
|
|
1013
|
+
}, Mn = (e, t) => (t = Un(e, t), kn[t]), Be = (e, t) => {
|
|
1014
|
+
(!t.ptrType || !t.ptr) && We("makeClassHandle requires ptr and ptrType");
|
|
1015
|
+
var r = !!t.smartPtrType, i = !!t.smartPtr;
|
|
1016
|
+
return r !== i && We("Both smartPtrType and smartPtr must be specified"), t.count = { value: 1 }, Ie(Object.create(e, {
|
|
831
1017
|
$$: {
|
|
832
|
-
value:
|
|
1018
|
+
value: t,
|
|
833
1019
|
writable: !0
|
|
834
1020
|
}
|
|
835
1021
|
}));
|
|
836
1022
|
};
|
|
837
|
-
function
|
|
838
|
-
var
|
|
839
|
-
if (!
|
|
1023
|
+
function Kt(e) {
|
|
1024
|
+
var t = this.getPointee(e);
|
|
1025
|
+
if (!t)
|
|
840
1026
|
return this.destructor(e), null;
|
|
841
|
-
var
|
|
842
|
-
if (
|
|
843
|
-
if (
|
|
844
|
-
return
|
|
845
|
-
var i =
|
|
1027
|
+
var r = Mn(this.registeredClass, t);
|
|
1028
|
+
if (r !== void 0) {
|
|
1029
|
+
if (r.$$.count.value === 0)
|
|
1030
|
+
return r.$$.ptr = t, r.$$.smartPtr = e, r.clone();
|
|
1031
|
+
var i = r.clone();
|
|
846
1032
|
return this.destructor(e), i;
|
|
847
1033
|
}
|
|
848
|
-
function
|
|
849
|
-
return this.isSmartPointer ?
|
|
1034
|
+
function o() {
|
|
1035
|
+
return this.isSmartPointer ? Be(this.registeredClass.instancePrototype, {
|
|
850
1036
|
ptrType: this.pointeeType,
|
|
851
|
-
ptr:
|
|
1037
|
+
ptr: t,
|
|
852
1038
|
smartPtrType: this,
|
|
853
1039
|
smartPtr: e
|
|
854
|
-
}) :
|
|
1040
|
+
}) : Be(this.registeredClass.instancePrototype, {
|
|
855
1041
|
ptrType: this,
|
|
856
1042
|
ptr: e
|
|
857
1043
|
});
|
|
858
1044
|
}
|
|
859
|
-
var
|
|
860
|
-
if (!
|
|
861
|
-
return
|
|
862
|
-
var
|
|
863
|
-
this.isConst ?
|
|
864
|
-
var
|
|
865
|
-
|
|
1045
|
+
var l = this.registeredClass.getActualType(t), d = qt[l];
|
|
1046
|
+
if (!d)
|
|
1047
|
+
return o.call(this);
|
|
1048
|
+
var s;
|
|
1049
|
+
this.isConst ? s = d.constPointerType : s = d.pointerType;
|
|
1050
|
+
var u = Jt(
|
|
1051
|
+
t,
|
|
866
1052
|
this.registeredClass,
|
|
867
|
-
|
|
1053
|
+
s.registeredClass
|
|
868
1054
|
);
|
|
869
|
-
return
|
|
870
|
-
ptrType:
|
|
871
|
-
ptr:
|
|
1055
|
+
return u === null ? o.call(this) : this.isSmartPointer ? Be(s.registeredClass.instancePrototype, {
|
|
1056
|
+
ptrType: s,
|
|
1057
|
+
ptr: u,
|
|
872
1058
|
smartPtrType: this,
|
|
873
1059
|
smartPtr: e
|
|
874
|
-
}) :
|
|
875
|
-
ptrType:
|
|
876
|
-
ptr:
|
|
1060
|
+
}) : Be(s.registeredClass.instancePrototype, {
|
|
1061
|
+
ptrType: s,
|
|
1062
|
+
ptr: u
|
|
877
1063
|
});
|
|
878
1064
|
}
|
|
879
|
-
var
|
|
880
|
-
console.warn(
|
|
881
|
-
}),
|
|
882
|
-
var
|
|
1065
|
+
var Ie = (e) => typeof FinalizationRegistry > "u" ? (Ie = (t) => t, e) : (it = new FinalizationRegistry((t) => {
|
|
1066
|
+
console.warn(t.leakWarning), Gt(t.$$);
|
|
1067
|
+
}), Ie = (t) => {
|
|
1068
|
+
var r = t.$$, i = !!r.smartPtr;
|
|
883
1069
|
if (i) {
|
|
884
|
-
var
|
|
1070
|
+
var o = { $$: r }, l = r.ptrType.registeredClass, d = new Error(`Embind found a leaked C++ instance ${l.name} <${oe(r.ptr)}>.
|
|
885
1071
|
We'll free it automatically in this case, but this functionality is not reliable across various environments.
|
|
886
1072
|
Make sure to invoke .delete() manually once you're done with the instance instead.
|
|
887
1073
|
Originally allocated`);
|
|
888
|
-
"captureStackTrace" in Error && Error.captureStackTrace(
|
|
1074
|
+
"captureStackTrace" in Error && Error.captureStackTrace(d, Kt), o.leakWarning = d.stack.replace(/^Error: /, ""), it.register(t, o, t);
|
|
889
1075
|
}
|
|
890
|
-
return
|
|
891
|
-
},
|
|
892
|
-
Object.assign(
|
|
1076
|
+
return t;
|
|
1077
|
+
}, zt = (t) => it.unregister(t), Ie(e)), Rn = () => {
|
|
1078
|
+
Object.assign(He.prototype, {
|
|
893
1079
|
isAliasOf(e) {
|
|
894
|
-
if (!(this instanceof
|
|
1080
|
+
if (!(this instanceof He) || !(e instanceof He))
|
|
895
1081
|
return !1;
|
|
896
|
-
var
|
|
1082
|
+
var t = this.$$.ptrType.registeredClass, r = this.$$.ptr;
|
|
897
1083
|
e.$$ = /** @type {Object} */
|
|
898
1084
|
e.$$;
|
|
899
|
-
for (var i = e.$$.ptrType.registeredClass,
|
|
900
|
-
|
|
1085
|
+
for (var i = e.$$.ptrType.registeredClass, o = e.$$.ptr; t.baseClass; )
|
|
1086
|
+
r = t.upcast(r), t = t.baseClass;
|
|
901
1087
|
for (; i.baseClass; )
|
|
902
|
-
|
|
903
|
-
return
|
|
1088
|
+
o = i.upcast(o), i = i.baseClass;
|
|
1089
|
+
return t === i && r === o;
|
|
904
1090
|
},
|
|
905
1091
|
clone() {
|
|
906
|
-
if (this.$$.ptr ||
|
|
1092
|
+
if (this.$$.ptr || nt(this), this.$$.preservePointerOnDelete)
|
|
907
1093
|
return this.$$.count.value += 1, this;
|
|
908
|
-
var e =
|
|
1094
|
+
var e = Ie(Object.create(Object.getPrototypeOf(this), {
|
|
909
1095
|
$$: {
|
|
910
|
-
value:
|
|
1096
|
+
value: $n(this.$$)
|
|
911
1097
|
}
|
|
912
1098
|
}));
|
|
913
1099
|
return e.$$.count.value += 1, e.$$.deleteScheduled = !1, e;
|
|
914
1100
|
},
|
|
915
1101
|
delete() {
|
|
916
|
-
this.$$.ptr ||
|
|
1102
|
+
this.$$.ptr || nt(this), this.$$.deleteScheduled && !this.$$.preservePointerOnDelete && R("Object already scheduled for deletion"), zt(this), Gt(this.$$), this.$$.preservePointerOnDelete || (this.$$.smartPtr = void 0, this.$$.ptr = void 0);
|
|
917
1103
|
},
|
|
918
1104
|
isDeleted() {
|
|
919
1105
|
return !this.$$.ptr;
|
|
920
1106
|
},
|
|
921
1107
|
deleteLater() {
|
|
922
|
-
return this.$$.ptr ||
|
|
1108
|
+
return this.$$.ptr || nt(this), this.$$.deleteScheduled && !this.$$.preservePointerOnDelete && R("Object already scheduled for deletion"), this.$$.deleteScheduled = !0, this;
|
|
923
1109
|
}
|
|
924
1110
|
});
|
|
925
1111
|
};
|
|
926
|
-
function
|
|
1112
|
+
function He() {
|
|
927
1113
|
}
|
|
928
|
-
var
|
|
1114
|
+
var $e = (e, t) => Object.defineProperty(t, "name", {
|
|
929
1115
|
value: e
|
|
930
|
-
}),
|
|
931
|
-
if (e[
|
|
932
|
-
var i = e[
|
|
933
|
-
e[
|
|
934
|
-
return e[
|
|
935
|
-
}, e[
|
|
1116
|
+
}), Qt = (e, t, r) => {
|
|
1117
|
+
if (e[t].overloadTable === void 0) {
|
|
1118
|
+
var i = e[t];
|
|
1119
|
+
e[t] = function(...o) {
|
|
1120
|
+
return e[t].overloadTable.hasOwnProperty(o.length) || R(`Function '${r}' called with an invalid number of arguments (${o.length}) - expects one of (${e[t].overloadTable})!`), e[t].overloadTable[o.length].apply(this, o);
|
|
1121
|
+
}, e[t].overloadTable = [], e[t].overloadTable[i.argCount] = i;
|
|
936
1122
|
}
|
|
937
|
-
},
|
|
938
|
-
|
|
939
|
-
},
|
|
940
|
-
|
|
941
|
-
var
|
|
942
|
-
return
|
|
1123
|
+
}, Dn = (e, t, r) => {
|
|
1124
|
+
a.hasOwnProperty(e) ? (R(`Cannot register public name '${e}' twice`), Qt(a, e, e), a[e].overloadTable.hasOwnProperty(r) && R(`Cannot register multiple overloads of a function with the same number of arguments (${r})!`), a[e].overloadTable[r] = t) : (a[e] = t, a[e].argCount = r);
|
|
1125
|
+
}, Ln = 48, On = 57, xn = (e) => {
|
|
1126
|
+
g(typeof e == "string"), e = e.replace(/[^a-zA-Z0-9_]/g, "$");
|
|
1127
|
+
var t = e.charCodeAt(0);
|
|
1128
|
+
return t >= Ln && t <= On ? `_${e}` : e;
|
|
943
1129
|
};
|
|
944
|
-
function
|
|
945
|
-
this.name = e, this.constructor =
|
|
1130
|
+
function jn(e, t, r, i, o, l, d, s) {
|
|
1131
|
+
this.name = e, this.constructor = t, this.instancePrototype = r, this.rawDestructor = i, this.baseClass = o, this.getActualType = l, this.upcast = d, this.downcast = s, this.pureVirtualFunctions = [];
|
|
946
1132
|
}
|
|
947
|
-
var
|
|
948
|
-
for (;
|
|
949
|
-
|
|
1133
|
+
var at = (e, t, r) => {
|
|
1134
|
+
for (; t !== r; )
|
|
1135
|
+
t.upcast || R(`Expected null or instance of ${r.name}, got an instance of ${t.name}`), e = t.upcast(e), t = t.baseClass;
|
|
950
1136
|
return e;
|
|
951
1137
|
};
|
|
952
|
-
function
|
|
953
|
-
if (
|
|
954
|
-
return this.isReference &&
|
|
955
|
-
|
|
956
|
-
var
|
|
1138
|
+
function Nn(e, t) {
|
|
1139
|
+
if (t === null)
|
|
1140
|
+
return this.isReference && R(`null is not a valid ${this.name}`), 0;
|
|
1141
|
+
t.$$ || R(`Cannot pass "${de(t)}" as a ${this.name}`), t.$$.ptr || R(`Cannot pass deleted object as a pointer of type ${this.name}`);
|
|
1142
|
+
var r = t.$$.ptrType.registeredClass, i = at(t.$$.ptr, r, this.registeredClass);
|
|
957
1143
|
return i;
|
|
958
1144
|
}
|
|
959
|
-
function
|
|
960
|
-
var
|
|
961
|
-
if (
|
|
962
|
-
return this.isReference &&
|
|
963
|
-
(!
|
|
964
|
-
var i =
|
|
965
|
-
if (
|
|
966
|
-
switch (
|
|
1145
|
+
function Wn(e, t) {
|
|
1146
|
+
var r;
|
|
1147
|
+
if (t === null)
|
|
1148
|
+
return this.isReference && R(`null is not a valid ${this.name}`), this.isSmartPointer ? (r = this.rawConstructor(), e !== null && e.push(this.rawDestructor, r), r) : 0;
|
|
1149
|
+
(!t || !t.$$) && R(`Cannot pass "${de(t)}" as a ${this.name}`), t.$$.ptr || R(`Cannot pass deleted object as a pointer of type ${this.name}`), !this.isConst && t.$$.ptrType.isConst && R(`Cannot convert argument of type ${t.$$.smartPtrType ? t.$$.smartPtrType.name : t.$$.ptrType.name} to parameter type ${this.name}`);
|
|
1150
|
+
var i = t.$$.ptrType.registeredClass;
|
|
1151
|
+
if (r = at(t.$$.ptr, i, this.registeredClass), this.isSmartPointer)
|
|
1152
|
+
switch (t.$$.smartPtr === void 0 && R("Passing raw pointer to smart pointer is illegal"), this.sharingPolicy) {
|
|
967
1153
|
case 0:
|
|
968
|
-
|
|
1154
|
+
t.$$.smartPtrType === this ? r = t.$$.smartPtr : R(`Cannot convert argument of type ${t.$$.smartPtrType ? t.$$.smartPtrType.name : t.$$.ptrType.name} to parameter type ${this.name}`);
|
|
969
1155
|
break;
|
|
970
1156
|
case 1:
|
|
971
|
-
|
|
1157
|
+
r = t.$$.smartPtr;
|
|
972
1158
|
break;
|
|
973
1159
|
case 2:
|
|
974
|
-
if (
|
|
975
|
-
|
|
1160
|
+
if (t.$$.smartPtrType === this)
|
|
1161
|
+
r = t.$$.smartPtr;
|
|
976
1162
|
else {
|
|
977
|
-
var
|
|
978
|
-
|
|
979
|
-
|
|
980
|
-
|
|
981
|
-
), e !== null && e.push(this.rawDestructor,
|
|
1163
|
+
var o = t.clone();
|
|
1164
|
+
r = this.rawShare(
|
|
1165
|
+
r,
|
|
1166
|
+
G.toHandle(() => o.delete())
|
|
1167
|
+
), e !== null && e.push(this.rawDestructor, r);
|
|
982
1168
|
}
|
|
983
1169
|
break;
|
|
984
1170
|
default:
|
|
985
|
-
|
|
1171
|
+
R("Unsupporting sharing policy");
|
|
986
1172
|
}
|
|
987
|
-
return
|
|
1173
|
+
return r;
|
|
988
1174
|
}
|
|
989
|
-
function
|
|
990
|
-
if (
|
|
991
|
-
return this.isReference &&
|
|
992
|
-
|
|
993
|
-
var
|
|
1175
|
+
function Bn(e, t) {
|
|
1176
|
+
if (t === null)
|
|
1177
|
+
return this.isReference && R(`null is not a valid ${this.name}`), 0;
|
|
1178
|
+
t.$$ || R(`Cannot pass "${de(t)}" as a ${this.name}`), t.$$.ptr || R(`Cannot pass deleted object as a pointer of type ${this.name}`), t.$$.ptrType.isConst && R(`Cannot convert argument of type ${t.$$.ptrType.name} to parameter type ${this.name}`);
|
|
1179
|
+
var r = t.$$.ptrType.registeredClass, i = at(t.$$.ptr, r, this.registeredClass);
|
|
994
1180
|
return i;
|
|
995
1181
|
}
|
|
996
|
-
var
|
|
997
|
-
Object.assign(
|
|
1182
|
+
var Hn = () => {
|
|
1183
|
+
Object.assign(Ve.prototype, {
|
|
998
1184
|
getPointee(e) {
|
|
999
1185
|
return this.rawGetPointee && (e = this.rawGetPointee(e)), e;
|
|
1000
1186
|
},
|
|
@@ -1002,233 +1188,233 @@ Originally allocated`);
|
|
|
1002
1188
|
this.rawDestructor?.(e);
|
|
1003
1189
|
},
|
|
1004
1190
|
argPackAdvance: ie,
|
|
1005
|
-
readValueFromPointer:
|
|
1006
|
-
fromWireType:
|
|
1191
|
+
readValueFromPointer: Fe,
|
|
1192
|
+
fromWireType: Kt
|
|
1007
1193
|
});
|
|
1008
1194
|
};
|
|
1009
|
-
function
|
|
1010
|
-
this.name = e, this.registeredClass =
|
|
1195
|
+
function Ve(e, t, r, i, o, l, d, s, u, v, _) {
|
|
1196
|
+
this.name = e, this.registeredClass = t, this.isReference = r, this.isConst = i, this.isSmartPointer = o, this.pointeeType = l, this.sharingPolicy = d, this.rawGetPointee = s, this.rawConstructor = u, this.rawShare = v, this.rawDestructor = _, !o && t.baseClass === void 0 ? i ? (this.toWireType = Nn, this.destructorFunction = null) : (this.toWireType = Bn, this.destructorFunction = null) : this.toWireType = Wn;
|
|
1011
1197
|
}
|
|
1012
|
-
var
|
|
1013
|
-
|
|
1014
|
-
},
|
|
1015
|
-
e = e.replace(/p/g, "i"),
|
|
1016
|
-
var i =
|
|
1017
|
-
return i(
|
|
1018
|
-
},
|
|
1019
|
-
var i =
|
|
1198
|
+
var Vn = (e, t, r) => {
|
|
1199
|
+
a.hasOwnProperty(e) || We("Replacing nonexistent public symbol"), a[e].overloadTable !== void 0 && r !== void 0 || (a[e] = t, a[e].argCount = r);
|
|
1200
|
+
}, Yn = (e, t, r) => {
|
|
1201
|
+
e = e.replace(/p/g, "i"), g("dynCall_" + e in a, `bad function pointer type - dynCall function not found for sig '${e}'`), r?.length ? g(r.length === e.length - 1) : g(e.length == 1);
|
|
1202
|
+
var i = a["dynCall_" + e];
|
|
1203
|
+
return i(t, ...r);
|
|
1204
|
+
}, Xt, zn = (e, t, r = []) => {
|
|
1205
|
+
var i = Yn(e, t, r);
|
|
1020
1206
|
return i;
|
|
1021
|
-
},
|
|
1022
|
-
e =
|
|
1023
|
-
function
|
|
1024
|
-
return
|
|
1207
|
+
}, Gn = (e, t) => (...r) => zn(e, t, r), ae = (e, t) => {
|
|
1208
|
+
e = Y(e);
|
|
1209
|
+
function r() {
|
|
1210
|
+
return Gn(e, t);
|
|
1025
1211
|
}
|
|
1026
|
-
var i =
|
|
1027
|
-
return typeof i != "function" &&
|
|
1028
|
-
},
|
|
1029
|
-
var
|
|
1030
|
-
this.name =
|
|
1031
|
-
var
|
|
1032
|
-
|
|
1033
|
-
` +
|
|
1212
|
+
var i = r();
|
|
1213
|
+
return typeof i != "function" && R(`unknown function pointer with signature ${e}: ${t}`), i;
|
|
1214
|
+
}, Jn = (e, t) => {
|
|
1215
|
+
var r = $e(t, function(i) {
|
|
1216
|
+
this.name = t, this.message = i;
|
|
1217
|
+
var o = new Error(i).stack;
|
|
1218
|
+
o !== void 0 && (this.stack = this.toString() + `
|
|
1219
|
+
` + o.replace(/^Error(:[^\n]*)?\n/, ""));
|
|
1034
1220
|
});
|
|
1035
|
-
return
|
|
1221
|
+
return r.prototype = Object.create(e.prototype), r.prototype.constructor = r, r.prototype.toString = function() {
|
|
1036
1222
|
return this.message === void 0 ? this.name : `${this.name}: ${this.message}`;
|
|
1037
|
-
},
|
|
1038
|
-
},
|
|
1039
|
-
var
|
|
1040
|
-
return
|
|
1041
|
-
},
|
|
1042
|
-
var
|
|
1043
|
-
function
|
|
1044
|
-
if (!i[
|
|
1045
|
-
if (
|
|
1046
|
-
|
|
1223
|
+
}, r;
|
|
1224
|
+
}, Zt, er = (e) => {
|
|
1225
|
+
var t = ca(e), r = Y(t);
|
|
1226
|
+
return se(t), r;
|
|
1227
|
+
}, ot = (e, t) => {
|
|
1228
|
+
var r = [], i = {};
|
|
1229
|
+
function o(l) {
|
|
1230
|
+
if (!i[l] && !ve[l]) {
|
|
1231
|
+
if (Ne[l]) {
|
|
1232
|
+
Ne[l].forEach(o);
|
|
1047
1233
|
return;
|
|
1048
1234
|
}
|
|
1049
|
-
|
|
1235
|
+
r.push(l), i[l] = !0;
|
|
1050
1236
|
}
|
|
1051
1237
|
}
|
|
1052
|
-
throw
|
|
1053
|
-
},
|
|
1054
|
-
|
|
1055
|
-
var
|
|
1056
|
-
|
|
1057
|
-
|
|
1238
|
+
throw t.forEach(o), new Zt(`${e}: ` + r.map(er).join([", "]));
|
|
1239
|
+
}, qn = (e, t, r, i, o, l, d, s, u, v, _, w, U) => {
|
|
1240
|
+
_ = Y(_), l = ae(o, l), s &&= ae(d, s), v &&= ae(u, v), U = ae(w, U);
|
|
1241
|
+
var D = xn(_);
|
|
1242
|
+
Dn(D, function() {
|
|
1243
|
+
ot(`Cannot construct ${_} due to unbound types`, [i]);
|
|
1058
1244
|
}), me(
|
|
1059
|
-
[e,
|
|
1245
|
+
[e, t, r],
|
|
1060
1246
|
i ? [i] : [],
|
|
1061
|
-
(
|
|
1062
|
-
|
|
1063
|
-
var
|
|
1064
|
-
i ? (
|
|
1065
|
-
var
|
|
1066
|
-
if (Object.getPrototypeOf(this) !==
|
|
1067
|
-
throw new he("Use 'new' to construct " +
|
|
1068
|
-
if (
|
|
1069
|
-
throw new he(
|
|
1070
|
-
var
|
|
1071
|
-
if (
|
|
1072
|
-
throw new he(`Tried to invoke ctor of ${
|
|
1073
|
-
return
|
|
1074
|
-
}),
|
|
1075
|
-
constructor: { value:
|
|
1247
|
+
(x) => {
|
|
1248
|
+
x = x[0];
|
|
1249
|
+
var z, te;
|
|
1250
|
+
i ? (z = x.registeredClass, te = z.instancePrototype) : te = He.prototype;
|
|
1251
|
+
var J = $e(_, function(...gt) {
|
|
1252
|
+
if (Object.getPrototypeOf(this) !== ke)
|
|
1253
|
+
throw new he("Use 'new' to construct " + _);
|
|
1254
|
+
if (Q.constructor_body === void 0)
|
|
1255
|
+
throw new he(_ + " has no accessible constructor");
|
|
1256
|
+
var _r = Q.constructor_body[gt.length];
|
|
1257
|
+
if (_r === void 0)
|
|
1258
|
+
throw new he(`Tried to invoke ctor of ${_} with invalid number of parameters (${gt.length}) - expected (${Object.keys(Q.constructor_body).toString()}) parameters instead!`);
|
|
1259
|
+
return _r.apply(this, gt);
|
|
1260
|
+
}), ke = Object.create(te, {
|
|
1261
|
+
constructor: { value: J }
|
|
1076
1262
|
});
|
|
1077
|
-
|
|
1078
|
-
var
|
|
1079
|
-
|
|
1080
|
-
Q,
|
|
1081
|
-
Me,
|
|
1082
|
-
A,
|
|
1263
|
+
J.prototype = ke;
|
|
1264
|
+
var Q = new jn(
|
|
1265
|
+
_,
|
|
1083
1266
|
J,
|
|
1267
|
+
ke,
|
|
1268
|
+
U,
|
|
1269
|
+
z,
|
|
1270
|
+
l,
|
|
1084
1271
|
s,
|
|
1085
|
-
|
|
1086
|
-
p
|
|
1272
|
+
v
|
|
1087
1273
|
);
|
|
1088
|
-
|
|
1089
|
-
var
|
|
1090
|
-
|
|
1091
|
-
|
|
1274
|
+
Q.baseClass && (Q.baseClass.__derivedClasses ??= [], Q.baseClass.__derivedClasses.push(Q));
|
|
1275
|
+
var wa = new Ve(
|
|
1276
|
+
_,
|
|
1277
|
+
Q,
|
|
1092
1278
|
!0,
|
|
1093
1279
|
!1,
|
|
1094
1280
|
!1
|
|
1095
|
-
),
|
|
1096
|
-
|
|
1097
|
-
|
|
1281
|
+
), yr = new Ve(
|
|
1282
|
+
_ + "*",
|
|
1283
|
+
Q,
|
|
1098
1284
|
!1,
|
|
1099
1285
|
!1,
|
|
1100
1286
|
!1
|
|
1101
|
-
),
|
|
1102
|
-
|
|
1103
|
-
|
|
1287
|
+
), gr = new Ve(
|
|
1288
|
+
_ + " const*",
|
|
1289
|
+
Q,
|
|
1104
1290
|
!1,
|
|
1105
1291
|
!0,
|
|
1106
1292
|
!1
|
|
1107
1293
|
);
|
|
1108
|
-
return
|
|
1109
|
-
pointerType:
|
|
1110
|
-
constPointerType:
|
|
1111
|
-
},
|
|
1294
|
+
return qt[e] = {
|
|
1295
|
+
pointerType: yr,
|
|
1296
|
+
constPointerType: gr
|
|
1297
|
+
}, Vn(D, J), [wa, yr, gr];
|
|
1112
1298
|
}
|
|
1113
1299
|
);
|
|
1114
|
-
},
|
|
1115
|
-
for (var
|
|
1116
|
-
|
|
1117
|
-
return
|
|
1300
|
+
}, tr = (e, t) => {
|
|
1301
|
+
for (var r = [], i = 0; i < e; i++)
|
|
1302
|
+
r.push(k[t + i * 4 >> 2]);
|
|
1303
|
+
return r;
|
|
1118
1304
|
};
|
|
1119
|
-
function
|
|
1120
|
-
for (var
|
|
1121
|
-
if (e[
|
|
1305
|
+
function rr(e) {
|
|
1306
|
+
for (var t = 1; t < e.length; ++t)
|
|
1307
|
+
if (e[t] !== null && e[t].destructorFunction === void 0)
|
|
1122
1308
|
return !0;
|
|
1123
1309
|
return !1;
|
|
1124
1310
|
}
|
|
1125
|
-
function
|
|
1311
|
+
function nr(e, t) {
|
|
1126
1312
|
if (!(e instanceof Function))
|
|
1127
1313
|
throw new TypeError(`new_ called with constructor type ${typeof e} which is not a function`);
|
|
1128
|
-
var
|
|
1314
|
+
var r = $e(e.name || "unknownFunctionName", function() {
|
|
1129
1315
|
});
|
|
1130
|
-
|
|
1131
|
-
var i = new
|
|
1132
|
-
return
|
|
1316
|
+
r.prototype = e.prototype;
|
|
1317
|
+
var i = new r(), o = e.apply(i, t);
|
|
1318
|
+
return o instanceof Object ? o : i;
|
|
1133
1319
|
}
|
|
1134
|
-
function
|
|
1135
|
-
if (e <
|
|
1136
|
-
var
|
|
1137
|
-
|
|
1320
|
+
function Kn(e, t, r, i, o) {
|
|
1321
|
+
if (e < t || e > r) {
|
|
1322
|
+
var l = t == r ? t : `${t} to ${r}`;
|
|
1323
|
+
o(`function ${i} called with ${e} arguments, expected ${l}`);
|
|
1138
1324
|
}
|
|
1139
1325
|
}
|
|
1140
|
-
function
|
|
1141
|
-
var
|
|
1142
|
-
|
|
1143
|
-
for (var
|
|
1144
|
-
|
|
1145
|
-
|
|
1146
|
-
var
|
|
1326
|
+
function Qn(e, t, r, i) {
|
|
1327
|
+
var o = rr(e), l = e.length - 2, d = [], s = ["fn"];
|
|
1328
|
+
t && s.push("thisWired");
|
|
1329
|
+
for (var u = 0; u < l; ++u)
|
|
1330
|
+
d.push(`arg${u}`), s.push(`arg${u}Wired`);
|
|
1331
|
+
d = d.join(","), s = s.join(",");
|
|
1332
|
+
var v = `return function (${d}) {
|
|
1147
1333
|
`;
|
|
1148
|
-
|
|
1149
|
-
`,
|
|
1334
|
+
v += `checkArgCount(arguments.length, minArgs, maxArgs, humanName, throwBindingError);
|
|
1335
|
+
`, o && (v += `var destructors = [];
|
|
1150
1336
|
`);
|
|
1151
|
-
var
|
|
1152
|
-
|
|
1337
|
+
var _ = o ? "destructors" : "null", w = ["humanName", "throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"];
|
|
1338
|
+
t && (v += `var thisWired = classParam['toWireType'](${_}, this);
|
|
1153
1339
|
`);
|
|
1154
|
-
for (var
|
|
1155
|
-
|
|
1156
|
-
`,
|
|
1157
|
-
|
|
1340
|
+
for (var u = 0; u < l; ++u)
|
|
1341
|
+
v += `var arg${u}Wired = argType${u}['toWireType'](${_}, arg${u});
|
|
1342
|
+
`, w.push(`argType${u}`);
|
|
1343
|
+
v += (r || i ? "var rv = " : "") + `invoker(${s});
|
|
1158
1344
|
`;
|
|
1159
|
-
var
|
|
1160
|
-
if (
|
|
1161
|
-
`,
|
|
1162
|
-
|
|
1345
|
+
var U = r ? "rv" : "";
|
|
1346
|
+
if (w.push("Asyncify"), v += `function onDone(${U}) {
|
|
1347
|
+
`, o)
|
|
1348
|
+
v += `runDestructors(destructors);
|
|
1163
1349
|
`;
|
|
1164
1350
|
else
|
|
1165
|
-
for (var
|
|
1166
|
-
var
|
|
1167
|
-
e[
|
|
1168
|
-
`,
|
|
1351
|
+
for (var u = t ? 1 : 2; u < e.length; ++u) {
|
|
1352
|
+
var D = u === 1 ? "thisWired" : "arg" + (u - 2) + "Wired";
|
|
1353
|
+
e[u].destructorFunction !== null && (v += `${D}_dtor(${D});
|
|
1354
|
+
`, w.push(`${D}_dtor`));
|
|
1169
1355
|
}
|
|
1170
|
-
return
|
|
1356
|
+
return r && (v += `var ret = retType['fromWireType'](rv);
|
|
1171
1357
|
return ret;
|
|
1172
|
-
`),
|
|
1173
|
-
`,
|
|
1174
|
-
`,
|
|
1175
|
-
`,
|
|
1176
|
-
${
|
|
1358
|
+
`), v += `}
|
|
1359
|
+
`, v += `return Asyncify.currData ? Asyncify.whenDone().then(onDone) : onDone(${U});
|
|
1360
|
+
`, v += `}
|
|
1361
|
+
`, w.push("checkArgCount", "minArgs", "maxArgs"), v = `if (arguments.length !== ${w.length}){ throw new Error(humanName + "Expected ${w.length} closure arguments " + arguments.length + " given."); }
|
|
1362
|
+
${v}`, [w, v];
|
|
1177
1363
|
}
|
|
1178
|
-
var
|
|
1364
|
+
var Ye = (e) => {
|
|
1179
1365
|
try {
|
|
1180
1366
|
return e();
|
|
1181
|
-
} catch (
|
|
1182
|
-
|
|
1367
|
+
} catch (t) {
|
|
1368
|
+
L(t);
|
|
1183
1369
|
}
|
|
1184
|
-
},
|
|
1185
|
-
if (e instanceof
|
|
1186
|
-
return
|
|
1187
|
-
|
|
1188
|
-
},
|
|
1189
|
-
},
|
|
1190
|
-
if (
|
|
1191
|
-
|
|
1370
|
+
}, Xn = (e) => {
|
|
1371
|
+
if (e instanceof en || e == "unwind")
|
|
1372
|
+
return Re;
|
|
1373
|
+
Le(), e instanceof WebAssembly.RuntimeError && fa() <= 0 && $("Stack overflow detected. You can try increasing -sSTACK_SIZE (currently set to 52428800)"), V(1, e);
|
|
1374
|
+
}, Zn = () => {
|
|
1375
|
+
}, ei = (e) => {
|
|
1376
|
+
if (N) {
|
|
1377
|
+
$("user callback triggered after runtime exited or application aborted. Ignoring.");
|
|
1192
1378
|
return;
|
|
1193
1379
|
}
|
|
1194
1380
|
try {
|
|
1195
|
-
e(),
|
|
1196
|
-
} catch (
|
|
1197
|
-
|
|
1381
|
+
e(), Zn();
|
|
1382
|
+
} catch (t) {
|
|
1383
|
+
Xn(t);
|
|
1198
1384
|
}
|
|
1199
|
-
},
|
|
1385
|
+
}, h = {
|
|
1200
1386
|
instrumentWasmImports(e) {
|
|
1201
|
-
var
|
|
1202
|
-
for (let [
|
|
1387
|
+
var t = /^(invoke_.*|__asyncjs__.*)$/;
|
|
1388
|
+
for (let [r, i] of Object.entries(e))
|
|
1203
1389
|
if (typeof i == "function") {
|
|
1204
|
-
let
|
|
1205
|
-
e[
|
|
1206
|
-
var
|
|
1390
|
+
let o = i.isAsync || t.test(r);
|
|
1391
|
+
e[r] = (...l) => {
|
|
1392
|
+
var d = h.state;
|
|
1207
1393
|
try {
|
|
1208
|
-
return i(...
|
|
1394
|
+
return i(...l);
|
|
1209
1395
|
} finally {
|
|
1210
|
-
var
|
|
1211
|
-
if (
|
|
1212
|
-
throw new Error(`import ${
|
|
1396
|
+
var s = d === h.State.Normal && h.state === h.State.Disabled, u = r.startsWith("invoke_") && !0;
|
|
1397
|
+
if (h.state !== d && !o && !s && !u)
|
|
1398
|
+
throw new Error(`import ${r} was not in ASYNCIFY_IMPORTS, but changed the state`);
|
|
1213
1399
|
}
|
|
1214
1400
|
};
|
|
1215
1401
|
}
|
|
1216
1402
|
},
|
|
1217
1403
|
instrumentWasmExports(e) {
|
|
1218
|
-
var
|
|
1219
|
-
for (let [
|
|
1220
|
-
typeof i == "function" ? r
|
|
1221
|
-
|
|
1404
|
+
var t = {};
|
|
1405
|
+
for (let [r, i] of Object.entries(e))
|
|
1406
|
+
typeof i == "function" ? t[r] = (...o) => {
|
|
1407
|
+
h.exportCallStack.push(r);
|
|
1222
1408
|
try {
|
|
1223
|
-
return i(...
|
|
1409
|
+
return i(...o);
|
|
1224
1410
|
} finally {
|
|
1225
|
-
if (!
|
|
1226
|
-
var
|
|
1227
|
-
|
|
1411
|
+
if (!N) {
|
|
1412
|
+
var l = h.exportCallStack.pop();
|
|
1413
|
+
g(l === r), h.maybeStopUnwind();
|
|
1228
1414
|
}
|
|
1229
1415
|
}
|
|
1230
|
-
} : r
|
|
1231
|
-
return
|
|
1416
|
+
} : t[r] = i;
|
|
1417
|
+
return t;
|
|
1232
1418
|
},
|
|
1233
1419
|
State: {
|
|
1234
1420
|
Normal: 0,
|
|
@@ -1247,126 +1433,126 @@ ${p}`, [m, p];
|
|
|
1247
1433
|
asyncPromiseHandlers: null,
|
|
1248
1434
|
sleepCallbacks: [],
|
|
1249
1435
|
getCallStackId(e) {
|
|
1250
|
-
var
|
|
1251
|
-
return
|
|
1436
|
+
var t = h.callStackNameToId[e];
|
|
1437
|
+
return t === void 0 && (t = h.callStackId++, h.callStackNameToId[e] = t, h.callStackIdToName[t] = e), t;
|
|
1252
1438
|
},
|
|
1253
1439
|
maybeStopUnwind() {
|
|
1254
|
-
|
|
1440
|
+
h.currData && h.state === h.State.Unwinding && h.exportCallStack.length === 0 && (h.state = h.State.Normal, Ye(ya), typeof Fibers < "u" && Fibers.trampoline());
|
|
1255
1441
|
},
|
|
1256
1442
|
whenDone() {
|
|
1257
|
-
return
|
|
1258
|
-
|
|
1443
|
+
return g(h.currData, "Tried to wait for an async operation when none is in progress."), g(!h.asyncPromiseHandlers, "Cannot have multiple async operations in flight at once"), new Promise((e, t) => {
|
|
1444
|
+
h.asyncPromiseHandlers = { resolve: e, reject: t };
|
|
1259
1445
|
});
|
|
1260
1446
|
},
|
|
1261
1447
|
allocateData() {
|
|
1262
|
-
var e =
|
|
1263
|
-
return
|
|
1448
|
+
var e = vt(12 + h.StackSize);
|
|
1449
|
+
return h.setDataHeader(e, e + 12, h.StackSize), h.setDataRewindFunc(e), e;
|
|
1264
1450
|
},
|
|
1265
|
-
setDataHeader(e,
|
|
1266
|
-
|
|
1451
|
+
setDataHeader(e, t, r) {
|
|
1452
|
+
k[e >> 2] = t, k[e + 4 >> 2] = t + r;
|
|
1267
1453
|
},
|
|
1268
1454
|
setDataRewindFunc(e) {
|
|
1269
|
-
var
|
|
1270
|
-
|
|
1455
|
+
var t = h.exportCallStack[0], r = h.getCallStackId(t);
|
|
1456
|
+
E[e + 8 >> 2] = r, S(r);
|
|
1271
1457
|
},
|
|
1272
1458
|
getDataRewindFuncName(e) {
|
|
1273
|
-
var
|
|
1274
|
-
return
|
|
1459
|
+
var t = E[e + 8 >> 2], r = h.callStackIdToName[t];
|
|
1460
|
+
return r;
|
|
1275
1461
|
},
|
|
1276
1462
|
getDataRewindFunc(e) {
|
|
1277
|
-
var
|
|
1278
|
-
return
|
|
1463
|
+
var t = B[e];
|
|
1464
|
+
return t;
|
|
1279
1465
|
},
|
|
1280
1466
|
doRewind(e) {
|
|
1281
|
-
var
|
|
1282
|
-
return
|
|
1467
|
+
var t = h.getDataRewindFuncName(e), r = h.getDataRewindFunc(t);
|
|
1468
|
+
return r();
|
|
1283
1469
|
},
|
|
1284
1470
|
handleSleep(e) {
|
|
1285
|
-
if (
|
|
1286
|
-
if (
|
|
1287
|
-
var
|
|
1471
|
+
if (g(h.state !== h.State.Disabled, "Asyncify cannot be done during or after the runtime exits"), !N) {
|
|
1472
|
+
if (h.state === h.State.Normal) {
|
|
1473
|
+
var t = !1, r = !1;
|
|
1288
1474
|
e((i = 0) => {
|
|
1289
|
-
if (
|
|
1290
|
-
|
|
1291
|
-
var
|
|
1475
|
+
if (g(!i || typeof i == "number" || typeof i == "boolean"), !N && (h.handleSleepReturnValue = i, t = !0, !!r)) {
|
|
1476
|
+
g(!h.exportCallStack.length, "Waking up (starting to rewind) must be done from JS, without compiled code on the stack."), h.state = h.State.Rewinding, Ye(() => ga(h.currData)), typeof MainLoop < "u" && MainLoop.func && MainLoop.resume();
|
|
1477
|
+
var o, l = !1;
|
|
1292
1478
|
try {
|
|
1293
|
-
|
|
1294
|
-
} catch (
|
|
1295
|
-
|
|
1479
|
+
o = h.doRewind(h.currData);
|
|
1480
|
+
} catch (u) {
|
|
1481
|
+
o = u, l = !0;
|
|
1296
1482
|
}
|
|
1297
|
-
var
|
|
1298
|
-
if (!
|
|
1299
|
-
var
|
|
1300
|
-
|
|
1483
|
+
var d = !1;
|
|
1484
|
+
if (!h.currData) {
|
|
1485
|
+
var s = h.asyncPromiseHandlers;
|
|
1486
|
+
s && (h.asyncPromiseHandlers = null, (l ? s.reject : s.resolve)(o), d = !0);
|
|
1301
1487
|
}
|
|
1302
|
-
if (
|
|
1303
|
-
throw
|
|
1488
|
+
if (l && !d)
|
|
1489
|
+
throw o;
|
|
1304
1490
|
}
|
|
1305
|
-
}),
|
|
1306
|
-
} else
|
|
1307
|
-
return
|
|
1491
|
+
}), r = !0, t || (h.state = h.State.Unwinding, h.currData = h.allocateData(), typeof MainLoop < "u" && MainLoop.func && MainLoop.pause(), Ye(() => va(h.currData)));
|
|
1492
|
+
} else h.state === h.State.Rewinding ? (h.state = h.State.Normal, Ye(_a), se(h.currData), h.currData = null, h.sleepCallbacks.forEach(ei)) : L(`invalid state: ${h.state}`);
|
|
1493
|
+
return h.handleSleepReturnValue;
|
|
1308
1494
|
}
|
|
1309
1495
|
},
|
|
1310
1496
|
handleAsync(e) {
|
|
1311
|
-
return
|
|
1312
|
-
e().then(
|
|
1497
|
+
return h.handleSleep((t) => {
|
|
1498
|
+
e().then(t);
|
|
1313
1499
|
});
|
|
1314
1500
|
}
|
|
1315
1501
|
};
|
|
1316
|
-
function
|
|
1317
|
-
for (var
|
|
1318
|
-
|
|
1319
|
-
return
|
|
1502
|
+
function ti(e) {
|
|
1503
|
+
for (var t = e.length - 2, r = e.length - 1; r >= 2 && e[r].optional; --r)
|
|
1504
|
+
t--;
|
|
1505
|
+
return t;
|
|
1320
1506
|
}
|
|
1321
|
-
function
|
|
1322
|
-
var
|
|
1323
|
-
|
|
1324
|
-
for (var
|
|
1325
|
-
|
|
1326
|
-
if (
|
|
1327
|
-
for (var
|
|
1328
|
-
|
|
1329
|
-
|
|
1330
|
-
let [
|
|
1331
|
-
|
|
1332
|
-
var
|
|
1333
|
-
return
|
|
1507
|
+
function ir(e, t, r, i, o, l) {
|
|
1508
|
+
var d = t.length;
|
|
1509
|
+
d < 2 && R("argTypes array size mismatch! Must at least get return value and 'this' types!"), g(!l, "Async bindings are only supported with JSPI.");
|
|
1510
|
+
for (var s = t[1] !== null && r !== null, u = rr(t), v = t[0].name !== "void", _ = d - 2, w = ti(t), U = [e, R, i, o, rt, t[0], t[1]], D = 0; D < d - 2; ++D)
|
|
1511
|
+
U.push(t[D + 2]);
|
|
1512
|
+
if (U.push(h), !u)
|
|
1513
|
+
for (var D = s ? 1 : 2; D < t.length; ++D)
|
|
1514
|
+
t[D].destructorFunction !== null && U.push(t[D].destructorFunction);
|
|
1515
|
+
U.push(Kn, w, _);
|
|
1516
|
+
let [x, z] = Qn(t, s, v, l);
|
|
1517
|
+
x.push(z);
|
|
1518
|
+
var te = nr(Function, x)(...U);
|
|
1519
|
+
return $e(e, te);
|
|
1334
1520
|
}
|
|
1335
|
-
var
|
|
1336
|
-
|
|
1337
|
-
var
|
|
1338
|
-
|
|
1339
|
-
|
|
1340
|
-
var
|
|
1341
|
-
if (
|
|
1342
|
-
throw new he(`Cannot register multiple constructors with identical number of parameters (${
|
|
1343
|
-
return
|
|
1344
|
-
|
|
1345
|
-
}, me([],
|
|
1521
|
+
var ri = (e, t, r, i, o, l) => {
|
|
1522
|
+
g(t > 0);
|
|
1523
|
+
var d = tr(t, r);
|
|
1524
|
+
o = ae(i, o), me([], [e], (s) => {
|
|
1525
|
+
s = s[0];
|
|
1526
|
+
var u = `constructor ${s.name}`;
|
|
1527
|
+
if (s.registeredClass.constructor_body === void 0 && (s.registeredClass.constructor_body = []), s.registeredClass.constructor_body[t - 1] !== void 0)
|
|
1528
|
+
throw new he(`Cannot register multiple constructors with identical number of parameters (${t - 1}) for class '${s.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`);
|
|
1529
|
+
return s.registeredClass.constructor_body[t - 1] = () => {
|
|
1530
|
+
ot(`Cannot construct ${s.name} due to unbound types`, d);
|
|
1531
|
+
}, me([], d, (v) => (v.splice(1, 0, null), s.registeredClass.constructor_body[t - 1] = ir(u, v, null, o, l), [])), [];
|
|
1346
1532
|
});
|
|
1347
|
-
},
|
|
1533
|
+
}, ni = (e) => {
|
|
1348
1534
|
e = e.trim();
|
|
1349
|
-
const
|
|
1350
|
-
return
|
|
1351
|
-
},
|
|
1352
|
-
var
|
|
1353
|
-
|
|
1354
|
-
|
|
1355
|
-
var
|
|
1356
|
-
|
|
1357
|
-
function
|
|
1358
|
-
|
|
1535
|
+
const t = e.indexOf("(");
|
|
1536
|
+
return t === -1 ? e : (g(e.endsWith(")"), "Parentheses for argument names should match."), e.slice(0, t));
|
|
1537
|
+
}, ii = (e, t, r, i, o, l, d, s, u, v) => {
|
|
1538
|
+
var _ = tr(r, i);
|
|
1539
|
+
t = Y(t), t = ni(t), l = ae(o, l), me([], [e], (w) => {
|
|
1540
|
+
w = w[0];
|
|
1541
|
+
var U = `${w.name}.${t}`;
|
|
1542
|
+
t.startsWith("@@") && (t = Symbol[t.substring(2)]), s && w.registeredClass.pureVirtualFunctions.push(t);
|
|
1543
|
+
function D() {
|
|
1544
|
+
ot(`Cannot call ${U} due to unbound types`, _);
|
|
1359
1545
|
}
|
|
1360
|
-
var
|
|
1361
|
-
return
|
|
1362
|
-
var
|
|
1363
|
-
return
|
|
1546
|
+
var x = w.registeredClass.instancePrototype, z = x[t];
|
|
1547
|
+
return z === void 0 || z.overloadTable === void 0 && z.className !== w.name && z.argCount === r - 2 ? (D.argCount = r - 2, D.className = w.name, x[t] = D) : (Qt(x, t, U), x[t].overloadTable[r - 2] = D), me([], _, (te) => {
|
|
1548
|
+
var J = ir(U, te, w, l, d, u);
|
|
1549
|
+
return x[t].overloadTable === void 0 ? (J.argCount = r - 2, x[t] = J) : x[t].overloadTable[r - 2] = J, [];
|
|
1364
1550
|
}), [];
|
|
1365
1551
|
});
|
|
1366
|
-
},
|
|
1367
|
-
e > 9 && --
|
|
1368
|
-
},
|
|
1369
|
-
|
|
1552
|
+
}, st = [], X = [], lt = (e) => {
|
|
1553
|
+
e > 9 && --X[e + 1] === 0 && (g(X[e] !== void 0, "Decref for unallocated handle."), X[e] = void 0, st.push(e));
|
|
1554
|
+
}, ai = () => X.length / 2 - 5 - st.length, oi = () => {
|
|
1555
|
+
X.push(
|
|
1370
1556
|
0,
|
|
1371
1557
|
1,
|
|
1372
1558
|
void 0,
|
|
@@ -1377,9 +1563,9 @@ ${p}`, [m, p];
|
|
|
1377
1563
|
1,
|
|
1378
1564
|
!1,
|
|
1379
1565
|
1
|
|
1380
|
-
),
|
|
1381
|
-
},
|
|
1382
|
-
toValue: (e) => (e ||
|
|
1566
|
+
), g(X.length === 5 * 2), a.count_emval_handles = ai;
|
|
1567
|
+
}, G = {
|
|
1568
|
+
toValue: (e) => (e || R("Cannot use deleted val. handle = " + e), g(e === 2 || X[e] !== void 0 && e % 2 === 0, `invalid handle: ${e}`), X[e]),
|
|
1383
1569
|
toHandle: (e) => {
|
|
1384
1570
|
switch (e) {
|
|
1385
1571
|
case void 0:
|
|
@@ -1391,78 +1577,78 @@ ${p}`, [m, p];
|
|
|
1391
1577
|
case !1:
|
|
1392
1578
|
return 8;
|
|
1393
1579
|
default: {
|
|
1394
|
-
const
|
|
1395
|
-
return
|
|
1580
|
+
const t = st.pop() || X.length;
|
|
1581
|
+
return X[t] = e, X[t + 1] = 1, t;
|
|
1396
1582
|
}
|
|
1397
1583
|
}
|
|
1398
1584
|
}
|
|
1399
|
-
},
|
|
1585
|
+
}, ar = {
|
|
1400
1586
|
name: "emscripten::val",
|
|
1401
1587
|
fromWireType: (e) => {
|
|
1402
|
-
var
|
|
1403
|
-
return
|
|
1588
|
+
var t = G.toValue(e);
|
|
1589
|
+
return lt(e), t;
|
|
1404
1590
|
},
|
|
1405
|
-
toWireType: (e,
|
|
1591
|
+
toWireType: (e, t) => G.toHandle(t),
|
|
1406
1592
|
argPackAdvance: ie,
|
|
1407
|
-
readValueFromPointer:
|
|
1593
|
+
readValueFromPointer: Fe,
|
|
1408
1594
|
destructorFunction: null
|
|
1409
1595
|
// This type does not need a destructor
|
|
1410
1596
|
// TODO: do we need a deleteObject here? write a test where
|
|
1411
1597
|
// emval is passed into JS via an interface
|
|
1412
|
-
},
|
|
1413
|
-
switch (
|
|
1598
|
+
}, si = (e) => ee(e, ar), li = (e, t) => {
|
|
1599
|
+
switch (t) {
|
|
1414
1600
|
case 4:
|
|
1415
|
-
return function(
|
|
1416
|
-
return this.fromWireType(
|
|
1601
|
+
return function(r) {
|
|
1602
|
+
return this.fromWireType(Ut[r >> 2]);
|
|
1417
1603
|
};
|
|
1418
1604
|
case 8:
|
|
1419
|
-
return function(
|
|
1420
|
-
return this.fromWireType(
|
|
1605
|
+
return function(r) {
|
|
1606
|
+
return this.fromWireType(Rt[r >> 3]);
|
|
1421
1607
|
};
|
|
1422
1608
|
default:
|
|
1423
|
-
throw new TypeError(`invalid float width (${
|
|
1609
|
+
throw new TypeError(`invalid float width (${t}): ${e}`);
|
|
1424
1610
|
}
|
|
1425
|
-
},
|
|
1426
|
-
|
|
1427
|
-
name:
|
|
1611
|
+
}, di = (e, t, r) => {
|
|
1612
|
+
t = Y(t), ee(e, {
|
|
1613
|
+
name: t,
|
|
1428
1614
|
fromWireType: (i) => i,
|
|
1429
|
-
toWireType: (i,
|
|
1430
|
-
if (typeof
|
|
1431
|
-
throw new TypeError(`Cannot convert ${
|
|
1432
|
-
return
|
|
1615
|
+
toWireType: (i, o) => {
|
|
1616
|
+
if (typeof o != "number" && typeof o != "boolean")
|
|
1617
|
+
throw new TypeError(`Cannot convert ${de(o)} to ${this.name}`);
|
|
1618
|
+
return o;
|
|
1433
1619
|
},
|
|
1434
1620
|
argPackAdvance: ie,
|
|
1435
|
-
readValueFromPointer:
|
|
1621
|
+
readValueFromPointer: li(t, r),
|
|
1436
1622
|
destructorFunction: null
|
|
1437
1623
|
// This type does not need a destructor
|
|
1438
1624
|
});
|
|
1439
|
-
},
|
|
1440
|
-
|
|
1441
|
-
var
|
|
1625
|
+
}, ci = (e, t, r, i, o) => {
|
|
1626
|
+
t = Y(t), o === -1 && (o = 4294967295);
|
|
1627
|
+
var l = (_) => _;
|
|
1442
1628
|
if (i === 0) {
|
|
1443
|
-
var
|
|
1444
|
-
|
|
1629
|
+
var d = 32 - 8 * r;
|
|
1630
|
+
l = (_) => _ << d >>> d;
|
|
1445
1631
|
}
|
|
1446
|
-
var
|
|
1447
|
-
if (typeof
|
|
1448
|
-
throw new TypeError(`Cannot convert "${
|
|
1449
|
-
if (
|
|
1450
|
-
throw new TypeError(`Passing a number "${
|
|
1451
|
-
},
|
|
1452
|
-
|
|
1453
|
-
return
|
|
1454
|
-
} :
|
|
1455
|
-
return
|
|
1632
|
+
var s = t.includes("unsigned"), u = (_, w) => {
|
|
1633
|
+
if (typeof _ != "number" && typeof _ != "boolean")
|
|
1634
|
+
throw new TypeError(`Cannot convert "${de(_)}" to ${w}`);
|
|
1635
|
+
if (_ < i || _ > o)
|
|
1636
|
+
throw new TypeError(`Passing a number "${de(_)}" from JS side to C/C++ side to an argument of type "${t}", which is outside the valid range [${i}, ${o}]!`);
|
|
1637
|
+
}, v;
|
|
1638
|
+
s ? v = function(_, w) {
|
|
1639
|
+
return u(w, this.name), w >>> 0;
|
|
1640
|
+
} : v = function(_, w) {
|
|
1641
|
+
return u(w, this.name), w;
|
|
1456
1642
|
}, ee(e, {
|
|
1457
|
-
name:
|
|
1458
|
-
fromWireType:
|
|
1459
|
-
toWireType:
|
|
1643
|
+
name: t,
|
|
1644
|
+
fromWireType: l,
|
|
1645
|
+
toWireType: v,
|
|
1460
1646
|
argPackAdvance: ie,
|
|
1461
|
-
readValueFromPointer:
|
|
1647
|
+
readValueFromPointer: Yt(t, r, i !== 0),
|
|
1462
1648
|
destructorFunction: null
|
|
1463
1649
|
// This type does not need a destructor
|
|
1464
1650
|
});
|
|
1465
|
-
},
|
|
1651
|
+
}, ui = (e, t, r) => {
|
|
1466
1652
|
var i = [
|
|
1467
1653
|
Int8Array,
|
|
1468
1654
|
Uint8Array,
|
|
@@ -1474,511 +1660,511 @@ ${p}`, [m, p];
|
|
|
1474
1660
|
Float64Array,
|
|
1475
1661
|
BigInt64Array,
|
|
1476
1662
|
BigUint64Array
|
|
1477
|
-
],
|
|
1478
|
-
function
|
|
1479
|
-
var
|
|
1480
|
-
return new
|
|
1663
|
+
], o = i[t];
|
|
1664
|
+
function l(d) {
|
|
1665
|
+
var s = k[d >> 2], u = k[d + 4 >> 2];
|
|
1666
|
+
return new o(ne.buffer, u, s);
|
|
1481
1667
|
}
|
|
1482
|
-
|
|
1483
|
-
name:
|
|
1484
|
-
fromWireType:
|
|
1668
|
+
r = Y(r), ee(e, {
|
|
1669
|
+
name: r,
|
|
1670
|
+
fromWireType: l,
|
|
1485
1671
|
argPackAdvance: ie,
|
|
1486
|
-
readValueFromPointer:
|
|
1672
|
+
readValueFromPointer: l
|
|
1487
1673
|
}, {
|
|
1488
1674
|
ignoreDuplicateRegistrations: !0
|
|
1489
1675
|
});
|
|
1490
|
-
},
|
|
1491
|
-
ee(e,
|
|
1492
|
-
},
|
|
1493
|
-
for (var
|
|
1494
|
-
var i = e.charCodeAt(
|
|
1495
|
-
i <= 127 ?
|
|
1676
|
+
}, fi = Object.assign({ optional: !0 }, ar), pi = (e, t) => {
|
|
1677
|
+
ee(e, fi);
|
|
1678
|
+
}, dt = (e) => {
|
|
1679
|
+
for (var t = 0, r = 0; r < e.length; ++r) {
|
|
1680
|
+
var i = e.charCodeAt(r);
|
|
1681
|
+
i <= 127 ? t++ : i <= 2047 ? t += 2 : i >= 55296 && i <= 57343 ? (t += 4, ++r) : t += 3;
|
|
1496
1682
|
}
|
|
1497
|
-
return
|
|
1498
|
-
},
|
|
1499
|
-
|
|
1500
|
-
name:
|
|
1683
|
+
return t;
|
|
1684
|
+
}, vi = (e, t) => {
|
|
1685
|
+
t = Y(t), ee(e, {
|
|
1686
|
+
name: t,
|
|
1501
1687
|
// For some method names we use string keys here since they are part of
|
|
1502
1688
|
// the public/external API and/or used by the runtime-generated code.
|
|
1503
|
-
fromWireType(
|
|
1504
|
-
for (var i =
|
|
1505
|
-
var
|
|
1506
|
-
if (
|
|
1507
|
-
var
|
|
1508
|
-
|
|
1689
|
+
fromWireType(r) {
|
|
1690
|
+
for (var i = k[r >> 2], o = r + 4, l, d, s = o, d = 0; d <= i; ++d) {
|
|
1691
|
+
var u = o + d;
|
|
1692
|
+
if (d == i || K[u] == 0) {
|
|
1693
|
+
var v = u - s, _ = xe(s, v);
|
|
1694
|
+
l === void 0 ? l = _ : (l += "\0", l += _), s = u + 1;
|
|
1509
1695
|
}
|
|
1510
1696
|
}
|
|
1511
|
-
return
|
|
1697
|
+
return se(r), l;
|
|
1512
1698
|
},
|
|
1513
|
-
toWireType(
|
|
1699
|
+
toWireType(r, i) {
|
|
1514
1700
|
i instanceof ArrayBuffer && (i = new Uint8Array(i));
|
|
1515
|
-
var
|
|
1516
|
-
|
|
1517
|
-
var
|
|
1518
|
-
if (
|
|
1519
|
-
|
|
1520
|
-
else if (
|
|
1521
|
-
for (var
|
|
1522
|
-
var
|
|
1523
|
-
|
|
1701
|
+
var o, l = typeof i == "string";
|
|
1702
|
+
l || i instanceof Uint8Array || i instanceof Uint8ClampedArray || i instanceof Int8Array || R("Cannot pass non-string to std::string"), l ? o = dt(i) : o = i.length;
|
|
1703
|
+
var d = vt(4 + o + 1), s = d + 4;
|
|
1704
|
+
if (k[d >> 2] = o, S(o), l)
|
|
1705
|
+
Se(i, s, o + 1);
|
|
1706
|
+
else if (l)
|
|
1707
|
+
for (var u = 0; u < o; ++u) {
|
|
1708
|
+
var v = i.charCodeAt(u);
|
|
1709
|
+
v > 255 && (se(d), R("String has UTF-16 code units that do not fit in 8 bits")), K[s + u] = v;
|
|
1524
1710
|
}
|
|
1525
1711
|
else
|
|
1526
|
-
for (var
|
|
1527
|
-
|
|
1528
|
-
return
|
|
1712
|
+
for (var u = 0; u < o; ++u)
|
|
1713
|
+
K[s + u] = i[u];
|
|
1714
|
+
return r !== null && r.push(se, d), d;
|
|
1529
1715
|
},
|
|
1530
1716
|
argPackAdvance: ie,
|
|
1531
|
-
readValueFromPointer:
|
|
1532
|
-
destructorFunction(
|
|
1533
|
-
|
|
1717
|
+
readValueFromPointer: Fe,
|
|
1718
|
+
destructorFunction(r) {
|
|
1719
|
+
se(r);
|
|
1534
1720
|
}
|
|
1535
1721
|
});
|
|
1536
|
-
},
|
|
1537
|
-
|
|
1538
|
-
for (var
|
|
1539
|
-
if (
|
|
1540
|
-
return
|
|
1541
|
-
for (var
|
|
1542
|
-
var
|
|
1543
|
-
if (
|
|
1544
|
-
|
|
1722
|
+
}, or = typeof TextDecoder < "u" ? new TextDecoder("utf-16le") : void 0, yi = (e, t) => {
|
|
1723
|
+
g(e % 2 == 0, "Pointer passed to UTF16ToString must be aligned to two bytes!");
|
|
1724
|
+
for (var r = e, i = r >> 1, o = i + t / 2; !(i >= o) && De[i]; ) ++i;
|
|
1725
|
+
if (r = i << 1, r - e > 32 && or)
|
|
1726
|
+
return or.decode(K.subarray(e, r));
|
|
1727
|
+
for (var l = "", d = 0; !(d >= t / 2); ++d) {
|
|
1728
|
+
var s = ge[e + d * 2 >> 1];
|
|
1729
|
+
if (s == 0) break;
|
|
1730
|
+
l += String.fromCharCode(s);
|
|
1545
1731
|
}
|
|
1546
|
-
return
|
|
1547
|
-
},
|
|
1548
|
-
if (
|
|
1549
|
-
|
|
1550
|
-
for (var i =
|
|
1551
|
-
var
|
|
1552
|
-
|
|
1732
|
+
return l;
|
|
1733
|
+
}, gi = (e, t, r) => {
|
|
1734
|
+
if (g(t % 2 == 0, "Pointer passed to stringToUTF16 must be aligned to two bytes!"), g(typeof r == "number", "stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!"), r ??= 2147483647, r < 2) return 0;
|
|
1735
|
+
r -= 2;
|
|
1736
|
+
for (var i = t, o = r < e.length * 2 ? r / 2 : e.length, l = 0; l < o; ++l) {
|
|
1737
|
+
var d = e.charCodeAt(l);
|
|
1738
|
+
ge[t >> 1] = d, et(d), t += 2;
|
|
1553
1739
|
}
|
|
1554
|
-
return
|
|
1555
|
-
},
|
|
1556
|
-
|
|
1557
|
-
for (var
|
|
1558
|
-
var
|
|
1559
|
-
if (
|
|
1560
|
-
if (++
|
|
1561
|
-
var
|
|
1562
|
-
i += String.fromCharCode(55296 |
|
|
1740
|
+
return ge[t >> 1] = 0, et(0), t - i;
|
|
1741
|
+
}, _i = (e) => e.length * 2, mi = (e, t) => {
|
|
1742
|
+
g(e % 4 == 0, "Pointer passed to UTF32ToString must be aligned to four bytes!");
|
|
1743
|
+
for (var r = 0, i = ""; !(r >= t / 4); ) {
|
|
1744
|
+
var o = E[e + r * 4 >> 2];
|
|
1745
|
+
if (o == 0) break;
|
|
1746
|
+
if (++r, o >= 65536) {
|
|
1747
|
+
var l = o - 65536;
|
|
1748
|
+
i += String.fromCharCode(55296 | l >> 10, 56320 | l & 1023);
|
|
1563
1749
|
} else
|
|
1564
|
-
i += String.fromCharCode(
|
|
1750
|
+
i += String.fromCharCode(o);
|
|
1565
1751
|
}
|
|
1566
1752
|
return i;
|
|
1567
|
-
},
|
|
1568
|
-
if (
|
|
1569
|
-
for (var i =
|
|
1570
|
-
var
|
|
1571
|
-
if (
|
|
1572
|
-
var
|
|
1573
|
-
|
|
1753
|
+
}, hi = (e, t, r) => {
|
|
1754
|
+
if (g(t % 4 == 0, "Pointer passed to stringToUTF32 must be aligned to four bytes!"), g(typeof r == "number", "stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!"), r ??= 2147483647, r < 4) return 0;
|
|
1755
|
+
for (var i = t, o = i + r - 4, l = 0; l < e.length; ++l) {
|
|
1756
|
+
var d = e.charCodeAt(l);
|
|
1757
|
+
if (d >= 55296 && d <= 57343) {
|
|
1758
|
+
var s = e.charCodeAt(++l);
|
|
1759
|
+
d = 65536 + ((d & 1023) << 10) | s & 1023;
|
|
1574
1760
|
}
|
|
1575
|
-
if (
|
|
1761
|
+
if (E[t >> 2] = d, S(d), t += 4, t + 4 > o) break;
|
|
1576
1762
|
}
|
|
1577
|
-
return
|
|
1578
|
-
},
|
|
1579
|
-
for (var
|
|
1580
|
-
var i = e.charCodeAt(
|
|
1581
|
-
i >= 55296 && i <= 57343 && ++
|
|
1763
|
+
return E[t >> 2] = 0, S(0), t - i;
|
|
1764
|
+
}, bi = (e) => {
|
|
1765
|
+
for (var t = 0, r = 0; r < e.length; ++r) {
|
|
1766
|
+
var i = e.charCodeAt(r);
|
|
1767
|
+
i >= 55296 && i <= 57343 && ++r, t += 4;
|
|
1582
1768
|
}
|
|
1583
|
-
return
|
|
1584
|
-
},
|
|
1585
|
-
|
|
1586
|
-
var i,
|
|
1587
|
-
|
|
1588
|
-
name:
|
|
1589
|
-
fromWireType: (
|
|
1590
|
-
for (var
|
|
1591
|
-
var
|
|
1592
|
-
if (
|
|
1593
|
-
var
|
|
1594
|
-
|
|
1769
|
+
return t;
|
|
1770
|
+
}, wi = (e, t, r) => {
|
|
1771
|
+
r = Y(r);
|
|
1772
|
+
var i, o, l, d;
|
|
1773
|
+
t === 2 ? (i = yi, o = gi, d = _i, l = (s) => De[s >> 1]) : t === 4 && (i = mi, o = hi, d = bi, l = (s) => k[s >> 2]), ee(e, {
|
|
1774
|
+
name: r,
|
|
1775
|
+
fromWireType: (s) => {
|
|
1776
|
+
for (var u = k[s >> 2], v, _ = s + 4, w = 0; w <= u; ++w) {
|
|
1777
|
+
var U = s + 4 + w * t;
|
|
1778
|
+
if (w == u || l(U) == 0) {
|
|
1779
|
+
var D = U - _, x = i(_, D);
|
|
1780
|
+
v === void 0 ? v = x : (v += "\0", v += x), _ = U + t;
|
|
1595
1781
|
}
|
|
1596
1782
|
}
|
|
1597
|
-
return
|
|
1783
|
+
return se(s), v;
|
|
1598
1784
|
},
|
|
1599
|
-
toWireType: (
|
|
1600
|
-
typeof
|
|
1601
|
-
var
|
|
1602
|
-
return
|
|
1785
|
+
toWireType: (s, u) => {
|
|
1786
|
+
typeof u != "string" && R(`Cannot pass non-string to C++ string type ${r}`);
|
|
1787
|
+
var v = d(u), _ = vt(4 + v + t);
|
|
1788
|
+
return k[_ >> 2] = v / t, S(v / t), o(u, _ + 4, v + t), s !== null && s.push(se, _), _;
|
|
1603
1789
|
},
|
|
1604
1790
|
argPackAdvance: ie,
|
|
1605
|
-
readValueFromPointer:
|
|
1606
|
-
destructorFunction(
|
|
1607
|
-
|
|
1791
|
+
readValueFromPointer: Fe,
|
|
1792
|
+
destructorFunction(s) {
|
|
1793
|
+
se(s);
|
|
1608
1794
|
}
|
|
1609
1795
|
});
|
|
1610
|
-
},
|
|
1611
|
-
|
|
1612
|
-
name:
|
|
1613
|
-
rawConstructor:
|
|
1614
|
-
rawDestructor:
|
|
1796
|
+
}, Ci = (e, t, r, i, o, l) => {
|
|
1797
|
+
je[e] = {
|
|
1798
|
+
name: Y(t),
|
|
1799
|
+
rawConstructor: ae(r, i),
|
|
1800
|
+
rawDestructor: ae(o, l),
|
|
1615
1801
|
fields: []
|
|
1616
1802
|
};
|
|
1617
|
-
},
|
|
1618
|
-
|
|
1619
|
-
fieldName:
|
|
1620
|
-
getterReturnType:
|
|
1621
|
-
getter:
|
|
1622
|
-
getterContext:
|
|
1623
|
-
setterArgumentType:
|
|
1624
|
-
setter:
|
|
1625
|
-
setterContext:
|
|
1803
|
+
}, Ti = (e, t, r, i, o, l, d, s, u, v) => {
|
|
1804
|
+
je[e].fields.push({
|
|
1805
|
+
fieldName: Y(t),
|
|
1806
|
+
getterReturnType: r,
|
|
1807
|
+
getter: ae(i, o),
|
|
1808
|
+
getterContext: l,
|
|
1809
|
+
setterArgumentType: d,
|
|
1810
|
+
setter: ae(s, u),
|
|
1811
|
+
setterContext: v
|
|
1626
1812
|
});
|
|
1627
|
-
},
|
|
1628
|
-
|
|
1813
|
+
}, Ei = (e, t) => {
|
|
1814
|
+
t = Y(t), ee(e, {
|
|
1629
1815
|
isVoid: !0,
|
|
1630
1816
|
// void return values can be optimized out sometimes
|
|
1631
|
-
name:
|
|
1817
|
+
name: t,
|
|
1632
1818
|
argPackAdvance: 0,
|
|
1633
1819
|
fromWireType: () => {
|
|
1634
1820
|
},
|
|
1635
1821
|
// TODO: assert if anything else is given?
|
|
1636
|
-
toWireType: (
|
|
1822
|
+
toWireType: (r, i) => {
|
|
1637
1823
|
}
|
|
1638
1824
|
});
|
|
1639
|
-
},
|
|
1640
|
-
var
|
|
1641
|
-
return
|
|
1642
|
-
},
|
|
1643
|
-
var i = [],
|
|
1644
|
-
return i.length && (
|
|
1645
|
-
},
|
|
1646
|
-
var
|
|
1647
|
-
return
|
|
1825
|
+
}, ct = (e, t) => {
|
|
1826
|
+
var r = ve[e];
|
|
1827
|
+
return r === void 0 && R(`${t} has unknown type ${er(e)}`), r;
|
|
1828
|
+
}, sr = (e, t, r) => {
|
|
1829
|
+
var i = [], o = e.toWireType(i, r);
|
|
1830
|
+
return i.length && (k[t >> 2] = G.toHandle(i)), o;
|
|
1831
|
+
}, Ai = (e, t, r) => (e = G.toValue(e), t = ct(t, "emval::as"), sr(t, r, e)), lr = (e) => h.handleAsync(async () => {
|
|
1832
|
+
var t = await G.toValue(e);
|
|
1833
|
+
return G.toHandle(t);
|
|
1648
1834
|
});
|
|
1649
|
-
|
|
1650
|
-
var
|
|
1651
|
-
var
|
|
1652
|
-
return
|
|
1653
|
-
},
|
|
1654
|
-
for (var
|
|
1655
|
-
|
|
1656
|
-
|
|
1835
|
+
lr.isAsync = !0;
|
|
1836
|
+
var ut = [], Si = (e, t, r, i) => (e = ut[e], t = G.toValue(t), e(null, t, r, i)), Fi = (e) => {
|
|
1837
|
+
var t = ut.length;
|
|
1838
|
+
return ut.push(e), t;
|
|
1839
|
+
}, Ii = (e, t) => {
|
|
1840
|
+
for (var r = new Array(e), i = 0; i < e; ++i)
|
|
1841
|
+
r[i] = ct(
|
|
1842
|
+
k[t + i * 4 >> 2],
|
|
1657
1843
|
"parameter " + i
|
|
1658
1844
|
);
|
|
1659
|
-
return
|
|
1660
|
-
},
|
|
1661
|
-
var i =
|
|
1845
|
+
return r;
|
|
1846
|
+
}, $i = (e, t, r) => {
|
|
1847
|
+
var i = Ii(e, t), o = i.shift();
|
|
1662
1848
|
e--;
|
|
1663
|
-
var
|
|
1664
|
-
`,
|
|
1665
|
-
|
|
1666
|
-
0 &&
|
|
1667
|
-
for (var
|
|
1668
|
-
|
|
1669
|
-
`,
|
|
1670
|
-
var
|
|
1849
|
+
var l = `return function (obj, func, destructorsRef, args) {
|
|
1850
|
+
`, d = 0, s = [];
|
|
1851
|
+
r === /* FUNCTION */
|
|
1852
|
+
0 && s.push("obj");
|
|
1853
|
+
for (var u = ["retType"], v = [o], _ = 0; _ < e; ++_)
|
|
1854
|
+
s.push("arg" + _), u.push("argType" + _), v.push(i[_]), l += ` var arg${_} = argType${_}.readValueFromPointer(args${d ? "+" + d : ""});
|
|
1855
|
+
`, d += i[_].argPackAdvance;
|
|
1856
|
+
var w = r === /* CONSTRUCTOR */
|
|
1671
1857
|
1 ? "new func" : "func.call";
|
|
1672
|
-
|
|
1673
|
-
`,
|
|
1674
|
-
`),
|
|
1675
|
-
`,
|
|
1676
|
-
var
|
|
1677
|
-
return
|
|
1678
|
-
},
|
|
1679
|
-
e > 9 && (
|
|
1680
|
-
},
|
|
1681
|
-
var
|
|
1682
|
-
return
|
|
1683
|
-
},
|
|
1684
|
-
var
|
|
1685
|
-
|
|
1686
|
-
},
|
|
1687
|
-
e =
|
|
1688
|
-
var
|
|
1689
|
-
return
|
|
1690
|
-
},
|
|
1691
|
-
function
|
|
1692
|
-
e =
|
|
1693
|
-
var
|
|
1694
|
-
|
|
1695
|
-
var i = Date.UTC(
|
|
1696
|
-
|
|
1858
|
+
l += ` var rv = ${w}(${s.join(", ")});
|
|
1859
|
+
`, o.isVoid || (u.push("emval_returnValue"), v.push(sr), l += ` return emval_returnValue(retType, destructorsRef, rv);
|
|
1860
|
+
`), l += `};
|
|
1861
|
+
`, u.push(l);
|
|
1862
|
+
var U = nr(Function, u)(...v), D = `methodCaller<(${i.map((x) => x.name).join(", ")}) => ${o.name}>`;
|
|
1863
|
+
return Fi($e(D, U));
|
|
1864
|
+
}, Pi = (e, t) => (e = G.toValue(e), t = G.toValue(t), G.toHandle(e[t])), ki = (e) => {
|
|
1865
|
+
e > 9 && (X[e + 1] += 1);
|
|
1866
|
+
}, Ui = {}, Mi = (e) => {
|
|
1867
|
+
var t = Ui[e];
|
|
1868
|
+
return t === void 0 ? Y(e) : t;
|
|
1869
|
+
}, Ri = (e) => G.toHandle(Mi(e)), Di = (e) => {
|
|
1870
|
+
var t = G.toValue(e);
|
|
1871
|
+
rt(t), lt(e);
|
|
1872
|
+
}, Li = (e, t) => {
|
|
1873
|
+
e = ct(e, "_emval_take_value");
|
|
1874
|
+
var r = e.readValueFromPointer(t);
|
|
1875
|
+
return G.toHandle(r);
|
|
1876
|
+
}, Oi = 9007199254740992, xi = -9007199254740992, dr = (e) => e < xi || e > Oi ? NaN : Number(e);
|
|
1877
|
+
function ji(e, t) {
|
|
1878
|
+
e = dr(e);
|
|
1879
|
+
var r = new Date(e * 1e3);
|
|
1880
|
+
E[t >> 2] = r.getUTCSeconds(), S(r.getUTCSeconds()), E[t + 4 >> 2] = r.getUTCMinutes(), S(r.getUTCMinutes()), E[t + 8 >> 2] = r.getUTCHours(), S(r.getUTCHours()), E[t + 12 >> 2] = r.getUTCDate(), S(r.getUTCDate()), E[t + 16 >> 2] = r.getUTCMonth(), S(r.getUTCMonth()), E[t + 20 >> 2] = r.getUTCFullYear() - 1900, S(r.getUTCFullYear() - 1900), E[t + 24 >> 2] = r.getUTCDay(), S(r.getUTCDay());
|
|
1881
|
+
var i = Date.UTC(r.getUTCFullYear(), 0, 1, 0, 0, 0, 0), o = (r.getTime() - i) / (1e3 * 60 * 60 * 24) | 0;
|
|
1882
|
+
E[t + 28 >> 2] = o, S(o);
|
|
1697
1883
|
}
|
|
1698
|
-
var
|
|
1699
|
-
var
|
|
1884
|
+
var Ni = (e) => e % 4 === 0 && (e % 100 !== 0 || e % 400 === 0), Wi = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335], Bi = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334], cr = (e) => {
|
|
1885
|
+
var t = Ni(e.getFullYear()), r = t ? Wi : Bi, i = r[e.getMonth()] + e.getDate() - 1;
|
|
1700
1886
|
return i;
|
|
1701
1887
|
};
|
|
1702
|
-
function
|
|
1703
|
-
e =
|
|
1704
|
-
var
|
|
1705
|
-
|
|
1706
|
-
var i =
|
|
1707
|
-
|
|
1708
|
-
var
|
|
1709
|
-
|
|
1888
|
+
function Hi(e, t) {
|
|
1889
|
+
e = dr(e);
|
|
1890
|
+
var r = new Date(e * 1e3);
|
|
1891
|
+
E[t >> 2] = r.getSeconds(), S(r.getSeconds()), E[t + 4 >> 2] = r.getMinutes(), S(r.getMinutes()), E[t + 8 >> 2] = r.getHours(), S(r.getHours()), E[t + 12 >> 2] = r.getDate(), S(r.getDate()), E[t + 16 >> 2] = r.getMonth(), S(r.getMonth()), E[t + 20 >> 2] = r.getFullYear() - 1900, S(r.getFullYear() - 1900), E[t + 24 >> 2] = r.getDay(), S(r.getDay());
|
|
1892
|
+
var i = cr(r) | 0;
|
|
1893
|
+
E[t + 28 >> 2] = i, S(i), E[t + 36 >> 2] = -(r.getTimezoneOffset() * 60), S(-(r.getTimezoneOffset() * 60));
|
|
1894
|
+
var o = new Date(r.getFullYear(), 0, 1), l = new Date(r.getFullYear(), 6, 1).getTimezoneOffset(), d = o.getTimezoneOffset(), s = (l != d && r.getTimezoneOffset() == Math.min(d, l)) | 0;
|
|
1895
|
+
E[t + 32 >> 2] = s, S(s);
|
|
1710
1896
|
}
|
|
1711
|
-
var
|
|
1712
|
-
var
|
|
1713
|
-
var
|
|
1714
|
-
|
|
1715
|
-
|
|
1716
|
-
|
|
1717
|
-
|
|
1718
|
-
|
|
1719
|
-
|
|
1897
|
+
var Vi = function(e) {
|
|
1898
|
+
var t = (() => {
|
|
1899
|
+
var r = new Date(
|
|
1900
|
+
E[e + 20 >> 2] + 1900,
|
|
1901
|
+
E[e + 16 >> 2],
|
|
1902
|
+
E[e + 12 >> 2],
|
|
1903
|
+
E[e + 8 >> 2],
|
|
1904
|
+
E[e + 4 >> 2],
|
|
1905
|
+
E[e >> 2],
|
|
1720
1906
|
0
|
|
1721
|
-
), i =
|
|
1907
|
+
), i = E[e + 32 >> 2], o = r.getTimezoneOffset(), l = new Date(r.getFullYear(), 0, 1), d = new Date(r.getFullYear(), 6, 1).getTimezoneOffset(), s = l.getTimezoneOffset(), u = Math.min(s, d);
|
|
1722
1908
|
if (i < 0)
|
|
1723
|
-
|
|
1724
|
-
else if (i > 0 != (
|
|
1725
|
-
var
|
|
1726
|
-
|
|
1909
|
+
E[e + 32 >> 2] = +(d != s && u == o), S(+(d != s && u == o));
|
|
1910
|
+
else if (i > 0 != (u == o)) {
|
|
1911
|
+
var v = Math.max(s, d), _ = i > 0 ? u : v;
|
|
1912
|
+
r.setTime(r.getTime() + (_ - o) * 6e4);
|
|
1727
1913
|
}
|
|
1728
|
-
|
|
1729
|
-
var
|
|
1730
|
-
|
|
1731
|
-
var
|
|
1732
|
-
return isNaN(
|
|
1914
|
+
E[e + 24 >> 2] = r.getDay(), S(r.getDay());
|
|
1915
|
+
var w = cr(r) | 0;
|
|
1916
|
+
E[e + 28 >> 2] = w, S(w), E[e >> 2] = r.getSeconds(), S(r.getSeconds()), E[e + 4 >> 2] = r.getMinutes(), S(r.getMinutes()), E[e + 8 >> 2] = r.getHours(), S(r.getHours()), E[e + 12 >> 2] = r.getDate(), S(r.getDate()), E[e + 16 >> 2] = r.getMonth(), S(r.getMonth()), E[e + 20 >> 2] = r.getYear(), S(r.getYear());
|
|
1917
|
+
var U = r.getTime();
|
|
1918
|
+
return isNaN(U) ? -1 : U / 1e3;
|
|
1733
1919
|
})();
|
|
1734
|
-
return BigInt(
|
|
1735
|
-
},
|
|
1736
|
-
var
|
|
1737
|
-
|
|
1738
|
-
var
|
|
1739
|
-
var
|
|
1740
|
-
return `UTC${
|
|
1741
|
-
},
|
|
1742
|
-
|
|
1743
|
-
},
|
|
1744
|
-
function
|
|
1745
|
-
if (!
|
|
1920
|
+
return BigInt(t);
|
|
1921
|
+
}, Yi = (e, t, r, i) => {
|
|
1922
|
+
var o = (/* @__PURE__ */ new Date()).getFullYear(), l = new Date(o, 0, 1), d = new Date(o, 6, 1), s = l.getTimezoneOffset(), u = d.getTimezoneOffset(), v = Math.max(s, u);
|
|
1923
|
+
k[e >> 2] = v * 60, S(v * 60), E[t >> 2] = +(s != u), S(+(s != u));
|
|
1924
|
+
var _ = (D) => {
|
|
1925
|
+
var x = D >= 0 ? "-" : "+", z = Math.abs(D), te = String(Math.floor(z / 60)).padStart(2, "0"), J = String(z % 60).padStart(2, "0");
|
|
1926
|
+
return `UTC${x}${te}${J}`;
|
|
1927
|
+
}, w = _(s), U = _(u);
|
|
1928
|
+
g(w), g(U), g(dt(w) <= 16, `timezone name truncated to fit in TZNAME_MAX (${w})`), g(dt(U) <= 16, `timezone name truncated to fit in TZNAME_MAX (${U})`), u < s ? (Se(w, r, 17), Se(U, i, 17)) : (Se(w, i, 17), Se(U, r, 17));
|
|
1929
|
+
}, ze = () => performance.now(), ur = () => Date.now(), zi = (e) => e >= 0 && e <= 3;
|
|
1930
|
+
function Gi(e, t, r) {
|
|
1931
|
+
if (!zi(e))
|
|
1746
1932
|
return 28;
|
|
1747
1933
|
var i;
|
|
1748
|
-
e === 0 ? i =
|
|
1749
|
-
var
|
|
1750
|
-
return
|
|
1934
|
+
e === 0 ? i = ur() : i = ze();
|
|
1935
|
+
var o = Math.round(i * 1e3 * 1e3);
|
|
1936
|
+
return be[r >> 3] = BigInt(o), tt(o), 0;
|
|
1751
1937
|
}
|
|
1752
|
-
var
|
|
1938
|
+
var fr = () => (
|
|
1753
1939
|
// Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
|
|
1754
1940
|
// full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
|
|
1755
1941
|
// for any code that deals with heap sizes, which would require special
|
|
1756
1942
|
// casing all heap size related code to treat 0 specially.
|
|
1757
1943
|
2147483648
|
|
1758
|
-
),
|
|
1759
|
-
var
|
|
1944
|
+
), Ji = () => fr(), qi = (e, t) => (g(t, "alignment argument is required"), Math.ceil(e / t) * t), Ki = (e) => {
|
|
1945
|
+
var t = W.buffer, r = (e - t.byteLength + 65535) / 65536 | 0;
|
|
1760
1946
|
try {
|
|
1761
|
-
return
|
|
1947
|
+
return W.grow(r), Ot(), 1;
|
|
1762
1948
|
} catch (i) {
|
|
1763
|
-
|
|
1949
|
+
$(`growMemory: Attempted to grow heap from ${t.byteLength} bytes to ${e} bytes, but got error: ${i}`);
|
|
1764
1950
|
}
|
|
1765
|
-
},
|
|
1766
|
-
var
|
|
1767
|
-
e >>>= 0,
|
|
1768
|
-
var
|
|
1769
|
-
if (e >
|
|
1770
|
-
return
|
|
1951
|
+
}, Qi = (e) => {
|
|
1952
|
+
var t = K.length;
|
|
1953
|
+
e >>>= 0, g(e > t);
|
|
1954
|
+
var r = fr();
|
|
1955
|
+
if (e > r)
|
|
1956
|
+
return $(`Cannot enlarge memory, requested ${e} bytes, but the limit is ${r} bytes!`), !1;
|
|
1771
1957
|
for (var i = 1; i <= 4; i *= 2) {
|
|
1772
|
-
var
|
|
1773
|
-
|
|
1774
|
-
var
|
|
1775
|
-
if (
|
|
1958
|
+
var o = t * (1 + 0.2 / i);
|
|
1959
|
+
o = Math.min(o, e + 100663296);
|
|
1960
|
+
var l = Math.min(r, qi(Math.max(e, o), 65536)), d = ze(), s = Ki(l), u = ze();
|
|
1961
|
+
if (Wr(`Heap resize call from ${t} to ${l} took ${u - d} msecs. Success: ${!!s}`), s)
|
|
1776
1962
|
return !0;
|
|
1777
1963
|
}
|
|
1778
|
-
return
|
|
1779
|
-
},
|
|
1780
|
-
if (!
|
|
1781
|
-
var e = (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8",
|
|
1964
|
+
return $(`Failed to grow the heap from ${t} bytes to ${l} bytes, not enough memory!`), !1;
|
|
1965
|
+
}, ft = {}, Xi = () => j || "./this.program", Pe = () => {
|
|
1966
|
+
if (!Pe.strings) {
|
|
1967
|
+
var e = (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8", t = {
|
|
1782
1968
|
USER: "web_user",
|
|
1783
1969
|
LOGNAME: "web_user",
|
|
1784
1970
|
PATH: "/",
|
|
1785
1971
|
PWD: "/",
|
|
1786
1972
|
HOME: "/home/web_user",
|
|
1787
1973
|
LANG: e,
|
|
1788
|
-
_:
|
|
1974
|
+
_: Xi()
|
|
1789
1975
|
};
|
|
1790
|
-
for (var
|
|
1791
|
-
|
|
1976
|
+
for (var r in ft)
|
|
1977
|
+
ft[r] === void 0 ? delete t[r] : t[r] = ft[r];
|
|
1792
1978
|
var i = [];
|
|
1793
|
-
for (var
|
|
1794
|
-
i.push(`${
|
|
1795
|
-
|
|
1979
|
+
for (var r in t)
|
|
1980
|
+
i.push(`${r}=${t[r]}`);
|
|
1981
|
+
Pe.strings = i;
|
|
1796
1982
|
}
|
|
1797
|
-
return
|
|
1798
|
-
},
|
|
1799
|
-
for (var
|
|
1800
|
-
|
|
1801
|
-
|
|
1802
|
-
},
|
|
1803
|
-
var
|
|
1804
|
-
return
|
|
1805
|
-
var
|
|
1806
|
-
|
|
1983
|
+
return Pe.strings;
|
|
1984
|
+
}, Zi = (e, t) => {
|
|
1985
|
+
for (var r = 0; r < e.length; ++r)
|
|
1986
|
+
g(e.charCodeAt(r) === (e.charCodeAt(r) & 255)), ne[t++] = e.charCodeAt(r), we(e.charCodeAt(r));
|
|
1987
|
+
ne[t] = 0, we(0);
|
|
1988
|
+
}, ea = (e, t) => {
|
|
1989
|
+
var r = 0;
|
|
1990
|
+
return Pe().forEach((i, o) => {
|
|
1991
|
+
var l = t + r;
|
|
1992
|
+
k[e + o * 4 >> 2] = l, S(l), Zi(i, l), r += i.length + 1;
|
|
1807
1993
|
}), 0;
|
|
1808
|
-
},
|
|
1809
|
-
var
|
|
1810
|
-
|
|
1994
|
+
}, ta = (e, t) => {
|
|
1995
|
+
var r = Pe();
|
|
1996
|
+
k[e >> 2] = r.length, S(r.length);
|
|
1811
1997
|
var i = 0;
|
|
1812
|
-
return
|
|
1813
|
-
},
|
|
1814
|
-
|
|
1815
|
-
},
|
|
1816
|
-
var
|
|
1998
|
+
return r.forEach((o) => i += o.length + 1), k[t >> 2] = i, S(i), 0;
|
|
1999
|
+
}, ra = (e) => {
|
|
2000
|
+
L("fd_close called without SYSCALLS_REQUIRE_FILESYSTEM");
|
|
2001
|
+
}, na = (e, t) => {
|
|
2002
|
+
var r = 0, i = 0, o = 0;
|
|
1817
2003
|
{
|
|
1818
|
-
|
|
1819
|
-
var
|
|
1820
|
-
e == 0 ?
|
|
2004
|
+
g(e == 0 || e == 1 || e == 2);
|
|
2005
|
+
var l = 2;
|
|
2006
|
+
e == 0 ? r = 2 : (e == 1 || e == 2) && (r = 64), o = 1;
|
|
1821
2007
|
}
|
|
1822
|
-
return
|
|
1823
|
-
},
|
|
1824
|
-
|
|
2008
|
+
return ne[t] = l, we(l), ge[t + 2 >> 1] = o, et(o), be[t + 8 >> 3] = BigInt(r), tt(r), be[t + 16 >> 3] = BigInt(i), tt(i), 0;
|
|
2009
|
+
}, ia = (e, t, r, i) => {
|
|
2010
|
+
L("fd_read called without SYSCALLS_REQUIRE_FILESYSTEM");
|
|
1825
2011
|
};
|
|
1826
|
-
function
|
|
2012
|
+
function aa(e, t, r, i) {
|
|
1827
2013
|
return 70;
|
|
1828
2014
|
}
|
|
1829
|
-
var
|
|
1830
|
-
var
|
|
1831
|
-
|
|
1832
|
-
},
|
|
1833
|
-
for (var
|
|
1834
|
-
var
|
|
1835
|
-
|
|
1836
|
-
for (var
|
|
1837
|
-
|
|
1838
|
-
|
|
2015
|
+
var oa = [null, [], []], sa = (e, t) => {
|
|
2016
|
+
var r = oa[e];
|
|
2017
|
+
g(r), t === 0 || t === 10 ? ((e === 1 ? I : $)(Bt(r)), r.length = 0) : r.push(t);
|
|
2018
|
+
}, la = (e, t, r, i) => {
|
|
2019
|
+
for (var o = 0, l = 0; l < r; l++) {
|
|
2020
|
+
var d = k[t >> 2], s = k[t + 4 >> 2];
|
|
2021
|
+
t += 8;
|
|
2022
|
+
for (var u = 0; u < s; u++)
|
|
2023
|
+
sa(e, K[d + u]);
|
|
2024
|
+
o += s;
|
|
1839
2025
|
}
|
|
1840
|
-
return
|
|
2026
|
+
return k[i >> 2] = o, S(o), 0;
|
|
1841
2027
|
};
|
|
1842
|
-
|
|
1843
|
-
constructor(
|
|
1844
|
-
super(
|
|
2028
|
+
Ht = a.InternalError = class extends Error {
|
|
2029
|
+
constructor(t) {
|
|
2030
|
+
super(t), this.name = "InternalError";
|
|
1845
2031
|
}
|
|
1846
|
-
},
|
|
1847
|
-
constructor(
|
|
1848
|
-
super(
|
|
2032
|
+
}, An(), he = a.BindingError = class extends Error {
|
|
2033
|
+
constructor(t) {
|
|
2034
|
+
super(t), this.name = "BindingError";
|
|
1849
2035
|
}
|
|
1850
|
-
},
|
|
1851
|
-
function
|
|
1852
|
-
|
|
2036
|
+
}, Rn(), Hn(), Zt = a.UnboundTypeError = Jn(Error, "UnboundTypeError"), oi();
|
|
2037
|
+
function da() {
|
|
2038
|
+
Pr("fetchSettings");
|
|
1853
2039
|
}
|
|
1854
|
-
var
|
|
2040
|
+
var pt = {
|
|
1855
2041
|
/** @export */
|
|
1856
|
-
__assert_fail:
|
|
2042
|
+
__assert_fail: an,
|
|
1857
2043
|
/** @export */
|
|
1858
|
-
__cxa_throw:
|
|
2044
|
+
__cxa_throw: sn,
|
|
1859
2045
|
/** @export */
|
|
1860
|
-
__handle_stack_overflow:
|
|
2046
|
+
__handle_stack_overflow: ln,
|
|
1861
2047
|
/** @export */
|
|
1862
|
-
__syscall_faccessat:
|
|
2048
|
+
__syscall_faccessat: dn,
|
|
1863
2049
|
/** @export */
|
|
1864
|
-
__syscall_fcntl64:
|
|
2050
|
+
__syscall_fcntl64: cn,
|
|
1865
2051
|
/** @export */
|
|
1866
|
-
__syscall_fstat64:
|
|
2052
|
+
__syscall_fstat64: un,
|
|
1867
2053
|
/** @export */
|
|
1868
|
-
__syscall_getdents64:
|
|
2054
|
+
__syscall_getdents64: pn,
|
|
1869
2055
|
/** @export */
|
|
1870
|
-
__syscall_ioctl:
|
|
2056
|
+
__syscall_ioctl: vn,
|
|
1871
2057
|
/** @export */
|
|
1872
|
-
__syscall_lstat64:
|
|
2058
|
+
__syscall_lstat64: yn,
|
|
1873
2059
|
/** @export */
|
|
1874
|
-
__syscall_mkdirat:
|
|
2060
|
+
__syscall_mkdirat: gn,
|
|
1875
2061
|
/** @export */
|
|
1876
|
-
__syscall_newfstatat:
|
|
2062
|
+
__syscall_newfstatat: _n,
|
|
1877
2063
|
/** @export */
|
|
1878
|
-
__syscall_openat:
|
|
2064
|
+
__syscall_openat: mn,
|
|
1879
2065
|
/** @export */
|
|
1880
|
-
__syscall_renameat:
|
|
2066
|
+
__syscall_renameat: hn,
|
|
1881
2067
|
/** @export */
|
|
1882
|
-
__syscall_rmdir:
|
|
2068
|
+
__syscall_rmdir: bn,
|
|
1883
2069
|
/** @export */
|
|
1884
|
-
__syscall_stat64:
|
|
2070
|
+
__syscall_stat64: wn,
|
|
1885
2071
|
/** @export */
|
|
1886
|
-
__syscall_unlinkat:
|
|
2072
|
+
__syscall_unlinkat: Cn,
|
|
1887
2073
|
/** @export */
|
|
1888
|
-
_abort_js:
|
|
2074
|
+
_abort_js: Tn,
|
|
1889
2075
|
/** @export */
|
|
1890
|
-
_embind_finalize_value_object:
|
|
2076
|
+
_embind_finalize_value_object: En,
|
|
1891
2077
|
/** @export */
|
|
1892
|
-
_embind_register_bigint:
|
|
2078
|
+
_embind_register_bigint: Fn,
|
|
1893
2079
|
/** @export */
|
|
1894
|
-
_embind_register_bool:
|
|
2080
|
+
_embind_register_bool: In,
|
|
1895
2081
|
/** @export */
|
|
1896
|
-
_embind_register_class:
|
|
2082
|
+
_embind_register_class: qn,
|
|
1897
2083
|
/** @export */
|
|
1898
|
-
_embind_register_class_constructor:
|
|
2084
|
+
_embind_register_class_constructor: ri,
|
|
1899
2085
|
/** @export */
|
|
1900
|
-
_embind_register_class_function:
|
|
2086
|
+
_embind_register_class_function: ii,
|
|
1901
2087
|
/** @export */
|
|
1902
|
-
_embind_register_emval:
|
|
2088
|
+
_embind_register_emval: si,
|
|
1903
2089
|
/** @export */
|
|
1904
|
-
_embind_register_float:
|
|
2090
|
+
_embind_register_float: di,
|
|
1905
2091
|
/** @export */
|
|
1906
|
-
_embind_register_integer:
|
|
2092
|
+
_embind_register_integer: ci,
|
|
1907
2093
|
/** @export */
|
|
1908
|
-
_embind_register_memory_view:
|
|
2094
|
+
_embind_register_memory_view: ui,
|
|
1909
2095
|
/** @export */
|
|
1910
|
-
_embind_register_optional:
|
|
2096
|
+
_embind_register_optional: pi,
|
|
1911
2097
|
/** @export */
|
|
1912
|
-
_embind_register_std_string:
|
|
2098
|
+
_embind_register_std_string: vi,
|
|
1913
2099
|
/** @export */
|
|
1914
|
-
_embind_register_std_wstring:
|
|
2100
|
+
_embind_register_std_wstring: wi,
|
|
1915
2101
|
/** @export */
|
|
1916
|
-
_embind_register_value_object:
|
|
2102
|
+
_embind_register_value_object: Ci,
|
|
1917
2103
|
/** @export */
|
|
1918
|
-
_embind_register_value_object_field:
|
|
2104
|
+
_embind_register_value_object_field: Ti,
|
|
1919
2105
|
/** @export */
|
|
1920
|
-
_embind_register_void:
|
|
2106
|
+
_embind_register_void: Ei,
|
|
1921
2107
|
/** @export */
|
|
1922
|
-
_emval_as:
|
|
2108
|
+
_emval_as: Ai,
|
|
1923
2109
|
/** @export */
|
|
1924
|
-
_emval_await:
|
|
2110
|
+
_emval_await: lr,
|
|
1925
2111
|
/** @export */
|
|
1926
|
-
_emval_call:
|
|
2112
|
+
_emval_call: Si,
|
|
1927
2113
|
/** @export */
|
|
1928
|
-
_emval_decref:
|
|
2114
|
+
_emval_decref: lt,
|
|
1929
2115
|
/** @export */
|
|
1930
|
-
_emval_get_method_caller:
|
|
2116
|
+
_emval_get_method_caller: $i,
|
|
1931
2117
|
/** @export */
|
|
1932
|
-
_emval_get_property:
|
|
2118
|
+
_emval_get_property: Pi,
|
|
1933
2119
|
/** @export */
|
|
1934
|
-
_emval_incref:
|
|
2120
|
+
_emval_incref: ki,
|
|
1935
2121
|
/** @export */
|
|
1936
|
-
_emval_new_cstring:
|
|
2122
|
+
_emval_new_cstring: Ri,
|
|
1937
2123
|
/** @export */
|
|
1938
|
-
_emval_run_destructors:
|
|
2124
|
+
_emval_run_destructors: Di,
|
|
1939
2125
|
/** @export */
|
|
1940
|
-
_emval_take_value:
|
|
2126
|
+
_emval_take_value: Li,
|
|
1941
2127
|
/** @export */
|
|
1942
|
-
_gmtime_js:
|
|
2128
|
+
_gmtime_js: ji,
|
|
1943
2129
|
/** @export */
|
|
1944
|
-
_localtime_js:
|
|
2130
|
+
_localtime_js: Hi,
|
|
1945
2131
|
/** @export */
|
|
1946
|
-
_mktime_js:
|
|
2132
|
+
_mktime_js: Vi,
|
|
1947
2133
|
/** @export */
|
|
1948
|
-
_tzset_js:
|
|
2134
|
+
_tzset_js: Yi,
|
|
1949
2135
|
/** @export */
|
|
1950
|
-
clock_time_get:
|
|
2136
|
+
clock_time_get: Gi,
|
|
1951
2137
|
/** @export */
|
|
1952
|
-
emscripten_date_now:
|
|
2138
|
+
emscripten_date_now: ur,
|
|
1953
2139
|
/** @export */
|
|
1954
|
-
emscripten_get_heap_max:
|
|
2140
|
+
emscripten_get_heap_max: Ji,
|
|
1955
2141
|
/** @export */
|
|
1956
|
-
emscripten_get_now:
|
|
2142
|
+
emscripten_get_now: ze,
|
|
1957
2143
|
/** @export */
|
|
1958
|
-
emscripten_resize_heap:
|
|
2144
|
+
emscripten_resize_heap: Qi,
|
|
1959
2145
|
/** @export */
|
|
1960
|
-
environ_get:
|
|
2146
|
+
environ_get: ea,
|
|
1961
2147
|
/** @export */
|
|
1962
|
-
environ_sizes_get:
|
|
2148
|
+
environ_sizes_get: ta,
|
|
1963
2149
|
/** @export */
|
|
1964
|
-
fd_close:
|
|
2150
|
+
fd_close: ra,
|
|
1965
2151
|
/** @export */
|
|
1966
|
-
fd_fdstat_get:
|
|
2152
|
+
fd_fdstat_get: na,
|
|
1967
2153
|
/** @export */
|
|
1968
|
-
fd_read:
|
|
2154
|
+
fd_read: ia,
|
|
1969
2155
|
/** @export */
|
|
1970
|
-
fd_seek:
|
|
2156
|
+
fd_seek: aa,
|
|
1971
2157
|
/** @export */
|
|
1972
|
-
fd_write:
|
|
1973
|
-
},
|
|
1974
|
-
|
|
1975
|
-
var
|
|
1976
|
-
|
|
1977
|
-
var
|
|
1978
|
-
|
|
1979
|
-
var
|
|
1980
|
-
|
|
1981
|
-
var
|
|
2158
|
+
fd_write: la
|
|
2159
|
+
}, B = await Zr(), ca = p("__getTypeName", 1), se = p("free", 1), vt = p("malloc", 1), ua = B.emscripten_stack_init;
|
|
2160
|
+
B.emscripten_stack_get_free;
|
|
2161
|
+
var pr = B.emscripten_stack_get_base, Ge = B.emscripten_stack_get_end;
|
|
2162
|
+
B._emscripten_stack_restore, B._emscripten_stack_alloc;
|
|
2163
|
+
var fa = B.emscripten_stack_get_current, pa = a.___set_stack_limits = p("__set_stack_limits", 2);
|
|
2164
|
+
a.dynCall_v = p("dynCall_v", 1), a.dynCall_ii = p("dynCall_ii", 2), a.dynCall_viiii = p("dynCall_viiii", 5), a.dynCall_dd = p("dynCall_dd", 2), a.dynCall_vii = p("dynCall_vii", 3), a.dynCall_iii = p("dynCall_iii", 3), a.dynCall_iiii = p("dynCall_iiii", 4), a.dynCall_iiiiii = p("dynCall_iiiiii", 6), a.dynCall_ijii = p("dynCall_ijii", 4), a.dynCall_iiiiiii = p("dynCall_iiiiiii", 7), a.dynCall_vi = p("dynCall_vi", 2), a.dynCall_iiiii = p("dynCall_iiiii", 5), a.dynCall_viiiiii = p("dynCall_viiiiii", 7), a.dynCall_viiiiij = p("dynCall_viiiiij", 7), a.dynCall_viiiii = p("dynCall_viiiii", 6), a.dynCall_viii = p("dynCall_viii", 4), a.dynCall_viiiiiiiiii = p("dynCall_viiiiiiiiii", 11), a.dynCall_viiiiiiiiiii = p("dynCall_viiiiiiiiiii", 12), a.dynCall_viiiiiii = p("dynCall_viiiiiii", 8), a.dynCall_viiiiiiiiiiiiii = p("dynCall_viiiiiiiiiiiiii", 15), a.dynCall_viiiiiiiii = p("dynCall_viiiiiiiii", 10), a.dynCall_iiiiiiiii = p("dynCall_iiiiiiiii", 9), a.dynCall_did = p("dynCall_did", 3), a.dynCall_viiiiiiii = p("dynCall_viiiiiiii", 9), a.dynCall_viifi = p("dynCall_viifi", 5), a.dynCall_diii = p("dynCall_diii", 4), a.dynCall_fiii = p("dynCall_fiii", 4), a.dynCall_viidi = p("dynCall_viidi", 5), a.dynCall_fiiiiiiiiffii = p("dynCall_fiiiiiiiiffii", 13), a.dynCall_viiif = p("dynCall_viiif", 5), a.dynCall_viiiif = p("dynCall_viiiif", 6), a.dynCall_viiiiiiifi = p("dynCall_viiiiiiifi", 10), a.dynCall_iiijiiii = p("dynCall_iiijiiii", 8), a.dynCall_viiiiiiff = p("dynCall_viiiiiiff", 9), a.dynCall_viiiff = p("dynCall_viiiff", 6), a.dynCall_viiiffi = p("dynCall_viiiffi", 7), a.dynCall_fiiii = p("dynCall_fiiii", 5), a.dynCall_iiiiiiiiiiiiiifii = p("dynCall_iiiiiiiiiiiiiifii", 17), a.dynCall_i = p("dynCall_i", 1), a.dynCall_viiiiiiiiiiii = p("dynCall_viiiiiiiiiiii", 13), a.dynCall_iiiiiiii = p("dynCall_iiiiiiii", 8), a.dynCall_viiiifiiiiiiifi = p("dynCall_viiiifiiiiiiifi", 15), a.dynCall_iiiiiiiiiiiiii = p("dynCall_iiiiiiiiiiiiii", 14), a.dynCall_viiiiiiiiiiiii = p("dynCall_viiiiiiiiiiiii", 14), a.dynCall_viiiiiiiiiiiiiiii = p("dynCall_viiiiiiiiiiiiiiii", 17), a.dynCall_viiiiiifi = p("dynCall_viiiiiifi", 9), a.dynCall_viiiifii = p("dynCall_viiiifii", 8), a.dynCall_fii = p("dynCall_fii", 3), a.dynCall_viiiffiii = p("dynCall_viiiffiii", 9), a.dynCall_viiiiiiiiiiif = p("dynCall_viiiiiiiiiiif", 13), a.dynCall_viiiiifi = p("dynCall_viiiiifi", 8), a.dynCall_fiifii = p("dynCall_fiifii", 6), a.dynCall_viiijj = p("dynCall_viiijj", 6), a.dynCall_iiiiiiidiiddii = p("dynCall_iiiiiiidiiddii", 14), a.dynCall_jij = p("dynCall_jij", 3), a.dynCall_jii = p("dynCall_jii", 3), a.dynCall_iiij = p("dynCall_iiij", 4), a.dynCall_jiji = p("dynCall_jiji", 4), a.dynCall_iiiji = p("dynCall_iiiji", 5), a.dynCall_iiijjji = p("dynCall_iiijjji", 7), a.dynCall_jiiij = p("dynCall_jiiij", 5), a.dynCall_iiiiij = p("dynCall_iiiiij", 6), a.dynCall_iiiiiij = p("dynCall_iiiiiij", 7), a.dynCall_jiiji = p("dynCall_jiiji", 5), a.dynCall_viiid = p("dynCall_viiid", 5), a.dynCall_viif = p("dynCall_viif", 4), a.dynCall_dii = p("dynCall_dii", 3), a.dynCall_viid = p("dynCall_viid", 4), a.dynCall_iiiid = p("dynCall_iiiid", 5), a.dynCall_diiii = p("dynCall_diiii", 5), a.dynCall_iidiiii = p("dynCall_iidiiii", 7);
|
|
2165
|
+
var va = p("asyncify_start_unwind", 1), ya = p("asyncify_stop_unwind", 0), ga = p("asyncify_start_rewind", 1), _a = p("asyncify_stop_rewind", 0);
|
|
2166
|
+
a._ff_h264_cabac_tables = 1209289;
|
|
2167
|
+
var ma = [
|
|
1982
2168
|
"writeI53ToI64",
|
|
1983
2169
|
"writeI53ToI64Clamped",
|
|
1984
2170
|
"writeI53ToI64Signaling",
|
|
@@ -2145,8 +2331,8 @@ ${p}`, [m, p];
|
|
|
2145
2331
|
"validateThis",
|
|
2146
2332
|
"emval_get_global"
|
|
2147
2333
|
];
|
|
2148
|
-
|
|
2149
|
-
var
|
|
2334
|
+
ma.forEach(Ur);
|
|
2335
|
+
var ha = [
|
|
2150
2336
|
"run",
|
|
2151
2337
|
"addRunDependency",
|
|
2152
2338
|
"removeRunDependency",
|
|
@@ -2345,202 +2531,202 @@ ${p}`, [m, p];
|
|
|
2345
2531
|
"emval_addMethodCaller",
|
|
2346
2532
|
"reflectConstruct"
|
|
2347
2533
|
];
|
|
2348
|
-
|
|
2349
|
-
var
|
|
2350
|
-
function
|
|
2351
|
-
|
|
2534
|
+
ha.forEach(Lt);
|
|
2535
|
+
var vr;
|
|
2536
|
+
function ba() {
|
|
2537
|
+
ua(), $r();
|
|
2352
2538
|
}
|
|
2353
|
-
function
|
|
2539
|
+
function yt() {
|
|
2354
2540
|
if (fe > 0) {
|
|
2355
|
-
|
|
2541
|
+
Ce = yt;
|
|
2356
2542
|
return;
|
|
2357
2543
|
}
|
|
2358
|
-
if (
|
|
2359
|
-
|
|
2544
|
+
if (ba(), Br(), fe > 0) {
|
|
2545
|
+
Ce = yt;
|
|
2360
2546
|
return;
|
|
2361
2547
|
}
|
|
2362
2548
|
function e() {
|
|
2363
|
-
|
|
2549
|
+
g(!vr), vr = !0, a.calledRun = !0, !N && (Hr(), M(a), a.onRuntimeInitialized?.(), g(!a._main, 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]'), Vr());
|
|
2364
2550
|
}
|
|
2365
|
-
|
|
2366
|
-
setTimeout(() =>
|
|
2367
|
-
}, 1)) : e(),
|
|
2551
|
+
a.setStatus ? (a.setStatus("Running..."), setTimeout(() => {
|
|
2552
|
+
setTimeout(() => a.setStatus(""), 1), e();
|
|
2553
|
+
}, 1)) : e(), Le();
|
|
2368
2554
|
}
|
|
2369
|
-
if (
|
|
2370
|
-
for (typeof
|
|
2371
|
-
|
|
2372
|
-
|
|
2373
|
-
for (const e of Object.keys(
|
|
2374
|
-
e in
|
|
2555
|
+
if (a.preInit)
|
|
2556
|
+
for (typeof a.preInit == "function" && (a.preInit = [a.preInit]); a.preInit.length > 0; )
|
|
2557
|
+
a.preInit.pop()();
|
|
2558
|
+
yt(), m = H;
|
|
2559
|
+
for (const e of Object.keys(a))
|
|
2560
|
+
e in b || Object.defineProperty(b, e, {
|
|
2375
2561
|
configurable: !0,
|
|
2376
2562
|
get() {
|
|
2377
|
-
|
|
2563
|
+
L(`Access to module property ('${e}') is no longer possible via the module constructor argument; Instead, use the result of the module constructor.`);
|
|
2378
2564
|
}
|
|
2379
2565
|
});
|
|
2380
|
-
return
|
|
2566
|
+
return m;
|
|
2381
2567
|
};
|
|
2382
2568
|
})();
|
|
2383
2569
|
(() => {
|
|
2384
|
-
var
|
|
2385
|
-
|
|
2570
|
+
var y = f;
|
|
2571
|
+
f = function(b) {
|
|
2386
2572
|
if (new.target) throw new Error("Module() should not be called with `new Module()`");
|
|
2387
|
-
return b
|
|
2573
|
+
return y(b);
|
|
2388
2574
|
};
|
|
2389
|
-
})(),
|
|
2390
|
-
})(
|
|
2391
|
-
const
|
|
2392
|
-
locateFile: (
|
|
2393
|
-
print: (
|
|
2394
|
-
printErr: (
|
|
2575
|
+
})(), n.exports = f, n.exports.default = f;
|
|
2576
|
+
})(po);
|
|
2577
|
+
const vo = wt, yo = (n, c) => vo({
|
|
2578
|
+
locateFile: (f) => `${n}${f.replace("/dist", "")}`,
|
|
2579
|
+
print: (f) => console.log(f),
|
|
2580
|
+
printErr: (f) => f.includes("Read error at pos") ? void 0 : console.error(f)
|
|
2395
2581
|
// print: (text: string) => log(false, text),
|
|
2396
2582
|
// printErr: (text: string) => log(true, text),
|
|
2397
|
-
}),
|
|
2398
|
-
makeRemuxer: async ({ publicPath:
|
|
2399
|
-
const
|
|
2400
|
-
init: (
|
|
2401
|
-
const
|
|
2402
|
-
return
|
|
2403
|
-
data:
|
|
2404
|
-
videoExtradata: new Uint8Array(
|
|
2405
|
-
attachments:
|
|
2406
|
-
const
|
|
2583
|
+
}), ye = (n) => Array(n.size()).fill(void 0).map((c, f) => n.get(f)), go = {
|
|
2584
|
+
makeRemuxer: async ({ publicPath: n, length: c, bufferSize: f, log: y }) => {
|
|
2585
|
+
const b = await yo(n), m = new b.Remuxer({ resolvedPromise: Promise.resolve(), length: c, bufferSize: f }), a = {
|
|
2586
|
+
init: (P) => m.init(P).then((T) => {
|
|
2587
|
+
const A = new Uint8Array(T.data.byteLength);
|
|
2588
|
+
return A.set(T.data), {
|
|
2589
|
+
data: A.buffer,
|
|
2590
|
+
videoExtradata: new Uint8Array(ye(T.videoExtradata)).buffer,
|
|
2591
|
+
attachments: ye(T.attachments).map((I) => {
|
|
2592
|
+
const $ = new Uint8Array(b.HEAPU8.buffer, I.ptr, I.size), C = new Uint8Array($);
|
|
2407
2593
|
return {
|
|
2408
2594
|
filename: I.filename,
|
|
2409
2595
|
mimetype: I.mimetype,
|
|
2410
|
-
data:
|
|
2596
|
+
data: C.buffer
|
|
2411
2597
|
};
|
|
2412
2598
|
}),
|
|
2413
|
-
subtitles:
|
|
2599
|
+
subtitles: ye(T.subtitles).map((I) => {
|
|
2414
2600
|
if (!I.isHeader) throw new Error("Subtitle type is not header");
|
|
2415
|
-
const { isHeader:
|
|
2601
|
+
const { isHeader: $, data: C, ...W } = I;
|
|
2416
2602
|
return {
|
|
2417
|
-
...
|
|
2603
|
+
...W,
|
|
2418
2604
|
type: "header",
|
|
2419
|
-
content:
|
|
2605
|
+
content: C
|
|
2420
2606
|
};
|
|
2421
2607
|
}),
|
|
2422
|
-
indexes:
|
|
2608
|
+
indexes: ye(T.indexes).map(({ index: I, timestamp: $, pos: C }) => ({
|
|
2423
2609
|
index: I,
|
|
2424
|
-
timestamp:
|
|
2425
|
-
pos:
|
|
2610
|
+
timestamp: $,
|
|
2611
|
+
pos: C
|
|
2426
2612
|
})),
|
|
2427
|
-
chapters:
|
|
2613
|
+
chapters: ye(T.chapters).map(({ index: I, start: $, end: C, title: W }) => ({
|
|
2428
2614
|
index: I,
|
|
2429
|
-
start:
|
|
2430
|
-
end:
|
|
2431
|
-
title:
|
|
2615
|
+
start: $,
|
|
2616
|
+
end: C,
|
|
2617
|
+
title: W
|
|
2432
2618
|
})),
|
|
2433
2619
|
info: {
|
|
2434
2620
|
input: {
|
|
2435
|
-
audioMimeType:
|
|
2436
|
-
duration:
|
|
2437
|
-
formatName:
|
|
2438
|
-
mimeType:
|
|
2439
|
-
videoMimeType:
|
|
2621
|
+
audioMimeType: T.info.input.audioMimeType,
|
|
2622
|
+
duration: T.info.input.duration,
|
|
2623
|
+
formatName: T.info.input.formatName,
|
|
2624
|
+
mimeType: T.info.input.mimeType,
|
|
2625
|
+
videoMimeType: T.info.input.videoMimeType
|
|
2440
2626
|
},
|
|
2441
2627
|
output: {
|
|
2442
|
-
audioMimeType:
|
|
2443
|
-
duration:
|
|
2444
|
-
formatName:
|
|
2445
|
-
mimeType:
|
|
2446
|
-
videoMimeType:
|
|
2628
|
+
audioMimeType: T.info.output.audioMimeType,
|
|
2629
|
+
duration: T.info.output.duration,
|
|
2630
|
+
formatName: T.info.output.formatName,
|
|
2631
|
+
mimeType: T.info.output.mimeType,
|
|
2632
|
+
videoMimeType: T.info.output.videoMimeType
|
|
2447
2633
|
}
|
|
2448
2634
|
}
|
|
2449
2635
|
};
|
|
2450
2636
|
}),
|
|
2451
|
-
destroy: () =>
|
|
2452
|
-
seek: (
|
|
2453
|
-
if (
|
|
2454
|
-
const I = new Uint8Array(
|
|
2455
|
-
return I.set(new Uint8Array(
|
|
2637
|
+
destroy: () => m.destroy(),
|
|
2638
|
+
seek: (P, T) => m.seek(P, T * 1e3).then((A) => {
|
|
2639
|
+
if (A.cancelled) throw new Error("Cancelled");
|
|
2640
|
+
const I = new Uint8Array(A.data.byteLength);
|
|
2641
|
+
return I.set(new Uint8Array(A.data)), {
|
|
2456
2642
|
data: I.buffer,
|
|
2457
|
-
subtitles:
|
|
2458
|
-
if (
|
|
2459
|
-
const { isHeader:
|
|
2643
|
+
subtitles: ye(A.subtitles).map(($) => {
|
|
2644
|
+
if ($.isHeader) throw new Error("Subtitle type is header");
|
|
2645
|
+
const { isHeader: C, data: W, ...N } = $;
|
|
2460
2646
|
return {
|
|
2461
|
-
...
|
|
2647
|
+
...N,
|
|
2462
2648
|
type: "dialogue",
|
|
2463
|
-
content:
|
|
2649
|
+
content: W
|
|
2464
2650
|
};
|
|
2465
2651
|
}),
|
|
2466
|
-
offset:
|
|
2467
|
-
pts:
|
|
2468
|
-
duration:
|
|
2469
|
-
cancelled:
|
|
2470
|
-
finished:
|
|
2652
|
+
offset: A.offset,
|
|
2653
|
+
pts: A.pts,
|
|
2654
|
+
duration: A.duration,
|
|
2655
|
+
cancelled: A.cancelled,
|
|
2656
|
+
finished: A.finished
|
|
2471
2657
|
};
|
|
2472
2658
|
}),
|
|
2473
|
-
read: (
|
|
2474
|
-
if (
|
|
2475
|
-
const
|
|
2476
|
-
return
|
|
2477
|
-
data:
|
|
2478
|
-
subtitles:
|
|
2659
|
+
read: (P) => m.read(P).then((T) => {
|
|
2660
|
+
if (T.cancelled) throw new Error("Cancelled");
|
|
2661
|
+
const A = new Uint8Array(T.data.byteLength);
|
|
2662
|
+
return A.set(new Uint8Array(T.data)), {
|
|
2663
|
+
data: A.buffer,
|
|
2664
|
+
subtitles: ye(T.subtitles).map((I) => {
|
|
2479
2665
|
if (I.isHeader) throw new Error("Subtitle type is header");
|
|
2480
|
-
const { isHeader:
|
|
2666
|
+
const { isHeader: $, data: C, ...W } = I;
|
|
2481
2667
|
return {
|
|
2482
|
-
...
|
|
2668
|
+
...W,
|
|
2483
2669
|
type: "dialogue",
|
|
2484
|
-
content:
|
|
2670
|
+
content: C
|
|
2485
2671
|
};
|
|
2486
2672
|
}),
|
|
2487
|
-
offset:
|
|
2488
|
-
pts:
|
|
2489
|
-
duration:
|
|
2490
|
-
cancelled:
|
|
2491
|
-
finished:
|
|
2673
|
+
offset: T.offset,
|
|
2674
|
+
pts: T.pts,
|
|
2675
|
+
duration: T.duration,
|
|
2676
|
+
cancelled: T.cancelled,
|
|
2677
|
+
finished: T.finished
|
|
2492
2678
|
};
|
|
2493
2679
|
}),
|
|
2494
|
-
readKeyframe: (
|
|
2495
|
-
if (
|
|
2496
|
-
const I = new Uint8Array(
|
|
2497
|
-
return I.set(new Uint8Array(
|
|
2680
|
+
readKeyframe: (P, T) => m.readKeyframe(P, T).then((A) => {
|
|
2681
|
+
if (A.cancelled) throw new Error("Cancelled");
|
|
2682
|
+
const I = new Uint8Array(A.data.byteLength);
|
|
2683
|
+
return I.set(new Uint8Array(A.data)), {
|
|
2498
2684
|
data: I.buffer,
|
|
2499
|
-
pts:
|
|
2500
|
-
duration:
|
|
2501
|
-
offset:
|
|
2502
|
-
cancelled:
|
|
2685
|
+
pts: A.pts,
|
|
2686
|
+
duration: A.duration,
|
|
2687
|
+
offset: A.offset,
|
|
2688
|
+
cancelled: A.cancelled
|
|
2503
2689
|
};
|
|
2504
2690
|
})
|
|
2505
|
-
},
|
|
2506
|
-
({ resolved: I, rejected:
|
|
2691
|
+
}, M = (P) => (T, A) => P(Number(T), Number(A)).then(
|
|
2692
|
+
({ resolved: I, rejected: $ }) => ({ resolved: new Uint8Array(I), rejected: $ }),
|
|
2507
2693
|
() => ({ resolved: new Uint8Array(0), rejected: !0 })
|
|
2508
2694
|
);
|
|
2509
|
-
let
|
|
2510
|
-
const
|
|
2511
|
-
output: (
|
|
2512
|
-
|
|
2695
|
+
let F, H;
|
|
2696
|
+
const O = new VideoDecoder({
|
|
2697
|
+
output: (P) => {
|
|
2698
|
+
F?.(P), F = void 0, H = void 0;
|
|
2513
2699
|
},
|
|
2514
|
-
error: (
|
|
2515
|
-
|
|
2700
|
+
error: (P) => {
|
|
2701
|
+
H?.(P), F = void 0, H = void 0;
|
|
2516
2702
|
}
|
|
2517
|
-
}),
|
|
2518
|
-
if (!
|
|
2703
|
+
}), j = new OffscreenCanvas(200 * 16 / 9, 200), V = j.getContext("2d");
|
|
2704
|
+
if (!V) throw new Error("OffscreenCanvas not supported");
|
|
2519
2705
|
return {
|
|
2520
|
-
destroy: async () =>
|
|
2521
|
-
init: async (
|
|
2522
|
-
const
|
|
2523
|
-
return
|
|
2524
|
-
codec:
|
|
2525
|
-
description:
|
|
2526
|
-
}),
|
|
2706
|
+
destroy: async () => a.destroy(),
|
|
2707
|
+
init: async (P) => {
|
|
2708
|
+
const T = await a.init(M(P));
|
|
2709
|
+
return O.state === "unconfigured" && O.configure({
|
|
2710
|
+
codec: T.info.input.videoMimeType,
|
|
2711
|
+
description: T.videoExtradata
|
|
2712
|
+
}), T;
|
|
2527
2713
|
},
|
|
2528
|
-
seek: (
|
|
2529
|
-
read: (
|
|
2530
|
-
readKeyframe: async (
|
|
2531
|
-
const
|
|
2532
|
-
|
|
2533
|
-
}), I = await
|
|
2534
|
-
|
|
2714
|
+
seek: (P, T) => a.seek(M(P), T),
|
|
2715
|
+
read: (P) => a.read(M(P)),
|
|
2716
|
+
readKeyframe: async (P, T) => {
|
|
2717
|
+
const A = new Promise((C, W) => {
|
|
2718
|
+
F = C, H = W;
|
|
2719
|
+
}), I = await a.readKeyframe(M(P), T);
|
|
2720
|
+
O.decode(new EncodedVideoChunk({
|
|
2535
2721
|
type: "key",
|
|
2536
2722
|
timestamp: I.pts,
|
|
2537
2723
|
duration: I.duration,
|
|
2538
2724
|
data: I.data
|
|
2539
|
-
})),
|
|
2540
|
-
const
|
|
2541
|
-
return
|
|
2725
|
+
})), O.flush();
|
|
2726
|
+
const $ = await A;
|
|
2727
|
+
return V.drawImage($, 0, 0, 200 * 16 / 9, 200), $.close(), j.convertToBlob().then((C) => C.arrayBuffer());
|
|
2542
2728
|
}
|
|
2543
2729
|
};
|
|
2544
2730
|
}
|
|
2545
2731
|
};
|
|
2546
|
-
|
|
2732
|
+
fo(go, { transport: globalThis });
|