Fossil SCM

Rebuild pikchr.wasm/js with emcc 3.1.53 and adapt the associated build rule in src/main.mk to account for a breaking emcc change (should also be backwards-compatible to older emcc's).

stephan 2024-02-09 00:12 trunk
Commit 5a09f499a8bfe2bb8d8a9a0c8411f514efb0f778c22308c4b155eed5a6c58a98
Parent f4ec8e0f05f28b3…
3 files changed +378 -377 +1 -1
~ extsrc/pikchr.js ~ extsrc/pikchr.wasm ~ src/main.mk
M extsrc/pikchr.js
+378 -377
--- extsrc/pikchr.js
+++ extsrc/pikchr.js
@@ -1,18 +1,17 @@
11
22
 var initPikchrModule = (() => {
33
 var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;
44
55
 return (
6
-function(config) {
7
- var initPikchrModule = config || {};
6
+function(moduleArg = {}) {
87
9
-var Module = typeof initPikchrModule != "undefined" ? initPikchrModule : {};
8
+var Module = moduleArg;
109
1110
 var readyPromiseResolve, readyPromiseReject;
1211
13
-Module["ready"] = new Promise(function(resolve, reject) {
12
+Module["ready"] = new Promise((resolve, reject) => {
1413
 readyPromiseResolve = resolve;
1514
 readyPromiseReject = reject;
1615
 });
1716
1817
 var moduleOverrides = Object.assign({}, Module);
@@ -36,11 +35,11 @@
3635
 return Module["locateFile"](path, scriptDirectory);
3736
 }
3837
 return scriptDirectory + path;
3938
 }
4039
41
-var read_, readAsync, readBinary, setWindowTitle;
40
+var read_, readAsync, readBinary;
4241
4342
 if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
4443
 if (ENVIRONMENT_IS_WORKER) {
4544
 scriptDirectory = self.location.href;
4645
 } else if (typeof document != "undefined" && document.currentScript) {
@@ -47,52 +46,51 @@
4746
 scriptDirectory = document.currentScript.src;
4847
 }
4948
 if (_scriptDir) {
5049
 scriptDirectory = _scriptDir;
5150
 }
52
- if (scriptDirectory.indexOf("blob:") !== 0) {
53
- scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
51
+ if (scriptDirectory.startsWith("blob:")) {
52
+ scriptDirectory = "";
5453
 } else {
55
- scriptDirectory = "";
54
+ scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
5655
 }
5756
 {
5857
 read_ = url => {
59
- var xhr = new XMLHttpRequest();
58
+ var xhr = new XMLHttpRequest;
6059
 xhr.open("GET", url, false);
6160
 xhr.send(null);
6261
 return xhr.responseText;
6362
 };
6463
 if (ENVIRONMENT_IS_WORKER) {
6564
 readBinary = url => {
66
- var xhr = new XMLHttpRequest();
65
+ var xhr = new XMLHttpRequest;
6766
 xhr.open("GET", url, false);
6867
 xhr.responseType = "arraybuffer";
6968
 xhr.send(null);
70
- return new Uint8Array(xhr.response);
69
+ return new Uint8Array(/** @type{!ArrayBuffer} */ (xhr.response));
7170
 };
7271
 }
7372
 readAsync = (url, onload, onerror) => {
74
- var xhr = new XMLHttpRequest();
73
+ var xhr = new XMLHttpRequest;
7574
 xhr.open("GET", url, true);
7675
 xhr.responseType = "arraybuffer";
7776
 xhr.onload = () => {
78
- if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
77
+ if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
7978
 onload(xhr.response);
8079
 return;
8180
 }
8281
 onerror();
8382
 };
8483
 xhr.onerror = onerror;
8584
 xhr.send(null);
8685
 };
8786
 }
88
- setWindowTitle = title => document.title = title;
8987
 } else {}
9088
9189
 var out = Module["print"] || console.log.bind(console);
9290
93
-var err = Module["printErr"] || console.warn.bind(console);
91
+var err = Module["printErr"] || console.error.bind(console);
9492
9593
 Object.assign(Module, moduleOverrides);
9694
9795
 moduleOverrides = null;
9896
@@ -104,12 +102,10 @@
104102
105103
 var wasmBinary;
106104
107105
 if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
108106
109
-var noExitRuntime = Module["noExitRuntime"] || true;
110
-
111107
 if (typeof WebAssembly != "object") {
112108
 abort("no native wasm support detected");
113109
 }
114110
115111
 var wasmMemory;
@@ -116,119 +112,32 @@
116112
117113
 var ABORT = false;
118114
119115
 var EXITSTATUS;
120116
121
-var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
122
-
123
-function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
124
- var endIdx = idx + maxBytesToRead;
125
- var endPtr = idx;
126
- while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
127
- if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
128
- return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
129
- }
130
- var str = "";
131
- while (idx < endPtr) {
132
- var u0 = heapOrArray[idx++];
133
- if (!(u0 & 128)) {
134
- str += String.fromCharCode(u0);
135
- continue;
136
- }
137
- var u1 = heapOrArray[idx++] & 63;
138
- if ((u0 & 224) == 192) {
139
- str += String.fromCharCode((u0 & 31) << 6 | u1);
140
- continue;
141
- }
142
- var u2 = heapOrArray[idx++] & 63;
143
- if ((u0 & 240) == 224) {
144
- u0 = (u0 & 15) << 12 | u1 << 6 | u2;
145
- } else {
146
- u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
147
- }
148
- if (u0 < 65536) {
149
- str += String.fromCharCode(u0);
150
- } else {
151
- var ch = u0 - 65536;
152
- str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
153
- }
154
- }
155
- return str;
156
-}
157
-
158
-function UTF8ToString(ptr, maxBytesToRead) {
159
- return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
160
-}
161
-
162
-function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
163
- if (!(maxBytesToWrite > 0)) return 0;
164
- var startIdx = outIdx;
165
- var endIdx = outIdx + maxBytesToWrite - 1;
166
- for (var i = 0; i < str.length; ++i) {
167
- var u = str.charCodeAt(i);
168
- if (u >= 55296 && u <= 57343) {
169
- var u1 = str.charCodeAt(++i);
170
- u = 65536 + ((u & 1023) << 10) | u1 & 1023;
171
- }
172
- if (u <= 127) {
173
- if (outIdx >= endIdx) break;
174
- heap[outIdx++] = u;
175
- } else if (u <= 2047) {
176
- if (outIdx + 1 >= endIdx) break;
177
- heap[outIdx++] = 192 | u >> 6;
178
- heap[outIdx++] = 128 | u & 63;
179
- } else if (u <= 65535) {
180
- if (outIdx + 2 >= endIdx) break;
181
- heap[outIdx++] = 224 | u >> 12;
182
- heap[outIdx++] = 128 | u >> 6 & 63;
183
- heap[outIdx++] = 128 | u & 63;
184
- } else {
185
- if (outIdx + 3 >= endIdx) break;
186
- heap[outIdx++] = 240 | u >> 18;
187
- heap[outIdx++] = 128 | u >> 12 & 63;
188
- heap[outIdx++] = 128 | u >> 6 & 63;
189
- heap[outIdx++] = 128 | u & 63;
190
- }
191
- }
192
- heap[outIdx] = 0;
193
- return outIdx - startIdx;
194
-}
195
-
196
-function stringToUTF8(str, outPtr, maxBytesToWrite) {
197
- return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
198
-}
199
-
200
-var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
117
+var /** @type {!Int8Array} */ HEAP8, /** @type {!Uint8Array} */ HEAPU8, /** @type {!Int16Array} */ HEAP16, /** @type {!Uint16Array} */ HEAPU16, /** @type {!Int32Array} */ HEAP32, /** @type {!Uint32Array} */ HEAPU32, /** @type {!Float32Array} */ HEAPF32, /** @type {!Float64Array} */ HEAPF64;
201118
202119
 function updateMemoryViews() {
203120
 var b = wasmMemory.buffer;
204121
 Module["HEAP8"] = HEAP8 = new Int8Array(b);
205122
 Module["HEAP16"] = HEAP16 = new Int16Array(b);
206
- Module["HEAP32"] = HEAP32 = new Int32Array(b);
207123
 Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
208124
 Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
125
+ Module["HEAP32"] = HEAP32 = new Int32Array(b);
209126
 Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
210127
 Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
211128
 Module["HEAPF64"] = HEAPF64 = new Float64Array(b);
212129
 }
213130
214
-var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;
215
-
216
-var wasmTable;
217
-
218131
 var __ATPRERUN__ = [];
219132
220133
 var __ATINIT__ = [];
221134
222135
 var __ATPOSTRUN__ = [];
223136
224137
 var runtimeInitialized = false;
225138
226
-function keepRuntimeAlive() {
227
- return noExitRuntime;
228
-}
229
-
230139
 function preRun() {
231140
 if (Module["preRun"]) {
232141
 if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ];
233142
 while (Module["preRun"].length) {
234143
 addOnPreRun(Module["preRun"].shift());
@@ -270,20 +179,16 @@
270179
271180
 var dependenciesFulfilled = null;
272181
273182
 function addRunDependency(id) {
274183
 runDependencies++;
275
- if (Module["monitorRunDependencies"]) {
276
- Module["monitorRunDependencies"](runDependencies);
277
- }
184
+ Module["monitorRunDependencies"]?.(runDependencies);
278185
 }
279186
280187
 function removeRunDependency(id) {
281188
 runDependencies--;
282
- if (Module["monitorRunDependencies"]) {
283
- Module["monitorRunDependencies"](runDependencies);
284
- }
189
+ Module["monitorRunDependencies"]?.(runDependencies);
285190
 if (runDependencies == 0) {
286191
 if (runDependencyWatcher !== null) {
287192
 clearInterval(runDependencyWatcher);
288193
 runDependencyWatcher = null;
289194
 }
@@ -293,278 +198,382 @@
293198
 callback();
294199
 }
295200
 }
296201
 }
297202
298
-function abort(what) {
299
- if (Module["onAbort"]) {
300
- Module["onAbort"](what);
301
- }
203
+/** @param {string|number=} what */ function abort(what) {
204
+ Module["onAbort"]?.(what);
302205
 what = "Aborted(" + what + ")";
303206
 err(what);
304207
 ABORT = true;
305208
 EXITSTATUS = 1;
306209
 what += ". Build with -sASSERTIONS for more info.";
307
- var e = new WebAssembly.RuntimeError(what);
210
+ /** @suppress {checkTypes} */ var e = new WebAssembly.RuntimeError(what);
308211
 readyPromiseReject(e);
309212
 throw e;
310213
 }
311214
312215
 var dataURIPrefix = "data:application/octet-stream;base64,";
313216
314
-function isDataURI(filename) {
315
- return filename.startsWith(dataURIPrefix);
316
-}
217
+/**
218
+ * Indicates whether filename is a base64 data URI.
219
+ * @noinline
220
+ */ var isDataURI = filename => filename.startsWith(dataURIPrefix);
317221
318222
 var wasmBinaryFile;
319223
320224
 wasmBinaryFile = "pikchr.wasm";
321225
322226
 if (!isDataURI(wasmBinaryFile)) {
323227
 wasmBinaryFile = locateFile(wasmBinaryFile);
324228
 }
325229
326
-function getBinary(file) {
327
- try {
328
- if (file == wasmBinaryFile && wasmBinary) {
329
- return new Uint8Array(wasmBinary);
330
- }
331
- if (readBinary) {
332
- return readBinary(file);
333
- }
334
- throw "both async and sync fetching of the wasm failed";
335
- } catch (err) {
336
- abort(err);
337
- }
338
-}
339
-
340
-function getBinaryPromise() {
230
+function getBinarySync(file) {
231
+ if (file == wasmBinaryFile && wasmBinary) {
232
+ return new Uint8Array(wasmBinary);
233
+ }
234
+ if (readBinary) {
235
+ return readBinary(file);
236
+ }
237
+ throw "both async and sync fetching of the wasm failed";
238
+}
239
+
240
+function getBinaryPromise(binaryFile) {
341241
 if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
342242
 if (typeof fetch == "function") {
343
- return fetch(wasmBinaryFile, {
243
+ return fetch(binaryFile, {
344244
 credentials: "same-origin"
345
- }).then(function(response) {
245
+ }).then(response => {
346246
 if (!response["ok"]) {
347
- throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
247
+ throw `failed to load wasm binary file at '${binaryFile}'`;
348248
 }
349249
 return response["arrayBuffer"]();
350
- }).catch(function() {
351
- return getBinary(wasmBinaryFile);
352
- });
353
- }
354
- }
355
- return Promise.resolve().then(function() {
356
- return getBinary(wasmBinaryFile);
357
- });
250
+ }).catch(() => getBinarySync(binaryFile));
251
+ }
252
+ }
253
+ return Promise.resolve().then(() => getBinarySync(binaryFile));
254
+}
255
+
256
+function instantiateArrayBuffer(binaryFile, imports, receiver) {
257
+ return getBinaryPromise(binaryFile).then(binary => WebAssembly.instantiate(binary, imports)).then(instance => instance).then(receiver, reason => {
258
+ err(`failed to asynchronously prepare wasm: ${reason}`);
259
+ abort(reason);
260
+ });
261
+}
262
+
263
+function instantiateAsync(binary, binaryFile, imports, callback) {
264
+ if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && typeof fetch == "function") {
265
+ return fetch(binaryFile, {
266
+ credentials: "same-origin"
267
+ }).then(response => {
268
+ /** @suppress {checkTypes} */ var result = WebAssembly.instantiateStreaming(response, imports);
269
+ return result.then(callback, function(reason) {
270
+ err(`wasm streaming compile failed: ${reason}`);
271
+ err("falling back to ArrayBuffer instantiation");
272
+ return instantiateArrayBuffer(binaryFile, imports, callback);
273
+ });
274
+ });
275
+ }
276
+ return instantiateArrayBuffer(binaryFile, imports, callback);
358277
 }
359278
360279
 function createWasm() {
361280
 var info = {
362
- "a": asmLibraryArg
281
+ "a": wasmImports
363282
 };
364
- function receiveInstance(instance, module) {
365
- var exports = instance.exports;
366
- Module["asm"] = exports;
367
- wasmMemory = Module["asm"]["d"];
283
+ /** @param {WebAssembly.Module=} module*/ function receiveInstance(instance, module) {
284
+ wasmExports = instance.exports;
285
+ wasmMemory = wasmExports["d"];
368286
 updateMemoryViews();
369
- wasmTable = Module["asm"]["g"];
370
- addOnInit(Module["asm"]["e"]);
287
+ addOnInit(wasmExports["e"]);
371288
 removeRunDependency("wasm-instantiate");
289
+ return wasmExports;
372290
 }
373291
 addRunDependency("wasm-instantiate");
374292
 function receiveInstantiationResult(result) {
375293
 receiveInstance(result["instance"]);
376294
 }
377
- function instantiateArrayBuffer(receiver) {
378
- return getBinaryPromise().then(function(binary) {
379
- return WebAssembly.instantiate(binary, info);
380
- }).then(function(instance) {
381
- return instance;
382
- }).then(receiver, function(reason) {
383
- err("failed to asynchronously prepare wasm: " + reason);
384
- abort(reason);
385
- });
386
- }
387
- function instantiateAsync() {
388
- if (!wasmBinary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(wasmBinaryFile) && typeof fetch == "function") {
389
- return fetch(wasmBinaryFile, {
390
- credentials: "same-origin"
391
- }).then(function(response) {
392
- var result = WebAssembly.instantiateStreaming(response, info);
393
- return result.then(receiveInstantiationResult, function(reason) {
394
- err("wasm streaming compile failed: " + reason);
395
- err("falling back to ArrayBuffer instantiation");
396
- return instantiateArrayBuffer(receiveInstantiationResult);
397
- });
398
- });
399
- } else {
400
- return instantiateArrayBuffer(receiveInstantiationResult);
401
- }
402
- }
403
- if (Module["instantiateWasm"]) {
404
- try {
405
- var exports = Module["instantiateWasm"](info, receiveInstance);
406
- return exports;
407
- } catch (e) {
408
- err("Module.instantiateWasm callback failed with error: " + e);
409
- readyPromiseReject(e);
410
- }
411
- }
412
- instantiateAsync().catch(readyPromiseReject);
413
- return {};
414
-}
415
-
416
-var tempDouble;
417
-
418
-var tempI64;
419
-
420
-function ExitStatus(status) {
421
- this.name = "ExitStatus";
422
- this.message = "Program terminated with exit(" + status + ")";
423
- this.status = status;
424
-}
425
-
426
-function callRuntimeCallbacks(callbacks) {
427
- while (callbacks.length > 0) {
428
- callbacks.shift()(Module);
429
- }
430
-}
431
-
432
-function getValue(ptr, type = "i8") {
433
- if (type.endsWith("*")) type = "*";
434
- switch (type) {
435
- case "i1":
436
- return HEAP8[ptr >> 0];
437
-
438
- case "i8":
439
- return HEAP8[ptr >> 0];
440
-
441
- case "i16":
442
- return HEAP16[ptr >> 1];
443
-
444
- case "i32":
445
- return HEAP32[ptr >> 2];
446
-
447
- case "i64":
448
- return HEAP32[ptr >> 2];
449
-
450
- case "float":
451
- return HEAPF32[ptr >> 2];
452
-
453
- case "double":
454
- return HEAPF64[ptr >> 3];
455
-
456
- case "*":
457
- return HEAPU32[ptr >> 2];
458
-
459
- default:
460
- abort("invalid type for getValue: " + type);
461
- }
462
- return null;
463
-}
464
-
465
-function setValue(ptr, value, type = "i8") {
466
- if (type.endsWith("*")) type = "*";
467
- switch (type) {
468
- case "i1":
469
- HEAP8[ptr >> 0] = value;
470
- break;
471
-
472
- case "i8":
473
- HEAP8[ptr >> 0] = value;
474
- break;
475
-
476
- case "i16":
477
- HEAP16[ptr >> 1] = value;
478
- break;
479
-
480
- case "i32":
481
- HEAP32[ptr >> 2] = value;
482
- break;
483
-
484
- case "i64":
485
- tempI64 = [ value >>> 0, (tempDouble = value, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ],
486
- HEAP32[ptr >> 2] = tempI64[0], HEAP32[ptr + 4 >> 2] = tempI64[1];
487
- break;
488
-
489
- case "float":
490
- HEAPF32[ptr >> 2] = value;
491
- break;
492
-
493
- case "double":
494
- HEAPF64[ptr >> 3] = value;
495
- break;
496
-
497
- case "*":
498
- HEAPU32[ptr >> 2] = value;
499
- break;
500
-
501
- default:
502
- abort("invalid type for setValue: " + type);
503
- }
504
-}
505
-
506
-function ___assert_fail(condition, filename, line, func) {
507
- abort("Assertion failed: " + UTF8ToString(condition) + ", at: " + [ filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function" ]);
508
-}
509
-
510
-function abortOnCannotGrowMemory(requestedSize) {
511
- abort("OOM");
512
-}
513
-
514
-function _emscripten_resize_heap(requestedSize) {
515
- var oldSize = HEAPU8.length;
516
- requestedSize = requestedSize >>> 0;
517
- abortOnCannotGrowMemory(requestedSize);
518
-}
519
-
520
-var SYSCALLS = {
521
- varargs: undefined,
522
- get: function() {
523
- SYSCALLS.varargs += 4;
524
- var ret = HEAP32[SYSCALLS.varargs - 4 >> 2];
525
- return ret;
526
- },
527
- getStr: function(ptr) {
528
- var ret = UTF8ToString(ptr);
529
- return ret;
530
- }
531
-};
532
-
533
-function _proc_exit(code) {
534
- EXITSTATUS = code;
535
- if (!keepRuntimeAlive()) {
536
- if (Module["onExit"]) Module["onExit"](code);
537
- ABORT = true;
538
- }
539
- quit_(code, new ExitStatus(code));
540
-}
541
-
542
-function exitJS(status, implicit) {
543
- EXITSTATUS = status;
544
- _proc_exit(status);
545
-}
546
-
547
-var _exit = exitJS;
548
-
549
-function getCFunc(ident) {
550
- var func = Module["_" + ident];
551
- return func;
552
-}
553
-
554
-function writeArrayToMemory(array, buffer) {
555
- HEAP8.set(array, buffer);
556
-}
557
-
558
-function ccall(ident, returnType, argTypes, args, opts) {
295
+ if (Module["instantiateWasm"]) {
296
+ try {
297
+ return Module["instantiateWasm"](info, receiveInstance);
298
+ } catch (e) {
299
+ err(`Module.instantiateWasm callback failed with error: ${e}`);
300
+ readyPromiseReject(e);
301
+ }
302
+ }
303
+ instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject);
304
+ return {};
305
+}
306
+
307
+/** @constructor */ function ExitStatus(status) {
308
+ this.name = "ExitStatus";
309
+ this.message = `Program terminated with exit(${status})`;
310
+ this.status = status;
311
+}
312
+
313
+var callRuntimeCallbacks = callbacks => {
314
+ while (callbacks.length > 0) {
315
+ callbacks.shift()(Module);
316
+ }
317
+};
318
+
319
+/**
320
+ * @param {number} ptr
321
+ * @param {string} type
322
+ */ function getValue(ptr, type = "i8") {
323
+ if (type.endsWith("*")) type = "*";
324
+ switch (type) {
325
+ case "i1":
326
+ return HEAP8[((ptr) >> 0)];
327
+
328
+ case "i8":
329
+ return HEAP8[((ptr) >> 0)];
330
+
331
+ case "i16":
332
+ return HEAP16[((ptr) >> 1)];
333
+
334
+ case "i32":
335
+ return HEAP32[((ptr) >> 2)];
336
+
337
+ case "i64":
338
+ abort("to do getValue(i64) use WASM_BIGINT");
339
+
340
+ case "float":
341
+ return HEAPF32[((ptr) >> 2)];
342
+
343
+ case "double":
344
+ return HEAPF64[((ptr) >> 3)];
345
+
346
+ case "*":
347
+ return HEAPU32[((ptr) >> 2)];
348
+
349
+ default:
350
+ abort(`invalid type for getValue: ${type}`);
351
+ }
352
+}
353
+
354
+var noExitRuntime = Module["noExitRuntime"] || true;
355
+
356
+/**
357
+ * @param {number} ptr
358
+ * @param {number} value
359
+ * @param {string} type
360
+ */ function setValue(ptr, value, type = "i8") {
361
+ if (type.endsWith("*")) type = "*";
362
+ switch (type) {
363
+ case "i1":
364
+ HEAP8[((ptr) >> 0)] = value;
365
+ break;
366
+
367
+ case "i8":
368
+ HEAP8[((ptr) >> 0)] = value;
369
+ break;
370
+
371
+ case "i16":
372
+ HEAP16[((ptr) >> 1)] = value;
373
+ break;
374
+
375
+ case "i32":
376
+ HEAP32[((ptr) >> 2)] = value;
377
+ break;
378
+
379
+ case "i64":
380
+ abort("to do setValue(i64) use WASM_BIGINT");
381
+
382
+ case "float":
383
+ HEAPF32[((ptr) >> 2)] = value;
384
+ break;
385
+
386
+ case "double":
387
+ HEAPF64[((ptr) >> 3)] = value;
388
+ break;
389
+
390
+ case "*":
391
+ HEAPU32[((ptr) >> 2)] = value;
392
+ break;
393
+
394
+ default:
395
+ abort(`invalid type for setValue: ${type}`);
396
+ }
397
+}
398
+
399
+var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
400
+
401
+/**
402
+ * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given
403
+ * array that contains uint8 values, returns a copy of that string as a
404
+ * Javascript String object.
405
+ * heapOrArray is either a regular array, or a JavaScript typed array view.
406
+ * @param {number} idx
407
+ * @param {number=} maxBytesToRead
408
+ * @return {string}
409
+ */ var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => {
410
+ var endIdx = idx + maxBytesToRead;
411
+ var endPtr = idx;
412
+ while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
413
+ if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
414
+ return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
415
+ }
416
+ var str = "";
417
+ while (idx < endPtr) {
418
+ var u0 = heapOrArray[idx++];
419
+ if (!(u0 & 128)) {
420
+ str += String.fromCharCode(u0);
421
+ continue;
422
+ }
423
+ var u1 = heapOrArray[idx++] & 63;
424
+ if ((u0 & 224) == 192) {
425
+ str += String.fromCharCode(((u0 & 31) << 6) | u1);
426
+ continue;
427
+ }
428
+ var u2 = heapOrArray[idx++] & 63;
429
+ if ((u0 & 240) == 224) {
430
+ u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
431
+ } else {
432
+ u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
433
+ }
434
+ if (u0 < 65536) {
435
+ str += String.fromCharCode(u0);
436
+ } else {
437
+ var ch = u0 - 65536;
438
+ str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
439
+ }
440
+ }
441
+ return str;
442
+};
443
+
444
+/**
445
+ * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
446
+ * emscripten HEAP, returns a copy of that string as a Javascript String object.
447
+ *
448
+ * @param {number} ptr
449
+ * @param {number=} maxBytesToRead - An optional length that specifies the
450
+ * maximum number of bytes to read. You can omit this parameter to scan the
451
+ * string until the first 0 byte. If maxBytesToRead is passed, and the string
452
+ * at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
453
+ * string will cut short at that byte index (i.e. maxBytesToRead will not
454
+ * produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing
455
+ * frequent uses of UTF8ToString() with and without maxBytesToRead may throw
456
+ * JS JIT optimizations off, so it is worth to consider consistently using one
457
+ * @return {string}
458
+ */ var UTF8ToString = (ptr, maxBytesToRead) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
459
+
460
+var ___assert_fail = (condition, filename, line, func) => {
461
+ abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [ filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function" ]);
462
+};
463
+
464
+var abortOnCannotGrowMemory = requestedSize => {
465
+ abort("OOM");
466
+};
467
+
468
+var _emscripten_resize_heap = requestedSize => {
469
+ var oldSize = HEAPU8.length;
470
+ requestedSize >>>= 0;
471
+ abortOnCannotGrowMemory(requestedSize);
472
+};
473
+
474
+var runtimeKeepaliveCounter = 0;
475
+
476
+var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
477
+
478
+var _proc_exit = code => {
479
+ EXITSTATUS = code;
480
+ if (!keepRuntimeAlive()) {
481
+ Module["onExit"]?.(code);
482
+ ABORT = true;
483
+ }
484
+ quit_(code, new ExitStatus(code));
485
+};
486
+
487
+/** @param {boolean|number=} implicit */ var exitJS = (status, implicit) => {
488
+ EXITSTATUS = status;
489
+ _proc_exit(status);
490
+};
491
+
492
+var _exit = exitJS;
493
+
494
+var getCFunc = ident => {
495
+ var func = Module["_" + ident];
496
+ return func;
497
+};
498
+
499
+var writeArrayToMemory = (array, buffer) => {
500
+ HEAP8.set(array, buffer);
501
+};
502
+
503
+var lengthBytesUTF8 = str => {
504
+ var len = 0;
505
+ for (var i = 0; i < str.length; ++i) {
506
+ var c = str.charCodeAt(i);
507
+ if (c <= 127) {
508
+ len++;
509
+ } else if (c <= 2047) {
510
+ len += 2;
511
+ } else if (c >= 55296 && c <= 57343) {
512
+ len += 4;
513
+ ++i;
514
+ } else {
515
+ len += 3;
516
+ }
517
+ }
518
+ return len;
519
+};
520
+
521
+var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
522
+ if (!(maxBytesToWrite > 0)) return 0;
523
+ var startIdx = outIdx;
524
+ var endIdx = outIdx + maxBytesToWrite - 1;
525
+ for (var i = 0; i < str.length; ++i) {
526
+ var u = str.charCodeAt(i);
527
+ if (u >= 55296 && u <= 57343) {
528
+ var u1 = str.charCodeAt(++i);
529
+ u = 65536 + ((u & 1023) << 10) | (u1 & 1023);
530
+ }
531
+ if (u <= 127) {
532
+ if (outIdx >= endIdx) break;
533
+ heap[outIdx++] = u;
534
+ } else if (u <= 2047) {
535
+ if (outIdx + 1 >= endIdx) break;
536
+ heap[outIdx++] = 192 | (u >> 6);
537
+ heap[outIdx++] = 128 | (u & 63);
538
+ } else if (u <= 65535) {
539
+ if (outIdx + 2 >= endIdx) break;
540
+ heap[outIdx++] = 224 | (u >> 12);
541
+ heap[outIdx++] = 128 | ((u >> 6) & 63);
542
+ heap[outIdx++] = 128 | (u & 63);
543
+ } else {
544
+ if (outIdx + 3 >= endIdx) break;
545
+ heap[outIdx++] = 240 | (u >> 18);
546
+ heap[outIdx++] = 128 | ((u >> 12) & 63);
547
+ heap[outIdx++] = 128 | ((u >> 6) & 63);
548
+ heap[outIdx++] = 128 | (u & 63);
549
+ }
550
+ }
551
+ heap[outIdx] = 0;
552
+ return outIdx - startIdx;
553
+};
554
+
555
+var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
556
+
557
+var stringToUTF8OnStack = str => {
558
+ var size = lengthBytesUTF8(str) + 1;
559
+ var ret = stackAlloc(size);
560
+ stringToUTF8(str, ret, size);
561
+ return ret;
562
+};
563
+
564
+/**
565
+ * @param {string|null=} returnType
566
+ * @param {Array=} argTypes
567
+ * @param {Arguments|Array=} args
568
+ * @param {Object=} opts
569
+ */ var ccall = (ident, returnType, argTypes, args, opts) => {
559570
 var toC = {
560571
 "string": str => {
561572
 var ret = 0;
562573
 if (str !== null && str !== undefined && str !== 0) {
563
- var len = (str.length << 2) + 1;
564
- ret = stackAlloc(len);
565
- stringToUTF8(str, ret, len);
574
+ ret = stringToUTF8OnStack(str);
566575
 }
567576
 return ret;
568577
 },
569578
 "array": arr => {
570579
 var ret = stackAlloc(arr.length);
@@ -598,51 +607,46 @@
598607
 if (stack !== 0) stackRestore(stack);
599608
 return convertReturnValue(ret);
600609
 }
601610
 ret = onDone(ret);
602611
 return ret;
603
-}
612
+};
604613
605
-function cwrap(ident, returnType, argTypes, opts) {
606
- argTypes = argTypes || [];
607
- var numericArgs = argTypes.every(type => type === "number" || type === "boolean");
614
+/**
615
+ * @param {string=} returnType
616
+ * @param {Array=} argTypes
617
+ * @param {Object=} opts
618
+ */ var cwrap = (ident, returnType, argTypes, opts) => {
619
+ var numericArgs = !argTypes || argTypes.every(type => type === "number" || type === "boolean");
608620
 var numericRet = returnType !== "string";
609621
 if (numericRet && numericArgs && !opts) {
610622
 return getCFunc(ident);
611623
 }
612624
 return function() {
613625
 return ccall(ident, returnType, argTypes, arguments, opts);
614626
 };
615
-}
616
-
617
-var asmLibraryArg = {
618
- "a": ___assert_fail,
619
- "b": _emscripten_resize_heap,
620
- "c": _exit
621
-};
622
-
623
-var asm = createWasm();
624
-
625
-var ___wasm_call_ctors = Module["___wasm_call_ctors"] = function() {
626
- return (___wasm_call_ctors = Module["___wasm_call_ctors"] = Module["asm"]["e"]).apply(null, arguments);
627
-};
628
-
629
-var _pikchr = Module["_pikchr"] = function() {
630
- return (_pikchr = Module["_pikchr"] = Module["asm"]["f"]).apply(null, arguments);
631
-};
632
-
633
-var stackSave = Module["stackSave"] = function() {
634
- return (stackSave = Module["stackSave"] = Module["asm"]["h"]).apply(null, arguments);
635
-};
636
-
637
-var stackRestore = Module["stackRestore"] = function() {
638
- return (stackRestore = Module["stackRestore"] = Module["asm"]["i"]).apply(null, arguments);
639
-};
640
-
641
-var stackAlloc = Module["stackAlloc"] = function() {
642
- return (stackAlloc = Module["stackAlloc"] = Module["asm"]["j"]).apply(null, arguments);
643
-};
627
+};
628
+
629
+var wasmImports = {
630
+ /** @export */ a: ___assert_fail,
631
+ /** @export */ b: _emscripten_resize_heap,
632
+ /** @export */ c: _exit
633
+};
634
+
635
+var wasmExports = createWasm();
636
+
637
+var ___wasm_call_ctors = () => (___wasm_call_ctors = wasmExports["e"])();
638
+
639
+var _pikchr = Module["_pikchr"] = (a0, a1, a2, a3, a4) => (_pikchr = Module["_pikchr"] = wasmExports["f"])(a0, a1, a2, a3, a4);
640
+
641
+var stackSave = () => (stackSave = wasmExports["h"])();
642
+
643
+var stackRestore = a0 => (stackRestore = wasmExports["i"])(a0);
644
+
645
+var stackAlloc = a0 => (stackAlloc = wasmExports["j"])(a0);
646
+
647
+Module["stackAlloc"] = stackAlloc;
644648
645649
 Module["stackSave"] = stackSave;
646650
647651
 Module["stackRestore"] = stackRestore;
648652
@@ -657,12 +661,11 @@
657661
 dependenciesFulfilled = function runCaller() {
658662
 if (!calledRun) run();
659663
 if (!calledRun) dependenciesFulfilled = runCaller;
660664
 };
661665
662
-function run(args) {
663
- args = args || arguments_;
666
+function run() {
664667
 if (runDependencies > 0) {
665668
 return;
666669
 }
667670
 preRun();
668671
 if (runDependencies > 0) {
@@ -699,15 +702,13 @@
699702
 }
700703
701704
 run();
702705
703706
704
- return initPikchrModule.ready
707
+ return moduleArg.ready
705708
 }
706709
 );
707710
 })();
708711
 if (typeof exports === 'object' && typeof module === 'object')
709712
 module.exports = initPikchrModule;
710713
 else if (typeof define === 'function' && define['amd'])
711
- define([], function() { return initPikchrModule; });
712
-else if (typeof exports === 'object')
713
- exports["initPikchrModule"] = initPikchrModule;
714
+ define([], () => initPikchrModule);
714715
--- extsrc/pikchr.js
+++ extsrc/pikchr.js
@@ -1,18 +1,17 @@
1
2 var initPikchrModule = (() => {
3 var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;
4
5 return (
6 function(config) {
7 var initPikchrModule = config || {};
8
9 var Module = typeof initPikchrModule != "undefined" ? initPikchrModule : {};
10
11 var readyPromiseResolve, readyPromiseReject;
12
13 Module["ready"] = new Promise(function(resolve, reject) {
14 readyPromiseResolve = resolve;
15 readyPromiseReject = reject;
16 });
17
18 var moduleOverrides = Object.assign({}, Module);
@@ -36,11 +35,11 @@
36 return Module["locateFile"](path, scriptDirectory);
37 }
38 return scriptDirectory + path;
39 }
40
41 var read_, readAsync, readBinary, setWindowTitle;
42
43 if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
44 if (ENVIRONMENT_IS_WORKER) {
45 scriptDirectory = self.location.href;
46 } else if (typeof document != "undefined" && document.currentScript) {
@@ -47,52 +46,51 @@
47 scriptDirectory = document.currentScript.src;
48 }
49 if (_scriptDir) {
50 scriptDirectory = _scriptDir;
51 }
52 if (scriptDirectory.indexOf("blob:") !== 0) {
53 scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
54 } else {
55 scriptDirectory = "";
56 }
57 {
58 read_ = url => {
59 var xhr = new XMLHttpRequest();
60 xhr.open("GET", url, false);
61 xhr.send(null);
62 return xhr.responseText;
63 };
64 if (ENVIRONMENT_IS_WORKER) {
65 readBinary = url => {
66 var xhr = new XMLHttpRequest();
67 xhr.open("GET", url, false);
68 xhr.responseType = "arraybuffer";
69 xhr.send(null);
70 return new Uint8Array(xhr.response);
71 };
72 }
73 readAsync = (url, onload, onerror) => {
74 var xhr = new XMLHttpRequest();
75 xhr.open("GET", url, true);
76 xhr.responseType = "arraybuffer";
77 xhr.onload = () => {
78 if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
79 onload(xhr.response);
80 return;
81 }
82 onerror();
83 };
84 xhr.onerror = onerror;
85 xhr.send(null);
86 };
87 }
88 setWindowTitle = title => document.title = title;
89 } else {}
90
91 var out = Module["print"] || console.log.bind(console);
92
93 var err = Module["printErr"] || console.warn.bind(console);
94
95 Object.assign(Module, moduleOverrides);
96
97 moduleOverrides = null;
98
@@ -104,12 +102,10 @@
104
105 var wasmBinary;
106
107 if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
108
109 var noExitRuntime = Module["noExitRuntime"] || true;
110
111 if (typeof WebAssembly != "object") {
112 abort("no native wasm support detected");
113 }
114
115 var wasmMemory;
@@ -116,119 +112,32 @@
116
117 var ABORT = false;
118
119 var EXITSTATUS;
120
121 var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
122
123 function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
124 var endIdx = idx + maxBytesToRead;
125 var endPtr = idx;
126 while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
127 if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
128 return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
129 }
130 var str = "";
131 while (idx < endPtr) {
132 var u0 = heapOrArray[idx++];
133 if (!(u0 & 128)) {
134 str += String.fromCharCode(u0);
135 continue;
136 }
137 var u1 = heapOrArray[idx++] & 63;
138 if ((u0 & 224) == 192) {
139 str += String.fromCharCode((u0 & 31) << 6 | u1);
140 continue;
141 }
142 var u2 = heapOrArray[idx++] & 63;
143 if ((u0 & 240) == 224) {
144 u0 = (u0 & 15) << 12 | u1 << 6 | u2;
145 } else {
146 u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
147 }
148 if (u0 < 65536) {
149 str += String.fromCharCode(u0);
150 } else {
151 var ch = u0 - 65536;
152 str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
153 }
154 }
155 return str;
156 }
157
158 function UTF8ToString(ptr, maxBytesToRead) {
159 return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
160 }
161
162 function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
163 if (!(maxBytesToWrite > 0)) return 0;
164 var startIdx = outIdx;
165 var endIdx = outIdx + maxBytesToWrite - 1;
166 for (var i = 0; i < str.length; ++i) {
167 var u = str.charCodeAt(i);
168 if (u >= 55296 && u <= 57343) {
169 var u1 = str.charCodeAt(++i);
170 u = 65536 + ((u & 1023) << 10) | u1 & 1023;
171 }
172 if (u <= 127) {
173 if (outIdx >= endIdx) break;
174 heap[outIdx++] = u;
175 } else if (u <= 2047) {
176 if (outIdx + 1 >= endIdx) break;
177 heap[outIdx++] = 192 | u >> 6;
178 heap[outIdx++] = 128 | u & 63;
179 } else if (u <= 65535) {
180 if (outIdx + 2 >= endIdx) break;
181 heap[outIdx++] = 224 | u >> 12;
182 heap[outIdx++] = 128 | u >> 6 & 63;
183 heap[outIdx++] = 128 | u & 63;
184 } else {
185 if (outIdx + 3 >= endIdx) break;
186 heap[outIdx++] = 240 | u >> 18;
187 heap[outIdx++] = 128 | u >> 12 & 63;
188 heap[outIdx++] = 128 | u >> 6 & 63;
189 heap[outIdx++] = 128 | u & 63;
190 }
191 }
192 heap[outIdx] = 0;
193 return outIdx - startIdx;
194 }
195
196 function stringToUTF8(str, outPtr, maxBytesToWrite) {
197 return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
198 }
199
200 var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
201
202 function updateMemoryViews() {
203 var b = wasmMemory.buffer;
204 Module["HEAP8"] = HEAP8 = new Int8Array(b);
205 Module["HEAP16"] = HEAP16 = new Int16Array(b);
206 Module["HEAP32"] = HEAP32 = new Int32Array(b);
207 Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
208 Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
 
209 Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
210 Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
211 Module["HEAPF64"] = HEAPF64 = new Float64Array(b);
212 }
213
214 var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;
215
216 var wasmTable;
217
218 var __ATPRERUN__ = [];
219
220 var __ATINIT__ = [];
221
222 var __ATPOSTRUN__ = [];
223
224 var runtimeInitialized = false;
225
226 function keepRuntimeAlive() {
227 return noExitRuntime;
228 }
229
230 function preRun() {
231 if (Module["preRun"]) {
232 if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ];
233 while (Module["preRun"].length) {
234 addOnPreRun(Module["preRun"].shift());
@@ -270,20 +179,16 @@
270
271 var dependenciesFulfilled = null;
272
273 function addRunDependency(id) {
274 runDependencies++;
275 if (Module["monitorRunDependencies"]) {
276 Module["monitorRunDependencies"](runDependencies);
277 }
278 }
279
280 function removeRunDependency(id) {
281 runDependencies--;
282 if (Module["monitorRunDependencies"]) {
283 Module["monitorRunDependencies"](runDependencies);
284 }
285 if (runDependencies == 0) {
286 if (runDependencyWatcher !== null) {
287 clearInterval(runDependencyWatcher);
288 runDependencyWatcher = null;
289 }
@@ -293,278 +198,382 @@
293 callback();
294 }
295 }
296 }
297
298 function abort(what) {
299 if (Module["onAbort"]) {
300 Module["onAbort"](what);
301 }
302 what = "Aborted(" + what + ")";
303 err(what);
304 ABORT = true;
305 EXITSTATUS = 1;
306 what += ". Build with -sASSERTIONS for more info.";
307 var e = new WebAssembly.RuntimeError(what);
308 readyPromiseReject(e);
309 throw e;
310 }
311
312 var dataURIPrefix = "data:application/octet-stream;base64,";
313
314 function isDataURI(filename) {
315 return filename.startsWith(dataURIPrefix);
316 }
 
317
318 var wasmBinaryFile;
319
320 wasmBinaryFile = "pikchr.wasm";
321
322 if (!isDataURI(wasmBinaryFile)) {
323 wasmBinaryFile = locateFile(wasmBinaryFile);
324 }
325
326 function getBinary(file) {
327 try {
328 if (file == wasmBinaryFile && wasmBinary) {
329 return new Uint8Array(wasmBinary);
330 }
331 if (readBinary) {
332 return readBinary(file);
333 }
334 throw "both async and sync fetching of the wasm failed";
335 } catch (err) {
336 abort(err);
337 }
338 }
339
340 function getBinaryPromise() {
341 if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
342 if (typeof fetch == "function") {
343 return fetch(wasmBinaryFile, {
344 credentials: "same-origin"
345 }).then(function(response) {
346 if (!response["ok"]) {
347 throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
348 }
349 return response["arrayBuffer"]();
350 }).catch(function() {
351 return getBinary(wasmBinaryFile);
352 });
353 }
354 }
355 return Promise.resolve().then(function() {
356 return getBinary(wasmBinaryFile);
357 });
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
358 }
359
360 function createWasm() {
361 var info = {
362 "a": asmLibraryArg
363 };
364 function receiveInstance(instance, module) {
365 var exports = instance.exports;
366 Module["asm"] = exports;
367 wasmMemory = Module["asm"]["d"];
368 updateMemoryViews();
369 wasmTable = Module["asm"]["g"];
370 addOnInit(Module["asm"]["e"]);
371 removeRunDependency("wasm-instantiate");
 
372 }
373 addRunDependency("wasm-instantiate");
374 function receiveInstantiationResult(result) {
375 receiveInstance(result["instance"]);
376 }
377 function instantiateArrayBuffer(receiver) {
378 return getBinaryPromise().then(function(binary) {
379 return WebAssembly.instantiate(binary, info);
380 }).then(function(instance) {
381 return instance;
382 }).then(receiver, function(reason) {
383 err("failed to asynchronously prepare wasm: " + reason);
384 abort(reason);
385 });
386 }
387 function instantiateAsync() {
388 if (!wasmBinary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(wasmBinaryFile) && typeof fetch == "function") {
389 return fetch(wasmBinaryFile, {
390 credentials: "same-origin"
391 }).then(function(response) {
392 var result = WebAssembly.instantiateStreaming(response, info);
393 return result.then(receiveInstantiationResult, function(reason) {
394 err("wasm streaming compile failed: " + reason);
395 err("falling back to ArrayBuffer instantiation");
396 return instantiateArrayBuffer(receiveInstantiationResult);
397 });
398 });
399 } else {
400 return instantiateArrayBuffer(receiveInstantiationResult);
401 }
402 }
403 if (Module["instantiateWasm"]) {
404 try {
405 var exports = Module["instantiateWasm"](info, receiveInstance);
406 return exports;
407 } catch (e) {
408 err("Module.instantiateWasm callback failed with error: " + e);
409 readyPromiseReject(e);
410 }
411 }
412 instantiateAsync().catch(readyPromiseReject);
413 return {};
414 }
415
416 var tempDouble;
417
418 var tempI64;
419
420 function ExitStatus(status) {
421 this.name = "ExitStatus";
422 this.message = "Program terminated with exit(" + status + ")";
423 this.status = status;
424 }
425
426 function callRuntimeCallbacks(callbacks) {
427 while (callbacks.length > 0) {
428 callbacks.shift()(Module);
429 }
430 }
431
432 function getValue(ptr, type = "i8") {
433 if (type.endsWith("*")) type = "*";
434 switch (type) {
435 case "i1":
436 return HEAP8[ptr >> 0];
437
438 case "i8":
439 return HEAP8[ptr >> 0];
440
441 case "i16":
442 return HEAP16[ptr >> 1];
443
444 case "i32":
445 return HEAP32[ptr >> 2];
446
447 case "i64":
448 return HEAP32[ptr >> 2];
449
450 case "float":
451 return HEAPF32[ptr >> 2];
452
453 case "double":
454 return HEAPF64[ptr >> 3];
455
456 case "*":
457 return HEAPU32[ptr >> 2];
458
459 default:
460 abort("invalid type for getValue: " + type);
461 }
462 return null;
463 }
464
465 function setValue(ptr, value, type = "i8") {
466 if (type.endsWith("*")) type = "*";
467 switch (type) {
468 case "i1":
469 HEAP8[ptr >> 0] = value;
470 break;
471
472 case "i8":
473 HEAP8[ptr >> 0] = value;
474 break;
475
476 case "i16":
477 HEAP16[ptr >> 1] = value;
478 break;
479
480 case "i32":
481 HEAP32[ptr >> 2] = value;
482 break;
483
484 case "i64":
485 tempI64 = [ value >>> 0, (tempDouble = value, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ],
486 HEAP32[ptr >> 2] = tempI64[0], HEAP32[ptr + 4 >> 2] = tempI64[1];
487 break;
488
489 case "float":
490 HEAPF32[ptr >> 2] = value;
491 break;
492
493 case "double":
494 HEAPF64[ptr >> 3] = value;
495 break;
496
497 case "*":
498 HEAPU32[ptr >> 2] = value;
499 break;
500
501 default:
502 abort("invalid type for setValue: " + type);
503 }
504 }
505
506 function ___assert_fail(condition, filename, line, func) {
507 abort("Assertion failed: " + UTF8ToString(condition) + ", at: " + [ filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function" ]);
508 }
509
510 function abortOnCannotGrowMemory(requestedSize) {
511 abort("OOM");
512 }
513
514 function _emscripten_resize_heap(requestedSize) {
515 var oldSize = HEAPU8.length;
516 requestedSize = requestedSize >>> 0;
517 abortOnCannotGrowMemory(requestedSize);
518 }
519
520 var SYSCALLS = {
521 varargs: undefined,
522 get: function() {
523 SYSCALLS.varargs += 4;
524 var ret = HEAP32[SYSCALLS.varargs - 4 >> 2];
525 return ret;
526 },
527 getStr: function(ptr) {
528 var ret = UTF8ToString(ptr);
529 return ret;
530 }
531 };
532
533 function _proc_exit(code) {
534 EXITSTATUS = code;
535 if (!keepRuntimeAlive()) {
536 if (Module["onExit"]) Module["onExit"](code);
537 ABORT = true;
538 }
539 quit_(code, new ExitStatus(code));
540 }
541
542 function exitJS(status, implicit) {
543 EXITSTATUS = status;
544 _proc_exit(status);
545 }
546
547 var _exit = exitJS;
548
549 function getCFunc(ident) {
550 var func = Module["_" + ident];
551 return func;
552 }
553
554 function writeArrayToMemory(array, buffer) {
555 HEAP8.set(array, buffer);
556 }
557
558 function ccall(ident, returnType, argTypes, args, opts) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
559 var toC = {
560 "string": str => {
561 var ret = 0;
562 if (str !== null && str !== undefined && str !== 0) {
563 var len = (str.length << 2) + 1;
564 ret = stackAlloc(len);
565 stringToUTF8(str, ret, len);
566 }
567 return ret;
568 },
569 "array": arr => {
570 var ret = stackAlloc(arr.length);
@@ -598,51 +607,46 @@
598 if (stack !== 0) stackRestore(stack);
599 return convertReturnValue(ret);
600 }
601 ret = onDone(ret);
602 return ret;
603 }
604
605 function cwrap(ident, returnType, argTypes, opts) {
606 argTypes = argTypes || [];
607 var numericArgs = argTypes.every(type => type === "number" || type === "boolean");
 
 
 
608 var numericRet = returnType !== "string";
609 if (numericRet && numericArgs && !opts) {
610 return getCFunc(ident);
611 }
612 return function() {
613 return ccall(ident, returnType, argTypes, arguments, opts);
614 };
615 }
616
617 var asmLibraryArg = {
618 "a": ___assert_fail,
619 "b": _emscripten_resize_heap,
620 "c": _exit
621 };
622
623 var asm = createWasm();
624
625 var ___wasm_call_ctors = Module["___wasm_call_ctors"] = function() {
626 return (___wasm_call_ctors = Module["___wasm_call_ctors"] = Module["asm"]["e"]).apply(null, arguments);
627 };
628
629 var _pikchr = Module["_pikchr"] = function() {
630 return (_pikchr = Module["_pikchr"] = Module["asm"]["f"]).apply(null, arguments);
631 };
632
633 var stackSave = Module["stackSave"] = function() {
634 return (stackSave = Module["stackSave"] = Module["asm"]["h"]).apply(null, arguments);
635 };
636
637 var stackRestore = Module["stackRestore"] = function() {
638 return (stackRestore = Module["stackRestore"] = Module["asm"]["i"]).apply(null, arguments);
639 };
640
641 var stackAlloc = Module["stackAlloc"] = function() {
642 return (stackAlloc = Module["stackAlloc"] = Module["asm"]["j"]).apply(null, arguments);
643 };
644
645 Module["stackSave"] = stackSave;
646
647 Module["stackRestore"] = stackRestore;
648
@@ -657,12 +661,11 @@
657 dependenciesFulfilled = function runCaller() {
658 if (!calledRun) run();
659 if (!calledRun) dependenciesFulfilled = runCaller;
660 };
661
662 function run(args) {
663 args = args || arguments_;
664 if (runDependencies > 0) {
665 return;
666 }
667 preRun();
668 if (runDependencies > 0) {
@@ -699,15 +702,13 @@
699 }
700
701 run();
702
703
704 return initPikchrModule.ready
705 }
706 );
707 })();
708 if (typeof exports === 'object' && typeof module === 'object')
709 module.exports = initPikchrModule;
710 else if (typeof define === 'function' && define['amd'])
711 define([], function() { return initPikchrModule; });
712 else if (typeof exports === 'object')
713 exports["initPikchrModule"] = initPikchrModule;
714
--- extsrc/pikchr.js
+++ extsrc/pikchr.js
@@ -1,18 +1,17 @@
1
2 var initPikchrModule = (() => {
3 var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;
4
5 return (
6 function(moduleArg = {}) {
 
7
8 var Module = moduleArg;
9
10 var readyPromiseResolve, readyPromiseReject;
11
12 Module["ready"] = new Promise((resolve, reject) => {
13 readyPromiseResolve = resolve;
14 readyPromiseReject = reject;
15 });
16
17 var moduleOverrides = Object.assign({}, Module);
@@ -36,11 +35,11 @@
35 return Module["locateFile"](path, scriptDirectory);
36 }
37 return scriptDirectory + path;
38 }
39
40 var read_, readAsync, readBinary;
41
42 if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
43 if (ENVIRONMENT_IS_WORKER) {
44 scriptDirectory = self.location.href;
45 } else if (typeof document != "undefined" && document.currentScript) {
@@ -47,52 +46,51 @@
46 scriptDirectory = document.currentScript.src;
47 }
48 if (_scriptDir) {
49 scriptDirectory = _scriptDir;
50 }
51 if (scriptDirectory.startsWith("blob:")) {
52 scriptDirectory = "";
53 } else {
54 scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
55 }
56 {
57 read_ = url => {
58 var xhr = new XMLHttpRequest;
59 xhr.open("GET", url, false);
60 xhr.send(null);
61 return xhr.responseText;
62 };
63 if (ENVIRONMENT_IS_WORKER) {
64 readBinary = url => {
65 var xhr = new XMLHttpRequest;
66 xhr.open("GET", url, false);
67 xhr.responseType = "arraybuffer";
68 xhr.send(null);
69 return new Uint8Array(/** @type{!ArrayBuffer} */ (xhr.response));
70 };
71 }
72 readAsync = (url, onload, onerror) => {
73 var xhr = new XMLHttpRequest;
74 xhr.open("GET", url, true);
75 xhr.responseType = "arraybuffer";
76 xhr.onload = () => {
77 if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
78 onload(xhr.response);
79 return;
80 }
81 onerror();
82 };
83 xhr.onerror = onerror;
84 xhr.send(null);
85 };
86 }
 
87 } else {}
88
89 var out = Module["print"] || console.log.bind(console);
90
91 var err = Module["printErr"] || console.error.bind(console);
92
93 Object.assign(Module, moduleOverrides);
94
95 moduleOverrides = null;
96
@@ -104,12 +102,10 @@
102
103 var wasmBinary;
104
105 if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
106
 
 
107 if (typeof WebAssembly != "object") {
108 abort("no native wasm support detected");
109 }
110
111 var wasmMemory;
@@ -116,119 +112,32 @@
112
113 var ABORT = false;
114
115 var EXITSTATUS;
116
117 var /** @type {!Int8Array} */ HEAP8, /** @type {!Uint8Array} */ HEAPU8, /** @type {!Int16Array} */ HEAP16, /** @type {!Uint16Array} */ HEAPU16, /** @type {!Int32Array} */ HEAP32, /** @type {!Uint32Array} */ HEAPU32, /** @type {!Float32Array} */ HEAPF32, /** @type {!Float64Array} */ HEAPF64;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
118
119 function updateMemoryViews() {
120 var b = wasmMemory.buffer;
121 Module["HEAP8"] = HEAP8 = new Int8Array(b);
122 Module["HEAP16"] = HEAP16 = new Int16Array(b);
 
123 Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
124 Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
125 Module["HEAP32"] = HEAP32 = new Int32Array(b);
126 Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
127 Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
128 Module["HEAPF64"] = HEAPF64 = new Float64Array(b);
129 }
130
 
 
 
 
131 var __ATPRERUN__ = [];
132
133 var __ATINIT__ = [];
134
135 var __ATPOSTRUN__ = [];
136
137 var runtimeInitialized = false;
138
 
 
 
 
139 function preRun() {
140 if (Module["preRun"]) {
141 if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ];
142 while (Module["preRun"].length) {
143 addOnPreRun(Module["preRun"].shift());
@@ -270,20 +179,16 @@
179
180 var dependenciesFulfilled = null;
181
182 function addRunDependency(id) {
183 runDependencies++;
184 Module["monitorRunDependencies"]?.(runDependencies);
 
 
185 }
186
187 function removeRunDependency(id) {
188 runDependencies--;
189 Module["monitorRunDependencies"]?.(runDependencies);
 
 
190 if (runDependencies == 0) {
191 if (runDependencyWatcher !== null) {
192 clearInterval(runDependencyWatcher);
193 runDependencyWatcher = null;
194 }
@@ -293,278 +198,382 @@
198 callback();
199 }
200 }
201 }
202
203 /** @param {string|number=} what */ function abort(what) {
204 Module["onAbort"]?.(what);
 
 
205 what = "Aborted(" + what + ")";
206 err(what);
207 ABORT = true;
208 EXITSTATUS = 1;
209 what += ". Build with -sASSERTIONS for more info.";
210 /** @suppress {checkTypes} */ var e = new WebAssembly.RuntimeError(what);
211 readyPromiseReject(e);
212 throw e;
213 }
214
215 var dataURIPrefix = "data:application/octet-stream;base64,";
216
217 /**
218 * Indicates whether filename is a base64 data URI.
219 * @noinline
220 */ var isDataURI = filename => filename.startsWith(dataURIPrefix);
221
222 var wasmBinaryFile;
223
224 wasmBinaryFile = "pikchr.wasm";
225
226 if (!isDataURI(wasmBinaryFile)) {
227 wasmBinaryFile = locateFile(wasmBinaryFile);
228 }
229
230 function getBinarySync(file) {
231 if (file == wasmBinaryFile && wasmBinary) {
232 return new Uint8Array(wasmBinary);
233 }
234 if (readBinary) {
235 return readBinary(file);
236 }
237 throw "both async and sync fetching of the wasm failed";
238 }
239
240 function getBinaryPromise(binaryFile) {
 
 
 
 
241 if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
242 if (typeof fetch == "function") {
243 return fetch(binaryFile, {
244 credentials: "same-origin"
245 }).then(response => {
246 if (!response["ok"]) {
247 throw `failed to load wasm binary file at '${binaryFile}'`;
248 }
249 return response["arrayBuffer"]();
250 }).catch(() => getBinarySync(binaryFile));
251 }
252 }
253 return Promise.resolve().then(() => getBinarySync(binaryFile));
254 }
255
256 function instantiateArrayBuffer(binaryFile, imports, receiver) {
257 return getBinaryPromise(binaryFile).then(binary => WebAssembly.instantiate(binary, imports)).then(instance => instance).then(receiver, reason => {
258 err(`failed to asynchronously prepare wasm: ${reason}`);
259 abort(reason);
260 });
261 }
262
263 function instantiateAsync(binary, binaryFile, imports, callback) {
264 if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && typeof fetch == "function") {
265 return fetch(binaryFile, {
266 credentials: "same-origin"
267 }).then(response => {
268 /** @suppress {checkTypes} */ var result = WebAssembly.instantiateStreaming(response, imports);
269 return result.then(callback, function(reason) {
270 err(`wasm streaming compile failed: ${reason}`);
271 err("falling back to ArrayBuffer instantiation");
272 return instantiateArrayBuffer(binaryFile, imports, callback);
273 });
274 });
275 }
276 return instantiateArrayBuffer(binaryFile, imports, callback);
277 }
278
279 function createWasm() {
280 var info = {
281 "a": wasmImports
282 };
283 /** @param {WebAssembly.Module=} module*/ function receiveInstance(instance, module) {
284 wasmExports = instance.exports;
285 wasmMemory = wasmExports["d"];
 
286 updateMemoryViews();
287 addOnInit(wasmExports["e"]);
 
288 removeRunDependency("wasm-instantiate");
289 return wasmExports;
290 }
291 addRunDependency("wasm-instantiate");
292 function receiveInstantiationResult(result) {
293 receiveInstance(result["instance"]);
294 }
295 if (Module["instantiateWasm"]) {
296 try {
297 return Module["instantiateWasm"](info, receiveInstance);
298 } catch (e) {
299 err(`Module.instantiateWasm callback failed with error: ${e}`);
300 readyPromiseReject(e);
301 }
302 }
303 instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject);
304 return {};
305 }
306
307 /** @constructor */ function ExitStatus(status) {
308 this.name = "ExitStatus";
309 this.message = `Program terminated with exit(${status})`;
310 this.status = status;
311 }
312
313 var callRuntimeCallbacks = callbacks => {
314 while (callbacks.length > 0) {
315 callbacks.shift()(Module);
316 }
317 };
318
319 /**
320 * @param {number} ptr
321 * @param {string} type
322 */ function getValue(ptr, type = "i8") {
323 if (type.endsWith("*")) type = "*";
324 switch (type) {
325 case "i1":
326 return HEAP8[((ptr) >> 0)];
327
328 case "i8":
329 return HEAP8[((ptr) >> 0)];
330
331 case "i16":
332 return HEAP16[((ptr) >> 1)];
333
334 case "i32":
335 return HEAP32[((ptr) >> 2)];
336
337 case "i64":
338 abort("to do getValue(i64) use WASM_BIGINT");
339
340 case "float":
341 return HEAPF32[((ptr) >> 2)];
342
343 case "double":
344 return HEAPF64[((ptr) >> 3)];
345
346 case "*":
347 return HEAPU32[((ptr) >> 2)];
348
349 default:
350 abort(`invalid type for getValue: ${type}`);
351 }
352 }
353
354 var noExitRuntime = Module["noExitRuntime"] || true;
355
356 /**
357 * @param {number} ptr
358 * @param {number} value
359 * @param {string} type
360 */ function setValue(ptr, value, type = "i8") {
361 if (type.endsWith("*")) type = "*";
362 switch (type) {
363 case "i1":
364 HEAP8[((ptr) >> 0)] = value;
365 break;
366
367 case "i8":
368 HEAP8[((ptr) >> 0)] = value;
369 break;
370
371 case "i16":
372 HEAP16[((ptr) >> 1)] = value;
373 break;
374
375 case "i32":
376 HEAP32[((ptr) >> 2)] = value;
377 break;
378
379 case "i64":
380 abort("to do setValue(i64) use WASM_BIGINT");
381
382 case "float":
383 HEAPF32[((ptr) >> 2)] = value;
384 break;
385
386 case "double":
387 HEAPF64[((ptr) >> 3)] = value;
388 break;
389
390 case "*":
391 HEAPU32[((ptr) >> 2)] = value;
392 break;
393
394 default:
395 abort(`invalid type for setValue: ${type}`);
396 }
397 }
398
399 var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
400
401 /**
402 * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given
403 * array that contains uint8 values, returns a copy of that string as a
404 * Javascript String object.
405 * heapOrArray is either a regular array, or a JavaScript typed array view.
406 * @param {number} idx
407 * @param {number=} maxBytesToRead
408 * @return {string}
409 */ var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => {
410 var endIdx = idx + maxBytesToRead;
411 var endPtr = idx;
412 while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
413 if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
414 return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
415 }
416 var str = "";
417 while (idx < endPtr) {
418 var u0 = heapOrArray[idx++];
419 if (!(u0 & 128)) {
420 str += String.fromCharCode(u0);
421 continue;
422 }
423 var u1 = heapOrArray[idx++] & 63;
424 if ((u0 & 224) == 192) {
425 str += String.fromCharCode(((u0 & 31) << 6) | u1);
426 continue;
427 }
428 var u2 = heapOrArray[idx++] & 63;
429 if ((u0 & 240) == 224) {
430 u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
431 } else {
432 u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
433 }
434 if (u0 < 65536) {
435 str += String.fromCharCode(u0);
436 } else {
437 var ch = u0 - 65536;
438 str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
439 }
440 }
441 return str;
442 };
443
444 /**
445 * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
446 * emscripten HEAP, returns a copy of that string as a Javascript String object.
447 *
448 * @param {number} ptr
449 * @param {number=} maxBytesToRead - An optional length that specifies the
450 * maximum number of bytes to read. You can omit this parameter to scan the
451 * string until the first 0 byte. If maxBytesToRead is passed, and the string
452 * at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
453 * string will cut short at that byte index (i.e. maxBytesToRead will not
454 * produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing
455 * frequent uses of UTF8ToString() with and without maxBytesToRead may throw
456 * JS JIT optimizations off, so it is worth to consider consistently using one
457 * @return {string}
458 */ var UTF8ToString = (ptr, maxBytesToRead) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
459
460 var ___assert_fail = (condition, filename, line, func) => {
461 abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [ filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function" ]);
462 };
463
464 var abortOnCannotGrowMemory = requestedSize => {
465 abort("OOM");
466 };
467
468 var _emscripten_resize_heap = requestedSize => {
469 var oldSize = HEAPU8.length;
470 requestedSize >>>= 0;
471 abortOnCannotGrowMemory(requestedSize);
472 };
473
474 var runtimeKeepaliveCounter = 0;
475
476 var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
477
478 var _proc_exit = code => {
479 EXITSTATUS = code;
480 if (!keepRuntimeAlive()) {
481 Module["onExit"]?.(code);
482 ABORT = true;
483 }
484 quit_(code, new ExitStatus(code));
485 };
486
487 /** @param {boolean|number=} implicit */ var exitJS = (status, implicit) => {
488 EXITSTATUS = status;
489 _proc_exit(status);
490 };
491
492 var _exit = exitJS;
493
494 var getCFunc = ident => {
495 var func = Module["_" + ident];
496 return func;
497 };
498
499 var writeArrayToMemory = (array, buffer) => {
500 HEAP8.set(array, buffer);
501 };
502
503 var lengthBytesUTF8 = str => {
504 var len = 0;
505 for (var i = 0; i < str.length; ++i) {
506 var c = str.charCodeAt(i);
507 if (c <= 127) {
508 len++;
509 } else if (c <= 2047) {
510 len += 2;
511 } else if (c >= 55296 && c <= 57343) {
512 len += 4;
513 ++i;
514 } else {
515 len += 3;
516 }
517 }
518 return len;
519 };
520
521 var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
522 if (!(maxBytesToWrite > 0)) return 0;
523 var startIdx = outIdx;
524 var endIdx = outIdx + maxBytesToWrite - 1;
525 for (var i = 0; i < str.length; ++i) {
526 var u = str.charCodeAt(i);
527 if (u >= 55296 && u <= 57343) {
528 var u1 = str.charCodeAt(++i);
529 u = 65536 + ((u & 1023) << 10) | (u1 & 1023);
530 }
531 if (u <= 127) {
532 if (outIdx >= endIdx) break;
533 heap[outIdx++] = u;
534 } else if (u <= 2047) {
535 if (outIdx + 1 >= endIdx) break;
536 heap[outIdx++] = 192 | (u >> 6);
537 heap[outIdx++] = 128 | (u & 63);
538 } else if (u <= 65535) {
539 if (outIdx + 2 >= endIdx) break;
540 heap[outIdx++] = 224 | (u >> 12);
541 heap[outIdx++] = 128 | ((u >> 6) & 63);
542 heap[outIdx++] = 128 | (u & 63);
543 } else {
544 if (outIdx + 3 >= endIdx) break;
545 heap[outIdx++] = 240 | (u >> 18);
546 heap[outIdx++] = 128 | ((u >> 12) & 63);
547 heap[outIdx++] = 128 | ((u >> 6) & 63);
548 heap[outIdx++] = 128 | (u & 63);
549 }
550 }
551 heap[outIdx] = 0;
552 return outIdx - startIdx;
553 };
554
555 var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
556
557 var stringToUTF8OnStack = str => {
558 var size = lengthBytesUTF8(str) + 1;
559 var ret = stackAlloc(size);
560 stringToUTF8(str, ret, size);
561 return ret;
562 };
563
564 /**
565 * @param {string|null=} returnType
566 * @param {Array=} argTypes
567 * @param {Arguments|Array=} args
568 * @param {Object=} opts
569 */ var ccall = (ident, returnType, argTypes, args, opts) => {
570 var toC = {
571 "string": str => {
572 var ret = 0;
573 if (str !== null && str !== undefined && str !== 0) {
574 ret = stringToUTF8OnStack(str);
 
 
575 }
576 return ret;
577 },
578 "array": arr => {
579 var ret = stackAlloc(arr.length);
@@ -598,51 +607,46 @@
607 if (stack !== 0) stackRestore(stack);
608 return convertReturnValue(ret);
609 }
610 ret = onDone(ret);
611 return ret;
612 };
613
614 /**
615 * @param {string=} returnType
616 * @param {Array=} argTypes
617 * @param {Object=} opts
618 */ var cwrap = (ident, returnType, argTypes, opts) => {
619 var numericArgs = !argTypes || argTypes.every(type => type === "number" || type === "boolean");
620 var numericRet = returnType !== "string";
621 if (numericRet && numericArgs && !opts) {
622 return getCFunc(ident);
623 }
624 return function() {
625 return ccall(ident, returnType, argTypes, arguments, opts);
626 };
627 };
628
629 var wasmImports = {
630 /** @export */ a: ___assert_fail,
631 /** @export */ b: _emscripten_resize_heap,
632 /** @export */ c: _exit
633 };
634
635 var wasmExports = createWasm();
636
637 var ___wasm_call_ctors = () => (___wasm_call_ctors = wasmExports["e"])();
638
639 var _pikchr = Module["_pikchr"] = (a0, a1, a2, a3, a4) => (_pikchr = Module["_pikchr"] = wasmExports["f"])(a0, a1, a2, a3, a4);
640
641 var stackSave = () => (stackSave = wasmExports["h"])();
642
643 var stackRestore = a0 => (stackRestore = wasmExports["i"])(a0);
644
645 var stackAlloc = a0 => (stackAlloc = wasmExports["j"])(a0);
646
647 Module["stackAlloc"] = stackAlloc;
 
 
 
 
 
 
 
 
648
649 Module["stackSave"] = stackSave;
650
651 Module["stackRestore"] = stackRestore;
652
@@ -657,12 +661,11 @@
661 dependenciesFulfilled = function runCaller() {
662 if (!calledRun) run();
663 if (!calledRun) dependenciesFulfilled = runCaller;
664 };
665
666 function run() {
 
667 if (runDependencies > 0) {
668 return;
669 }
670 preRun();
671 if (runDependencies > 0) {
@@ -699,15 +702,13 @@
702 }
703
704 run();
705
706
707 return moduleArg.ready
708 }
709 );
710 })();
711 if (typeof exports === 'object' && typeof module === 'object')
712 module.exports = initPikchrModule;
713 else if (typeof define === 'function' && define['amd'])
714 define([], () => initPikchrModule);
 
 
715
M extsrc/pikchr.wasm
--- extsrc/pikchr.wasm
+++ extsrc/pikchr.wasm
cannot compute difference between binary files
11
--- extsrc/pikchr.wasm
+++ extsrc/pikchr.wasm
0 annot compute difference between binary files
1
--- extsrc/pikchr.wasm
+++ extsrc/pikchr.wasm
0 annot compute difference between binary files
1
M src/main.mk
+1 -1
--- src/main.mk
+++ src/main.mk
@@ -2115,11 +2115,11 @@
21152115
 $(OBJDIR)/cson_amalgamation.o: $(SRCDIR_extsrc)/cson_amalgamation.c
