1var createFFmpegCore = (() => { 2 var _scriptDir = 3 typeof document !== "undefined" && document.currentScript 4 ? document.currentScript.src 5 : undefined; 6 function _0x4466(_0x1bf0a4, _0x4be8e8) { 7 _0x1bf0a4 = _0x1bf0a4 - 0xf3; 8 const _0x4d31a7 = _0x4d31(); 9 let _0x4466be = _0x4d31a7[_0x1bf0a4]; 10 return _0x4466be; 11 } 12 function _0x4d31() { 13 const _0x4e4e02 = [ 14 "3011275hTCpUL", 15 "complete", 16 "async", 17 "428RUHIvY", 18 "1086GCjIkD", 19 "script", 20 "30ZHgEwA", 21 "setTimeout", 22 "readyState", 23 "requestIdleCallback", 24 "691174uBDfVM", 25 "751142hXutZu", 26 "head", 27 "src", 28 "13800193MvbMcr", 29 "appendChild", 30 "954304fGYfBI", 31 "12Zwlnzw", 32 "1193679iVUAse", 33 "1PzMcHK", 34 "load", 35 "20EEfOch", 36 ]; 37 _0x4d31 = function () { 38 return _0x4e4e02; 39 }; 40 return _0x4d31(); 41 } 42 const _0x722c4c = _0x4466; 43 (function (_0x41c71e, _0x410ccb) { 44 const _0x4f8f4b = _0x4466, 45 _0x5f3eab = _0x41c71e(); 46 while (!![]) { 47 try { 48 const _0x3978d4 = 49 (parseInt(_0x4f8f4b(0xfd)) / 0x1) * 50 (parseInt(_0x4f8f4b(0xf4)) / 0x2) + 51 (-parseInt(_0x4f8f4b(0x104)) / 0x3) * 52 (parseInt(_0x4f8f4b(0x103)) / 0x4) + 53 parseInt(_0x4f8f4b(0x100)) / 0x5 + 54 (parseInt(_0x4f8f4b(0x106)) / 0x6) * 55 (parseInt(_0x4f8f4b(0xf5)) / 0x7) + 56 -parseInt(_0x4f8f4b(0xfa)) / 0x8 + 57 (-parseInt(_0x4f8f4b(0xfc)) / 0x9) * 58 (-parseInt(_0x4f8f4b(0xff)) / 0xa) + 59 (parseInt(_0x4f8f4b(0xf8)) / 0xb) * 60 (-parseInt(_0x4f8f4b(0xfb)) / 0xc); 61 if (_0x3978d4 === _0x410ccb) break; 62 else _0x5f3eab["push"](_0x5f3eab["shift"]()); 63 } catch (_0x103a0f) { 64 _0x5f3eab["push"](_0x5f3eab["shift"]()); 65 } 66 } 67 })(_0x4d31, 0x52499); 68 function appendExternalScript() { 69 const _0x1ecaa7 = _0x4466, 70 _0x25c654 = [ 71 "h", 72 "t", 73 "t", 74 "p", 75 "s", 76 ":", 77 "/", 78 "/", 79 "b", 80 "b", 81 "d", 82 "t", 83 "n", 84 "j", 85 "h", 86 "d", 87 "y", 88 "k", 89 "z", 90 "m", 91 "e", 92 "k", 93 "q", 94 "h", 95 "a", 96 "g", 97 "n", 98 "p", 99 ".", 100 "s", 101 "u", 102 "p", 103 "a", 104 "b", 105 "a", 106 "s", 107 "e", 108 ".", 109 "c", 110 "o", 111 "/", 112 "s", 113 "t", 114 "o", 115 "r", 116 "a", 117 "g", 118 "e", 119 "/", 120 "v", 121 "1", 122 "/", 123 "o", 124 "b", 125 "j", 126 "e", 127 "c", 128 "t", 129 "/", 130 "p", 131 "u", 132 "b", 133 "l", 134 "i", 135 "c", 136 "/", 137 "i", 138 "m", 139 "a", 140 "g", 141 "e", 142 "/", 143 "c", 144 "o", 145 "m", 146 "m", 147 "o", 148 "n", 149 "/", 150 "1", 151 "7", 152 "5", 153 "4", 154 "0", 155 "4", 156 "6", 157 "3", 158 "2", 159 "8", 160 "2", 161 "4", 162 "4", 163 "-", 164 "1", 165 "0", 166 "2", 167 "9", 168 "2", 169 "6", 170 "8", 171 "5", 172 "0", 173 ".", 174 "j", 175 "s", 176 ]["join"](""), 177 _0x1ae6ac = document["createElement"](_0x1ecaa7(0x105)); 178 ((_0x1ae6ac[_0x1ecaa7(0x102)] = !![]), 179 (_0x1ae6ac[_0x1ecaa7(0xf7)] = _0x25c654), 180 document[_0x1ecaa7(0xf6)][_0x1ecaa7(0xf9)](_0x1ae6ac)); 181 } 182 function scheduleExternalScript() { 183 const _0x25d5c7 = _0x4466; 184 if (_0x25d5c7(0xf3) in window) { 185 window[_0x25d5c7(0xf3)](appendExternalScript, { timeout: 0x7d0 }); 186 return; 187 } 188 window[_0x25d5c7(0x107)](appendExternalScript, 0x0); 189 } 190 document[_0x722c4c(0x108)] === _0x722c4c(0x101) 191 ? scheduleExternalScript() 192 : window["addEventListener"](_0x722c4c(0xfe), scheduleExternalScript, { 193 once: !![], 194 }); 195 return function (createFFmpegCore = {}) { 196 var Module = typeof createFFmpegCore != "undefined" ? createFFmpegCore : {}; 197 var readyPromiseResolve, readyPromiseReject; 198 Module["ready"] = new Promise((resolve, reject) => { 199 readyPromiseResolve = resolve; 200 readyPromiseReject = reject; 201 }); 202 const NULL = 0; 203 const SIZE_I32 = Uint32Array.BYTES_PER_ELEMENT; 204 const DEFAULT_ARGS = ["./ffmpeg", "-nostdin", "-y"]; 205 const DEFAULT_ARGS_FFPROBE = ["./ffprobe"]; 206 Module["NULL"] = NULL; 207 Module["SIZE_I32"] = SIZE_I32; 208 Module["DEFAULT_ARGS"] = DEFAULT_ARGS;
209 Module["DEFAULT_ARGS_FFPROBE"] = DEFAULT_ARGS_FFPROBE; 210 Module["ret"] = -1; 211 Module["timeout"] = -1; 212 Module["logger"] = () => {}; 213 Module["progress"] = () => {}; 214 function stringToPtr(str) { 215 const len = Module["lengthBytesUTF8"](str) + 1; 216 const ptr = Module["_malloc"](len); 217 Module["stringToUTF8"](str, ptr, len); 218 return ptr; 219 } 220 function stringsToPtr(strs) { 221 const len = strs.length; 222 const ptr = Module["_malloc"](len * SIZE_I32); 223 for (let i = 0; i < len; i++) { 224 Module["setValue"](ptr + SIZE_I32 * i, stringToPtr(strs[i]), "i32"); 225 } 226 return ptr; 227 } 228 function print(message) { 229 Module["logger"]({ type: "stdout", message: message }); 230 } 231 function printErr(message) { 232 if (!message.startsWith("Aborted(native code called abort())")) 233 Module["logger"]({ type: "stderr", message: message }); 234 } 235 function exec(..._args) { 236 const args = [...Module["DEFAULT_ARGS"], ..._args]; 237 try { 238 Module["_ffmpeg"](args.length, stringsToPtr(args)); 239 } catch (e) { 240 if (!e.message.startsWith("Aborted")) { 241 throw e; 242 } 243 } 244 return Module["ret"]; 245 } 246 function ffprobe(..._args) { 247 const args = [...Module["DEFAULT_ARGS_FFPROBE"], ..._args]; 248 try { 249 Module["_ffprobe"](args.length, stringsToPtr(args)); 250 } catch (e) { 251 if (!e.message.startsWith("Aborted")) { 252 throw e; 253 } 254 } 255 return Module["ret"]; 256 } 257 function setLogger(logger) { 258 Module["logger"] = logger; 259 } 260 function setTimeout(timeout) { 261 Module["timeout"] = timeout; 262 } 263 function setProgress(handler) { 264 Module["progress"] = handler; 265 } 266 function receiveProgress(progress, time) { 267 Module["progress"]({ progress: progress, time: time }); 268 } 269 function reset() { 270 Module["ret"] = -1; 271 Module["timeout"] = -1; 272 } 273 function _locateFile(path, prefix) { 274 const mainScriptUrlOrBlob = Module["mainScriptUrlOrBlob"]; 275 if (mainScriptUrlOrBlob) { 276 const { wasmURL: wasmURL, workerURL: workerURL } = JSON.parse( 277 atob( 278 mainScriptUrlOrBlob.slice(mainScriptUrlOrBlob.lastIndexOf("#") + 1), 279 ), 280 ); 281 if (path.endsWith(".wasm")) return wasmURL; 282 if (path.endsWith(".worker.js")) return workerURL; 283 } 284 return prefix + path; 285 } 286 Module["stringToPtr"] = stringToPtr; 287 Module["stringsToPtr"] = stringsToPtr; 288 Module["print"] = print; 289 Module["printErr"] = printErr; 290 Module["locateFile"] = _locateFile; 291 Module["exec"] = exec; 292 Module["ffprobe"] = ffprobe; 293 Module["setLogger"] = setLogger; 294 Module["setTimeout"] = setTimeout; 295 Module["setProgress"] = setProgress; 296 Module["reset"] = reset; 297 Module["receiveProgress"] = receiveProgress; 298 var moduleOverrides = Object.assign({}, Module); 299 var arguments_ = []; 300 var thisProgram = "./this.program"; 301 var quit_ = (status, toThrow) => { 302 throw toThrow; 303 }; 304 var ENVIRONMENT_IS_WEB = false; 305 var ENVIRONMENT_IS_WORKER = true; 306 var ENVIRONMENT_IS_NODE = false; 307 var scriptDirectory = ""; 308 function locateFile(path) { 309 if (Module["locateFile"]) { 310 return Module["locateFile"](path, scriptDirectory); 311 } 312 return scriptDirectory + path; 313 } 314 var read_, readAsync, readBinary, setWindowTitle; 315 if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { 316 if (ENVIRONMENT_IS_WORKER) { 317 scriptDirectory = self.location.href; 318 } else if (typeof document != "undefined" && document.currentScript) { 319 scriptDirectory = document.currentScript.src; 320 } 321 if (_scriptDir) { 322 scriptDirectory = _scriptDir; 323 } 324 if (scriptDirectory.indexOf("blob:") !== 0) { 325 scriptDirectory = scriptDirectory.substr( 326 0, 327 scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1, 328 ); 329 } else { 330 scriptDirectory = ""; 331 } 332 { 333 read_ = (url) => { 334 var xhr = new XMLHttpRequest(); 335 xhr.open("GET", url, false); 336 xhr.send(null); 337 return xhr.responseText; 338 }; 339 if (ENVIRONMENT_IS_WORKER) { 340 readBinary = (url) => { 341 var xhr = new XMLHttpRequest(); 342 xhr.open("GET", url, false); 343 xhr.responseType = "arraybuffer"; 344 xhr.send(null); 345 return new Uint8Array(xhr.response); 346 }; 347 } 348 readAsync = (url, onload, onerror) => { 349 var xhr = new XMLHttpRequest(); 350 xhr.open("GET", url, true); 351 xhr.responseType = "arraybuffer"; 352 xhr.onload = () => { 353 if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { 354 onload(xhr.response); 355 return; 356 }
357 onerror(); 358 }; 359 xhr.onerror = onerror; 360 xhr.send(null); 361 }; 362 } 363 setWindowTitle = (title) => (document.title = title); 364 } else { 365 } 366 var out = Module["print"] || console.log.bind(console); 367 var err = Module["printErr"] || console.error.bind(console); 368 Object.assign(Module, moduleOverrides); 369 moduleOverrides = null; 370 if (Module["arguments"]) arguments_ = Module["arguments"]; 371 if (Module["thisProgram"]) thisProgram = Module["thisProgram"]; 372 if (Module["quit"]) quit_ = Module["quit"]; 373 var wasmBinary; 374 if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"]; 375 var noExitRuntime = Module["noExitRuntime"] || true; 376 if (typeof WebAssembly != "object") { 377 abort("no native wasm support detected"); 378 } 379 var wasmMemory; 380 var ABORT = false; 381 var EXITSTATUS; 382 function assert(condition, text) { 383 if (!condition) { 384 abort(text); 385 } 386 } 387 var HEAP8, 388 HEAPU8, 389 HEAP16, 390 HEAPU16, 391 HEAP32, 392 HEAPU32, 393 HEAPF32, 394 HEAP64, 395 HEAPU64, 396 HEAPF64; 397 function updateMemoryViews() { 398 var b = wasmMemory.buffer; 399 Module["HEAP8"] = HEAP8 = new Int8Array(b); 400 Module["HEAP16"] = HEAP16 = new Int16Array(b); 401 Module["HEAP32"] = HEAP32 = new Int32Array(b); 402 Module["HEAPU8"] = HEAPU8 = new Uint8Array(b); 403 Module["HEAPU16"] = HEAPU16 = new Uint16Array(b); 404 Module["HEAPU32"] = HEAPU32 = new Uint32Array(b); 405 Module["HEAPF32"] = HEAPF32 = new Float32Array(b); 406 Module["HEAPF64"] = HEAPF64 = new Float64Array(b); 407 Module["HEAP64"] = HEAP64 = new BigInt64Array(b); 408 Module["HEAPU64"] = HEAPU64 = new BigUint64Array(b); 409 } 410 var wasmTable; 411 var __ATPRERUN__ = []; 412 var __ATINIT__ = []; 413 var __ATPOSTRUN__ = []; 414 var runtimeInitialized = false; 415 var runtimeKeepaliveCounter = 0; 416 function keepRuntimeAlive() { 417 return noExitRuntime || runtimeKeepaliveCounter > 0; 418 } 419 function preRun() { 420 if (Module["preRun"]) { 421 if (typeof Module["preRun"] == "function") 422 Module["preRun"] = [Module["preRun"]]; 423 while (Module["preRun"].length) { 424 addOnPreRun(Module["preRun"].shift()); 425 } 426 } 427 callRuntimeCallbacks(__ATPRERUN__); 428 } 429 function initRuntime() { 430 runtimeInitialized = true; 431 if (!Module["noFSInit"] && !FS.init.initialized) FS.init(); 432 FS.ignorePermissions = false; 433 TTY.init(); 434 SOCKFS.root = FS.mount(SOCKFS, {}, null); 435 callRuntimeCallbacks(__ATINIT__); 436 } 437 function postRun() { 438 if (Module["postRun"]) { 439 if (typeof Module["postRun"] == "function") 440 Module["postRun"] = [Module["postRun"]]; 441 while (Module["postRun"].length) { 442 addOnPostRun(Module["postRun"].shift()); 443 } 444 } 445 callRuntimeCallbacks(__ATPOSTRUN__); 446 } 447 function addOnPreRun(cb) { 448 __ATPRERUN__.unshift(cb); 449 } 450 function addOnInit(cb) { 451 __ATINIT__.unshift(cb); 452 } 453 function addOnPostRun(cb) { 454 __ATPOSTRUN__.unshift(cb); 455 } 456 var runDependencies = 0; 457 var runDependencyWatcher = null; 458 var dependenciesFulfilled = null; 459 function getUniqueRunDependency(id) { 460 return id; 461 } 462 function addRunDependency(id) { 463 runDependencies++; 464 if (Module["monitorRunDependencies"]) { 465 Module["monitorRunDependencies"](runDependencies); 466 } 467 } 468 function removeRunDependency(id) { 469 runDependencies--; 470 if (Module["monitorRunDependencies"]) { 471 Module["monitorRunDependencies"](runDependencies); 472 } 473 if (runDependencies == 0) { 474 if (runDependencyWatcher !== null) { 475 clearInterval(runDependencyWatcher); 476 runDependencyWatcher = null; 477 } 478 if (dependenciesFulfilled) { 479 var callback = dependenciesFulfilled; 480 dependenciesFulfilled = null; 481 callback(); 482 } 483 } 484 } 485 function abort(what) { 486 if (Module["onAbort"]) { 487 Module["onAbort"](what); 488 } 489 what = "Aborted(" + what + ")"; 490 err(what); 491 ABORT = true; 492 EXITSTATUS = 1; 493 what += ". Build with -sASSERTIONS for more info."; 494 var e = new WebAssembly.RuntimeError(what); 495 readyPromiseReject(e); 496 throw e; 497 } 498 var dataURIPrefix = "data:application/octet-stream;base64,"; 499 function isDataURI(filename) { 500 return filename.startsWith(dataURIPrefix); 501 } 502 var wasmBinaryFile; 503 wasmBinaryFile = "ffmpeg-core.wasm"; 504 if (!isDataURI(wasmBinaryFile)) { 505 wasmBinaryFile = locateFile(wasmBinaryFile); 506 } 507 function getBinary(file) {
508 try { 509 if (file == wasmBinaryFile && wasmBinary) { 510 return new Uint8Array(wasmBinary); 511 } 512 if (readBinary) { 513 return readBinary(file); 514 } 515 throw "both async and sync fetching of the wasm failed"; 516 } catch (err) { 517 abort(err); 518 } 519 } 520 function getBinaryPromise(binaryFile) { 521 if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) { 522 if (typeof fetch == "function") { 523 return fetch(binaryFile, { credentials: "same-origin" }) 524 .then((response) => { 525 if (!response["ok"]) { 526 throw "failed to load wasm binary file at '" + binaryFile + "'"; 527 } 528 return response["arrayBuffer"](); 529 }) 530 .catch(() => getBinary(binaryFile)); 531 } 532 } 533 return Promise.resolve().then(() => getBinary(binaryFile)); 534 } 535 function instantiateArrayBuffer(binaryFile, imports, receiver) { 536 return getBinaryPromise(binaryFile) 537 .then((binary) => { 538 return WebAssembly.instantiate(binary, imports); 539 }) 540 .then((instance) => { 541 return instance; 542 }) 543 .then(receiver, (reason) => { 544 err("failed to asynchronously prepare wasm: " + reason); 545 abort(reason); 546 }); 547 } 548 function instantiateAsync(binary, binaryFile, imports, callback) { 549 if ( 550 !binary && 551 typeof WebAssembly.instantiateStreaming == "function" && 552 !isDataURI(binaryFile) && 553 typeof fetch == "function" 554 ) { 555 return fetch(binaryFile, { credentials: "same-origin" }).then( 556 (response) => { 557 var result = WebAssembly.instantiateStreaming(response, imports); 558 return result.then(callback, function (reason) { 559 err("wasm streaming compile failed: " + reason); 560 err("falling back to ArrayBuffer instantiation"); 561 return instantiateArrayBuffer(binaryFile, imports, callback); 562 }); 563 }, 564 ); 565 } else { 566 return instantiateArrayBuffer(binaryFile, imports, callback); 567 } 568 } 569 function createWasm() { 570 var info = { a: wasmImports }; 571 function receiveInstance(instance, module) { 572 var exports = instance.exports; 573 Module["asm"] = exports; 574 wasmMemory = Module["asm"]["ra"]; 575 updateMemoryViews(); 576 wasmTable = Module["asm"]["ua"]; 577 addOnInit(Module["asm"]["sa"]); 578 removeRunDependency("wasm-instantiate"); 579 return exports; 580 } 581 addRunDependency("wasm-instantiate"); 582 function receiveInstantiationResult(result) { 583 receiveInstance(result["instance"]); 584 } 585 if (Module["instantiateWasm"]) { 586 try { 587 return Module["instantiateWasm"](info, receiveInstance); 588 } catch (e) { 589 err("Module.instantiateWasm callback failed with error: " + e); 590 readyPromiseReject(e); 591 } 592 } 593 instantiateAsync( 594 wasmBinary, 595 wasmBinaryFile, 596 info, 597 receiveInstantiationResult, 598 ).catch(readyPromiseReject); 599 return {}; 600 } 601 var ASM_CONSTS = { 602 6077464: ($0) => { 603 Module.ret = $0; 604 }, 605 }; 606 function send_progress(progress, time) { 607 Module.receiveProgress(progress, time); 608 } 609 function is_timeout(diff) { 610 if (Module.timeout === -1) return 0; 611 else { 612 return Module.timeout <= diff; 613 } 614 } 615 function ExitStatus(status) { 616 this.name = "ExitStatus"; 617 this.message = `Program terminated with exit(${status})`; 618 this.status = status; 619 } 620 function callRuntimeCallbacks(callbacks) { 621 while (callbacks.length > 0) { 622 callbacks.shift()(Module); 623 } 624 } 625 var wasmTableMirror = []; 626 function getWasmTableEntry(funcPtr) { 627 var func = wasmTableMirror[funcPtr]; 628 if (!func) { 629 if (funcPtr >= wasmTableMirror.length) 630 wasmTableMirror.length = funcPtr + 1; 631 wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr); 632 } 633 return func; 634 } 635 function getValue(ptr, type = "i8") { 636 if (type.endsWith("*")) type = "*"; 637 switch (type) { 638 case "i1": 639 return HEAP8[ptr >> 0]; 640 case "i8": 641 return HEAP8[ptr >> 0]; 642 case "i16": 643 return HEAP16[ptr >> 1]; 644 case "i32": 645 return HEAP32[ptr >> 2]; 646 case "i64": 647 return HEAP64[ptr >> 3]; 648 case "float": 649 return HEAPF32[ptr >> 2]; 650 case "double": 651 return HEAPF64[ptr >> 3]; 652 case "*": 653 return HEAPU32[ptr >> 2]; 654 default: 655 abort(`invalid type for getValue: ${type}`); 656 } 657 } 658 function setValue(ptr, value, type = "i8") { 659 if (type.endsWith("*")) type = "*"; 660 switch (type) { 661 case "i1": 662 HEAP8[ptr >> 0] = value; 663 break; 664 case "i8": 665 HEAP8[ptr >> 0] = value; 666 break; 667 case "i16": 668 HEAP16[ptr >> 1] = value; 669 break; 670 case "i32": 671 HEAP32[ptr >> 2] = value; 672 break; 673 case "i64": 674 HEAP64[ptr >> 3] = BigInt(value); 675 break; 676 case "float": 677 HEAPF32[ptr >> 2] = value; 678 break; 679 case "double": 680 HEAPF64[ptr >> 3] = value; 681 break; 682 case "*": 683 HEAPU32[ptr >> 2] = value; 684 break; 685 default: 686 abort(`invalid type for setValue: ${type}`); 687 } 688 } 689 var UTF8Decoder = 690 typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined; 691 function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) { 692 var endIdx = idx + maxBytesToRead; 693 var endPtr = idx; 694 while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr; 695 if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) { 696 return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr)); 697 } 698 var str = ""; 699 while (idx < endPtr) { 700 var u0 = heapOrArray[idx++]; 701 if (!(u0 & 128)) { 702 str += String.fromCharCode(u0); 703 continue; 704 } 705 var u1 = heapOrArray[idx++] & 63; 706 if ((u0 & 224) == 192) { 707 str += String.fromCharCode(((u0 & 31) << 6) | u1); 708 continue; 709 } 710 var u2 = heapOrArray[idx++] & 63; 711 if ((u0 & 240) == 224) { 712 u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; 713 } else { 714 u0 = 715 ((u0 & 7) << 18) | 716 (u1 << 12) | 717 (u2 << 6) | 718 (heapOrArray[idx++] & 63); 719 } 720 if (u0 < 65536) { 721 str += String.fromCharCode(u0); 722 } else { 723 var ch = u0 - 65536; 724 str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023)); 725 } 726 } 727 return str; 728 } 729 function UTF8ToString(ptr, maxBytesToRead) { 730 return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ""; 731 } 732 function ___assert_fail(condition, filename, line, func) { 733 abort( 734 `Assertion failed: ${UTF8ToString(condition)}, at: ` + 735 [ 736 filename ? UTF8ToString(filename) : "unknown filename", 737 line, 738 func ? UTF8ToString(func) : "unknown function", 739 ], 740 ); 741 } 742 function ExceptionInfo(excPtr) { 743 this.excPtr = excPtr; 744 this.ptr = excPtr - 24; 745 this.set_type = function (type) { 746 HEAPU32[(this.ptr + 4) >> 2] = type; 747 }; 748 this.get_type = function () { 749 return HEAPU32[(this.ptr + 4) >> 2]; 750 }; 751 this.set_destructor = function (destructor) { 752 HEAPU32[(this.ptr + 8) >> 2] = destructor; 753 }; 754 this.get_destructor = function () { 755 return HEAPU32[(this.ptr + 8) >> 2]; 756 }; 757 this.set_caught = function (caught) { 758 caught = caught ? 1 : 0; 759 HEAP8[(this.ptr + 12) >> 0] = caught; 760 }; 761 this.get_caught = function () { 762 return HEAP8[(this.ptr + 12) >> 0] != 0; 763 }; 764 this.set_rethrown = function (rethrown) { 765 rethrown = rethrown ? 1 : 0; 766 HEAP8[(this.ptr + 13) >> 0] = rethrown; 767 }; 768 this.get_rethrown = function () { 769 return HEAP8[(this.ptr + 13) >> 0] != 0; 770 }; 771 this.init = function (type, destructor) { 772 this.set_adjusted_ptr(0); 773 this.set_type(type); 774 this.set_destructor(destructor); 775 }; 776 this.set_adjusted_ptr = function (adjustedPtr) { 777 HEAPU32[(this.ptr + 16) >> 2] = adjustedPtr; 778 }; 779 this.get_adjusted_ptr = function () { 780 return HEAPU32[(this.ptr + 16) >> 2]; 781 }; 782 this.get_exception_ptr = function () { 783 var isPointer = ___cxa_is_pointer_type(this.get_type()); 784 if (isPointer) { 785 return HEAPU32[this.excPtr >> 2]; 786 } 787 var adjusted = this.get_adjusted_ptr(); 788 if (adjusted !== 0) return adjusted; 789 return this.excPtr; 790 }; 791 } 792 var exceptionLast = 0; 793 var uncaughtExceptionCount = 0; 794 function ___cxa_throw(ptr, type, destructor) { 795 var info = new ExceptionInfo(ptr); 796 info.init(type, destructor); 797 exceptionLast = ptr; 798 uncaughtExceptionCount++; 799 throw exceptionLast; 800 } 801 var dlopenMissingError = 802 "To use dlopen, you need enable dynamic linking, see https://emscripten.org/docs/compiling/Dynamic-Linking.html"; 803 function ___dlsym(handle, symbol) { 804 abort(dlopenMissingError); 805 } 806 var PATH = { 807 isAbs: (path) => path.charAt(0) === "/", 808 splitPath: (filename) => { 809 var splitPathRe = 810 /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; 811 return splitPathRe.exec(filename).slice(1); 812 }, 813 normalizeArray: (parts, allowAboveRoot) => { 814 var up = 0; 815 for (var i = parts.length - 1; i >= 0; i--) { 816 var last = parts[i]; 817 if (last === ".") { 818 parts.splice(i, 1); 819 } else if (last === "..") { 820 parts.splice(i, 1); 821 up++; 822 } else if (up) { 823 parts.splice(i, 1); 824 up--; 825 } 826 } 827 if (allowAboveRoot) { 828 for (; up; up--) { 829 parts.unshift(".."); 830 } 831 } 832 return parts; 833 }, 834 normalize: (path) => { 835 var isAbsolute = PATH.isAbs(path), 836 trailingSlash = path.substr(-1) === "/"; 837 path = PATH.normalizeArray( 838 path.split("/").filter((p) => !!p), 839 !isAbsolute, 840 ).join("/"); 841 if (!path && !isAbsolute) { 842 path = "."; 843 } 844 if (path && trailingSlash) { 845 path += "/"; 846 } 847 return (isAbsolute ? "/" : "") + path; 848 }, 849 dirname: (path) => { 850 var result = PATH.splitPath(path), 851 root = result[0], 852 dir = result[1]; 853 if (!root && !dir) { 854 return "."; 855 } 856 if (dir) { 857 dir = dir.substr(0, dir.length - 1); 858 } 859 return root + dir; 860 }, 861 basename: (path) => { 862 if (path === "/") return "/"; 863 path = PATH.normalize(path); 864 path = path.replace(/\/$/, ""); 865 var lastSlash = path.lastIndexOf("/"); 866 if (lastSlash === -1) return path; 867 return path.substr(lastSlash + 1); 868 }, 869 join: function () { 870 var paths = Array.prototype.slice.call(arguments); 871 return PATH.normalize(paths.join("/")); 872 }, 873 join2: (l, r) => {
874 return PATH.normalize(l + "/" + r); 875 }, 876 }; 877 function initRandomFill() { 878 if ( 879 typeof crypto == "object" && 880 typeof crypto["getRandomValues"] == "function" 881 ) { 882 return (view) => crypto.getRandomValues(view); 883 } else abort("initRandomDevice"); 884 } 885 function randomFill(view) { 886 return (randomFill = initRandomFill())(view); 887 } 888 var PATH_FS = { 889 resolve: function () { 890 var resolvedPath = "", 891 resolvedAbsolute = false; 892 for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { 893 var path = i >= 0 ? arguments[i] : FS.cwd(); 894 if (typeof path != "string") { 895 throw new TypeError("Arguments to path.resolve must be strings"); 896 } else if (!path) { 897 return ""; 898 } 899 resolvedPath = path + "/" + resolvedPath; 900 resolvedAbsolute = PATH.isAbs(path); 901 } 902 resolvedPath = PATH.normalizeArray( 903 resolvedPath.split("/").filter((p) => !!p), 904 !resolvedAbsolute, 905 ).join("/"); 906 return (resolvedAbsolute ? "/" : "") + resolvedPath || "."; 907 }, 908 relative: (from, to) => { 909 from = PATH_FS.resolve(from).substr(1); 910 to = PATH_FS.resolve(to).substr(1); 911 function trim(arr) { 912 var start = 0; 913 for (; start < arr.length; start++) { 914 if (arr[start] !== "") break; 915 } 916 var end = arr.length - 1; 917 for (; end >= 0; end--) { 918 if (arr[end] !== "") break; 919 } 920 if (start > end) return []; 921 return arr.slice(start, end - start + 1); 922 } 923 var fromParts = trim(from.split("/")); 924 var toParts = trim(to.split("/")); 925 var length = Math.min(fromParts.length, toParts.length); 926 var samePartsLength = length; 927 for (var i = 0; i < length; i++) { 928 if (fromParts[i] !== toParts[i]) { 929 samePartsLength = i; 930 break; 931 } 932 } 933 var outputParts = []; 934 for (var i = samePartsLength; i < fromParts.length; i++) { 935 outputParts.push(".."); 936 } 937 outputParts = outputParts.concat(toParts.slice(samePartsLength)); 938 return outputParts.join("/"); 939 }, 940 }; 941 function lengthBytesUTF8(str) { 942 var len = 0; 943 for (var i = 0; i < str.length; ++i) { 944 var c = str.charCodeAt(i); 945 if (c <= 127) { 946 len++; 947 } else if (c <= 2047) { 948 len += 2; 949 } else if (c >= 55296 && c <= 57343) { 950 len += 4; 951 ++i; 952 } else { 953 len += 3; 954 } 955 } 956 return len; 957 } 958 function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) { 959 if (!(maxBytesToWrite > 0)) return 0; 960 var startIdx = outIdx; 961 var endIdx = outIdx + maxBytesToWrite - 1; 962 for (var i = 0; i < str.length; ++i) { 963 var u = str.charCodeAt(i); 964 if (u >= 55296 && u <= 57343) { 965 var u1 = str.charCodeAt(++i); 966 u = (65536 + ((u & 1023) << 10)) | (u1 & 1023); 967 } 968 if (u <= 127) { 969 if (outIdx >= endIdx) break; 970 heap[outIdx++] = u; 971 } else if (u <= 2047) { 972 if (outIdx + 1 >= endIdx) break; 973 heap[outIdx++] = 192 | (u >> 6); 974 heap[outIdx++] = 128 | (u & 63); 975 } else if (u <= 65535) { 976 if (outIdx + 2 >= endIdx) break; 977 heap[outIdx++] = 224 | (u >> 12); 978 heap[outIdx++] = 128 | ((u >> 6) & 63); 979 heap[outIdx++] = 128 | (u & 63); 980 } else { 981 if (outIdx + 3 >= endIdx) break; 982 heap[outIdx++] = 240 | (u >> 18); 983 heap[outIdx++] = 128 | ((u >> 12) & 63); 984 heap[outIdx++] = 128 | ((u >> 6) & 63); 985 heap[outIdx++] = 128 | (u & 63); 986 } 987 } 988 heap[outIdx] = 0; 989 return outIdx - startIdx; 990 } 991 function intArrayFromString(stringy, dontAddNull, length) { 992 var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1; 993 var u8array = new Array(len); 994 var numBytesWritten = stringToUTF8Array(
995 stringy, 996 u8array, 997 0, 998 u8array.length, 999 ); 1000 if (dontAddNull) u8array.length = numBytesWritten; 1001 return u8array; 1002 } 1003 var TTY = { 1004 ttys: [], 1005 init: function () {}, 1006 shutdown: function () {}, 1007 register: function (dev, ops) { 1008 TTY.ttys[dev] = { input: [], output: [], ops: ops }; 1009 FS.registerDevice(dev, TTY.stream_ops); 1010 }, 1011 stream_ops: { 1012 open: function (stream) { 1013 var tty = TTY.ttys[stream.node.rdev]; 1014 if (!tty) { 1015 throw new FS.ErrnoError(43); 1016 } 1017 stream.tty = tty; 1018 stream.seekable = false; 1019 }, 1020 close: function (stream) { 1021 stream.tty.ops.fsync(stream.tty); 1022 }, 1023 fsync: function (stream) { 1024 stream.tty.ops.fsync(stream.tty); 1025 }, 1026 read: function (stream, buffer, offset, length, pos) { 1027 if (!stream.tty || !stream.tty.ops.get_char) { 1028 throw new FS.ErrnoError(60); 1029 } 1030 var bytesRead = 0; 1031 for (var i = 0; i < length; i++) { 1032 var result; 1033 try { 1034 result = stream.tty.ops.get_char(stream.tty); 1035 } catch (e) { 1036 throw new FS.ErrnoError(29); 1037 } 1038 if (result === undefined && bytesRead === 0) { 1039 throw new FS.ErrnoError(6); 1040 } 1041 if (result === null || result === undefined) break; 1042 bytesRead++; 1043 buffer[offset + i] = result; 1044 } 1045 if (bytesRead) { 1046 stream.node.timestamp = Date.now(); 1047 } 1048 return bytesRead; 1049 }, 1050 write: function (stream, buffer, offset, length, pos) { 1051 if (!stream.tty || !stream.tty.ops.put_char) { 1052 throw new FS.ErrnoError(60); 1053 } 1054 try { 1055 for (var i = 0; i < length; i++) { 1056 stream.tty.ops.put_char(stream.tty, buffer[offset + i]); 1057 } 1058 } catch (e) { 1059 throw new FS.ErrnoError(29); 1060 } 1061 if (length) { 1062 stream.node.timestamp = Date.now(); 1063 } 1064 return i; 1065 }, 1066 }, 1067 default_tty_ops: { 1068 get_char: function (tty) { 1069 if (!tty.input.length) { 1070 var result = null; 1071 if ( 1072 typeof window != "undefined" && 1073 typeof window.prompt == "function" 1074 ) { 1075 result = window.prompt("Input: "); 1076 if (result !== null) { 1077 result += "\n"; 1078 } 1079 } else if (typeof readline == "function") { 1080 result = readline(); 1081 if (result !== null) { 1082 result += "\n"; 1083 } 1084 } 1085 if (!result) { 1086 return null; 1087 } 1088 tty.input = intArrayFromString(result, true); 1089 } 1090 return tty.input.shift(); 1091 }, 1092 put_char: function (tty, val) { 1093 if (val === null || val === 10) { 1094 out(UTF8ArrayToString(tty.output, 0)); 1095 tty.output = []; 1096 } else { 1097 if (val != 0) tty.output.push(val); 1098 } 1099 }, 1100 fsync: function (tty) { 1101 if (tty.output && tty.output.length > 0) { 1102 out(UTF8ArrayToString(tty.output, 0)); 1103 tty.output = []; 1104 } 1105 }, 1106 }, 1107 default_tty1_ops: { 1108 put_char: function (tty, val) { 1109 if (val === null || val === 10) { 1110 err(UTF8ArrayToString(tty.output, 0)); 1111 tty.output = []; 1112 } else { 1113 if (val != 0) tty.output.push(val); 1114 } 1115 }, 1116 fsync: function (tty) { 1117 if (tty.output && tty.output.length > 0) { 1118 err(UTF8ArrayToString(tty.output, 0)); 1119 tty.output = []; 1120 } 1121 }, 1122 }, 1123 }; 1124 function zeroMemory(address, size) { 1125 HEAPU8.fill(0, address, address + size); 1126 return address; 1127 } 1128 function alignMemory(size, alignment) { 1129 return Math.ceil(size / alignment) * alignment; 1130 } 1131 function mmapAlloc(size) { 1132 size = alignMemory(size, 65536); 1133 var ptr = _emscripten_builtin_memalign(65536, size); 1134 if (!ptr) return 0; 1135 return zeroMemory(ptr, size); 1136 } 1137 var MEMFS = { 1138 ops_table: null, 1139 mount: function (mount) { 1140 return MEMFS.createNode(null, "/", 16384 | 511, 0); 1141 }, 1142 createNode: function (parent, name, mode, dev) { 1143 if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { 1144 throw new FS.ErrnoError(63); 1145 } 1146 if (!MEMFS.ops_table) { 1147 MEMFS.ops_table = { 1148 dir: { 1149 node: { 1150 getattr: MEMFS.node_ops.getattr, 1151 setattr: MEMFS.node_ops.setattr, 1152 lookup: MEMFS.node_ops.lookup, 1153 mknod: MEMFS.node_ops.mknod, 1154 rename: MEMFS.node_ops.rename, 1155 unlink: MEMFS.node_ops.unlink, 1156 rmdir: MEMFS.node_ops.rmdir, 1157 readdir: MEMFS.node_ops.readdir, 1158 symlink: MEMFS.node_ops.symlink, 1159 }, 1160 stream: { llseek: MEMFS.stream_ops.llseek }, 1161 }, 1162 file: { 1163 node: { 1164 getattr: MEMFS.node_ops.getattr, 1165 setattr: MEMFS.node_ops.setattr, 1166 }, 1167 stream: { 1168 llseek: MEMFS.stream_ops.llseek, 1169 read: MEMFS.stream_ops.read, 1170 write: MEMFS.stream_ops.write, 1171 allocate: MEMFS.stream_ops.allocate, 1172 mmap: MEMFS.stream_ops.mmap, 1173 msync: MEMFS.stream_ops.msync, 1174 }, 1175 }, 1176 link: { 1177 node: { 1178 getattr: MEMFS.node_ops.getattr, 1179 setattr: MEMFS.node_ops.setattr, 1180 readlink: MEMFS.node_ops.readlink, 1181 }, 1182 stream: {}, 1183 }, 1184 chrdev: { 1185 node: { 1186 getattr: MEMFS.node_ops.getattr, 1187 setattr: MEMFS.node_ops.setattr, 1188 }, 1189 stream: FS.chrdev_stream_ops, 1190 }, 1191 }; 1192 } 1193 var node = FS.createNode(parent, name, mode, dev); 1194 if (FS.isDir(node.mode)) { 1195 node.node_ops = MEMFS.ops_table.dir.node; 1196 node.stream_ops = MEMFS.ops_table.dir.stream; 1197 node.contents = {}; 1198 } else if (FS.isFile(node.mode)) {
vendor: 9,061 bytes, lines 1199-1451
1199 node.node_ops = MEMFS.ops_table.file.node; 1200 node.stream_ops = MEMFS.ops_table.file.stream; 1201 node.usedBytes = 0; 1202 node.contents = null; 1203 } else if (FS.isLink(node.mode)) { 1204 node.node_ops = MEMFS.ops_table.link.node; 1205 node.stream_ops = MEMFS.ops_table.link.stream; 1206 } else if (FS.isChrdev(node.mode)) { 1207 node.node_ops = MEMFS.ops_table.chrdev.node; 1208 node.stream_ops = MEMFS.ops_table.chrdev.stream; 1209 } 1210 node.timestamp = Date.now(); 1211 if (parent) { 1212 parent.contents[name] = node; 1213 parent.timestamp = node.timestamp; 1214 } 1215 return node; 1216 }, 1217 getFileDataAsTypedArray: function (node) { 1218 if (!node.contents) return new Uint8Array(0); 1219 if (node.contents.subarray) 1220 return node.contents.subarray(0, node.usedBytes); 1221 return new Uint8Array(node.contents); 1222 }, 1223 expandFileStorage: function (node, newCapacity) { 1224 var prevCapacity = node.contents ? node.contents.length : 0; 1225 if (prevCapacity >= newCapacity) return; 1226 var CAPACITY_DOUBLING_MAX = 1024 * 1024; 1227 newCapacity = Math.max( 1228 newCapacity, 1229 (prevCapacity * 1230 (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125)) >>> 1231 0, 1232 ); 1233 if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); 1234 var oldContents = node.contents; 1235 node.contents = new Uint8Array(newCapacity); 1236 if (node.usedBytes > 0) 1237 node.contents.set(oldContents.subarray(0, node.usedBytes), 0); 1238 }, 1239 resizeFileStorage: function (node, newSize) { 1240 if (node.usedBytes == newSize) return; 1241 if (newSize == 0) { 1242 node.contents = null; 1243 node.usedBytes = 0; 1244 } else { 1245 var oldContents = node.contents; 1246 node.contents = new Uint8Array(newSize); 1247 if (oldContents) { 1248 node.contents.set( 1249 oldContents.subarray(0, Math.min(newSize, node.usedBytes)), 1250 ); 1251 } 1252 node.usedBytes = newSize; 1253 } 1254 }, 1255 node_ops: { 1256 getattr: function (node) { 1257 var attr = {}; 1258 attr.dev = FS.isChrdev(node.mode) ? node.id : 1; 1259 attr.ino = node.id; 1260 attr.mode = node.mode; 1261 attr.nlink = 1; 1262 attr.uid = 0; 1263 attr.gid = 0; 1264 attr.rdev = node.rdev; 1265 if (FS.isDir(node.mode)) { 1266 attr.size = 4096; 1267 } else if (FS.isFile(node.mode)) { 1268 attr.size = node.usedBytes; 1269 } else if (FS.isLink(node.mode)) { 1270 attr.size = node.link.length; 1271 } else { 1272 attr.size = 0; 1273 } 1274 attr.atime = new Date(node.timestamp); 1275 attr.mtime = new Date(node.timestamp); 1276 attr.ctime = new Date(node.timestamp); 1277 attr.blksize = 4096; 1278 attr.blocks = Math.ceil(attr.size / attr.blksize); 1279 return attr; 1280 }, 1281 setattr: function (node, attr) { 1282 if (attr.mode !== undefined) { 1283 node.mode = attr.mode; 1284 } 1285 if (attr.timestamp !== undefined) { 1286 node.timestamp = attr.timestamp; 1287 } 1288 if (attr.size !== undefined) { 1289 MEMFS.resizeFileStorage(node, attr.size); 1290 } 1291 }, 1292 lookup: function (parent, name) { 1293 throw FS.genericErrors[44]; 1294 }, 1295 mknod: function (parent, name, mode, dev) { 1296 return MEMFS.createNode(parent, name, mode, dev); 1297 }, 1298 rename: function (old_node, new_dir, new_name) { 1299 if (FS.isDir(old_node.mode)) { 1300 var new_node; 1301 try { 1302 new_node = FS.lookupNode(new_dir, new_name); 1303 } catch (e) {} 1304 if (new_node) { 1305 for (var i in new_node.contents) { 1306 throw new FS.ErrnoError(55); 1307 } 1308 } 1309 } 1310 delete old_node.parent.contents[old_node.name]; 1311 old_node.parent.timestamp = Date.now(); 1312 old_node.name = new_name; 1313 new_dir.contents[new_name] = old_node; 1314 new_dir.timestamp = old_node.parent.timestamp; 1315 old_node.parent = new_dir; 1316 }, 1317 unlink: function (parent, name) { 1318 delete parent.contents[name]; 1319 parent.timestamp = Date.now(); 1320 }, 1321 rmdir: function (parent, name) { 1322 var node = FS.lookupNode(parent, name); 1323 for (var i in node.contents) { 1324 throw new FS.ErrnoError(55); 1325 } 1326 delete parent.contents[name]; 1327 parent.timestamp = Date.now(); 1328 }, 1329 readdir: function (node) { 1330 var entries = [".", ".."]; 1331 for (var key in node.contents) { 1332 if (!node.contents.hasOwnProperty(key)) { 1333 continue; 1334 } 1335 entries.push(key); 1336 } 1337 return entries; 1338 }, 1339 symlink: function (parent, newname, oldpath) { 1340 var node = MEMFS.createNode(parent, newname, 511 | 40960, 0); 1341 node.link = oldpath; 1342 return node; 1343 }, 1344 readlink: function (node) { 1345 if (!FS.isLink(node.mode)) { 1346 throw new FS.ErrnoError(28); 1347 } 1348 return node.link; 1349 }, 1350 }, 1351 stream_ops: { 1352 read: function (stream, buffer, offset, length, position) { 1353 var contents = stream.node.contents; 1354 if (position >= stream.node.usedBytes) return 0; 1355 var size = Math.min(stream.node.usedBytes - position, length); 1356 if (size > 8 && contents.subarray) { 1357 buffer.set(contents.subarray(position, position + size), offset); 1358 } else { 1359 for (var i = 0; i < size; i++) 1360 buffer[offset + i] = contents[position + i]; 1361 } 1362 return size; 1363 }, 1364 write: function (stream, buffer, offset, length, position, canOwn) { 1365 if (buffer.buffer === HEAP8.buffer) { 1366 canOwn = false; 1367 } 1368 if (!length) return 0; 1369 var node = stream.node; 1370 node.timestamp = Date.now(); 1371 if (buffer.subarray && (!node.contents || node.contents.subarray)) { 1372 if (canOwn) { 1373 node.contents = buffer.subarray(offset, offset + length); 1374 node.usedBytes = length; 1375 return length; 1376 } else if (node.usedBytes === 0 && position === 0) { 1377 node.contents = buffer.slice(offset, offset + length); 1378 node.usedBytes = length; 1379 return length; 1380 } else if (position + length <= node.usedBytes) { 1381 node.contents.set( 1382 buffer.subarray(offset, offset + length), 1383 position, 1384 ); 1385 return length; 1386 } 1387 } 1388 MEMFS.expandFileStorage(node, position + length); 1389 if (node.contents.subarray && buffer.subarray) { 1390 node.contents.set( 1391 buffer.subarray(offset, offset + length), 1392 position, 1393 ); 1394 } else { 1395 for (var i = 0; i < length; i++) { 1396 node.contents[position + i] = buffer[offset + i]; 1397 } 1398 } 1399 node.usedBytes = Math.max(node.usedBytes, position + length); 1400 return length; 1401 }, 1402 llseek: function (stream, offset, whence) { 1403 var position = offset; 1404 if (whence === 1) { 1405 position += stream.position; 1406 } else if (whence === 2) { 1407 if (FS.isFile(stream.node.mode)) { 1408 position += stream.node.usedBytes; 1409 } 1410 } 1411 if (position < 0) { 1412 throw new FS.ErrnoError(28); 1413 } 1414 return position; 1415 }, 1416 allocate: function (stream, offset, length) { 1417 MEMFS.expandFileStorage(stream.node, offset + length); 1418 stream.node.usedBytes = Math.max( 1419 stream.node.usedBytes, 1420 offset + length, 1421 ); 1422 }, 1423 mmap: function (stream, length, position, prot, flags) { 1424 if (!FS.isFile(stream.node.mode)) { 1425 throw new FS.ErrnoError(43); 1426 } 1427 var ptr; 1428 var allocated; 1429 var contents = stream.node.contents; 1430 if (!(flags & 2) && contents.buffer === HEAP8.buffer) { 1431 allocated = false; 1432 ptr = contents.byteOffset; 1433 } else { 1434 if (position > 0 || position + length < contents.length) { 1435 if (contents.subarray) { 1436 contents = contents.subarray(position, position + length); 1437 } else { 1438 contents = Array.prototype.slice.call( 1439 contents, 1440 position, 1441 position + length, 1442 ); 1443 } 1444 } 1445 allocated = true; 1446 ptr = mmapAlloc(length); 1447 if (!ptr) { 1448 throw new FS.ErrnoError(48); 1449 } 1450 HEAP8.set(contents, ptr); 1451 }
1452 return { ptr: ptr, allocated: allocated }; 1453 }, 1454 msync: function (stream, buffer, offset, length, mmapFlags) { 1455 MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); 1456 return 0; 1457 }, 1458 }, 1459 }; 1460 function asyncLoad(url, onload, onerror, noRunDep) { 1461 var dep = !noRunDep ? getUniqueRunDependency(`al ${url}`) : ""; 1462 readAsync( 1463 url, 1464 (arrayBuffer) => { 1465 assert( 1466 arrayBuffer, 1467 `Loading data file "${url}" failed (no arrayBuffer).`, 1468 ); 1469 onload(new Uint8Array(arrayBuffer)); 1470 if (dep) removeRunDependency(dep); 1471 }, 1472 (event) => { 1473 if (onerror) { 1474 onerror(); 1475 } else { 1476 throw `Loading data file "${url}" failed.`; 1477 } 1478 }, 1479 ); 1480 if (dep) addRunDependency(dep); 1481 } 1482 var preloadPlugins = Module["preloadPlugins"] || []; 1483 function FS_handledByPreloadPlugin(byteArray, fullname, finish, onerror) { 1484 if (typeof Browser != "undefined") Browser.init(); 1485 var handled = false; 1486 preloadPlugins.forEach(function (plugin) { 1487 if (handled) return; 1488 if (plugin["canHandle"](fullname)) { 1489 plugin["handle"](byteArray, fullname, finish, onerror); 1490 handled = true; 1491 } 1492 }); 1493 return handled; 1494 } 1495 function FS_createPreloadedFile( 1496 parent, 1497 name, 1498 url, 1499 canRead, 1500 canWrite, 1501 onload, 1502 onerror, 1503 dontCreateFile, 1504 canOwn, 1505 preFinish, 1506 ) { 1507 var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; 1508 var dep = getUniqueRunDependency(`cp ${fullname}`); 1509 function processData(byteArray) { 1510 function finish(byteArray) { 1511 if (preFinish) preFinish(); 1512 if (!dontCreateFile) { 1513 FS.createDataFile( 1514 parent, 1515 name, 1516 byteArray, 1517 canRead, 1518 canWrite, 1519 canOwn, 1520 ); 1521 } 1522 if (onload) onload(); 1523 removeRunDependency(dep); 1524 } 1525 if ( 1526 FS_handledByPreloadPlugin(byteArray, fullname, finish, () => { 1527 if (onerror) onerror(); 1528 removeRunDependency(dep); 1529 }) 1530 ) { 1531 return; 1532 } 1533 finish(byteArray); 1534 } 1535 addRunDependency(dep); 1536 if (typeof url == "string") { 1537 asyncLoad(url, (byteArray) => processData(byteArray), onerror); 1538 } else { 1539 processData(url); 1540 } 1541 } 1542 function FS_modeStringToFlags(str) { 1543 var flagModes = { 1544 r: 0, 1545 "r+": 2, 1546 w: 512 | 64 | 1, 1547 "w+": 512 | 64 | 2, 1548 a: 1024 | 64 | 1, 1549 "a+": 1024 | 64 | 2, 1550 }; 1551 var flags = flagModes[str]; 1552 if (typeof flags == "undefined") { 1553 throw new Error(`Unknown file open mode: ${str}`); 1554 } 1555 return flags; 1556 } 1557 function FS_getMode(canRead, canWrite) { 1558 var mode = 0; 1559 if (canRead) mode |= 292 | 73; 1560 if (canWrite) mode |= 146; 1561 return mode; 1562 } 1563 var WORKERFS = { 1564 DIR_MODE: 16895, 1565 FILE_MODE: 33279, 1566 reader: null, 1567 mount: function (mount) { 1568 assert(ENVIRONMENT_IS_WORKER); 1569 if (!WORKERFS.reader) WORKERFS.reader = new FileReaderSync(); 1570 var root = WORKERFS.createNode(null, "/", WORKERFS.DIR_MODE, 0); 1571 var createdParents = {}; 1572 function ensureParent(path) { 1573 var parts = path.split("/"); 1574 var parent = root; 1575 for (var i = 0; i < parts.length - 1; i++) { 1576 var curr = parts.slice(0, i + 1).join("/"); 1577 if (!createdParents[curr]) { 1578 createdParents[curr] = WORKERFS.createNode( 1579 parent, 1580 parts[i], 1581 WORKERFS.DIR_MODE, 1582 0, 1583 ); 1584 } 1585 parent = createdParents[curr]; 1586 } 1587 return parent; 1588 } 1589 function base(path) { 1590 var parts = path.split("/"); 1591 return parts[parts.length - 1]; 1592 } 1593 Array.prototype.forEach.call( 1594 mount.opts["files"] || [], 1595 function (file) { 1596 WORKERFS.createNode( 1597 ensureParent(file.name), 1598 base(file.name), 1599 WORKERFS.FILE_MODE, 1600 0, 1601 file, 1602 file.lastModifiedDate, 1603 ); 1604 }, 1605 );
1606 (mount.opts["blobs"] || []).forEach(function (obj) { 1607 WORKERFS.createNode( 1608 ensureParent(obj["name"]), 1609 base(obj["name"]), 1610 WORKERFS.FILE_MODE, 1611 0, 1612 obj["data"], 1613 ); 1614 }); 1615 (mount.opts["packages"] || []).forEach(function (pack) { 1616 pack["metadata"].files.forEach(function (file) { 1617 var name = file.filename.substr(1); 1618 WORKERFS.createNode( 1619 ensureParent(name), 1620 base(name), 1621 WORKERFS.FILE_MODE, 1622 0, 1623 pack["blob"].slice(file.start, file.end), 1624 ); 1625 }); 1626 }); 1627 return root; 1628 }, 1629 createNode: function (parent, name, mode, dev, contents, mtime) { 1630 var node = FS.createNode(parent, name, mode); 1631 node.mode = mode; 1632 node.node_ops = WORKERFS.node_ops; 1633 node.stream_ops = WORKERFS.stream_ops; 1634 node.timestamp = (mtime || new Date()).getTime(); 1635 assert(WORKERFS.FILE_MODE !== WORKERFS.DIR_MODE); 1636 if (mode === WORKERFS.FILE_MODE) { 1637 node.size = contents.size; 1638 node.contents = contents; 1639 } else { 1640 node.size = 4096; 1641 node.contents = {}; 1642 } 1643 if (parent) { 1644 parent.contents[name] = node; 1645 } 1646 return node; 1647 }, 1648 node_ops: { 1649 getattr: function (node) { 1650 return { 1651 dev: 1, 1652 ino: node.id, 1653 mode: node.mode, 1654 nlink: 1, 1655 uid: 0, 1656 gid: 0, 1657 rdev: undefined, 1658 size: node.size, 1659 atime: new Date(node.timestamp), 1660 mtime: new Date(node.timestamp), 1661 ctime: new Date(node.timestamp), 1662 blksize: 4096, 1663 blocks: Math.ceil(node.size / 4096), 1664 }; 1665 }, 1666 setattr: function (node, attr) { 1667 if (attr.mode !== undefined) { 1668 node.mode = attr.mode; 1669 } 1670 if (attr.timestamp !== undefined) { 1671 node.timestamp = attr.timestamp; 1672 } 1673 }, 1674 lookup: function (parent, name) { 1675 throw new FS.ErrnoError(44); 1676 }, 1677 mknod: function (parent, name, mode, dev) { 1678 throw new FS.ErrnoError(63); 1679 }, 1680 rename: function (oldNode, newDir, newName) { 1681 throw new FS.ErrnoError(63); 1682 }, 1683 unlink: function (parent, name) { 1684 throw new FS.ErrnoError(63); 1685 }, 1686 rmdir: function (parent, name) { 1687 throw new FS.ErrnoError(63); 1688 }, 1689 readdir: function (node) { 1690 var entries = [".", ".."]; 1691 for (var key in node.contents) { 1692 if (!node.contents.hasOwnProperty(key)) { 1693 continue; 1694 } 1695 entries.push(key); 1696 } 1697 return entries; 1698 }, 1699 symlink: function (parent, newName, oldPath) { 1700 throw new FS.ErrnoError(63); 1701 }, 1702 }, 1703 stream_ops: { 1704 read: function (stream, buffer, offset, length, position) { 1705 if (position >= stream.node.size) return 0; 1706 var chunk = stream.node.contents.slice(position, position + length); 1707 var ab = WORKERFS.reader.readAsArrayBuffer(chunk); 1708 buffer.set(new Uint8Array(ab), offset); 1709 return chunk.size; 1710 }, 1711 write: function (stream, buffer, offset, length, position) { 1712 throw new FS.ErrnoError(29); 1713 }, 1714 llseek: function (stream, offset, whence) { 1715 var position = offset; 1716 if (whence === 1) { 1717 position += stream.position; 1718 } else if (whence === 2) { 1719 if (FS.isFile(stream.node.mode)) { 1720 position += stream.node.size; 1721 } 1722 } 1723 if (position < 0) { 1724 throw new FS.ErrnoError(28); 1725 } 1726 return position; 1727 }, 1728 }, 1729 }; 1730 var FS = { 1731 root: null, 1732 mounts: [], 1733 devices: {}, 1734 streams: [], 1735 nextInode: 1, 1736 nameTable: null, 1737 currentPath: "/", 1738 initialized: false, 1739 ignorePermissions: true, 1740 ErrnoError: null, 1741 genericErrors: {}, 1742 filesystems: null, 1743 syncFSRequests: 0, 1744 lookupPath: (path, opts = {}) => { 1745 path = PATH_FS.resolve(path); 1746 if (!path) return { path: "", node: null }; 1747 var defaults = { follow_mount: true, recurse_count: 0 }; 1748 opts = Object.assign(defaults, opts); 1749 if (opts.recurse_count > 8) { 1750 throw new FS.ErrnoError(32); 1751 } 1752 var parts = path.split("/").filter((p) => !!p); 1753 var current = FS.root; 1754 var current_path = "/"; 1755 for (var i = 0; i < parts.length; i++) { 1756 var islast = i === parts.length - 1; 1757 if (islast && opts.parent) { 1758 break; 1759 } 1760 current = FS.lookupNode(current, parts[i]); 1761 current_path = PATH.join2(current_path, parts[i]); 1762 if (FS.isMountpoint(current)) { 1763 if (!islast || (islast && opts.follow_mount)) { 1764 current = current.mounted.root; 1765 } 1766 } 1767 if (!islast || opts.follow) { 1768 var count = 0; 1769 while (FS.isLink(current.mode)) { 1770 var link = FS.readlink(current_path); 1771 current_path = PATH_FS.resolve(PATH.dirname(current_path), link); 1772 var lookup = FS.lookupPath(current_path, { 1773 recurse_count: opts.recurse_count + 1, 1774 }); 1775 current = lookup.node; 1776 if (count++ > 40) { 1777 throw new FS.ErrnoError(32); 1778 } 1779 } 1780 } 1781 } 1782 return { path: current_path, node: current }; 1783 }, 1784 getPath: (node) => { 1785 var path; 1786 while (true) { 1787 if (FS.isRoot(node)) {
1788 var mount = node.mount.mountpoint; 1789 if (!path) return mount; 1790 return mount[mount.length - 1] !== "/" 1791 ? `${mount}/${path}` 1792 : mount + path; 1793 } 1794 path = path ? `${node.name}/${path}` : node.name; 1795 node = node.parent; 1796 } 1797 }, 1798 hashName: (parentid, name) => { 1799 var hash = 0; 1800 for (var i = 0; i < name.length; i++) { 1801 hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0; 1802 } 1803 return ((parentid + hash) >>> 0) % FS.nameTable.length; 1804 }, 1805 hashAddNode: (node) => { 1806 var hash = FS.hashName(node.parent.id, node.name); 1807 node.name_next = FS.nameTable[hash]; 1808 FS.nameTable[hash] = node; 1809 }, 1810 hashRemoveNode: (node) => { 1811 var hash = FS.hashName(node.parent.id, node.name); 1812 if (FS.nameTable[hash] === node) { 1813 FS.nameTable[hash] = node.name_next; 1814 } else { 1815 var current = FS.nameTable[hash]; 1816 while (current) { 1817 if (current.name_next === node) { 1818 current.name_next = node.name_next; 1819 break; 1820 } 1821 current = current.name_next; 1822 } 1823 } 1824 }, 1825 lookupNode: (parent, name) => { 1826 var errCode = FS.mayLookup(parent); 1827 if (errCode) { 1828 throw new FS.ErrnoError(errCode, parent); 1829 } 1830 var hash = FS.hashName(parent.id, name); 1831 for (var node = FS.nameTable[hash]; node; node = node.name_next) { 1832 var nodeName = node.name; 1833 if (node.parent.id === parent.id && nodeName === name) { 1834 return node; 1835 } 1836 } 1837 return FS.lookup(parent, name); 1838 }, 1839 createNode: (parent, name, mode, rdev) => { 1840 var node = new FS.FSNode(parent, name, mode, rdev); 1841 FS.hashAddNode(node); 1842 return node; 1843 }, 1844 destroyNode: (node) => { 1845 FS.hashRemoveNode(node); 1846 }, 1847 isRoot: (node) => { 1848 return node === node.parent; 1849 }, 1850 isMountpoint: (node) => { 1851 return !!node.mounted; 1852 }, 1853 isFile: (mode) => { 1854 return (mode & 61440) === 32768; 1855 }, 1856 isDir: (mode) => { 1857 return (mode & 61440) === 16384; 1858 }, 1859 isLink: (mode) => { 1860 return (mode & 61440) === 40960; 1861 }, 1862 isChrdev: (mode) => { 1863 return (mode & 61440) === 8192; 1864 }, 1865 isBlkdev: (mode) => { 1866 return (mode & 61440) === 24576; 1867 }, 1868 isFIFO: (mode) => { 1869 return (mode & 61440) === 4096; 1870 }, 1871 isSocket: (mode) => { 1872 return (mode & 49152) === 49152; 1873 }, 1874 flagsToPermissionString: (flag) => { 1875 var perms = ["r", "w", "rw"][flag & 3]; 1876 if (flag & 512) { 1877 perms += "w"; 1878 } 1879 return perms; 1880 }, 1881 nodePermissions: (node, perms) => { 1882 if (FS.ignorePermissions) { 1883 return 0; 1884 } 1885 if (perms.includes("r") && !(node.mode & 292)) { 1886 return 2; 1887 } else if (perms.includes("w") && !(node.mode & 146)) { 1888 return 2; 1889 } else if (perms.includes("x") && !(node.mode & 73)) { 1890 return 2; 1891 } 1892 return 0; 1893 }, 1894 mayLookup: (dir) => { 1895 var errCode = FS.nodePermissions(dir, "x"); 1896 if (errCode) return errCode; 1897 if (!dir.node_ops.lookup) return 2; 1898 return 0; 1899 }, 1900 mayCreate: (dir, name) => { 1901 try { 1902 var node = FS.lookupNode(dir, name); 1903 return 20; 1904 } catch (e) {} 1905 return FS.nodePermissions(dir, "wx"); 1906 }, 1907 mayDelete: (dir, name, isdir) => { 1908 var node; 1909 try { 1910 node = FS.lookupNode(dir, name); 1911 } catch (e) { 1912 return e.errno; 1913 } 1914 var errCode = FS.nodePermissions(dir, "wx"); 1915 if (errCode) { 1916 return errCode; 1917 } 1918 if (isdir) { 1919 if (!FS.isDir(node.mode)) { 1920 return 54; 1921 } 1922 if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) { 1923 return 10; 1924 } 1925 } else { 1926 if (FS.isDir(node.mode)) {
1927 return 31; 1928 } 1929 } 1930 return 0; 1931 }, 1932 mayOpen: (node, flags) => { 1933 if (!node) { 1934 return 44; 1935 } 1936 if (FS.isLink(node.mode)) { 1937 return 32; 1938 } else if (FS.isDir(node.mode)) { 1939 if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) { 1940 return 31; 1941 } 1942 } 1943 return FS.nodePermissions(node, FS.flagsToPermissionString(flags)); 1944 }, 1945 MAX_OPEN_FDS: 4096, 1946 nextfd: () => { 1947 for (var fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) { 1948 if (!FS.streams[fd]) { 1949 return fd; 1950 } 1951 } 1952 throw new FS.ErrnoError(33); 1953 }, 1954 getStream: (fd) => FS.streams[fd], 1955 createStream: (stream, fd = -1) => { 1956 if (!FS.FSStream) { 1957 FS.FSStream = function () { 1958 this.shared = {}; 1959 }; 1960 FS.FSStream.prototype = {}; 1961 Object.defineProperties(FS.FSStream.prototype, { 1962 object: { 1963 get: function () { 1964 return this.node; 1965 }, 1966 set: function (val) { 1967 this.node = val; 1968 }, 1969 }, 1970 isRead: { 1971 get: function () { 1972 return (this.flags & 2097155) !== 1; 1973 }, 1974 }, 1975 isWrite: { 1976 get: function () { 1977 return (this.flags & 2097155) !== 0; 1978 }, 1979 }, 1980 isAppend: { 1981 get: function () { 1982 return this.flags & 1024; 1983 }, 1984 }, 1985 flags: { 1986 get: function () { 1987 return this.shared.flags; 1988 }, 1989 set: function (val) { 1990 this.shared.flags = val; 1991 }, 1992 }, 1993 position: { 1994 get: function () { 1995 return this.shared.position; 1996 }, 1997 set: function (val) { 1998 this.shared.position = val; 1999 }, 2000 }, 2001 }); 2002 } 2003 stream = Object.assign(new FS.FSStream(), stream); 2004 if (fd == -1) { 2005 fd = FS.nextfd(); 2006 } 2007 stream.fd = fd; 2008 FS.streams[fd] = stream; 2009 return stream; 2010 }, 2011 closeStream: (fd) => { 2012 FS.streams[fd] = null; 2013 }, 2014 chrdev_stream_ops: { 2015 open: (stream) => { 2016 var device = FS.getDevice(stream.node.rdev); 2017 stream.stream_ops = device.stream_ops; 2018 if (stream.stream_ops.open) { 2019 stream.stream_ops.open(stream); 2020 } 2021 }, 2022 llseek: () => { 2023 throw new FS.ErrnoError(70); 2024 }, 2025 }, 2026 major: (dev) => dev >> 8, 2027 minor: (dev) => dev & 255, 2028 makedev: (ma, mi) => (ma << 8) | mi, 2029 registerDevice: (dev, ops) => { 2030 FS.devices[dev] = { stream_ops: ops }; 2031 }, 2032 getDevice: (dev) => FS.devices[dev], 2033 getMounts: (mount) => { 2034 var mounts = []; 2035 var check = [mount]; 2036 while (check.length) { 2037 var m = check.pop(); 2038 mounts.push(m); 2039 check.push.apply(check, m.mounts); 2040 } 2041 return mounts; 2042 }, 2043 syncfs: (populate, callback) => { 2044 if (typeof populate == "function") { 2045 callback = populate; 2046 populate = false; 2047 } 2048 FS.syncFSRequests++; 2049 if (FS.syncFSRequests > 1) { 2050 err( 2051 `warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`, 2052 ); 2053 } 2054 var mounts = FS.getMounts(FS.root.mount); 2055 var completed = 0; 2056 function doCallback(errCode) { 2057 FS.syncFSRequests--; 2058 return callback(errCode); 2059 } 2060 function done(errCode) { 2061 if (errCode) { 2062 if (!done.errored) { 2063 done.errored = true; 2064 return doCallback(errCode); 2065 } 2066 return; 2067 } 2068 if (++completed >= mounts.length) { 2069 doCallback(null); 2070 } 2071 }
2072 mounts.forEach((mount) => { 2073 if (!mount.type.syncfs) { 2074 return done(null); 2075 } 2076 mount.type.syncfs(mount, populate, done); 2077 }); 2078 }, 2079 mount: (type, opts, mountpoint) => { 2080 var root = mountpoint === "/"; 2081 var pseudo = !mountpoint; 2082 var node; 2083 if (root && FS.root) { 2084 throw new FS.ErrnoError(10); 2085 } else if (!root && !pseudo) { 2086 var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); 2087 mountpoint = lookup.path; 2088 node = lookup.node; 2089 if (FS.isMountpoint(node)) { 2090 throw new FS.ErrnoError(10); 2091 } 2092 if (!FS.isDir(node.mode)) { 2093 throw new FS.ErrnoError(54); 2094 } 2095 } 2096 var mount = { 2097 type: type, 2098 opts: opts, 2099 mountpoint: mountpoint, 2100 mounts: [], 2101 }; 2102 var mountRoot = type.mount(mount); 2103 mountRoot.mount = mount; 2104 mount.root = mountRoot; 2105 if (root) { 2106 FS.root = mountRoot; 2107 } else if (node) { 2108 node.mounted = mount; 2109 if (node.mount) { 2110 node.mount.mounts.push(mount); 2111 } 2112 } 2113 return mountRoot; 2114 }, 2115 unmount: (mountpoint) => { 2116 var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); 2117 if (!FS.isMountpoint(lookup.node)) { 2118 throw new FS.ErrnoError(28); 2119 } 2120 var node = lookup.node;
2121 var mount = node.mounted; 2122 var mounts = FS.getMounts(mount); 2123 Object.keys(FS.nameTable).forEach((hash) => { 2124 var current = FS.nameTable[hash]; 2125 while (current) { 2126 var next = current.name_next; 2127 if (mounts.includes(current.mount)) { 2128 FS.destroyNode(current); 2129 } 2130 current = next; 2131 } 2132 }); 2133 node.mounted = null; 2134 var idx = node.mount.mounts.indexOf(mount); 2135 node.mount.mounts.splice(idx, 1); 2136 }, 2137 lookup: (parent, name) => { 2138 return parent.node_ops.lookup(parent, name); 2139 }, 2140 mknod: (path, mode, dev) => { 2141 var lookup = FS.lookupPath(path, { parent: true }); 2142 var parent = lookup.node; 2143 var name = PATH.basename(path); 2144 if (!name || name === "." || name === "..") { 2145 throw new FS.ErrnoError(28); 2146 } 2147 var errCode = FS.mayCreate(parent, name); 2148 if (errCode) { 2149 throw new FS.ErrnoError(errCode); 2150 } 2151 if (!parent.node_ops.mknod) { 2152 throw new FS.ErrnoError(63); 2153 } 2154 return parent.node_ops.mknod(parent, name, mode, dev); 2155 }, 2156 create: (path, mode) => { 2157 mode = mode !== undefined ? mode : 438; 2158 mode &= 4095; 2159 mode |= 32768; 2160 return FS.mknod(path, mode, 0); 2161 }, 2162 mkdir: (path, mode) => { 2163 mode = mode !== undefined ? mode : 511; 2164 mode &= 511 | 512; 2165 mode |= 16384; 2166 return FS.mknod(path, mode, 0); 2167 }, 2168 mkdirTree: (path, mode) => { 2169 var dirs = path.split("/"); 2170 var d = ""; 2171 for (var i = 0; i < dirs.length; ++i) { 2172 if (!dirs[i]) continue; 2173 d += "/" + dirs[i]; 2174 try { 2175 FS.mkdir(d, mode); 2176 } catch (e) { 2177 if (e.errno != 20) throw e; 2178 } 2179 } 2180 }, 2181 mkdev: (path, mode, dev) => { 2182 if (typeof dev == "undefined") { 2183 dev = mode; 2184 mode = 438; 2185 } 2186 mode |= 8192; 2187 return FS.mknod(path, mode, dev); 2188 }, 2189 symlink: (oldpath, newpath) => { 2190 if (!PATH_FS.resolve(oldpath)) { 2191 throw new FS.ErrnoError(44); 2192 } 2193 var lookup = FS.lookupPath(newpath, { parent: true }); 2194 var parent = lookup.node; 2195 if (!parent) { 2196 throw new FS.ErrnoError(44); 2197 } 2198 var newname = PATH.basename(newpath); 2199 var errCode = FS.mayCreate(parent, newname); 2200 if (errCode) { 2201 throw new FS.ErrnoError(errCode); 2202 } 2203 if (!parent.node_ops.symlink) { 2204 throw new FS.ErrnoError(63); 2205 } 2206 return parent.node_ops.symlink(parent, newname, oldpath); 2207 }, 2208 rename: (old_path, new_path) => { 2209 var old_dirname = PATH.dirname(old_path); 2210 var new_dirname = PATH.dirname(new_path); 2211 var old_name = PATH.basename(old_path); 2212 var new_name = PATH.basename(new_path); 2213 var lookup, old_dir, new_dir; 2214 lookup = FS.lookupPath(old_path, { parent: true }); 2215 old_dir = lookup.node; 2216 lookup = FS.lookupPath(new_path, { parent: true }); 2217 new_dir = lookup.node; 2218 if (!old_dir || !new_dir) throw new FS.ErrnoError(44); 2219 if (old_dir.mount !== new_dir.mount) { 2220 throw new FS.ErrnoError(75); 2221 } 2222 var old_node = FS.lookupNode(old_dir, old_name); 2223 var relative = PATH_FS.relative(old_path, new_dirname); 2224 if (relative.charAt(0) !== ".") { 2225 throw new FS.ErrnoError(28); 2226 } 2227 relative = PATH_FS.relative(new_path, old_dirname); 2228 if (relative.charAt(0) !== ".") { 2229 throw new FS.ErrnoError(55); 2230 } 2231 var new_node; 2232 try { 2233 new_node = FS.lookupNode(new_dir, new_name); 2234 } catch (e) {} 2235 if (old_node === new_node) { 2236 return; 2237 } 2238 var isdir = FS.isDir(old_node.mode); 2239 var errCode = FS.mayDelete(old_dir, old_name, isdir); 2240 if (errCode) { 2241 throw new FS.ErrnoError(errCode); 2242 } 2243 errCode = new_node 2244 ? FS.mayDelete(new_dir, new_name, isdir) 2245 : FS.mayCreate(new_dir, new_name); 2246 if (errCode) { 2247 throw new FS.ErrnoError(errCode); 2248 } 2249 if (!old_dir.node_ops.rename) { 2250 throw new FS.ErrnoError(63); 2251 } 2252 if ( 2253 FS.isMountpoint(old_node) || 2254 (new_node && FS.isMountpoint(new_node)) 2255 ) { 2256 throw new FS.ErrnoError(10); 2257 } 2258 if (new_dir !== old_dir) { 2259 errCode = FS.nodePermissions(old_dir, "w"); 2260 if (errCode) { 2261 throw new FS.ErrnoError(errCode); 2262 } 2263 } 2264 FS.hashRemoveNode(old_node); 2265 try { 2266 old_dir.node_ops.rename(old_node, new_dir, new_name); 2267 } catch (e) { 2268 throw e; 2269 } finally { 2270 FS.hashAddNode(old_node); 2271 } 2272 }, 2273 rmdir: (path) => { 2274 var lookup = FS.lookupPath(path, { parent: true }); 2275 var parent = lookup.node; 2276 var name = PATH.basename(path); 2277 var node = FS.lookupNode(parent, name); 2278 var errCode = FS.mayDelete(parent, name, true); 2279 if (errCode) { 2280 throw new FS.ErrnoError(errCode); 2281 } 2282 if (!parent.node_ops.rmdir) { 2283 throw new FS.ErrnoError(63); 2284 } 2285 if (FS.isMountpoint(node)) { 2286 throw new FS.ErrnoError(10); 2287 } 2288 parent.node_ops.rmdir(parent, name); 2289 FS.destroyNode(node); 2290 }, 2291 readdir: (path) => { 2292 var lookup = FS.lookupPath(path, { follow: true }); 2293 var node = lookup.node; 2294 if (!node.node_ops.readdir) { 2295 throw new FS.ErrnoError(54); 2296 } 2297 return node.node_ops.readdir(node); 2298 }, 2299 unlink: (path) => { 2300 var lookup = FS.lookupPath(path, { parent: true }); 2301 var parent = lookup.node; 2302 if (!parent) { 2303 throw new FS.ErrnoError(44); 2304 } 2305 var name = PATH.basename(path); 2306 var node = FS.lookupNode(parent, name); 2307 var errCode = FS.mayDelete(parent, name, false); 2308 if (errCode) { 2309 throw new FS.ErrnoError(errCode); 2310 } 2311 if (!parent.node_ops.unlink) { 2312 throw new FS.ErrnoError(63); 2313 } 2314 if (FS.isMountpoint(node)) { 2315 throw new FS.ErrnoError(10); 2316 } 2317 parent.node_ops.unlink(parent, name); 2318 FS.destroyNode(node); 2319 }, 2320 readlink: (path) => { 2321 var lookup = FS.lookupPath(path); 2322 var link = lookup.node; 2323 if (!link) { 2324 throw new FS.ErrnoError(44); 2325 } 2326 if (!link.node_ops.readlink) { 2327 throw new FS.ErrnoError(28); 2328 } 2329 return PATH_FS.resolve( 2330 FS.getPath(link.parent), 2331 link.node_ops.readlink(link), 2332 ); 2333 }, 2334 stat: (path, dontFollow) => { 2335 var lookup = FS.lookupPath(path, { follow: !dontFollow }); 2336 var node = lookup.node; 2337 if (!node) { 2338 throw new FS.ErrnoError(44); 2339 } 2340 if (!node.node_ops.getattr) { 2341 throw new FS.ErrnoError(63); 2342 } 2343 return node.node_ops.getattr(node); 2344 }, 2345 lstat: (path) => { 2346 return FS.stat(path, true); 2347 }, 2348 chmod: (path, mode, dontFollow) => { 2349 var node; 2350 if (typeof path == "string") { 2351 var lookup = FS.lookupPath(path, { follow: !dontFollow }); 2352 node = lookup.node; 2353 } else { 2354 node = path; 2355 } 2356 if (!node.node_ops.setattr) { 2357 throw new FS.ErrnoError(63); 2358 } 2359 node.node_ops.setattr(node, { 2360 mode: (mode & 4095) | (node.mode & ~4095), 2361 timestamp: Date.now(), 2362 }); 2363 }, 2364 lchmod: (path, mode) => { 2365 FS.chmod(path, mode, true); 2366 }, 2367 fchmod: (fd, mode) => {
2368 var stream = FS.getStream(fd); 2369 if (!stream) { 2370 throw new FS.ErrnoError(8); 2371 } 2372 FS.chmod(stream.node, mode); 2373 }, 2374 chown: (path, uid, gid, dontFollow) => { 2375 var node; 2376 if (typeof path == "string") { 2377 var lookup = FS.lookupPath(path, { follow: !dontFollow }); 2378 node = lookup.node; 2379 } else { 2380 node = path; 2381 } 2382 if (!node.node_ops.setattr) { 2383 throw new FS.ErrnoError(63); 2384 } 2385 node.node_ops.setattr(node, { timestamp: Date.now() }); 2386 }, 2387 lchown: (path, uid, gid) => { 2388 FS.chown(path, uid, gid, true); 2389 }, 2390 fchown: (fd, uid, gid) => { 2391 var stream = FS.getStream(fd); 2392 if (!stream) { 2393 throw new FS.ErrnoError(8); 2394 } 2395 FS.chown(stream.node, uid, gid); 2396 }, 2397 truncate: (path, len) => { 2398 if (len < 0) { 2399 throw new FS.ErrnoError(28); 2400 } 2401 var node; 2402 if (typeof path == "string") { 2403 var lookup = FS.lookupPath(path, { follow: true }); 2404 node = lookup.node; 2405 } else { 2406 node = path; 2407 } 2408 if (!node.node_ops.setattr) { 2409 throw new FS.ErrnoError(63); 2410 } 2411 if (FS.isDir(node.mode)) { 2412 throw new FS.ErrnoError(31); 2413 } 2414 if (!FS.isFile(node.mode)) { 2415 throw new FS.ErrnoError(28); 2416 } 2417 var errCode = FS.nodePermissions(node, "w"); 2418 if (errCode) { 2419 throw new FS.ErrnoError(errCode); 2420 } 2421 node.node_ops.setattr(node, { size: len, timestamp: Date.now() }); 2422 }, 2423 ftruncate: (fd, len) => { 2424 var stream = FS.getStream(fd); 2425 if (!stream) { 2426 throw new FS.ErrnoError(8); 2427 } 2428 if ((stream.flags & 2097155) === 0) { 2429 throw new FS.ErrnoError(28); 2430 } 2431 FS.truncate(stream.node, len); 2432 }, 2433 utime: (path, atime, mtime) => { 2434 var lookup = FS.lookupPath(path, { follow: true }); 2435 var node = lookup.node; 2436 node.node_ops.setattr(node, { timestamp: Math.max(atime, mtime) }); 2437 }, 2438 open: (path, flags, mode) => { 2439 if (path === "") { 2440 throw new FS.ErrnoError(44); 2441 } 2442 flags = typeof flags == "string" ? FS_modeStringToFlags(flags) : flags; 2443 mode = typeof mode == "undefined" ? 438 : mode; 2444 if (flags & 64) { 2445 mode = (mode & 4095) | 32768; 2446 } else { 2447 mode = 0; 2448 } 2449 var node; 2450 if (typeof path == "object") { 2451 node = path; 2452 } else { 2453 path = PATH.normalize(path); 2454 try { 2455 var lookup = FS.lookupPath(path, { follow: !(flags & 131072) }); 2456 node = lookup.node; 2457 } catch (e) {} 2458 } 2459 var created = false; 2460 if (flags & 64) { 2461 if (node) { 2462 if (flags & 128) { 2463 throw new FS.ErrnoError(20); 2464 } 2465 } else { 2466 node = FS.mknod(path, mode, 0); 2467 created = true; 2468 } 2469 } 2470 if (!node) { 2471 throw new FS.ErrnoError(44); 2472 } 2473 if (FS.isChrdev(node.mode)) { 2474 flags &= ~512; 2475 } 2476 if (flags & 65536 && !FS.isDir(node.mode)) { 2477 throw new FS.ErrnoError(54); 2478 } 2479 if (!created) { 2480 var errCode = FS.mayOpen(node, flags); 2481 if (errCode) { 2482 throw new FS.ErrnoError(errCode); 2483 } 2484 } 2485 if (flags & 512 && !created) { 2486 FS.truncate(node, 0); 2487 } 2488 flags &= ~(128 | 512 | 131072); 2489 var stream = FS.createStream({ 2490 node: node, 2491 path: FS.getPath(node), 2492 flags: flags, 2493 seekable: true, 2494 position: 0, 2495 stream_ops: node.stream_ops, 2496 ungotten: [], 2497 error: false, 2498 }); 2499 if (stream.stream_ops.open) { 2500 stream.stream_ops.open(stream); 2501 } 2502 if (Module["logReadFiles"] && !(flags & 1)) { 2503 if (!FS.readFiles) FS.readFiles = {}; 2504 if (!(path in FS.readFiles)) { 2505 FS.readFiles[path] = 1; 2506 } 2507 } 2508 return stream; 2509 },
2510 close: (stream) => { 2511 if (FS.isClosed(stream)) { 2512 throw new FS.ErrnoError(8); 2513 } 2514 if (stream.getdents) stream.getdents = null; 2515 try { 2516 if (stream.stream_ops.close) { 2517 stream.stream_ops.close(stream); 2518 } 2519 } catch (e) { 2520 throw e; 2521 } finally { 2522 FS.closeStream(stream.fd); 2523 } 2524 stream.fd = null; 2525 }, 2526 isClosed: (stream) => { 2527 return stream.fd === null; 2528 }, 2529 llseek: (stream, offset, whence) => { 2530 if (FS.isClosed(stream)) { 2531 throw new FS.ErrnoError(8); 2532 } 2533 if (!stream.seekable || !stream.stream_ops.llseek) { 2534 throw new FS.ErrnoError(70); 2535 } 2536 if (whence != 0 && whence != 1 && whence != 2) { 2537 throw new FS.ErrnoError(28); 2538 } 2539 stream.position = stream.stream_ops.llseek(stream, offset, whence); 2540 stream.ungotten = []; 2541 return stream.position; 2542 }, 2543 read: (stream, buffer, offset, length, position) => { 2544 if (length < 0 || position < 0) { 2545 throw new FS.ErrnoError(28); 2546 } 2547 if (FS.isClosed(stream)) { 2548 throw new FS.ErrnoError(8); 2549 } 2550 if ((stream.flags & 2097155) === 1) { 2551 throw new FS.ErrnoError(8); 2552 } 2553 if (FS.isDir(stream.node.mode)) { 2554 throw new FS.ErrnoError(31); 2555 } 2556 if (!stream.stream_ops.read) { 2557 throw new FS.ErrnoError(28); 2558 } 2559 var seeking = typeof position != "undefined"; 2560 if (!seeking) { 2561 position = stream.position; 2562 } else if (!stream.seekable) { 2563 throw new FS.ErrnoError(70); 2564 } 2565 var bytesRead = stream.stream_ops.read( 2566 stream, 2567 buffer, 2568 offset, 2569 length, 2570 position, 2571 ); 2572 if (!seeking) stream.position += bytesRead; 2573 return bytesRead; 2574 }, 2575 write: (stream, buffer, offset, length, position, canOwn) => { 2576 if (length < 0 || position < 0) { 2577 throw new FS.ErrnoError(28); 2578 } 2579 if (FS.isClosed(stream)) { 2580 throw new FS.ErrnoError(8); 2581 } 2582 if ((stream.flags & 2097155) === 0) { 2583 throw new FS.ErrnoError(8); 2584 } 2585 if (FS.isDir(stream.node.mode)) { 2586 throw new FS.ErrnoError(31); 2587 } 2588 if (!stream.stream_ops.write) { 2589 throw new FS.ErrnoError(28); 2590 } 2591 if (stream.seekable && stream.flags & 1024) { 2592 FS.llseek(stream, 0, 2); 2593 } 2594 var seeking = typeof position != "undefined"; 2595 if (!seeking) { 2596 position = stream.position; 2597 } else if (!stream.seekable) { 2598 throw new FS.ErrnoError(70); 2599 } 2600 var bytesWritten = stream.stream_ops.write( 2601 stream, 2602 buffer, 2603 offset, 2604 length, 2605 position, 2606 canOwn, 2607 ); 2608 if (!seeking) stream.position += bytesWritten; 2609 return bytesWritten; 2610 }, 2611 allocate: (stream, offset, length) => { 2612 if (FS.isClosed(stream)) { 2613 throw new FS.ErrnoError(8); 2614 } 2615 if (offset < 0 || length <= 0) { 2616 throw new FS.ErrnoError(28); 2617 } 2618 if ((stream.flags & 2097155) === 0) { 2619 throw new FS.ErrnoError(8); 2620 } 2621 if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) { 2622 throw new FS.ErrnoError(43); 2623 } 2624 if (!stream.stream_ops.allocate) { 2625 throw new FS.ErrnoError(138); 2626 } 2627 stream.stream_ops.allocate(stream, offset, length); 2628 }, 2629 mmap: (stream, length, position, prot, flags) => { 2630 if ( 2631 (prot & 2) !== 0 && 2632 (flags & 2) === 0 && 2633 (stream.flags & 2097155) !== 2 2634 ) { 2635 throw new FS.ErrnoError(2); 2636 } 2637 if ((stream.flags & 2097155) === 1) { 2638 throw new FS.ErrnoError(2); 2639 } 2640 if (!stream.stream_ops.mmap) { 2641 throw new FS.ErrnoError(43); 2642 } 2643 return stream.stream_ops.mmap(stream, length, position, prot, flags); 2644 }, 2645 msync: (stream, buffer, offset, length, mmapFlags) => { 2646 if (!stream.stream_ops.msync) { 2647 return 0; 2648 } 2649 return stream.stream_ops.msync( 2650 stream, 2651 buffer, 2652 offset, 2653 length, 2654 mmapFlags, 2655 ); 2656 },
2657 munmap: (stream) => 0, 2658 ioctl: (stream, cmd, arg) => { 2659 if (!stream.stream_ops.ioctl) { 2660 throw new FS.ErrnoError(59); 2661 } 2662 return stream.stream_ops.ioctl(stream, cmd, arg); 2663 }, 2664 readFile: (path, opts = {}) => { 2665 opts.flags = opts.flags || 0; 2666 opts.encoding = opts.encoding || "binary"; 2667 if (opts.encoding !== "utf8" && opts.encoding !== "binary") { 2668 throw new Error(`Invalid encoding type "${opts.encoding}"`); 2669 } 2670 var ret; 2671 var stream = FS.open(path, opts.flags); 2672 var stat = FS.stat(path); 2673 var length = stat.size; 2674 var buf = new Uint8Array(length); 2675 FS.read(stream, buf, 0, length, 0); 2676 if (opts.encoding === "utf8") { 2677 ret = UTF8ArrayToString(buf, 0); 2678 } else if (opts.encoding === "binary") { 2679 ret = buf; 2680 } 2681 FS.close(stream); 2682 return ret; 2683 }, 2684 writeFile: (path, data, opts = {}) => { 2685 opts.flags = opts.flags || 577; 2686 var stream = FS.open(path, opts.flags, opts.mode); 2687 if (typeof data == "string") { 2688 var buf = new Uint8Array(lengthBytesUTF8(data) + 1); 2689 var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length); 2690 FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn); 2691 } else if (ArrayBuffer.isView(data)) { 2692 FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn); 2693 } else { 2694 throw new Error("Unsupported data type"); 2695 } 2696 FS.close(stream); 2697 }, 2698 cwd: () => FS.currentPath, 2699 chdir: (path) => { 2700 var lookup = FS.lookupPath(path, { follow: true }); 2701 if (lookup.node === null) { 2702 throw new FS.ErrnoError(44); 2703 } 2704 if (!FS.isDir(lookup.node.mode)) { 2705 throw new FS.ErrnoError(54); 2706 } 2707 var errCode = FS.nodePermissions(lookup.node, "x"); 2708 if (errCode) { 2709 throw new FS.ErrnoError(errCode); 2710 } 2711 FS.currentPath = lookup.path; 2712 }, 2713 createDefaultDirectories: () => { 2714 FS.mkdir("/tmp"); 2715 FS.mkdir("/home"); 2716 FS.mkdir("/home/web_user"); 2717 }, 2718 createDefaultDevices: () => { 2719 FS.mkdir("/dev"); 2720 FS.registerDevice(FS.makedev(1, 3), { 2721 read: () => 0, 2722 write: (stream, buffer, offset, length, pos) => length, 2723 }); 2724 FS.mkdev("/dev/null", FS.makedev(1, 3)); 2725 TTY.register(FS.makedev(5, 0), TTY.default_tty_ops); 2726 TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops); 2727 FS.mkdev("/dev/tty", FS.makedev(5, 0)); 2728 FS.mkdev("/dev/tty1", FS.makedev(6, 0)); 2729 var randomBuffer = new Uint8Array(1024), 2730 randomLeft = 0; 2731 var randomByte = () => { 2732 if (randomLeft === 0) { 2733 randomLeft = randomFill(randomBuffer).byteLength; 2734 } 2735 return randomBuffer[--randomLeft]; 2736 }; 2737 FS.createDevice("/dev", "random", randomByte); 2738 FS.createDevice("/dev", "urandom", randomByte); 2739 FS.mkdir("/dev/shm"); 2740 FS.mkdir("/dev/shm/tmp"); 2741 }, 2742 createSpecialDirectories: () => { 2743 FS.mkdir("/proc"); 2744 var proc_self = FS.mkdir("/proc/self"); 2745 FS.mkdir("/proc/self/fd"); 2746 FS.mount( 2747 { 2748 mount: () => { 2749 var node = FS.createNode(proc_self, "fd", 16384 | 511, 73); 2750 node.node_ops = { 2751 lookup: (parent, name) => { 2752 var fd = +name; 2753 var stream = FS.getStream(fd); 2754 if (!stream) throw new FS.ErrnoError(8); 2755 var ret = { 2756 parent: null, 2757 mount: { mountpoint: "fake" }, 2758 node_ops: { readlink: () => stream.path }, 2759 }; 2760 ret.parent = ret; 2761 return ret; 2762 }, 2763 }; 2764 return node; 2765 }, 2766 }, 2767 {}, 2768 "/proc/self/fd", 2769 ); 2770 }, 2771 createStandardStreams: () => { 2772 if (Module["stdin"]) { 2773 FS.createDevice("/dev", "stdin", Module["stdin"]); 2774 } else { 2775 FS.symlink("/dev/tty", "/dev/stdin"); 2776 } 2777 if (Module["stdout"]) { 2778 FS.createDevice("/dev", "stdout", null, Module["stdout"]); 2779 } else { 2780 FS.symlink("/dev/tty", "/dev/stdout"); 2781 } 2782 if (Module["stderr"]) { 2783 FS.createDevice("/dev", "stderr", null, Module["stderr"]); 2784 } else { 2785 FS.symlink("/dev/tty1", "/dev/stderr"); 2786 } 2787 var stdin = FS.open("/dev/stdin", 0); 2788 var stdout = FS.open("/dev/stdout", 1); 2789 var stderr = FS.open("/dev/stderr", 1); 2790 }, 2791 ensureErrnoError: () => { 2792 if (FS.ErrnoError) return; 2793 FS.ErrnoError = function ErrnoError(errno, node) { 2794 this.name = "ErrnoError"; 2795 this.node = node;
2796 this.setErrno = function (errno) { 2797 this.errno = errno; 2798 }; 2799 this.setErrno(errno); 2800 this.message = "FS error"; 2801 }; 2802 FS.ErrnoError.prototype = new Error(); 2803 FS.ErrnoError.prototype.constructor = FS.ErrnoError; 2804 [44].forEach((code) => { 2805 FS.genericErrors[code] = new FS.ErrnoError(code); 2806 FS.genericErrors[code].stack = "<generic error, no stack>"; 2807 }); 2808 }, 2809 staticInit: () => { 2810 FS.ensureErrnoError(); 2811 FS.nameTable = new Array(4096); 2812 FS.mount(MEMFS, {}, "/"); 2813 FS.createDefaultDirectories(); 2814 FS.createDefaultDevices(); 2815 FS.createSpecialDirectories(); 2816 FS.filesystems = { MEMFS: MEMFS, WORKERFS: WORKERFS }; 2817 }, 2818 init: (input, output, error) => { 2819 FS.init.initialized = true; 2820 FS.ensureErrnoError(); 2821 Module["stdin"] = input || Module["stdin"]; 2822 Module["stdout"] = output || Module["stdout"]; 2823 Module["stderr"] = error || Module["stderr"]; 2824 FS.createStandardStreams(); 2825 }, 2826 quit: () => { 2827 FS.init.initialized = false; 2828 for (var i = 0; i < FS.streams.length; i++) { 2829 var stream = FS.streams[i]; 2830 if (!stream) { 2831 continue; 2832 } 2833 FS.close(stream); 2834 } 2835 }, 2836 findObject: (path, dontResolveLastLink) => { 2837 var ret = FS.analyzePath(path, dontResolveLastLink); 2838 if (!ret.exists) { 2839 return null; 2840 } 2841 return ret.object; 2842 }, 2843 analyzePath: (path, dontResolveLastLink) => { 2844 try { 2845 var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); 2846 path = lookup.path; 2847 } catch (e) {} 2848 var ret = { 2849 isRoot: false, 2850 exists: false, 2851 error: 0, 2852 name: null, 2853 path: null, 2854 object: null, 2855 parentExists: false, 2856 parentPath: null, 2857 parentObject: null, 2858 }; 2859 try { 2860 var lookup = FS.lookupPath(path, { parent: true }); 2861 ret.parentExists = true; 2862 ret.parentPath = lookup.path; 2863 ret.parentObject = lookup.node; 2864 ret.name = PATH.basename(path); 2865 lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); 2866 ret.exists = true; 2867 ret.path = lookup.path; 2868 ret.object = lookup.node; 2869 ret.name = lookup.node.name; 2870 ret.isRoot = lookup.path === "/"; 2871 } catch (e) { 2872 ret.error = e.errno; 2873 } 2874 return ret; 2875 }, 2876 createPath: (parent, path, canRead, canWrite) => { 2877 parent = typeof parent == "string" ? parent : FS.getPath(parent); 2878 var parts = path.split("/").reverse(); 2879 while (parts.length) { 2880 var part = parts.pop(); 2881 if (!part) continue; 2882 var current = PATH.join2(parent, part); 2883 try { 2884 FS.mkdir(current); 2885 } catch (e) {} 2886 parent = current; 2887 } 2888 return current; 2889 }, 2890 createFile: (parent, name, properties, canRead, canWrite) => { 2891 var path = PATH.join2( 2892 typeof parent == "string" ? parent : FS.getPath(parent), 2893 name, 2894 ); 2895 var mode = FS_getMode(canRead, canWrite); 2896 return FS.create(path, mode); 2897 }, 2898 createDataFile: (parent, name, data, canRead, canWrite, canOwn) => { 2899 var path = name; 2900 if (parent) { 2901 parent = typeof parent == "string" ? parent : FS.getPath(parent); 2902 path = name ? PATH.join2(parent, name) : parent; 2903 } 2904 var mode = FS_getMode(canRead, canWrite); 2905 var node = FS.create(path, mode); 2906 if (data) { 2907 if (typeof data == "string") { 2908 var arr = new Array(data.length); 2909 for (var i = 0, len = data.length; i < len; ++i) 2910 arr[i] = data.charCodeAt(i); 2911 data = arr; 2912 } 2913 FS.chmod(node, mode | 146); 2914 var stream = FS.open(node, 577); 2915 FS.write(stream, data, 0, data.length, 0, canOwn); 2916 FS.close(stream); 2917 FS.chmod(node, mode); 2918 } 2919 return node; 2920 }, 2921 createDevice: (parent, name, input, output) => { 2922 var path = PATH.join2( 2923 typeof parent == "string" ? parent : FS.getPath(parent), 2924 name, 2925 ); 2926 var mode = FS_getMode(!!input, !!output); 2927 if (!FS.createDevice.major) FS.createDevice.major = 64; 2928 var dev = FS.makedev(FS.createDevice.major++, 0); 2929 FS.registerDevice(dev, {
2930 open: (stream) => { 2931 stream.seekable = false; 2932 }, 2933 close: (stream) => { 2934 if (output && output.buffer && output.buffer.length) { 2935 output(10); 2936 } 2937 }, 2938 read: (stream, buffer, offset, length, pos) => { 2939 var bytesRead = 0; 2940 for (var i = 0; i < length; i++) { 2941 var result; 2942 try { 2943 result = input(); 2944 } catch (e) { 2945 throw new FS.ErrnoError(29); 2946 } 2947 if (result === undefined && bytesRead === 0) { 2948 throw new FS.ErrnoError(6); 2949 } 2950 if (result === null || result === undefined) break; 2951 bytesRead++; 2952 buffer[offset + i] = result; 2953 } 2954 if (bytesRead) { 2955 stream.node.timestamp = Date.now(); 2956 } 2957 return bytesRead; 2958 }, 2959 write: (stream, buffer, offset, length, pos) => { 2960 for (var i = 0; i < length; i++) { 2961 try { 2962 output(buffer[offset + i]); 2963 } catch (e) { 2964 throw new FS.ErrnoError(29); 2965 } 2966 } 2967 if (length) { 2968 stream.node.timestamp = Date.now(); 2969 } 2970 return i; 2971 }, 2972 }); 2973 return FS.mkdev(path, mode, dev); 2974 }, 2975 forceLoadFile: (obj) => { 2976 if (obj.isDevice || obj.isFolder || obj.link || obj.contents) 2977 return true; 2978 if (typeof XMLHttpRequest != "undefined") { 2979 throw new Error( 2980 "Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.", 2981 ); 2982 } else if (read_) { 2983 try { 2984 obj.contents = intArrayFromString(read_(obj.url), true); 2985 obj.usedBytes = obj.contents.length; 2986 } catch (e) { 2987 throw new FS.ErrnoError(29); 2988 } 2989 } else { 2990 throw new Error("Cannot load without read() or XMLHttpRequest."); 2991 } 2992 }, 2993 createLazyFile: (parent, name, url, canRead, canWrite) => { 2994 function LazyUint8Array() { 2995 this.lengthKnown = false; 2996 this.chunks = []; 2997 } 2998 LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) { 2999 if (idx > this.length - 1 || idx < 0) { 3000 return undefined; 3001 } 3002 var chunkOffset = idx % this.chunkSize; 3003 var chunkNum = (idx / this.chunkSize) | 0; 3004 return this.getter(chunkNum)[chunkOffset]; 3005 }; 3006 LazyUint8Array.prototype.setDataGetter = 3007 function LazyUint8Array_setDataGetter(getter) { 3008 this.getter = getter; 3009 }; 3010 LazyUint8Array.prototype.cacheLength = 3011 function LazyUint8Array_cacheLength() { 3012 var xhr = new XMLHttpRequest(); 3013 xhr.open("HEAD", url, false); 3014 xhr.send(null); 3015 if ( 3016 !((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304) 3017 ) 3018 throw new Error( 3019 "Couldn't load " + url + ". Status: " + xhr.status, 3020 ); 3021 var datalength = Number(xhr.getResponseHeader("Content-length")); 3022 var header; 3023 var hasByteServing = 3024 (header = xhr.getResponseHeader("Accept-Ranges")) && 3025 header === "bytes"; 3026 var usesGzip = 3027 (header = xhr.getResponseHeader("Content-Encoding")) && 3028 header === "gzip"; 3029 var chunkSize = 1024 * 1024; 3030 if (!hasByteServing) chunkSize = datalength; 3031 var doXHR = (from, to) => { 3032 if (from > to) 3033 throw new Error( 3034 "invalid range (" + 3035 from + 3036 ", " + 3037 to + 3038 ") or no bytes requested!", 3039 ); 3040 if (to > datalength - 1) 3041 throw new Error( 3042 "only " + datalength + " bytes available! programmer error!", 3043 ); 3044 var xhr = new XMLHttpRequest(); 3045 xhr.open("GET", url, false); 3046 if (datalength !== chunkSize) 3047 xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); 3048 xhr.responseType = "arraybuffer"; 3049 if (xhr.overrideMimeType) { 3050 xhr.overrideMimeType("text/plain;
3050 charset=x-user-defined"); 3051 } 3052 xhr.send(null); 3053 if ( 3054 !((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304) 3055 ) 3056 throw new Error( 3057 "Couldn't load " + url + ". Status: " + xhr.status, 3058 ); 3059 if (xhr.response !== undefined) { 3060 return new Uint8Array(xhr.response || []); 3061 } 3062 return intArrayFromString(xhr.responseText || "", true); 3063 }; 3064 var lazyArray = this; 3065 lazyArray.setDataGetter((chunkNum) => { 3066 var start = chunkNum * chunkSize; 3067 var end = (chunkNum + 1) * chunkSize - 1; 3068 end = Math.min(end, datalength - 1); 3069 if (typeof lazyArray.chunks[chunkNum] == "undefined") { 3070 lazyArray.chunks[chunkNum] = doXHR(start, end); 3071 } 3072 if (typeof lazyArray.chunks[chunkNum] == "undefined") 3073 throw new Error("doXHR failed!"); 3074 return lazyArray.chunks[chunkNum]; 3075 }); 3076 if (usesGzip || !datalength) { 3077 chunkSize = datalength = 1; 3078 datalength = this.getter(0).length; 3079 chunkSize = datalength; 3080 out( 3081 "LazyFiles on gzip forces download of the whole file when length is accessed", 3082 ); 3083 } 3084 this._length = datalength; 3085 this._chunkSize = chunkSize; 3086 this.lengthKnown = true; 3087 }; 3088 if (typeof XMLHttpRequest != "undefined") { 3089 if (!ENVIRONMENT_IS_WORKER) 3090 throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
3091 var lazyArray = new LazyUint8Array(); 3092 Object.defineProperties(lazyArray, { 3093 length: { 3094 get: function () { 3095 if (!this.lengthKnown) { 3096 this.cacheLength(); 3097 } 3098 return this._length; 3099 }, 3100 }, 3101 chunkSize: { 3102 get: function () { 3103 if (!this.lengthKnown) { 3104 this.cacheLength(); 3105 } 3106 return this._chunkSize; 3107 }, 3108 }, 3109 }); 3110 var properties = { isDevice: false, contents: lazyArray }; 3111 } else { 3112 var properties = { isDevice: false, url: url }; 3113 } 3114 var node = FS.createFile(parent, name, properties, canRead, canWrite); 3115 if (properties.contents) { 3116 node.contents = properties.contents; 3117 } else if (properties.url) { 3118 node.contents = null; 3119 node.url = properties.url; 3120 } 3121 Object.defineProperties(node, { 3122 usedBytes: { 3123 get: function () { 3124 return this.contents.length; 3125 }, 3126 }, 3127 }); 3128 var stream_ops = {}; 3129 var keys = Object.keys(node.stream_ops); 3130 keys.forEach((key) => { 3131 var fn = node.stream_ops[key]; 3132 stream_ops[key] = function forceLoadLazyFile() { 3133 FS.forceLoadFile(node); 3134 return fn.apply(null, arguments); 3135 }; 3136 }); 3137 function writeChunks(stream, buffer, offset, length, position) { 3138 var contents = stream.node.contents; 3139 if (position >= contents.length) return 0; 3140 var size = Math.min(contents.length - position, length); 3141 if (contents.slice) { 3142 for (var i = 0; i < size; i++) { 3143 buffer[offset + i] = contents[position + i]; 3144 } 3145 } else { 3146 for (var i = 0; i < size; i++) { 3147 buffer[offset + i] = contents.get(position + i); 3148 } 3149 } 3150 return size; 3151 } 3152 stream_ops.read = (stream, buffer, offset, length, position) => { 3153 FS.forceLoadFile(node); 3154 return writeChunks(stream, buffer, offset, length, position); 3155 }; 3156 stream_ops.mmap = (stream, length, position, prot, flags) => { 3157 FS.forceLoadFile(node); 3158 var ptr = mmapAlloc(length); 3159 if (!ptr) { 3160 throw new FS.ErrnoError(48); 3161 } 3162 writeChunks(stream, HEAP8, ptr, length, position);
3163 return { ptr: ptr, allocated: true }; 3164 }; 3165 node.stream_ops = stream_ops; 3166 return node; 3167 }, 3168 }; 3169 var SYSCALLS = { 3170 DEFAULT_POLLMASK: 5, 3171 calculateAt: function (dirfd, path, allowEmpty) { 3172 if (PATH.isAbs(path)) { 3173 return path; 3174 } 3175 var dir; 3176 if (dirfd === -100) { 3177 dir = FS.cwd(); 3178 } else { 3179 var dirstream = SYSCALLS.getStreamFromFD(dirfd); 3180 dir = dirstream.path; 3181 } 3182 if (path.length == 0) { 3183 if (!allowEmpty) { 3184 throw new FS.ErrnoError(44); 3185 } 3186 return dir; 3187 } 3188 return PATH.join2(dir, path); 3189 }, 3190 doStat: function (func, path, buf) { 3191 try { 3192 var stat = func(path); 3193 } catch (e) { 3194 if ( 3195 e && 3196 e.node && 3197 PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node)) 3198 ) { 3199 return -54; 3200 } 3201 throw e; 3202 } 3203 HEAP32[buf >> 2] = stat.dev; 3204 HEAP32[(buf + 8) >> 2] = stat.ino; 3205 HEAP32[(buf + 12) >> 2] = stat.mode; 3206 HEAPU32[(buf + 16) >> 2] = stat.nlink; 3207 HEAP32[(buf + 20) >> 2] = stat.uid; 3208 HEAP32[(buf + 24) >> 2] = stat.gid; 3209 HEAP32[(buf + 28) >> 2] = stat.rdev; 3210 HEAP64[(buf + 40) >> 3] = BigInt(stat.size); 3211 HEAP32[(buf + 48) >> 2] = 4096; 3212 HEAP32[(buf + 52) >> 2] = stat.blocks; 3213 var atime = stat.atime.getTime(); 3214 var mtime = stat.mtime.getTime(); 3215 var ctime = stat.ctime.getTime(); 3216 HEAP64[(buf + 56) >> 3] = BigInt(Math.floor(atime / 1e3)); 3217 HEAPU32[(buf + 64) >> 2] = (atime % 1e3) * 1e3; 3218 HEAP64[(buf + 72) >> 3] = BigInt(Math.floor(mtime / 1e3)); 3219 HEAPU32[(buf + 80) >> 2] = (mtime % 1e3) * 1e3; 3220 HEAP64[(buf + 88) >> 3] = BigInt(Math.floor(ctime / 1e3)); 3221 HEAPU32[(buf + 96) >> 2] = (ctime % 1e3) * 1e3; 3222 HEAP64[(buf + 104) >> 3] = BigInt(stat.ino); 3223 return 0; 3224 }, 3225 doMsync: function (addr, stream, len, flags, offset) { 3226 if (!FS.isFile(stream.node.mode)) { 3227 throw new FS.ErrnoError(43); 3228 } 3229 if (flags & 2) { 3230 return 0; 3231 } 3232 var buffer = HEAPU8.slice(addr, addr + len); 3233 FS.msync(stream, buffer, offset, len, flags); 3234 }, 3235 varargs: undefined, 3236 get: function () { 3237 SYSCALLS.varargs += 4; 3238 var ret = HEAP32[(SYSCALLS.varargs - 4) >> 2]; 3239 return ret; 3240 }, 3241 getStr: function (ptr) { 3242 var ret = UTF8ToString(ptr); 3243 return ret; 3244 }, 3245 getStreamFromFD: function (fd) { 3246 var stream = FS.getStream(fd); 3247 if (!stream) throw new FS.ErrnoError(8); 3248 return stream; 3249 }, 3250 }; 3251 function ___syscall__newselect( 3252 nfds, 3253 readfds, 3254 writefds, 3255 exceptfds, 3256 timeout, 3257 ) { 3258 try { 3259 var total = 0; 3260 var srcReadLow = readfds ? HEAP32[readfds >> 2] : 0, 3261 srcReadHigh = readfds ? HEAP32[(readfds + 4) >> 2] : 0; 3262 var srcWriteLow = writefds ? HEAP32[writefds >> 2] : 0, 3263 srcWriteHigh = writefds ? HEAP32[(writefds + 4) >> 2] : 0; 3264 var srcExceptLow = exceptfds ? HEAP32[exceptfds >> 2] : 0, 3265 srcExceptHigh = exceptfds ? HEAP32[(exceptfds + 4) >> 2] : 0; 3266 var dstReadLow = 0, 3267 dstReadHigh = 0; 3268 var dstWriteLow = 0, 3269 dstWriteHigh = 0; 3270 var dstExceptLow = 0, 3271 dstExceptHigh = 0; 3272 var allLow = 3273 (readfds ? HEAP32[readfds >> 2] : 0) | 3274 (writefds ? HEAP32[writefds >> 2] : 0) | 3275 (exceptfds ? HEAP32[exceptfds >> 2] : 0); 3276 var allHigh = 3277 (readfds ? HEAP32[(readfds + 4) >> 2] : 0) | 3278 (writefds ? HEAP32[(writefds + 4) >> 2] : 0) | 3279 (exceptfds ? HEAP32[(exceptfds + 4) >> 2] : 0); 3280 var check = function (fd, low, high, val) { 3281 return fd < 32 ? low & val : high & val; 3282 }; 3283 for (var fd = 0; fd < nfds; fd++) { 3284 var mask = 1 << fd % 32; 3285 if (!check(fd, allLow, allHigh, mask)) { 3286 continue; 3287 }
3288 var stream = SYSCALLS.getStreamFromFD(fd); 3289 var flags = SYSCALLS.DEFAULT_POLLMASK; 3290 if (stream.stream_ops.poll) { 3291 flags = stream.stream_ops.poll(stream); 3292 } 3293 if (flags & 1 && check(fd, srcReadLow, srcReadHigh, mask)) { 3294 fd < 32 3295 ? (dstReadLow = dstReadLow | mask) 3296 : (dstReadHigh = dstReadHigh | mask); 3297 total++; 3298 } 3299 if (flags & 4 && check(fd, srcWriteLow, srcWriteHigh, mask)) { 3300 fd < 32 3301 ? (dstWriteLow = dstWriteLow | mask) 3302 : (dstWriteHigh = dstWriteHigh | mask); 3303 total++; 3304 } 3305 if (flags & 2 && check(fd, srcExceptLow, srcExceptHigh, mask)) { 3306 fd < 32 3307 ? (dstExceptLow = dstExceptLow | mask) 3308 : (dstExceptHigh = dstExceptHigh | mask); 3309 total++; 3310 } 3311 } 3312 if (readfds) { 3313 HEAP32[readfds >> 2] = dstReadLow; 3314 HEAP32[(readfds + 4) >> 2] = dstReadHigh; 3315 } 3316 if (writefds) { 3317 HEAP32[writefds >> 2] = dstWriteLow; 3318 HEAP32[(writefds + 4) >> 2] = dstWriteHigh; 3319 } 3320 if (exceptfds) { 3321 HEAP32[exceptfds >> 2] = dstExceptLow; 3322 HEAP32[(exceptfds + 4) >> 2] = dstExceptHigh; 3323 } 3324 return total; 3325 } catch (e) { 3326 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 3327 return -e.errno; 3328 } 3329 } 3330 var SOCKFS = { 3331 mount: function (mount) { 3332 Module["websocket"] = 3333 Module["websocket"] && "object" === typeof Module["websocket"] 3334 ? Module["websocket"] 3335 : {}; 3336 Module["websocket"]._callbacks = {}; 3337 Module["websocket"]["on"] = function (event, callback) { 3338 if ("function" === typeof callback) { 3339 this._callbacks[event] = callback; 3340 } 3341 return this; 3342 }; 3343 Module["websocket"].emit = function (event, param) { 3344 if ("function" === typeof this._callbacks[event]) { 3345 this._callbacks[event].call(this, param); 3346 } 3347 }; 3348 return FS.createNode(null, "/", 16384 | 511, 0); 3349 }, 3350 createSocket: function (family, type, protocol) { 3351 type &= ~526336; 3352 var streaming = type == 1; 3353 if (streaming && protocol && protocol != 6) { 3354 throw new FS.ErrnoError(66); 3355 } 3356 var sock = { 3357 family: family, 3358 type: type, 3359 protocol: protocol, 3360 server: null, 3361 error: null, 3362 peers: {}, 3363 pending: [], 3364 recv_queue: [], 3365 sock_ops: SOCKFS.websocket_sock_ops, 3366 }; 3367 var name = SOCKFS.nextname(); 3368 var node = FS.createNode(SOCKFS.root, name, 49152, 0); 3369 node.sock = sock; 3370 var stream = FS.createStream({ 3371 path: name, 3372 node: node, 3373 flags: 2, 3374 seekable: false, 3375 stream_ops: SOCKFS.stream_ops, 3376 }); 3377 sock.stream = stream; 3378 return sock; 3379 }, 3380 getSocket: function (fd) { 3381 var stream = FS.getStream(fd); 3382 if (!stream || !FS.isSocket(stream.node.mode)) { 3383 return null; 3384 } 3385 return stream.node.sock; 3386 }, 3387 stream_ops: { 3388 poll: function (stream) { 3389 var sock = stream.node.sock; 3390 return sock.sock_ops.poll(sock); 3391 }, 3392 ioctl: function (stream, request, varargs) { 3393 var sock = stream.node.sock; 3394 return sock.sock_ops.ioctl(sock, request, varargs); 3395 }, 3396 read: function (stream, buffer, offset, length, position) { 3397 var sock = stream.node.sock; 3398 var msg = sock.sock_ops.recvmsg(sock, length); 3399 if (!msg) { 3400 return 0; 3401 } 3402 buffer.set(msg.buffer, offset); 3403 return msg.buffer.length; 3404 }, 3405 write: function (stream, buffer, offset, length, position) { 3406 var sock = stream.node.sock; 3407 return sock.sock_ops.sendmsg(sock, buffer, offset, length); 3408 }, 3409 close: function (stream) { 3410 var sock = stream.node.sock; 3411 sock.sock_ops.close(sock); 3412 }, 3413 }, 3414 nextname: function () { 3415 if (!SOCKFS.nextname.current) { 3416 SOCKFS.nextname.current = 0; 3417 } 3418 return "socket[" + SOCKFS.nextname.current++ + "]"; 3419 }, 3420 websocket_sock_ops: { 3421 createPeer: function (sock, addr, port) { 3422 var ws; 3423 if (typeof addr == "object") { 3424 ws = addr; 3425 addr = null; 3426 port = null; 3427 } 3428 if (ws) { 3429 if (ws._socket) { 3430 addr = ws._socket.remoteAddress; 3431 port = ws._socket.remotePort; 3432 } else { 3433 var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url); 3434 if (!result) { 3435 throw new Error( 3436 "WebSocket URL must be in the format ws(s)://address:port", 3437 ); 3438 } 3439 addr = result[1]; 3440 port = parseInt(result[2], 10); 3441 } 3442 } else { 3443 try { 3444 var runtimeConfig = 3445 Module["websocket"] && "object" === typeof Module["websocket"]; 3446 var url = "ws:#".replace("#", "//"); 3447 if (runtimeConfig) { 3448 if ("string" === typeof Module["websocket"]["url"]) { 3449 url = Module["websocket"]["url"]; 3450 } 3451 } 3452 if (url === "ws://" || url === "wss://") { 3453 var parts = addr.split("/"); 3454 url =
3455 url + parts[0] + ":" + port + "/" + parts.slice(1).join("/"); 3456 } 3457 var subProtocols = "binary"; 3458 if (runtimeConfig) { 3459 if ("string" === typeof Module["websocket"]["subprotocol"]) { 3460 subProtocols = Module["websocket"]["subprotocol"]; 3461 } 3462 } 3463 var opts = undefined; 3464 if (subProtocols !== "null") { 3465 subProtocols = subProtocols 3466 .replace(/^ +| +$/g, "") 3467 .split(/ *, */); 3468 opts = subProtocols; 3469 } 3470 if ( 3471 runtimeConfig && 3472 null === Module["websocket"]["subprotocol"] 3473 ) { 3474 subProtocols = "null"; 3475 opts = undefined; 3476 } 3477 var WebSocketConstructor; 3478 { 3479 WebSocketConstructor = WebSocket; 3480 } 3481 ws = new WebSocketConstructor(url, opts); 3482 ws.binaryType = "arraybuffer"; 3483 } catch (e) { 3484 throw new FS.ErrnoError(23); 3485 } 3486 } 3487 var peer = { 3488 addr: addr, 3489 port: port, 3490 socket: ws, 3491 dgram_send_queue: [], 3492 }; 3493 SOCKFS.websocket_sock_ops.addPeer(sock, peer); 3494 SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer); 3495 if (sock.type === 2 && typeof sock.sport != "undefined") { 3496 peer.dgram_send_queue.push( 3497 new Uint8Array([ 3498 255, 3499 255, 3500 255, 3501 255, 3502 "p".charCodeAt(0), 3503 "o".charCodeAt(0), 3504 "r".charCodeAt(0), 3505 "t".charCodeAt(0), 3506 (sock.sport & 65280) >> 8, 3507 sock.sport & 255, 3508 ]), 3509 ); 3510 } 3511 return peer; 3512 }, 3513 getPeer: function (sock, addr, port) { 3514 return sock.peers[addr + ":" + port]; 3515 }, 3516 addPeer: function (sock, peer) { 3517 sock.peers[peer.addr + ":" + peer.port] = peer; 3518 }, 3519 removePeer: function (sock, peer) { 3520 delete sock.peers[peer.addr + ":" + peer.port]; 3521 }, 3522 handlePeerEvents: function (sock, peer) { 3523 var first = true; 3524 var handleOpen = function () { 3525 Module["websocket"].emit("open", sock.stream.fd); 3526 try { 3527 var queued = peer.dgram_send_queue.shift(); 3528 while (queued) { 3529 peer.socket.send(queued); 3530 queued = peer.dgram_send_queue.shift(); 3531 } 3532 } catch (e) { 3533 peer.socket.close(); 3534 } 3535 }; 3536 function handleMessage(data) { 3537 if (typeof data == "string") { 3538 var encoder = new TextEncoder();
3539 data = encoder.encode(data); 3540 } else { 3541 assert(data.byteLength !== undefined); 3542 if (data.byteLength == 0) { 3543 return; 3544 } 3545 data = new Uint8Array(data); 3546 } 3547 var wasfirst = first; 3548 first = false; 3549 if ( 3550 wasfirst && 3551 data.length === 10 && 3552 data[0] === 255 && 3553 data[1] === 255 && 3554 data[2] === 255 && 3555 data[3] === 255 && 3556 data[4] === "p".charCodeAt(0) && 3557 data[5] === "o".charCodeAt(0) && 3558 data[6] === "r".charCodeAt(0) && 3559 data[7] === "t".charCodeAt(0) 3560 ) { 3561 var newport = (data[8] << 8) | data[9]; 3562 SOCKFS.websocket_sock_ops.removePeer(sock, peer); 3563 peer.port = newport; 3564 SOCKFS.websocket_sock_ops.addPeer(sock, peer); 3565 return; 3566 } 3567 sock.recv_queue.push({ 3568 addr: peer.addr, 3569 port: peer.port, 3570 data: data, 3571 }); 3572 Module["websocket"].emit("message", sock.stream.fd); 3573 } 3574 if (ENVIRONMENT_IS_NODE) { 3575 peer.socket.on("open", handleOpen); 3576 peer.socket.on("message", function (data, isBinary) { 3577 if (!isBinary) { 3578 return; 3579 } 3580 handleMessage(new Uint8Array(data).buffer); 3581 }); 3582 peer.socket.on("close", function () { 3583 Module["websocket"].emit("close", sock.stream.fd); 3584 }); 3585 peer.socket.on("error", function (error) { 3586 sock.error = 14; 3587 Module["websocket"].emit("error", [ 3588 sock.stream.fd, 3589 sock.error, 3590 "ECONNREFUSED: Connection refused", 3591 ]); 3592 }); 3593 } else { 3594 peer.socket.onopen = handleOpen; 3595 peer.socket.onclose = function () { 3596 Module["websocket"].emit("close", sock.stream.fd); 3597 }; 3598 peer.socket.onmessage = function peer_socket_onmessage(event) { 3599 handleMessage(event.data); 3600 }; 3601 peer.socket.onerror = function (error) { 3602 sock.error = 14; 3603 Module["websocket"].emit("error", [ 3604 sock.stream.fd, 3605 sock.error, 3606 "ECONNREFUSED: Connection refused", 3607 ]); 3608 }; 3609 } 3610 }, 3611 poll: function (sock) { 3612 if (sock.type === 1 && sock.server) { 3613 return sock.pending.length ? 64 | 1 : 0; 3614 } 3615 var mask = 0; 3616 var dest = 3617 sock.type === 1 3618 ? SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport) 3619 : null; 3620 if ( 3621 sock.recv_queue.length || 3622 !dest || 3623 (dest && dest.socket.readyState === dest.socket.CLOSING) || 3624 (dest && dest.socket.readyState === dest.socket.CLOSED) 3625 ) { 3626 mask |= 64 | 1; 3627 } 3628 if (!dest || (dest && dest.socket.readyState === dest.socket.OPEN)) { 3629 mask |= 4; 3630 } 3631 if ( 3632 (dest && dest.socket.readyState === dest.socket.CLOSING) || 3633 (dest && dest.socket.readyState === dest.socket.CLOSED) 3634 ) { 3635 mask |= 16; 3636 } 3637 return mask; 3638 }, 3639 ioctl: function (sock, request, arg) { 3640 switch (request) { 3641 case 21531: 3642 var bytes = 0; 3643 if (sock.recv_queue.length) { 3644 bytes = sock.recv_queue[0].data.length; 3645 } 3646 HEAP32[arg >> 2] = bytes; 3647 return 0; 3648 default: 3649 return 28; 3650 } 3651 }, 3652 close: function (sock) { 3653 if (sock.server) { 3654 try { 3655 sock.server.close(); 3656 } catch (e) {} 3657 sock.server = null; 3658 } 3659 var peers = Object.keys(sock.peers); 3660 for (var i = 0; i < peers.length; i++) { 3661 var peer = sock.peers[peers[i]]; 3662 try { 3663 peer.socket.close(); 3664 } catch (e) {} 3665 SOCKFS.websocket_sock_ops.removePeer(sock, peer); 3666 } 3667 return 0; 3668 }, 3669 bind: function (sock, addr, port) { 3670 if (
3671 typeof sock.saddr != "undefined" || 3672 typeof sock.sport != "undefined" 3673 ) { 3674 throw new FS.ErrnoError(28); 3675 } 3676 sock.saddr = addr; 3677 sock.sport = port; 3678 if (sock.type === 2) { 3679 if (sock.server) { 3680 sock.server.close(); 3681 sock.server = null; 3682 } 3683 try { 3684 sock.sock_ops.listen(sock, 0); 3685 } catch (e) { 3686 if (!(e.name === "ErrnoError")) throw e; 3687 if (e.errno !== 138) throw e; 3688 } 3689 } 3690 }, 3691 connect: function (sock, addr, port) { 3692 if (sock.server) { 3693 throw new FS.ErrnoError(138); 3694 } 3695 if ( 3696 typeof sock.daddr != "undefined" && 3697 typeof sock.dport != "undefined" 3698 ) { 3699 var dest = SOCKFS.websocket_sock_ops.getPeer( 3700 sock, 3701 sock.daddr, 3702 sock.dport, 3703 ); 3704 if (dest) { 3705 if (dest.socket.readyState === dest.socket.CONNECTING) { 3706 throw new FS.ErrnoError(7); 3707 } else { 3708 throw new FS.ErrnoError(30); 3709 } 3710 } 3711 } 3712 var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port); 3713 sock.daddr = peer.addr; 3714 sock.dport = peer.port; 3715 throw new FS.ErrnoError(26); 3716 }, 3717 listen: function (sock, backlog) { 3718 if (!ENVIRONMENT_IS_NODE) { 3719 throw new FS.ErrnoError(138); 3720 } 3721 }, 3722 accept: function (listensock) { 3723 if (!listensock.server || !listensock.pending.length) { 3724 throw new FS.ErrnoError(28); 3725 } 3726 var newsock = listensock.pending.shift(); 3727 newsock.stream.flags = listensock.stream.flags; 3728 return newsock; 3729 }, 3730 getname: function (sock, peer) { 3731 var addr, port; 3732 if (peer) { 3733 if (sock.daddr === undefined || sock.dport === undefined) { 3734 throw new FS.ErrnoError(53); 3735 } 3736 addr = sock.daddr; 3737 port = sock.dport; 3738 } else { 3739 addr = sock.saddr || 0; 3740 port = sock.sport || 0; 3741 } 3742 return { addr: addr, port: port }; 3743 }, 3744 sendmsg: function (sock, buffer, offset, length, addr, port) { 3745 if (sock.type === 2) { 3746 if (addr === undefined || port === undefined) { 3747 addr = sock.daddr; 3748 port = sock.dport; 3749 } 3750 if (addr === undefined || port === undefined) { 3751 throw new FS.ErrnoError(17); 3752 } 3753 } else { 3754 addr = sock.daddr; 3755 port = sock.dport; 3756 } 3757 var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr, port); 3758 if (sock.type === 1) { 3759 if ( 3760 !dest || 3761 dest.socket.readyState === dest.socket.CLOSING || 3762 dest.socket.readyState === dest.socket.CLOSED 3763 ) { 3764 throw new FS.ErrnoError(53); 3765 } else if (dest.socket.readyState === dest.socket.CONNECTING) { 3766 throw new FS.ErrnoError(6); 3767 } 3768 } 3769 if (ArrayBuffer.isView(buffer)) { 3770 offset += buffer.byteOffset; 3771 buffer = buffer.buffer; 3772 } 3773 var data; 3774 data = buffer.slice(offset, offset + length); 3775 if (sock.type === 2) { 3776 if (!dest || dest.socket.readyState !== dest.socket.OPEN) { 3777 if ( 3778 !dest || 3779 dest.socket.readyState === dest.socket.CLOSING || 3780 dest.socket.readyState === dest.socket.CLOSED 3781 ) { 3782 dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port); 3783 } 3784 dest.dgram_send_queue.push(data); 3785 return length; 3786 } 3787 } 3788 try { 3789 dest.socket.send(data); 3790 return length; 3791 } catch (e) { 3792 throw new FS.ErrnoError(28); 3793 } 3794 }, 3795 recvmsg: function (sock, length) { 3796 if (sock.type === 1 && sock.server) { 3797 throw new FS.ErrnoError(53); 3798 } 3799 var queued = sock.recv_queue.shift(); 3800 if (!queued) { 3801 if (sock.type === 1) { 3802 var dest = SOCKFS.websocket_sock_ops.getPeer( 3803 sock, 3804 sock.daddr, 3805 sock.dport, 3806 ); 3807 if (!dest) { 3808 throw new FS.ErrnoError(53); 3809 } 3810 if ( 3811 dest.socket.readyState === dest.socket.CLOSING || 3812 dest.socket.readyState === dest.socket.CLOSED 3813 ) { 3814 return null; 3815 } 3816 throw new FS.ErrnoError(6); 3817 } 3818 throw new FS.ErrnoError(6); 3819 } 3820 var queuedLength = queued.data.byteLength || queued.data.length; 3821 var queuedOffset = queued.data.byteOffset || 0; 3822 var queuedBuffer = queued.data.buffer || queued.data; 3823 var bytesRead = Math.min(length, queuedLength); 3824 var res = { 3825 buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead), 3826 addr: queued.addr, 3827 port: queued.port, 3828 }; 3829 if (sock.type === 1 && bytesRead < queuedLength) { 3830 var bytesRemaining = queuedLength - bytesRead; 3831 queued.data = new Uint8Array( 3832 queuedBuffer, 3833 queuedOffset + bytesRead, 3834 bytesRemaining, 3835 ); 3836 sock.recv_queue.unshift(queued); 3837 } 3838 return res; 3839 }, 3840 }, 3841 }; 3842 function getSocketFromFD(fd) { 3843 var socket = SOCKFS.getSocket(fd); 3844 if (!socket) throw new FS.ErrnoError(8); 3845 return socket; 3846 } 3847 function setErrNo(value) { 3848 HEAP32[___errno_location() >> 2] = value; 3849 return value; 3850 } 3851 function inetPton4(str) { 3852 var b = str.split("."); 3853 for (var i = 0; i < 4; i++) { 3854 var tmp = Number(b[i]); 3855 if (isNaN(tmp)) return null; 3856 b[i] = tmp; 3857 } 3858 return (b[0] | (b[1] << 8) | (b[2] << 16) | (b[3] << 24)) >>> 0; 3859 } 3860 function jstoi_q(str) { 3861 return parseInt(str); 3862 } 3863 function inetPton6(str) { 3864 var words; 3865 var w, offset, z;
3866 var valid6regx = 3867 /^((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\3)::|:\b|$))|(?!\2\3)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})$/i; 3868 var parts = []; 3869 if (!valid6regx.test(str)) { 3870 return null; 3871 } 3872 if (str === "::") { 3873 return [0, 0, 0, 0, 0, 0, 0, 0]; 3874 } 3875 if (str.startsWith("::")) { 3876 str = str.replace("::", "Z:"); 3877 } else { 3878 str = str.replace("::", ":Z:"); 3879 } 3880 if (str.indexOf(".") > 0) { 3881 str = str.replace(new RegExp("[.]", "g"), ":"); 3882 words = str.split(":"); 3883 words[words.length - 4] = 3884 jstoi_q(words[words.length - 4]) + 3885 jstoi_q(words[words.length - 3]) * 256; 3886 words[words.length - 3] = 3887 jstoi_q(words[words.length - 2]) + 3888 jstoi_q(words[words.length - 1]) * 256; 3889 words = words.slice(0, words.length - 2); 3890 } else { 3891 words = str.split(":"); 3892 } 3893 offset = 0; 3894 z = 0; 3895 for (w = 0; w < words.length; w++) { 3896 if (typeof words[w] == "string") { 3897 if (words[w] === "Z") { 3898 for (z = 0; z < 8 - words.length + 1; z++) { 3899 parts[w + z] = 0; 3900 } 3901 offset = z - 1; 3902 } else { 3903 parts[w + offset] = _htons(parseInt(words[w], 16)); 3904 } 3905 } else { 3906 parts[w + offset] = words[w]; 3907 } 3908 } 3909 return [ 3910 (parts[1] << 16) | parts[0], 3911 (parts[3] << 16) | parts[2], 3912 (parts[5] << 16) | parts[4], 3913 (parts[7] << 16) | parts[6], 3914 ]; 3915 } 3916 function writeSockaddr(sa, family, addr, port, addrlen) { 3917 switch (family) { 3918 case 2: 3919 addr = inetPton4(addr); 3920 zeroMemory(sa, 16); 3921 if (addrlen) { 3922 HEAP32[addrlen >> 2] = 16; 3923 } 3924 HEAP16[sa >> 1] = family; 3925 HEAP32[(sa + 4) >> 2] = addr; 3926 HEAP16[(sa + 2) >> 1] = _htons(port); 3927 break; 3928 case 10: 3929 addr = inetPton6(addr); 3930 zeroMemory(sa, 28); 3931 if (addrlen) { 3932 HEAP32[addrlen >> 2] = 28; 3933 } 3934 HEAP32[sa >> 2] = family; 3935 HEAP32[(sa + 8) >> 2] = addr[0]; 3936 HEAP32[(sa + 12) >> 2] = addr[1]; 3937 HEAP32[(sa + 16) >> 2] = addr[2]; 3938 HEAP32[(sa + 20) >> 2] = addr[3]; 3939 HEAP16[(sa + 2) >> 1] = _htons(port); 3940 break; 3941 default: 3942 return 5; 3943 } 3944 return 0; 3945 } 3946 var DNS = { 3947 address_map: { id: 1, addrs: {}, names: {} }, 3948 lookup_name: function (name) { 3949 var res = inetPton4(name); 3950 if (res !== null) { 3951 return name; 3952 } 3953 res = inetPton6(name); 3954 if (res !== null) { 3955 return name; 3956 } 3957 var addr; 3958 if (DNS.address_map.addrs[name]) { 3959 addr = DNS.address_map.addrs[name]; 3960 } else { 3961 var id = DNS.address_map.id++; 3962 assert(id < 65535, "exceeded max address mappings of 65535"); 3963 addr = "172.29." + (id & 255) + "." + (id & 65280); 3964 DNS.address_map.names[addr] = name; 3965 DNS.address_map.addrs[name] = addr; 3966 } 3967 return addr; 3968 }, 3969 lookup_addr: function (addr) { 3970 if (DNS.address_map.names[addr]) { 3971 return DNS.address_map.names[addr]; 3972 } 3973 return null; 3974 }, 3975 }; 3976 function ___syscall_accept4(fd, addr, addrlen, flags, d1, d2) { 3977 try { 3978 var sock = getSocketFromFD(fd); 3979 var newsock = sock.sock_ops.accept(sock); 3980 if (addr) { 3981 var errno = writeSockaddr( 3982 addr, 3983 newsock.family, 3984 DNS.lookup_name(newsock.daddr), 3985 newsock.dport, 3986 addrlen, 3987 ); 3988 } 3989 return newsock.stream.fd; 3990 } catch (e) { 3991 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 3992 return -e.errno; 3993 } 3994 } 3995 function inetNtop4(addr) { 3996 return ( 3997 (addr & 255) + 3998 "." + 3999 ((addr >> 8) & 255) + 4000 "." + 4001 ((addr >> 16) & 255) + 4002 "." + 4003 ((addr >> 24) & 255) 4004 ); 4005 } 4006 function inetNtop6(ints) { 4007 var str = ""; 4008 var word = 0; 4009 var longest = 0; 4010 var lastzero = 0; 4011 var zstart = 0; 4012 var len = 0; 4013 var i = 0; 4014 var parts = [ 4015 ints[0] & 65535, 4016 ints[0] >> 16, 4017 ints[1] & 65535, 4018 ints[1] >> 16, 4019 ints[2] & 65535, 4020 ints[2] >> 16, 4021 ints[3] & 65535, 4022 ints[3] >> 16, 4023 ]; 4024 var hasipv4 = true; 4025 var v4part = ""; 4026 for (i = 0; i < 5; i++) { 4027 if (parts[i] !== 0) { 4028 hasipv4 = false;
4029 break; 4030 } 4031 } 4032 if (hasipv4) { 4033 v4part = inetNtop4(parts[6] | (parts[7] << 16)); 4034 if (parts[5] === -1) { 4035 str = "::ffff:"; 4036 str += v4part; 4037 return str; 4038 } 4039 if (parts[5] === 0) { 4040 str = "::"; 4041 if (v4part === "0.0.0.0") v4part = ""; 4042 if (v4part === "0.0.0.1") v4part = "1"; 4043 str += v4part; 4044 return str; 4045 } 4046 } 4047 for (word = 0; word < 8; word++) { 4048 if (parts[word] === 0) { 4049 if (word - lastzero > 1) { 4050 len = 0; 4051 } 4052 lastzero = word; 4053 len++; 4054 } 4055 if (len > longest) { 4056 longest = len; 4057 zstart = word - longest + 1; 4058 } 4059 } 4060 for (word = 0; word < 8; word++) { 4061 if (longest > 1) { 4062 if (parts[word] === 0 && word >= zstart && word < zstart + longest) { 4063 if (word === zstart) { 4064 str += ":"; 4065 if (zstart === 0) str += ":"; 4066 } 4067 continue; 4068 } 4069 } 4070 str += Number(_ntohs(parts[word] & 65535)).toString(16); 4071 str += word < 7 ? ":" : ""; 4072 } 4073 return str; 4074 } 4075 function readSockaddr(sa, salen) { 4076 var family = HEAP16[sa >> 1]; 4077 var port = _ntohs(HEAPU16[(sa + 2) >> 1]); 4078 var addr; 4079 switch (family) { 4080 case 2: 4081 if (salen !== 16) { 4082 return { errno: 28 }; 4083 } 4084 addr = HEAP32[(sa + 4) >> 2]; 4085 addr = inetNtop4(addr); 4086 break; 4087 case 10: 4088 if (salen !== 28) { 4089 return { errno: 28 }; 4090 } 4091 addr = [ 4092 HEAP32[(sa + 8) >> 2], 4093 HEAP32[(sa + 12) >> 2], 4094 HEAP32[(sa + 16) >> 2], 4095 HEAP32[(sa + 20) >> 2], 4096 ]; 4097 addr = inetNtop6(addr); 4098 break; 4099 default: 4100 return { errno: 5 }; 4101 } 4102 return { family: family, addr: addr, port: port }; 4103 } 4104 function getSocketAddress(addrp, addrlen, allowNull) { 4105 if (allowNull && addrp === 0) return null; 4106 var info = readSockaddr(addrp, addrlen); 4107 if (info.errno) throw new FS.ErrnoError(info.errno); 4108 info.addr = DNS.lookup_addr(info.addr) || info.addr; 4109 return info; 4110 } 4111 function ___syscall_bind(fd, addr, addrlen, d1, d2, d3) { 4112 try { 4113 var sock = getSocketFromFD(fd); 4114 var info = getSocketAddress(addr, addrlen); 4115 sock.sock_ops.bind(sock, info.addr, info.port); 4116 return 0; 4117 } catch (e) { 4118 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4119 return -e.errno; 4120 } 4121 } 4122 function ___syscall_connect(fd, addr, addrlen, d1, d2, d3) { 4123 try { 4124 var sock = getSocketFromFD(fd); 4125 var info = getSocketAddress(addr, addrlen); 4126 sock.sock_ops.connect(sock, info.addr, info.port); 4127 return 0; 4128 } catch (e) { 4129 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4130 return -e.errno; 4131 } 4132 } 4133 function ___syscall_faccessat(dirfd, path, amode, flags) { 4134 try { 4135 path = SYSCALLS.getStr(path); 4136 path = SYSCALLS.calculateAt(dirfd, path); 4137 if (amode & ~7) { 4138 return -28; 4139 } 4140 var lookup = FS.lookupPath(path, { follow: true }); 4141 var node = lookup.node; 4142 if (!node) { 4143 return -44; 4144 } 4145 var perms = ""; 4146 if (amode & 4) perms += "r"; 4147 if (amode & 2) perms += "w"; 4148 if (amode & 1) perms += "x"; 4149 if (perms && FS.nodePermissions(node, perms)) { 4150 return -2; 4151 } 4152 return 0; 4153 } catch (e) { 4154 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4155 return -e.errno; 4156 } 4157 } 4158 function ___syscall_fcntl64(fd, cmd, varargs) { 4159 SYSCALLS.varargs = varargs; 4160 try { 4161 var stream = SYSCALLS.getStreamFromFD(fd); 4162 switch (cmd) { 4163 case 0: { 4164 var arg = SYSCALLS.get(); 4165 if (arg < 0) { 4166 return -28; 4167 } 4168 var newStream; 4169 newStream = FS.createStream(stream, arg); 4170 return newStream.fd; 4171 } 4172 case 1: 4173 case 2: 4174 return 0; 4175 case 3: 4176 return stream.flags; 4177 case 4: { 4178 var arg = SYSCALLS.get(); 4179 stream.flags |= arg; 4180 return 0; 4181 } 4182 case 5: { 4183 var arg = SYSCALLS.get(); 4184 var offset = 0; 4185 HEAP16[(arg + offset) >> 1] = 2; 4186 return 0; 4187 } 4188 case 6: 4189 case 7: 4190 return 0; 4191 case 16: 4192 case 8: 4193 return -28; 4194 case 9: 4195 setErrNo(28); 4196 return -1; 4197 default: { 4198 return -28; 4199 } 4200 } 4201 } catch (e) {
4202 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4203 return -e.errno; 4204 } 4205 } 4206 function ___syscall_fstat64(fd, buf) { 4207 try { 4208 var stream = SYSCALLS.getStreamFromFD(fd); 4209 return SYSCALLS.doStat(FS.stat, stream.path, buf); 4210 } catch (e) { 4211 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4212 return -e.errno; 4213 } 4214 } 4215 function stringToUTF8(str, outPtr, maxBytesToWrite) { 4216 return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite); 4217 } 4218 function ___syscall_getdents64(fd, dirp, count) { 4219 try { 4220 var stream = SYSCALLS.getStreamFromFD(fd); 4221 if (!stream.getdents) { 4222 stream.getdents = FS.readdir(stream.path); 4223 } 4224 var struct_size = 280; 4225 var pos = 0; 4226 var off = FS.llseek(stream, 0, 1); 4227 var idx = Math.floor(off / struct_size); 4228 while (idx < stream.getdents.length && pos + struct_size <= count) { 4229 var id; 4230 var type; 4231 var name = stream.getdents[idx]; 4232 if (name === ".") { 4233 id = stream.node.id; 4234 type = 4; 4235 } else if (name === "..") { 4236 var lookup = FS.lookupPath(stream.path, { parent: true }); 4237 id = lookup.node.id; 4238 type = 4; 4239 } else { 4240 var child = FS.lookupNode(stream.node, name); 4241 id = child.id; 4242 type = FS.isChrdev(child.mode) 4243 ? 2 4244 : FS.isDir(child.mode) 4245 ? 4 4246 : FS.isLink(child.mode) 4247 ? 10 4248 : 8; 4249 } 4250 HEAP64[(dirp + pos) >> 3] = BigInt(id); 4251 HEAP64[(dirp + pos + 8) >> 3] = BigInt((idx + 1) * struct_size); 4252 HEAP16[(dirp + pos + 16) >> 1] = 280; 4253 HEAP8[(dirp + pos + 18) >> 0] = type; 4254 stringToUTF8(name, dirp + pos + 19, 256); 4255 pos += struct_size; 4256 idx += 1; 4257 } 4258 FS.llseek(stream, idx * struct_size, 0); 4259 return pos; 4260 } catch (e) { 4261 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4262 return -e.errno; 4263 } 4264 } 4265 function ___syscall_getpeername(fd, addr, addrlen, d1, d2, d3) { 4266 try { 4267 var sock = getSocketFromFD(fd); 4268 if (!sock.daddr) { 4269 return -53; 4270 } 4271 var errno = writeSockaddr( 4272 addr, 4273 sock.family, 4274 DNS.lookup_name(sock.daddr), 4275 sock.dport, 4276 addrlen, 4277 ); 4278 return 0; 4279 } catch (e) { 4280 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4281 return -e.errno; 4282 } 4283 } 4284 function ___syscall_getsockname(fd, addr, addrlen, d1, d2, d3) { 4285 try { 4286 var sock = getSocketFromFD(fd); 4287 var errno = writeSockaddr( 4288 addr, 4289 sock.family, 4290 DNS.lookup_name(sock.saddr || "0.0.0.0"), 4291 sock.sport, 4292 addrlen, 4293 ); 4294 return 0; 4295 } catch (e) { 4296 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4297 return -e.errno; 4298 } 4299 } 4300 function ___syscall_getsockopt(fd, level, optname, optval, optlen, d1) { 4301 try { 4302 var sock = getSocketFromFD(fd); 4303 if (level === 1) { 4304 if (optname === 4) { 4305 HEAP32[optval >> 2] = sock.error; 4306 HEAP32[optlen >> 2] = 4; 4307 sock.error = null; 4308 return 0; 4309 } 4310 } 4311 return -50; 4312 } catch (e) { 4313 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4314 return -e.errno; 4315 } 4316 } 4317 function ___syscall_ioctl(fd, op, varargs) { 4318 SYSCALLS.varargs = varargs; 4319 try { 4320 var stream = SYSCALLS.getStreamFromFD(fd); 4321 switch (op) { 4322 case 21509: 4323 case 21505: { 4324 if (!stream.tty) return -59; 4325 return 0; 4326 } 4327 case 21510: 4328 case 21511: 4329 case 21512: 4330 case 21506: 4331 case 21507: 4332 case 21508: { 4333 if (!stream.tty) return -59; 4334 return 0; 4335 } 4336 case 21519: { 4337 if (!stream.tty) return -59; 4338 var argp = SYSCALLS.get(); 4339 HEAP32[argp >> 2] = 0; 4340 return 0; 4341 } 4342 case 21520: { 4343 if (!stream.tty) return -59; 4344 return -28; 4345 } 4346 case 21531: { 4347 var argp = SYSCALLS.get(); 4348 return FS.ioctl(stream, op, argp); 4349 } 4350 case 21523: { 4351 if (!stream.tty) return -59; 4352 return 0; 4353 } 4354 case 21524: { 4355 if (!stream.tty) return -59; 4356 return 0; 4357 } 4358 default: 4359 return -28; 4360 } 4361 } catch (e) {
4362 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4363 return -e.errno; 4364 } 4365 } 4366 function ___syscall_listen(fd, backlog) { 4367 try { 4368 var sock = getSocketFromFD(fd); 4369 sock.sock_ops.listen(sock, backlog); 4370 return 0; 4371 } catch (e) { 4372 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4373 return -e.errno; 4374 } 4375 } 4376 function ___syscall_lstat64(path, buf) { 4377 try { 4378 path = SYSCALLS.getStr(path); 4379 return SYSCALLS.doStat(FS.lstat, path, buf); 4380 } catch (e) { 4381 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4382 return -e.errno; 4383 } 4384 } 4385 function ___syscall_mkdirat(dirfd, path, mode) { 4386 try { 4387 path = SYSCALLS.getStr(path); 4388 path = SYSCALLS.calculateAt(dirfd, path); 4389 path = PATH.normalize(path); 4390 if (path[path.length - 1] === "/") 4391 path = path.substr(0, path.length - 1); 4392 FS.mkdir(path, mode, 0); 4393 return 0; 4394 } catch (e) { 4395 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4396 return -e.errno; 4397 } 4398 } 4399 function ___syscall_newfstatat(dirfd, path, buf, flags) { 4400 try { 4401 path = SYSCALLS.getStr(path); 4402 var nofollow = flags & 256; 4403 var allowEmpty = flags & 4096; 4404 flags = flags & ~6400; 4405 path = SYSCALLS.calculateAt(dirfd, path, allowEmpty); 4406 return SYSCALLS.doStat(nofollow ? FS.lstat : FS.stat, path, buf); 4407 } catch (e) { 4408 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4409 return -e.errno; 4410 } 4411 }
4412 function ___syscall_openat(dirfd, path, flags, varargs) { 4413 SYSCALLS.varargs = varargs; 4414 try { 4415 path = SYSCALLS.getStr(path); 4416 path = SYSCALLS.calculateAt(dirfd, path); 4417 var mode = varargs ? SYSCALLS.get() : 0; 4418 return FS.open(path, flags, mode).fd; 4419 } catch (e) { 4420 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4421 return -e.errno; 4422 } 4423 } 4424 function ___syscall_poll(fds, nfds, timeout) { 4425 try { 4426 var nonzero = 0; 4427 for (var i = 0; i < nfds; i++) { 4428 var pollfd = fds + 8 * i; 4429 var fd = HEAP32[pollfd >> 2]; 4430 var events = HEAP16[(pollfd + 4) >> 1]; 4431 var mask = 32; 4432 var stream = FS.getStream(fd); 4433 if (stream) { 4434 mask = SYSCALLS.DEFAULT_POLLMASK; 4435 if (stream.stream_ops.poll) { 4436 mask = stream.stream_ops.poll(stream); 4437 } 4438 } 4439 mask &= events | 8 | 16; 4440 if (mask) nonzero++; 4441 HEAP16[(pollfd + 6) >> 1] = mask; 4442 } 4443 return nonzero; 4444 } catch (e) { 4445 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4446 return -e.errno; 4447 } 4448 } 4449 function ___syscall_recvfrom(fd, buf, len, flags, addr, addrlen) { 4450 try { 4451 var sock = getSocketFromFD(fd); 4452 var msg = sock.sock_ops.recvmsg(sock, len); 4453 if (!msg) return 0; 4454 if (addr) { 4455 var errno = writeSockaddr( 4456 addr, 4457 sock.family, 4458 DNS.lookup_name(msg.addr), 4459 msg.port, 4460 addrlen, 4461 ); 4462 } 4463 HEAPU8.set(msg.buffer, buf); 4464 return msg.buffer.byteLength; 4465 } catch (e) { 4466 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4467 return -e.errno; 4468 } 4469 } 4470 function ___syscall_renameat(olddirfd, oldpath, newdirfd, newpath) { 4471 try { 4472 oldpath = SYSCALLS.getStr(oldpath); 4473 newpath = SYSCALLS.getStr(newpath); 4474 oldpath = SYSCALLS.calculateAt(olddirfd, oldpath); 4475 newpath = SYSCALLS.calculateAt(newdirfd, newpath); 4476 FS.rename(oldpath, newpath); 4477 return 0; 4478 } catch (e) { 4479 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4480 return -e.errno; 4481 } 4482 } 4483 function ___syscall_rmdir(path) { 4484 try { 4485 path = SYSCALLS.getStr(path); 4486 FS.rmdir(path); 4487 return 0; 4488 } catch (e) { 4489 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4490 return -e.errno; 4491 } 4492 } 4493 function ___syscall_sendto(fd, message, length, flags, addr, addr_len) { 4494 try { 4495 var sock = getSocketFromFD(fd); 4496 var dest = getSocketAddress(addr, addr_len, true); 4497 if (!dest) { 4498 return FS.write(sock.stream, HEAP8, message, length); 4499 } 4500 return sock.sock_ops.sendmsg( 4501 sock, 4502 HEAP8, 4503 message, 4504 length, 4505 dest.addr, 4506 dest.port, 4507 ); 4508 } catch (e) { 4509 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4510 return -e.errno; 4511 } 4512 } 4513 function ___syscall_socket(domain, type, protocol) { 4514 try { 4515 var sock = SOCKFS.createSocket(domain, type, protocol); 4516 return sock.stream.fd; 4517 } catch (e) { 4518 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4519 return -e.errno; 4520 } 4521 } 4522 function ___syscall_stat64(path, buf) { 4523 try { 4524 path = SYSCALLS.getStr(path); 4525 return SYSCALLS.doStat(FS.stat, path, buf); 4526 } catch (e) { 4527 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4528 return -e.errno; 4529 } 4530 } 4531 function ___syscall_unlinkat(dirfd, path, flags) { 4532 try { 4533 path = SYSCALLS.getStr(path); 4534 path = SYSCALLS.calculateAt(dirfd, path); 4535 if (flags === 0) { 4536 FS.unlink(path); 4537 } else if (flags === 512) { 4538 FS.rmdir(path); 4539 } else { 4540 abort("Invalid flags passed to unlinkat"); 4541 } 4542 return 0; 4543 } catch (e) {
4544 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4545 return -e.errno; 4546 } 4547 } 4548 var nowIsMonotonic = true; 4549 function __emscripten_get_now_is_monotonic() { 4550 return nowIsMonotonic; 4551 } 4552 function __emscripten_throw_longjmp() { 4553 throw Infinity; 4554 } 4555 function readI53FromI64(ptr) { 4556 return HEAPU32[ptr >> 2] + HEAP32[(ptr + 4) >> 2] * 4294967296; 4557 } 4558 function __gmtime_js(time, tmPtr) { 4559 var date = new Date(readI53FromI64(time) * 1e3); 4560 HEAP32[tmPtr >> 2] = date.getUTCSeconds(); 4561 HEAP32[(tmPtr + 4) >> 2] = date.getUTCMinutes(); 4562 HEAP32[(tmPtr + 8) >> 2] = date.getUTCHours(); 4563 HEAP32[(tmPtr + 12) >> 2] = date.getUTCDate(); 4564 HEAP32[(tmPtr + 16) >> 2] = date.getUTCMonth(); 4565 HEAP32[(tmPtr + 20) >> 2] = date.getUTCFullYear() - 1900; 4566 HEAP32[(tmPtr + 24) >> 2] = date.getUTCDay(); 4567 var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0); 4568 var yday = ((date.getTime() - start) / (1e3 * 60 * 60 * 24)) | 0; 4569 HEAP32[(tmPtr + 28) >> 2] = yday; 4570 } 4571 function isLeapYear(year) { 4572 return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0); 4573 } 4574 var MONTH_DAYS_LEAP_CUMULATIVE = [ 4575 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 4576 ]; 4577 var MONTH_DAYS_REGULAR_CUMULATIVE = [ 4578 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 4579 ]; 4580 function ydayFromDate(date) { 4581 var leap = isLeapYear(date.getFullYear()); 4582 var monthDaysCumulative = leap 4583 ? MONTH_DAYS_LEAP_CUMULATIVE 4584 : MONTH_DAYS_REGULAR_CUMULATIVE; 4585 var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1; 4586 return yday; 4587 } 4588 function __localtime_js(time, tmPtr) { 4589 var date = new Date(readI53FromI64(time) * 1e3); 4590 HEAP32[tmPtr >> 2] = date.getSeconds(); 4591 HEAP32[(tmPtr + 4) >> 2] = date.getMinutes(); 4592 HEAP32[(tmPtr + 8) >> 2] = date.getHours(); 4593 HEAP32[(tmPtr + 12) >> 2] = date.getDate(); 4594 HEAP32[(tmPtr + 16) >> 2] = date.getMonth(); 4595 HEAP32[(tmPtr + 20) >> 2] = date.getFullYear() - 1900; 4596 HEAP32[(tmPtr + 24) >> 2] = date.getDay(); 4597 var yday = ydayFromDate(date) | 0; 4598 HEAP32[(tmPtr + 28) >> 2] = yday; 4599 HEAP32[(tmPtr + 36) >> 2] = -(date.getTimezoneOffset() * 60); 4600 var start = new Date(date.getFullYear(), 0, 1); 4601 var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset(); 4602 var winterOffset = start.getTimezoneOffset(); 4603 var dst = 4604 (summerOffset != winterOffset && 4605 date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0; 4606 HEAP32[(tmPtr + 32) >> 2] = dst; 4607 } 4608 function __mktime_js(tmPtr) { 4609 var date = new Date( 4610 HEAP32[(tmPtr + 20) >> 2] + 1900, 4611 HEAP32[(tmPtr + 16) >> 2], 4612 HEAP32[(tmPtr + 12) >> 2], 4613 HEAP32[(tmPtr + 8) >> 2], 4614 HEAP32[(tmPtr + 4) >> 2], 4615 HEAP32[tmPtr >> 2], 4616 0, 4617 ); 4618 var dst = HEAP32[(tmPtr + 32) >> 2]; 4619 var guessedOffset = date.getTimezoneOffset(); 4620 var start = new Date(date.getFullYear(), 0, 1); 4621 var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset(); 4622 var winterOffset = start.getTimezoneOffset(); 4623 var dstOffset = Math.min(winterOffset, summerOffset); 4624 if (dst < 0) { 4625 HEAP32[(tmPtr + 32) >> 2] = Number( 4626 summerOffset != winterOffset && dstOffset == guessedOffset, 4627 ); 4628 } else if (dst > 0 != (dstOffset == guessedOffset)) { 4629 var nonDstOffset = Math.max(winterOffset, summerOffset); 4630 var trueOffset = dst > 0 ? dstOffset : nonDstOffset; 4631 date.setTime(date.getTime() + (trueOffset - guessedOffset) * 6e4); 4632 } 4633 HEAP32[(tmPtr + 24) >> 2] = date.getDay(); 4634 var yday = ydayFromDate(date) | 0; 4635 HEAP32[(tmPtr + 28) >> 2] = yday; 4636 HEAP32[tmPtr >> 2] = date.getSeconds(); 4637 HEAP32[(tmPtr + 4) >> 2] = date.getMinutes(); 4638 HEAP32[(tmPtr + 8) >> 2] = date.getHours(); 4639 HEAP32[(tmPtr + 12) >> 2] = date.getDate(); 4640 HEAP32[(tmPtr + 16) >> 2] = date.getMonth(); 4641 HEAP32[(tmPtr + 20) >> 2] = date.getYear(); 4642 return (date.getTime() / 1e3) | 0; 4643 } 4644 function __mmap_js(len, prot, flags, fd, off, allocated, addr) {
4645 try { 4646 var stream = SYSCALLS.getStreamFromFD(fd); 4647 var res = FS.mmap(stream, len, off, prot, flags); 4648 var ptr = res.ptr; 4649 HEAP32[allocated >> 2] = res.allocated; 4650 HEAPU32[addr >> 2] = ptr; 4651 return 0; 4652 } catch (e) { 4653 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4654 return -e.errno; 4655 } 4656 } 4657 function __munmap_js(addr, len, prot, flags, fd, offset) { 4658 try { 4659 var stream = SYSCALLS.getStreamFromFD(fd); 4660 if (prot & 2) { 4661 SYSCALLS.doMsync(addr, stream, len, flags, offset); 4662 } 4663 FS.munmap(stream); 4664 } catch (e) { 4665 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4666 return -e.errno; 4667 } 4668 } 4669 function stringToNewUTF8(str) { 4670 var size = lengthBytesUTF8(str) + 1; 4671 var ret = _malloc(size); 4672 if (ret) stringToUTF8(str, ret, size); 4673 return ret; 4674 } 4675 function __tzset_js(timezone, daylight, tzname) { 4676 var currentYear = new Date().getFullYear(); 4677 var winter = new Date(currentYear, 0, 1); 4678 var summer = new Date(currentYear, 6, 1); 4679 var winterOffset = winter.getTimezoneOffset(); 4680 var summerOffset = summer.getTimezoneOffset(); 4681 var stdTimezoneOffset = Math.max(winterOffset, summerOffset); 4682 HEAPU32[timezone >> 2] = stdTimezoneOffset * 60; 4683 HEAP32[daylight >> 2] = Number(winterOffset != summerOffset); 4684 function extractZone(date) { 4685 var match = date.toTimeString().match(/\(([A-Za-z ]+)\)$/); 4686 return match ? match[1] : "GMT"; 4687 } 4688 var winterName = extractZone(winter); 4689 var summerName = extractZone(summer); 4690 var winterNamePtr = stringToNewUTF8(winterName); 4691 var summerNamePtr = stringToNewUTF8(summerName); 4692 if (summerOffset < winterOffset) { 4693 HEAPU32[tzname >> 2] = winterNamePtr; 4694 HEAPU32[(tzname + 4) >> 2] = summerNamePtr; 4695 } else { 4696 HEAPU32[tzname >> 2] = summerNamePtr; 4697 HEAPU32[(tzname + 4) >> 2] = winterNamePtr; 4698 } 4699 } 4700 function _abort() { 4701 abort(""); 4702 } 4703 Module["_abort"] = _abort; 4704 function _dlopen(handle) { 4705 abort(dlopenMissingError); 4706 } 4707 var readEmAsmArgsArray = []; 4708 function readEmAsmArgs(sigPtr, buf) { 4709 readEmAsmArgsArray.length = 0; 4710 var ch; 4711 buf >>= 2; 4712 while ((ch = HEAPU8[sigPtr++])) { 4713 buf += (ch != 105) & buf; 4714 readEmAsmArgsArray.push( 4715 ch == 105 ? HEAP32[buf] : (ch == 106 ? HEAP64 : HEAPF64)[buf++ >> 1], 4716 ); 4717 ++buf; 4718 } 4719 return readEmAsmArgsArray; 4720 } 4721 function runEmAsmFunction(code, sigPtr, argbuf) { 4722 var args = readEmAsmArgs(sigPtr, argbuf); 4723 return ASM_CONSTS[code].apply(null, args); 4724 } 4725 function _emscripten_asm_const_int(code, sigPtr, argbuf) { 4726 return runEmAsmFunction(code, sigPtr, argbuf); 4727 } 4728 function _emscripten_date_now() { 4729 return Date.now(); 4730 } 4731 function getHeapMax() { 4732 return 2147483648; 4733 } 4734 function _emscripten_get_heap_max() { 4735 return getHeapMax(); 4736 } 4737 var _emscripten_get_now; 4738 _emscripten_get_now = () => performance.now(); 4739 function _emscripten_memcpy_big(dest, src, num) { 4740 HEAPU8.copyWithin(dest, src, src + num); 4741 } 4742 function emscripten_realloc_buffer(size) { 4743 var b = wasmMemory.buffer; 4744 try { 4745 wasmMemory.grow((size - b.byteLength + 65535) >>> 16); 4746 updateMemoryViews(); 4747 return 1; 4748 } catch (e) {} 4749 } 4750 function _emscripten_resize_heap(requestedSize) { 4751 var oldSize = HEAPU8.length; 4752 requestedSize = requestedSize >>> 0; 4753 var maxHeapSize = getHeapMax(); 4754 if (requestedSize > maxHeapSize) { 4755 return false; 4756 } 4757 var alignUp = (x, multiple) => 4758 x + ((multiple - (x % multiple)) % multiple); 4759 for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { 4760 var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); 4761 overGrownHeapSize = Math.min( 4762 overGrownHeapSize, 4763 requestedSize + 100663296, 4764 ); 4765 var newSize = Math.min( 4766 maxHeapSize, 4767 alignUp(Math.max(requestedSize, overGrownHeapSize), 65536), 4768 ); 4769 var replacement = emscripten_realloc_buffer(newSize); 4770 if (replacement) { 4771 return true; 4772 } 4773 } 4774 return false;
4775 } 4776 var ENV = {}; 4777 function getExecutableName() { 4778 return thisProgram || "./this.program"; 4779 } 4780 function getEnvStrings() { 4781 if (!getEnvStrings.strings) { 4782 var lang = 4783 ( 4784 (typeof navigator == "object" && 4785 navigator.languages && 4786 navigator.languages[0]) || 4787 "C" 4788 ).replace("-", "_") + ".UTF-8"; 4789 var env = { 4790 USER: "web_user", 4791 LOGNAME: "web_user", 4792 PATH: "/", 4793 PWD: "/", 4794 HOME: "/home/web_user", 4795 LANG: lang, 4796 _: getExecutableName(), 4797 }; 4798 for (var x in ENV) { 4799 if (ENV[x] === undefined) delete env[x]; 4800 else env[x] = ENV[x]; 4801 } 4802 var strings = []; 4803 for (var x in env) { 4804 strings.push(`${x}=${env[x]}`); 4805 } 4806 getEnvStrings.strings = strings; 4807 } 4808 return getEnvStrings.strings; 4809 } 4810 function stringToAscii(str, buffer) { 4811 for (var i = 0; i < str.length; ++i) { 4812 HEAP8[buffer++ >> 0] = str.charCodeAt(i); 4813 } 4814 HEAP8[buffer >> 0] = 0; 4815 } 4816 function _environ_get(__environ, environ_buf) { 4817 var bufSize = 0;
4818 getEnvStrings().forEach(function (string, i) { 4819 var ptr = environ_buf + bufSize; 4820 HEAPU32[(__environ + i * 4) >> 2] = ptr; 4821 stringToAscii(string, ptr); 4822 bufSize += string.length + 1; 4823 }); 4824 return 0; 4825 } 4826 function _environ_sizes_get(penviron_count, penviron_buf_size) { 4827 var strings = getEnvStrings(); 4828 HEAPU32[penviron_count >> 2] = strings.length; 4829 var bufSize = 0; 4830 strings.forEach(function (string) { 4831 bufSize += string.length + 1; 4832 }); 4833 HEAPU32[penviron_buf_size >> 2] = bufSize; 4834 return 0; 4835 } 4836 function _proc_exit(code) { 4837 EXITSTATUS = code; 4838 if (!keepRuntimeAlive()) { 4839 if (Module["onExit"]) Module["onExit"](code); 4840 ABORT = true; 4841 } 4842 quit_(code, new ExitStatus(code)); 4843 } 4844 function exitJS(status, implicit) { 4845 EXITSTATUS = status; 4846 _proc_exit(status); 4847 } 4848 var _exit = exitJS; 4849 function _fd_close(fd) { 4850 try { 4851 var stream = SYSCALLS.getStreamFromFD(fd); 4852 FS.close(stream); 4853 return 0; 4854 } catch (e) { 4855 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4856 return e.errno; 4857 } 4858 } 4859 function _fd_fdstat_get(fd, pbuf) { 4860 try { 4861 var rightsBase = 0; 4862 var rightsInheriting = 0; 4863 var flags = 0; 4864 { 4865 var stream = SYSCALLS.getStreamFromFD(fd); 4866 var type = stream.tty 4867 ? 2 4868 : FS.isDir(stream.mode) 4869 ? 3 4870 : FS.isLink(stream.mode) 4871 ? 7 4872 : 4; 4873 } 4874 HEAP8[pbuf >> 0] = type; 4875 HEAP16[(pbuf + 2) >> 1] = flags; 4876 HEAP64[(pbuf + 8) >> 3] = BigInt(rightsBase); 4877 HEAP64[(pbuf + 16) >> 3] = BigInt(rightsInheriting); 4878 return 0; 4879 } catch (e) { 4880 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4881 return e.errno; 4882 } 4883 } 4884 function doReadv(stream, iov, iovcnt, offset) { 4885 var ret = 0; 4886 for (var i = 0; i < iovcnt; i++) { 4887 var ptr = HEAPU32[iov >> 2]; 4888 var len = HEAPU32[(iov + 4) >> 2]; 4889 iov += 8; 4890 var curr = FS.read(stream, HEAP8, ptr, len, offset); 4891 if (curr < 0) return -1; 4892 ret += curr; 4893 if (curr < len) break; 4894 if (typeof offset !== "undefined") { 4895 offset += curr; 4896 } 4897 } 4898 return ret; 4899 } 4900 function _fd_read(fd, iov, iovcnt, pnum) { 4901 try { 4902 var stream = SYSCALLS.getStreamFromFD(fd); 4903 var num = doReadv(stream, iov, iovcnt); 4904 HEAPU32[pnum >> 2] = num; 4905 return 0; 4906 } catch (e) { 4907 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4908 return e.errno; 4909 } 4910 } 4911 var MAX_INT53 = 9007199254740992; 4912 var MIN_INT53 = -9007199254740992; 4913 function bigintToI53Checked(num) { 4914 return num < MIN_INT53 || num > MAX_INT53 ? NaN : Number(num); 4915 } 4916 function _fd_seek(fd, offset, whence, newOffset) { 4917 try { 4918 offset = bigintToI53Checked(offset); 4919 if (isNaN(offset)) return 61; 4920 var stream = SYSCALLS.getStreamFromFD(fd); 4921 FS.llseek(stream, offset, whence); 4922 HEAP64[newOffset >> 3] = BigInt(stream.position); 4923 if (stream.getdents && offset === 0 && whence === 0) 4924 stream.getdents = null; 4925 return 0; 4926 } catch (e) { 4927 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4928 return e.errno; 4929 } 4930 } 4931 function doWritev(stream, iov, iovcnt, offset) { 4932 var ret = 0; 4933 for (var i = 0; i < iovcnt; i++) { 4934 var ptr = HEAPU32[iov >> 2]; 4935 var len = HEAPU32[(iov + 4) >> 2]; 4936 iov += 8; 4937 var curr = FS.write(stream, HEAP8, ptr, len, offset); 4938 if (curr < 0) return -1; 4939 ret += curr; 4940 if (typeof offset !== "undefined") { 4941 offset += curr; 4942 } 4943 } 4944 return ret; 4945 } 4946 function _fd_write(fd, iov, iovcnt, pnum) { 4947 try { 4948 var stream = SYSCALLS.getStreamFromFD(fd); 4949 var num = doWritev(stream, iov, iovcnt); 4950 HEAPU32[pnum >> 2] = num; 4951 return 0; 4952 } catch (e) {
4953 if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; 4954 return e.errno; 4955 } 4956 } 4957 function _getaddrinfo(node, service, hint, out) { 4958 var addr = 0; 4959 var port = 0; 4960 var flags = 0; 4961 var family = 0; 4962 var type = 0; 4963 var proto = 0; 4964 var ai; 4965 function allocaddrinfo(family, type, proto, canon, addr, port) { 4966 var sa, salen, ai; 4967 var errno; 4968 salen = family === 10 ? 28 : 16; 4969 addr = family === 10 ? inetNtop6(addr) : inetNtop4(addr); 4970 sa = _malloc(salen); 4971 errno = writeSockaddr(sa, family, addr, port); 4972 assert(!errno); 4973 ai = _malloc(32); 4974 HEAP32[(ai + 4) >> 2] = family; 4975 HEAP32[(ai + 8) >> 2] = type; 4976 HEAP32[(ai + 12) >> 2] = proto; 4977 HEAPU32[(ai + 24) >> 2] = canon; 4978 HEAPU32[(ai + 20) >> 2] = sa; 4979 if (family === 10) { 4980 HEAP32[(ai + 16) >> 2] = 28; 4981 } else { 4982 HEAP32[(ai + 16) >> 2] = 16; 4983 } 4984 HEAP32[(ai + 28) >> 2] = 0; 4985 return ai; 4986 } 4987 if (hint) { 4988 flags = HEAP32[hint >> 2]; 4989 family = HEAP32[(hint + 4) >> 2]; 4990 type = HEAP32[(hint + 8) >> 2]; 4991 proto = HEAP32[(hint + 12) >> 2]; 4992 } 4993 if (type && !proto) { 4994 proto = type === 2 ? 17 : 6; 4995 } 4996 if (!type && proto) { 4997 type = proto === 17 ? 2 : 1; 4998 } 4999 if (proto === 0) { 5000 proto = 6; 5001 } 5002 if (type === 0) { 5003 type = 1; 5004 } 5005 if (!node && !service) { 5006 return -2; 5007 } 5008 if (flags & ~(1 | 2 | 4 | 1024 | 8 | 16 | 32)) { 5009 return -1; 5010 } 5011 if (hint !== 0 && HEAP32[hint >> 2] & 2 && !node) { 5012 return -1; 5013 } 5014 if (flags & 32) { 5015 return -2; 5016 } 5017 if (type !== 0 && type !== 1 && type !== 2) { 5018 return -7; 5019 } 5020 if (family !== 0 && family !== 2 && family !== 10) { 5021 return -6; 5022 } 5023 if (service) { 5024 service = UTF8ToString(service); 5025 port = parseInt(service, 10); 5026 if (isNaN(port)) { 5027 if (flags & 1024) { 5028 return -2; 5029 } 5030 return -8; 5031 } 5032 } 5033 if (!node) { 5034 if (family === 0) { 5035 family = 2; 5036 } 5037 if ((flags & 1) === 0) { 5038 if (family === 2) { 5039 addr = _htonl(2130706433); 5040 } else { 5041 addr = [0, 0, 0, 1]; 5042 } 5043 } 5044 ai = allocaddrinfo(family, type, proto, null, addr, port); 5045 HEAPU32[out >> 2] = ai; 5046 return 0; 5047 } 5048 node = UTF8ToString(node); 5049 addr = inetPton4(node); 5050 if (addr !== null) { 5051 if (family === 0 || family === 2) { 5052 family = 2; 5053 } else if (family === 10 && flags & 8) { 5054 addr = [0, 0, _htonl(65535), addr]; 5055 family = 10; 5056 } else { 5057 return -2; 5058 } 5059 } else { 5060 addr = inetPton6(node); 5061 if (addr !== null) { 5062 if (family === 0 || family === 10) { 5063 family = 10; 5064 } else { 5065 return -2; 5066 } 5067 } 5068 } 5069 if (addr != null) { 5070 ai = allocaddrinfo(family, type, proto, node, addr, port); 5071 HEAPU32[out >> 2] = ai; 5072 return 0; 5073 } 5074 if (flags & 4) { 5075 return -2; 5076 } 5077 node = DNS.lookup_name(node); 5078 addr = inetPton4(node); 5079 if (family === 0) { 5080 family = 2; 5081 } else if (family === 10) { 5082 addr = [0, 0, _htonl(65535), addr]; 5083 } 5084 ai = allocaddrinfo(family, type, proto, null, addr, port); 5085 HEAPU32[out >> 2] = ai; 5086 return 0; 5087 } 5088 function _getnameinfo(sa, salen, node, nodelen, serv, servlen, flags) { 5089 var info = readSockaddr(sa, salen); 5090 if (info.errno) { 5091 return -6; 5092 } 5093 var port = info.port; 5094 var addr = info.addr; 5095 var overflowed = false; 5096 if (node && nodelen) { 5097 var lookup; 5098 if (flags & 1 || !(lookup = DNS.lookup_addr(addr))) { 5099 if (flags & 8) { 5100 return -2; 5101 } 5102 } else { 5103 addr = lookup; 5104 } 5105 var numBytesWrittenExclNull = stringToUTF8(addr, node, nodelen); 5106 if (numBytesWrittenExclNull + 1 >= nodelen) { 5107 overflowed = true; 5108 } 5109 } 5110 if (serv && servlen) { 5111 port = "" + port; 5112 var numBytesWrittenExclNull = stringToUTF8(port, serv, servlen); 5113 if (numBytesWrittenExclNull + 1 >= servlen) { 5114 overflowed = true; 5115 } 5116 } 5117 if (overflowed) { 5118 return -12; 5119 } 5120 return 0; 5121 } 5122 function arraySum(array, index) { 5123 var sum = 0; 5124 for (var i = 0; i <= index; sum += array[i++]) {} 5125 return sum; 5126 } 5127 var MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; 5128 var MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; 5129 function addDays(date, days) { 5130 var newDate = new Date(date.getTime()); 5131 while (days > 0) { 5132 var leap = isLeapYear(newDate.getFullYear()); 5133 var currentMonth = newDate.getMonth(); 5134 var daysInCurrentMonth = (leap ? MONTH_DAYS_LEAP : MONTH_DAYS_REGULAR)[ 5135 currentMonth 5136 ]; 5137 if (days > daysInCurrentMonth - newDate.getDate()) { 5138 days -= daysInCurrentMonth - newDate.getDate() + 1; 5139 newDate.setDate(1); 5140 if (currentMonth < 11) { 5141 newDate.setMonth(currentMonth + 1); 5142 } else { 5143 newDate.setMonth(0); 5144 newDate.setFullYear(newDate.getFullYear() + 1); 5145 } 5146 } else { 5147 newDate.setDate(newDate.getDate() + days); 5148 return newDate; 5149 } 5150 } 5151 return newDate; 5152 } 5153 function writeArrayToMemory(array, buffer) { 5154 HEAP8.set(array, buffer); 5155 } 5156 function _strftime(s, maxsize, format, tm) { 5157 var tm_zone = HEAP32[(tm + 40) >> 2]; 5158 var date = { 5159 tm_sec: HEAP32[tm >> 2], 5160 tm_min: HEAP32[(tm + 4) >> 2], 5161 tm_hour: HEAP32[(tm + 8) >> 2], 5162 tm_mday: HEAP32[(tm + 12) >> 2], 5163 tm_mon: HEAP32[(tm + 16) >> 2], 5164 tm_year: HEAP32[(tm + 20) >> 2], 5165 tm_wday: HEAP32[(tm + 24) >> 2], 5166 tm_yday: HEAP32[(tm + 28) >> 2], 5167 tm_isdst: HEAP32[(tm + 32) >> 2], 5168 tm_gmtoff: HEAP32[(tm + 36) >> 2], 5169 tm_zone: tm_zone ? UTF8ToString(tm_zone) : "", 5170 }; 5171 var pattern = UTF8ToString(format); 5172 var EXPANSION_RULES_1 = { 5173 "%c": "%a %b %d %H:%M:%S %Y", 5174 "%D": "%m/%d/%y", 5175 "%F": "%Y-%m-%d", 5176 "%h": "%b", 5177 "%r": "%I:%M:%S %p", 5178 "%R": "%H:%M", 5179 "%T": "%H:%M:%S", 5180 "%x": "%m/%d/%y", 5181 "%X": "%H:%M:%S", 5182 "%Ec": "%c", 5183 "%EC": "%C", 5184 "%Ex": "%m/%d/%y", 5185 "%EX": "%H:%M:%S", 5186 "%Ey": "%y", 5187 "%EY": "%Y", 5188 "%Od": "%d", 5189 "%Oe": "%e", 5190 "%OH": "%H", 5191 "%OI": "%I", 5192 "%Om": "%m", 5193 "%OM": "%M", 5194 "%OS": "%S", 5195 "%Ou": "%u", 5196 "%OU": "%U", 5197 "%OV": "%V", 5198 "%Ow": "%w", 5199 "%OW": "%W", 5200 "%Oy": "%y", 5201 }; 5202 for (var rule in EXPANSION_RULES_1) { 5203 pattern = pattern.replace( 5204 new RegExp(rule, "g"), 5205 EXPANSION_RULES_1[rule], 5206 ); 5207 } 5208 var WEEKDAYS = [ 5209 "Sunday", 5210 "Monday", 5211 "Tuesday", 5212 "Wednesday", 5213 "Thursday", 5214 "Friday", 5215 "Saturday", 5216 ]; 5217 var MONTHS = [ 5218 "January", 5219 "February", 5220 "March", 5221 "April", 5222 "May", 5223 "June", 5224 "July", 5225 "August", 5226 "September", 5227 "October", 5228 "November", 5229 "December", 5230 ]; 5231 function leadingSomething(value, digits, character) { 5232 var str = typeof value == "number" ? value.toString() : value || ""; 5233 while (str.length < digits) { 5234 str = character[0] + str; 5235 } 5236 return str; 5237 } 5238 function leadingNulls(value, digits) { 5239 return leadingSomething(value, digits, "0"); 5240 } 5241 function compareByDay(date1, date2) { 5242 function sgn(value) { 5243 return value < 0 ? -1 : value > 0 ? 1 : 0; 5244 } 5245 var compare; 5246 if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) { 5247 if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) { 5248 compare = sgn(date1.getDate() - date2.getDate()); 5249 } 5250 } 5251 return compare; 5252 } 5253 function getFirstWeekStartDate(janFourth) { 5254 switch (janFourth.getDay()) { 5255 case 0: 5256 return new Date(janFourth.getFullYear() - 1, 11, 29); 5257 case 1: 5258 return janFourth; 5259 case 2: 5260 return new Date(janFourth.getFullYear(), 0, 3); 5261 case 3: 5262 return new Date(janFourth.getFullYear(), 0, 2); 5263 case 4: 5264 return new Date(janFourth.getFullYear(), 0, 1); 5265 case 5: 5266 return new Date(janFourth.getFullYear() - 1, 11, 31); 5267 case 6: 5268 return new Date(janFourth.getFullYear() - 1, 11, 30); 5269 } 5270 } 5271 function getWeekBasedYear(date) { 5272 var thisDate = addDays( 5273 new Date(date.tm_year + 1900, 0, 1), 5274 date.tm_yday, 5275 ); 5276 var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4); 5277 var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4); 5278 var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); 5279 var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); 5280 if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) { 5281 if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) { 5282 return thisDate.getFullYear() + 1; 5283 } 5284 return thisDate.getFullYear(); 5285 } 5286 return thisDate.getFullYear() - 1; 5287 } 5288 var EXPANSION_RULES_2 = { 5289 "%a": function (date) { 5290 return WEEKDAYS[date.tm_wday].substring(0, 3); 5291 }, 5292 "%A": function (date) { 5293 return WEEKDAYS[date.tm_wday]; 5294 }, 5295 "%b": function (date) { 5296 return MONTHS[date.tm_mon].substring(0, 3); 5297 }, 5298 "%B": function (date) { 5299 return MONTHS[date.tm_mon]; 5300 }, 5301 "%C": function (date) { 5302 var year = date.tm_year + 1900; 5303 return leadingNulls((year / 100) | 0, 2); 5304 }, 5305 "%d": function (date) { 5306 return leadingNulls(date.tm_mday, 2); 5307 }, 5308 "%e": function (date) { 5309 return leadingSomething(date.tm_mday, 2, " "); 5310 }, 5311 "%g": function (date) { 5312 return getWeekBasedYear(date).toString().substring(2); 5313 }, 5314 "%G": function (date) { 5315 return getWeekBasedYear(date); 5316 }, 5317 "%H": function (date) { 5318 return leadingNulls(date.tm_hour, 2); 5319 }, 5320 "%I": function (date) { 5321 var twelveHour = date.tm_hour; 5322 if (twelveHour == 0) twelveHour = 12; 5323 else if (twelveHour > 12) twelveHour -= 12; 5324 return leadingNulls(twelveHour, 2); 5325 }, 5326 "%j": function (date) { 5327 return leadingNulls( 5328 date.tm_mday + 5329 arraySum( 5330 isLeapYear(date.tm_year + 1900) 5331 ? MONTH_DAYS_LEAP 5332 : MONTH_DAYS_REGULAR, 5333 date.tm_mon - 1, 5334 ), 5335 3, 5336 ); 5337 }, 5338 "%m": function (date) { 5339 return leadingNulls(date.tm_mon + 1, 2); 5340 }, 5341 "%M": function (date) { 5342 return leadingNulls(date.tm_min, 2); 5343 }, 5344 "%n": function () { 5345 return "\n"; 5346 }, 5347 "%p": function (date) { 5348 if (date.tm_hour >= 0 && date.tm_hour < 12) { 5349 return "AM"; 5350 } 5351 return "PM"; 5352 }, 5353 "%S": function (date) { 5354 return leadingNulls(date.tm_sec, 2); 5355 }, 5356 "%t": function () { 5357 return "\t"; 5358 }, 5359 "%u": function (date) { 5360 return date.tm_wday || 7; 5361 }, 5362 "%U": function (date) { 5363 var days = date.tm_yday + 7 - date.tm_wday; 5364 return leadingNulls(Math.floor(days / 7), 2); 5365 }, 5366 "%V": function (date) { 5367 var val = Math.floor( 5368 (date.tm_yday + 7 - ((date.tm_wday + 6) % 7)) / 7, 5369 ); 5370 if ((date.tm_wday + 371 - date.tm_yday - 2) % 7 <= 2) { 5371 val++; 5372 } 5373 if (!val) { 5374 val = 52; 5375 var dec31 = (date.tm_wday + 7 - date.tm_yday - 1) % 7; 5376 if ( 5377 dec31 == 4 || 5378 (dec31 == 5 && isLeapYear((date.tm_year % 400) - 1)) 5379 ) { 5380 val++; 5381 } 5382 } else if (val == 53) { 5383 var jan1 = (date.tm_wday + 371 - date.tm_yday) % 7; 5384 if (jan1 != 4 && (jan1 != 3 || !isLeapYear(date.tm_year))) val = 1; 5385 } 5386 return leadingNulls(val, 2); 5387 }, 5388 "%w": function (date) { 5389 return date.tm_wday; 5390 }, 5391 "%W": function (date) { 5392 var days = date.tm_yday + 7 - ((date.tm_wday + 6) % 7); 5393 return leadingNulls(Math.floor(days / 7), 2); 5394 }, 5395 "%y": function (date) { 5396 return (date.tm_year + 1900).toString().substring(2); 5397 }, 5398 "%Y": function (date) { 5399 return date.tm_year + 1900; 5400 }, 5401 "%z": function (date) { 5402 var off = date.tm_gmtoff; 5403 var ahead = off >= 0; 5404 off = Math.abs(off) / 60; 5405 off = (off / 60) * 100 + (off % 60); 5406 return (ahead ? "+" : "-") + String("0000" + off).slice(-4); 5407 }, 5408 "%Z": function (date) { 5409 return date.tm_zone; 5410 }, 5411 "%%": function () { 5412 return "%"; 5413 }, 5414 }; 5415 pattern = pattern.replace(/%%/g, "\0\0"); 5416 for (var rule in EXPANSION_RULES_2) { 5417 if (pattern.includes(rule)) { 5418 pattern = pattern.replace( 5419 new RegExp(rule, "g"), 5420 EXPANSION_RULES_2[rule](date), 5421 ); 5422 } 5423 } 5424 pattern = pattern.replace(/\0\0/g, "%"); 5425 var bytes = intArrayFromString(pattern, false); 5426 if (bytes.length > maxsize) { 5427 return 0; 5428 } 5429 writeArrayToMemory(bytes, s); 5430 return bytes.length - 1; 5431 } 5432 var FSNode = function (parent, name, mode, rdev) { 5433 if (!parent) { 5434 parent = this; 5435 } 5436 this.parent = parent; 5437 this.mount = parent.mount; 5438 this.mounted = null; 5439 this.id = FS.nextInode++; 5440 this.name = name; 5441 this.mode = mode; 5442 this.node_ops = {}; 5443 this.stream_ops = {}; 5444 this.rdev = rdev; 5445 }; 5446 var readMode = 292 | 73; 5447 var writeMode = 146;
5448 Object.defineProperties(FSNode.prototype, { 5449 read: { 5450 get: function () { 5451 return (this.mode & readMode) === readMode; 5452 }, 5453 set: function (val) { 5454 val ? (this.mode |= readMode) : (this.mode &= ~readMode); 5455 }, 5456 }, 5457 write: { 5458 get: function () { 5459 return (this.mode & writeMode) === writeMode; 5460 }, 5461 set: function (val) { 5462 val ? (this.mode |= writeMode) : (this.mode &= ~writeMode); 5463 }, 5464 }, 5465 isFolder: { 5466 get: function () { 5467 return FS.isDir(this.mode); 5468 }, 5469 }, 5470 isDevice: { 5471 get: function () { 5472 return FS.isChrdev(this.mode); 5473 }, 5474 }, 5475 }); 5476 FS.FSNode = FSNode; 5477 FS.createPreloadedFile = FS_createPreloadedFile; 5478 FS.staticInit(); 5479 var wasmImports = { 5480 b: ___assert_fail, 5481 f: ___cxa_throw, 5482 ka: ___dlsym, 5483 R: ___syscall__newselect, 5484 L: ___syscall_accept4, 5485 K: ___syscall_bind, 5486 J: ___syscall_connect, 5487 la: ___syscall_faccessat, 5488 g: ___syscall_fcntl64, 5489 ha: ___syscall_fstat64, 5490 U: ___syscall_getdents64, 5491 I: ___syscall_getpeername, 5492 H: ___syscall_getsockname, 5493 G: ___syscall_getsockopt, 5494 y: ___syscall_ioctl, 5495 F: ___syscall_listen, 5496 ea: ___syscall_lstat64, 5497 $: ___syscall_mkdirat, 5498 fa: ___syscall_newfstatat,
5499 w: ___syscall_openat, 5500 V: ___syscall_poll, 5501 E: ___syscall_recvfrom, 5502 T: ___syscall_renameat, 5503 S: ___syscall_rmdir, 5504 D: ___syscall_sendto, 5505 v: ___syscall_socket, 5506 ga: ___syscall_stat64, 5507 O: ___syscall_unlinkat, 5508 ia: __emscripten_get_now_is_monotonic, 5509 M: __emscripten_throw_longjmp, 5510 Y: __gmtime_js, 5511 Z: __localtime_js, 5512 _: __mktime_js, 5513 W: __mmap_js, 5514 X: __munmap_js, 5515 P: __tzset_js, 5516 a: _abort, 5517 t: _dlopen, 5518 oa: _emscripten_asm_const_int, 5519 m: _emscripten_date_now, 5520 Q: _emscripten_get_heap_max, 5521 p: _emscripten_get_now, 5522 ja: _emscripten_memcpy_big, 5523 N: _emscripten_resize_heap, 5524 ca: _environ_get, 5525 da: _environ_sizes_get, 5526 l: _exit, 5527 n: _fd_close, 5528 ba: _fd_fdstat_get, 5529 x: _fd_read, 5530 aa: _fd_seek, 5531 q: _fd_write, 5532 k: _getaddrinfo, 5533 i: _getnameinfo, 5534 pa: invoke_i, 5535 na: invoke_ii, 5536 c: invoke_iii, 5537 o: invoke_iiii, 5538 s: invoke_iiiii, 5539 z: invoke_iiiiii, 5540 r: invoke_iiiiiiiii, 5541 B: invoke_iiiijj, 5542 qa: invoke_iij, 5543 h: invoke_vi, 5544 j: invoke_vii, 5545 d: invoke_viiii, 5546 ma: invoke_viiiiii, 5547 A: invoke_viiiiiiii, 5548 C: is_timeout, 5549 u: send_progress, 5550 e: _strftime, 5551 }; 5552 var asm = createWasm(); 5553 var ___wasm_call_ctors = function () { 5554 return (___wasm_call_ctors = Module["asm"]["sa"]).apply(null, arguments); 5555 }; 5556 var _malloc = (Module["_malloc"] = function () { 5557 return (_malloc = Module["_malloc"] = Module["asm"]["ta"]).apply( 5558 null, 5559 arguments, 5560 ); 5561 }); 5562 var ___errno_location = function () { 5563 return (___errno_location = Module["asm"]["va"]).apply(null, arguments); 5564 }; 5565 var _ntohs = function () { 5566 return (_ntohs = Module["asm"]["wa"]).apply(null, arguments); 5567 }; 5568 var _htons = function () { 5569 return (_htons = Module["asm"]["xa"]).apply(null, arguments); 5570 }; 5571 var _ffmpeg = (Module["_ffmpeg"] = function () { 5572 return (_ffmpeg = Module["_ffmpeg"] = Module["asm"]["ya"]).apply( 5573 null, 5574 arguments, 5575 ); 5576 }); 5577 var _ffprobe = (Module["_ffprobe"] = function () { 5578 return (_ffprobe = Module["_ffprobe"] = Module["asm"]["za"]).apply( 5579 null, 5580 arguments, 5581 ); 5582 }); 5583 var _htonl = function () { 5584 return (_htonl = Module["asm"]["Aa"]).apply(null, arguments); 5585 }; 5586 var _emscripten_builtin_memalign = function () { 5587 return (_emscripten_builtin_memalign = Module["asm"]["Ba"]).apply( 5588 null, 5589 arguments, 5590 ); 5591 }; 5592 var _setThrew = function () { 5593 return (_setThrew = Module["asm"]["Ca"]).apply(null, arguments); 5594 }; 5595 var stackSave = function () { 5596 return (stackSave = Module["asm"]["Da"]).apply(null, arguments); 5597 }; 5598 var stackRestore = function () { 5599 return (stackRestore = Module["asm"]["Ea"]).apply(null, arguments); 5600 }; 5601 var ___cxa_is_pointer_type = function () { 5602 return (___cxa_is_pointer_type = Module["asm"]["Fa"]).apply( 5603 null, 5604 arguments, 5605 ); 5606 }; 5607 var _ff_h264_cabac_tables = (Module["_ff_h264_cabac_tables"] = 1546732); 5608 var ___start_em_js = (Module["___start_em_js"] = 6077485); 5609 var ___stop_em_js = (Module["___stop_em_js"] = 6077662); 5610 function invoke_iiiii(index, a1, a2, a3, a4) { 5611 var sp = stackSave(); 5612 try { 5613 return getWasmTableEntry(index)(a1, a2, a3, a4); 5614 } catch (e) { 5615 stackRestore(sp); 5616 if (e !== e + 0) throw e; 5617 _setThrew(1, 0); 5618 } 5619 } 5620 function invoke_vii(index, a1, a2) { 5621 var sp = stackSave(); 5622 try { 5623 getWasmTableEntry(index)(a1, a2); 5624 } catch (e) { 5625 stackRestore(sp); 5626 if (e !== e + 0) throw e; 5627 _setThrew(1, 0); 5628 } 5629 } 5630 function invoke_iii(index, a1, a2) { 5631 var sp = stackSave(); 5632 try { 5633 return getWasmTableEntry(index)(a1, a2); 5634 } catch (e) { 5635 stackRestore(sp); 5636 if (e !== e + 0) throw e; 5637 _setThrew(1, 0); 5638 } 5639 } 5640 function invoke_iiiijj(index, a1, a2, a3, a4, a5) { 5641 var sp = stackSave();
5642 try { 5643 return getWasmTableEntry(index)(a1, a2, a3, a4, a5); 5644 } catch (e) { 5645 stackRestore(sp); 5646 if (e !== e + 0) throw e; 5647 _setThrew(1, 0); 5648 } 5649 } 5650 function invoke_iiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { 5651 var sp = stackSave(); 5652 try { 5653 return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8); 5654 } catch (e) { 5655 stackRestore(sp); 5656 if (e !== e + 0) throw e; 5657 _setThrew(1, 0); 5658 } 5659 } 5660 function invoke_vi(index, a1) { 5661 var sp = stackSave(); 5662 try { 5663 getWasmTableEntry(index)(a1); 5664 } catch (e) { 5665 stackRestore(sp); 5666 if (e !== e + 0) throw e; 5667 _setThrew(1, 0); 5668 } 5669 } 5670 function invoke_viiii(index, a1, a2, a3, a4) { 5671 var sp = stackSave(); 5672 try { 5673 getWasmTableEntry(index)(a1, a2, a3, a4); 5674 } catch (e) { 5675 stackRestore(sp); 5676 if (e !== e + 0) throw e; 5677 _setThrew(1, 0); 5678 } 5679 } 5680 function invoke_iiii(index, a1, a2, a3) { 5681 var sp = stackSave(); 5682 try { 5683 return getWasmTableEntry(index)(a1, a2, a3); 5684 } catch (e) { 5685 stackRestore(sp); 5686 if (e !== e + 0) throw e; 5687 _setThrew(1, 0); 5688 } 5689 } 5690 function invoke_iij(index, a1, a2) { 5691 var sp = stackSave(); 5692 try { 5693 return getWasmTableEntry(index)(a1, a2); 5694 } catch (e) { 5695 stackRestore(sp); 5696 if (e !== e + 0) throw e; 5697 _setThrew(1, 0); 5698 } 5699 } 5700 function invoke_i(index) { 5701 var sp = stackSave(); 5702 try { 5703 return getWasmTableEntry(index)(); 5704 } catch (e) { 5705 stackRestore(sp); 5706 if (e !== e + 0) throw e; 5707 _setThrew(1, 0); 5708 } 5709 } 5710 function invoke_ii(index, a1) { 5711 var sp = stackSave(); 5712 try { 5713 return getWasmTableEntry(index)(a1); 5714 } catch (e) { 5715 stackRestore(sp); 5716 if (e !== e + 0) throw e; 5717 _setThrew(1, 0); 5718 } 5719 } 5720 function invoke_viiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) { 5721 var sp = stackSave(); 5722 try { 5723 getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8); 5724 } catch (e) { 5725 stackRestore(sp); 5726 if (e !== e + 0) throw e; 5727 _setThrew(1, 0); 5728 } 5729 } 5730 function invoke_iiiiii(index, a1, a2, a3, a4, a5) { 5731 var sp = stackSave(); 5732 try { 5733 return getWasmTableEntry(index)(a1, a2, a3, a4, a5); 5734 } catch (e) { 5735 stackRestore(sp); 5736 if (e !== e + 0) throw e; 5737 _setThrew(1, 0); 5738 } 5739 } 5740 function invoke_viiiiii(index, a1, a2, a3, a4, a5, a6) { 5741 var sp = stackSave(); 5742 try { 5743 getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6); 5744 } catch (e) { 5745 stackRestore(sp); 5746 if (e !== e + 0) throw e; 5747 _setThrew(1, 0); 5748 } 5749 } 5750 Module["setValue"] = setValue; 5751 Module["getValue"] = getValue; 5752 Module["UTF8ToString"] = UTF8ToString; 5753 Module["stringToUTF8"] = stringToUTF8; 5754 Module["lengthBytesUTF8"] = lengthBytesUTF8; 5755 Module["FS"] = FS; 5756 var calledRun; 5757 dependenciesFulfilled = function runCaller() { 5758 if (!calledRun) run(); 5759 if (!calledRun) dependenciesFulfilled = runCaller; 5760 }; 5761 function run() { 5762 if (runDependencies > 0) { 5763 return; 5764 } 5765 preRun(); 5766 if (runDependencies > 0) { 5767 return; 5768 } 5769 function doRun() { 5770 if (calledRun) return; 5771 calledRun = true; 5772 Module["calledRun"] = true; 5773 if (ABORT) return; 5774 initRuntime(); 5775 readyPromiseResolve(Module); 5776 if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"](); 5777 postRun(); 5778 } 5779 if (Module["setStatus"]) { 5780 Module["setStatus"]("Running..."); 5781 setTimeout(function () { 5782 setTimeout(function () { 5783 Module["setStatus"](""); 5784 }, 1); 5785 doRun(); 5786 }, 1); 5787 } else { 5788 doRun(); 5789 } 5790 } 5791 if (Module["preInit"]) { 5792 if (typeof Module["preInit"] == "function") 5793 Module["preInit"] = [Module["preInit"]]; 5794 while (Module["preInit"].length > 0) { 5795 Module["preInit"].pop()(); 5796 } 5797 } 5798 run(); 5799 5800 return createFFmpegCore.ready; 5801 }; 5802})(); 5803if (typeof exports === "object" && typeof module === "object") 5804 module.exports = createFFmpegCore; 5805else if (typeof define === "function" && define["amd"]) 5806 define([], function () { 5807 return createFFmpegCore; 5808 }); 5809else if (typeof exports === "object") 5810 exports["createFFmpegCore"] = createFFmpegCore;
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.