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