21162116
 $(XTCC) -c $(SRCDIR_extsrc)/cson_amalgamation.c -o $@
21172117
21182118
 $(SRCDIR_extsrc)/pikchr.js: $(SRCDIR_extsrc)/pikchr.c
21192119
 $(EMCC_WRAPPER) -o $@ $(EMCC_OPT) --no-entry \
2120
- -sEXPORTED_RUNTIME_METHODS=cwrap,setValue,getValue,stackSave,stackRestore \
2120
+ -sEXPORTED_RUNTIME_METHODS=cwrap,setValue,getValue,stackSave,stackRestore,stackAlloc \
21212121
 -sEXPORTED_FUNCTIONS=_pikchr $(SRCDIR_extsrc)/pikchr.c \
21222122
 -sENVIRONMENT=web \
21232123
 -sMODULARIZE \
21242124
 -sEXPORT_NAME=initPikchrModule \
21252125
 --minify 0
21262126
--- src/main.mk
+++ src/main.mk
@@ -2115,11 +2115,11 @@
2115 $(OBJDIR)/cson_amalgamation.o: $(SRCDIR_extsrc)/cson_amalgamation.c
2116 $(XTCC) -c $(SRCDIR_extsrc)/cson_amalgamation.c -o $@
2117
2118 $(SRCDIR_extsrc)/pikchr.js: $(SRCDIR_extsrc)/pikchr.c
2119 $(EMCC_WRAPPER) -o $@ $(EMCC_OPT) --no-entry \
2120 -sEXPORTED_RUNTIME_METHODS=cwrap,setValue,getValue,stackSave,stackRestore \
2121 -sEXPORTED_FUNCTIONS=_pikchr $(SRCDIR_extsrc)/pikchr.c \
2122 -sENVIRONMENT=web \
2123 -sMODULARIZE \
2124 -sEXPORT_NAME=initPikchrModule \
2125 --minify 0
2126
--- src/main.mk
+++ src/main.mk
@@ -2115,11 +2115,11 @@
2115 $(OBJDIR)/cson_amalgamation.o: $(SRCDIR_extsrc)/cson_amalgamation.c
2116 $(XTCC) -c $(SRCDIR_extsrc)/cson_amalgamation.c -o $@
2117
2118 $(SRCDIR_extsrc)/pikchr.js: $(SRCDIR_extsrc)/pikchr.c
2119 $(EMCC_WRAPPER) -o $@ $(EMCC_OPT) --no-entry \
2120 -sEXPORTED_RUNTIME_METHODS=cwrap,setValue,getValue,stackSave,stackRestore,stackAlloc \
2121 -sEXPORTED_FUNCTIONS=_pikchr $(SRCDIR_extsrc)/pikchr.c \
2122 -sENVIRONMENT=web \
2123 -sMODULARIZE \
2124 -sEXPORT_NAME=initPikchrModule \
2125 --minify 0
2126

Keyboard Shortcuts

Open search /
Next entry (timeline) j
Previous entry (timeline) k
Open focused entry Enter
Show this help ?
Toggle theme Top nav button