From d40360bff82b29979d5404a266962c210a539228 Mon Sep 17 00:00:00 2001 From: "google-labs-jules[bot]" <161369871+google-labs-jules[bot]@users.noreply.github.com> Date: Sat, 7 Mar 2026 23:16:56 +0000 Subject: [PATCH] feat: replace Internet Explorer with x86 emulator for retro browsing - Integrate v86 emulator and picotcp.js virtual networking. - Implement InternetExplorerEmulator to handle emulator lifecycle. - Update ZenExplorerApp to use the emulator instead of an iframe in web mode. - Add download progress dialog for OS disk image loading. - Provide a Cloudflare Worker proxy script and setup guide. - Add attribution for OldWebToday in CREDITS.md. Co-authored-by: azayrahmad <10110227+azayrahmad@users.noreply.github.com> --- CREDITS.md | 5 + docs/proxy-setup.md | 98 + public/assets/ie-emulator/config.json | 205 + public/assets/ie-emulator/test-linux.iso | 1456 ++ public/assets/ie-emulator/win31.img | 1456 ++ public/lib/picotcp/broadcast-stream.js | 33 + public/lib/picotcp/httpproxyserver.js | 226 + public/lib/picotcp/jsnet-client.js | 294 + public/lib/picotcp/jsnet.js | 11519 ++++++++++++++++ public/lib/picotcp/network-parser.js | 93 + public/lib/picotcp/picotcp.js | 6471 +++++++++ public/lib/picotcp/picotcp.wasm | Bin 0 -> 205932 bytes .../lib/picotcp/sab-ring-buffer/ringbuffer.js | 201 + public/lib/picotcp/streams-polyfills.js | 8 + public/lib/picotcp/transform-stream.js | 110 + public/lib/picotcp/webnetwork.js | 414 + public/lib/v86/libv86.js | 835 ++ public/lib/v86/seabios.bin | Bin 0 -> 131072 bytes public/lib/v86/v86.wasm | Bin 0 -> 1970322 bytes public/lib/v86/vgabios.bin | Bin 0 -> 36352 bytes src/apps/internet-explorer/ie-emulator.js | 141 + src/shared/components/progress-dialog.js | 74 + src/shell/explorer/explorer-app.js | 17 +- 23 files changed, 23654 insertions(+), 2 deletions(-) create mode 100644 docs/proxy-setup.md create mode 100644 public/assets/ie-emulator/config.json create mode 100644 public/assets/ie-emulator/test-linux.iso create mode 100644 public/assets/ie-emulator/win31.img create mode 100644 public/lib/picotcp/broadcast-stream.js create mode 100644 public/lib/picotcp/httpproxyserver.js create mode 100644 public/lib/picotcp/jsnet-client.js create mode 100644 public/lib/picotcp/jsnet.js create mode 100644 public/lib/picotcp/network-parser.js create mode 100644 public/lib/picotcp/picotcp.js create mode 100644 public/lib/picotcp/picotcp.wasm create mode 100644 public/lib/picotcp/sab-ring-buffer/ringbuffer.js create mode 100644 public/lib/picotcp/streams-polyfills.js create mode 100644 public/lib/picotcp/transform-stream.js create mode 100644 public/lib/picotcp/webnetwork.js create mode 100644 public/lib/v86/libv86.js create mode 100644 public/lib/v86/seabios.bin create mode 100644 public/lib/v86/v86.wasm create mode 100644 public/lib/v86/vgabios.bin create mode 100644 src/apps/internet-explorer/ie-emulator.js create mode 100644 src/shared/components/progress-dialog.js diff --git a/CREDITS.md b/CREDITS.md index dbe767de..db73e486 100644 --- a/CREDITS.md +++ b/CREDITS.md @@ -63,3 +63,8 @@ This project is made possible by the following amazing open-source libraries and ## Asset Sources - Graphical elements, icons, and sounds are derived from classic Windows operating systems for historical recreation and compatibility. - All rights to original Windows artwork, icons, cursors, and media belong to Microsoft Corporation. + +## OldWebToday +- **Source**: [oldweb-today/oldweb-today](https://github.com/oldweb-today/oldweb-today) +- **License**: AGPL-3.0 +- **Use**: x86 emulation and virtual networking for Internet Explorer retro mode. diff --git a/docs/proxy-setup.md b/docs/proxy-setup.md new file mode 100644 index 00000000..c73490c6 --- /dev/null +++ b/docs/proxy-setup.md @@ -0,0 +1,98 @@ +# Internet Explorer Retro Proxy Setup Guide + +To use the new emulated Internet Explorer with real archived websites, you need to set up a CORS proxy. A Cloudflare Worker is the best free option for this. + +## Cloudflare Worker Setup + +1. **Create a Cloudflare Account**: If you don't have one, sign up for free at [cloudflare.com](https://www.cloudflare.com/). +2. **Create a Worker**: + * Log in to the [Cloudflare Dashboard](https://dash.cloudflare.com/). + * Navigate to **Workers & Pages** > **Overview**. + * Click **Create application** > **Create Worker**. + * Name it `win98-web-proxy` and click **Deploy**. +3. **Configure the Worker**: + * Click **Edit Code**. + * Replace the entire content of `worker.js` with the script provided below. + * Click **Save and Deploy**. +4. **Get your Proxy URL**: + * Your worker URL will look like `https://win98-web-proxy.yourname.workers.dev/`. + * Copy this URL. + +## Using the Proxy in Win98-Web + +1. Open the emulated Internet Explorer in your browser. +2. (Optional) If I implement a settings UI: Paste the URL into the "Proxy Settings" dialog. +3. Currently, the proxy is hardcoded to a default, but you can change it in `localStorage`: + * Open Browser Console (F12). + * Type: `localStorage.setItem("ie-proxy-url", "https://your-worker-url.workers.dev/proxy/")` + * Restart the Internet Explorer app. + +--- + +## Proxy Script (`worker.js`) + +```javascript +/** + * win98-web-proxy + * A simple CORS proxy for OldWebToday-style historical browsing. + */ + +const CORS_HEADERS = { + "Access-Control-Allow-Origin": "*", + "Access-Control-Allow-Methods": "GET, HEAD, POST, OPTIONS", + "Access-Control-Allow-Headers": "*", + "Access-Control-Expose-Headers": "*", +}; + +export default { + async fetch(request, env, ctx) { + const url = new URL(request.url); + + // Handle OPTIONS request for CORS preflight + if (request.method === "OPTIONS") { + return new Response(null, { headers: CORS_HEADERS }); + } + + // Expecting URL format: /proxy/http://example.com or /proxy/https://web.archive.org/... + let targetUrl = url.pathname.slice(1); + if (targetUrl.startsWith("proxy/")) { + targetUrl = targetUrl.replace("proxy/", ""); + } + + if (!targetUrl) { + return new Response("Win98 Web Proxy is running. Usage: /proxy/http://url-to-fetch", { + headers: { "Content-Type": "text/plain", ...CORS_HEADERS } + }); + } + + // Ensure protocol + if (!targetUrl.startsWith("http")) { + targetUrl = "http://" + targetUrl; + } + + try { + const newRequest = new Request(targetUrl, { + method: request.method, + headers: request.headers, + body: request.body, + redirect: "follow" + }); + + const response = await fetch(newRequest); + + // Reconstruct the response with CORS headers + const newResponse = new Response(response.body, response); + Object.keys(CORS_HEADERS).forEach(key => { + newResponse.headers.set(key, CORS_HEADERS[key]); + }); + + return newResponse; + } catch (err) { + return new Response("Proxy Error: " + err.message, { + status: 500, + headers: CORS_HEADERS + }); + } + }, +}; +``` diff --git a/public/assets/ie-emulator/config.json b/public/assets/ie-emulator/config.json new file mode 100644 index 00000000..75d8ee65 --- /dev/null +++ b/public/assets/ie-emulator/config.json @@ -0,0 +1,205 @@ +[ + { + "id": "nm2-mac", + "name": "NCSA Mosaic 2", + "os": "macos", + "emu": "bas", + "icon": "mosaic.png", + "opts": { + "biosPath": "$IMAGE_PREFIX/bas-2/bios/", + "imageUrl": "$IMAGE_PREFIX/bas-2/images/hd-ie-m.img$GZ", + "emuBrowserId": "br-nm2" + } + }, + { + "id": "nm3-mac", + "name": "NCSA Mosaic 3", + "os": "macos", + "emu": "bas", + "icon": "mosaic.png", + "opts": { + "biosPath": "$IMAGE_PREFIX/bas-2/bios/", + "imageUrl": "$IMAGE_PREFIX/bas-2/images/hd-ns.img$GZ", + "emuBrowserId": "br-nm3" + } + }, + { + "id": "ml-mac", + "name": "MacLynx 2", + "os": "macos", + "emu": "bas", + "icon": "maclynx.png", + "opts": { + "biosPath": "$IMAGE_PREFIX/bas-2/bios/", + "imageUrl": "$IMAGE_PREFIX/bas-2/images/hd-ns.img$GZ", + "emuBrowserId": "br-ml2" + } + }, + { + "id": "ns3-mac", + "name": "Navigator 3", + "os": "macos", + "emu": "bas", + "icon": "ns3.png", + "features": ["shockwave 3", "java 1.0"], + "opts": { + "biosPath": "$IMAGE_PREFIX/bas-2/bios/", + "imageUrl": "$IMAGE_PREFIX/bas-2/images/hd-ns.img$GZ", + "emuBrowserId": "br-ns3" + } + }, + { + "id": "ns4-mac", + "name": "Navigator 4", + "os": "macos", + "emu": "bas", + "icon": "ns4.png", + "features": ["shockwave 3"], + "opts": { + "biosPath": "$IMAGE_PREFIX/bas-2/bios/", + "imageUrl": "$IMAGE_PREFIX/bas-2/images/hd-ns.img$GZ", + "emuBrowserId": "br-ns4" + } + }, + { + "id": "ie4-mac", + "name": "IE 4", + "os": "macos", + "emu": "bas", + "icon": "ie4-mac.png", + "features": ["shockwave 3", "java 1.0"], + "opts": { + "biosPath": "$IMAGE_PREFIX/bas-2/bios/", + "imageUrl": "$IMAGE_PREFIX/bas-2/images/hd-ie-m.img$GZ", + "emuBrowserId": "br-ie4" + } + }, + { + "id": "ie5-full-boot", + "name": "(Slow Full Boot) IE5 + Netscape 4", + "os": "win98", + "emu": "v86", + "opts": { + "biosPath": "$IMAGE_PREFIX/v86-2/bios/", + "imageUrl": "$IMAGE_PREFIX/v86-2/images/ie5-ns4.img", + "imageSize": 419430400 + }, + "hidden": true + }, + { + "id": "ns4-win", + "name": "Navigator 4", + "os": "win98", + "emu": "v86", + "icon": "ns4.png", + "features": ["flash 8", "java 1.1.5"], + "opts": { + "biosPath": "$IMAGE_PREFIX/v86-2/bios/", + "imageUrl": "$IMAGE_PREFIX/v86-2/images/ie5-ns4.img", + "imageSize": 419430400, + "stateUrl": "$IMAGE_PREFIX/v86-2/state/ns4.bin$GZ", + "clientMAC": [0, 34, 21, 16, 17, 18], + "clientIP": [10, 0, 2, 100] + } + }, + { + "id": "ie6-full-boot", + "name": "(Slow Full Boot) IE6", + "os": "win98", + "emu": "v86", + "opts": { + "biosPath": "$IMAGE_PREFIX/v86-2/bios/", + "imageUrl": "$IMAGE_PREFIX/v86-2/images/ie6.img", + "imageSize": 419430400 + }, + "hidden": true + }, + { + "id": "ie5", + "name": "IE 5", + "os": "win98", + "emu": "v86", + "icon": "ie5.png", + "features": ["flash 9", "java 5.0"], + "opts": { + "biosPath": "$IMAGE_PREFIX/v86-2/bios/", + "imageUrl": "$IMAGE_PREFIX/v86-2/images/ie5-ns4.img", + "imageSize": 419430400, + "stateUrl": "$IMAGE_PREFIX/v86-2/state/ie5.bin$GZ", + "clientMAC": [0, 34, 21, 16, 17, 18], + "clientIP": [10, 0, 2, 100] + } + }, + { + "id": "ie6", + "name": "IE 6", + "os": "win98", + "emu": "v86", + "icon": "ie6.png", + "features": ["flash 9", "java 5.0"], + "opts": { + "biosPath": "$IMAGE_PREFIX/v86-2/bios/", + "imageUrl": "$IMAGE_PREFIX/v86-2/images/ie6.img", + "imageSize": 419430400, + "stateUrl": "$IMAGE_PREFIX/v86-2/state/ie6.bin$GZ", + "clientMAC": [0, 34, 21, 16, 17, 18], + "clientIP": [10, 0, 2, 100] + } + }, + { + "id": "tc-full-boot", + "name": "(Slow Full Boot) TinyCore Image", + "os": "linux", + "emu": "v86", + "opts": { + "biosPath": "$IMAGE_PREFIX/v86-2/bios/", + "imageUrl": "$IMAGE_PREFIX/v86-2/images/tclinux.img", + "imageSize": 209715200, + "acpi": true + }, + "hidden": true + }, + { + "id": "ff10", + "name": "Firefox 10", + "os": "linux", + "emu": "v86", + "icon": "firefox.png", + "features": ["flash 32"], + "opts": { + "biosPath": "$IMAGE_PREFIX/v86-2/bios/", + "imageUrl": "$IMAGE_PREFIX/v86-2/images/tclinux.img", + "imageSize": 209715200, + "stateUrl": "$IMAGE_PREFIX/v86-2/state/ff10.bin$GZ", + "clientMAC": [0, 34, 21, 16, 17, 18], + "clientIP": [10, 0, 2, 100], + "acpi": true + } + }, + { + "id": "op12", + "name": "Opera 12", + "os": "linux", + "emu": "v86", + "icon": "opera.png", + "features": ["flash 32"], + "opts": { + "biosPath": "$IMAGE_PREFIX/v86-2/bios/", + "imageUrl": "$IMAGE_PREFIX/v86-2/images/tclinux.img", + "imageSize": 209715200, + "stateUrl": "$IMAGE_PREFIX/v86-2/state/op12.bin$GZ", + "clientMAC": [0, 34, 21, 16, 17, 18], + "clientIP": [10, 0, 2, 100], + "acpi": true + } + }, + { + "id": "ruffle", + "name": "Ruffle (Flash)", + "os": "native", + "emu": "native", + "icon": "ruffle.png", + "features": ["flash"], + "opts": {"injectScripts": ["dist/ruffle.js"]} + } +] diff --git a/public/assets/ie-emulator/test-linux.iso b/public/assets/ie-emulator/test-linux.iso new file mode 100644 index 00000000..f7a8ea5a --- /dev/null +++ b/public/assets/ie-emulator/test-linux.iso @@ -0,0 +1,1456 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Page not found · GitHub · GitHub + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + +
+ Skip to content + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + + +
+ +
+ + + + + + + + +
+ + + + + +
+ + + + + + + + + +
+
+ + + +
+
+ +
+
+ 404 “This is not the web page you are looking for” + + + + + + + + + + + + +
+
+ +
+
+ +
+ + +
+
+
+ Contact Support — + GitHub Status — + @githubstatus +
+
+ +
+ +
+ + + + + + + + + + + + + + + + + + + + + + +
+
+
+ + diff --git a/public/assets/ie-emulator/win31.img b/public/assets/ie-emulator/win31.img new file mode 100644 index 00000000..4dc3bddc --- /dev/null +++ b/public/assets/ie-emulator/win31.img @@ -0,0 +1,1456 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Page not found · GitHub · GitHub + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + +
+ Skip to content + + + + + + + + + + + +
+ + + + + + + + + + + + + + + + + + + + +
+ +
+ + + + + + + + +
+ + + + + +
+ + + + + + + + + +
+
+ + + +
+
+ +
+
+ 404 “This is not the web page you are looking for” + + + + + + + + + + + + +
+
+ +
+
+ +
+ + +
+
+
+ Contact Support — + GitHub Status — + @githubstatus +
+
+ +
+ +
+ + + + + + + + + + + + + + + + + + + + + + +
+
+
+ + diff --git a/public/lib/picotcp/broadcast-stream.js b/public/lib/picotcp/broadcast-stream.js new file mode 100644 index 00000000..a40168d3 --- /dev/null +++ b/public/lib/picotcp/broadcast-stream.js @@ -0,0 +1,33 @@ +// Copyright 2018 The Emulation-as-a-Service Authors. +// SPDX-License-Identifier: GPL-2.0-or-later + +export const broadcastStream = (name) => { + const channel = new BroadcastChannel(name); + let writableClosed, readableClosed; + const closed = Promise.all([ + new Promise(r => writableClosed = r), + new Promise(r => readableClosed = r).then(() => channel.onmessage = null), + ]).then(() => channel.close()); + const writable = new WritableStream({ + write(ch) { + channel.postMessage(ch); + }, + close() { + writableClosed(); + }, + abort() { + writableClosed(); + }, + }); + let readController; + const readable = new ReadableStream({ + start(c) { + readController = c; + }, + cancel() { + readableClosed(); + }, + }); + channel.onmessage = ({data}) => readController.enqueue(data); + return {writable, readable}; +}; diff --git a/public/lib/picotcp/httpproxyserver.js b/public/lib/picotcp/httpproxyserver.js new file mode 100644 index 00000000..9059285f --- /dev/null +++ b/public/lib/picotcp/httpproxyserver.js @@ -0,0 +1,226 @@ + +const encoder = new TextEncoder(); + +const CORS_PREFIX = __CORS_PREFIX__; +const ARCHIVE_PREFIX = __ARCHIVE_PREFIX__; + + +export default class HttpProxyServer +{ + constructor({socket, replayUrl, replayTs, homePage, proxyIP, proxyPort, updateCallback}) { + this.socket = socket; + this.replayTs = replayTs; + this.replayUrl = replayUrl; + this.homePage = homePage; + this.proxyIP = proxyIP; + this.proxyPort = proxyPort; + this.updateCallback = updateCallback; + + this.keepAlive = false; + } + + get proxyPac() { + return `\ +function FindProxyForURL(url, host) +{ + if (isInNet(host, "${this.proxyIP}") || shExpMatch(url, "http://${this.proxyIP}:${this.proxyPort}/*")) { + return "DIRECT"; + } + + return "PROXY ${this.proxyIP}:${this.proxyPort}"; +} +`; + } + + useKeepAlive(req) { + //disabled for now + return false; + + if (!req.match(/Proxy-Connection\:\skeep-alive/i)) { + return false; + } + + // only use for IE5 or IE6 for now.. + if (!req.match(/User-Agent\:.*MSIE (5|6)/)) { + return false; + } + + return true; + } + + async handleResponse() { + const writer = this.socket.writable.getWriter(); + const reader = this.socket.readable.getReader(); + + await this.handleOneResponse(writer, reader); + + while (this.keepAlive) { + await this.handleOneResponse(writer, reader); + } + + try { + writer.close(); + } catch (e) { + console.log(e); + } + } + + async handleOneResponse(writer, reader) { + let req = null; + + try { + const data = await reader.read(); + if (data.done || !data.value) { + this.keepAlive = false; + return; + } + req = new TextDecoder().decode(data.value); + } catch (e) { + console.log(e); + this.sendResponse({ + content: "Server Error", + status: 500, + statusText: "Server Error", + writer + }); + return; + } + + if (this.updateCallback) { + this.updateCallback(); + } + + //TODO: handle other methods + const m = req.match(/GET\s([^\s]+)/); + + //console.log(req); + + let requestURL = m && m[1]; + + if (requestURL === "/proxy.pac") { + this.sendResponse({ + content: this.proxyPac, + contentType: "application/x-ns-proxy-autoconfig", + writer + }); + return; + } + + this.keepAlive = this.useKeepAlive(req); + + if (requestURL === "/" || requestURL === this.homePage) { + this.sendRedirect({ + redirect: this.replayUrl, + writer + }); + return; + } + + if (!requestURL || !requestURL.startsWith("http://")) { + this.sendResponse({ + content: "Invalid URL: " + requestURL, + status: 400, + statusText: "Bad Request", + writer + }); + return; + } + + const targetUrl = m[1]; + + const resp = await this.doProxy(targetUrl); + + if (resp.status !== 200 && !resp.headers.get("memento-datetime")) { + let msg = ""; + let status = 400; + + switch (resp.status) { + case 429: + msg = "Too Many Requests. Please try again later"; + break; + + case 404: + msg = "Page Not Found"; + status = resp.status; + break; + } + + this.sendResponse({ + content: `Sorry, an error has occured.\n(Status ${resp.status}) ${msg}`, + status, + statusText: "Bad Request", + writer + }); + return; + } + + const content = await resp.arrayBuffer(); + + let { status, statusText } = resp; + + if (resp.headers.has("x-redirect-status")) { + status = resp.headers.get("x-redirect-status"); + statusText = resp.headers.get("x-redirect-statusText") || "Redirect"; + + const redirect = resp.headers.get("x-orig-location") || resp.headers.get("location"); + + if (redirect) { + this.sendRedirect({redirect, writer}); + return; + } + } + + const contentType = resp.headers.get("content-type"); + + this.sendResponse({content, status, statusText, contentType, writer}); + } + + sendResponse({writer, content, status = 200, statusText = "OK", contentType = "text/plain"}) { + const payload = typeof(content) === "string" ? encoder.encode(content) : new Uint8Array(content); + + const contentTypeStr = (status === 200 && contentType) ? `Content-Type: ${contentType}\r\n` : ""; + + try{ + writer.write(encoder.encode(`\ +HTTP/1.0 ${status} ${statusText}\r\n\ +${contentTypeStr}\ +Connection: ${this.keepAlive ? 'keep-alive' : 'close'}\r\n\ +Proxy-Connection: ${this.keepAlive ? 'keep-alive' : 'close'}\r\n\ +Content-Length: ${payload.byteLength}\r\n\ +\r\n`)); + + writer.write(payload); + + } catch (e) { + console.log(e); + } + + //this.socket.close(); + } + + sendRedirect({writer, redirect}) { + + try { + writer.write(encoder.encode(`\ +HTTP/1.0 301 Permanent Redirect\r\n\ +Content-Type: text/plain\r\n\ +Connection: ${this.keepAlive ? 'keep-alive' : 'close'}\r\n\ +Proxy-Connection: ${this.keepAlive ? 'keep-alive' : 'close'}\r\n\ +Content-Length: 0\r\n\ +Location: ${redirect}\r\n\ +\r\n`)); + + } catch (e) { + console.log(e); + } + + //this.socket.close(); + } + + doProxy(targetUrl) { + //TODO: multi archive support + const fetchUrl = CORS_PREFIX + (this.replayTs ? ARCHIVE_PREFIX + this.replayTs + "id_/" + targetUrl : targetUrl); + + return fetch(fetchUrl, {headers: {"X-OWT-No-HTTPS": "1"}}); + } +} diff --git a/public/lib/picotcp/jsnet-client.js b/public/lib/picotcp/jsnet-client.js new file mode 100644 index 00000000..2e0a30fc --- /dev/null +++ b/public/lib/picotcp/jsnet-client.js @@ -0,0 +1,294 @@ +var JSNetClient = (function () { + 'use strict'; + + /* + Copyright 2020 Google Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + */ + + class RingBuffer { + static from(sab) { + return new RingBuffer(sab); + } + + get buffer() { + return this._sab; + } + + get remaining() { + return this._size - this.length; + } + + get size() { + return this._size; + } + + get length() { + let readIndex = Atomics.load(this._header, HEADER.READ); + let writeIndex = Atomics.load(this._header, HEADER.WRITE); + + const delta = writeIndex - readIndex; + return readIndex <= writeIndex ? delta : delta + this._size; + } + + get eof() { + return (this.length === 0 && Atomics.load(this._state, READER_STATE.EOF) === 0) ? true : false; + } + + set eof(val) { + let eofVal = !!val ? 0 : 1; + if (this.length === 0 && val) { + Atomics.notify(this._state, READER_STATE.DATA_AVAILABLE); + } + Atomics.store(this._state, READER_STATE.EOF, eofVal); + } + + /* + Create's a Ring Buffer backed by a correctly sized SAB. + + There can only be one writer and one reader. + */ + static create(length) { + const buffer = new SharedArrayBuffer( + length + + Uint32Array.BYTES_PER_ELEMENT * HEADER_LENGTH + + Int32Array.BYTES_PER_ELEMENT * READER_STATE_LENGTH + ); + + return new RingBuffer(buffer); + } + + constructor(sab) { + if (!!sab == false) throw new Error("Shared Array Buffer is undefined"); + if (sab instanceof SharedArrayBuffer == false) + throw new Error("Parameter 0 is not a Shared Array Buffer"); + + this._size = sab.byteLength + - Uint32Array.BYTES_PER_ELEMENT * HEADER_LENGTH + - Int32Array.BYTES_PER_ELEMENT * READER_STATE_LENGTH; + this._sab = sab; + this._header = new Uint32Array(sab, 0, HEADER_LENGTH); + this._state = new Int32Array(sab, Uint32Array.BYTES_PER_ELEMENT * HEADER_LENGTH, READER_STATE_LENGTH); + this._body = new Uint8Array( + sab, + Uint32Array.BYTES_PER_ELEMENT * HEADER_LENGTH + + Int32Array.BYTES_PER_ELEMENT * READER_STATE_LENGTH, + this._size + ); + } + + /* + data: An array of Uint8 + attemptToFill (deafault: false): if true, will fill as much of the array as possible + returning the items that couldn't be added. + + */ + append(data, attemptToFill = false) { + const { remaining, length, size } = this; + + if (data.length > remaining && attemptToFill == false) { + throw new Error("Data being appended will overflow the buffer"); + } + + if (data instanceof Array == false && data instanceof Uint8Array == false) { + throw new Error( + "data is not an array that can be converted to Uint8array" + ); + } + + let writeIndex = Atomics.load(this._header, HEADER.WRITE); + let writeStart = writeIndex % size; + + // We need at most two write operations. + // If the data will go past the end of the buffer, we need + // to write a 2nd batch from the start of the buffer. + // 9, 15 + // batch1, pos [9] = val [0] + // batch2, pos [0] = val [1,2,3,4,5] + + const batch1 = data.slice(0, size - writeStart); + this._body.set(batch1, writeStart); + let writeLength = batch1.length; + let slice = undefined; + + if (writeLength < data.length) { + // We are wrapping around because there was more data. + const batch2 = data.slice(writeLength, remaining - writeLength); + this._body.set(batch2, 0); + writeLength += batch2.length; + + Atomics.add(this._header, HEADER.WRITE, writeLength); + + if (attemptToFill && (writeLength < data.length)) { + slice = data.slice(writeLength); + } + } + else { + Atomics.add(this._header, HEADER.WRITE, writeLength); + } + + Atomics.store(this._state, READER_STATE.DATA_AVAILABLE, 1); + Atomics.notify(this._state, READER_STATE.DATA_AVAILABLE); + + return slice; + } + + // Reads the next byte of data. Note: Assuming 4GB of addressable buffer. + read() { + let readIndex = Atomics.load(this._header, HEADER.READ); + let writeIndex = Atomics.load(this._header, HEADER.WRITE); + + if (readIndex == writeIndex - 1) { + // The next blocking read, should wait. + console.log('next block'); + Atomics.store(this._state, READER_STATE.DATA_AVAILABLE, 0); + Atomics.notify(this._state, READER_STATE.DATA_AVAILABLE); + } + + if (readIndex == writeIndex) { + return undefined; + } + + const value = Atomics.load(this._body, readIndex % this._size); + + readIndex = Atomics.add(this._header, HEADER.READ, 1); + + return value; + } + + blockingRead() { + if (this.eof) return undefined; + + Atomics.wait(this._state, READER_STATE.DATA_AVAILABLE, 0); + return this.read(); + } + + *readToHead() { + // Feels odd to have to create a buffer the same size as the buffer. Just iterate. + let data; + while ((data = this.read()) != undefined) { + yield data; + } + } + + clear() { + Atomics.store(this._header, HEADER.READ, 0); + Atomics.store(this._header, HEADER.WRITE, 0); + } + } + + const HEADER = { + READ: 0, // 4GB buffer + WRITE: 1, // 4GB buffer + }; + + const HEADER_LENGTH = Object.keys(HEADER).length; + + const READER_STATE = { + DATA_AVAILABLE: 0, + WAITING: 1, + EOF: 2 + }; + + const READER_STATE_LENGTH = Object.keys(READER_STATE).length; + + class JSNetClient + { + constructor({ + replayUrl = "", + replayTs = "", + proxyIP = "10.0.2.2", + proxyPort = 6082, + jsnetUrl = "jsnet.js", + clientMAC = null, + clientIP = null, + recvCallback = null + }) { + this.netWorker = new Worker(jsnetUrl); + + this.eth_from_emu = new BroadcastChannel("eth_from_emu"); + + this.netChannel = new MessageChannel(); + + this.netrb = null; + + if (replayUrl.startsWith("https://")) { + replayUrl = replayUrl.replace("https://", "http://"); + } + if (!replayUrl.startsWith("http://")) { + replayUrl = "http://" + replayUrl; + } + + this.netRecvBuffer = null; + + this.netWorker.postMessage({ + port: this.netChannel.port1, + replayUrl, + replayTs, + proxyIP, + proxyPort, + clientIP, + clientMAC, + pollSAB: !recvCallback, + }, [this.netChannel.port1]); + + if (!recvCallback) { + this.netChannel.port2.onmessage = (event) => { + console.log("got shared ringbuffer", event.data); + this.netrb = RingBuffer.from(event.data); + }; + } else { + this.eth_to_emu = new BroadcastChannel("eth_to_emu"); + this.eth_to_emu.onmessage = (event) => recvCallback(event.data); + } + } + + pollRecv(targetBufferOrFunc, writeOffset = 0) { + if (!this.netrb) { + return 0; + } + + let netRecvBuffer = this.netRecvBuffer; + + if (!netRecvBuffer || this.netRecvBuffer.byteLength === 0) { + netRecvBuffer = new Uint8Array([...this.netrb.readToHead()]); + } + + if (netRecvBuffer.byteLength > 0) { + const size = new DataView(netRecvBuffer.buffer, netRecvBuffer.byteOffset, netRecvBuffer.byteLength).getUint16(0); + const chunk = netRecvBuffer.slice(2, 2 + size); + + //console.log(`Emu Receive ${chunk.byteLength}`); + if (typeof(targetBufferOrFunc) === "function") { + targetBufferOrFunc(chunk); + } else { + targetBufferOrFunc.set(chunk, writeOffset); + } + + this.netRecvBuffer = netRecvBuffer.slice(2 + size); + + return size; + } + + return 0; + } + + send(buffer) { + this.eth_from_emu.postMessage(buffer); + } + } + + return JSNetClient; + +})(); diff --git a/public/lib/picotcp/jsnet.js b/public/lib/picotcp/jsnet.js new file mode 100644 index 00000000..70880c10 --- /dev/null +++ b/public/lib/picotcp/jsnet.js @@ -0,0 +1,11519 @@ +(function () { + 'use strict'; + + /** + * web-streams-polyfill v3.0.1 + */ + /// + const SymbolPolyfill = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? + Symbol : + description => `Symbol(${description})`; + + /// + function noop() { + // do nothing + } + function getGlobals() { + if (typeof self !== 'undefined') { + return self; + } + else if (typeof window !== 'undefined') { + return window; + } + else if (typeof global !== 'undefined') { + return global; + } + return undefined; + } + const globals = getGlobals(); + + function typeIsObject(x) { + return (typeof x === 'object' && x !== null) || typeof x === 'function'; + } + const rethrowAssertionErrorRejection = noop; + + const originalPromise = Promise; + const originalPromiseThen = Promise.prototype.then; + const originalPromiseResolve = Promise.resolve.bind(originalPromise); + const originalPromiseReject = Promise.reject.bind(originalPromise); + function newPromise(executor) { + return new originalPromise(executor); + } + function promiseResolvedWith(value) { + return originalPromiseResolve(value); + } + function promiseRejectedWith(reason) { + return originalPromiseReject(reason); + } + function PerformPromiseThen(promise, onFulfilled, onRejected) { + // There doesn't appear to be any way to correctly emulate the behaviour from JavaScript, so this is just an + // approximation. + return originalPromiseThen.call(promise, onFulfilled, onRejected); + } + function uponPromise(promise, onFulfilled, onRejected) { + PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), undefined, rethrowAssertionErrorRejection); + } + function uponFulfillment(promise, onFulfilled) { + uponPromise(promise, onFulfilled); + } + function uponRejection(promise, onRejected) { + uponPromise(promise, undefined, onRejected); + } + function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) { + return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler); + } + function setPromiseIsHandledToTrue(promise) { + PerformPromiseThen(promise, undefined, rethrowAssertionErrorRejection); + } + const queueMicrotask = (() => { + const globalQueueMicrotask = globals && globals.queueMicrotask; + if (typeof globalQueueMicrotask === 'function') { + return globalQueueMicrotask; + } + const resolvedPromise = promiseResolvedWith(undefined); + return (fn) => PerformPromiseThen(resolvedPromise, fn); + })(); + function reflectCall(F, V, args) { + if (typeof F !== 'function') { + throw new TypeError('Argument is not a function'); + } + return Function.prototype.apply.call(F, V, args); + } + function promiseCall(F, V, args) { + try { + return promiseResolvedWith(reflectCall(F, V, args)); + } + catch (value) { + return promiseRejectedWith(value); + } + } + + // Original from Chromium + // https://chromium.googlesource.com/chromium/src/+/0aee4434a4dba42a42abaea9bfbc0cd196a63bc1/third_party/blink/renderer/core/streams/SimpleQueue.js + const QUEUE_MAX_ARRAY_SIZE = 16384; + /** + * Simple queue structure. + * + * Avoids scalability issues with using a packed array directly by using + * multiple arrays in a linked list and keeping the array size bounded. + */ + class SimpleQueue { + constructor() { + this._cursor = 0; + this._size = 0; + // _front and _back are always defined. + this._front = { + _elements: [], + _next: undefined + }; + this._back = this._front; + // The cursor is used to avoid calling Array.shift(). + // It contains the index of the front element of the array inside the + // front-most node. It is always in the range [0, QUEUE_MAX_ARRAY_SIZE). + this._cursor = 0; + // When there is only one node, size === elements.length - cursor. + this._size = 0; + } + get length() { + return this._size; + } + // For exception safety, this method is structured in order: + // 1. Read state + // 2. Calculate required state mutations + // 3. Perform state mutations + push(element) { + const oldBack = this._back; + let newBack = oldBack; + if (oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1) { + newBack = { + _elements: [], + _next: undefined + }; + } + // push() is the mutation most likely to throw an exception, so it + // goes first. + oldBack._elements.push(element); + if (newBack !== oldBack) { + this._back = newBack; + oldBack._next = newBack; + } + ++this._size; + } + // Like push(), shift() follows the read -> calculate -> mutate pattern for + // exception safety. + shift() { // must not be called on an empty queue + const oldFront = this._front; + let newFront = oldFront; + const oldCursor = this._cursor; + let newCursor = oldCursor + 1; + const elements = oldFront._elements; + const element = elements[oldCursor]; + if (newCursor === QUEUE_MAX_ARRAY_SIZE) { + newFront = oldFront._next; + newCursor = 0; + } + // No mutations before this point. + --this._size; + this._cursor = newCursor; + if (oldFront !== newFront) { + this._front = newFront; + } + // Permit shifted element to be garbage collected. + elements[oldCursor] = undefined; + return element; + } + // The tricky thing about forEach() is that it can be called + // re-entrantly. The queue may be mutated inside the callback. It is easy to + // see that push() within the callback has no negative effects since the end + // of the queue is checked for on every iteration. If shift() is called + // repeatedly within the callback then the next iteration may return an + // element that has been removed. In this case the callback will be called + // with undefined values until we either "catch up" with elements that still + // exist or reach the back of the queue. + forEach(callback) { + let i = this._cursor; + let node = this._front; + let elements = node._elements; + while (i !== elements.length || node._next !== undefined) { + if (i === elements.length) { + node = node._next; + elements = node._elements; + i = 0; + if (elements.length === 0) { + break; + } + } + callback(elements[i]); + ++i; + } + } + // Return the element that would be returned if shift() was called now, + // without modifying the queue. + peek() { // must not be called on an empty queue + const front = this._front; + const cursor = this._cursor; + return front._elements[cursor]; + } + } + + function ReadableStreamReaderGenericInitialize(reader, stream) { + reader._ownerReadableStream = stream; + stream._reader = reader; + if (stream._state === 'readable') { + defaultReaderClosedPromiseInitialize(reader); + } + else if (stream._state === 'closed') { + defaultReaderClosedPromiseInitializeAsResolved(reader); + } + else { + defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError); + } + } + // A client of ReadableStreamDefaultReader and ReadableStreamBYOBReader may use these functions directly to bypass state + // check. + function ReadableStreamReaderGenericCancel(reader, reason) { + const stream = reader._ownerReadableStream; + return ReadableStreamCancel(stream, reason); + } + function ReadableStreamReaderGenericRelease(reader) { + if (reader._ownerReadableStream._state === 'readable') { + defaultReaderClosedPromiseReject(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`)); + } + else { + defaultReaderClosedPromiseResetToRejected(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`)); + } + reader._ownerReadableStream._reader = undefined; + reader._ownerReadableStream = undefined; + } + // Helper functions for the readers. + function readerLockException(name) { + return new TypeError('Cannot ' + name + ' a stream using a released reader'); + } + // Helper functions for the ReadableStreamDefaultReader. + function defaultReaderClosedPromiseInitialize(reader) { + reader._closedPromise = newPromise((resolve, reject) => { + reader._closedPromise_resolve = resolve; + reader._closedPromise_reject = reject; + }); + } + function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) { + defaultReaderClosedPromiseInitialize(reader); + defaultReaderClosedPromiseReject(reader, reason); + } + function defaultReaderClosedPromiseInitializeAsResolved(reader) { + defaultReaderClosedPromiseInitialize(reader); + defaultReaderClosedPromiseResolve(reader); + } + function defaultReaderClosedPromiseReject(reader, reason) { + if (reader._closedPromise_reject === undefined) { + return; + } + setPromiseIsHandledToTrue(reader._closedPromise); + reader._closedPromise_reject(reason); + reader._closedPromise_resolve = undefined; + reader._closedPromise_reject = undefined; + } + function defaultReaderClosedPromiseResetToRejected(reader, reason) { + defaultReaderClosedPromiseInitializeAsRejected(reader, reason); + } + function defaultReaderClosedPromiseResolve(reader) { + if (reader._closedPromise_resolve === undefined) { + return; + } + reader._closedPromise_resolve(undefined); + reader._closedPromise_resolve = undefined; + reader._closedPromise_reject = undefined; + } + + const AbortSteps = SymbolPolyfill('[[AbortSteps]]'); + const ErrorSteps = SymbolPolyfill('[[ErrorSteps]]'); + const CancelSteps = SymbolPolyfill('[[CancelSteps]]'); + const PullSteps = SymbolPolyfill('[[PullSteps]]'); + + /// + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite#Polyfill + const NumberIsFinite = Number.isFinite || function (x) { + return typeof x === 'number' && isFinite(x); + }; + + /// + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc#Polyfill + const MathTrunc = Math.trunc || function (v) { + return v < 0 ? Math.ceil(v) : Math.floor(v); + }; + + // https://heycam.github.io/webidl/#idl-dictionaries + function isDictionary(x) { + return typeof x === 'object' || typeof x === 'function'; + } + function assertDictionary(obj, context) { + if (obj !== undefined && !isDictionary(obj)) { + throw new TypeError(`${context} is not an object.`); + } + } + // https://heycam.github.io/webidl/#idl-callback-functions + function assertFunction(x, context) { + if (typeof x !== 'function') { + throw new TypeError(`${context} is not a function.`); + } + } + // https://heycam.github.io/webidl/#idl-object + function isObject(x) { + return (typeof x === 'object' && x !== null) || typeof x === 'function'; + } + function assertObject(x, context) { + if (!isObject(x)) { + throw new TypeError(`${context} is not an object.`); + } + } + function assertRequiredArgument(x, position, context) { + if (x === undefined) { + throw new TypeError(`Parameter ${position} is required in '${context}'.`); + } + } + function assertRequiredField(x, field, context) { + if (x === undefined) { + throw new TypeError(`${field} is required in '${context}'.`); + } + } + // https://heycam.github.io/webidl/#idl-unrestricted-double + function convertUnrestrictedDouble(value) { + return Number(value); + } + function censorNegativeZero(x) { + return x === 0 ? 0 : x; + } + function integerPart(x) { + return censorNegativeZero(MathTrunc(x)); + } + // https://heycam.github.io/webidl/#idl-unsigned-long-long + function convertUnsignedLongLongWithEnforceRange(value, context) { + const lowerBound = 0; + const upperBound = Number.MAX_SAFE_INTEGER; + let x = Number(value); + x = censorNegativeZero(x); + if (!NumberIsFinite(x)) { + throw new TypeError(`${context} is not a finite number`); + } + x = integerPart(x); + if (x < lowerBound || x > upperBound) { + throw new TypeError(`${context} is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`); + } + if (!NumberIsFinite(x) || x === 0) { + return 0; + } + // TODO Use BigInt if supported? + // let xBigInt = BigInt(integerPart(x)); + // xBigInt = BigInt.asUintN(64, xBigInt); + // return Number(xBigInt); + return x; + } + + function assertReadableStream(x, context) { + if (!IsReadableStream(x)) { + throw new TypeError(`${context} is not a ReadableStream.`); + } + } + + // Abstract operations for the ReadableStream. + function AcquireReadableStreamDefaultReader(stream) { + return new ReadableStreamDefaultReader(stream); + } + // ReadableStream API exposed for controllers. + function ReadableStreamAddReadRequest(stream, readRequest) { + stream._reader._readRequests.push(readRequest); + } + function ReadableStreamFulfillReadRequest(stream, chunk, done) { + const reader = stream._reader; + const readRequest = reader._readRequests.shift(); + if (done) { + readRequest._closeSteps(); + } + else { + readRequest._chunkSteps(chunk); + } + } + function ReadableStreamGetNumReadRequests(stream) { + return stream._reader._readRequests.length; + } + function ReadableStreamHasDefaultReader(stream) { + const reader = stream._reader; + if (reader === undefined) { + return false; + } + if (!IsReadableStreamDefaultReader(reader)) { + return false; + } + return true; + } + /** + * A default reader vended by a {@link ReadableStream}. + * + * @public + */ + class ReadableStreamDefaultReader { + constructor(stream) { + assertRequiredArgument(stream, 1, 'ReadableStreamDefaultReader'); + assertReadableStream(stream, 'First parameter'); + if (IsReadableStreamLocked(stream)) { + throw new TypeError('This stream has already been locked for exclusive reading by another reader'); + } + ReadableStreamReaderGenericInitialize(this, stream); + this._readRequests = new SimpleQueue(); + } + /** + * Returns a promise that will be fulfilled when the stream becomes closed, + * or rejected if the stream ever errors or the reader's lock is released before the stream finishes closing. + */ + get closed() { + if (!IsReadableStreamDefaultReader(this)) { + return promiseRejectedWith(defaultReaderBrandCheckException('closed')); + } + return this._closedPromise; + } + /** + * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}. + */ + cancel(reason = undefined) { + if (!IsReadableStreamDefaultReader(this)) { + return promiseRejectedWith(defaultReaderBrandCheckException('cancel')); + } + if (this._ownerReadableStream === undefined) { + return promiseRejectedWith(readerLockException('cancel')); + } + return ReadableStreamReaderGenericCancel(this, reason); + } + /** + * Returns a promise that allows access to the next chunk from the stream's internal queue, if available. + * + * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source. + */ + read() { + if (!IsReadableStreamDefaultReader(this)) { + return promiseRejectedWith(defaultReaderBrandCheckException('read')); + } + if (this._ownerReadableStream === undefined) { + return promiseRejectedWith(readerLockException('read from')); + } + let resolvePromise; + let rejectPromise; + const promise = newPromise((resolve, reject) => { + resolvePromise = resolve; + rejectPromise = reject; + }); + const readRequest = { + _chunkSteps: chunk => resolvePromise({ value: chunk, done: false }), + _closeSteps: () => resolvePromise({ value: undefined, done: true }), + _errorSteps: e => rejectPromise(e) + }; + ReadableStreamDefaultReaderRead(this, readRequest); + return promise; + } + /** + * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active. + * If the associated stream is errored when the lock is released, the reader will appear errored in the same way + * from now on; otherwise, the reader will appear closed. + * + * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by + * the reader's {@link ReadableStreamDefaultReader.read | read()} method has not yet been settled. Attempting to + * do so will throw a `TypeError` and leave the reader locked to the stream. + */ + releaseLock() { + if (!IsReadableStreamDefaultReader(this)) { + throw defaultReaderBrandCheckException('releaseLock'); + } + if (this._ownerReadableStream === undefined) { + return; + } + if (this._readRequests.length > 0) { + throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled'); + } + ReadableStreamReaderGenericRelease(this); + } + } + Object.defineProperties(ReadableStreamDefaultReader.prototype, { + cancel: { enumerable: true }, + read: { enumerable: true }, + releaseLock: { enumerable: true }, + closed: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === 'symbol') { + Object.defineProperty(ReadableStreamDefaultReader.prototype, SymbolPolyfill.toStringTag, { + value: 'ReadableStreamDefaultReader', + configurable: true + }); + } + // Abstract operations for the readers. + function IsReadableStreamDefaultReader(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) { + return false; + } + return true; + } + function ReadableStreamDefaultReaderRead(reader, readRequest) { + const stream = reader._ownerReadableStream; + stream._disturbed = true; + if (stream._state === 'closed') { + readRequest._closeSteps(); + } + else if (stream._state === 'errored') { + readRequest._errorSteps(stream._storedError); + } + else { + stream._readableStreamController[PullSteps](readRequest); + } + } + // Helper functions for the ReadableStreamDefaultReader. + function defaultReaderBrandCheckException(name) { + return new TypeError(`ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`); + } + + /// + let AsyncIteratorPrototype; + if (typeof SymbolPolyfill.asyncIterator === 'symbol') { + // We're running inside a ES2018+ environment, but we're compiling to an older syntax. + // We cannot access %AsyncIteratorPrototype% without non-ES2018 syntax, but we can re-create it. + AsyncIteratorPrototype = { + // 25.1.3.1 %AsyncIteratorPrototype% [ @@asyncIterator ] ( ) + // https://tc39.github.io/ecma262/#sec-asynciteratorprototype-asynciterator + [SymbolPolyfill.asyncIterator]() { + return this; + } + }; + Object.defineProperty(AsyncIteratorPrototype, SymbolPolyfill.asyncIterator, { enumerable: false }); + } + + /// + class ReadableStreamAsyncIteratorImpl { + constructor(reader, preventCancel) { + this._ongoingPromise = undefined; + this._isFinished = false; + this._reader = reader; + this._preventCancel = preventCancel; + } + next() { + const nextSteps = () => this._nextSteps(); + this._ongoingPromise = this._ongoingPromise ? + transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) : + nextSteps(); + return this._ongoingPromise; + } + return(value) { + const returnSteps = () => this._returnSteps(value); + return this._ongoingPromise ? + transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) : + returnSteps(); + } + _nextSteps() { + if (this._isFinished) { + return Promise.resolve({ value: undefined, done: true }); + } + const reader = this._reader; + if (reader._ownerReadableStream === undefined) { + return promiseRejectedWith(readerLockException('iterate')); + } + let resolvePromise; + let rejectPromise; + const promise = newPromise((resolve, reject) => { + resolvePromise = resolve; + rejectPromise = reject; + }); + const readRequest = { + _chunkSteps: chunk => { + this._ongoingPromise = undefined; + // This needs to be delayed by one microtask, otherwise we stop pulling too early which breaks a test. + // FIXME Is this a bug in the specification, or in the test? + queueMicrotask(() => resolvePromise({ value: chunk, done: false })); + }, + _closeSteps: () => { + this._ongoingPromise = undefined; + this._isFinished = true; + ReadableStreamReaderGenericRelease(reader); + resolvePromise({ value: undefined, done: true }); + }, + _errorSteps: reason => { + this._ongoingPromise = undefined; + this._isFinished = true; + ReadableStreamReaderGenericRelease(reader); + rejectPromise(reason); + } + }; + ReadableStreamDefaultReaderRead(reader, readRequest); + return promise; + } + _returnSteps(value) { + if (this._isFinished) { + return Promise.resolve({ value, done: true }); + } + this._isFinished = true; + const reader = this._reader; + if (reader._ownerReadableStream === undefined) { + return promiseRejectedWith(readerLockException('finish iterating')); + } + if (!this._preventCancel) { + const result = ReadableStreamReaderGenericCancel(reader, value); + ReadableStreamReaderGenericRelease(reader); + return transformPromiseWith(result, () => ({ value, done: true })); + } + ReadableStreamReaderGenericRelease(reader); + return promiseResolvedWith({ value, done: true }); + } + } + const ReadableStreamAsyncIteratorPrototype = { + next() { + if (!IsReadableStreamAsyncIterator(this)) { + return promiseRejectedWith(streamAsyncIteratorBrandCheckException('next')); + } + return this._asyncIteratorImpl.next(); + }, + return(value) { + if (!IsReadableStreamAsyncIterator(this)) { + return promiseRejectedWith(streamAsyncIteratorBrandCheckException('return')); + } + return this._asyncIteratorImpl.return(value); + } + }; + if (AsyncIteratorPrototype !== undefined) { + Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype); + } + // Abstract operations for the ReadableStream. + function AcquireReadableStreamAsyncIterator(stream, preventCancel) { + const reader = AcquireReadableStreamDefaultReader(stream); + const impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel); + const iterator = Object.create(ReadableStreamAsyncIteratorPrototype); + iterator._asyncIteratorImpl = impl; + return iterator; + } + function IsReadableStreamAsyncIterator(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_asyncIteratorImpl')) { + return false; + } + return true; + } + // Helper functions for the ReadableStream. + function streamAsyncIteratorBrandCheckException(name) { + return new TypeError(`ReadableStreamAsyncIterator.${name} can only be used on a ReadableSteamAsyncIterator`); + } + + /// + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN#Polyfill + const NumberIsNaN = Number.isNaN || function (x) { + // eslint-disable-next-line no-self-compare + return x !== x; + }; + + function IsFiniteNonNegativeNumber(v) { + if (!IsNonNegativeNumber(v)) { + return false; + } + if (v === Infinity) { + return false; + } + return true; + } + function IsNonNegativeNumber(v) { + if (typeof v !== 'number') { + return false; + } + if (NumberIsNaN(v)) { + return false; + } + if (v < 0) { + return false; + } + return true; + } + + function DequeueValue(container) { + const pair = container._queue.shift(); + container._queueTotalSize -= pair.size; + if (container._queueTotalSize < 0) { + container._queueTotalSize = 0; + } + return pair.value; + } + function EnqueueValueWithSize(container, value, size) { + size = Number(size); + if (!IsFiniteNonNegativeNumber(size)) { + throw new RangeError('Size must be a finite, non-NaN, non-negative number.'); + } + container._queue.push({ value, size }); + container._queueTotalSize += size; + } + function PeekQueueValue(container) { + const pair = container._queue.peek(); + return pair.value; + } + function ResetQueue(container) { + container._queue = new SimpleQueue(); + container._queueTotalSize = 0; + } + + function CreateArrayFromList(elements) { + // We use arrays to represent lists, so this is basically a no-op. + // Do a slice though just in case we happen to depend on the unique-ness. + return elements.slice(); + } + function CopyDataBlockBytes(dest, destOffset, src, srcOffset, n) { + new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset); + } + // Not implemented correctly + function TransferArrayBuffer(O) { + return O; + } + // Not implemented correctly + function IsDetachedBuffer(O) { + return false; + } + + /** + * A pull-into request in a {@link ReadableByteStreamController}. + * + * @public + */ + class ReadableStreamBYOBRequest { + constructor() { + throw new TypeError('Illegal constructor'); + } + /** + * Returns the view for writing in to, or `null` if the BYOB request has already been responded to. + */ + get view() { + if (!IsReadableStreamBYOBRequest(this)) { + throw byobRequestBrandCheckException('view'); + } + return this._view; + } + respond(bytesWritten) { + if (!IsReadableStreamBYOBRequest(this)) { + throw byobRequestBrandCheckException('respond'); + } + assertRequiredArgument(bytesWritten, 1, 'respond'); + bytesWritten = convertUnsignedLongLongWithEnforceRange(bytesWritten, 'First parameter'); + if (this._associatedReadableByteStreamController === undefined) { + throw new TypeError('This BYOB request has been invalidated'); + } + if (IsDetachedBuffer(this._view.buffer)) ; + ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten); + } + respondWithNewView(view) { + if (!IsReadableStreamBYOBRequest(this)) { + throw byobRequestBrandCheckException('respondWithNewView'); + } + assertRequiredArgument(view, 1, 'respondWithNewView'); + if (!ArrayBuffer.isView(view)) { + throw new TypeError('You can only respond with array buffer views'); + } + if (view.byteLength === 0) { + throw new TypeError('chunk must have non-zero byteLength'); + } + if (view.buffer.byteLength === 0) { + throw new TypeError(`chunk's buffer must have non-zero byteLength`); + } + if (this._associatedReadableByteStreamController === undefined) { + throw new TypeError('This BYOB request has been invalidated'); + } + ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view); + } + } + Object.defineProperties(ReadableStreamBYOBRequest.prototype, { + respond: { enumerable: true }, + respondWithNewView: { enumerable: true }, + view: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === 'symbol') { + Object.defineProperty(ReadableStreamBYOBRequest.prototype, SymbolPolyfill.toStringTag, { + value: 'ReadableStreamBYOBRequest', + configurable: true + }); + } + /** + * Allows control of a {@link ReadableStream | readable byte stream}'s state and internal queue. + * + * @public + */ + class ReadableByteStreamController { + constructor() { + throw new TypeError('Illegal constructor'); + } + /** + * Returns the current BYOB pull request, or `null` if there isn't one. + */ + get byobRequest() { + if (!IsReadableByteStreamController(this)) { + throw byteStreamControllerBrandCheckException('byobRequest'); + } + if (this._byobRequest === null && this._pendingPullIntos.length > 0) { + const firstDescriptor = this._pendingPullIntos.peek(); + const view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled); + const byobRequest = Object.create(ReadableStreamBYOBRequest.prototype); + SetUpReadableStreamBYOBRequest(byobRequest, this, view); + this._byobRequest = byobRequest; + } + return this._byobRequest; + } + /** + * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is + * over-full. An underlying byte source ought to use this information to determine when and how to apply backpressure. + */ + get desiredSize() { + if (!IsReadableByteStreamController(this)) { + throw byteStreamControllerBrandCheckException('desiredSize'); + } + return ReadableByteStreamControllerGetDesiredSize(this); + } + /** + * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from + * the stream, but once those are read, the stream will become closed. + */ + close() { + if (!IsReadableByteStreamController(this)) { + throw byteStreamControllerBrandCheckException('close'); + } + if (this._closeRequested) { + throw new TypeError('The stream has already been closed; do not close it again!'); + } + const state = this._controlledReadableByteStream._state; + if (state !== 'readable') { + throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be closed`); + } + ReadableByteStreamControllerClose(this); + } + enqueue(chunk) { + if (!IsReadableByteStreamController(this)) { + throw byteStreamControllerBrandCheckException('enqueue'); + } + assertRequiredArgument(chunk, 1, 'enqueue'); + if (!ArrayBuffer.isView(chunk)) { + throw new TypeError('chunk must be an array buffer view'); + } + if (chunk.byteLength === 0) { + throw new TypeError('chunk must have non-zero byteLength'); + } + if (chunk.buffer.byteLength === 0) { + throw new TypeError(`chunk's buffer must have non-zero byteLength`); + } + if (this._closeRequested) { + throw new TypeError('stream is closed or draining'); + } + const state = this._controlledReadableByteStream._state; + if (state !== 'readable') { + throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be enqueued to`); + } + ReadableByteStreamControllerEnqueue(this, chunk); + } + /** + * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`. + */ + error(e = undefined) { + if (!IsReadableByteStreamController(this)) { + throw byteStreamControllerBrandCheckException('error'); + } + ReadableByteStreamControllerError(this, e); + } + /** @internal */ + [CancelSteps](reason) { + if (this._pendingPullIntos.length > 0) { + const firstDescriptor = this._pendingPullIntos.peek(); + firstDescriptor.bytesFilled = 0; + } + ResetQueue(this); + const result = this._cancelAlgorithm(reason); + ReadableByteStreamControllerClearAlgorithms(this); + return result; + } + /** @internal */ + [PullSteps](readRequest) { + const stream = this._controlledReadableByteStream; + if (this._queueTotalSize > 0) { + const entry = this._queue.shift(); + this._queueTotalSize -= entry.byteLength; + ReadableByteStreamControllerHandleQueueDrain(this); + const view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength); + readRequest._chunkSteps(view); + return; + } + const autoAllocateChunkSize = this._autoAllocateChunkSize; + if (autoAllocateChunkSize !== undefined) { + let buffer; + try { + buffer = new ArrayBuffer(autoAllocateChunkSize); + } + catch (bufferE) { + readRequest._errorSteps(bufferE); + return; + } + const pullIntoDescriptor = { + buffer, + byteOffset: 0, + byteLength: autoAllocateChunkSize, + bytesFilled: 0, + elementSize: 1, + viewConstructor: Uint8Array, + readerType: 'default' + }; + this._pendingPullIntos.push(pullIntoDescriptor); + } + ReadableStreamAddReadRequest(stream, readRequest); + ReadableByteStreamControllerCallPullIfNeeded(this); + } + } + Object.defineProperties(ReadableByteStreamController.prototype, { + close: { enumerable: true }, + enqueue: { enumerable: true }, + error: { enumerable: true }, + byobRequest: { enumerable: true }, + desiredSize: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === 'symbol') { + Object.defineProperty(ReadableByteStreamController.prototype, SymbolPolyfill.toStringTag, { + value: 'ReadableByteStreamController', + configurable: true + }); + } + // Abstract operations for the ReadableByteStreamController. + function IsReadableByteStreamController(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableByteStream')) { + return false; + } + return true; + } + function IsReadableStreamBYOBRequest(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) { + return false; + } + return true; + } + function ReadableByteStreamControllerCallPullIfNeeded(controller) { + const shouldPull = ReadableByteStreamControllerShouldCallPull(controller); + if (!shouldPull) { + return; + } + if (controller._pulling) { + controller._pullAgain = true; + return; + } + controller._pulling = true; + // TODO: Test controller argument + const pullPromise = controller._pullAlgorithm(); + uponPromise(pullPromise, () => { + controller._pulling = false; + if (controller._pullAgain) { + controller._pullAgain = false; + ReadableByteStreamControllerCallPullIfNeeded(controller); + } + }, e => { + ReadableByteStreamControllerError(controller, e); + }); + } + function ReadableByteStreamControllerClearPendingPullIntos(controller) { + ReadableByteStreamControllerInvalidateBYOBRequest(controller); + controller._pendingPullIntos = new SimpleQueue(); + } + function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) { + let done = false; + if (stream._state === 'closed') { + done = true; + } + const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor); + if (pullIntoDescriptor.readerType === 'default') { + ReadableStreamFulfillReadRequest(stream, filledView, done); + } + else { + ReadableStreamFulfillReadIntoRequest(stream, filledView, done); + } + } + function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) { + const bytesFilled = pullIntoDescriptor.bytesFilled; + const elementSize = pullIntoDescriptor.elementSize; + return new pullIntoDescriptor.viewConstructor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize); + } + function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) { + controller._queue.push({ buffer, byteOffset, byteLength }); + controller._queueTotalSize += byteLength; + } + function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) { + const elementSize = pullIntoDescriptor.elementSize; + const currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize; + const maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled); + const maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy; + const maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize; + let totalBytesToCopyRemaining = maxBytesToCopy; + let ready = false; + if (maxAlignedBytes > currentAlignedBytes) { + totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled; + ready = true; + } + const queue = controller._queue; + while (totalBytesToCopyRemaining > 0) { + const headOfQueue = queue.peek(); + const bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength); + const destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled; + CopyDataBlockBytes(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy); + if (headOfQueue.byteLength === bytesToCopy) { + queue.shift(); + } + else { + headOfQueue.byteOffset += bytesToCopy; + headOfQueue.byteLength -= bytesToCopy; + } + controller._queueTotalSize -= bytesToCopy; + ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor); + totalBytesToCopyRemaining -= bytesToCopy; + } + return ready; + } + function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) { + ReadableByteStreamControllerInvalidateBYOBRequest(controller); + pullIntoDescriptor.bytesFilled += size; + } + function ReadableByteStreamControllerHandleQueueDrain(controller) { + if (controller._queueTotalSize === 0 && controller._closeRequested) { + ReadableByteStreamControllerClearAlgorithms(controller); + ReadableStreamClose(controller._controlledReadableByteStream); + } + else { + ReadableByteStreamControllerCallPullIfNeeded(controller); + } + } + function ReadableByteStreamControllerInvalidateBYOBRequest(controller) { + if (controller._byobRequest === null) { + return; + } + controller._byobRequest._associatedReadableByteStreamController = undefined; + controller._byobRequest._view = null; + controller._byobRequest = null; + } + function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) { + while (controller._pendingPullIntos.length > 0) { + if (controller._queueTotalSize === 0) { + return; + } + const pullIntoDescriptor = controller._pendingPullIntos.peek(); + if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) { + ReadableByteStreamControllerShiftPendingPullInto(controller); + ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor); + } + } + } + function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest) { + const stream = controller._controlledReadableByteStream; + let elementSize = 1; + if (view.constructor !== DataView) { + elementSize = view.constructor.BYTES_PER_ELEMENT; + } + const ctor = view.constructor; + const buffer = TransferArrayBuffer(view.buffer); + const pullIntoDescriptor = { + buffer, + byteOffset: view.byteOffset, + byteLength: view.byteLength, + bytesFilled: 0, + elementSize, + viewConstructor: ctor, + readerType: 'byob' + }; + if (controller._pendingPullIntos.length > 0) { + controller._pendingPullIntos.push(pullIntoDescriptor); + // No ReadableByteStreamControllerCallPullIfNeeded() call since: + // - No change happens on desiredSize + // - The source has already been notified of that there's at least 1 pending read(view) + ReadableStreamAddReadIntoRequest(stream, readIntoRequest); + return; + } + if (stream._state === 'closed') { + const emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0); + readIntoRequest._closeSteps(emptyView); + return; + } + if (controller._queueTotalSize > 0) { + if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) { + const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor); + ReadableByteStreamControllerHandleQueueDrain(controller); + readIntoRequest._chunkSteps(filledView); + return; + } + if (controller._closeRequested) { + const e = new TypeError('Insufficient bytes to fill elements in the given buffer'); + ReadableByteStreamControllerError(controller, e); + readIntoRequest._errorSteps(e); + return; + } + } + controller._pendingPullIntos.push(pullIntoDescriptor); + ReadableStreamAddReadIntoRequest(stream, readIntoRequest); + ReadableByteStreamControllerCallPullIfNeeded(controller); + } + function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) { + firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer); + const stream = controller._controlledReadableByteStream; + if (ReadableStreamHasBYOBReader(stream)) { + while (ReadableStreamGetNumReadIntoRequests(stream) > 0) { + const pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller); + ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor); + } + } + } + function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) { + if (pullIntoDescriptor.bytesFilled + bytesWritten > pullIntoDescriptor.byteLength) { + throw new RangeError('bytesWritten out of range'); + } + ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor); + if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) { + // TODO: Figure out whether we should detach the buffer or not here. + return; + } + ReadableByteStreamControllerShiftPendingPullInto(controller); + const remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize; + if (remainderSize > 0) { + const end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled; + const remainder = pullIntoDescriptor.buffer.slice(end - remainderSize, end); + ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength); + } + pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer); + pullIntoDescriptor.bytesFilled -= remainderSize; + ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor); + ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller); + } + function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) { + const firstDescriptor = controller._pendingPullIntos.peek(); + const state = controller._controlledReadableByteStream._state; + if (state === 'closed') { + if (bytesWritten !== 0) { + throw new TypeError('bytesWritten must be 0 when calling respond() on a closed stream'); + } + ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor); + } + else { + ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor); + } + ReadableByteStreamControllerCallPullIfNeeded(controller); + } + function ReadableByteStreamControllerShiftPendingPullInto(controller) { + const descriptor = controller._pendingPullIntos.shift(); + ReadableByteStreamControllerInvalidateBYOBRequest(controller); + return descriptor; + } + function ReadableByteStreamControllerShouldCallPull(controller) { + const stream = controller._controlledReadableByteStream; + if (stream._state !== 'readable') { + return false; + } + if (controller._closeRequested) { + return false; + } + if (!controller._started) { + return false; + } + if (ReadableStreamHasDefaultReader(stream) && ReadableStreamGetNumReadRequests(stream) > 0) { + return true; + } + if (ReadableStreamHasBYOBReader(stream) && ReadableStreamGetNumReadIntoRequests(stream) > 0) { + return true; + } + const desiredSize = ReadableByteStreamControllerGetDesiredSize(controller); + if (desiredSize > 0) { + return true; + } + return false; + } + function ReadableByteStreamControllerClearAlgorithms(controller) { + controller._pullAlgorithm = undefined; + controller._cancelAlgorithm = undefined; + } + // A client of ReadableByteStreamController may use these functions directly to bypass state check. + function ReadableByteStreamControllerClose(controller) { + const stream = controller._controlledReadableByteStream; + if (controller._closeRequested || stream._state !== 'readable') { + return; + } + if (controller._queueTotalSize > 0) { + controller._closeRequested = true; + return; + } + if (controller._pendingPullIntos.length > 0) { + const firstPendingPullInto = controller._pendingPullIntos.peek(); + if (firstPendingPullInto.bytesFilled > 0) { + const e = new TypeError('Insufficient bytes to fill elements in the given buffer'); + ReadableByteStreamControllerError(controller, e); + throw e; + } + } + ReadableByteStreamControllerClearAlgorithms(controller); + ReadableStreamClose(stream); + } + function ReadableByteStreamControllerEnqueue(controller, chunk) { + const stream = controller._controlledReadableByteStream; + if (controller._closeRequested || stream._state !== 'readable') { + return; + } + const buffer = chunk.buffer; + const byteOffset = chunk.byteOffset; + const byteLength = chunk.byteLength; + const transferredBuffer = TransferArrayBuffer(buffer); + if (ReadableStreamHasDefaultReader(stream)) { + if (ReadableStreamGetNumReadRequests(stream) === 0) { + ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength); + } + else { + const transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength); + ReadableStreamFulfillReadRequest(stream, transferredView, false); + } + } + else if (ReadableStreamHasBYOBReader(stream)) { + // TODO: Ideally in this branch detaching should happen only if the buffer is not consumed fully. + ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength); + ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller); + } + else { + ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength); + } + ReadableByteStreamControllerCallPullIfNeeded(controller); + } + function ReadableByteStreamControllerError(controller, e) { + const stream = controller._controlledReadableByteStream; + if (stream._state !== 'readable') { + return; + } + ReadableByteStreamControllerClearPendingPullIntos(controller); + ResetQueue(controller); + ReadableByteStreamControllerClearAlgorithms(controller); + ReadableStreamError(stream, e); + } + function ReadableByteStreamControllerGetDesiredSize(controller) { + const state = controller._controlledReadableByteStream._state; + if (state === 'errored') { + return null; + } + if (state === 'closed') { + return 0; + } + return controller._strategyHWM - controller._queueTotalSize; + } + function ReadableByteStreamControllerRespond(controller, bytesWritten) { + bytesWritten = Number(bytesWritten); + if (!IsFiniteNonNegativeNumber(bytesWritten)) { + throw new RangeError('bytesWritten must be a finite'); + } + ReadableByteStreamControllerRespondInternal(controller, bytesWritten); + } + function ReadableByteStreamControllerRespondWithNewView(controller, view) { + const firstDescriptor = controller._pendingPullIntos.peek(); + if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) { + throw new RangeError('The region specified by view does not match byobRequest'); + } + if (firstDescriptor.byteLength !== view.byteLength) { + throw new RangeError('The buffer of view has different capacity than byobRequest'); + } + firstDescriptor.buffer = view.buffer; + ReadableByteStreamControllerRespondInternal(controller, view.byteLength); + } + function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) { + controller._controlledReadableByteStream = stream; + controller._pullAgain = false; + controller._pulling = false; + controller._byobRequest = null; + // Need to set the slots so that the assert doesn't fire. In the spec the slots already exist implicitly. + controller._queue = controller._queueTotalSize = undefined; + ResetQueue(controller); + controller._closeRequested = false; + controller._started = false; + controller._strategyHWM = highWaterMark; + controller._pullAlgorithm = pullAlgorithm; + controller._cancelAlgorithm = cancelAlgorithm; + controller._autoAllocateChunkSize = autoAllocateChunkSize; + controller._pendingPullIntos = new SimpleQueue(); + stream._readableStreamController = controller; + const startResult = startAlgorithm(); + uponPromise(promiseResolvedWith(startResult), () => { + controller._started = true; + ReadableByteStreamControllerCallPullIfNeeded(controller); + }, r => { + ReadableByteStreamControllerError(controller, r); + }); + } + function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingByteSource, highWaterMark) { + const controller = Object.create(ReadableByteStreamController.prototype); + let startAlgorithm = () => undefined; + let pullAlgorithm = () => promiseResolvedWith(undefined); + let cancelAlgorithm = () => promiseResolvedWith(undefined); + if (underlyingByteSource.start !== undefined) { + startAlgorithm = () => underlyingByteSource.start(controller); + } + if (underlyingByteSource.pull !== undefined) { + pullAlgorithm = () => underlyingByteSource.pull(controller); + } + if (underlyingByteSource.cancel !== undefined) { + cancelAlgorithm = reason => underlyingByteSource.cancel(reason); + } + const autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize; + SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize); + } + function SetUpReadableStreamBYOBRequest(request, controller, view) { + request._associatedReadableByteStreamController = controller; + request._view = view; + } + // Helper functions for the ReadableStreamBYOBRequest. + function byobRequestBrandCheckException(name) { + return new TypeError(`ReadableStreamBYOBRequest.prototype.${name} can only be used on a ReadableStreamBYOBRequest`); + } + // Helper functions for the ReadableByteStreamController. + function byteStreamControllerBrandCheckException(name) { + return new TypeError(`ReadableByteStreamController.prototype.${name} can only be used on a ReadableByteStreamController`); + } + + // Abstract operations for the ReadableStream. + function AcquireReadableStreamBYOBReader(stream) { + return new ReadableStreamBYOBReader(stream); + } + // ReadableStream API exposed for controllers. + function ReadableStreamAddReadIntoRequest(stream, readIntoRequest) { + stream._reader._readIntoRequests.push(readIntoRequest); + } + function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) { + const reader = stream._reader; + const readIntoRequest = reader._readIntoRequests.shift(); + if (done) { + readIntoRequest._closeSteps(chunk); + } + else { + readIntoRequest._chunkSteps(chunk); + } + } + function ReadableStreamGetNumReadIntoRequests(stream) { + return stream._reader._readIntoRequests.length; + } + function ReadableStreamHasBYOBReader(stream) { + const reader = stream._reader; + if (reader === undefined) { + return false; + } + if (!IsReadableStreamBYOBReader(reader)) { + return false; + } + return true; + } + /** + * A BYOB reader vended by a {@link ReadableStream}. + * + * @public + */ + class ReadableStreamBYOBReader { + constructor(stream) { + assertRequiredArgument(stream, 1, 'ReadableStreamBYOBReader'); + assertReadableStream(stream, 'First parameter'); + if (IsReadableStreamLocked(stream)) { + throw new TypeError('This stream has already been locked for exclusive reading by another reader'); + } + if (!IsReadableByteStreamController(stream._readableStreamController)) { + throw new TypeError('Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte ' + + 'source'); + } + ReadableStreamReaderGenericInitialize(this, stream); + this._readIntoRequests = new SimpleQueue(); + } + /** + * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or + * the reader's lock is released before the stream finishes closing. + */ + get closed() { + if (!IsReadableStreamBYOBReader(this)) { + return promiseRejectedWith(byobReaderBrandCheckException('closed')); + } + return this._closedPromise; + } + /** + * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}. + */ + cancel(reason = undefined) { + if (!IsReadableStreamBYOBReader(this)) { + return promiseRejectedWith(byobReaderBrandCheckException('cancel')); + } + if (this._ownerReadableStream === undefined) { + return promiseRejectedWith(readerLockException('cancel')); + } + return ReadableStreamReaderGenericCancel(this, reason); + } + /** + * Attempts to reads bytes into view, and returns a promise resolved with the result. + * + * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source. + */ + read(view) { + if (!IsReadableStreamBYOBReader(this)) { + return promiseRejectedWith(byobReaderBrandCheckException('read')); + } + if (!ArrayBuffer.isView(view)) { + return promiseRejectedWith(new TypeError('view must be an array buffer view')); + } + if (view.byteLength === 0) { + return promiseRejectedWith(new TypeError('view must have non-zero byteLength')); + } + if (view.buffer.byteLength === 0) { + return promiseRejectedWith(new TypeError(`view's buffer must have non-zero byteLength`)); + } + if (this._ownerReadableStream === undefined) { + return promiseRejectedWith(readerLockException('read from')); + } + let resolvePromise; + let rejectPromise; + const promise = newPromise((resolve, reject) => { + resolvePromise = resolve; + rejectPromise = reject; + }); + const readIntoRequest = { + _chunkSteps: chunk => resolvePromise({ value: chunk, done: false }), + _closeSteps: chunk => resolvePromise({ value: chunk, done: true }), + _errorSteps: e => rejectPromise(e) + }; + ReadableStreamBYOBReaderRead(this, view, readIntoRequest); + return promise; + } + /** + * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active. + * If the associated stream is errored when the lock is released, the reader will appear errored in the same way + * from now on; otherwise, the reader will appear closed. + * + * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by + * the reader's {@link ReadableStreamBYOBReader.read | read()} method has not yet been settled. Attempting to + * do so will throw a `TypeError` and leave the reader locked to the stream. + */ + releaseLock() { + if (!IsReadableStreamBYOBReader(this)) { + throw byobReaderBrandCheckException('releaseLock'); + } + if (this._ownerReadableStream === undefined) { + return; + } + if (this._readIntoRequests.length > 0) { + throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled'); + } + ReadableStreamReaderGenericRelease(this); + } + } + Object.defineProperties(ReadableStreamBYOBReader.prototype, { + cancel: { enumerable: true }, + read: { enumerable: true }, + releaseLock: { enumerable: true }, + closed: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === 'symbol') { + Object.defineProperty(ReadableStreamBYOBReader.prototype, SymbolPolyfill.toStringTag, { + value: 'ReadableStreamBYOBReader', + configurable: true + }); + } + // Abstract operations for the readers. + function IsReadableStreamBYOBReader(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) { + return false; + } + return true; + } + function ReadableStreamBYOBReaderRead(reader, view, readIntoRequest) { + const stream = reader._ownerReadableStream; + stream._disturbed = true; + if (stream._state === 'errored') { + readIntoRequest._errorSteps(stream._storedError); + } + else { + ReadableByteStreamControllerPullInto(stream._readableStreamController, view, readIntoRequest); + } + } + // Helper functions for the ReadableStreamBYOBReader. + function byobReaderBrandCheckException(name) { + return new TypeError(`ReadableStreamBYOBReader.prototype.${name} can only be used on a ReadableStreamBYOBReader`); + } + + function ExtractHighWaterMark(strategy, defaultHWM) { + const { highWaterMark } = strategy; + if (highWaterMark === undefined) { + return defaultHWM; + } + if (NumberIsNaN(highWaterMark) || highWaterMark < 0) { + throw new RangeError('Invalid highWaterMark'); + } + return highWaterMark; + } + function ExtractSizeAlgorithm(strategy) { + const { size } = strategy; + if (!size) { + return () => 1; + } + return size; + } + + function convertQueuingStrategy(init, context) { + assertDictionary(init, context); + const highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark; + const size = init === null || init === void 0 ? void 0 : init.size; + return { + highWaterMark: highWaterMark === undefined ? undefined : convertUnrestrictedDouble(highWaterMark), + size: size === undefined ? undefined : convertQueuingStrategySize(size, `${context} has member 'size' that`) + }; + } + function convertQueuingStrategySize(fn, context) { + assertFunction(fn, context); + return chunk => convertUnrestrictedDouble(fn(chunk)); + } + + function convertUnderlyingSink(original, context) { + assertDictionary(original, context); + const abort = original === null || original === void 0 ? void 0 : original.abort; + const close = original === null || original === void 0 ? void 0 : original.close; + const start = original === null || original === void 0 ? void 0 : original.start; + const type = original === null || original === void 0 ? void 0 : original.type; + const write = original === null || original === void 0 ? void 0 : original.write; + return { + abort: abort === undefined ? + undefined : + convertUnderlyingSinkAbortCallback(abort, original, `${context} has member 'abort' that`), + close: close === undefined ? + undefined : + convertUnderlyingSinkCloseCallback(close, original, `${context} has member 'close' that`), + start: start === undefined ? + undefined : + convertUnderlyingSinkStartCallback(start, original, `${context} has member 'start' that`), + write: write === undefined ? + undefined : + convertUnderlyingSinkWriteCallback(write, original, `${context} has member 'write' that`), + type + }; + } + function convertUnderlyingSinkAbortCallback(fn, original, context) { + assertFunction(fn, context); + return (reason) => promiseCall(fn, original, [reason]); + } + function convertUnderlyingSinkCloseCallback(fn, original, context) { + assertFunction(fn, context); + return () => promiseCall(fn, original, []); + } + function convertUnderlyingSinkStartCallback(fn, original, context) { + assertFunction(fn, context); + return (controller) => reflectCall(fn, original, [controller]); + } + function convertUnderlyingSinkWriteCallback(fn, original, context) { + assertFunction(fn, context); + return (chunk, controller) => promiseCall(fn, original, [chunk, controller]); + } + + function assertWritableStream(x, context) { + if (!IsWritableStream(x)) { + throw new TypeError(`${context} is not a WritableStream.`); + } + } + + /** + * A writable stream represents a destination for data, into which you can write. + * + * @public + */ + class WritableStream$1 { + constructor(rawUnderlyingSink = {}, rawStrategy = {}) { + if (rawUnderlyingSink === undefined) { + rawUnderlyingSink = null; + } + else { + assertObject(rawUnderlyingSink, 'First parameter'); + } + const strategy = convertQueuingStrategy(rawStrategy, 'Second parameter'); + const underlyingSink = convertUnderlyingSink(rawUnderlyingSink, 'First parameter'); + InitializeWritableStream(this); + const type = underlyingSink.type; + if (type !== undefined) { + throw new RangeError('Invalid type is specified'); + } + const sizeAlgorithm = ExtractSizeAlgorithm(strategy); + const highWaterMark = ExtractHighWaterMark(strategy, 1); + SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, highWaterMark, sizeAlgorithm); + } + /** + * Returns whether or not the writable stream is locked to a writer. + */ + get locked() { + if (!IsWritableStream(this)) { + throw streamBrandCheckException('locked'); + } + return IsWritableStreamLocked(this); + } + /** + * Aborts the stream, signaling that the producer can no longer successfully write to the stream and it is to be + * immediately moved to an errored state, with any queued-up writes discarded. This will also execute any abort + * mechanism of the underlying sink. + * + * The returned promise will fulfill if the stream shuts down successfully, or reject if the underlying sink signaled + * that there was an error doing so. Additionally, it will reject with a `TypeError` (without attempting to cancel + * the stream) if the stream is currently locked. + */ + abort(reason = undefined) { + if (!IsWritableStream(this)) { + return promiseRejectedWith(streamBrandCheckException('abort')); + } + if (IsWritableStreamLocked(this)) { + return promiseRejectedWith(new TypeError('Cannot abort a stream that already has a writer')); + } + return WritableStreamAbort(this, reason); + } + /** + * Closes the stream. The underlying sink will finish processing any previously-written chunks, before invoking its + * close behavior. During this time any further attempts to write will fail (without erroring the stream). + * + * The method returns a promise that will fulfill if all remaining chunks are successfully written and the stream + * successfully closes, or rejects if an error is encountered during this process. Additionally, it will reject with + * a `TypeError` (without attempting to cancel the stream) if the stream is currently locked. + */ + close() { + if (!IsWritableStream(this)) { + return promiseRejectedWith(streamBrandCheckException('close')); + } + if (IsWritableStreamLocked(this)) { + return promiseRejectedWith(new TypeError('Cannot close a stream that already has a writer')); + } + if (WritableStreamCloseQueuedOrInFlight(this)) { + return promiseRejectedWith(new TypeError('Cannot close an already-closing stream')); + } + return WritableStreamClose(this); + } + /** + * Creates a {@link WritableStreamDefaultWriter | writer} and locks the stream to the new writer. While the stream + * is locked, no other writer can be acquired until this one is released. + * + * This functionality is especially useful for creating abstractions that desire the ability to write to a stream + * without interruption or interleaving. By getting a writer for the stream, you can ensure nobody else can write at + * the same time, which would cause the resulting written data to be unpredictable and probably useless. + */ + getWriter() { + if (!IsWritableStream(this)) { + throw streamBrandCheckException('getWriter'); + } + return AcquireWritableStreamDefaultWriter(this); + } + } + Object.defineProperties(WritableStream$1.prototype, { + abort: { enumerable: true }, + close: { enumerable: true }, + getWriter: { enumerable: true }, + locked: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === 'symbol') { + Object.defineProperty(WritableStream$1.prototype, SymbolPolyfill.toStringTag, { + value: 'WritableStream', + configurable: true + }); + } + // Abstract operations for the WritableStream. + function AcquireWritableStreamDefaultWriter(stream) { + return new WritableStreamDefaultWriter$1(stream); + } + // Throws if and only if startAlgorithm throws. + function CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark = 1, sizeAlgorithm = () => 1) { + const stream = Object.create(WritableStream$1.prototype); + InitializeWritableStream(stream); + const controller = Object.create(WritableStreamDefaultController.prototype); + SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm); + return stream; + } + function InitializeWritableStream(stream) { + stream._state = 'writable'; + // The error that will be reported by new method calls once the state becomes errored. Only set when [[state]] is + // 'erroring' or 'errored'. May be set to an undefined value. + stream._storedError = undefined; + stream._writer = undefined; + // Initialize to undefined first because the constructor of the controller checks this + // variable to validate the caller. + stream._writableStreamController = undefined; + // This queue is placed here instead of the writer class in order to allow for passing a writer to the next data + // producer without waiting for the queued writes to finish. + stream._writeRequests = new SimpleQueue(); + // Write requests are removed from _writeRequests when write() is called on the underlying sink. This prevents + // them from being erroneously rejected on error. If a write() call is in-flight, the request is stored here. + stream._inFlightWriteRequest = undefined; + // The promise that was returned from writer.close(). Stored here because it may be fulfilled after the writer + // has been detached. + stream._closeRequest = undefined; + // Close request is removed from _closeRequest when close() is called on the underlying sink. This prevents it + // from being erroneously rejected on error. If a close() call is in-flight, the request is stored here. + stream._inFlightCloseRequest = undefined; + // The promise that was returned from writer.abort(). This may also be fulfilled after the writer has detached. + stream._pendingAbortRequest = undefined; + // The backpressure signal set by the controller. + stream._backpressure = false; + } + function IsWritableStream(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) { + return false; + } + return true; + } + function IsWritableStreamLocked(stream) { + if (stream._writer === undefined) { + return false; + } + return true; + } + function WritableStreamAbort(stream, reason) { + const state = stream._state; + if (state === 'closed' || state === 'errored') { + return promiseResolvedWith(undefined); + } + if (stream._pendingAbortRequest !== undefined) { + return stream._pendingAbortRequest._promise; + } + let wasAlreadyErroring = false; + if (state === 'erroring') { + wasAlreadyErroring = true; + // reason will not be used, so don't keep a reference to it. + reason = undefined; + } + const promise = newPromise((resolve, reject) => { + stream._pendingAbortRequest = { + _promise: undefined, + _resolve: resolve, + _reject: reject, + _reason: reason, + _wasAlreadyErroring: wasAlreadyErroring + }; + }); + stream._pendingAbortRequest._promise = promise; + if (!wasAlreadyErroring) { + WritableStreamStartErroring(stream, reason); + } + return promise; + } + function WritableStreamClose(stream) { + const state = stream._state; + if (state === 'closed' || state === 'errored') { + return promiseRejectedWith(new TypeError(`The stream (in ${state} state) is not in the writable state and cannot be closed`)); + } + const promise = newPromise((resolve, reject) => { + const closeRequest = { + _resolve: resolve, + _reject: reject + }; + stream._closeRequest = closeRequest; + }); + const writer = stream._writer; + if (writer !== undefined && stream._backpressure && state === 'writable') { + defaultWriterReadyPromiseResolve(writer); + } + WritableStreamDefaultControllerClose(stream._writableStreamController); + return promise; + } + // WritableStream API exposed for controllers. + function WritableStreamAddWriteRequest(stream) { + const promise = newPromise((resolve, reject) => { + const writeRequest = { + _resolve: resolve, + _reject: reject + }; + stream._writeRequests.push(writeRequest); + }); + return promise; + } + function WritableStreamDealWithRejection(stream, error) { + const state = stream._state; + if (state === 'writable') { + WritableStreamStartErroring(stream, error); + return; + } + WritableStreamFinishErroring(stream); + } + function WritableStreamStartErroring(stream, reason) { + const controller = stream._writableStreamController; + stream._state = 'erroring'; + stream._storedError = reason; + const writer = stream._writer; + if (writer !== undefined) { + WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason); + } + if (!WritableStreamHasOperationMarkedInFlight(stream) && controller._started) { + WritableStreamFinishErroring(stream); + } + } + function WritableStreamFinishErroring(stream) { + stream._state = 'errored'; + stream._writableStreamController[ErrorSteps](); + const storedError = stream._storedError; + stream._writeRequests.forEach(writeRequest => { + writeRequest._reject(storedError); + }); + stream._writeRequests = new SimpleQueue(); + if (stream._pendingAbortRequest === undefined) { + WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream); + return; + } + const abortRequest = stream._pendingAbortRequest; + stream._pendingAbortRequest = undefined; + if (abortRequest._wasAlreadyErroring) { + abortRequest._reject(storedError); + WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream); + return; + } + const promise = stream._writableStreamController[AbortSteps](abortRequest._reason); + uponPromise(promise, () => { + abortRequest._resolve(); + WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream); + }, (reason) => { + abortRequest._reject(reason); + WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream); + }); + } + function WritableStreamFinishInFlightWrite(stream) { + stream._inFlightWriteRequest._resolve(undefined); + stream._inFlightWriteRequest = undefined; + } + function WritableStreamFinishInFlightWriteWithError(stream, error) { + stream._inFlightWriteRequest._reject(error); + stream._inFlightWriteRequest = undefined; + WritableStreamDealWithRejection(stream, error); + } + function WritableStreamFinishInFlightClose(stream) { + stream._inFlightCloseRequest._resolve(undefined); + stream._inFlightCloseRequest = undefined; + const state = stream._state; + if (state === 'erroring') { + // The error was too late to do anything, so it is ignored. + stream._storedError = undefined; + if (stream._pendingAbortRequest !== undefined) { + stream._pendingAbortRequest._resolve(); + stream._pendingAbortRequest = undefined; + } + } + stream._state = 'closed'; + const writer = stream._writer; + if (writer !== undefined) { + defaultWriterClosedPromiseResolve(writer); + } + } + function WritableStreamFinishInFlightCloseWithError(stream, error) { + stream._inFlightCloseRequest._reject(error); + stream._inFlightCloseRequest = undefined; + // Never execute sink abort() after sink close(). + if (stream._pendingAbortRequest !== undefined) { + stream._pendingAbortRequest._reject(error); + stream._pendingAbortRequest = undefined; + } + WritableStreamDealWithRejection(stream, error); + } + // TODO(ricea): Fix alphabetical order. + function WritableStreamCloseQueuedOrInFlight(stream) { + if (stream._closeRequest === undefined && stream._inFlightCloseRequest === undefined) { + return false; + } + return true; + } + function WritableStreamHasOperationMarkedInFlight(stream) { + if (stream._inFlightWriteRequest === undefined && stream._inFlightCloseRequest === undefined) { + return false; + } + return true; + } + function WritableStreamMarkCloseRequestInFlight(stream) { + stream._inFlightCloseRequest = stream._closeRequest; + stream._closeRequest = undefined; + } + function WritableStreamMarkFirstWriteRequestInFlight(stream) { + stream._inFlightWriteRequest = stream._writeRequests.shift(); + } + function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) { + if (stream._closeRequest !== undefined) { + stream._closeRequest._reject(stream._storedError); + stream._closeRequest = undefined; + } + const writer = stream._writer; + if (writer !== undefined) { + defaultWriterClosedPromiseReject(writer, stream._storedError); + } + } + function WritableStreamUpdateBackpressure(stream, backpressure) { + const writer = stream._writer; + if (writer !== undefined && backpressure !== stream._backpressure) { + if (backpressure) { + defaultWriterReadyPromiseReset(writer); + } + else { + defaultWriterReadyPromiseResolve(writer); + } + } + stream._backpressure = backpressure; + } + /** + * A default writer vended by a {@link WritableStream}. + * + * @public + */ + class WritableStreamDefaultWriter$1 { + constructor(stream) { + assertRequiredArgument(stream, 1, 'WritableStreamDefaultWriter'); + assertWritableStream(stream, 'First parameter'); + if (IsWritableStreamLocked(stream)) { + throw new TypeError('This stream has already been locked for exclusive writing by another writer'); + } + this._ownerWritableStream = stream; + stream._writer = this; + const state = stream._state; + if (state === 'writable') { + if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._backpressure) { + defaultWriterReadyPromiseInitialize(this); + } + else { + defaultWriterReadyPromiseInitializeAsResolved(this); + } + defaultWriterClosedPromiseInitialize(this); + } + else if (state === 'erroring') { + defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError); + defaultWriterClosedPromiseInitialize(this); + } + else if (state === 'closed') { + defaultWriterReadyPromiseInitializeAsResolved(this); + defaultWriterClosedPromiseInitializeAsResolved(this); + } + else { + const storedError = stream._storedError; + defaultWriterReadyPromiseInitializeAsRejected(this, storedError); + defaultWriterClosedPromiseInitializeAsRejected(this, storedError); + } + } + /** + * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or + * the writer’s lock is released before the stream finishes closing. + */ + get closed() { + if (!IsWritableStreamDefaultWriter(this)) { + return promiseRejectedWith(defaultWriterBrandCheckException('closed')); + } + return this._closedPromise; + } + /** + * Returns the desired size to fill the stream’s internal queue. It can be negative, if the queue is over-full. + * A producer can use this information to determine the right amount of data to write. + * + * It will be `null` if the stream cannot be successfully written to (due to either being errored, or having an abort + * queued up). It will return zero if the stream is closed. And the getter will throw an exception if invoked when + * the writer’s lock is released. + */ + get desiredSize() { + if (!IsWritableStreamDefaultWriter(this)) { + throw defaultWriterBrandCheckException('desiredSize'); + } + if (this._ownerWritableStream === undefined) { + throw defaultWriterLockException('desiredSize'); + } + return WritableStreamDefaultWriterGetDesiredSize(this); + } + /** + * Returns a promise that will be fulfilled when the desired size to fill the stream’s internal queue transitions + * from non-positive to positive, signaling that it is no longer applying backpressure. Once the desired size dips + * back to zero or below, the getter will return a new promise that stays pending until the next transition. + * + * If the stream becomes errored or aborted, or the writer’s lock is released, the returned promise will become + * rejected. + */ + get ready() { + if (!IsWritableStreamDefaultWriter(this)) { + return promiseRejectedWith(defaultWriterBrandCheckException('ready')); + } + return this._readyPromise; + } + /** + * If the reader is active, behaves the same as {@link WritableStream.abort | stream.abort(reason)}. + */ + abort(reason = undefined) { + if (!IsWritableStreamDefaultWriter(this)) { + return promiseRejectedWith(defaultWriterBrandCheckException('abort')); + } + if (this._ownerWritableStream === undefined) { + return promiseRejectedWith(defaultWriterLockException('abort')); + } + return WritableStreamDefaultWriterAbort(this, reason); + } + /** + * If the reader is active, behaves the same as {@link WritableStream.close | stream.close()}. + */ + close() { + if (!IsWritableStreamDefaultWriter(this)) { + return promiseRejectedWith(defaultWriterBrandCheckException('close')); + } + const stream = this._ownerWritableStream; + if (stream === undefined) { + return promiseRejectedWith(defaultWriterLockException('close')); + } + if (WritableStreamCloseQueuedOrInFlight(stream)) { + return promiseRejectedWith(new TypeError('Cannot close an already-closing stream')); + } + return WritableStreamDefaultWriterClose(this); + } + /** + * Releases the writer’s lock on the corresponding stream. After the lock is released, the writer is no longer active. + * If the associated stream is errored when the lock is released, the writer will appear errored in the same way from + * now on; otherwise, the writer will appear closed. + * + * Note that the lock can still be released even if some ongoing writes have not yet finished (i.e. even if the + * promises returned from previous calls to {@link WritableStreamDefaultWriter.write | write()} have not yet settled). + * It’s not necessary to hold the lock on the writer for the duration of the write; the lock instead simply prevents + * other producers from writing in an interleaved manner. + */ + releaseLock() { + if (!IsWritableStreamDefaultWriter(this)) { + throw defaultWriterBrandCheckException('releaseLock'); + } + const stream = this._ownerWritableStream; + if (stream === undefined) { + return; + } + WritableStreamDefaultWriterRelease(this); + } + write(chunk = undefined) { + if (!IsWritableStreamDefaultWriter(this)) { + return promiseRejectedWith(defaultWriterBrandCheckException('write')); + } + if (this._ownerWritableStream === undefined) { + return promiseRejectedWith(defaultWriterLockException('write to')); + } + return WritableStreamDefaultWriterWrite(this, chunk); + } + } + Object.defineProperties(WritableStreamDefaultWriter$1.prototype, { + abort: { enumerable: true }, + close: { enumerable: true }, + releaseLock: { enumerable: true }, + write: { enumerable: true }, + closed: { enumerable: true }, + desiredSize: { enumerable: true }, + ready: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === 'symbol') { + Object.defineProperty(WritableStreamDefaultWriter$1.prototype, SymbolPolyfill.toStringTag, { + value: 'WritableStreamDefaultWriter', + configurable: true + }); + } + // Abstract operations for the WritableStreamDefaultWriter. + function IsWritableStreamDefaultWriter(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_ownerWritableStream')) { + return false; + } + return true; + } + // A client of WritableStreamDefaultWriter may use these functions directly to bypass state check. + function WritableStreamDefaultWriterAbort(writer, reason) { + const stream = writer._ownerWritableStream; + return WritableStreamAbort(stream, reason); + } + function WritableStreamDefaultWriterClose(writer) { + const stream = writer._ownerWritableStream; + return WritableStreamClose(stream); + } + function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) { + const stream = writer._ownerWritableStream; + const state = stream._state; + if (WritableStreamCloseQueuedOrInFlight(stream) || state === 'closed') { + return promiseResolvedWith(undefined); + } + if (state === 'errored') { + return promiseRejectedWith(stream._storedError); + } + return WritableStreamDefaultWriterClose(writer); + } + function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) { + if (writer._closedPromiseState === 'pending') { + defaultWriterClosedPromiseReject(writer, error); + } + else { + defaultWriterClosedPromiseResetToRejected(writer, error); + } + } + function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) { + if (writer._readyPromiseState === 'pending') { + defaultWriterReadyPromiseReject(writer, error); + } + else { + defaultWriterReadyPromiseResetToRejected(writer, error); + } + } + function WritableStreamDefaultWriterGetDesiredSize(writer) { + const stream = writer._ownerWritableStream; + const state = stream._state; + if (state === 'errored' || state === 'erroring') { + return null; + } + if (state === 'closed') { + return 0; + } + return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController); + } + function WritableStreamDefaultWriterRelease(writer) { + const stream = writer._ownerWritableStream; + const releasedError = new TypeError(`Writer was released and can no longer be used to monitor the stream's closedness`); + WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError); + // The state transitions to "errored" before the sink abort() method runs, but the writer.closed promise is not + // rejected until afterwards. This means that simply testing state will not work. + WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError); + stream._writer = undefined; + writer._ownerWritableStream = undefined; + } + function WritableStreamDefaultWriterWrite(writer, chunk) { + const stream = writer._ownerWritableStream; + const controller = stream._writableStreamController; + const chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk); + if (stream !== writer._ownerWritableStream) { + return promiseRejectedWith(defaultWriterLockException('write to')); + } + const state = stream._state; + if (state === 'errored') { + return promiseRejectedWith(stream._storedError); + } + if (WritableStreamCloseQueuedOrInFlight(stream) || state === 'closed') { + return promiseRejectedWith(new TypeError('The stream is closing or closed and cannot be written to')); + } + if (state === 'erroring') { + return promiseRejectedWith(stream._storedError); + } + const promise = WritableStreamAddWriteRequest(stream); + WritableStreamDefaultControllerWrite(controller, chunk, chunkSize); + return promise; + } + const closeSentinel = {}; + /** + * Allows control of a {@link WritableStream | writable stream}'s state and internal queue. + * + * @public + */ + class WritableStreamDefaultController { + constructor() { + throw new TypeError('Illegal constructor'); + } + /** + * Closes the controlled writable stream, making all future interactions with it fail with the given error `e`. + * + * This method is rarely used, since usually it suffices to return a rejected promise from one of the underlying + * sink's methods. However, it can be useful for suddenly shutting down a stream in response to an event outside the + * normal lifecycle of interactions with the underlying sink. + */ + error(e = undefined) { + if (!IsWritableStreamDefaultController(this)) { + throw new TypeError('WritableStreamDefaultController.prototype.error can only be used on a WritableStreamDefaultController'); + } + const state = this._controlledWritableStream._state; + if (state !== 'writable') { + // The stream is closed, errored or will be soon. The sink can't do anything useful if it gets an error here, so + // just treat it as a no-op. + return; + } + WritableStreamDefaultControllerError(this, e); + } + /** @internal */ + [AbortSteps](reason) { + const result = this._abortAlgorithm(reason); + WritableStreamDefaultControllerClearAlgorithms(this); + return result; + } + /** @internal */ + [ErrorSteps]() { + ResetQueue(this); + } + } + Object.defineProperties(WritableStreamDefaultController.prototype, { + error: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === 'symbol') { + Object.defineProperty(WritableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, { + value: 'WritableStreamDefaultController', + configurable: true + }); + } + // Abstract operations implementing interface required by the WritableStream. + function IsWritableStreamDefaultController(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_controlledWritableStream')) { + return false; + } + return true; + } + function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) { + controller._controlledWritableStream = stream; + stream._writableStreamController = controller; + // Need to set the slots so that the assert doesn't fire. In the spec the slots already exist implicitly. + controller._queue = undefined; + controller._queueTotalSize = undefined; + ResetQueue(controller); + controller._started = false; + controller._strategySizeAlgorithm = sizeAlgorithm; + controller._strategyHWM = highWaterMark; + controller._writeAlgorithm = writeAlgorithm; + controller._closeAlgorithm = closeAlgorithm; + controller._abortAlgorithm = abortAlgorithm; + const backpressure = WritableStreamDefaultControllerGetBackpressure(controller); + WritableStreamUpdateBackpressure(stream, backpressure); + const startResult = startAlgorithm(); + const startPromise = promiseResolvedWith(startResult); + uponPromise(startPromise, () => { + controller._started = true; + WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller); + }, r => { + controller._started = true; + WritableStreamDealWithRejection(stream, r); + }); + } + function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, highWaterMark, sizeAlgorithm) { + const controller = Object.create(WritableStreamDefaultController.prototype); + let startAlgorithm = () => undefined; + let writeAlgorithm = () => promiseResolvedWith(undefined); + let closeAlgorithm = () => promiseResolvedWith(undefined); + let abortAlgorithm = () => promiseResolvedWith(undefined); + if (underlyingSink.start !== undefined) { + startAlgorithm = () => underlyingSink.start(controller); + } + if (underlyingSink.write !== undefined) { + writeAlgorithm = chunk => underlyingSink.write(chunk, controller); + } + if (underlyingSink.close !== undefined) { + closeAlgorithm = () => underlyingSink.close(); + } + if (underlyingSink.abort !== undefined) { + abortAlgorithm = reason => underlyingSink.abort(reason); + } + SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm); + } + // ClearAlgorithms may be called twice. Erroring the same stream in multiple ways will often result in redundant calls. + function WritableStreamDefaultControllerClearAlgorithms(controller) { + controller._writeAlgorithm = undefined; + controller._closeAlgorithm = undefined; + controller._abortAlgorithm = undefined; + controller._strategySizeAlgorithm = undefined; + } + function WritableStreamDefaultControllerClose(controller) { + EnqueueValueWithSize(controller, closeSentinel, 0); + WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller); + } + function WritableStreamDefaultControllerGetChunkSize(controller, chunk) { + try { + return controller._strategySizeAlgorithm(chunk); + } + catch (chunkSizeE) { + WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE); + return 1; + } + } + function WritableStreamDefaultControllerGetDesiredSize(controller) { + return controller._strategyHWM - controller._queueTotalSize; + } + function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) { + try { + EnqueueValueWithSize(controller, chunk, chunkSize); + } + catch (enqueueE) { + WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE); + return; + } + const stream = controller._controlledWritableStream; + if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._state === 'writable') { + const backpressure = WritableStreamDefaultControllerGetBackpressure(controller); + WritableStreamUpdateBackpressure(stream, backpressure); + } + WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller); + } + // Abstract operations for the WritableStreamDefaultController. + function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) { + const stream = controller._controlledWritableStream; + if (!controller._started) { + return; + } + if (stream._inFlightWriteRequest !== undefined) { + return; + } + const state = stream._state; + if (state === 'erroring') { + WritableStreamFinishErroring(stream); + return; + } + if (controller._queue.length === 0) { + return; + } + const value = PeekQueueValue(controller); + if (value === closeSentinel) { + WritableStreamDefaultControllerProcessClose(controller); + } + else { + WritableStreamDefaultControllerProcessWrite(controller, value); + } + } + function WritableStreamDefaultControllerErrorIfNeeded(controller, error) { + if (controller._controlledWritableStream._state === 'writable') { + WritableStreamDefaultControllerError(controller, error); + } + } + function WritableStreamDefaultControllerProcessClose(controller) { + const stream = controller._controlledWritableStream; + WritableStreamMarkCloseRequestInFlight(stream); + DequeueValue(controller); + const sinkClosePromise = controller._closeAlgorithm(); + WritableStreamDefaultControllerClearAlgorithms(controller); + uponPromise(sinkClosePromise, () => { + WritableStreamFinishInFlightClose(stream); + }, reason => { + WritableStreamFinishInFlightCloseWithError(stream, reason); + }); + } + function WritableStreamDefaultControllerProcessWrite(controller, chunk) { + const stream = controller._controlledWritableStream; + WritableStreamMarkFirstWriteRequestInFlight(stream); + const sinkWritePromise = controller._writeAlgorithm(chunk); + uponPromise(sinkWritePromise, () => { + WritableStreamFinishInFlightWrite(stream); + const state = stream._state; + DequeueValue(controller); + if (!WritableStreamCloseQueuedOrInFlight(stream) && state === 'writable') { + const backpressure = WritableStreamDefaultControllerGetBackpressure(controller); + WritableStreamUpdateBackpressure(stream, backpressure); + } + WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller); + }, reason => { + if (stream._state === 'writable') { + WritableStreamDefaultControllerClearAlgorithms(controller); + } + WritableStreamFinishInFlightWriteWithError(stream, reason); + }); + } + function WritableStreamDefaultControllerGetBackpressure(controller) { + const desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller); + return desiredSize <= 0; + } + // A client of WritableStreamDefaultController may use these functions directly to bypass state check. + function WritableStreamDefaultControllerError(controller, error) { + const stream = controller._controlledWritableStream; + WritableStreamDefaultControllerClearAlgorithms(controller); + WritableStreamStartErroring(stream, error); + } + // Helper functions for the WritableStream. + function streamBrandCheckException(name) { + return new TypeError(`WritableStream.prototype.${name} can only be used on a WritableStream`); + } + // Helper functions for the WritableStreamDefaultWriter. + function defaultWriterBrandCheckException(name) { + return new TypeError(`WritableStreamDefaultWriter.prototype.${name} can only be used on a WritableStreamDefaultWriter`); + } + function defaultWriterLockException(name) { + return new TypeError('Cannot ' + name + ' a stream using a released writer'); + } + function defaultWriterClosedPromiseInitialize(writer) { + writer._closedPromise = newPromise((resolve, reject) => { + writer._closedPromise_resolve = resolve; + writer._closedPromise_reject = reject; + writer._closedPromiseState = 'pending'; + }); + } + function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) { + defaultWriterClosedPromiseInitialize(writer); + defaultWriterClosedPromiseReject(writer, reason); + } + function defaultWriterClosedPromiseInitializeAsResolved(writer) { + defaultWriterClosedPromiseInitialize(writer); + defaultWriterClosedPromiseResolve(writer); + } + function defaultWriterClosedPromiseReject(writer, reason) { + if (writer._closedPromise_reject === undefined) { + return; + } + setPromiseIsHandledToTrue(writer._closedPromise); + writer._closedPromise_reject(reason); + writer._closedPromise_resolve = undefined; + writer._closedPromise_reject = undefined; + writer._closedPromiseState = 'rejected'; + } + function defaultWriterClosedPromiseResetToRejected(writer, reason) { + defaultWriterClosedPromiseInitializeAsRejected(writer, reason); + } + function defaultWriterClosedPromiseResolve(writer) { + if (writer._closedPromise_resolve === undefined) { + return; + } + writer._closedPromise_resolve(undefined); + writer._closedPromise_resolve = undefined; + writer._closedPromise_reject = undefined; + writer._closedPromiseState = 'resolved'; + } + function defaultWriterReadyPromiseInitialize(writer) { + writer._readyPromise = newPromise((resolve, reject) => { + writer._readyPromise_resolve = resolve; + writer._readyPromise_reject = reject; + }); + writer._readyPromiseState = 'pending'; + } + function defaultWriterReadyPromiseInitializeAsRejected(writer, reason) { + defaultWriterReadyPromiseInitialize(writer); + defaultWriterReadyPromiseReject(writer, reason); + } + function defaultWriterReadyPromiseInitializeAsResolved(writer) { + defaultWriterReadyPromiseInitialize(writer); + defaultWriterReadyPromiseResolve(writer); + } + function defaultWriterReadyPromiseReject(writer, reason) { + if (writer._readyPromise_reject === undefined) { + return; + } + setPromiseIsHandledToTrue(writer._readyPromise); + writer._readyPromise_reject(reason); + writer._readyPromise_resolve = undefined; + writer._readyPromise_reject = undefined; + writer._readyPromiseState = 'rejected'; + } + function defaultWriterReadyPromiseReset(writer) { + defaultWriterReadyPromiseInitialize(writer); + } + function defaultWriterReadyPromiseResetToRejected(writer, reason) { + defaultWriterReadyPromiseInitializeAsRejected(writer, reason); + } + function defaultWriterReadyPromiseResolve(writer) { + if (writer._readyPromise_resolve === undefined) { + return; + } + writer._readyPromise_resolve(undefined); + writer._readyPromise_resolve = undefined; + writer._readyPromise_reject = undefined; + writer._readyPromiseState = 'fulfilled'; + } + + function isAbortSignal(value) { + if (typeof value !== 'object' || value === null) { + return false; + } + try { + return typeof value.aborted === 'boolean'; + } + catch (_a) { + // AbortSignal.prototype.aborted throws if its brand check fails + return false; + } + } + + /// + const NativeDOMException = typeof DOMException !== 'undefined' ? DOMException : undefined; + + /// + function isDOMExceptionConstructor(ctor) { + if (!(typeof ctor === 'function' || typeof ctor === 'object')) { + return false; + } + try { + new ctor(); + return true; + } + catch (_a) { + return false; + } + } + function createDOMExceptionPolyfill() { + const ctor = function DOMException(message, name) { + this.message = message || ''; + this.name = name || 'Error'; + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + }; + ctor.prototype = Object.create(Error.prototype); + Object.defineProperty(ctor.prototype, 'constructor', { value: ctor, writable: true, configurable: true }); + return ctor; + } + const DOMException$1 = isDOMExceptionConstructor(NativeDOMException) ? NativeDOMException : createDOMExceptionPolyfill(); + + function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) { + const reader = AcquireReadableStreamDefaultReader(source); + const writer = AcquireWritableStreamDefaultWriter(dest); + source._disturbed = true; + let shuttingDown = false; + // This is used to keep track of the spec's requirement that we wait for ongoing writes during shutdown. + let currentWrite = promiseResolvedWith(undefined); + return newPromise((resolve, reject) => { + let abortAlgorithm; + if (signal !== undefined) { + abortAlgorithm = () => { + const error = new DOMException$1('Aborted', 'AbortError'); + const actions = []; + if (!preventAbort) { + actions.push(() => { + if (dest._state === 'writable') { + return WritableStreamAbort(dest, error); + } + return promiseResolvedWith(undefined); + }); + } + if (!preventCancel) { + actions.push(() => { + if (source._state === 'readable') { + return ReadableStreamCancel(source, error); + } + return promiseResolvedWith(undefined); + }); + } + shutdownWithAction(() => Promise.all(actions.map(action => action())), true, error); + }; + if (signal.aborted) { + abortAlgorithm(); + return; + } + signal.addEventListener('abort', abortAlgorithm); + } + // Using reader and writer, read all chunks from this and write them to dest + // - Backpressure must be enforced + // - Shutdown must stop all activity + function pipeLoop() { + return newPromise((resolveLoop, rejectLoop) => { + function next(done) { + if (done) { + resolveLoop(); + } + else { + // Use `PerformPromiseThen` instead of `uponPromise` to avoid + // adding unnecessary `.catch(rethrowAssertionErrorRejection)` handlers + PerformPromiseThen(pipeStep(), next, rejectLoop); + } + } + next(false); + }); + } + function pipeStep() { + if (shuttingDown) { + return promiseResolvedWith(true); + } + return PerformPromiseThen(writer._readyPromise, () => { + return newPromise((resolveRead, rejectRead) => { + ReadableStreamDefaultReaderRead(reader, { + _chunkSteps: chunk => { + currentWrite = PerformPromiseThen(WritableStreamDefaultWriterWrite(writer, chunk), undefined, noop); + resolveRead(false); + }, + _closeSteps: () => resolveRead(true), + _errorSteps: rejectRead + }); + }); + }); + } + // Errors must be propagated forward + isOrBecomesErrored(source, reader._closedPromise, storedError => { + if (!preventAbort) { + shutdownWithAction(() => WritableStreamAbort(dest, storedError), true, storedError); + } + else { + shutdown(true, storedError); + } + }); + // Errors must be propagated backward + isOrBecomesErrored(dest, writer._closedPromise, storedError => { + if (!preventCancel) { + shutdownWithAction(() => ReadableStreamCancel(source, storedError), true, storedError); + } + else { + shutdown(true, storedError); + } + }); + // Closing must be propagated forward + isOrBecomesClosed(source, reader._closedPromise, () => { + if (!preventClose) { + shutdownWithAction(() => WritableStreamDefaultWriterCloseWithErrorPropagation(writer)); + } + else { + shutdown(); + } + }); + // Closing must be propagated backward + if (WritableStreamCloseQueuedOrInFlight(dest) || dest._state === 'closed') { + const destClosed = new TypeError('the destination writable stream closed before all data could be piped to it'); + if (!preventCancel) { + shutdownWithAction(() => ReadableStreamCancel(source, destClosed), true, destClosed); + } + else { + shutdown(true, destClosed); + } + } + setPromiseIsHandledToTrue(pipeLoop()); + function waitForWritesToFinish() { + // Another write may have started while we were waiting on this currentWrite, so we have to be sure to wait + // for that too. + const oldCurrentWrite = currentWrite; + return PerformPromiseThen(currentWrite, () => oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : undefined); + } + function isOrBecomesErrored(stream, promise, action) { + if (stream._state === 'errored') { + action(stream._storedError); + } + else { + uponRejection(promise, action); + } + } + function isOrBecomesClosed(stream, promise, action) { + if (stream._state === 'closed') { + action(); + } + else { + uponFulfillment(promise, action); + } + } + function shutdownWithAction(action, originalIsError, originalError) { + if (shuttingDown) { + return; + } + shuttingDown = true; + if (dest._state === 'writable' && !WritableStreamCloseQueuedOrInFlight(dest)) { + uponFulfillment(waitForWritesToFinish(), doTheRest); + } + else { + doTheRest(); + } + function doTheRest() { + uponPromise(action(), () => finalize(originalIsError, originalError), newError => finalize(true, newError)); + } + } + function shutdown(isError, error) { + if (shuttingDown) { + return; + } + shuttingDown = true; + if (dest._state === 'writable' && !WritableStreamCloseQueuedOrInFlight(dest)) { + uponFulfillment(waitForWritesToFinish(), () => finalize(isError, error)); + } + else { + finalize(isError, error); + } + } + function finalize(isError, error) { + WritableStreamDefaultWriterRelease(writer); + ReadableStreamReaderGenericRelease(reader); + if (signal !== undefined) { + signal.removeEventListener('abort', abortAlgorithm); + } + if (isError) { + reject(error); + } + else { + resolve(undefined); + } + } + }); + } + + /** + * Allows control of a {@link ReadableStream | readable stream}'s state and internal queue. + * + * @public + */ + class ReadableStreamDefaultController { + constructor() { + throw new TypeError('Illegal constructor'); + } + /** + * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is + * over-full. An underlying source ought to use this information to determine when and how to apply backpressure. + */ + get desiredSize() { + if (!IsReadableStreamDefaultController(this)) { + throw defaultControllerBrandCheckException('desiredSize'); + } + return ReadableStreamDefaultControllerGetDesiredSize(this); + } + /** + * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from + * the stream, but once those are read, the stream will become closed. + */ + close() { + if (!IsReadableStreamDefaultController(this)) { + throw defaultControllerBrandCheckException('close'); + } + if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) { + throw new TypeError('The stream is not in a state that permits close'); + } + ReadableStreamDefaultControllerClose(this); + } + enqueue(chunk = undefined) { + if (!IsReadableStreamDefaultController(this)) { + throw defaultControllerBrandCheckException('enqueue'); + } + if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) { + throw new TypeError('The stream is not in a state that permits enqueue'); + } + return ReadableStreamDefaultControllerEnqueue(this, chunk); + } + /** + * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`. + */ + error(e = undefined) { + if (!IsReadableStreamDefaultController(this)) { + throw defaultControllerBrandCheckException('error'); + } + ReadableStreamDefaultControllerError(this, e); + } + /** @internal */ + [CancelSteps](reason) { + ResetQueue(this); + const result = this._cancelAlgorithm(reason); + ReadableStreamDefaultControllerClearAlgorithms(this); + return result; + } + /** @internal */ + [PullSteps](readRequest) { + const stream = this._controlledReadableStream; + if (this._queue.length > 0) { + const chunk = DequeueValue(this); + if (this._closeRequested && this._queue.length === 0) { + ReadableStreamDefaultControllerClearAlgorithms(this); + ReadableStreamClose(stream); + } + else { + ReadableStreamDefaultControllerCallPullIfNeeded(this); + } + readRequest._chunkSteps(chunk); + } + else { + ReadableStreamAddReadRequest(stream, readRequest); + ReadableStreamDefaultControllerCallPullIfNeeded(this); + } + } + } + Object.defineProperties(ReadableStreamDefaultController.prototype, { + close: { enumerable: true }, + enqueue: { enumerable: true }, + error: { enumerable: true }, + desiredSize: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === 'symbol') { + Object.defineProperty(ReadableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, { + value: 'ReadableStreamDefaultController', + configurable: true + }); + } + // Abstract operations for the ReadableStreamDefaultController. + function IsReadableStreamDefaultController(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableStream')) { + return false; + } + return true; + } + function ReadableStreamDefaultControllerCallPullIfNeeded(controller) { + const shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller); + if (!shouldPull) { + return; + } + if (controller._pulling) { + controller._pullAgain = true; + return; + } + controller._pulling = true; + const pullPromise = controller._pullAlgorithm(); + uponPromise(pullPromise, () => { + controller._pulling = false; + if (controller._pullAgain) { + controller._pullAgain = false; + ReadableStreamDefaultControllerCallPullIfNeeded(controller); + } + }, e => { + ReadableStreamDefaultControllerError(controller, e); + }); + } + function ReadableStreamDefaultControllerShouldCallPull(controller) { + const stream = controller._controlledReadableStream; + if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) { + return false; + } + if (!controller._started) { + return false; + } + if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) { + return true; + } + const desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller); + if (desiredSize > 0) { + return true; + } + return false; + } + function ReadableStreamDefaultControllerClearAlgorithms(controller) { + controller._pullAlgorithm = undefined; + controller._cancelAlgorithm = undefined; + controller._strategySizeAlgorithm = undefined; + } + // A client of ReadableStreamDefaultController may use these functions directly to bypass state check. + function ReadableStreamDefaultControllerClose(controller) { + if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) { + return; + } + const stream = controller._controlledReadableStream; + controller._closeRequested = true; + if (controller._queue.length === 0) { + ReadableStreamDefaultControllerClearAlgorithms(controller); + ReadableStreamClose(stream); + } + } + function ReadableStreamDefaultControllerEnqueue(controller, chunk) { + if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) { + return; + } + const stream = controller._controlledReadableStream; + if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) { + ReadableStreamFulfillReadRequest(stream, chunk, false); + } + else { + let chunkSize; + try { + chunkSize = controller._strategySizeAlgorithm(chunk); + } + catch (chunkSizeE) { + ReadableStreamDefaultControllerError(controller, chunkSizeE); + throw chunkSizeE; + } + try { + EnqueueValueWithSize(controller, chunk, chunkSize); + } + catch (enqueueE) { + ReadableStreamDefaultControllerError(controller, enqueueE); + throw enqueueE; + } + } + ReadableStreamDefaultControllerCallPullIfNeeded(controller); + } + function ReadableStreamDefaultControllerError(controller, e) { + const stream = controller._controlledReadableStream; + if (stream._state !== 'readable') { + return; + } + ResetQueue(controller); + ReadableStreamDefaultControllerClearAlgorithms(controller); + ReadableStreamError(stream, e); + } + function ReadableStreamDefaultControllerGetDesiredSize(controller) { + const state = controller._controlledReadableStream._state; + if (state === 'errored') { + return null; + } + if (state === 'closed') { + return 0; + } + return controller._strategyHWM - controller._queueTotalSize; + } + // This is used in the implementation of TransformStream. + function ReadableStreamDefaultControllerHasBackpressure(controller) { + if (ReadableStreamDefaultControllerShouldCallPull(controller)) { + return false; + } + return true; + } + function ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) { + const state = controller._controlledReadableStream._state; + if (!controller._closeRequested && state === 'readable') { + return true; + } + return false; + } + function SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) { + controller._controlledReadableStream = stream; + controller._queue = undefined; + controller._queueTotalSize = undefined; + ResetQueue(controller); + controller._started = false; + controller._closeRequested = false; + controller._pullAgain = false; + controller._pulling = false; + controller._strategySizeAlgorithm = sizeAlgorithm; + controller._strategyHWM = highWaterMark; + controller._pullAlgorithm = pullAlgorithm; + controller._cancelAlgorithm = cancelAlgorithm; + stream._readableStreamController = controller; + const startResult = startAlgorithm(); + uponPromise(promiseResolvedWith(startResult), () => { + controller._started = true; + ReadableStreamDefaultControllerCallPullIfNeeded(controller); + }, r => { + ReadableStreamDefaultControllerError(controller, r); + }); + } + function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, highWaterMark, sizeAlgorithm) { + const controller = Object.create(ReadableStreamDefaultController.prototype); + let startAlgorithm = () => undefined; + let pullAlgorithm = () => promiseResolvedWith(undefined); + let cancelAlgorithm = () => promiseResolvedWith(undefined); + if (underlyingSource.start !== undefined) { + startAlgorithm = () => underlyingSource.start(controller); + } + if (underlyingSource.pull !== undefined) { + pullAlgorithm = () => underlyingSource.pull(controller); + } + if (underlyingSource.cancel !== undefined) { + cancelAlgorithm = reason => underlyingSource.cancel(reason); + } + SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm); + } + // Helper functions for the ReadableStreamDefaultController. + function defaultControllerBrandCheckException(name) { + return new TypeError(`ReadableStreamDefaultController.prototype.${name} can only be used on a ReadableStreamDefaultController`); + } + + function ReadableStreamTee(stream, cloneForBranch2) { + const reader = AcquireReadableStreamDefaultReader(stream); + let reading = false; + let canceled1 = false; + let canceled2 = false; + let reason1; + let reason2; + let branch1; + let branch2; + let resolveCancelPromise; + const cancelPromise = newPromise(resolve => { + resolveCancelPromise = resolve; + }); + function pullAlgorithm() { + if (reading) { + return promiseResolvedWith(undefined); + } + reading = true; + const readRequest = { + _chunkSteps: value => { + // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using + // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let + // successful synchronously-available reads get ahead of asynchronously-available errors. + queueMicrotask(() => { + reading = false; + const value1 = value; + const value2 = value; + // There is no way to access the cloning code right now in the reference implementation. + // If we add one then we'll need an implementation for serializable objects. + // if (!canceled2 && cloneForBranch2) { + // value2 = StructuredDeserialize(StructuredSerialize(value2)); + // } + if (!canceled1) { + ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, value1); + } + if (!canceled2) { + ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, value2); + } + resolveCancelPromise(undefined); + }); + }, + _closeSteps: () => { + reading = false; + if (!canceled1) { + ReadableStreamDefaultControllerClose(branch1._readableStreamController); + } + if (!canceled2) { + ReadableStreamDefaultControllerClose(branch2._readableStreamController); + } + }, + _errorSteps: () => { + reading = false; + } + }; + ReadableStreamDefaultReaderRead(reader, readRequest); + return promiseResolvedWith(undefined); + } + function cancel1Algorithm(reason) { + canceled1 = true; + reason1 = reason; + if (canceled2) { + const compositeReason = CreateArrayFromList([reason1, reason2]); + const cancelResult = ReadableStreamCancel(stream, compositeReason); + resolveCancelPromise(cancelResult); + } + return cancelPromise; + } + function cancel2Algorithm(reason) { + canceled2 = true; + reason2 = reason; + if (canceled1) { + const compositeReason = CreateArrayFromList([reason1, reason2]); + const cancelResult = ReadableStreamCancel(stream, compositeReason); + resolveCancelPromise(cancelResult); + } + return cancelPromise; + } + function startAlgorithm() { + // do nothing + } + branch1 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm); + branch2 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm); + uponRejection(reader._closedPromise, (r) => { + ReadableStreamDefaultControllerError(branch1._readableStreamController, r); + ReadableStreamDefaultControllerError(branch2._readableStreamController, r); + resolveCancelPromise(undefined); + }); + return [branch1, branch2]; + } + + function convertUnderlyingDefaultOrByteSource(source, context) { + assertDictionary(source, context); + const original = source; + const autoAllocateChunkSize = original === null || original === void 0 ? void 0 : original.autoAllocateChunkSize; + const cancel = original === null || original === void 0 ? void 0 : original.cancel; + const pull = original === null || original === void 0 ? void 0 : original.pull; + const start = original === null || original === void 0 ? void 0 : original.start; + const type = original === null || original === void 0 ? void 0 : original.type; + return { + autoAllocateChunkSize: autoAllocateChunkSize === undefined ? + undefined : + convertUnsignedLongLongWithEnforceRange(autoAllocateChunkSize, `${context} has member 'autoAllocateChunkSize' that`), + cancel: cancel === undefined ? + undefined : + convertUnderlyingSourceCancelCallback(cancel, original, `${context} has member 'cancel' that`), + pull: pull === undefined ? + undefined : + convertUnderlyingSourcePullCallback(pull, original, `${context} has member 'pull' that`), + start: start === undefined ? + undefined : + convertUnderlyingSourceStartCallback(start, original, `${context} has member 'start' that`), + type: type === undefined ? undefined : convertReadableStreamType(type, `${context} has member 'type' that`) + }; + } + function convertUnderlyingSourceCancelCallback(fn, original, context) { + assertFunction(fn, context); + return (reason) => promiseCall(fn, original, [reason]); + } + function convertUnderlyingSourcePullCallback(fn, original, context) { + assertFunction(fn, context); + return (controller) => promiseCall(fn, original, [controller]); + } + function convertUnderlyingSourceStartCallback(fn, original, context) { + assertFunction(fn, context); + return (controller) => reflectCall(fn, original, [controller]); + } + function convertReadableStreamType(type, context) { + type = `${type}`; + if (type !== 'bytes') { + throw new TypeError(`${context} '${type}' is not a valid enumeration value for ReadableStreamType`); + } + return type; + } + + function convertReaderOptions(options, context) { + assertDictionary(options, context); + const mode = options === null || options === void 0 ? void 0 : options.mode; + return { + mode: mode === undefined ? undefined : convertReadableStreamReaderMode(mode, `${context} has member 'mode' that`) + }; + } + function convertReadableStreamReaderMode(mode, context) { + mode = `${mode}`; + if (mode !== 'byob') { + throw new TypeError(`${context} '${mode}' is not a valid enumeration value for ReadableStreamReaderMode`); + } + return mode; + } + + function convertIteratorOptions(options, context) { + assertDictionary(options, context); + const preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel; + return { preventCancel: Boolean(preventCancel) }; + } + + function convertPipeOptions(options, context) { + assertDictionary(options, context); + const preventAbort = options === null || options === void 0 ? void 0 : options.preventAbort; + const preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel; + const preventClose = options === null || options === void 0 ? void 0 : options.preventClose; + const signal = options === null || options === void 0 ? void 0 : options.signal; + if (signal !== undefined) { + assertAbortSignal(signal, `${context} has member 'signal' that`); + } + return { + preventAbort: Boolean(preventAbort), + preventCancel: Boolean(preventCancel), + preventClose: Boolean(preventClose), + signal + }; + } + function assertAbortSignal(signal, context) { + if (!isAbortSignal(signal)) { + throw new TypeError(`${context} is not an AbortSignal.`); + } + } + + function convertReadableWritablePair(pair, context) { + assertDictionary(pair, context); + const readable = pair === null || pair === void 0 ? void 0 : pair.readable; + assertRequiredField(readable, 'readable', 'ReadableWritablePair'); + assertReadableStream(readable, `${context} has member 'readable' that`); + const writable = pair === null || pair === void 0 ? void 0 : pair.writable; + assertRequiredField(writable, 'writable', 'ReadableWritablePair'); + assertWritableStream(writable, `${context} has member 'writable' that`); + return { readable, writable }; + } + + /** + * A readable stream represents a source of data, from which you can read. + * + * @public + */ + class ReadableStream$1 { + constructor(rawUnderlyingSource = {}, rawStrategy = {}) { + if (rawUnderlyingSource === undefined) { + rawUnderlyingSource = null; + } + else { + assertObject(rawUnderlyingSource, 'First parameter'); + } + const strategy = convertQueuingStrategy(rawStrategy, 'Second parameter'); + const underlyingSource = convertUnderlyingDefaultOrByteSource(rawUnderlyingSource, 'First parameter'); + InitializeReadableStream(this); + if (underlyingSource.type === 'bytes') { + if (strategy.size !== undefined) { + throw new RangeError('The strategy for a byte stream cannot have a size function'); + } + const highWaterMark = ExtractHighWaterMark(strategy, 0); + SetUpReadableByteStreamControllerFromUnderlyingSource(this, underlyingSource, highWaterMark); + } + else { + const sizeAlgorithm = ExtractSizeAlgorithm(strategy); + const highWaterMark = ExtractHighWaterMark(strategy, 1); + SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, highWaterMark, sizeAlgorithm); + } + } + /** + * Whether or not the readable stream is locked to a {@link ReadableStreamDefaultReader | reader}. + */ + get locked() { + if (!IsReadableStream(this)) { + throw streamBrandCheckException$1('locked'); + } + return IsReadableStreamLocked(this); + } + /** + * Cancels the stream, signaling a loss of interest in the stream by a consumer. + * + * The supplied `reason` argument will be given to the underlying source's {@link UnderlyingSource.cancel | cancel()} + * method, which might or might not use it. + */ + cancel(reason = undefined) { + if (!IsReadableStream(this)) { + return promiseRejectedWith(streamBrandCheckException$1('cancel')); + } + if (IsReadableStreamLocked(this)) { + return promiseRejectedWith(new TypeError('Cannot cancel a stream that already has a reader')); + } + return ReadableStreamCancel(this, reason); + } + getReader(rawOptions = undefined) { + if (!IsReadableStream(this)) { + throw streamBrandCheckException$1('getReader'); + } + const options = convertReaderOptions(rawOptions, 'First parameter'); + if (options.mode === undefined) { + return AcquireReadableStreamDefaultReader(this); + } + return AcquireReadableStreamBYOBReader(this); + } + pipeThrough(rawTransform, rawOptions = {}) { + if (!IsReadableStream(this)) { + throw streamBrandCheckException$1('pipeThrough'); + } + assertRequiredArgument(rawTransform, 1, 'pipeThrough'); + const transform = convertReadableWritablePair(rawTransform, 'First parameter'); + const options = convertPipeOptions(rawOptions, 'Second parameter'); + if (IsReadableStreamLocked(this)) { + throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream'); + } + if (IsWritableStreamLocked(transform.writable)) { + throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream'); + } + const promise = ReadableStreamPipeTo(this, transform.writable, options.preventClose, options.preventAbort, options.preventCancel, options.signal); + setPromiseIsHandledToTrue(promise); + return transform.readable; + } + pipeTo(destination, rawOptions = {}) { + if (!IsReadableStream(this)) { + return promiseRejectedWith(streamBrandCheckException$1('pipeTo')); + } + if (destination === undefined) { + return promiseRejectedWith(`Parameter 1 is required in 'pipeTo'.`); + } + if (!IsWritableStream(destination)) { + return promiseRejectedWith(new TypeError(`ReadableStream.prototype.pipeTo's first argument must be a WritableStream`)); + } + let options; + try { + options = convertPipeOptions(rawOptions, 'Second parameter'); + } + catch (e) { + return promiseRejectedWith(e); + } + if (IsReadableStreamLocked(this)) { + return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream')); + } + if (IsWritableStreamLocked(destination)) { + return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream')); + } + return ReadableStreamPipeTo(this, destination, options.preventClose, options.preventAbort, options.preventCancel, options.signal); + } + /** + * Tees this readable stream, returning a two-element array containing the two resulting branches as + * new {@link ReadableStream} instances. + * + * Teeing a stream will lock it, preventing any other consumer from acquiring a reader. + * To cancel the stream, cancel both of the resulting branches; a composite cancellation reason will then be + * propagated to the stream's underlying source. + * + * Note that the chunks seen in each branch will be the same object. If the chunks are not immutable, + * this could allow interference between the two branches. + */ + tee() { + if (!IsReadableStream(this)) { + throw streamBrandCheckException$1('tee'); + } + const branches = ReadableStreamTee(this); + return CreateArrayFromList(branches); + } + values(rawOptions = undefined) { + if (!IsReadableStream(this)) { + throw streamBrandCheckException$1('values'); + } + const options = convertIteratorOptions(rawOptions, 'First parameter'); + return AcquireReadableStreamAsyncIterator(this, options.preventCancel); + } + } + Object.defineProperties(ReadableStream$1.prototype, { + cancel: { enumerable: true }, + getReader: { enumerable: true }, + pipeThrough: { enumerable: true }, + pipeTo: { enumerable: true }, + tee: { enumerable: true }, + values: { enumerable: true }, + locked: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === 'symbol') { + Object.defineProperty(ReadableStream$1.prototype, SymbolPolyfill.toStringTag, { + value: 'ReadableStream', + configurable: true + }); + } + if (typeof SymbolPolyfill.asyncIterator === 'symbol') { + Object.defineProperty(ReadableStream$1.prototype, SymbolPolyfill.asyncIterator, { + value: ReadableStream$1.prototype.values, + writable: true, + configurable: true + }); + } + // Abstract operations for the ReadableStream. + // Throws if and only if startAlgorithm throws. + function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark = 1, sizeAlgorithm = () => 1) { + const stream = Object.create(ReadableStream$1.prototype); + InitializeReadableStream(stream); + const controller = Object.create(ReadableStreamDefaultController.prototype); + SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm); + return stream; + } + function InitializeReadableStream(stream) { + stream._state = 'readable'; + stream._reader = undefined; + stream._storedError = undefined; + stream._disturbed = false; + } + function IsReadableStream(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) { + return false; + } + return true; + } + function IsReadableStreamLocked(stream) { + if (stream._reader === undefined) { + return false; + } + return true; + } + // ReadableStream API exposed for controllers. + function ReadableStreamCancel(stream, reason) { + stream._disturbed = true; + if (stream._state === 'closed') { + return promiseResolvedWith(undefined); + } + if (stream._state === 'errored') { + return promiseRejectedWith(stream._storedError); + } + ReadableStreamClose(stream); + const sourceCancelPromise = stream._readableStreamController[CancelSteps](reason); + return transformPromiseWith(sourceCancelPromise, noop); + } + function ReadableStreamClose(stream) { + stream._state = 'closed'; + const reader = stream._reader; + if (reader === undefined) { + return; + } + if (IsReadableStreamDefaultReader(reader)) { + reader._readRequests.forEach(readRequest => { + readRequest._closeSteps(); + }); + reader._readRequests = new SimpleQueue(); + } + defaultReaderClosedPromiseResolve(reader); + } + function ReadableStreamError(stream, e) { + stream._state = 'errored'; + stream._storedError = e; + const reader = stream._reader; + if (reader === undefined) { + return; + } + if (IsReadableStreamDefaultReader(reader)) { + reader._readRequests.forEach(readRequest => { + readRequest._errorSteps(e); + }); + reader._readRequests = new SimpleQueue(); + } + else { + reader._readIntoRequests.forEach(readIntoRequest => { + readIntoRequest._errorSteps(e); + }); + reader._readIntoRequests = new SimpleQueue(); + } + defaultReaderClosedPromiseReject(reader, e); + } + // Helper functions for the ReadableStream. + function streamBrandCheckException$1(name) { + return new TypeError(`ReadableStream.prototype.${name} can only be used on a ReadableStream`); + } + + function convertQueuingStrategyInit(init, context) { + assertDictionary(init, context); + const highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark; + assertRequiredField(highWaterMark, 'highWaterMark', 'QueuingStrategyInit'); + return { + highWaterMark: convertUnrestrictedDouble(highWaterMark) + }; + } + + const byteLengthSizeFunction = function size(chunk) { + return chunk.byteLength; + }; + /** + * A queuing strategy that counts the number of bytes in each chunk. + * + * @public + */ + class ByteLengthQueuingStrategy { + constructor(options) { + assertRequiredArgument(options, 1, 'ByteLengthQueuingStrategy'); + options = convertQueuingStrategyInit(options, 'First parameter'); + this._byteLengthQueuingStrategyHighWaterMark = options.highWaterMark; + } + /** + * Returns the high water mark provided to the constructor. + */ + get highWaterMark() { + if (!IsByteLengthQueuingStrategy(this)) { + throw byteLengthBrandCheckException('highWaterMark'); + } + return this._byteLengthQueuingStrategyHighWaterMark; + } + /** + * Measures the size of `chunk` by returning the value of its `byteLength` property. + */ + get size() { + if (!IsByteLengthQueuingStrategy(this)) { + throw byteLengthBrandCheckException('size'); + } + return byteLengthSizeFunction; + } + } + Object.defineProperties(ByteLengthQueuingStrategy.prototype, { + highWaterMark: { enumerable: true }, + size: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === 'symbol') { + Object.defineProperty(ByteLengthQueuingStrategy.prototype, SymbolPolyfill.toStringTag, { + value: 'ByteLengthQueuingStrategy', + configurable: true + }); + } + // Helper functions for the ByteLengthQueuingStrategy. + function byteLengthBrandCheckException(name) { + return new TypeError(`ByteLengthQueuingStrategy.prototype.${name} can only be used on a ByteLengthQueuingStrategy`); + } + function IsByteLengthQueuingStrategy(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_byteLengthQueuingStrategyHighWaterMark')) { + return false; + } + return true; + } + + const countSizeFunction = function size() { + return 1; + }; + /** + * A queuing strategy that counts the number of chunks. + * + * @public + */ + class CountQueuingStrategy { + constructor(options) { + assertRequiredArgument(options, 1, 'CountQueuingStrategy'); + options = convertQueuingStrategyInit(options, 'First parameter'); + this._countQueuingStrategyHighWaterMark = options.highWaterMark; + } + /** + * Returns the high water mark provided to the constructor. + */ + get highWaterMark() { + if (!IsCountQueuingStrategy(this)) { + throw countBrandCheckException('highWaterMark'); + } + return this._countQueuingStrategyHighWaterMark; + } + /** + * Measures the size of `chunk` by always returning 1. + * This ensures that the total queue size is a count of the number of chunks in the queue. + */ + get size() { + if (!IsCountQueuingStrategy(this)) { + throw countBrandCheckException('size'); + } + return countSizeFunction; + } + } + Object.defineProperties(CountQueuingStrategy.prototype, { + highWaterMark: { enumerable: true }, + size: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === 'symbol') { + Object.defineProperty(CountQueuingStrategy.prototype, SymbolPolyfill.toStringTag, { + value: 'CountQueuingStrategy', + configurable: true + }); + } + // Helper functions for the CountQueuingStrategy. + function countBrandCheckException(name) { + return new TypeError(`CountQueuingStrategy.prototype.${name} can only be used on a CountQueuingStrategy`); + } + function IsCountQueuingStrategy(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_countQueuingStrategyHighWaterMark')) { + return false; + } + return true; + } + + function convertTransformer(original, context) { + assertDictionary(original, context); + const flush = original === null || original === void 0 ? void 0 : original.flush; + const readableType = original === null || original === void 0 ? void 0 : original.readableType; + const start = original === null || original === void 0 ? void 0 : original.start; + const transform = original === null || original === void 0 ? void 0 : original.transform; + const writableType = original === null || original === void 0 ? void 0 : original.writableType; + return { + flush: flush === undefined ? + undefined : + convertTransformerFlushCallback(flush, original, `${context} has member 'flush' that`), + readableType, + start: start === undefined ? + undefined : + convertTransformerStartCallback(start, original, `${context} has member 'start' that`), + transform: transform === undefined ? + undefined : + convertTransformerTransformCallback(transform, original, `${context} has member 'transform' that`), + writableType + }; + } + function convertTransformerFlushCallback(fn, original, context) { + assertFunction(fn, context); + return (controller) => promiseCall(fn, original, [controller]); + } + function convertTransformerStartCallback(fn, original, context) { + assertFunction(fn, context); + return (controller) => reflectCall(fn, original, [controller]); + } + function convertTransformerTransformCallback(fn, original, context) { + assertFunction(fn, context); + return (chunk, controller) => promiseCall(fn, original, [chunk, controller]); + } + + // Class TransformStream + /** + * A transform stream consists of a pair of streams: a {@link WritableStream | writable stream}, + * known as its writable side, and a {@link ReadableStream | readable stream}, known as its readable side. + * In a manner specific to the transform stream in question, writes to the writable side result in new data being + * made available for reading from the readable side. + * + * @public + */ + class TransformStream$1 { + constructor(rawTransformer = {}, rawWritableStrategy = {}, rawReadableStrategy = {}) { + if (rawTransformer === undefined) { + rawTransformer = null; + } + const writableStrategy = convertQueuingStrategy(rawWritableStrategy, 'Second parameter'); + const readableStrategy = convertQueuingStrategy(rawReadableStrategy, 'Third parameter'); + const transformer = convertTransformer(rawTransformer, 'First parameter'); + if (transformer.readableType !== undefined) { + throw new RangeError('Invalid readableType specified'); + } + if (transformer.writableType !== undefined) { + throw new RangeError('Invalid writableType specified'); + } + const readableHighWaterMark = ExtractHighWaterMark(readableStrategy, 0); + const readableSizeAlgorithm = ExtractSizeAlgorithm(readableStrategy); + const writableHighWaterMark = ExtractHighWaterMark(writableStrategy, 1); + const writableSizeAlgorithm = ExtractSizeAlgorithm(writableStrategy); + let startPromise_resolve; + const startPromise = newPromise(resolve => { + startPromise_resolve = resolve; + }); + InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm); + SetUpTransformStreamDefaultControllerFromTransformer(this, transformer); + if (transformer.start !== undefined) { + startPromise_resolve(transformer.start(this._transformStreamController)); + } + else { + startPromise_resolve(undefined); + } + } + /** + * The readable side of the transform stream. + */ + get readable() { + if (!IsTransformStream(this)) { + throw streamBrandCheckException$2('readable'); + } + return this._readable; + } + /** + * The writable side of the transform stream. + */ + get writable() { + if (!IsTransformStream(this)) { + throw streamBrandCheckException$2('writable'); + } + return this._writable; + } + } + Object.defineProperties(TransformStream$1.prototype, { + readable: { enumerable: true }, + writable: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === 'symbol') { + Object.defineProperty(TransformStream$1.prototype, SymbolPolyfill.toStringTag, { + value: 'TransformStream', + configurable: true + }); + } + function InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm) { + function startAlgorithm() { + return startPromise; + } + function writeAlgorithm(chunk) { + return TransformStreamDefaultSinkWriteAlgorithm(stream, chunk); + } + function abortAlgorithm(reason) { + return TransformStreamDefaultSinkAbortAlgorithm(stream, reason); + } + function closeAlgorithm() { + return TransformStreamDefaultSinkCloseAlgorithm(stream); + } + stream._writable = CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, writableHighWaterMark, writableSizeAlgorithm); + function pullAlgorithm() { + return TransformStreamDefaultSourcePullAlgorithm(stream); + } + function cancelAlgorithm(reason) { + TransformStreamErrorWritableAndUnblockWrite(stream, reason); + return promiseResolvedWith(undefined); + } + stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark, readableSizeAlgorithm); + // The [[backpressure]] slot is set to undefined so that it can be initialised by TransformStreamSetBackpressure. + stream._backpressure = undefined; + stream._backpressureChangePromise = undefined; + stream._backpressureChangePromise_resolve = undefined; + TransformStreamSetBackpressure(stream, true); + stream._transformStreamController = undefined; + } + function IsTransformStream(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) { + return false; + } + return true; + } + // This is a no-op if both sides are already errored. + function TransformStreamError(stream, e) { + ReadableStreamDefaultControllerError(stream._readable._readableStreamController, e); + TransformStreamErrorWritableAndUnblockWrite(stream, e); + } + function TransformStreamErrorWritableAndUnblockWrite(stream, e) { + TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController); + WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e); + if (stream._backpressure) { + // Pretend that pull() was called to permit any pending write() calls to complete. TransformStreamSetBackpressure() + // cannot be called from enqueue() or pull() once the ReadableStream is errored, so this will will be the final time + // _backpressure is set. + TransformStreamSetBackpressure(stream, false); + } + } + function TransformStreamSetBackpressure(stream, backpressure) { + // Passes also when called during construction. + if (stream._backpressureChangePromise !== undefined) { + stream._backpressureChangePromise_resolve(); + } + stream._backpressureChangePromise = newPromise(resolve => { + stream._backpressureChangePromise_resolve = resolve; + }); + stream._backpressure = backpressure; + } + // Class TransformStreamDefaultController + /** + * Allows control of the {@link ReadableStream} and {@link WritableStream} of the associated {@link TransformStream}. + * + * @public + */ + class TransformStreamDefaultController$1 { + constructor() { + throw new TypeError('Illegal constructor'); + } + /** + * Returns the desired size to fill the readable side’s internal queue. It can be negative, if the queue is over-full. + */ + get desiredSize() { + if (!IsTransformStreamDefaultController(this)) { + throw defaultControllerBrandCheckException$1('desiredSize'); + } + const readableController = this._controlledTransformStream._readable._readableStreamController; + return ReadableStreamDefaultControllerGetDesiredSize(readableController); + } + enqueue(chunk = undefined) { + if (!IsTransformStreamDefaultController(this)) { + throw defaultControllerBrandCheckException$1('enqueue'); + } + TransformStreamDefaultControllerEnqueue(this, chunk); + } + /** + * Errors both the readable side and the writable side of the controlled transform stream, making all future + * interactions with it fail with the given error `e`. Any chunks queued for transformation will be discarded. + */ + error(reason = undefined) { + if (!IsTransformStreamDefaultController(this)) { + throw defaultControllerBrandCheckException$1('error'); + } + TransformStreamDefaultControllerError(this, reason); + } + /** + * Closes the readable side and errors the writable side of the controlled transform stream. This is useful when the + * transformer only needs to consume a portion of the chunks written to the writable side. + */ + terminate() { + if (!IsTransformStreamDefaultController(this)) { + throw defaultControllerBrandCheckException$1('terminate'); + } + TransformStreamDefaultControllerTerminate(this); + } + } + Object.defineProperties(TransformStreamDefaultController$1.prototype, { + enqueue: { enumerable: true }, + error: { enumerable: true }, + terminate: { enumerable: true }, + desiredSize: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === 'symbol') { + Object.defineProperty(TransformStreamDefaultController$1.prototype, SymbolPolyfill.toStringTag, { + value: 'TransformStreamDefaultController', + configurable: true + }); + } + // Transform Stream Default Controller Abstract Operations + function IsTransformStreamDefaultController(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) { + return false; + } + return true; + } + function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm) { + controller._controlledTransformStream = stream; + stream._transformStreamController = controller; + controller._transformAlgorithm = transformAlgorithm; + controller._flushAlgorithm = flushAlgorithm; + } + function SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer) { + const controller = Object.create(TransformStreamDefaultController$1.prototype); + let transformAlgorithm = (chunk) => { + try { + TransformStreamDefaultControllerEnqueue(controller, chunk); + return promiseResolvedWith(undefined); + } + catch (transformResultE) { + return promiseRejectedWith(transformResultE); + } + }; + let flushAlgorithm = () => promiseResolvedWith(undefined); + if (transformer.transform !== undefined) { + transformAlgorithm = chunk => transformer.transform(chunk, controller); + } + if (transformer.flush !== undefined) { + flushAlgorithm = () => transformer.flush(controller); + } + SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm); + } + function TransformStreamDefaultControllerClearAlgorithms(controller) { + controller._transformAlgorithm = undefined; + controller._flushAlgorithm = undefined; + } + function TransformStreamDefaultControllerEnqueue(controller, chunk) { + const stream = controller._controlledTransformStream; + const readableController = stream._readable._readableStreamController; + if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController)) { + throw new TypeError('Readable side is not in a state that permits enqueue'); + } + // We throttle transform invocations based on the backpressure of the ReadableStream, but we still + // accept TransformStreamDefaultControllerEnqueue() calls. + try { + ReadableStreamDefaultControllerEnqueue(readableController, chunk); + } + catch (e) { + // This happens when readableStrategy.size() throws. + TransformStreamErrorWritableAndUnblockWrite(stream, e); + throw stream._readable._storedError; + } + const backpressure = ReadableStreamDefaultControllerHasBackpressure(readableController); + if (backpressure !== stream._backpressure) { + TransformStreamSetBackpressure(stream, true); + } + } + function TransformStreamDefaultControllerError(controller, e) { + TransformStreamError(controller._controlledTransformStream, e); + } + function TransformStreamDefaultControllerPerformTransform(controller, chunk) { + const transformPromise = controller._transformAlgorithm(chunk); + return transformPromiseWith(transformPromise, undefined, r => { + TransformStreamError(controller._controlledTransformStream, r); + throw r; + }); + } + function TransformStreamDefaultControllerTerminate(controller) { + const stream = controller._controlledTransformStream; + const readableController = stream._readable._readableStreamController; + ReadableStreamDefaultControllerClose(readableController); + const error = new TypeError('TransformStream terminated'); + TransformStreamErrorWritableAndUnblockWrite(stream, error); + } + // TransformStreamDefaultSink Algorithms + function TransformStreamDefaultSinkWriteAlgorithm(stream, chunk) { + const controller = stream._transformStreamController; + if (stream._backpressure) { + const backpressureChangePromise = stream._backpressureChangePromise; + return transformPromiseWith(backpressureChangePromise, () => { + const writable = stream._writable; + const state = writable._state; + if (state === 'erroring') { + throw writable._storedError; + } + return TransformStreamDefaultControllerPerformTransform(controller, chunk); + }); + } + return TransformStreamDefaultControllerPerformTransform(controller, chunk); + } + function TransformStreamDefaultSinkAbortAlgorithm(stream, reason) { + // abort() is not called synchronously, so it is possible for abort() to be called when the stream is already + // errored. + TransformStreamError(stream, reason); + return promiseResolvedWith(undefined); + } + function TransformStreamDefaultSinkCloseAlgorithm(stream) { + // stream._readable cannot change after construction, so caching it across a call to user code is safe. + const readable = stream._readable; + const controller = stream._transformStreamController; + const flushPromise = controller._flushAlgorithm(); + TransformStreamDefaultControllerClearAlgorithms(controller); + // Return a promise that is fulfilled with undefined on success. + return transformPromiseWith(flushPromise, () => { + if (readable._state === 'errored') { + throw readable._storedError; + } + ReadableStreamDefaultControllerClose(readable._readableStreamController); + }, r => { + TransformStreamError(stream, r); + throw readable._storedError; + }); + } + // TransformStreamDefaultSource Algorithms + function TransformStreamDefaultSourcePullAlgorithm(stream) { + // Invariant. Enforced by the promises returned by start() and pull(). + TransformStreamSetBackpressure(stream, false); + // Prevent the next pull() call until there is backpressure. + return stream._backpressureChangePromise; + } + // Helper functions for the TransformStreamDefaultController. + function defaultControllerBrandCheckException$1(name) { + return new TypeError(`TransformStreamDefaultController.prototype.${name} can only be used on a TransformStreamDefaultController`); + } + // Helper functions for the TransformStream. + function streamBrandCheckException$2(name) { + return new TypeError(`TransformStream.prototype.${name} can only be used on a TransformStream`); + } + + if (!self.WritableStream) { + self.WritableStream = WritableStream$1; + + // also need to polyfill ReadableStream as it likely doesn't support pipeTo/Through if no WritableStream + self.ReadableStream = ReadableStream$1; + } + + // Copyright 2018 The Emulation-as-a-Service Authors. + // SPDX-License-Identifier: GPL-2.0-or-later + + const broadcastStream = (name) => { + const channel = new BroadcastChannel(name); + let writableClosed, readableClosed; + const closed = Promise.all([ + new Promise(r => writableClosed = r), + new Promise(r => readableClosed = r).then(() => channel.onmessage = null), + ]).then(() => channel.close()); + const writable = new WritableStream({ + write(ch) { + channel.postMessage(ch); + }, + close() { + writableClosed(); + }, + abort() { + writableClosed(); + }, + }); + let readController; + const readable = new ReadableStream({ + start(c) { + readController = c; + }, + cancel() { + readableClosed(); + }, + }); + channel.onmessage = ({data}) => readController.enqueue(data); + return {writable, readable}; + }; + + // Copyright 2018 The Emulation-as-a-Service Authors. + // SPDX-License-Identifier: GPL-2.0-or-later + + const _writable = new WeakMap(); + const _readable = new WeakMap(); + const _writeController = new WeakMap(); + const _readController = new WeakMap(); + + const call = (object, method, args) => { + const fun = object[method]; + if (typeof fun === "undefined") return; + if (typeof fun !== "function") throw new TypeError(); + return Reflect.apply(fun, object, args); + }; + + /** + * A polyfill for `TransformStream` that uses the native `ReadableStream` + * and `WritableStream` implementations. + */ + class TransformStream { + constructor(transformer = {}, writableStrategy = {}, readableStrategy = {}) { + let resolveRead = () => {}; + const writable = new WritableStream({ + start: (writeController) => { + _writeController.set(this, writeController); + }, + write: async (chunk) => { + const readC = _readController.get(this); + if (readC.desiredSize <= 0) { + await new Promise(r => resolveRead = r); + } + return call(transformer, "transform", [chunk, controller]); + }, + close: async () => { + await call(transformer, "flush", [controller]); + _readController.get(this).close(); + }, + abort: () => { + return _readController.get(this).error(); + } + }, writableStrategy); + const readable = new ReadableStream({ + start: (readController) => { + _readController.set(this, readController); + if (typeof transformer.start !== "function") return; + return transformer.start(controller); + }, + pull: (chunk, controller) => { + resolveRead(); + }, + cancel(reason) {}, + + }, readableStrategy); + const controller = makeTransformStreamDefaultController( + _writeController.get(this), _readController.get(this)); + + _writable.set(this, writable); + _readable.set(this, readable); + } + get writable() {return _writable.get(this);} + get readable() {return _readable.get(this);} + } + + const _readController2 = new WeakMap(); + const _writeController2 = new WeakMap(); + const _lastWrite = new WeakMap(); + + const makeTransformStreamDefaultController = (writeController, readController) => { + const _this = Object.create(TransformStreamDefaultController.prototype); + _writeController2.set(_this, writeController); + _readController2.set(_this, readController); + return _this; + }; + + class TransformStreamDefaultController { + constructor() {throw new TypeError();} + + get desiredSize() { + return _readController2.get(this).desiredSize; + } + enqueue(chunk) { + const ret = _readController2.get(this).enqueue(chunk); + _lastWrite.set(this, ret); + return ret; + } + error(reason) { + _writeController2.get(this).error(reason); + _readController2.get(this).error(reason); + } + terminate() { + _writeController2.get(this).error(); + _readController2.get(this).close(); + } + } + + + class WritableStreamDefaultWriter { + constructor(stream) {} + + get closed() {return Promise.resolve();} + get desiredSize() {return 0;} + get ready() {return Promise.resolve();} + + abort(reason) {} + close() {} + releaseLock() {} + write(chunk) {} + } + + var Module = (function() { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + return ( + function(Module) { + Module = Module || {}; + + // Copyright 2010 The Emscripten Authors. All rights reserved. + // Emscripten is available under two separate licenses, the MIT license and the + // University of Illinois/NCSA Open Source License. Both these licenses can be + // found in the LICENSE file. + + // The Module object: Our interface to the outside world. We import + // and export values on it. There are various ways Module can be used: + // 1. Not defined. We create it here + // 2. A function parameter, function(Module) { ..generated code.. } + // 3. pre-run appended it, var Module = {}; ..generated code.. + // 4. External script tag defines var Module. + // We need to check if Module already exists (e.g. case 3 above). + // Substitution will be replaced with actual code on later stage of the build, + // this way Closure Compiler will not mangle it (e.g. case 4. above). + // Note that if you want to run closure, and also to use Module + // after the generated code, you will need to define var Module = {}; + // before the code. Then that object will be used in the code, and you + // can continue to use Module afterwards as well. + var Module = typeof Module !== 'undefined' ? Module : {}; + + // --pre-jses are emitted after the Module integration code, so that they can + // refer to Module (if they choose; they can also define Module) + Module["locateFile"] = function(path) { + //let url = import.meta.url; + let url = self.location.href; + url = url.replace(/^file:\/\//, ""); + // HACK: Special case for Node.js on Windows + // (`url` will look like "file:///C:/..."). + // Would properly use `require("url").fileURLToPath(url)` + // on all Node.js platforms, which is not avaible + // on older Node.js versions, though. + try { + if (process.platform === "win32") url = url.replace(/^\/+/, ""); + } catch {} + return url + "/../" + path; + }; + Module["noExitRuntime"] = true; + + // HACK: Work around https://github.com/emscripten-core/emscripten/issues/7855 + // for Node.js: turn process.on("uncaughtException" | "unhandledRejection", ...) + // into no-op. + let process; + try { + process = new Proxy(global.process, { + get(target, key, receiver) { + const ret = Reflect.get(target, key, receiver); + if (key !== "on") return ret; + return new Proxy(ret, { + apply(target, thisArg, args) { + if (args[0] !== "uncaughtException" + && args[0] !== "unhandledRejection") { + return Reflect.apply(target, thisArg, args); + } + } + }); + } + }); + } catch {} + + + + // Sometimes an existing Module object exists with properties + // meant to overwrite the default module functionality. Here + // we collect those properties and reapply _after_ we configure + // the current environment's defaults to avoid having to be so + // defensive during initialization. + var moduleOverrides = {}; + var key; + for (key in Module) { + if (Module.hasOwnProperty(key)) { + moduleOverrides[key] = Module[key]; + } + } + + var arguments_ = []; + var thisProgram = './this.program'; + var quit_ = function(status, toThrow) { + throw toThrow; + }; + + // Determine the runtime environment we are in. You can customize this by + // setting the ENVIRONMENT setting at compile time (see settings.js). + + var ENVIRONMENT_IS_WEB = false; + var ENVIRONMENT_IS_WORKER = false; + var ENVIRONMENT_IS_NODE = false; + var ENVIRONMENT_HAS_NODE = false; + var ENVIRONMENT_IS_SHELL = false; + ENVIRONMENT_IS_WEB = typeof window === 'object'; + ENVIRONMENT_IS_WORKER = typeof importScripts === 'function'; + // A web environment like Electron.js can have Node enabled, so we must + // distinguish between Node-enabled environments and Node environments per se. + // This will allow the former to do things like mount NODEFS. + // Extended check using process.versions fixes issue #8816. + // (Also makes redundant the original check that 'require' is a function.) + ENVIRONMENT_HAS_NODE = typeof process === 'object' && typeof process.versions === 'object' && typeof process.versions.node === 'string'; + ENVIRONMENT_IS_NODE = ENVIRONMENT_HAS_NODE && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER; + ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; + + + + + // `/` should be present at the end if `scriptDirectory` is not empty + var scriptDirectory = ''; + function locateFile(path) { + if (Module['locateFile']) { + return Module['locateFile'](path, scriptDirectory); + } + return scriptDirectory + path; + } + + // Hooks that are implemented differently in different runtime environments. + var read_, + readAsync, + readBinary, + setWindowTitle; + + var nodeFS; + var nodePath; + + if (ENVIRONMENT_IS_NODE) { + scriptDirectory = __dirname + '/'; + + + read_ = function shell_read(filename, binary) { + var ret; + if (!nodeFS) nodeFS = require('fs'); + if (!nodePath) nodePath = require('path'); + filename = nodePath['normalize'](filename); + return nodeFS['readFileSync'](filename, binary ? null : 'utf8'); + }; + + readBinary = function readBinary(filename) { + var ret = read_(filename, true); + if (!ret.buffer) { + ret = new Uint8Array(ret); + } + assert(ret.buffer); + return ret; + }; + + + + + if (process['argv'].length > 1) { + thisProgram = process['argv'][1].replace(/\\/g, '/'); + } + + arguments_ = process['argv'].slice(2); + + // MODULARIZE will export the module in the proper place outside, we don't need to export here + + process['on']('uncaughtException', function(ex) { + // suppress ExitStatus exceptions from showing an error + if (!(ex instanceof ExitStatus)) { + throw ex; + } + }); + + process['on']('unhandledRejection', abort); + + quit_ = function(status) { + process['exit'](status); + }; + + Module['inspect'] = function () { return '[Emscripten Module object]'; }; + + + } else + if (ENVIRONMENT_IS_SHELL) { + + + if (typeof read != 'undefined') { + read_ = function shell_read(f) { + return read(f); + }; + } + + readBinary = function readBinary(f) { + var data; + if (typeof readbuffer === 'function') { + return new Uint8Array(readbuffer(f)); + } + data = read(f, 'binary'); + assert(typeof data === 'object'); + return data; + }; + + if (typeof scriptArgs != 'undefined') { + arguments_ = scriptArgs; + } else if (typeof arguments != 'undefined') { + arguments_ = arguments; + } + + if (typeof quit === 'function') { + quit_ = function(status) { + quit(status); + }; + } + + if (typeof print !== 'undefined') { + // Prefer to use print/printErr where they exist, as they usually work better. + if (typeof console === 'undefined') console = {}; + console.log = print; + console.warn = console.error = typeof printErr !== 'undefined' ? printErr : print; + } + } else + + // Note that this includes Node.js workers when relevant (pthreads is enabled). + // Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and + // ENVIRONMENT_HAS_NODE. + if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled + scriptDirectory = self.location.href; + } else if (document.currentScript) { // web + scriptDirectory = document.currentScript.src; + } + // When MODULARIZE (and not _INSTANCE), this JS may be executed later, after document.currentScript + // is gone, so we saved it, and we use it here instead of any other info. + if (_scriptDir) { + scriptDirectory = _scriptDir; + } + // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them. + // otherwise, slice off the final part of the url to find the script directory. + // if scriptDirectory does not contain a slash, lastIndexOf will return -1, + // and scriptDirectory will correctly be replaced with an empty string. + if (scriptDirectory.indexOf('blob:') !== 0) { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf('/')+1); + } else { + scriptDirectory = ''; + } + + + // Differentiate the Web Worker from the Node Worker case, as reading must + // be done differently. + { + + + read_ = function shell_read(url) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.send(null); + return xhr.responseText; + }; + + if (ENVIRONMENT_IS_WORKER) { + readBinary = function readBinary(url) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.responseType = 'arraybuffer'; + xhr.send(null); + return new Uint8Array(xhr.response); + }; + } + + readAsync = function readAsync(url, onload, onerror) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'arraybuffer'; + xhr.onload = function xhr_onload() { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0 + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + }; + + + + + } + + setWindowTitle = function(title) { document.title = title; }; + } else + { + } + + + // Set up the out() and err() hooks, which are how we can print to stdout or + // stderr, respectively. + var out = Module['print'] || console.log.bind(console); + var err = Module['printErr'] || console.warn.bind(console); + + // Merge back in the overrides + for (key in moduleOverrides) { + if (moduleOverrides.hasOwnProperty(key)) { + Module[key] = moduleOverrides[key]; + } + } + // Free the object hierarchy contained in the overrides, this lets the GC + // reclaim data used e.g. in memoryInitializerRequest, which is a large typed array. + moduleOverrides = null; + + // Emit code to handle expected values on the Module object. This applies Module.x + // to the proper local x. This has two benefits: first, we only emit it if it is + // expected to arrive, and second, by using a local everywhere else that can be + // minified. + if (Module['arguments']) arguments_ = Module['arguments']; + if (Module['thisProgram']) thisProgram = Module['thisProgram']; + if (Module['quit']) quit_ = Module['quit']; + + // perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message + + // TODO remove when SDL2 is fixed (also see above) + + + + // Copyright 2017 The Emscripten Authors. All rights reserved. + // Emscripten is available under two separate licenses, the MIT license and the + // University of Illinois/NCSA Open Source License. Both these licenses can be + // found in the LICENSE file. + + // {{PREAMBLE_ADDITIONS}} + + var STACK_ALIGN = 16; + + + function dynamicAlloc(size) { + var ret = HEAP32[DYNAMICTOP_PTR>>2]; + var end = (ret + size + 15) & -16; + if (end > _emscripten_get_heap_size()) { + abort(); + } + HEAP32[DYNAMICTOP_PTR>>2] = end; + return ret; + } + + function alignMemory(size, factor) { + if (!factor) factor = STACK_ALIGN; // stack alignment (16-byte) by default + return Math.ceil(size / factor) * factor; + } + + function getNativeTypeSize(type) { + switch (type) { + case 'i1': case 'i8': return 1; + case 'i16': return 2; + case 'i32': return 4; + case 'i64': return 8; + case 'float': return 4; + case 'double': return 8; + default: { + if (type[type.length-1] === '*') { + return 4; // A pointer + } else if (type[0] === 'i') { + var bits = parseInt(type.substr(1)); + assert(bits % 8 === 0, 'getNativeTypeSize invalid bits ' + bits + ', type ' + type); + return bits / 8; + } else { + return 0; + } + } + } + } + + function warnOnce(text) { + if (!warnOnce.shown) warnOnce.shown = {}; + if (!warnOnce.shown[text]) { + warnOnce.shown[text] = 1; + err(text); + } + } + + var asm2wasmImports = { // special asm2wasm imports + "f64-rem": function(x, y) { + return x % y; + }, + "debugger": function() { + } + }; + + + + var jsCallStartIndex = 1; + var functionPointers = new Array(20); + + // Wraps a JS function as a wasm function with a given signature. + // In the future, we may get a WebAssembly.Function constructor. Until then, + // we create a wasm module that takes the JS function as an import with a given + // signature, and re-exports that as a wasm function. + function convertJsFunctionToWasm(func, sig) { + + // The module is static, with the exception of the type section, which is + // generated based on the signature passed in. + var typeSection = [ + 0x01, // id: section, + 0x00, // length: 0 (placeholder) + 0x01, // count: 1 + 0x60, // form: func + ]; + var sigRet = sig.slice(0, 1); + var sigParam = sig.slice(1); + var typeCodes = { + 'i': 0x7f, // i32 + 'j': 0x7e, // i64 + 'f': 0x7d, // f32 + 'd': 0x7c, // f64 + }; + + // Parameters, length + signatures + typeSection.push(sigParam.length); + for (var i = 0; i < sigParam.length; ++i) { + typeSection.push(typeCodes[sigParam[i]]); + } + + // Return values, length + signatures + // With no multi-return in MVP, either 0 (void) or 1 (anything else) + if (sigRet == 'v') { + typeSection.push(0x00); + } else { + typeSection = typeSection.concat([0x01, typeCodes[sigRet]]); + } + + // Write the overall length of the type section back into the section header + // (excepting the 2 bytes for the section id and length) + typeSection[1] = typeSection.length - 2; + + // Rest of the module is static + var bytes = new Uint8Array([ + 0x00, 0x61, 0x73, 0x6d, // magic ("\0asm") + 0x01, 0x00, 0x00, 0x00, // version: 1 + ].concat(typeSection, [ + 0x02, 0x07, // import section + // (import "e" "f" (func 0 (type 0))) + 0x01, 0x01, 0x65, 0x01, 0x66, 0x00, 0x00, + 0x07, 0x05, // export section + // (export "f" (func 0 (type 0))) + 0x01, 0x01, 0x66, 0x00, 0x00, + ])); + + // We can compile this wasm module synchronously because it is very small. + // This accepts an import (at "e.f"), that it reroutes to an export (at "f") + var module = new WebAssembly.Module(bytes); + var instance = new WebAssembly.Instance(module, { + e: { + f: func + } + }); + var wrappedFunc = instance.exports.f; + return wrappedFunc; + } + + // Add a wasm function to the table. + function addFunctionWasm(func, sig) { + var table = wasmTable; + var ret = table.length; + + // Grow the table + try { + table.grow(1); + } catch (err) { + if (!err instanceof RangeError) { + throw err; + } + throw 'Unable to grow wasm table. Use a higher value for RESERVED_FUNCTION_POINTERS or set ALLOW_TABLE_GROWTH.'; + } + + // Insert new element + try { + // Attempting to call this with JS function will cause of table.set() to fail + table.set(ret, func); + } catch (err) { + if (!err instanceof TypeError) { + throw err; + } + assert(typeof sig !== 'undefined', 'Missing signature argument to addFunction'); + var wrapped = convertJsFunctionToWasm(func, sig); + table.set(ret, wrapped); + } + + return ret; + } + + function removeFunctionWasm(index) { + // TODO(sbc): Look into implementing this to allow re-using of table slots + } + + // 'sig' parameter is required for the llvm backend but only when func is not + // already a WebAssembly function. + function addFunction(func, sig) { + + + var base = 0; + for (var i = base; i < base + 20; i++) { + if (!functionPointers[i]) { + functionPointers[i] = func; + return jsCallStartIndex + i; + } + } + throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.'; + + } + + function removeFunction(index) { + + functionPointers[index-jsCallStartIndex] = null; + } + + var funcWrappers = {}; + + function getFuncWrapper(func, sig) { + if (!func) return; // on null pointer, return undefined + assert(sig); + if (!funcWrappers[sig]) { + funcWrappers[sig] = {}; + } + var sigCache = funcWrappers[sig]; + if (!sigCache[func]) { + // optimize away arguments usage in common cases + if (sig.length === 1) { + sigCache[func] = function dynCall_wrapper() { + return dynCall(sig, func); + }; + } else if (sig.length === 2) { + sigCache[func] = function dynCall_wrapper(arg) { + return dynCall(sig, func, [arg]); + }; + } else { + // general case + sigCache[func] = function dynCall_wrapper() { + return dynCall(sig, func, Array.prototype.slice.call(arguments)); + }; + } + } + return sigCache[func]; + } + + + function makeBigInt(low, high, unsigned) { + return unsigned ? ((+((low>>>0)))+((+((high>>>0)))*4294967296.0)) : ((+((low>>>0)))+((+((high|0)))*4294967296.0)); + } + + function dynCall(sig, ptr, args) { + if (args && args.length) { + return Module['dynCall_' + sig].apply(null, [ptr].concat(args)); + } else { + return Module['dynCall_' + sig].call(null, ptr); + } + } + + var tempRet0 = 0; + + var setTempRet0 = function(value) { + tempRet0 = value; + }; + + var getTempRet0 = function() { + return tempRet0; + }; + + + var Runtime = { + }; + + // The address globals begin at. Very low in memory, for code size and optimization opportunities. + // Above 0 is static memory, starting with globals. + // Then the stack. + // Then 'dynamic' memory for sbrk. + var GLOBAL_BASE = 1024; + + + + + // === Preamble library stuff === + + // Documentation for the public APIs defined in this file must be updated in: + // site/source/docs/api_reference/preamble.js.rst + // A prebuilt local version of the documentation is available at: + // site/build/text/docs/api_reference/preamble.js.txt + // You can also build docs locally as HTML or other formats in site/ + // An online HTML version (which may be of a different version of Emscripten) + // is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html + + + var wasmBinary;if (Module['wasmBinary']) wasmBinary = Module['wasmBinary']; + var noExitRuntime;if (Module['noExitRuntime']) noExitRuntime = Module['noExitRuntime']; + + + if (typeof WebAssembly !== 'object') { + err('no native wasm support detected'); + } + + + // In MINIMAL_RUNTIME, setValue() and getValue() are only available when building with safe heap enabled, for heap safety checking. + // In traditional runtime, setValue() and getValue() are always available (although their use is highly discouraged due to perf penalties) + + /** @type {function(number, number, string, boolean=)} */ + function setValue(ptr, value, type, noSafe) { + type = type || 'i8'; + if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit + switch(type) { + case 'i1': HEAP8[((ptr)>>0)]=value; break; + case 'i8': HEAP8[((ptr)>>0)]=value; break; + case 'i16': HEAP16[((ptr)>>1)]=value; break; + case 'i32': HEAP32[((ptr)>>2)]=value; break; + case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math_min((+(Math_floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break; + case 'float': HEAPF32[((ptr)>>2)]=value; break; + case 'double': HEAPF64[((ptr)>>3)]=value; break; + default: abort('invalid type for setValue: ' + type); + } + } + + /** @type {function(number, string, boolean=)} */ + function getValue(ptr, type, noSafe) { + type = type || 'i8'; + if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit + switch(type) { + case 'i1': return HEAP8[((ptr)>>0)]; + case 'i8': return HEAP8[((ptr)>>0)]; + case 'i16': return HEAP16[((ptr)>>1)]; + case 'i32': return HEAP32[((ptr)>>2)]; + case 'i64': return HEAP32[((ptr)>>2)]; + case 'float': return HEAPF32[((ptr)>>2)]; + case 'double': return HEAPF64[((ptr)>>3)]; + default: abort('invalid type for getValue: ' + type); + } + return null; + } + + + + + + // Wasm globals + + var wasmMemory; + + // In fastcomp asm.js, we don't need a wasm Table at all. + // In the wasm backend, we polyfill the WebAssembly object, + // so this creates a (non-native-wasm) table for us. + var wasmTable = new WebAssembly.Table({ + 'initial': 448, + 'maximum': 448, + 'element': 'anyfunc' + }); + + + //======================================== + // Runtime essentials + //======================================== + + // whether we are quitting the application. no code should run after this. + // set in exit() and abort() + var ABORT = false; + + // set by exit() and abort(). Passed to 'onExit' handler. + // NOTE: This is also used as the process return code code in shell environments + // but only when noExitRuntime is false. + var EXITSTATUS = 0; + + /** @type {function(*, string=)} */ + function assert(condition, text) { + if (!condition) { + abort('Assertion failed: ' + text); + } + } + + // Returns the C function with a specified identifier (for C++, you need to do manual name mangling) + function getCFunc(ident) { + var func = Module['_' + ident]; // closure exported function + assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported'); + return func; + } + + // C calling interface. + function ccall(ident, returnType, argTypes, args, opts) { + // For fast lookup of conversion functions + var toC = { + 'string': function(str) { + var ret = 0; + if (str !== null && str !== undefined && str !== 0) { // null string + // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0' + var len = (str.length << 2) + 1; + ret = stackAlloc(len); + stringToUTF8(str, ret, len); + } + return ret; + }, + 'array': function(arr) { + var ret = stackAlloc(arr.length); + writeArrayToMemory(arr, ret); + return ret; + } + }; + + function convertReturnValue(ret) { + if (returnType === 'string') return UTF8ToString(ret); + if (returnType === 'boolean') return Boolean(ret); + return ret; + } + + var func = getCFunc(ident); + var cArgs = []; + var stack = 0; + if (args) { + for (var i = 0; i < args.length; i++) { + var converter = toC[argTypes[i]]; + if (converter) { + if (stack === 0) stack = stackSave(); + cArgs[i] = converter(args[i]); + } else { + cArgs[i] = args[i]; + } + } + } + var ret = func.apply(null, cArgs); + + ret = convertReturnValue(ret); + if (stack !== 0) stackRestore(stack); + return ret; + } + + function cwrap(ident, returnType, argTypes, opts) { + argTypes = argTypes || []; + // When the function takes numbers and returns a number, we can just return + // the original function + var numericArgs = argTypes.every(function(type){ return type === 'number'}); + var numericRet = returnType !== 'string'; + if (numericRet && numericArgs && !opts) { + return getCFunc(ident); + } + return function() { + return ccall(ident, returnType, argTypes, arguments, opts); + } + } + + var ALLOC_NORMAL = 0; // Tries to use _malloc() + var ALLOC_STACK = 1; // Lives for the duration of the current function call + var ALLOC_DYNAMIC = 2; // Cannot be freed except through sbrk + var ALLOC_NONE = 3; // Do not allocate + + // allocate(): This is for internal use. You can use it yourself as well, but the interface + // is a little tricky (see docs right below). The reason is that it is optimized + // for multiple syntaxes to save space in generated code. So you should + // normally not use allocate(), and instead allocate memory using _malloc(), + // initialize it with setValue(), and so forth. + // @slab: An array of data, or a number. If a number, then the size of the block to allocate, + // in *bytes* (note that this is sometimes confusing: the next parameter does not + // affect this!) + // @types: Either an array of types, one for each byte (or 0 if no type at that position), + // or a single type which is used for the entire block. This only matters if there + // is initial data - if @slab is a number, then this does not matter at all and is + // ignored. + // @allocator: How to allocate memory, see ALLOC_* + /** @type {function((TypedArray|Array|number), string, number, number=)} */ + function allocate(slab, types, allocator, ptr) { + var zeroinit, size; + if (typeof slab === 'number') { + zeroinit = true; + size = slab; + } else { + zeroinit = false; + size = slab.length; + } + + var singleType = typeof types === 'string' ? types : null; + + var ret; + if (allocator == ALLOC_NONE) { + ret = ptr; + } else { + ret = [_malloc, + stackAlloc, + dynamicAlloc][allocator](Math.max(size, singleType ? 1 : types.length)); + } + + if (zeroinit) { + var stop; + ptr = ret; + assert((ret & 3) == 0); + stop = ret + (size & ~3); + for (; ptr < stop; ptr += 4) { + HEAP32[((ptr)>>2)]=0; + } + stop = ret + size; + while (ptr < stop) { + HEAP8[((ptr++)>>0)]=0; + } + return ret; + } + + if (singleType === 'i8') { + if (slab.subarray || slab.slice) { + HEAPU8.set(/** @type {!Uint8Array} */ (slab), ret); + } else { + HEAPU8.set(new Uint8Array(slab), ret); + } + return ret; + } + + var i = 0, type, typeSize, previousType; + while (i < size) { + var curr = slab[i]; + + type = singleType || types[i]; + if (type === 0) { + i++; + continue; + } + + if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later + + setValue(ret+i, curr, type); + + // no need to look up size unless type changes, so cache it + if (previousType !== type) { + typeSize = getNativeTypeSize(type); + previousType = type; + } + i += typeSize; + } + + return ret; + } + + // Allocate memory during any stage of startup - static memory early on, dynamic memory later, malloc when ready + function getMemory(size) { + if (!runtimeInitialized) return dynamicAlloc(size); + return _malloc(size); + } + + + + + /** @type {function(number, number=)} */ + function Pointer_stringify(ptr, length) { + abort("this function has been removed - you should use UTF8ToString(ptr, maxBytesToRead) instead!"); + } + + // Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns + // a copy of that string as a Javascript String object. + + function AsciiToString(ptr) { + var str = ''; + while (1) { + var ch = HEAPU8[((ptr++)>>0)]; + if (!ch) return str; + str += String.fromCharCode(ch); + } + } + + // Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', + // null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP. + + function stringToAscii(str, outPtr) { + return writeAsciiToMemory(str, outPtr, false); + } + + + // Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns + // a copy of that string as a Javascript String object. + + var UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined; + + /** + * @param {number} idx + * @param {number=} maxBytesToRead + * @return {string} + */ + function UTF8ArrayToString(u8Array, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. + // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. + // (As a tiny code save trick, compare endPtr against endIdx using a negation, so that undefined means Infinity) + while (u8Array[endPtr] && !(endPtr >= endIdx)) ++endPtr; + + if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) { + return UTF8Decoder.decode(u8Array.subarray(idx, endPtr)); + } else { + var str = ''; + // If building with TextDecoder, we have already computed the string length above, so test loop end condition against that + while (idx < endPtr) { + // For UTF8 byte structure, see: + // http://en.wikipedia.org/wiki/UTF-8#Description + // https://www.ietf.org/rfc/rfc2279.txt + // https://tools.ietf.org/html/rfc3629 + var u0 = u8Array[idx++]; + if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } + var u1 = u8Array[idx++] & 63; + if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } + var u2 = u8Array[idx++] & 63; + if ((u0 & 0xF0) == 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (u8Array[idx++] & 63); + } + + if (u0 < 0x10000) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } + } + } + return str; + } + + // Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns a + // copy of that string as a Javascript String object. + // maxBytesToRead: an optional length that specifies the maximum number of bytes to read. You can omit + // this parameter to scan the string until the first \0 byte. If maxBytesToRead is + // passed, and the string at [ptr, ptr+maxBytesToReadr[ contains a null byte in the + // middle, then the string will cut short at that byte index (i.e. maxBytesToRead will + // not produce a string of exact length [ptr, ptr+maxBytesToRead[) + // N.B. mixing frequent uses of UTF8ToString() with and without maxBytesToRead may + // throw JS JIT optimizations off, so it is worth to consider consistently using one + // style or the other. + /** + * @param {number} ptr + * @param {number=} maxBytesToRead + * @return {string} + */ + function UTF8ToString(ptr, maxBytesToRead) { + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ''; + } + + // Copies the given Javascript String object 'str' to the given byte array at address 'outIdx', + // encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP. + // Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write. + // Parameters: + // str: the Javascript string to copy. + // outU8Array: the array to copy to. Each index in this array is assumed to be one 8-byte element. + // outIdx: The starting offset in the array to begin the copying. + // maxBytesToWrite: The maximum number of bytes this function can write to the array. + // This count should include the null terminator, + // i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else. + // maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator. + // Returns the number of bytes written, EXCLUDING the null terminator. + + function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) { + if (!(maxBytesToWrite > 0)) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes. + return 0; + + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator. + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) { + var u1 = str.charCodeAt(++i); + u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF); + } + if (u <= 0x7F) { + if (outIdx >= endIdx) break; + outU8Array[outIdx++] = u; + } else if (u <= 0x7FF) { + if (outIdx + 1 >= endIdx) break; + outU8Array[outIdx++] = 0xC0 | (u >> 6); + outU8Array[outIdx++] = 0x80 | (u & 63); + } else if (u <= 0xFFFF) { + if (outIdx + 2 >= endIdx) break; + outU8Array[outIdx++] = 0xE0 | (u >> 12); + outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); + outU8Array[outIdx++] = 0x80 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + outU8Array[outIdx++] = 0xF0 | (u >> 18); + outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63); + outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); + outU8Array[outIdx++] = 0x80 | (u & 63); + } + } + // Null-terminate the pointer to the buffer. + outU8Array[outIdx] = 0; + return outIdx - startIdx; + } + + // Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', + // null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP. + // Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write. + // Returns the number of bytes written, EXCLUDING the null terminator. + + function stringToUTF8(str, outPtr, maxBytesToWrite) { + return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite); + } + + // Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte. + function lengthBytesUTF8(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF); + if (u <= 0x7F) ++len; + else if (u <= 0x7FF) len += 2; + else if (u <= 0xFFFF) len += 3; + else len += 4; + } + return len; + } + + + // Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns + // a copy of that string as a Javascript String object. + + var UTF16Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-16le') : undefined; + function UTF16ToString(ptr) { + var endPtr = ptr; + // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. + // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. + var idx = endPtr >> 1; + while (HEAP16[idx]) ++idx; + endPtr = idx << 1; + + if (endPtr - ptr > 32 && UTF16Decoder) { + return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); + } else { + var i = 0; + + var str = ''; + while (1) { + var codeUnit = HEAP16[(((ptr)+(i*2))>>1)]; + if (codeUnit == 0) return str; + ++i; + // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through. + str += String.fromCharCode(codeUnit); + } + } + } + + // Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', + // null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP. + // Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write. + // Parameters: + // str: the Javascript string to copy. + // outPtr: Byte address in Emscripten HEAP where to write the string to. + // maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null + // terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else. + // maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator. + // Returns the number of bytes written, EXCLUDING the null terminator. + + function stringToUTF16(str, outPtr, maxBytesToWrite) { + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; // Null terminator. + var startPtr = outPtr; + var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + HEAP16[((outPtr)>>1)]=codeUnit; + outPtr += 2; + } + // Null-terminate the pointer to the HEAP. + HEAP16[((outPtr)>>1)]=0; + return outPtr - startPtr; + } + + // Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. + + function lengthBytesUTF16(str) { + return str.length*2; + } + + function UTF32ToString(ptr) { + var i = 0; + + var str = ''; + while (1) { + var utf32 = HEAP32[(((ptr)+(i*4))>>2)]; + if (utf32 == 0) + return str; + ++i; + // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + if (utf32 >= 0x10000) { + var ch = utf32 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } else { + str += String.fromCharCode(utf32); + } + } + } + + // Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', + // null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP. + // Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write. + // Parameters: + // str: the Javascript string to copy. + // outPtr: Byte address in Emscripten HEAP where to write the string to. + // maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null + // terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else. + // maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator. + // Returns the number of bytes written, EXCLUDING the null terminator. + + function stringToUTF32(str, outPtr, maxBytesToWrite) { + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF); + } + HEAP32[((outPtr)>>2)]=codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + // Null-terminate the pointer to the HEAP. + HEAP32[((outPtr)>>2)]=0; + return outPtr - startPtr; + } + + // Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. + + function lengthBytesUTF32(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate. + len += 4; + } + + return len; + } + + // Allocate heap space for a JS string, and write it there. + // It is the responsibility of the caller to free() that memory. + function allocateUTF8(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = _malloc(size); + if (ret) stringToUTF8Array(str, HEAP8, ret, size); + return ret; + } + + // Allocate stack space for a JS string, and write it there. + function allocateUTF8OnStack(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = stackAlloc(size); + stringToUTF8Array(str, HEAP8, ret, size); + return ret; + } + + // Deprecated: This function should not be called because it is unsafe and does not provide + // a maximum length limit of how many bytes it is allowed to write. Prefer calling the + // function stringToUTF8Array() instead, which takes in a maximum length that can be used + // to be secure from out of bounds writes. + /** @deprecated */ + function writeStringToMemory(string, buffer, dontAddNull) { + warnOnce('writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!'); + + var /** @type {number} */ lastChar, /** @type {number} */ end; + if (dontAddNull) { + // stringToUTF8Array always appends null. If we don't want to do that, remember the + // character that existed at the location where the null will be placed, and restore + // that after the write (below). + end = buffer + lengthBytesUTF8(string); + lastChar = HEAP8[end]; + } + stringToUTF8(string, buffer, Infinity); + if (dontAddNull) HEAP8[end] = lastChar; // Restore the value under the null character. + } + + function writeArrayToMemory(array, buffer) { + HEAP8.set(array, buffer); + } + + function writeAsciiToMemory(str, buffer, dontAddNull) { + for (var i = 0; i < str.length; ++i) { + HEAP8[((buffer++)>>0)]=str.charCodeAt(i); + } + // Null-terminate the pointer to the HEAP. + if (!dontAddNull) HEAP8[((buffer)>>0)]=0; + } + + + + + // Memory management + + var PAGE_SIZE = 16384; + var WASM_PAGE_SIZE = 65536; + var ASMJS_PAGE_SIZE = 16777216; + + function alignUp(x, multiple) { + if (x % multiple > 0) { + x += multiple - (x % multiple); + } + return x; + } + + var HEAP, + /** @type {ArrayBuffer} */ + buffer, + /** @type {Int8Array} */ + HEAP8, + /** @type {Uint8Array} */ + HEAPU8, + /** @type {Int16Array} */ + HEAP16, + /** @type {Uint16Array} */ + HEAPU16, + /** @type {Int32Array} */ + HEAP32, + /** @type {Uint32Array} */ + HEAPU32, + /** @type {Float32Array} */ + HEAPF32, + /** @type {Float64Array} */ + HEAPF64; + + function updateGlobalBufferAndViews(buf) { + buffer = buf; + Module['HEAP8'] = HEAP8 = new Int8Array(buf); + Module['HEAP16'] = HEAP16 = new Int16Array(buf); + Module['HEAP32'] = HEAP32 = new Int32Array(buf); + Module['HEAPU8'] = HEAPU8 = new Uint8Array(buf); + Module['HEAPU16'] = HEAPU16 = new Uint16Array(buf); + Module['HEAPU32'] = HEAPU32 = new Uint32Array(buf); + Module['HEAPF32'] = HEAPF32 = new Float32Array(buf); + Module['HEAPF64'] = HEAPF64 = new Float64Array(buf); + } + + var STATIC_BASE = 1024, + STACK_BASE = 13360, + STACKTOP = STACK_BASE, + STACK_MAX = 5256240, + DYNAMIC_BASE = 5256240, + DYNAMICTOP_PTR = 13168; + + + + + var TOTAL_STACK = 5242880; + + var INITIAL_TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 16777216; + + + + + + + + // In standalone mode, the wasm creates the memory, and the user can't provide it. + // In non-standalone/normal mode, we create the memory here. + + // Create the main memory. (Note: this isn't used in STANDALONE_WASM mode since the wasm + // memory is created in the wasm, not in JS.) + + if (Module['wasmMemory']) { + wasmMemory = Module['wasmMemory']; + } else + { + wasmMemory = new WebAssembly.Memory({ + 'initial': INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE + , + 'maximum': INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE + }); + } + + + if (wasmMemory) { + buffer = wasmMemory.buffer; + } + + // If the user provides an incorrect length, just use that length instead rather than providing the user to + // specifically provide the memory length with Module['TOTAL_MEMORY']. + INITIAL_TOTAL_MEMORY = buffer.byteLength; + updateGlobalBufferAndViews(buffer); + + HEAP32[DYNAMICTOP_PTR>>2] = DYNAMIC_BASE; + + + + + + + + + + + function callRuntimeCallbacks(callbacks) { + while(callbacks.length > 0) { + var callback = callbacks.shift(); + if (typeof callback == 'function') { + callback(); + continue; + } + var func = callback.func; + if (typeof func === 'number') { + if (callback.arg === undefined) { + Module['dynCall_v'](func); + } else { + Module['dynCall_vi'](func, callback.arg); + } + } else { + func(callback.arg === undefined ? null : callback.arg); + } + } + } + + var __ATPRERUN__ = []; // functions called before the runtime is initialized + var __ATINIT__ = []; // functions called during startup + var __ATMAIN__ = []; // functions called when main() is to be run + var __ATEXIT__ = []; // functions called during shutdown + var __ATPOSTRUN__ = []; // functions called after the main() is called + + var runtimeInitialized = false; + var runtimeExited = false; + + + function preRun() { + + if (Module['preRun']) { + if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']]; + while (Module['preRun'].length) { + addOnPreRun(Module['preRun'].shift()); + } + } + + callRuntimeCallbacks(__ATPRERUN__); + } + + function initRuntime() { + runtimeInitialized = true; + + callRuntimeCallbacks(__ATINIT__); + } + + function preMain() { + + callRuntimeCallbacks(__ATMAIN__); + } + + function exitRuntime() { + runtimeExited = true; + } + + function postRun() { + + if (Module['postRun']) { + if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']]; + while (Module['postRun'].length) { + addOnPostRun(Module['postRun'].shift()); + } + } + + callRuntimeCallbacks(__ATPOSTRUN__); + } + + function addOnPreRun(cb) { + __ATPRERUN__.unshift(cb); + } + + function addOnInit(cb) { + __ATINIT__.unshift(cb); + } + + function addOnPreMain(cb) { + __ATMAIN__.unshift(cb); + } + + function addOnExit(cb) { + } + + function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); + } + + function unSign(value, bits, ignore) { + if (value >= 0) { + return value; + } + return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts + : Math.pow(2, bits) + value; + } + function reSign(value, bits, ignore) { + if (value <= 0) { + return value; + } + var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32 + : Math.pow(2, bits-1); + if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that + // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors + // TODO: In i64 mode 1, resign the two parts separately and safely + value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts + } + return value; + } + + + + var Math_abs = Math.abs; + var Math_cos = Math.cos; + var Math_sin = Math.sin; + var Math_tan = Math.tan; + var Math_acos = Math.acos; + var Math_asin = Math.asin; + var Math_atan = Math.atan; + var Math_atan2 = Math.atan2; + var Math_exp = Math.exp; + var Math_log = Math.log; + var Math_sqrt = Math.sqrt; + var Math_ceil = Math.ceil; + var Math_floor = Math.floor; + var Math_pow = Math.pow; + var Math_imul = Math.imul; + var Math_fround = Math.fround; + var Math_round = Math.round; + var Math_min = Math.min; + var Math_max = Math.max; + var Math_clz32 = Math.clz32; + var Math_trunc = Math.trunc; + + + + // A counter of dependencies for calling run(). If we need to + // do asynchronous work before running, increment this and + // decrement it. Incrementing must happen in a place like + // Module.preRun (used by emcc to add file preloading). + // Note that you can add dependencies in preRun, even though + // it happens right before run - run will be postponed until + // the dependencies are met. + var runDependencies = 0; + var runDependencyWatcher = null; + var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled + + function getUniqueRunDependency(id) { + return id; + } + + function addRunDependency(id) { + runDependencies++; + + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + + } + + function removeRunDependency(id) { + runDependencies--; + + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); // can add another dependenciesFulfilled + } + } + } + + Module["preloadedImages"] = {}; // maps url to image data + Module["preloadedAudios"] = {}; // maps url to audio data + + + function abort(what) { + if (Module['onAbort']) { + Module['onAbort'](what); + } + + what += ''; + out(what); + err(what); + + ABORT = true; + EXITSTATUS = 1; + + what = 'abort(' + what + '). Build with -s ASSERTIONS=1 for more info.'; + + // Throw a wasm runtime error, because a JS error might be seen as a foreign + // exception, which means we'd run destructors on it. We need the error to + // simply make the program stop. + throw new WebAssembly.RuntimeError(what); + } + + + var memoryInitializer = null; + + + + + + + + // Copyright 2017 The Emscripten Authors. All rights reserved. + // Emscripten is available under two separate licenses, the MIT license and the + // University of Illinois/NCSA Open Source License. Both these licenses can be + // found in the LICENSE file. + + // Prefix of data URIs emitted by SINGLE_FILE and related options. + var dataURIPrefix = 'data:application/octet-stream;base64,'; + + // Indicates whether filename is a base64 data URI. + function isDataURI(filename) { + return String.prototype.startsWith ? + filename.startsWith(dataURIPrefix) : + filename.indexOf(dataURIPrefix) === 0; + } + + + + + var wasmBinaryFile = 'picotcp.wasm'; + if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = locateFile(wasmBinaryFile); + } + + function getBinary() { + try { + if (wasmBinary) { + return new Uint8Array(wasmBinary); + } + + if (readBinary) { + return readBinary(wasmBinaryFile); + } else { + throw "both async and sync fetching of the wasm failed"; + } + } + catch (err) { + abort(err); + } + } + + function getBinaryPromise() { + // if we don't have the binary yet, and have the Fetch api, use that + // in some environments, like Electron's render process, Fetch api may be present, but have a different context than expected, let's only use it on the Web + if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === 'function') { + return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function(response) { + if (!response['ok']) { + throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"; + } + return response['arrayBuffer'](); + }).catch(function () { + return getBinary(); + }); + } + // Otherwise, getBinary should be able to get it synchronously + return new Promise(function(resolve, reject) { + resolve(getBinary()); + }); + } + + + + // Create the wasm instance. + // Receives the wasm imports, returns the exports. + function createWasm() { + // prepare imports + var info = { + 'env': asmLibraryArg, + 'wasi_unstable': asmLibraryArg + , + 'global': { + 'NaN': NaN, + 'Infinity': Infinity + }, + 'global.Math': Math, + 'asm2wasm': asm2wasmImports + }; + // Load the wasm module and create an instance of using native support in the JS engine. + // handle a generated wasm instance, receiving its exports and + // performing other necessary setup + function receiveInstance(instance, module) { + var exports = instance.exports; + Module['asm'] = exports; + removeRunDependency('wasm-instantiate'); + } + // we can't run yet (except in a pthread, where we have a custom sync instantiator) + addRunDependency('wasm-instantiate'); + + + function receiveInstantiatedSource(output) { + // 'output' is a WebAssemblyInstantiatedSource object which has both the module and instance. + // receiveInstance() will swap in the exports (to Module.asm) so they can be called + // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. + // When the regression is fixed, can restore the above USE_PTHREADS-enabled path. + receiveInstance(output['instance']); + } + + + function instantiateArrayBuffer(receiver) { + return getBinaryPromise().then(function(binary) { + return WebAssembly.instantiate(binary, info); + }).then(receiver, function(reason) { + err('failed to asynchronously prepare wasm: ' + reason); + abort(reason); + }); + } + + // Prefer streaming instantiation if available. + function instantiateAsync() { + if (!wasmBinary && + typeof WebAssembly.instantiateStreaming === 'function' && + !isDataURI(wasmBinaryFile) && + typeof fetch === 'function') { + fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function (response) { + var result = WebAssembly.instantiateStreaming(response, info); + return result.then(receiveInstantiatedSource, function(reason) { + // We expect the most common failure cause to be a bad MIME type for the binary, + // in which case falling back to ArrayBuffer instantiation should work. + err('wasm streaming compile failed: ' + reason); + err('falling back to ArrayBuffer instantiation'); + instantiateArrayBuffer(receiveInstantiatedSource); + }); + }); + } else { + return instantiateArrayBuffer(receiveInstantiatedSource); + } + } + // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback + // to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel + // to any other async startup actions they are performing. + if (Module['instantiateWasm']) { + try { + var exports = Module['instantiateWasm'](info, receiveInstance); + return exports; + } catch(e) { + err('Module.instantiateWasm callback failed with error: ' + e); + return false; + } + } + + instantiateAsync(); + return {}; // no exports yet; we'll fill them in later + } + + Module['asm'] = createWasm; + + // Globals used by JS i64 conversions + var tempDouble; + var tempI64; + + // === Body === + + var ASM_CONSTS = [function($0) { Module.pointers[$0] = { writable: new SyncReadableWritableStream(), readable: new SyncWritableReadableStream(), }; }, + function($0, $1, $2, $3) { Module.pointers[$0] = { writable: new SyncReadableWritableStream(), readable: new SyncWritableReadableStream(), remoteIP: $1, remotePort: $2, }; Module.pointers[$3].readable._write(Module.pointers[$0]); }, + function($0) { Module.pointers[$0].readable.error(); }, + function($0, $1, $2) { Module.pointers[$0].readable._write(HEAPU8.slice($1, $1 + $2)); }, + function($0, $1) { const device = Module.pointers[$0]; const buffer = device.writable._read(); if (buffer === device.writable.EOF) return -1; if (!buffer) device.writable._onData = () => { Module._js_wakeup($1, $0); }; if (!buffer) return 0; Module._readBuffer = buffer; return buffer.byteLength; }, + function($0) { writeArrayToMemory(Module._readBuffer, $0); }, + function($0, $1) { const _unread = (reader, value) => { reader._read = new Proxy(reader._read, { apply(target, thisArg, args) { thisArg._read = target; return value; } }); }; const device = Module.pointers[$0]; if ($1 < Module._readBuffer.byteLength) { _unread(device.writable, Module._readBuffer.subarray($1)); } Module._readBuffer = null; }, + function($0) { Module.pointers[$0] && Module.pointers[$0]._readable && Module.pointers[$0].readable._close(); }, + function($0, $1) { Module.pointers[$0] = { name: UTF8ToString($1), writable: new SyncReadableWritableStream(), readable: new SyncWritableReadableStream(), }; }, + function($0) { return Module.pointers[$0].readable.desiredSize }, + function($0, $1, $2) { Module.pointers[$0].readable._write(HEAPU8.slice($1, $1 + $2)); }, + function($0) { const device = Module.pointers[$0]; const buffer = device.writable._read(); if (!buffer) return 0; Module._readBuffer = buffer; return buffer.byteLength; }, + function($0) { writeArrayToMemory(Module._readBuffer, $0); Module._readBuffer = null; }, + function() { Module._readBuffer = null; Module.pointers = {}; }]; + + function _emscripten_asm_const_i(code) { + return ASM_CONSTS[code](); + } + + function _emscripten_asm_const_iii(code, a0, a1) { + return ASM_CONSTS[code](a0, a1); + } + + function _emscripten_asm_const_iiiii(code, a0, a1, a2, a3) { + return ASM_CONSTS[code](a0, a1, a2, a3); + } + + function _emscripten_asm_const_ii(code, a0) { + return ASM_CONSTS[code](a0); + } + + function _emscripten_asm_const_iiii(code, a0, a1, a2) { + return ASM_CONSTS[code](a0, a1, a2); + } + + function _emscripten_asm_const_di(code, a0) { + return ASM_CONSTS[code](a0); + } + + + + + // STATICTOP = STATIC_BASE + 12336; + /* global initializers */ /*__ATINIT__.push();*/ + + + + + + + + + /* no memory initializer */ + var tempDoublePtr = 13344; + + function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much + HEAP8[tempDoublePtr] = HEAP8[ptr]; + HEAP8[tempDoublePtr+1] = HEAP8[ptr+1]; + HEAP8[tempDoublePtr+2] = HEAP8[ptr+2]; + HEAP8[tempDoublePtr+3] = HEAP8[ptr+3]; + } + + function copyTempDouble(ptr) { + HEAP8[tempDoublePtr] = HEAP8[ptr]; + HEAP8[tempDoublePtr+1] = HEAP8[ptr+1]; + HEAP8[tempDoublePtr+2] = HEAP8[ptr+2]; + HEAP8[tempDoublePtr+3] = HEAP8[ptr+3]; + HEAP8[tempDoublePtr+4] = HEAP8[ptr+4]; + HEAP8[tempDoublePtr+5] = HEAP8[ptr+5]; + HEAP8[tempDoublePtr+6] = HEAP8[ptr+6]; + HEAP8[tempDoublePtr+7] = HEAP8[ptr+7]; + } + + // {{PRE_LIBRARY}} + + + function demangle(func) { + return func; + } + Module["demangle"] = demangle; + + function demangleAll(text) { + var regex = + /\b__Z[\w\d_]+/g; + return text.replace(regex, + function(x) { + var y = demangle(x); + return x === y ? x : (y + ' [' + x + ']'); + }); + } + Module["demangleAll"] = demangleAll; + + function jsStackTrace() { + var err = new Error(); + if (!err.stack) { + // IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown, + // so try that as a special-case. + try { + throw new Error(0); + } catch(e) { + err = e; + } + if (!err.stack) { + return '(no stack trace available)'; + } + } + return err.stack.toString(); + } + Module["jsStackTrace"] = jsStackTrace; + + function stackTrace() { + var js = jsStackTrace(); + if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace'](); + return demangleAll(js); + } + Module["stackTrace"] = stackTrace; + + + + function flush_NO_FILESYSTEM() { + // flush anything remaining in the buffers during shutdown + var fflush = Module["_fflush"]; + if (fflush) fflush(0); + var buffers = SYSCALLS.buffers; + if (buffers[1].length) SYSCALLS.printChar(1, 10); + if (buffers[2].length) SYSCALLS.printChar(2, 10); + } + Module["flush_NO_FILESYSTEM"] = flush_NO_FILESYSTEM; + + + var PATH={splitPath:function (filename) { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1); + },normalizeArray:function (parts, allowAboveRoot) { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift('..'); + } + } + return parts; + },normalize:function (path) { + var isAbsolute = path.charAt(0) === '/', + trailingSlash = path.substr(-1) === '/'; + // Normalize the path + path = PATH.normalizeArray(path.split('/').filter(function(p) { + return !!p; + }), !isAbsolute).join('/'); + if (!path && !isAbsolute) { + path = '.'; + } + if (path && trailingSlash) { + path += '/'; + } + return (isAbsolute ? '/' : '') + path; + },dirname:function (path) { + var result = PATH.splitPath(path), + root = result[0], + dir = result[1]; + if (!root && !dir) { + // No dirname whatsoever + return '.'; + } + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + },basename:function (path) { + // EMSCRIPTEN return '/'' for '/', not an empty string + if (path === '/') return '/'; + var lastSlash = path.lastIndexOf('/'); + if (lastSlash === -1) return path; + return path.substr(lastSlash+1); + },extname:function (path) { + return PATH.splitPath(path)[3]; + },join:function () { + var paths = Array.prototype.slice.call(arguments, 0); + return PATH.normalize(paths.join('/')); + },join2:function (l, r) { + return PATH.normalize(l + '/' + r); + }}; + Module["PATH"] = PATH;var SYSCALLS={buffers:[null,[],[]],printChar:function (stream, curr) { + var buffer = SYSCALLS.buffers[stream]; + if (curr === 0 || curr === 10) { + (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0)); + buffer.length = 0; + } else { + buffer.push(curr); + } + },varargs:0,get:function (varargs) { + SYSCALLS.varargs += 4; + var ret = HEAP32[(((SYSCALLS.varargs)-(4))>>2)]; + return ret; + },getStr:function () { + var ret = UTF8ToString(SYSCALLS.get()); + return ret; + },get64:function () { + var low = SYSCALLS.get(), high = SYSCALLS.get(); + return low; + },getZero:function () { + SYSCALLS.get(); + }}; + Module["SYSCALLS"] = SYSCALLS;function _fd_write(fd, iov, iovcnt, pnum) {try { + + // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0 + var num = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAP32[(((iov)+(i*8))>>2)]; + var len = HEAP32[(((iov)+(i*8 + 4))>>2)]; + for (var j = 0; j < len; j++) { + SYSCALLS.printChar(fd, HEAPU8[ptr+j]); + } + num += len; + } + HEAP32[((pnum)>>2)]=num; + return 0; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return e.errno; + } + } + Module["_fd_write"] = _fd_write;function ___wasi_fd_write() { + return _fd_write.apply(null, arguments) + } + Module["___wasi_fd_write"] = ___wasi_fd_write; + + function _abort() { + abort(); + } + Module["_abort"] = _abort; + + var _emscripten_asm_const_double=true; + Module["_emscripten_asm_const_double"] = _emscripten_asm_const_double; + + var _emscripten_asm_const_int=true; + Module["_emscripten_asm_const_int"] = _emscripten_asm_const_int; + + function _emscripten_get_heap_size() { + return HEAP8.length; + } + Module["_emscripten_get_heap_size"] = _emscripten_get_heap_size; + + + + + function abortOnCannotGrowMemory(requestedSize) { + abort('OOM'); + } + Module["abortOnCannotGrowMemory"] = abortOnCannotGrowMemory;function _emscripten_resize_heap(requestedSize) { + abortOnCannotGrowMemory(requestedSize); + } + Module["_emscripten_resize_heap"] = _emscripten_resize_heap; + + function _gettimeofday(ptr) { + var now = Date.now(); + HEAP32[((ptr)>>2)]=(now/1000)|0; // seconds + HEAP32[(((ptr)+(4))>>2)]=((now % 1000)*1000)|0; // microseconds + return 0; + } + Module["_gettimeofday"] = _gettimeofday; + + + + + + + function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.set(HEAPU8.subarray(src, src+num), dest); + } + Module["_emscripten_memcpy_big"] = _emscripten_memcpy_big; + + + + + var ASSERTIONS = false; + + // Copyright 2017 The Emscripten Authors. All rights reserved. + // Emscripten is available under two separate licenses, the MIT license and the + // University of Illinois/NCSA Open Source License. Both these licenses can be + // found in the LICENSE file. + + /** @type {function(string, boolean=, number=)} */ + function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy)+1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) u8array.length = numBytesWritten; + return u8array; + } + + function intArrayToString(array) { + var ret = []; + for (var i = 0; i < array.length; i++) { + var chr = array[i]; + if (chr > 0xFF) { + if (ASSERTIONS) { + assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ') at offset ' + i + ' not in 0x00-0xFF.'); + } + chr &= 0xFF; + } + ret.push(String.fromCharCode(chr)); + } + return ret.join(''); + } + + + // ASM_LIBRARY EXTERN PRIMITIVES: Int8Array,Int32Array + + + function jsCall_ii(index,a1) { + return functionPointers[index](a1); + } + + function jsCall_iidiiii(index,a1,a2,a3,a4,a5,a6) { + return functionPointers[index](a1,a2,a3,a4,a5,a6); + } + + function jsCall_iii(index,a1,a2) { + return functionPointers[index](a1,a2); + } + + function jsCall_iiii(index,a1,a2,a3) { + return functionPointers[index](a1,a2,a3); + } + + function jsCall_jiji(index,a1,a2,a3) { + return functionPointers[index](a1,a2,a3); + } + + function jsCall_vi(index,a1) { + functionPointers[index](a1); + } + + function jsCall_vii(index,a1,a2) { + functionPointers[index](a1,a2); + } + + function jsCall_viiii(index,a1,a2,a3,a4) { + functionPointers[index](a1,a2,a3,a4); + } + + function jsCall_vji(index,a1,a2) { + functionPointers[index](a1,a2); + } + + var asmGlobalArg = {}; + + var asmLibraryArg = { "___wasi_fd_write": ___wasi_fd_write, "__memory_base": 1024, "__table_base": 0, "_abort": _abort, "_emscripten_asm_const_di": _emscripten_asm_const_di, "_emscripten_asm_const_i": _emscripten_asm_const_i, "_emscripten_asm_const_ii": _emscripten_asm_const_ii, "_emscripten_asm_const_iii": _emscripten_asm_const_iii, "_emscripten_asm_const_iiii": _emscripten_asm_const_iiii, "_emscripten_asm_const_iiiii": _emscripten_asm_const_iiiii, "_emscripten_get_heap_size": _emscripten_get_heap_size, "_emscripten_memcpy_big": _emscripten_memcpy_big, "_emscripten_resize_heap": _emscripten_resize_heap, "_fd_write": _fd_write, "_gettimeofday": _gettimeofday, "abort": abort, "abortOnCannotGrowMemory": abortOnCannotGrowMemory, "demangle": demangle, "demangleAll": demangleAll, "flush_NO_FILESYSTEM": flush_NO_FILESYSTEM, "getTempRet0": getTempRet0, "jsCall_ii": jsCall_ii, "jsCall_iidiiii": jsCall_iidiiii, "jsCall_iii": jsCall_iii, "jsCall_iiii": jsCall_iiii, "jsCall_jiji": jsCall_jiji, "jsCall_vi": jsCall_vi, "jsCall_vii": jsCall_vii, "jsCall_viiii": jsCall_viiii, "jsCall_vji": jsCall_vji, "jsStackTrace": jsStackTrace, "memory": wasmMemory, "setTempRet0": setTempRet0, "stackTrace": stackTrace, "table": wasmTable, "tempDoublePtr": tempDoublePtr }; + // EMSCRIPTEN_START_ASM + var asm =Module["asm"]// EMSCRIPTEN_END_ASM + (asmGlobalArg, asmLibraryArg, buffer); + + Module["asm"] = asm; + var _PICO_TIME = Module["_PICO_TIME"] = function() { + return Module["asm"]["_PICO_TIME"].apply(null, arguments) + }; + + var _PICO_TIME_MS = Module["_PICO_TIME_MS"] = function() { + return Module["asm"]["_PICO_TIME_MS"].apply(null, arguments) + }; + + var _PICO_TIME_MS_130 = Module["_PICO_TIME_MS_130"] = function() { + return Module["asm"]["_PICO_TIME_MS_130"].apply(null, arguments) + }; + + var _PICO_TIME_MS_137 = Module["_PICO_TIME_MS_137"] = function() { + return Module["asm"]["_PICO_TIME_MS_137"].apply(null, arguments) + }; + + var _PICO_TIME_MS_146 = Module["_PICO_TIME_MS_146"] = function() { + return Module["asm"]["_PICO_TIME_MS_146"].apply(null, arguments) + }; + + var _PICO_TIME_MS_231 = Module["_PICO_TIME_MS_231"] = function() { + return Module["asm"]["_PICO_TIME_MS_231"].apply(null, arguments) + }; + + var _PICO_TIME_MS_278 = Module["_PICO_TIME_MS_278"] = function() { + return Module["asm"]["_PICO_TIME_MS_278"].apply(null, arguments) + }; + + var _PICO_TIME_MS_310 = Module["_PICO_TIME_MS_310"] = function() { + return Module["asm"]["_PICO_TIME_MS_310"].apply(null, arguments) + }; + + var _PICO_TIME_MS_366 = Module["_PICO_TIME_MS_366"] = function() { + return Module["asm"]["_PICO_TIME_MS_366"].apply(null, arguments) + }; + + var _PICO_TIME_MS_376 = Module["_PICO_TIME_MS_376"] = function() { + return Module["asm"]["_PICO_TIME_MS_376"].apply(null, arguments) + }; + + var ___DOUBLE_BITS_670 = Module["___DOUBLE_BITS_670"] = function() { + return Module["asm"]["___DOUBLE_BITS_670"].apply(null, arguments) + }; + + var ___emscripten_stdout_close = Module["___emscripten_stdout_close"] = function() { + return Module["asm"]["___emscripten_stdout_close"].apply(null, arguments) + }; + + var ___emscripten_stdout_seek = Module["___emscripten_stdout_seek"] = function() { + return Module["asm"]["___emscripten_stdout_seek"].apply(null, arguments) + }; + + var ___errno_location = Module["___errno_location"] = function() { + return Module["asm"]["___errno_location"].apply(null, arguments) + }; + + var ___fwritex = Module["___fwritex"] = function() { + return Module["asm"]["___fwritex"].apply(null, arguments) + }; + + var ___lockfile = Module["___lockfile"] = function() { + return Module["asm"]["___lockfile"].apply(null, arguments) + }; + + var ___overflow = Module["___overflow"] = function() { + return Module["asm"]["___overflow"].apply(null, arguments) + }; + + var ___pthread_self_423 = Module["___pthread_self_423"] = function() { + return Module["asm"]["___pthread_self_423"].apply(null, arguments) + }; + + var ___stdio_write = Module["___stdio_write"] = function() { + return Module["asm"]["___stdio_write"].apply(null, arguments) + }; + + var ___stpncpy = Module["___stpncpy"] = function() { + return Module["asm"]["___stpncpy"].apply(null, arguments) + }; + + var ___towrite = Module["___towrite"] = function() { + return Module["asm"]["___towrite"].apply(null, arguments) + }; + + var ___unlockfile = Module["___unlockfile"] = function() { + return Module["asm"]["___unlockfile"].apply(null, arguments) + }; + + var ___vfprintf_internal = Module["___vfprintf_internal"] = function() { + return Module["asm"]["___vfprintf_internal"].apply(null, arguments) + }; + + var ___wasi_syscall_ret = Module["___wasi_syscall_ret"] = function() { + return Module["asm"]["___wasi_syscall_ret"].apply(null, arguments) + }; + + var __pico_stack_recv_zerocopy = Module["__pico_stack_recv_zerocopy"] = function() { + return Module["asm"]["__pico_stack_recv_zerocopy"].apply(null, arguments) + }; + + var _add_retransmission_timer = Module["_add_retransmission_timer"] = function() { + return Module["asm"]["_add_retransmission_timer"].apply(null, arguments) + }; + + var _aodv_dev_cmp = Module["_aodv_dev_cmp"] = function() { + return Module["asm"]["_aodv_dev_cmp"].apply(null, arguments) + }; + + var _aodv_elect_route = Module["_aodv_elect_route"] = function() { + return Module["asm"]["_aodv_elect_route"].apply(null, arguments) + }; + + var _aodv_forward = Module["_aodv_forward"] = function() { + return Module["asm"]["_aodv_forward"].apply(null, arguments) + }; + + var _aodv_lifetime = Module["_aodv_lifetime"] = function() { + return Module["asm"]["_aodv_lifetime"].apply(null, arguments) + }; + + var _aodv_make_rreq = Module["_aodv_make_rreq"] = function() { + return Module["asm"]["_aodv_make_rreq"].apply(null, arguments) + }; + + var _aodv_node_compare = Module["_aodv_node_compare"] = function() { + return Module["asm"]["_aodv_node_compare"].apply(null, arguments) + }; + + var _aodv_parse_rack = Module["_aodv_parse_rack"] = function() { + return Module["asm"]["_aodv_parse_rack"].apply(null, arguments) + }; + + var _aodv_parse_rerr = Module["_aodv_parse_rerr"] = function() { + return Module["asm"]["_aodv_parse_rerr"].apply(null, arguments) + }; + + var _aodv_parse_rrep = Module["_aodv_parse_rrep"] = function() { + return Module["asm"]["_aodv_parse_rrep"].apply(null, arguments) + }; + + var _aodv_parse_rreq = Module["_aodv_parse_rreq"] = function() { + return Module["asm"]["_aodv_parse_rreq"].apply(null, arguments) + }; + + var _aodv_peer_eval = Module["_aodv_peer_eval"] = function() { + return Module["asm"]["_aodv_peer_eval"].apply(null, arguments) + }; + + var _aodv_peer_new = Module["_aodv_peer_new"] = function() { + return Module["asm"]["_aodv_peer_new"].apply(null, arguments) + }; + + var _aodv_peer_refresh = Module["_aodv_peer_refresh"] = function() { + return Module["asm"]["_aodv_peer_refresh"].apply(null, arguments) + }; + + var _aodv_recv_valid_rreq = Module["_aodv_recv_valid_rreq"] = function() { + return Module["asm"]["_aodv_recv_valid_rreq"].apply(null, arguments) + }; + + var _aodv_retrans_rreq = Module["_aodv_retrans_rreq"] = function() { + return Module["asm"]["_aodv_retrans_rreq"].apply(null, arguments) + }; + + var _aodv_reverse_path_discover = Module["_aodv_reverse_path_discover"] = function() { + return Module["asm"]["_aodv_reverse_path_discover"].apply(null, arguments) + }; + + var _aodv_send_reply = Module["_aodv_send_reply"] = function() { + return Module["asm"]["_aodv_send_reply"].apply(null, arguments) + }; + + var _aodv_send_req = Module["_aodv_send_req"] = function() { + return Module["asm"]["_aodv_send_req"].apply(null, arguments) + }; + + var _arp_compare = Module["_arp_compare"] = function() { + return Module["asm"]["_arp_compare"].apply(null, arguments) + }; + + var _arp_expire = Module["_arp_expire"] = function() { + return Module["asm"]["_arp_expire"].apply(null, arguments) + }; + + var _calc_score = Module["_calc_score"] = function() { + return Module["asm"]["_calc_score"].apply(null, arguments) + }; + + var _calloc = Module["_calloc"] = function() { + return Module["asm"]["_calloc"].apply(null, arguments) + }; + + var _checkLocalClosing = Module["_checkLocalClosing"] = function() { + return Module["asm"]["_checkLocalClosing"].apply(null, arguments) + }; + + var _checkRemoteClosing = Module["_checkRemoteClosing"] = function() { + return Module["asm"]["_checkRemoteClosing"].apply(null, arguments) + }; + + var _check_dev_serve_interrupt = Module["_check_dev_serve_interrupt"] = function() { + return Module["asm"]["_check_dev_serve_interrupt"].apply(null, arguments) + }; + + var _check_dev_serve_polling = Module["_check_dev_serve_polling"] = function() { + return Module["asm"]["_check_dev_serve_polling"].apply(null, arguments) + }; + + var _check_socket_sanity = Module["_check_socket_sanity"] = function() { + return Module["asm"]["_check_socket_sanity"].apply(null, arguments) + }; + + var _checksum_is_ipv4 = Module["_checksum_is_ipv4"] = function() { + return Module["asm"]["_checksum_is_ipv4"].apply(null, arguments) + }; + + var _checksum_is_ipv6 = Module["_checksum_is_ipv6"] = function() { + return Module["asm"]["_checksum_is_ipv6"].apply(null, arguments) + }; + + var _cookie_compare = Module["_cookie_compare"] = function() { + return Module["asm"]["_cookie_compare"].apply(null, arguments) + }; + + var _create_dev_js = Module["_create_dev_js"] = function() { + return Module["asm"]["_create_dev_js"].apply(null, arguments) + }; + + var _create_node = Module["_create_node"] = function() { + return Module["asm"]["_create_node"].apply(null, arguments) + }; + + var _destination_is_bcast = Module["_destination_is_bcast"] = function() { + return Module["asm"]["_destination_is_bcast"].apply(null, arguments) + }; + + var _destination_is_mcast = Module["_destination_is_mcast"] = function() { + return Module["asm"]["_destination_is_mcast"].apply(null, arguments) + }; + + var _device_init_ipv6_final = Module["_device_init_ipv6_final"] = function() { + return Module["asm"]["_device_init_ipv6_final"].apply(null, arguments) + }; + + var _device_init_mac = Module["_device_init_mac"] = function() { + return Module["asm"]["_device_init_mac"].apply(null, arguments) + }; + + var _device_init_nomac = Module["_device_init_nomac"] = function() { + return Module["asm"]["_device_init_nomac"].apply(null, arguments) + }; + + var _devloop = Module["_devloop"] = function() { + return Module["asm"]["_devloop"].apply(null, arguments) + }; + + var _devloop_in = Module["_devloop_in"] = function() { + return Module["asm"]["_devloop_in"].apply(null, arguments) + }; + + var _devloop_out = Module["_devloop_out"] = function() { + return Module["asm"]["_devloop_out"].apply(null, arguments) + }; + + var _devloop_sendto_dev = Module["_devloop_sendto_dev"] = function() { + return Module["asm"]["_devloop_sendto_dev"].apply(null, arguments) + }; + + var _dhcp_action_call = Module["_dhcp_action_call"] = function() { + return Module["asm"]["_dhcp_action_call"].apply(null, arguments) + }; + + var _dhcp_cookies_cmp = Module["_dhcp_cookies_cmp"] = function() { + return Module["asm"]["_dhcp_cookies_cmp"].apply(null, arguments) + }; + + var _dhcp_get_timer_event = Module["_dhcp_get_timer_event"] = function() { + return Module["asm"]["_dhcp_get_timer_event"].apply(null, arguments) + }; + + var _dhcp_negotiation_set_ciaddr = Module["_dhcp_negotiation_set_ciaddr"] = function() { + return Module["asm"]["_dhcp_negotiation_set_ciaddr"].apply(null, arguments) + }; + + var _dhcp_negotiations_cmp = Module["_dhcp_negotiations_cmp"] = function() { + return Module["asm"]["_dhcp_negotiations_cmp"].apply(null, arguments) + }; + + var _dhcp_settings_cmp = Module["_dhcp_settings_cmp"] = function() { + return Module["asm"]["_dhcp_settings_cmp"].apply(null, arguments) + }; + + var _dhcpd_make_reply = Module["_dhcpd_make_reply"] = function() { + return Module["asm"]["_dhcpd_make_reply"].apply(null, arguments) + }; + + var _dhcps_make_reply_to_discover_or_request = Module["_dhcps_make_reply_to_discover_or_request"] = function() { + return Module["asm"]["_dhcps_make_reply_to_discover_or_request"].apply(null, arguments) + }; + + var _dhcps_make_reply_to_request_msg = Module["_dhcps_make_reply_to_request_msg"] = function() { + return Module["asm"]["_dhcps_make_reply_to_request_msg"].apply(null, arguments) + }; + + var _dhcps_parse_options_loop = Module["_dhcps_parse_options_loop"] = function() { + return Module["asm"]["_dhcps_parse_options_loop"].apply(null, arguments) + }; + + var _dhcps_set_default_lease_time_if_not_provided = Module["_dhcps_set_default_lease_time_if_not_provided"] = function() { + return Module["asm"]["_dhcps_set_default_lease_time_if_not_provided"].apply(null, arguments) + }; + + var _dhcps_set_default_pool_end_if_not_provided = Module["_dhcps_set_default_pool_end_if_not_provided"] = function() { + return Module["asm"]["_dhcps_set_default_pool_end_if_not_provided"].apply(null, arguments) + }; + + var _dhcps_set_default_pool_start_if_not_provided = Module["_dhcps_set_default_pool_start_if_not_provided"] = function() { + return Module["asm"]["_dhcps_set_default_pool_start_if_not_provided"].apply(null, arguments) + }; + + var _dhcps_try_open_socket = Module["_dhcps_try_open_socket"] = function() { + return Module["asm"]["_dhcps_try_open_socket"].apply(null, arguments) + }; + + var _discard = Module["_discard"] = function() { + return Module["asm"]["_discard"].apply(null, arguments) + }; + + var _dns_ns_cmp = Module["_dns_ns_cmp"] = function() { + return Module["asm"]["_dns_ns_cmp"].apply(null, arguments) + }; + + var _dns_ptr_ip6_nibble_hi = Module["_dns_ptr_ip6_nibble_hi"] = function() { + return Module["asm"]["_dns_ptr_ip6_nibble_hi"].apply(null, arguments) + }; + + var _dns_ptr_ip6_nibble_lo = Module["_dns_ptr_ip6_nibble_lo"] = function() { + return Module["asm"]["_dns_ptr_ip6_nibble_lo"].apply(null, arguments) + }; + + var _dns_query_cmp = Module["_dns_query_cmp"] = function() { + return Module["asm"]["_dns_query_cmp"].apply(null, arguments) + }; + + var _do_enqueue_segment = Module["_do_enqueue_segment"] = function() { + return Module["asm"]["_do_enqueue_segment"].apply(null, arguments) + }; + + var _emscripten_get_sbrk_ptr = Module["_emscripten_get_sbrk_ptr"] = function() { + return Module["asm"]["_emscripten_get_sbrk_ptr"].apply(null, arguments) + }; + + var _enqueue_segment_len = Module["_enqueue_segment_len"] = function() { + return Module["asm"]["_enqueue_segment_len"].apply(null, arguments) + }; + + var _eth_check_headroom = Module["_eth_check_headroom"] = function() { + return Module["asm"]["_eth_check_headroom"].apply(null, arguments) + }; + + var _filter_compare = Module["_filter_compare"] = function() { + return Module["asm"]["_filter_compare"].apply(null, arguments) + }; + + var _filter_compare_address_port = Module["_filter_compare_address_port"] = function() { + return Module["asm"]["_filter_compare_address_port"].apply(null, arguments) + }; + + var _filter_compare_addresses = Module["_filter_compare_addresses"] = function() { + return Module["asm"]["_filter_compare_addresses"].apply(null, arguments) + }; + + var _filter_compare_ports = Module["_filter_compare_ports"] = function() { + return Module["asm"]["_filter_compare_ports"].apply(null, arguments) + }; + + var _filter_compare_proto = Module["_filter_compare_proto"] = function() { + return Module["asm"]["_filter_compare_proto"].apply(null, arguments) + }; + + var _filter_match_packet = Module["_filter_match_packet"] = function() { + return Module["asm"]["_filter_match_packet"].apply(null, arguments) + }; + + var _filter_match_packet_addr = Module["_filter_match_packet_addr"] = function() { + return Module["asm"]["_filter_match_packet_addr"].apply(null, arguments) + }; + + var _filter_match_packet_addr_in = Module["_filter_match_packet_addr_in"] = function() { + return Module["asm"]["_filter_match_packet_addr_in"].apply(null, arguments) + }; + + var _filter_match_packet_addr_out = Module["_filter_match_packet_addr_out"] = function() { + return Module["asm"]["_filter_match_packet_addr_out"].apply(null, arguments) + }; + + var _filter_match_packet_dev = Module["_filter_match_packet_dev"] = function() { + return Module["asm"]["_filter_match_packet_dev"].apply(null, arguments) + }; + + var _filter_match_packet_dev_and_proto = Module["_filter_match_packet_dev_and_proto"] = function() { + return Module["asm"]["_filter_match_packet_dev_and_proto"].apply(null, arguments) + }; + + var _filter_match_packet_find_rule = Module["_filter_match_packet_find_rule"] = function() { + return Module["asm"]["_filter_match_packet_find_rule"].apply(null, arguments) + }; + + var _filter_match_packet_port = Module["_filter_match_packet_port"] = function() { + return Module["asm"]["_filter_match_packet_port"].apply(null, arguments) + }; + + var _filter_match_packet_port_in = Module["_filter_match_packet_port_in"] = function() { + return Module["asm"]["_filter_match_packet_port_in"].apply(null, arguments) + }; + + var _filter_match_packet_port_out = Module["_filter_match_packet_port_out"] = function() { + return Module["asm"]["_filter_match_packet_port_out"].apply(null, arguments) + }; + + var _filter_match_packet_proto = Module["_filter_match_packet_proto"] = function() { + return Module["asm"]["_filter_match_packet_proto"].apply(null, arguments) + }; + + var _first_segment = Module["_first_segment"] = function() { + return Module["asm"]["_first_segment"].apply(null, arguments) + }; + + var _fix_delete_collisions = Module["_fix_delete_collisions"] = function() { + return Module["asm"]["_fix_delete_collisions"].apply(null, arguments) + }; + + var _fix_insert_collisions = Module["_fix_insert_collisions"] = function() { + return Module["asm"]["_fix_insert_collisions"].apply(null, arguments) + }; + + var _fmt_fp = Module["_fmt_fp"] = function() { + return Module["asm"]["_fmt_fp"].apply(null, arguments) + }; + + var _fmt_o = Module["_fmt_o"] = function() { + return Module["asm"]["_fmt_o"].apply(null, arguments) + }; + + var _fmt_u = Module["_fmt_u"] = function() { + return Module["asm"]["_fmt_u"].apply(null, arguments) + }; + + var _fmt_x = Module["_fmt_x"] = function() { + return Module["asm"]["_fmt_x"].apply(null, arguments) + }; + + var _fputs = Module["_fputs"] = function() { + return Module["asm"]["_fputs"].apply(null, arguments) + }; + + var _free = Module["_free"] = function() { + return Module["asm"]["_free"].apply(null, arguments) + }; + + var _frexp = Module["_frexp"] = function() { + return Module["asm"]["_frexp"].apply(null, arguments) + }; + + var _fwrite = Module["_fwrite"] = function() { + return Module["asm"]["_fwrite"].apply(null, arguments) + }; + + var _get_node_by_addr = Module["_get_node_by_addr"] = function() { + return Module["asm"]["_get_node_by_addr"].apply(null, arguments) + }; + + var _get_sock_dev = Module["_get_sock_dev"] = function() { + return Module["asm"]["_get_sock_dev"].apply(null, arguments) + }; + + var _getint = Module["_getint"] = function() { + return Module["asm"]["_getint"].apply(null, arguments) + }; + + var _heap_first = Module["_heap_first"] = function() { + return Module["asm"]["_heap_first"].apply(null, arguments) + }; + + var _heap_get_element = Module["_heap_get_element"] = function() { + return Module["asm"]["_heap_get_element"].apply(null, arguments) + }; + + var _heap_increase_size = Module["_heap_increase_size"] = function() { + return Module["asm"]["_heap_increase_size"].apply(null, arguments) + }; + + var _heap_init = Module["_heap_init"] = function() { + return Module["asm"]["_heap_init"].apply(null, arguments) + }; + + var _heap_insert = Module["_heap_insert"] = function() { + return Module["asm"]["_heap_insert"].apply(null, arguments) + }; + + var _heap_peek = Module["_heap_peek"] = function() { + return Module["asm"]["_heap_peek"].apply(null, arguments) + }; + + var _icmp6_cookie_compare = Module["_icmp6_cookie_compare"] = function() { + return Module["asm"]["_icmp6_cookie_compare"].apply(null, arguments) + }; + + var _icmp6_initial_checks = Module["_icmp6_initial_checks"] = function() { + return Module["asm"]["_icmp6_initial_checks"].apply(null, arguments) + }; + + var _if_nodecolor_black_fix_collisions = Module["_if_nodecolor_black_fix_collisions"] = function() { + return Module["asm"]["_if_nodecolor_black_fix_collisions"].apply(null, arguments) + }; + + var _igmp_parameters_cmp = Module["_igmp_parameters_cmp"] = function() { + return Module["asm"]["_igmp_parameters_cmp"].apply(null, arguments) + }; + + var _igmp_sources_cmp = Module["_igmp_sources_cmp"] = function() { + return Module["asm"]["_igmp_sources_cmp"].apply(null, arguments) + }; + + var _igmp_timer_cmp = Module["_igmp_timer_cmp"] = function() { + return Module["asm"]["_igmp_timer_cmp"].apply(null, arguments) + }; + + var _igmpparm_group_compare = Module["_igmpparm_group_compare"] = function() { + return Module["asm"]["_igmpparm_group_compare"].apply(null, arguments) + }; + + var _igmpparm_link_compare = Module["_igmpparm_link_compare"] = function() { + return Module["asm"]["_igmpparm_link_compare"].apply(null, arguments) + }; + + var _igmpt_group_compare = Module["_igmpt_group_compare"] = function() { + return Module["asm"]["_igmpt_group_compare"].apply(null, arguments) + }; + + var _igmpt_link_compare = Module["_igmpt_link_compare"] = function() { + return Module["asm"]["_igmpt_link_compare"].apply(null, arguments) + }; + + var _igmpt_type_compare = Module["_igmpt_type_compare"] = function() { + return Module["asm"]["_igmpt_type_compare"].apply(null, arguments) + }; + + var _initconn_retry = Module["_initconn_retry"] = function() { + return Module["asm"]["_initconn_retry"].apply(null, arguments) + }; + + var _input_segment_compare = Module["_input_segment_compare"] = function() { + return Module["asm"]["_input_segment_compare"].apply(null, arguments) + }; + + var _invalid_flags = Module["_invalid_flags"] = function() { + return Module["asm"]["_invalid_flags"].apply(null, arguments) + }; + + var _ip_address_is_in_dhcp_range = Module["_ip_address_is_in_dhcp_range"] = function() { + return Module["asm"]["_ip_address_is_in_dhcp_range"].apply(null, arguments) + }; + + var _ipfilter = Module["_ipfilter"] = function() { + return Module["asm"]["_ipfilter"].apply(null, arguments) + }; + + var _ipfilter_apply_filter = Module["_ipfilter_apply_filter"] = function() { + return Module["asm"]["_ipfilter_apply_filter"].apply(null, arguments) + }; + + var _ipfilter_ptr_cmp = Module["_ipfilter_ptr_cmp"] = function() { + return Module["asm"]["_ipfilter_ptr_cmp"].apply(null, arguments) + }; + + var _ipfilter_uint16_cmp = Module["_ipfilter_uint16_cmp"] = function() { + return Module["asm"]["_ipfilter_uint16_cmp"].apply(null, arguments) + }; + + var _ipfilter_uint32_cmp = Module["_ipfilter_uint32_cmp"] = function() { + return Module["asm"]["_ipfilter_uint32_cmp"].apply(null, arguments) + }; + + var _ipfilter_uint8_cmp = Module["_ipfilter_uint8_cmp"] = function() { + return Module["asm"]["_ipfilter_uint8_cmp"].apply(null, arguments) + }; + + var _ipv4_link_compare = Module["_ipv4_link_compare"] = function() { + return Module["asm"]["_ipv4_link_compare"].apply(null, arguments) + }; + + var _ipv4_mcast_groups_cmp = Module["_ipv4_mcast_groups_cmp"] = function() { + return Module["asm"]["_ipv4_mcast_groups_cmp"].apply(null, arguments) + }; + + var _ipv4_mcast_sources_cmp = Module["_ipv4_mcast_sources_cmp"] = function() { + return Module["asm"]["_ipv4_mcast_sources_cmp"].apply(null, arguments) + }; + + var _ipv4_route_compare = Module["_ipv4_route_compare"] = function() { + return Module["asm"]["_ipv4_route_compare"].apply(null, arguments) + }; + + var _ipv6_compare_metric = Module["_ipv6_compare_metric"] = function() { + return Module["asm"]["_ipv6_compare_metric"].apply(null, arguments) + }; + + var _ipv6_duplicate_detected = Module["_ipv6_duplicate_detected"] = function() { + return Module["asm"]["_ipv6_duplicate_detected"].apply(null, arguments) + }; + + var _ipv6_frame_push_final = Module["_ipv6_frame_push_final"] = function() { + return Module["asm"]["_ipv6_frame_push_final"].apply(null, arguments) + }; + + var _ipv6_link_compare = Module["_ipv6_link_compare"] = function() { + return Module["asm"]["_ipv6_link_compare"].apply(null, arguments) + }; + + var _ipv6_mcast_groups_cmp = Module["_ipv6_mcast_groups_cmp"] = function() { + return Module["asm"]["_ipv6_mcast_groups_cmp"].apply(null, arguments) + }; + + var _ipv6_mcast_sources_cmp = Module["_ipv6_mcast_sources_cmp"] = function() { + return Module["asm"]["_ipv6_mcast_sources_cmp"].apply(null, arguments) + }; + + var _ipv6_push_hdr_adjust = Module["_ipv6_push_hdr_adjust"] = function() { + return Module["asm"]["_ipv6_push_hdr_adjust"].apply(null, arguments) + }; + + var _ipv6_pushed_frame_checks = Module["_ipv6_pushed_frame_checks"] = function() { + return Module["asm"]["_ipv6_pushed_frame_checks"].apply(null, arguments) + }; + + var _ipv6_pushed_frame_valid = Module["_ipv6_pushed_frame_valid"] = function() { + return Module["asm"]["_ipv6_pushed_frame_valid"].apply(null, arguments) + }; + + var _ipv6_route_add_link = Module["_ipv6_route_add_link"] = function() { + return Module["asm"]["_ipv6_route_add_link"].apply(null, arguments) + }; + + var _ipv6_route_compare = Module["_ipv6_route_compare"] = function() { + return Module["asm"]["_ipv6_route_compare"].apply(null, arguments) + }; + + var _isdigit = Module["_isdigit"] = function() { + return Module["asm"]["_isdigit"].apply(null, arguments) + }; + + var _isupper = Module["_isupper"] = function() { + return Module["asm"]["_isupper"].apply(null, arguments) + }; + + var _js_accept_nameserver = Module["_js_accept_nameserver"] = function() { + return Module["asm"]["_js_accept_nameserver"].apply(null, arguments) + }; + + var _js_add_ipv4 = Module["_js_add_ipv4"] = function() { + return Module["asm"]["_js_add_ipv4"].apply(null, arguments) + }; + + var _js_pico_err = Module["_js_pico_err"] = function() { + return Module["asm"]["_js_pico_err"].apply(null, arguments) + }; + + var _js_socket_bind = Module["_js_socket_bind"] = function() { + return Module["asm"]["_js_socket_bind"].apply(null, arguments) + }; + + var _js_socket_connect = Module["_js_socket_connect"] = function() { + return Module["asm"]["_js_socket_connect"].apply(null, arguments) + }; + + var _js_socket_open = Module["_js_socket_open"] = function() { + return Module["asm"]["_js_socket_open"].apply(null, arguments) + }; + + var _js_wakeup = Module["_js_wakeup"] = function() { + return Module["asm"]["_js_wakeup"].apply(null, arguments) + }; + + var _listen_find = Module["_listen_find"] = function() { + return Module["asm"]["_listen_find"].apply(null, arguments) + }; + + var _llvm_bswap_i16 = Module["_llvm_bswap_i16"] = function() { + return Module["asm"]["_llvm_bswap_i16"].apply(null, arguments) + }; + + var _llvm_bswap_i32 = Module["_llvm_bswap_i32"] = function() { + return Module["asm"]["_llvm_bswap_i32"].apply(null, arguments) + }; + + var _long_be = Module["_long_be"] = function() { + return Module["asm"]["_long_be"].apply(null, arguments) + }; + + var _long_be_133 = Module["_long_be_133"] = function() { + return Module["asm"]["_long_be_133"].apply(null, arguments) + }; + + var _long_be_147 = Module["_long_be_147"] = function() { + return Module["asm"]["_long_be_147"].apply(null, arguments) + }; + + var _long_be_162 = Module["_long_be_162"] = function() { + return Module["asm"]["_long_be_162"].apply(null, arguments) + }; + + var _long_be_311 = Module["_long_be_311"] = function() { + return Module["asm"]["_long_be_311"].apply(null, arguments) + }; + + var _long_be_329 = Module["_long_be_329"] = function() { + return Module["asm"]["_long_be_329"].apply(null, arguments) + }; + + var _long_be_340 = Module["_long_be_340"] = function() { + return Module["asm"]["_long_be_340"].apply(null, arguments) + }; + + var _long_be_368 = Module["_long_be_368"] = function() { + return Module["asm"]["_long_be_368"].apply(null, arguments) + }; + + var _long_be_37 = Module["_long_be_37"] = function() { + return Module["asm"]["_long_be_37"].apply(null, arguments) + }; + + var _long_be_381 = Module["_long_be_381"] = function() { + return Module["asm"]["_long_be_381"].apply(null, arguments) + }; + + var _long_be_39 = Module["_long_be_39"] = function() { + return Module["asm"]["_long_be_39"].apply(null, arguments) + }; + + var _long_be_69 = Module["_long_be_69"] = function() { + return Module["asm"]["_long_be_69"].apply(null, arguments) + }; + + var _long_from = Module["_long_from"] = function() { + return Module["asm"]["_long_from"].apply(null, arguments) + }; + + var _long_from_152 = Module["_long_from_152"] = function() { + return Module["asm"]["_long_from_152"].apply(null, arguments) + }; + + var _long_from_89 = Module["_long_from_89"] = function() { + return Module["asm"]["_long_from_89"].apply(null, arguments) + }; + + var _main = Module["_main"] = function() { + return Module["asm"]["_main"].apply(null, arguments) + }; + + var _malloc = Module["_malloc"] = function() { + return Module["asm"]["_malloc"].apply(null, arguments) + }; + + var _mcast_aggr_validate = Module["_mcast_aggr_validate"] = function() { + return Module["asm"]["_mcast_aggr_validate"].apply(null, arguments) + }; + + var _mcast_filter_cmp = Module["_mcast_filter_cmp"] = function() { + return Module["asm"]["_mcast_filter_cmp"].apply(null, arguments) + }; + + var _mcast_filter_cmp_ipv6 = Module["_mcast_filter_cmp_ipv6"] = function() { + return Module["asm"]["_mcast_filter_cmp_ipv6"].apply(null, arguments) + }; + + var _mcast_get_listen_tree = Module["_mcast_get_listen_tree"] = function() { + return Module["asm"]["_mcast_get_listen_tree"].apply(null, arguments) + }; + + var _mcast_get_src_tree = Module["_mcast_get_src_tree"] = function() { + return Module["asm"]["_mcast_get_src_tree"].apply(null, arguments) + }; + + var _mcast_group_update = Module["_mcast_group_update"] = function() { + return Module["asm"]["_mcast_group_update"].apply(null, arguments) + }; + + var _mcast_group_update_ipv6 = Module["_mcast_group_update_ipv6"] = function() { + return Module["asm"]["_mcast_group_update_ipv6"].apply(null, arguments) + }; + + var _mcast_parameters_cmp = Module["_mcast_parameters_cmp"] = function() { + return Module["asm"]["_mcast_parameters_cmp"].apply(null, arguments) + }; + + var _mcast_set_listen_tree_p_null = Module["_mcast_set_listen_tree_p_null"] = function() { + return Module["asm"]["_mcast_set_listen_tree_p_null"].apply(null, arguments) + }; + + var _mcast_socket_cmp = Module["_mcast_socket_cmp"] = function() { + return Module["asm"]["_mcast_socket_cmp"].apply(null, arguments) + }; + + var _mcast_sources_cmp = Module["_mcast_sources_cmp"] = function() { + return Module["asm"]["_mcast_sources_cmp"].apply(null, arguments) + }; + + var _mcast_sources_cmp_ipv6 = Module["_mcast_sources_cmp_ipv6"] = function() { + return Module["asm"]["_mcast_sources_cmp_ipv6"].apply(null, arguments) + }; + + var _memchr = Module["_memchr"] = function() { + return Module["asm"]["_memchr"].apply(null, arguments) + }; + + var _memcmp = Module["_memcmp"] = function() { + return Module["asm"]["_memcmp"].apply(null, arguments) + }; + + var _memcpy = Module["_memcpy"] = function() { + return Module["asm"]["_memcpy"].apply(null, arguments) + }; + + var _memset = Module["_memset"] = function() { + return Module["asm"]["_memset"].apply(null, arguments) + }; + + var _mld_discard = Module["_mld_discard"] = function() { + return Module["asm"]["_mld_discard"].apply(null, arguments) + }; + + var _mld_mrsrrt = Module["_mld_mrsrrt"] = function() { + return Module["asm"]["_mld_mrsrrt"].apply(null, arguments) + }; + + var _mld_rtimrtct = Module["_mld_rtimrtct"] = function() { + return Module["asm"]["_mld_rtimrtct"].apply(null, arguments) + }; + + var _mld_sources_cmp = Module["_mld_sources_cmp"] = function() { + return Module["asm"]["_mld_sources_cmp"].apply(null, arguments) + }; + + var _mld_srsf = Module["_mld_srsf"] = function() { + return Module["asm"]["_mld_srsf"].apply(null, arguments) + }; + + var _mld_srsfst = Module["_mld_srsfst"] = function() { + return Module["asm"]["_mld_srsfst"].apply(null, arguments) + }; + + var _mld_srst = Module["_mld_srst"] = function() { + return Module["asm"]["_mld_srst"].apply(null, arguments) + }; + + var _mld_stcl = Module["_mld_stcl"] = function() { + return Module["asm"]["_mld_stcl"].apply(null, arguments) + }; + + var _mld_stsdifs = Module["_mld_stsdifs"] = function() { + return Module["asm"]["_mld_stsdifs"].apply(null, arguments) + }; + + var _mld_timer_cmp = Module["_mld_timer_cmp"] = function() { + return Module["asm"]["_mld_timer_cmp"].apply(null, arguments) + }; + + var _mldparm_group_compare = Module["_mldparm_group_compare"] = function() { + return Module["asm"]["_mldparm_group_compare"].apply(null, arguments) + }; + + var _mldparm_link_compare = Module["_mldparm_link_compare"] = function() { + return Module["asm"]["_mldparm_link_compare"].apply(null, arguments) + }; + + var _mldt_group_compare = Module["_mldt_group_compare"] = function() { + return Module["asm"]["_mldt_group_compare"].apply(null, arguments) + }; + + var _mldt_link_compare = Module["_mldt_link_compare"] = function() { + return Module["asm"]["_mldt_link_compare"].apply(null, arguments) + }; + + var _mldt_type_compare = Module["_mldt_type_compare"] = function() { + return Module["asm"]["_mldt_type_compare"].apply(null, arguments) + }; + + var _mrsrrt = Module["_mrsrrt"] = function() { + return Module["asm"]["_mrsrrt"].apply(null, arguments) + }; + + var _nat_cmp_address = Module["_nat_cmp_address"] = function() { + return Module["asm"]["_nat_cmp_address"].apply(null, arguments) + }; + + var _nat_cmp_inbound = Module["_nat_cmp_inbound"] = function() { + return Module["asm"]["_nat_cmp_inbound"].apply(null, arguments) + }; + + var _nat_cmp_natport = Module["_nat_cmp_natport"] = function() { + return Module["asm"]["_nat_cmp_natport"].apply(null, arguments) + }; + + var _nat_cmp_outbound = Module["_nat_cmp_outbound"] = function() { + return Module["asm"]["_nat_cmp_outbound"].apply(null, arguments) + }; + + var _nat_cmp_proto = Module["_nat_cmp_proto"] = function() { + return Module["asm"]["_nat_cmp_proto"].apply(null, arguments) + }; + + var _nat_cmp_srcport = Module["_nat_cmp_srcport"] = function() { + return Module["asm"]["_nat_cmp_srcport"].apply(null, arguments) + }; + + var _nd_options = Module["_nd_options"] = function() { + return Module["asm"]["_nd_options"].apply(null, arguments) + }; + + var _neigh_adv_checks = Module["_neigh_adv_checks"] = function() { + return Module["asm"]["_neigh_adv_checks"].apply(null, arguments) + }; + + var _neigh_adv_mcast_validity_check = Module["_neigh_adv_mcast_validity_check"] = function() { + return Module["asm"]["_neigh_adv_mcast_validity_check"].apply(null, arguments) + }; + + var _neigh_adv_option_len_validity_check = Module["_neigh_adv_option_len_validity_check"] = function() { + return Module["asm"]["_neigh_adv_option_len_validity_check"].apply(null, arguments) + }; + + var _neigh_adv_process = Module["_neigh_adv_process"] = function() { + return Module["asm"]["_neigh_adv_process"].apply(null, arguments) + }; + + var _neigh_adv_process_incomplete = Module["_neigh_adv_process_incomplete"] = function() { + return Module["asm"]["_neigh_adv_process_incomplete"].apply(null, arguments) + }; + + var _neigh_adv_reconfirm = Module["_neigh_adv_reconfirm"] = function() { + return Module["asm"]["_neigh_adv_reconfirm"].apply(null, arguments) + }; + + var _neigh_adv_reconfirm_no_tlla = Module["_neigh_adv_reconfirm_no_tlla"] = function() { + return Module["asm"]["_neigh_adv_reconfirm_no_tlla"].apply(null, arguments) + }; + + var _neigh_adv_reconfirm_router_option = Module["_neigh_adv_reconfirm_router_option"] = function() { + return Module["asm"]["_neigh_adv_reconfirm_router_option"].apply(null, arguments) + }; + + var _neigh_adv_validity_checks = Module["_neigh_adv_validity_checks"] = function() { + return Module["asm"]["_neigh_adv_validity_checks"].apply(null, arguments) + }; + + var _neigh_options = Module["_neigh_options"] = function() { + return Module["asm"]["_neigh_options"].apply(null, arguments) + }; + + var _neigh_sol_detect_dad = Module["_neigh_sol_detect_dad"] = function() { + return Module["asm"]["_neigh_sol_detect_dad"].apply(null, arguments) + }; + + var _neigh_sol_mcast_validity_check = Module["_neigh_sol_mcast_validity_check"] = function() { + return Module["asm"]["_neigh_sol_mcast_validity_check"].apply(null, arguments) + }; + + var _neigh_sol_process = Module["_neigh_sol_process"] = function() { + return Module["asm"]["_neigh_sol_process"].apply(null, arguments) + }; + + var _neigh_sol_unicast_validity_check = Module["_neigh_sol_unicast_validity_check"] = function() { + return Module["asm"]["_neigh_sol_unicast_validity_check"].apply(null, arguments) + }; + + var _neigh_sol_validate_unspec = Module["_neigh_sol_validate_unspec"] = function() { + return Module["asm"]["_neigh_sol_validate_unspec"].apply(null, arguments) + }; + + var _neigh_sol_validity_checks = Module["_neigh_sol_validity_checks"] = function() { + return Module["asm"]["_neigh_sol_validity_checks"].apply(null, arguments) + }; + + var _next_ping = Module["_next_ping"] = function() { + return Module["asm"]["_next_ping"].apply(null, arguments) + }; + + var _next_segment = Module["_next_segment"] = function() { + return Module["asm"]["_next_segment"].apply(null, arguments) + }; + + var _out_8 = Module["_out_8"] = function() { + return Module["asm"]["_out_8"].apply(null, arguments) + }; + + var _pad_667 = Module["_pad_667"] = function() { + return Module["asm"]["_pad_667"].apply(null, arguments) + }; + + var _parse_opt_msgtype = Module["_parse_opt_msgtype"] = function() { + return Module["asm"]["_parse_opt_msgtype"].apply(null, arguments) + }; + + var _parse_opt_reqip = Module["_parse_opt_reqip"] = function() { + return Module["asm"]["_parse_opt_reqip"].apply(null, arguments) + }; + + var _parse_opt_serverid = Module["_parse_opt_serverid"] = function() { + return Module["asm"]["_parse_opt_serverid"].apply(null, arguments) + }; + + var _peek_segment = Module["_peek_segment"] = function() { + return Module["asm"]["_peek_segment"].apply(null, arguments) + }; + + var _pico_aodv_collector = Module["_pico_aodv_collector"] = function() { + return Module["asm"]["_pico_aodv_collector"].apply(null, arguments) + }; + + var _pico_aodv_expired = Module["_pico_aodv_expired"] = function() { + return Module["asm"]["_pico_aodv_expired"].apply(null, arguments) + }; + + var _pico_aodv_init = Module["_pico_aodv_init"] = function() { + return Module["asm"]["_pico_aodv_init"].apply(null, arguments) + }; + + var _pico_aodv_lookup = Module["_pico_aodv_lookup"] = function() { + return Module["asm"]["_pico_aodv_lookup"].apply(null, arguments) + }; + + var _pico_aodv_parse = Module["_pico_aodv_parse"] = function() { + return Module["asm"]["_pico_aodv_parse"].apply(null, arguments) + }; + + var _pico_aodv_refresh = Module["_pico_aodv_refresh"] = function() { + return Module["asm"]["_pico_aodv_refresh"].apply(null, arguments) + }; + + var _pico_aodv_set_dev = Module["_pico_aodv_set_dev"] = function() { + return Module["asm"]["_pico_aodv_set_dev"].apply(null, arguments) + }; + + var _pico_aodv_socket_callback = Module["_pico_aodv_socket_callback"] = function() { + return Module["asm"]["_pico_aodv_socket_callback"].apply(null, arguments) + }; + + var _pico_arp_add_entry = Module["_pico_arp_add_entry"] = function() { + return Module["asm"]["_pico_arp_add_entry"].apply(null, arguments) + }; + + var _pico_arp_check_conflict = Module["_pico_arp_check_conflict"] = function() { + return Module["asm"]["_pico_arp_check_conflict"].apply(null, arguments) + }; + + var _pico_arp_check_flooding = Module["_pico_arp_check_flooding"] = function() { + return Module["asm"]["_pico_arp_check_flooding"].apply(null, arguments) + }; + + var _pico_arp_check_incoming_hdr = Module["_pico_arp_check_incoming_hdr"] = function() { + return Module["asm"]["_pico_arp_check_incoming_hdr"].apply(null, arguments) + }; + + var _pico_arp_check_incoming_hdr_type = Module["_pico_arp_check_incoming_hdr_type"] = function() { + return Module["asm"]["_pico_arp_check_incoming_hdr_type"].apply(null, arguments) + }; + + var _pico_arp_create_entry = Module["_pico_arp_create_entry"] = function() { + return Module["asm"]["_pico_arp_create_entry"].apply(null, arguments) + }; + + var _pico_arp_get = Module["_pico_arp_get"] = function() { + return Module["asm"]["_pico_arp_get"].apply(null, arguments) + }; + + var _pico_arp_init = Module["_pico_arp_init"] = function() { + return Module["asm"]["_pico_arp_init"].apply(null, arguments) + }; + + var _pico_arp_lookup = Module["_pico_arp_lookup"] = function() { + return Module["asm"]["_pico_arp_lookup"].apply(null, arguments) + }; + + var _pico_arp_lookup_entry = Module["_pico_arp_lookup_entry"] = function() { + return Module["asm"]["_pico_arp_lookup_entry"].apply(null, arguments) + }; + + var _pico_arp_postpone = Module["_pico_arp_postpone"] = function() { + return Module["asm"]["_pico_arp_postpone"].apply(null, arguments) + }; + + var _pico_arp_process_in = Module["_pico_arp_process_in"] = function() { + return Module["asm"]["_pico_arp_process_in"].apply(null, arguments) + }; + + var _pico_arp_queued_trigger = Module["_pico_arp_queued_trigger"] = function() { + return Module["asm"]["_pico_arp_queued_trigger"].apply(null, arguments) + }; + + var _pico_arp_receive = Module["_pico_arp_receive"] = function() { + return Module["asm"]["_pico_arp_receive"].apply(null, arguments) + }; + + var _pico_arp_reply_on_request = Module["_pico_arp_reply_on_request"] = function() { + return Module["asm"]["_pico_arp_reply_on_request"].apply(null, arguments) + }; + + var _pico_arp_request = Module["_pico_arp_request"] = function() { + return Module["asm"]["_pico_arp_request"].apply(null, arguments) + }; + + var _pico_arp_request_xmit = Module["_pico_arp_request_xmit"] = function() { + return Module["asm"]["_pico_arp_request_xmit"].apply(null, arguments) + }; + + var _pico_arp_retry = Module["_pico_arp_retry"] = function() { + return Module["asm"]["_pico_arp_retry"].apply(null, arguments) + }; + + var _pico_arp_reverse_lookup = Module["_pico_arp_reverse_lookup"] = function() { + return Module["asm"]["_pico_arp_reverse_lookup"].apply(null, arguments) + }; + + var _pico_arp_unreachable = Module["_pico_arp_unreachable"] = function() { + return Module["asm"]["_pico_arp_unreachable"].apply(null, arguments) + }; + + var _pico_check_socket = Module["_pico_check_socket"] = function() { + return Module["asm"]["_pico_check_socket"].apply(null, arguments) + }; + + var _pico_check_timers = Module["_pico_check_timers"] = function() { + return Module["asm"]["_pico_check_timers"].apply(null, arguments) + }; + + var _pico_checksum = Module["_pico_checksum"] = function() { + return Module["asm"]["_pico_checksum"].apply(null, arguments) + }; + + var _pico_checksum_adder = Module["_pico_checksum_adder"] = function() { + return Module["asm"]["_pico_checksum_adder"].apply(null, arguments) + }; + + var _pico_checksum_finalize = Module["_pico_checksum_finalize"] = function() { + return Module["asm"]["_pico_checksum_finalize"].apply(null, arguments) + }; + + var _pico_datalink_receive = Module["_pico_datalink_receive"] = function() { + return Module["asm"]["_pico_datalink_receive"].apply(null, arguments) + }; + + var _pico_datalink_send = Module["_pico_datalink_send"] = function() { + return Module["asm"]["_pico_datalink_send"].apply(null, arguments) + }; + + var _pico_dequeue = Module["_pico_dequeue"] = function() { + return Module["asm"]["_pico_dequeue"].apply(null, arguments) + }; + + var _pico_dequeue_166 = Module["_pico_dequeue_166"] = function() { + return Module["asm"]["_pico_dequeue_166"].apply(null, arguments) + }; + + var _pico_dequeue_190 = Module["_pico_dequeue_190"] = function() { + return Module["asm"]["_pico_dequeue_190"].apply(null, arguments) + }; + + var _pico_dequeue_422 = Module["_pico_dequeue_422"] = function() { + return Module["asm"]["_pico_dequeue_422"].apply(null, arguments) + }; + + var _pico_dev_cmp = Module["_pico_dev_cmp"] = function() { + return Module["asm"]["_pico_dev_cmp"].apply(null, arguments) + }; + + var _pico_dev_roundrobin_end = Module["_pico_dev_roundrobin_end"] = function() { + return Module["asm"]["_pico_dev_roundrobin_end"].apply(null, arguments) + }; + + var _pico_dev_roundrobin_start = Module["_pico_dev_roundrobin_start"] = function() { + return Module["asm"]["_pico_dev_roundrobin_start"].apply(null, arguments) + }; + + var _pico_device_broadcast = Module["_pico_device_broadcast"] = function() { + return Module["asm"]["_pico_device_broadcast"].apply(null, arguments) + }; + + var _pico_device_init = Module["_pico_device_init"] = function() { + return Module["asm"]["_pico_device_init"].apply(null, arguments) + }; + + var _pico_device_ipv6_random_ll = Module["_pico_device_ipv6_random_ll"] = function() { + return Module["asm"]["_pico_device_ipv6_random_ll"].apply(null, arguments) + }; + + var _pico_device_link_state = Module["_pico_device_link_state"] = function() { + return Module["asm"]["_pico_device_link_state"].apply(null, arguments) + }; + + var _pico_devices_loop = Module["_pico_devices_loop"] = function() { + return Module["asm"]["_pico_devices_loop"].apply(null, arguments) + }; + + var _pico_dhcp_are_options_valid = Module["_pico_dhcp_are_options_valid"] = function() { + return Module["asm"]["_pico_dhcp_are_options_valid"].apply(null, arguments) + }; + + var _pico_dhcp_client_add_cookie = Module["_pico_dhcp_client_add_cookie"] = function() { + return Module["asm"]["_pico_dhcp_client_add_cookie"].apply(null, arguments) + }; + + var _pico_dhcp_client_callback = Module["_pico_dhcp_client_callback"] = function() { + return Module["asm"]["_pico_dhcp_client_callback"].apply(null, arguments) + }; + + var _pico_dhcp_client_del_cookie = Module["_pico_dhcp_client_del_cookie"] = function() { + return Module["asm"]["_pico_dhcp_client_del_cookie"].apply(null, arguments) + }; + + var _pico_dhcp_client_find_cookie = Module["_pico_dhcp_client_find_cookie"] = function() { + return Module["asm"]["_pico_dhcp_client_find_cookie"].apply(null, arguments) + }; + + var _pico_dhcp_client_init = Module["_pico_dhcp_client_init"] = function() { + return Module["asm"]["_pico_dhcp_client_init"].apply(null, arguments) + }; + + var _pico_dhcp_client_msg = Module["_pico_dhcp_client_msg"] = function() { + return Module["asm"]["_pico_dhcp_client_msg"].apply(null, arguments) + }; + + var _pico_dhcp_client_opt_parse = Module["_pico_dhcp_client_opt_parse"] = function() { + return Module["asm"]["_pico_dhcp_client_opt_parse"].apply(null, arguments) + }; + + var _pico_dhcp_client_recv_params = Module["_pico_dhcp_client_recv_params"] = function() { + return Module["asm"]["_pico_dhcp_client_recv_params"].apply(null, arguments) + }; + + var _pico_dhcp_client_reinit = Module["_pico_dhcp_client_reinit"] = function() { + return Module["asm"]["_pico_dhcp_client_reinit"].apply(null, arguments) + }; + + var _pico_dhcp_client_start_init_timer = Module["_pico_dhcp_client_start_init_timer"] = function() { + return Module["asm"]["_pico_dhcp_client_start_init_timer"].apply(null, arguments) + }; + + var _pico_dhcp_client_start_reacquisition_timers = Module["_pico_dhcp_client_start_reacquisition_timers"] = function() { + return Module["asm"]["_pico_dhcp_client_start_reacquisition_timers"].apply(null, arguments) + }; + + var _pico_dhcp_client_start_rebinding_timer = Module["_pico_dhcp_client_start_rebinding_timer"] = function() { + return Module["asm"]["_pico_dhcp_client_start_rebinding_timer"].apply(null, arguments) + }; + + var _pico_dhcp_client_start_renewing_timer = Module["_pico_dhcp_client_start_renewing_timer"] = function() { + return Module["asm"]["_pico_dhcp_client_start_renewing_timer"].apply(null, arguments) + }; + + var _pico_dhcp_client_start_requesting_timer = Module["_pico_dhcp_client_start_requesting_timer"] = function() { + return Module["asm"]["_pico_dhcp_client_start_requesting_timer"].apply(null, arguments) + }; + + var _pico_dhcp_client_stop_timers = Module["_pico_dhcp_client_stop_timers"] = function() { + return Module["asm"]["_pico_dhcp_client_stop_timers"].apply(null, arguments) + }; + + var _pico_dhcp_client_timer_handler = Module["_pico_dhcp_client_timer_handler"] = function() { + return Module["asm"]["_pico_dhcp_client_timer_handler"].apply(null, arguments) + }; + + var _pico_dhcp_client_update_link = Module["_pico_dhcp_client_update_link"] = function() { + return Module["asm"]["_pico_dhcp_client_update_link"].apply(null, arguments) + }; + + var _pico_dhcp_client_wakeup = Module["_pico_dhcp_client_wakeup"] = function() { + return Module["asm"]["_pico_dhcp_client_wakeup"].apply(null, arguments) + }; + + var _pico_dhcp_get_address = Module["_pico_dhcp_get_address"] = function() { + return Module["asm"]["_pico_dhcp_get_address"].apply(null, arguments) + }; + + var _pico_dhcp_get_nameserver = Module["_pico_dhcp_get_nameserver"] = function() { + return Module["asm"]["_pico_dhcp_get_nameserver"].apply(null, arguments) + }; + + var _pico_dhcp_initiate_negotiation = Module["_pico_dhcp_initiate_negotiation"] = function() { + return Module["asm"]["_pico_dhcp_initiate_negotiation"].apply(null, arguments) + }; + + var _pico_dhcp_next_option = Module["_pico_dhcp_next_option"] = function() { + return Module["asm"]["_pico_dhcp_next_option"].apply(null, arguments) + }; + + var _pico_dhcp_opt_broadcast = Module["_pico_dhcp_opt_broadcast"] = function() { + return Module["asm"]["_pico_dhcp_opt_broadcast"].apply(null, arguments) + }; + + var _pico_dhcp_opt_dns = Module["_pico_dhcp_opt_dns"] = function() { + return Module["asm"]["_pico_dhcp_opt_dns"].apply(null, arguments) + }; + + var _pico_dhcp_opt_end = Module["_pico_dhcp_opt_end"] = function() { + return Module["asm"]["_pico_dhcp_opt_end"].apply(null, arguments) + }; + + var _pico_dhcp_opt_leasetime = Module["_pico_dhcp_opt_leasetime"] = function() { + return Module["asm"]["_pico_dhcp_opt_leasetime"].apply(null, arguments) + }; + + var _pico_dhcp_opt_maxmsgsize = Module["_pico_dhcp_opt_maxmsgsize"] = function() { + return Module["asm"]["_pico_dhcp_opt_maxmsgsize"].apply(null, arguments) + }; + + var _pico_dhcp_opt_msgtype = Module["_pico_dhcp_opt_msgtype"] = function() { + return Module["asm"]["_pico_dhcp_opt_msgtype"].apply(null, arguments) + }; + + var _pico_dhcp_opt_netmask = Module["_pico_dhcp_opt_netmask"] = function() { + return Module["asm"]["_pico_dhcp_opt_netmask"].apply(null, arguments) + }; + + var _pico_dhcp_opt_paramlist = Module["_pico_dhcp_opt_paramlist"] = function() { + return Module["asm"]["_pico_dhcp_opt_paramlist"].apply(null, arguments) + }; + + var _pico_dhcp_opt_reqip = Module["_pico_dhcp_opt_reqip"] = function() { + return Module["asm"]["_pico_dhcp_opt_reqip"].apply(null, arguments) + }; + + var _pico_dhcp_opt_router = Module["_pico_dhcp_opt_router"] = function() { + return Module["asm"]["_pico_dhcp_opt_router"].apply(null, arguments) + }; + + var _pico_dhcp_opt_serverid = Module["_pico_dhcp_opt_serverid"] = function() { + return Module["asm"]["_pico_dhcp_opt_serverid"].apply(null, arguments) + }; + + var _pico_dhcp_server_add_negotiation = Module["_pico_dhcp_server_add_negotiation"] = function() { + return Module["asm"]["_pico_dhcp_server_add_negotiation"].apply(null, arguments) + }; + + var _pico_dhcp_server_add_setting = Module["_pico_dhcp_server_add_setting"] = function() { + return Module["asm"]["_pico_dhcp_server_add_setting"].apply(null, arguments) + }; + + var _pico_dhcp_server_find_negotiation = Module["_pico_dhcp_server_find_negotiation"] = function() { + return Module["asm"]["_pico_dhcp_server_find_negotiation"].apply(null, arguments) + }; + + var _pico_dhcp_server_initiate = Module["_pico_dhcp_server_initiate"] = function() { + return Module["asm"]["_pico_dhcp_server_initiate"].apply(null, arguments) + }; + + var _pico_dhcp_server_recv = Module["_pico_dhcp_server_recv"] = function() { + return Module["asm"]["_pico_dhcp_server_recv"].apply(null, arguments) + }; + + var _pico_dhcp_state_machine = Module["_pico_dhcp_state_machine"] = function() { + return Module["asm"]["_pico_dhcp_state_machine"].apply(null, arguments) + }; + + var _pico_dhcp_timer_add = Module["_pico_dhcp_timer_add"] = function() { + return Module["asm"]["_pico_dhcp_timer_add"].apply(null, arguments) + }; + + var _pico_dhcpd_wakeup = Module["_pico_dhcpd_wakeup"] = function() { + return Module["asm"]["_pico_dhcpd_wakeup"].apply(null, arguments) + }; + + var _pico_discard_segment = Module["_pico_discard_segment"] = function() { + return Module["asm"]["_pico_discard_segment"].apply(null, arguments) + }; + + var _pico_dns_check_namelen = Module["_pico_dns_check_namelen"] = function() { + return Module["asm"]["_pico_dns_check_namelen"].apply(null, arguments) + }; + + var _pico_dns_client_add_ns = Module["_pico_dns_client_add_ns"] = function() { + return Module["asm"]["_pico_dns_client_add_ns"].apply(null, arguments) + }; + + var _pico_dns_client_add_query = Module["_pico_dns_client_add_query"] = function() { + return Module["asm"]["_pico_dns_client_add_query"].apply(null, arguments) + }; + + var _pico_dns_client_addr_label_check_len = Module["_pico_dns_client_addr_label_check_len"] = function() { + return Module["asm"]["_pico_dns_client_addr_label_check_len"].apply(null, arguments) + }; + + var _pico_dns_client_callback = Module["_pico_dns_client_callback"] = function() { + return Module["asm"]["_pico_dns_client_callback"].apply(null, arguments) + }; + + var _pico_dns_client_check_asuffix = Module["_pico_dns_client_check_asuffix"] = function() { + return Module["asm"]["_pico_dns_client_check_asuffix"].apply(null, arguments) + }; + + var _pico_dns_client_check_header = Module["_pico_dns_client_check_header"] = function() { + return Module["asm"]["_pico_dns_client_check_header"].apply(null, arguments) + }; + + var _pico_dns_client_check_qsuffix = Module["_pico_dns_client_check_qsuffix"] = function() { + return Module["asm"]["_pico_dns_client_check_qsuffix"].apply(null, arguments) + }; + + var _pico_dns_client_check_rdlength = Module["_pico_dns_client_check_rdlength"] = function() { + return Module["asm"]["_pico_dns_client_check_rdlength"].apply(null, arguments) + }; + + var _pico_dns_client_check_url = Module["_pico_dns_client_check_url"] = function() { + return Module["asm"]["_pico_dns_client_check_url"].apply(null, arguments) + }; + + var _pico_dns_client_del_ns = Module["_pico_dns_client_del_ns"] = function() { + return Module["asm"]["_pico_dns_client_del_ns"].apply(null, arguments) + }; + + var _pico_dns_client_del_query = Module["_pico_dns_client_del_query"] = function() { + return Module["asm"]["_pico_dns_client_del_query"].apply(null, arguments) + }; + + var _pico_dns_client_find_query = Module["_pico_dns_client_find_query"] = function() { + return Module["asm"]["_pico_dns_client_find_query"].apply(null, arguments) + }; + + var _pico_dns_client_getaddr = Module["_pico_dns_client_getaddr"] = function() { + return Module["asm"]["_pico_dns_client_getaddr"].apply(null, arguments) + }; + + var _pico_dns_client_getaddr_check = Module["_pico_dns_client_getaddr_check"] = function() { + return Module["asm"]["_pico_dns_client_getaddr_check"].apply(null, arguments) + }; + + var _pico_dns_client_getaddr_init = Module["_pico_dns_client_getaddr_init"] = function() { + return Module["asm"]["_pico_dns_client_getaddr_init"].apply(null, arguments) + }; + + var _pico_dns_client_getname = Module["_pico_dns_client_getname"] = function() { + return Module["asm"]["_pico_dns_client_getname"].apply(null, arguments) + }; + + var _pico_dns_client_idcheck = Module["_pico_dns_client_idcheck"] = function() { + return Module["asm"]["_pico_dns_client_idcheck"].apply(null, arguments) + }; + + var _pico_dns_client_init = Module["_pico_dns_client_init"] = function() { + return Module["asm"]["_pico_dns_client_init"].apply(null, arguments) + }; + + var _pico_dns_client_nameserver = Module["_pico_dns_client_nameserver"] = function() { + return Module["asm"]["_pico_dns_client_nameserver"].apply(null, arguments) + }; + + var _pico_dns_client_next_ns = Module["_pico_dns_client_next_ns"] = function() { + return Module["asm"]["_pico_dns_client_next_ns"].apply(null, arguments) + }; + + var _pico_dns_client_query_header = Module["_pico_dns_client_query_header"] = function() { + return Module["asm"]["_pico_dns_client_query_header"].apply(null, arguments) + }; + + var _pico_dns_client_retransmission = Module["_pico_dns_client_retransmission"] = function() { + return Module["asm"]["_pico_dns_client_retransmission"].apply(null, arguments) + }; + + var _pico_dns_client_seek = Module["_pico_dns_client_seek"] = function() { + return Module["asm"]["_pico_dns_client_seek"].apply(null, arguments) + }; + + var _pico_dns_client_seek_suffix = Module["_pico_dns_client_seek_suffix"] = function() { + return Module["asm"]["_pico_dns_client_seek_suffix"].apply(null, arguments) + }; + + var _pico_dns_client_send = Module["_pico_dns_client_send"] = function() { + return Module["asm"]["_pico_dns_client_send"].apply(null, arguments) + }; + + var _pico_dns_client_user_callback = Module["_pico_dns_client_user_callback"] = function() { + return Module["asm"]["_pico_dns_client_user_callback"].apply(null, arguments) + }; + + var _pico_dns_create_message = Module["_pico_dns_create_message"] = function() { + return Module["asm"]["_pico_dns_create_message"].apply(null, arguments) + }; + + var _pico_dns_decompress_name = Module["_pico_dns_decompress_name"] = function() { + return Module["asm"]["_pico_dns_decompress_name"].apply(null, arguments) + }; + + var _pico_dns_fill_packet_header = Module["_pico_dns_fill_packet_header"] = function() { + return Module["asm"]["_pico_dns_fill_packet_header"].apply(null, arguments) + }; + + var _pico_dns_getname_univ = Module["_pico_dns_getname_univ"] = function() { + return Module["asm"]["_pico_dns_getname_univ"].apply(null, arguments) + }; + + var _pico_dns_ipv6_set_ptr = Module["_pico_dns_ipv6_set_ptr"] = function() { + return Module["asm"]["_pico_dns_ipv6_set_ptr"].apply(null, arguments) + }; + + var _pico_dns_mirror_addr = Module["_pico_dns_mirror_addr"] = function() { + return Module["asm"]["_pico_dns_mirror_addr"].apply(null, arguments) + }; + + var _pico_dns_name_to_dns_notation = Module["_pico_dns_name_to_dns_notation"] = function() { + return Module["asm"]["_pico_dns_name_to_dns_notation"].apply(null, arguments) + }; + + var _pico_dns_notation_to_name = Module["_pico_dns_notation_to_name"] = function() { + return Module["asm"]["_pico_dns_notation_to_name"].apply(null, arguments) + }; + + var _pico_dns_question_fill_suffix = Module["_pico_dns_question_fill_suffix"] = function() { + return Module["asm"]["_pico_dns_question_fill_suffix"].apply(null, arguments) + }; + + var _pico_dns_strlen = Module["_pico_dns_strlen"] = function() { + return Module["asm"]["_pico_dns_strlen"].apply(null, arguments) + }; + + var _pico_dns_try_fallback_cname = Module["_pico_dns_try_fallback_cname"] = function() { + return Module["asm"]["_pico_dns_try_fallback_cname"].apply(null, arguments) + }; + + var _pico_dualbuffer_checksum = Module["_pico_dualbuffer_checksum"] = function() { + return Module["asm"]["_pico_dualbuffer_checksum"].apply(null, arguments) + }; + + var _pico_endpoint_free = Module["_pico_endpoint_free"] = function() { + return Module["asm"]["_pico_endpoint_free"].apply(null, arguments) + }; + + var _pico_enqueue = Module["_pico_enqueue"] = function() { + return Module["asm"]["_pico_enqueue"].apply(null, arguments) + }; + + var _pico_enqueue_111 = Module["_pico_enqueue_111"] = function() { + return Module["asm"]["_pico_enqueue_111"].apply(null, arguments) + }; + + var _pico_enqueue_151 = Module["_pico_enqueue_151"] = function() { + return Module["asm"]["_pico_enqueue_151"].apply(null, arguments) + }; + + var _pico_enqueue_157 = Module["_pico_enqueue_157"] = function() { + return Module["asm"]["_pico_enqueue_157"].apply(null, arguments) + }; + + var _pico_enqueue_257 = Module["_pico_enqueue_257"] = function() { + return Module["asm"]["_pico_enqueue_257"].apply(null, arguments) + }; + + var _pico_enqueue_326 = Module["_pico_enqueue_326"] = function() { + return Module["asm"]["_pico_enqueue_326"].apply(null, arguments) + }; + + var _pico_enqueue_415 = Module["_pico_enqueue_415"] = function() { + return Module["asm"]["_pico_enqueue_415"].apply(null, arguments) + }; + + var _pico_enqueue_and_wakeup_if_needed = Module["_pico_enqueue_and_wakeup_if_needed"] = function() { + return Module["asm"]["_pico_enqueue_and_wakeup_if_needed"].apply(null, arguments) + }; + + var _pico_enqueue_segment = Module["_pico_enqueue_segment"] = function() { + return Module["asm"]["_pico_enqueue_segment"].apply(null, arguments) + }; + + var _pico_eth_check_bcast = Module["_pico_eth_check_bcast"] = function() { + return Module["asm"]["_pico_eth_check_bcast"].apply(null, arguments) + }; + + var _pico_eth_receive = Module["_pico_eth_receive"] = function() { + return Module["asm"]["_pico_eth_receive"].apply(null, arguments) + }; + + var _pico_ethernet_alloc = Module["_pico_ethernet_alloc"] = function() { + return Module["asm"]["_pico_ethernet_alloc"].apply(null, arguments) + }; + + var _pico_ethernet_ipv6_dst = Module["_pico_ethernet_ipv6_dst"] = function() { + return Module["asm"]["_pico_ethernet_ipv6_dst"].apply(null, arguments) + }; + + var _pico_ethernet_mcast6_translate = Module["_pico_ethernet_mcast6_translate"] = function() { + return Module["asm"]["_pico_ethernet_mcast6_translate"].apply(null, arguments) + }; + + var _pico_ethernet_mcast_translate = Module["_pico_ethernet_mcast_translate"] = function() { + return Module["asm"]["_pico_ethernet_mcast_translate"].apply(null, arguments) + }; + + var _pico_ethernet_process_in = Module["_pico_ethernet_process_in"] = function() { + return Module["asm"]["_pico_ethernet_process_in"].apply(null, arguments) + }; + + var _pico_ethernet_process_out = Module["_pico_ethernet_process_out"] = function() { + return Module["asm"]["_pico_ethernet_process_out"].apply(null, arguments) + }; + + var _pico_ethernet_receive = Module["_pico_ethernet_receive"] = function() { + return Module["asm"]["_pico_ethernet_receive"].apply(null, arguments) + }; + + var _pico_ethernet_send = Module["_pico_ethernet_send"] = function() { + return Module["asm"]["_pico_ethernet_send"].apply(null, arguments) + }; + + var _pico_ethsend_bcast = Module["_pico_ethsend_bcast"] = function() { + return Module["asm"]["_pico_ethsend_bcast"].apply(null, arguments) + }; + + var _pico_ethsend_dispatch = Module["_pico_ethsend_dispatch"] = function() { + return Module["asm"]["_pico_ethsend_dispatch"].apply(null, arguments) + }; + + var _pico_ethsend_local = Module["_pico_ethsend_local"] = function() { + return Module["asm"]["_pico_ethsend_local"].apply(null, arguments) + }; + + var _pico_frag_expire = Module["_pico_frag_expire"] = function() { + return Module["asm"]["_pico_frag_expire"].apply(null, arguments) + }; + + var _pico_fragments_check_complete = Module["_pico_fragments_check_complete"] = function() { + return Module["asm"]["_pico_fragments_check_complete"].apply(null, arguments) + }; + + var _pico_fragments_complete = Module["_pico_fragments_complete"] = function() { + return Module["asm"]["_pico_fragments_complete"].apply(null, arguments) + }; + + var _pico_fragments_empty_tree = Module["_pico_fragments_empty_tree"] = function() { + return Module["asm"]["_pico_fragments_empty_tree"].apply(null, arguments) + }; + + var _pico_fragments_get_header_length = Module["_pico_fragments_get_header_length"] = function() { + return Module["asm"]["_pico_fragments_get_header_length"].apply(null, arguments) + }; + + var _pico_fragments_get_more_flag = Module["_pico_fragments_get_more_flag"] = function() { + return Module["asm"]["_pico_fragments_get_more_flag"].apply(null, arguments) + }; + + var _pico_fragments_get_offset = Module["_pico_fragments_get_offset"] = function() { + return Module["asm"]["_pico_fragments_get_offset"].apply(null, arguments) + }; + + var _pico_fragments_reassemble = Module["_pico_fragments_reassemble"] = function() { + return Module["asm"]["_pico_fragments_reassemble"].apply(null, arguments) + }; + + var _pico_fragments_send_notify = Module["_pico_fragments_send_notify"] = function() { + return Module["asm"]["_pico_fragments_send_notify"].apply(null, arguments) + }; + + var _pico_frame_alloc = Module["_pico_frame_alloc"] = function() { + return Module["asm"]["_pico_frame_alloc"].apply(null, arguments) + }; + + var _pico_frame_alloc_skeleton = Module["_pico_frame_alloc_skeleton"] = function() { + return Module["asm"]["_pico_frame_alloc_skeleton"].apply(null, arguments) + }; + + var _pico_frame_copy = Module["_pico_frame_copy"] = function() { + return Module["asm"]["_pico_frame_copy"].apply(null, arguments) + }; + + var _pico_frame_discard = Module["_pico_frame_discard"] = function() { + return Module["asm"]["_pico_frame_discard"].apply(null, arguments) + }; + + var _pico_frame_do_alloc = Module["_pico_frame_do_alloc"] = function() { + return Module["asm"]["_pico_frame_do_alloc"].apply(null, arguments) + }; + + var _pico_frame_dst_is_unicast = Module["_pico_frame_dst_is_unicast"] = function() { + return Module["asm"]["_pico_frame_dst_is_unicast"].apply(null, arguments) + }; + + var _pico_frame_grow_head = Module["_pico_frame_grow_head"] = function() { + return Module["asm"]["_pico_frame_grow_head"].apply(null, arguments) + }; + + var _pico_frame_new_buffer = Module["_pico_frame_new_buffer"] = function() { + return Module["asm"]["_pico_frame_new_buffer"].apply(null, arguments) + }; + + var _pico_frame_skeleton_set_buffer = Module["_pico_frame_skeleton_set_buffer"] = function() { + return Module["asm"]["_pico_frame_skeleton_set_buffer"].apply(null, arguments) + }; + + var _pico_frame_update_pointers = Module["_pico_frame_update_pointers"] = function() { + return Module["asm"]["_pico_frame_update_pointers"].apply(null, arguments) + }; + + var _pico_generic_port_in_use = Module["_pico_generic_port_in_use"] = function() { + return Module["asm"]["_pico_generic_port_in_use"].apply(null, arguments) + }; + + var _pico_get_device = Module["_pico_get_device"] = function() { + return Module["asm"]["_pico_get_device"].apply(null, arguments) + }; + + var _pico_get_sockport = Module["_pico_get_sockport"] = function() { + return Module["asm"]["_pico_get_sockport"].apply(null, arguments) + }; + + var _pico_hash = Module["_pico_hash"] = function() { + return Module["asm"]["_pico_hash"].apply(null, arguments) + }; + + var _pico_hash_431 = Module["_pico_hash_431"] = function() { + return Module["asm"]["_pico_hash_431"].apply(null, arguments) + }; + + var _pico_hold_segment_make = Module["_pico_hold_segment_make"] = function() { + return Module["asm"]["_pico_hold_segment_make"].apply(null, arguments) + }; + + var _pico_icmp4_checksum = Module["_pico_icmp4_checksum"] = function() { + return Module["asm"]["_pico_icmp4_checksum"].apply(null, arguments) + }; + + var _pico_icmp4_dest_unreachable = Module["_pico_icmp4_dest_unreachable"] = function() { + return Module["asm"]["_pico_icmp4_dest_unreachable"].apply(null, arguments) + }; + + var _pico_icmp4_frag_expired = Module["_pico_icmp4_frag_expired"] = function() { + return Module["asm"]["_pico_icmp4_frag_expired"].apply(null, arguments) + }; + + var _pico_icmp4_mtu_exceeded = Module["_pico_icmp4_mtu_exceeded"] = function() { + return Module["asm"]["_pico_icmp4_mtu_exceeded"].apply(null, arguments) + }; + + var _pico_icmp4_notify = Module["_pico_icmp4_notify"] = function() { + return Module["asm"]["_pico_icmp4_notify"].apply(null, arguments) + }; + + var _pico_icmp4_param_problem = Module["_pico_icmp4_param_problem"] = function() { + return Module["asm"]["_pico_icmp4_param_problem"].apply(null, arguments) + }; + + var _pico_icmp4_ping = Module["_pico_icmp4_ping"] = function() { + return Module["asm"]["_pico_icmp4_ping"].apply(null, arguments) + }; + + var _pico_icmp4_port_unreachable = Module["_pico_icmp4_port_unreachable"] = function() { + return Module["asm"]["_pico_icmp4_port_unreachable"].apply(null, arguments) + }; + + var _pico_icmp4_process_in = Module["_pico_icmp4_process_in"] = function() { + return Module["asm"]["_pico_icmp4_process_in"].apply(null, arguments) + }; + + var _pico_icmp4_process_out = Module["_pico_icmp4_process_out"] = function() { + return Module["asm"]["_pico_icmp4_process_out"].apply(null, arguments) + }; + + var _pico_icmp4_proto_unreachable = Module["_pico_icmp4_proto_unreachable"] = function() { + return Module["asm"]["_pico_icmp4_proto_unreachable"].apply(null, arguments) + }; + + var _pico_icmp4_send_echo = Module["_pico_icmp4_send_echo"] = function() { + return Module["asm"]["_pico_icmp4_send_echo"].apply(null, arguments) + }; + + var _pico_icmp4_ttl_expired = Module["_pico_icmp4_ttl_expired"] = function() { + return Module["asm"]["_pico_icmp4_ttl_expired"].apply(null, arguments) + }; + + var _pico_icmp6_address_to_prefix = Module["_pico_icmp6_address_to_prefix"] = function() { + return Module["asm"]["_pico_icmp6_address_to_prefix"].apply(null, arguments) + }; + + var _pico_icmp6_checksum = Module["_pico_icmp6_checksum"] = function() { + return Module["asm"]["_pico_icmp6_checksum"].apply(null, arguments) + }; + + var _pico_icmp6_dest_unreachable = Module["_pico_icmp6_dest_unreachable"] = function() { + return Module["asm"]["_pico_icmp6_dest_unreachable"].apply(null, arguments) + }; + + var _pico_icmp6_frag_expired = Module["_pico_icmp6_frag_expired"] = function() { + return Module["asm"]["_pico_icmp6_frag_expired"].apply(null, arguments) + }; + + var _pico_icmp6_neigh_sol_prep = Module["_pico_icmp6_neigh_sol_prep"] = function() { + return Module["asm"]["_pico_icmp6_neigh_sol_prep"].apply(null, arguments) + }; + + var _pico_icmp6_neighbor_advertisement = Module["_pico_icmp6_neighbor_advertisement"] = function() { + return Module["asm"]["_pico_icmp6_neighbor_advertisement"].apply(null, arguments) + }; + + var _pico_icmp6_neighbor_solicitation = Module["_pico_icmp6_neighbor_solicitation"] = function() { + return Module["asm"]["_pico_icmp6_neighbor_solicitation"].apply(null, arguments) + }; + + var _pico_icmp6_notify = Module["_pico_icmp6_notify"] = function() { + return Module["asm"]["_pico_icmp6_notify"].apply(null, arguments) + }; + + var _pico_icmp6_parameter_problem = Module["_pico_icmp6_parameter_problem"] = function() { + return Module["asm"]["_pico_icmp6_parameter_problem"].apply(null, arguments) + }; + + var _pico_icmp6_ping_recv_reply = Module["_pico_icmp6_ping_recv_reply"] = function() { + return Module["asm"]["_pico_icmp6_ping_recv_reply"].apply(null, arguments) + }; + + var _pico_icmp6_pkt_too_big = Module["_pico_icmp6_pkt_too_big"] = function() { + return Module["asm"]["_pico_icmp6_pkt_too_big"].apply(null, arguments) + }; + + var _pico_icmp6_port_unreachable = Module["_pico_icmp6_port_unreachable"] = function() { + return Module["asm"]["_pico_icmp6_port_unreachable"].apply(null, arguments) + }; + + var _pico_icmp6_process_in = Module["_pico_icmp6_process_in"] = function() { + return Module["asm"]["_pico_icmp6_process_in"].apply(null, arguments) + }; + + var _pico_icmp6_process_out = Module["_pico_icmp6_process_out"] = function() { + return Module["asm"]["_pico_icmp6_process_out"].apply(null, arguments) + }; + + var _pico_icmp6_proto_unreachable = Module["_pico_icmp6_proto_unreachable"] = function() { + return Module["asm"]["_pico_icmp6_proto_unreachable"].apply(null, arguments) + }; + + var _pico_icmp6_provide_llao = Module["_pico_icmp6_provide_llao"] = function() { + return Module["asm"]["_pico_icmp6_provide_llao"].apply(null, arguments) + }; + + var _pico_icmp6_router_advertisement = Module["_pico_icmp6_router_advertisement"] = function() { + return Module["asm"]["_pico_icmp6_router_advertisement"].apply(null, arguments) + }; + + var _pico_icmp6_router_solicitation = Module["_pico_icmp6_router_solicitation"] = function() { + return Module["asm"]["_pico_icmp6_router_solicitation"].apply(null, arguments) + }; + + var _pico_icmp6_send_echoreply = Module["_pico_icmp6_send_echoreply"] = function() { + return Module["asm"]["_pico_icmp6_send_echoreply"].apply(null, arguments) + }; + + var _pico_icmp6_ttl_expired = Module["_pico_icmp6_ttl_expired"] = function() { + return Module["asm"]["_pico_icmp6_ttl_expired"].apply(null, arguments) + }; + + var _pico_igmp_analyse_packet = Module["_pico_igmp_analyse_packet"] = function() { + return Module["asm"]["_pico_igmp_analyse_packet"].apply(null, arguments) + }; + + var _pico_igmp_compatibility_mode = Module["_pico_igmp_compatibility_mode"] = function() { + return Module["asm"]["_pico_igmp_compatibility_mode"].apply(null, arguments) + }; + + var _pico_igmp_delete_parameter = Module["_pico_igmp_delete_parameter"] = function() { + return Module["asm"]["_pico_igmp_delete_parameter"].apply(null, arguments) + }; + + var _pico_igmp_find_parameter = Module["_pico_igmp_find_parameter"] = function() { + return Module["asm"]["_pico_igmp_find_parameter"].apply(null, arguments) + }; + + var _pico_igmp_find_timer = Module["_pico_igmp_find_timer"] = function() { + return Module["asm"]["_pico_igmp_find_timer"].apply(null, arguments) + }; + + var _pico_igmp_generate_report = Module["_pico_igmp_generate_report"] = function() { + return Module["asm"]["_pico_igmp_generate_report"].apply(null, arguments) + }; + + var _pico_igmp_is_checksum_valid = Module["_pico_igmp_is_checksum_valid"] = function() { + return Module["asm"]["_pico_igmp_is_checksum_valid"].apply(null, arguments) + }; + + var _pico_igmp_process_event = Module["_pico_igmp_process_event"] = function() { + return Module["asm"]["_pico_igmp_process_event"].apply(null, arguments) + }; + + var _pico_igmp_process_in = Module["_pico_igmp_process_in"] = function() { + return Module["asm"]["_pico_igmp_process_in"].apply(null, arguments) + }; + + var _pico_igmp_process_out = Module["_pico_igmp_process_out"] = function() { + return Module["asm"]["_pico_igmp_process_out"].apply(null, arguments) + }; + + var _pico_igmp_report_expired = Module["_pico_igmp_report_expired"] = function() { + return Module["asm"]["_pico_igmp_report_expired"].apply(null, arguments) + }; + + var _pico_igmp_send_report = Module["_pico_igmp_send_report"] = function() { + return Module["asm"]["_pico_igmp_send_report"].apply(null, arguments) + }; + + var _pico_igmp_state_change = Module["_pico_igmp_state_change"] = function() { + return Module["asm"]["_pico_igmp_state_change"].apply(null, arguments) + }; + + var _pico_igmp_timer_expired = Module["_pico_igmp_timer_expired"] = function() { + return Module["asm"]["_pico_igmp_timer_expired"].apply(null, arguments) + }; + + var _pico_igmp_timer_is_running = Module["_pico_igmp_timer_is_running"] = function() { + return Module["asm"]["_pico_igmp_timer_is_running"].apply(null, arguments) + }; + + var _pico_igmp_timer_reset = Module["_pico_igmp_timer_reset"] = function() { + return Module["asm"]["_pico_igmp_timer_reset"].apply(null, arguments) + }; + + var _pico_igmp_timer_start = Module["_pico_igmp_timer_start"] = function() { + return Module["asm"]["_pico_igmp_timer_start"].apply(null, arguments) + }; + + var _pico_igmp_timer_stop = Module["_pico_igmp_timer_stop"] = function() { + return Module["asm"]["_pico_igmp_timer_stop"].apply(null, arguments) + }; + + var _pico_igmp_v2querier_expired = Module["_pico_igmp_v2querier_expired"] = function() { + return Module["asm"]["_pico_igmp_v2querier_expired"].apply(null, arguments) + }; + + var _pico_igmpv2_generate_report = Module["_pico_igmpv2_generate_report"] = function() { + return Module["asm"]["_pico_igmpv2_generate_report"].apply(null, arguments) + }; + + var _pico_igmpv3_generate_filter = Module["_pico_igmpv3_generate_filter"] = function() { + return Module["asm"]["_pico_igmpv3_generate_filter"].apply(null, arguments) + }; + + var _pico_igmpv3_generate_report = Module["_pico_igmpv3_generate_report"] = function() { + return Module["asm"]["_pico_igmpv3_generate_report"].apply(null, arguments) + }; + + var _pico_ipv4_alloc = Module["_pico_ipv4_alloc"] = function() { + return Module["asm"]["_pico_ipv4_alloc"].apply(null, arguments) + }; + + var _pico_ipv4_checksum = Module["_pico_ipv4_checksum"] = function() { + return Module["asm"]["_pico_ipv4_checksum"].apply(null, arguments) + }; + + var _pico_ipv4_cleanup_routes = Module["_pico_ipv4_cleanup_routes"] = function() { + return Module["asm"]["_pico_ipv4_cleanup_routes"].apply(null, arguments) + }; + + var _pico_ipv4_compare = Module["_pico_ipv4_compare"] = function() { + return Module["asm"]["_pico_ipv4_compare"].apply(null, arguments) + }; + + var _pico_ipv4_crc_check = Module["_pico_ipv4_crc_check"] = function() { + return Module["asm"]["_pico_ipv4_crc_check"].apply(null, arguments) + }; + + var _pico_ipv4_ethernet_receive = Module["_pico_ipv4_ethernet_receive"] = function() { + return Module["asm"]["_pico_ipv4_ethernet_receive"].apply(null, arguments) + }; + + var _pico_ipv4_forward = Module["_pico_ipv4_forward"] = function() { + return Module["asm"]["_pico_ipv4_forward"].apply(null, arguments) + }; + + var _pico_ipv4_forward_check_dev = Module["_pico_ipv4_forward_check_dev"] = function() { + return Module["asm"]["_pico_ipv4_forward_check_dev"].apply(null, arguments) + }; + + var _pico_ipv4_frag_compare = Module["_pico_ipv4_frag_compare"] = function() { + return Module["asm"]["_pico_ipv4_frag_compare"].apply(null, arguments) + }; + + var _pico_ipv4_frag_match = Module["_pico_ipv4_frag_match"] = function() { + return Module["asm"]["_pico_ipv4_frag_match"].apply(null, arguments) + }; + + var _pico_ipv4_frag_timer_on = Module["_pico_ipv4_frag_timer_on"] = function() { + return Module["asm"]["_pico_ipv4_frag_timer_on"].apply(null, arguments) + }; + + var _pico_ipv4_fragments_complete = Module["_pico_ipv4_fragments_complete"] = function() { + return Module["asm"]["_pico_ipv4_fragments_complete"].apply(null, arguments) + }; + + var _pico_ipv4_frame_push = Module["_pico_ipv4_frame_push"] = function() { + return Module["asm"]["_pico_ipv4_frame_push"].apply(null, arguments) + }; + + var _pico_ipv4_frame_sock_push = Module["_pico_ipv4_frame_sock_push"] = function() { + return Module["asm"]["_pico_ipv4_frame_sock_push"].apply(null, arguments) + }; + + var _pico_ipv4_get_default_mcastlink = Module["_pico_ipv4_get_default_mcastlink"] = function() { + return Module["asm"]["_pico_ipv4_get_default_mcastlink"].apply(null, arguments) + }; + + var _pico_ipv4_is_broadcast = Module["_pico_ipv4_is_broadcast"] = function() { + return Module["asm"]["_pico_ipv4_is_broadcast"].apply(null, arguments) + }; + + var _pico_ipv4_is_invalid_loopback = Module["_pico_ipv4_is_invalid_loopback"] = function() { + return Module["asm"]["_pico_ipv4_is_invalid_loopback"].apply(null, arguments) + }; + + var _pico_ipv4_is_loopback = Module["_pico_ipv4_is_loopback"] = function() { + return Module["asm"]["_pico_ipv4_is_loopback"].apply(null, arguments) + }; + + var _pico_ipv4_is_multicast = Module["_pico_ipv4_is_multicast"] = function() { + return Module["asm"]["_pico_ipv4_is_multicast"].apply(null, arguments) + }; + + var _pico_ipv4_is_unicast = Module["_pico_ipv4_is_unicast"] = function() { + return Module["asm"]["_pico_ipv4_is_unicast"].apply(null, arguments) + }; + + var _pico_ipv4_is_valid_src = Module["_pico_ipv4_is_valid_src"] = function() { + return Module["asm"]["_pico_ipv4_is_valid_src"].apply(null, arguments) + }; + + var _pico_ipv4_link_add = Module["_pico_ipv4_link_add"] = function() { + return Module["asm"]["_pico_ipv4_link_add"].apply(null, arguments) + }; + + var _pico_ipv4_link_by_dev = Module["_pico_ipv4_link_by_dev"] = function() { + return Module["asm"]["_pico_ipv4_link_by_dev"].apply(null, arguments) + }; + + var _pico_ipv4_link_by_dev_next = Module["_pico_ipv4_link_by_dev_next"] = function() { + return Module["asm"]["_pico_ipv4_link_by_dev_next"].apply(null, arguments) + }; + + var _pico_ipv4_link_del = Module["_pico_ipv4_link_del"] = function() { + return Module["asm"]["_pico_ipv4_link_del"].apply(null, arguments) + }; + + var _pico_ipv4_link_find = Module["_pico_ipv4_link_find"] = function() { + return Module["asm"]["_pico_ipv4_link_find"].apply(null, arguments) + }; + + var _pico_ipv4_link_get = Module["_pico_ipv4_link_get"] = function() { + return Module["asm"]["_pico_ipv4_link_get"].apply(null, arguments) + }; + + var _pico_ipv4_mcast_filter = Module["_pico_ipv4_mcast_filter"] = function() { + return Module["asm"]["_pico_ipv4_mcast_filter"].apply(null, arguments) + }; + + var _pico_ipv4_mcast_join = Module["_pico_ipv4_mcast_join"] = function() { + return Module["asm"]["_pico_ipv4_mcast_join"].apply(null, arguments) + }; + + var _pico_ipv4_mcast_leave = Module["_pico_ipv4_mcast_leave"] = function() { + return Module["asm"]["_pico_ipv4_mcast_leave"].apply(null, arguments) + }; + + var _pico_ipv4_mcast_print_groups = Module["_pico_ipv4_mcast_print_groups"] = function() { + return Module["asm"]["_pico_ipv4_mcast_print_groups"].apply(null, arguments) + }; + + var _pico_ipv4_nat_add = Module["_pico_ipv4_nat_add"] = function() { + return Module["asm"]["_pico_ipv4_nat_add"].apply(null, arguments) + }; + + var _pico_ipv4_nat_find = Module["_pico_ipv4_nat_find"] = function() { + return Module["asm"]["_pico_ipv4_nat_find"].apply(null, arguments) + }; + + var _pico_ipv4_nat_find_tuple = Module["_pico_ipv4_nat_find_tuple"] = function() { + return Module["asm"]["_pico_ipv4_nat_find_tuple"].apply(null, arguments) + }; + + var _pico_ipv4_nat_generate_tuple = Module["_pico_ipv4_nat_generate_tuple"] = function() { + return Module["asm"]["_pico_ipv4_nat_generate_tuple"].apply(null, arguments) + }; + + var _pico_ipv4_nat_inbound = Module["_pico_ipv4_nat_inbound"] = function() { + return Module["asm"]["_pico_ipv4_nat_inbound"].apply(null, arguments) + }; + + var _pico_ipv4_nat_is_enabled = Module["_pico_ipv4_nat_is_enabled"] = function() { + return Module["asm"]["_pico_ipv4_nat_is_enabled"].apply(null, arguments) + }; + + var _pico_ipv4_nat_outbound = Module["_pico_ipv4_nat_outbound"] = function() { + return Module["asm"]["_pico_ipv4_nat_outbound"].apply(null, arguments) + }; + + var _pico_ipv4_nat_set_tcp_flags = Module["_pico_ipv4_nat_set_tcp_flags"] = function() { + return Module["asm"]["_pico_ipv4_nat_set_tcp_flags"].apply(null, arguments) + }; + + var _pico_ipv4_nat_sniff_session = Module["_pico_ipv4_nat_sniff_session"] = function() { + return Module["asm"]["_pico_ipv4_nat_sniff_session"].apply(null, arguments) + }; + + var _pico_ipv4_pre_forward_checks = Module["_pico_ipv4_pre_forward_checks"] = function() { + return Module["asm"]["_pico_ipv4_pre_forward_checks"].apply(null, arguments) + }; + + var _pico_ipv4_process_bcast_in = Module["_pico_ipv4_process_bcast_in"] = function() { + return Module["asm"]["_pico_ipv4_process_bcast_in"].apply(null, arguments) + }; + + var _pico_ipv4_process_finally_try_forward = Module["_pico_ipv4_process_finally_try_forward"] = function() { + return Module["asm"]["_pico_ipv4_process_finally_try_forward"].apply(null, arguments) + }; + + var _pico_ipv4_process_frag = Module["_pico_ipv4_process_frag"] = function() { + return Module["asm"]["_pico_ipv4_process_frag"].apply(null, arguments) + }; + + var _pico_ipv4_process_in = Module["_pico_ipv4_process_in"] = function() { + return Module["asm"]["_pico_ipv4_process_in"].apply(null, arguments) + }; + + var _pico_ipv4_process_local_unicast_in = Module["_pico_ipv4_process_local_unicast_in"] = function() { + return Module["asm"]["_pico_ipv4_process_local_unicast_in"].apply(null, arguments) + }; + + var _pico_ipv4_process_mcast_in = Module["_pico_ipv4_process_mcast_in"] = function() { + return Module["asm"]["_pico_ipv4_process_mcast_in"].apply(null, arguments) + }; + + var _pico_ipv4_process_out = Module["_pico_ipv4_process_out"] = function() { + return Module["asm"]["_pico_ipv4_process_out"].apply(null, arguments) + }; + + var _pico_ipv4_rebound = Module["_pico_ipv4_rebound"] = function() { + return Module["asm"]["_pico_ipv4_rebound"].apply(null, arguments) + }; + + var _pico_ipv4_rebound_large = Module["_pico_ipv4_rebound_large"] = function() { + return Module["asm"]["_pico_ipv4_rebound_large"].apply(null, arguments) + }; + + var _pico_ipv4_route_add = Module["_pico_ipv4_route_add"] = function() { + return Module["asm"]["_pico_ipv4_route_add"].apply(null, arguments) + }; + + var _pico_ipv4_route_del = Module["_pico_ipv4_route_del"] = function() { + return Module["asm"]["_pico_ipv4_route_del"].apply(null, arguments) + }; + + var _pico_ipv4_route_get_gateway = Module["_pico_ipv4_route_get_gateway"] = function() { + return Module["asm"]["_pico_ipv4_route_get_gateway"].apply(null, arguments) + }; + + var _pico_ipv4_route_set_bcast_link = Module["_pico_ipv4_route_set_bcast_link"] = function() { + return Module["asm"]["_pico_ipv4_route_set_bcast_link"].apply(null, arguments) + }; + + var _pico_ipv4_source_dev_find = Module["_pico_ipv4_source_dev_find"] = function() { + return Module["asm"]["_pico_ipv4_source_dev_find"].apply(null, arguments) + }; + + var _pico_ipv4_source_find = Module["_pico_ipv4_source_find"] = function() { + return Module["asm"]["_pico_ipv4_source_find"].apply(null, arguments) + }; + + var _pico_ipv4_to_string = Module["_pico_ipv4_to_string"] = function() { + return Module["asm"]["_pico_ipv4_to_string"].apply(null, arguments) + }; + + var _pico_ipv4_unreachable = Module["_pico_ipv4_unreachable"] = function() { + return Module["asm"]["_pico_ipv4_unreachable"].apply(null, arguments) + }; + + var _pico_ipv6_alloc = Module["_pico_ipv6_alloc"] = function() { + return Module["asm"]["_pico_ipv6_alloc"].apply(null, arguments) + }; + + var _pico_ipv6_check_aligned = Module["_pico_ipv6_check_aligned"] = function() { + return Module["asm"]["_pico_ipv6_check_aligned"].apply(null, arguments) + }; + + var _pico_ipv6_check_headers_sequence = Module["_pico_ipv6_check_headers_sequence"] = function() { + return Module["asm"]["_pico_ipv6_check_headers_sequence"].apply(null, arguments) + }; + + var _pico_ipv6_check_lifetime_expired = Module["_pico_ipv6_check_lifetime_expired"] = function() { + return Module["asm"]["_pico_ipv6_check_lifetime_expired"].apply(null, arguments) + }; + + var _pico_ipv6_cleanup_routes = Module["_pico_ipv6_cleanup_routes"] = function() { + return Module["asm"]["_pico_ipv6_cleanup_routes"].apply(null, arguments) + }; + + var _pico_ipv6_compare = Module["_pico_ipv6_compare"] = function() { + return Module["asm"]["_pico_ipv6_compare"].apply(null, arguments) + }; + + var _pico_ipv6_dec_to_char = Module["_pico_ipv6_dec_to_char"] = function() { + return Module["asm"]["_pico_ipv6_dec_to_char"].apply(null, arguments) + }; + + var _pico_ipv6_do_link_add = Module["_pico_ipv6_do_link_add"] = function() { + return Module["asm"]["_pico_ipv6_do_link_add"].apply(null, arguments) + }; + + var _pico_ipv6_ethernet_receive = Module["_pico_ipv6_ethernet_receive"] = function() { + return Module["asm"]["_pico_ipv6_ethernet_receive"].apply(null, arguments) + }; + + var _pico_ipv6_extension_headers = Module["_pico_ipv6_extension_headers"] = function() { + return Module["asm"]["_pico_ipv6_extension_headers"].apply(null, arguments) + }; + + var _pico_ipv6_forward = Module["_pico_ipv6_forward"] = function() { + return Module["asm"]["_pico_ipv6_forward"].apply(null, arguments) + }; + + var _pico_ipv6_forward_check_dev = Module["_pico_ipv6_forward_check_dev"] = function() { + return Module["asm"]["_pico_ipv6_forward_check_dev"].apply(null, arguments) + }; + + var _pico_ipv6_frag_compare = Module["_pico_ipv6_frag_compare"] = function() { + return Module["asm"]["_pico_ipv6_frag_compare"].apply(null, arguments) + }; + + var _pico_ipv6_frag_match = Module["_pico_ipv6_frag_match"] = function() { + return Module["asm"]["_pico_ipv6_frag_match"].apply(null, arguments) + }; + + var _pico_ipv6_frag_timer_on = Module["_pico_ipv6_frag_timer_on"] = function() { + return Module["asm"]["_pico_ipv6_frag_timer_on"].apply(null, arguments) + }; + + var _pico_ipv6_fragments_complete = Module["_pico_ipv6_fragments_complete"] = function() { + return Module["asm"]["_pico_ipv6_fragments_complete"].apply(null, arguments) + }; + + var _pico_ipv6_frame_push = Module["_pico_ipv6_frame_push"] = function() { + return Module["asm"]["_pico_ipv6_frame_push"].apply(null, arguments) + }; + + var _pico_ipv6_frame_sock_push = Module["_pico_ipv6_frame_sock_push"] = function() { + return Module["asm"]["_pico_ipv6_frame_sock_push"].apply(null, arguments) + }; + + var _pico_ipv6_get_default_mcastlink = Module["_pico_ipv6_get_default_mcastlink"] = function() { + return Module["asm"]["_pico_ipv6_get_default_mcastlink"].apply(null, arguments) + }; + + var _pico_ipv6_get_neighbor = Module["_pico_ipv6_get_neighbor"] = function() { + return Module["asm"]["_pico_ipv6_get_neighbor"].apply(null, arguments) + }; + + var _pico_ipv6_global_get = Module["_pico_ipv6_global_get"] = function() { + return Module["asm"]["_pico_ipv6_global_get"].apply(null, arguments) + }; + + var _pico_ipv6_hex_to_dec = Module["_pico_ipv6_hex_to_dec"] = function() { + return Module["asm"]["_pico_ipv6_hex_to_dec"].apply(null, arguments) + }; + + var _pico_ipv6_is_allhosts_multicast = Module["_pico_ipv6_is_allhosts_multicast"] = function() { + return Module["asm"]["_pico_ipv6_is_allhosts_multicast"].apply(null, arguments) + }; + + var _pico_ipv6_is_global = Module["_pico_ipv6_is_global"] = function() { + return Module["asm"]["_pico_ipv6_is_global"].apply(null, arguments) + }; + + var _pico_ipv6_is_linklocal = Module["_pico_ipv6_is_linklocal"] = function() { + return Module["asm"]["_pico_ipv6_is_linklocal"].apply(null, arguments) + }; + + var _pico_ipv6_is_localhost = Module["_pico_ipv6_is_localhost"] = function() { + return Module["asm"]["_pico_ipv6_is_localhost"].apply(null, arguments) + }; + + var _pico_ipv6_is_multicast = Module["_pico_ipv6_is_multicast"] = function() { + return Module["asm"]["_pico_ipv6_is_multicast"].apply(null, arguments) + }; + + var _pico_ipv6_is_null_address = Module["_pico_ipv6_is_null_address"] = function() { + return Module["asm"]["_pico_ipv6_is_null_address"].apply(null, arguments) + }; + + var _pico_ipv6_is_sitelocal = Module["_pico_ipv6_is_sitelocal"] = function() { + return Module["asm"]["_pico_ipv6_is_sitelocal"].apply(null, arguments) + }; + + var _pico_ipv6_is_solnode_multicast = Module["_pico_ipv6_is_solnode_multicast"] = function() { + return Module["asm"]["_pico_ipv6_is_solnode_multicast"].apply(null, arguments) + }; + + var _pico_ipv6_is_unicast = Module["_pico_ipv6_is_unicast"] = function() { + return Module["asm"]["_pico_ipv6_is_unicast"].apply(null, arguments) + }; + + var _pico_ipv6_is_uniquelocal = Module["_pico_ipv6_is_uniquelocal"] = function() { + return Module["asm"]["_pico_ipv6_is_uniquelocal"].apply(null, arguments) + }; + + var _pico_ipv6_is_unspecified = Module["_pico_ipv6_is_unspecified"] = function() { + return Module["asm"]["_pico_ipv6_is_unspecified"].apply(null, arguments) + }; + + var _pico_ipv6_lifetime_set = Module["_pico_ipv6_lifetime_set"] = function() { + return Module["asm"]["_pico_ipv6_lifetime_set"].apply(null, arguments) + }; + + var _pico_ipv6_link_add = Module["_pico_ipv6_link_add"] = function() { + return Module["asm"]["_pico_ipv6_link_add"].apply(null, arguments) + }; + + var _pico_ipv6_link_add_local = Module["_pico_ipv6_link_add_local"] = function() { + return Module["asm"]["_pico_ipv6_link_add_local"].apply(null, arguments) + }; + + var _pico_ipv6_link_by_dev = Module["_pico_ipv6_link_by_dev"] = function() { + return Module["asm"]["_pico_ipv6_link_by_dev"].apply(null, arguments) + }; + + var _pico_ipv6_link_by_dev_next = Module["_pico_ipv6_link_by_dev_next"] = function() { + return Module["asm"]["_pico_ipv6_link_by_dev_next"].apply(null, arguments) + }; + + var _pico_ipv6_link_del = Module["_pico_ipv6_link_del"] = function() { + return Module["asm"]["_pico_ipv6_link_del"].apply(null, arguments) + }; + + var _pico_ipv6_link_find = Module["_pico_ipv6_link_find"] = function() { + return Module["asm"]["_pico_ipv6_link_find"].apply(null, arguments) + }; + + var _pico_ipv6_link_get = Module["_pico_ipv6_link_get"] = function() { + return Module["asm"]["_pico_ipv6_link_get"].apply(null, arguments) + }; + + var _pico_ipv6_link_istentative = Module["_pico_ipv6_link_istentative"] = function() { + return Module["asm"]["_pico_ipv6_link_istentative"].apply(null, arguments) + }; + + var _pico_ipv6_linklocal_get = Module["_pico_ipv6_linklocal_get"] = function() { + return Module["asm"]["_pico_ipv6_linklocal_get"].apply(null, arguments) + }; + + var _pico_ipv6_mcast_filter = Module["_pico_ipv6_mcast_filter"] = function() { + return Module["asm"]["_pico_ipv6_mcast_filter"].apply(null, arguments) + }; + + var _pico_ipv6_mcast_join = Module["_pico_ipv6_mcast_join"] = function() { + return Module["asm"]["_pico_ipv6_mcast_join"].apply(null, arguments) + }; + + var _pico_ipv6_mcast_leave = Module["_pico_ipv6_mcast_leave"] = function() { + return Module["asm"]["_pico_ipv6_mcast_leave"].apply(null, arguments) + }; + + var _pico_ipv6_nd_dad = Module["_pico_ipv6_nd_dad"] = function() { + return Module["asm"]["_pico_ipv6_nd_dad"].apply(null, arguments) + }; + + var _pico_ipv6_nd_init = Module["_pico_ipv6_nd_init"] = function() { + return Module["asm"]["_pico_ipv6_nd_init"].apply(null, arguments) + }; + + var _pico_ipv6_nd_postpone = Module["_pico_ipv6_nd_postpone"] = function() { + return Module["asm"]["_pico_ipv6_nd_postpone"].apply(null, arguments) + }; + + var _pico_ipv6_nd_queued_trigger = Module["_pico_ipv6_nd_queued_trigger"] = function() { + return Module["asm"]["_pico_ipv6_nd_queued_trigger"].apply(null, arguments) + }; + + var _pico_ipv6_nd_ra_timer_callback = Module["_pico_ipv6_nd_ra_timer_callback"] = function() { + return Module["asm"]["_pico_ipv6_nd_ra_timer_callback"].apply(null, arguments) + }; + + var _pico_ipv6_nd_recv = Module["_pico_ipv6_nd_recv"] = function() { + return Module["asm"]["_pico_ipv6_nd_recv"].apply(null, arguments) + }; + + var _pico_ipv6_nd_timer_callback = Module["_pico_ipv6_nd_timer_callback"] = function() { + return Module["asm"]["_pico_ipv6_nd_timer_callback"].apply(null, arguments) + }; + + var _pico_ipv6_nd_timer_elapsed = Module["_pico_ipv6_nd_timer_elapsed"] = function() { + return Module["asm"]["_pico_ipv6_nd_timer_elapsed"].apply(null, arguments) + }; + + var _pico_ipv6_nd_unreachable = Module["_pico_ipv6_nd_unreachable"] = function() { + return Module["asm"]["_pico_ipv6_nd_unreachable"].apply(null, arguments) + }; + + var _pico_ipv6_neighbor_compare = Module["_pico_ipv6_neighbor_compare"] = function() { + return Module["asm"]["_pico_ipv6_neighbor_compare"].apply(null, arguments) + }; + + var _pico_ipv6_neighbor_compare_stored = Module["_pico_ipv6_neighbor_compare_stored"] = function() { + return Module["asm"]["_pico_ipv6_neighbor_compare_stored"].apply(null, arguments) + }; + + var _pico_ipv6_neighbor_from_sol_new = Module["_pico_ipv6_neighbor_from_sol_new"] = function() { + return Module["asm"]["_pico_ipv6_neighbor_from_sol_new"].apply(null, arguments) + }; + + var _pico_ipv6_neighbor_from_unsolicited = Module["_pico_ipv6_neighbor_from_unsolicited"] = function() { + return Module["asm"]["_pico_ipv6_neighbor_from_unsolicited"].apply(null, arguments) + }; + + var _pico_ipv6_neighbor_update = Module["_pico_ipv6_neighbor_update"] = function() { + return Module["asm"]["_pico_ipv6_neighbor_update"].apply(null, arguments) + }; + + var _pico_ipv6_pre_forward_checks = Module["_pico_ipv6_pre_forward_checks"] = function() { + return Module["asm"]["_pico_ipv6_pre_forward_checks"].apply(null, arguments) + }; + + var _pico_ipv6_prefix_configured = Module["_pico_ipv6_prefix_configured"] = function() { + return Module["asm"]["_pico_ipv6_prefix_configured"].apply(null, arguments) + }; + + var _pico_ipv6_process_destopt = Module["_pico_ipv6_process_destopt"] = function() { + return Module["asm"]["_pico_ipv6_process_destopt"].apply(null, arguments) + }; + + var _pico_ipv6_process_frag = Module["_pico_ipv6_process_frag"] = function() { + return Module["asm"]["_pico_ipv6_process_frag"].apply(null, arguments) + }; + + var _pico_ipv6_process_hopbyhop = Module["_pico_ipv6_process_hopbyhop"] = function() { + return Module["asm"]["_pico_ipv6_process_hopbyhop"].apply(null, arguments) + }; + + var _pico_ipv6_process_in = Module["_pico_ipv6_process_in"] = function() { + return Module["asm"]["_pico_ipv6_process_in"].apply(null, arguments) + }; + + var _pico_ipv6_process_mcast_in = Module["_pico_ipv6_process_mcast_in"] = function() { + return Module["asm"]["_pico_ipv6_process_mcast_in"].apply(null, arguments) + }; + + var _pico_ipv6_process_out = Module["_pico_ipv6_process_out"] = function() { + return Module["asm"]["_pico_ipv6_process_out"].apply(null, arguments) + }; + + var _pico_ipv6_process_routing = Module["_pico_ipv6_process_routing"] = function() { + return Module["asm"]["_pico_ipv6_process_routing"].apply(null, arguments) + }; + + var _pico_ipv6_route_add = Module["_pico_ipv6_route_add"] = function() { + return Module["asm"]["_pico_ipv6_route_add"].apply(null, arguments) + }; + + var _pico_ipv6_route_del = Module["_pico_ipv6_route_del"] = function() { + return Module["asm"]["_pico_ipv6_route_del"].apply(null, arguments) + }; + + var _pico_ipv6_route_find = Module["_pico_ipv6_route_find"] = function() { + return Module["asm"]["_pico_ipv6_route_find"].apply(null, arguments) + }; + + var _pico_ipv6_route_get_gateway = Module["_pico_ipv6_route_get_gateway"] = function() { + return Module["asm"]["_pico_ipv6_route_get_gateway"].apply(null, arguments) + }; + + var _pico_ipv6_router_down = Module["_pico_ipv6_router_down"] = function() { + return Module["asm"]["_pico_ipv6_router_down"].apply(null, arguments) + }; + + var _pico_ipv6_sitelocal_get = Module["_pico_ipv6_sitelocal_get"] = function() { + return Module["asm"]["_pico_ipv6_sitelocal_get"].apply(null, arguments) + }; + + var _pico_ipv6_source_dev_find = Module["_pico_ipv6_source_dev_find"] = function() { + return Module["asm"]["_pico_ipv6_source_dev_find"].apply(null, arguments) + }; + + var _pico_ipv6_source_find = Module["_pico_ipv6_source_find"] = function() { + return Module["asm"]["_pico_ipv6_source_find"].apply(null, arguments) + }; + + var _pico_ipv6_to_string = Module["_pico_ipv6_to_string"] = function() { + return Module["asm"]["_pico_ipv6_to_string"].apply(null, arguments) + }; + + var _pico_ipv6_unreachable = Module["_pico_ipv6_unreachable"] = function() { + return Module["asm"]["_pico_ipv6_unreachable"].apply(null, arguments) + }; + + var _pico_is_digit = Module["_pico_is_digit"] = function() { + return Module["asm"]["_pico_is_digit"].apply(null, arguments) + }; + + var _pico_is_hex = Module["_pico_is_hex"] = function() { + return Module["asm"]["_pico_is_hex"].apply(null, arguments) + }; + + var _pico_is_port_free = Module["_pico_is_port_free"] = function() { + return Module["asm"]["_pico_is_port_free"].apply(null, arguments) + }; + + var _pico_js_create = Module["_pico_js_create"] = function() { + return Module["asm"]["_pico_js_create"].apply(null, arguments) + }; + + var _pico_js_poll = Module["_pico_js_poll"] = function() { + return Module["asm"]["_pico_js_poll"].apply(null, arguments) + }; + + var _pico_js_send = Module["_pico_js_send"] = function() { + return Module["asm"]["_pico_js_send"].apply(null, arguments) + }; + + var _pico_mcast_filter_excl_excl = Module["_pico_mcast_filter_excl_excl"] = function() { + return Module["asm"]["_pico_mcast_filter_excl_excl"].apply(null, arguments) + }; + + var _pico_mcast_filter_excl_incl = Module["_pico_mcast_filter_excl_incl"] = function() { + return Module["asm"]["_pico_mcast_filter_excl_incl"].apply(null, arguments) + }; + + var _pico_mcast_filter_incl_excl = Module["_pico_mcast_filter_incl_excl"] = function() { + return Module["asm"]["_pico_mcast_filter_incl_excl"].apply(null, arguments) + }; + + var _pico_mcast_filter_incl_incl = Module["_pico_mcast_filter_incl_incl"] = function() { + return Module["asm"]["_pico_mcast_filter_incl_incl"].apply(null, arguments) + }; + + var _pico_mcast_generate_filter = Module["_pico_mcast_generate_filter"] = function() { + return Module["asm"]["_pico_mcast_generate_filter"].apply(null, arguments) + }; + + var _pico_mcast_src_filtering_cleanup = Module["_pico_mcast_src_filtering_cleanup"] = function() { + return Module["asm"]["_pico_mcast_src_filtering_cleanup"].apply(null, arguments) + }; + + var _pico_mcast_src_filtering_excl_excl = Module["_pico_mcast_src_filtering_excl_excl"] = function() { + return Module["asm"]["_pico_mcast_src_filtering_excl_excl"].apply(null, arguments) + }; + + var _pico_mcast_src_filtering_excl_inc = Module["_pico_mcast_src_filtering_excl_inc"] = function() { + return Module["asm"]["_pico_mcast_src_filtering_excl_inc"].apply(null, arguments) + }; + + var _pico_mcast_src_filtering_inc_excl = Module["_pico_mcast_src_filtering_inc_excl"] = function() { + return Module["asm"]["_pico_mcast_src_filtering_inc_excl"].apply(null, arguments) + }; + + var _pico_mcast_src_filtering_inc_inc = Module["_pico_mcast_src_filtering_inc_inc"] = function() { + return Module["asm"]["_pico_mcast_src_filtering_inc_inc"].apply(null, arguments) + }; + + var _pico_mld_analyse_packet = Module["_pico_mld_analyse_packet"] = function() { + return Module["asm"]["_pico_mld_analyse_packet"].apply(null, arguments) + }; + + var _pico_mld_check_hopbyhop = Module["_pico_mld_check_hopbyhop"] = function() { + return Module["asm"]["_pico_mld_check_hopbyhop"].apply(null, arguments) + }; + + var _pico_mld_checksum = Module["_pico_mld_checksum"] = function() { + return Module["asm"]["_pico_mld_checksum"].apply(null, arguments) + }; + + var _pico_mld_compatibility_mode = Module["_pico_mld_compatibility_mode"] = function() { + return Module["asm"]["_pico_mld_compatibility_mode"].apply(null, arguments) + }; + + var _pico_mld_delete_parameter = Module["_pico_mld_delete_parameter"] = function() { + return Module["asm"]["_pico_mld_delete_parameter"].apply(null, arguments) + }; + + var _pico_mld_fill_hopbyhop = Module["_pico_mld_fill_hopbyhop"] = function() { + return Module["asm"]["_pico_mld_fill_hopbyhop"].apply(null, arguments) + }; + + var _pico_mld_find_parameter = Module["_pico_mld_find_parameter"] = function() { + return Module["asm"]["_pico_mld_find_parameter"].apply(null, arguments) + }; + + var _pico_mld_find_timer = Module["_pico_mld_find_timer"] = function() { + return Module["asm"]["_pico_mld_find_timer"].apply(null, arguments) + }; + + var _pico_mld_generate_report = Module["_pico_mld_generate_report"] = function() { + return Module["asm"]["_pico_mld_generate_report"].apply(null, arguments) + }; + + var _pico_mld_is_checksum_valid = Module["_pico_mld_is_checksum_valid"] = function() { + return Module["asm"]["_pico_mld_is_checksum_valid"].apply(null, arguments) + }; + + var _pico_mld_process_event = Module["_pico_mld_process_event"] = function() { + return Module["asm"]["_pico_mld_process_event"].apply(null, arguments) + }; + + var _pico_mld_process_in = Module["_pico_mld_process_in"] = function() { + return Module["asm"]["_pico_mld_process_in"].apply(null, arguments) + }; + + var _pico_mld_report_expired = Module["_pico_mld_report_expired"] = function() { + return Module["asm"]["_pico_mld_report_expired"].apply(null, arguments) + }; + + var _pico_mld_send_done = Module["_pico_mld_send_done"] = function() { + return Module["asm"]["_pico_mld_send_done"].apply(null, arguments) + }; + + var _pico_mld_send_report = Module["_pico_mld_send_report"] = function() { + return Module["asm"]["_pico_mld_send_report"].apply(null, arguments) + }; + + var _pico_mld_state_change = Module["_pico_mld_state_change"] = function() { + return Module["asm"]["_pico_mld_state_change"].apply(null, arguments) + }; + + var _pico_mld_timer_expired = Module["_pico_mld_timer_expired"] = function() { + return Module["asm"]["_pico_mld_timer_expired"].apply(null, arguments) + }; + + var _pico_mld_timer_is_running = Module["_pico_mld_timer_is_running"] = function() { + return Module["asm"]["_pico_mld_timer_is_running"].apply(null, arguments) + }; + + var _pico_mld_timer_reset = Module["_pico_mld_timer_reset"] = function() { + return Module["asm"]["_pico_mld_timer_reset"].apply(null, arguments) + }; + + var _pico_mld_timer_start = Module["_pico_mld_timer_start"] = function() { + return Module["asm"]["_pico_mld_timer_start"].apply(null, arguments) + }; + + var _pico_mld_timer_stop = Module["_pico_mld_timer_stop"] = function() { + return Module["asm"]["_pico_mld_timer_stop"].apply(null, arguments) + }; + + var _pico_mld_v1querier_expired = Module["_pico_mld_v1querier_expired"] = function() { + return Module["asm"]["_pico_mld_v1querier_expired"].apply(null, arguments) + }; + + var _pico_mldv1_generate_report = Module["_pico_mldv1_generate_report"] = function() { + return Module["asm"]["_pico_mldv1_generate_report"].apply(null, arguments) + }; + + var _pico_mldv2_generate_filter = Module["_pico_mldv2_generate_filter"] = function() { + return Module["asm"]["_pico_mldv2_generate_filter"].apply(null, arguments) + }; + + var _pico_mldv2_generate_report = Module["_pico_mldv2_generate_report"] = function() { + return Module["asm"]["_pico_mldv2_generate_report"].apply(null, arguments) + }; + + var _pico_multicast_delete = Module["_pico_multicast_delete"] = function() { + return Module["asm"]["_pico_multicast_delete"].apply(null, arguments) + }; + + var _pico_nat_generate_tuple_trans = Module["_pico_nat_generate_tuple_trans"] = function() { + return Module["asm"]["_pico_nat_generate_tuple_trans"].apply(null, arguments) + }; + + var _pico_nd_add = Module["_pico_nd_add"] = function() { + return Module["asm"]["_pico_nd_add"].apply(null, arguments) + }; + + var _pico_nd_discover = Module["_pico_nd_discover"] = function() { + return Module["asm"]["_pico_nd_discover"].apply(null, arguments) + }; + + var _pico_nd_find_neighbor = Module["_pico_nd_find_neighbor"] = function() { + return Module["asm"]["_pico_nd_find_neighbor"].apply(null, arguments) + }; + + var _pico_nd_get = Module["_pico_nd_get"] = function() { + return Module["asm"]["_pico_nd_get"].apply(null, arguments) + }; + + var _pico_nd_get_neighbor = Module["_pico_nd_get_neighbor"] = function() { + return Module["asm"]["_pico_nd_get_neighbor"].apply(null, arguments) + }; + + var _pico_nd_neigh_adv_recv = Module["_pico_nd_neigh_adv_recv"] = function() { + return Module["asm"]["_pico_nd_neigh_adv_recv"].apply(null, arguments) + }; + + var _pico_nd_neigh_sol_recv = Module["_pico_nd_neigh_sol_recv"] = function() { + return Module["asm"]["_pico_nd_neigh_sol_recv"].apply(null, arguments) + }; + + var _pico_nd_new_expire_time = Module["_pico_nd_new_expire_time"] = function() { + return Module["asm"]["_pico_nd_new_expire_time"].apply(null, arguments) + }; + + var _pico_nd_redirect_recv = Module["_pico_nd_redirect_recv"] = function() { + return Module["asm"]["_pico_nd_redirect_recv"].apply(null, arguments) + }; + + var _pico_nd_router_adv_recv = Module["_pico_nd_router_adv_recv"] = function() { + return Module["asm"]["_pico_nd_router_adv_recv"].apply(null, arguments) + }; + + var _pico_nd_router_sol_recv = Module["_pico_nd_router_sol_recv"] = function() { + return Module["asm"]["_pico_nd_router_sol_recv"].apply(null, arguments) + }; + + var _pico_network_receive = Module["_pico_network_receive"] = function() { + return Module["asm"]["_pico_network_receive"].apply(null, arguments) + }; + + var _pico_network_send = Module["_pico_network_send"] = function() { + return Module["asm"]["_pico_network_send"].apply(null, arguments) + }; + + var _pico_notify_dest_unreachable = Module["_pico_notify_dest_unreachable"] = function() { + return Module["asm"]["_pico_notify_dest_unreachable"].apply(null, arguments) + }; + + var _pico_notify_frag_expired = Module["_pico_notify_frag_expired"] = function() { + return Module["asm"]["_pico_notify_frag_expired"].apply(null, arguments) + }; + + var _pico_notify_pkt_too_big = Module["_pico_notify_pkt_too_big"] = function() { + return Module["asm"]["_pico_notify_pkt_too_big"].apply(null, arguments) + }; + + var _pico_notify_proto_unreachable = Module["_pico_notify_proto_unreachable"] = function() { + return Module["asm"]["_pico_notify_proto_unreachable"].apply(null, arguments) + }; + + var _pico_notify_socket_unreachable = Module["_pico_notify_socket_unreachable"] = function() { + return Module["asm"]["_pico_notify_socket_unreachable"].apply(null, arguments) + }; + + var _pico_notify_ttl_expired = Module["_pico_notify_ttl_expired"] = function() { + return Module["asm"]["_pico_notify_ttl_expired"].apply(null, arguments) + }; + + var _pico_paws = Module["_pico_paws"] = function() { + return Module["asm"]["_pico_paws"].apply(null, arguments) + }; + + var _pico_port_in_use_by_nat = Module["_pico_port_in_use_by_nat"] = function() { + return Module["asm"]["_pico_port_in_use_by_nat"].apply(null, arguments) + }; + + var _pico_port_in_use_ipv4 = Module["_pico_port_in_use_ipv4"] = function() { + return Module["asm"]["_pico_port_in_use_ipv4"].apply(null, arguments) + }; + + var _pico_port_in_use_ipv6 = Module["_pico_port_in_use_ipv6"] = function() { + return Module["asm"]["_pico_port_in_use_ipv6"].apply(null, arguments) + }; + + var _pico_port_in_use_with_this_ipv4_address = Module["_pico_port_in_use_with_this_ipv4_address"] = function() { + return Module["asm"]["_pico_port_in_use_with_this_ipv4_address"].apply(null, arguments) + }; + + var _pico_port_in_use_with_this_ipv6_address = Module["_pico_port_in_use_with_this_ipv6_address"] = function() { + return Module["asm"]["_pico_port_in_use_with_this_ipv6_address"].apply(null, arguments) + }; + + var _pico_proto_cmp = Module["_pico_proto_cmp"] = function() { + return Module["asm"]["_pico_proto_cmp"].apply(null, arguments) + }; + + var _pico_protocol_datalink_loop = Module["_pico_protocol_datalink_loop"] = function() { + return Module["asm"]["_pico_protocol_datalink_loop"].apply(null, arguments) + }; + + var _pico_protocol_generic_loop = Module["_pico_protocol_generic_loop"] = function() { + return Module["asm"]["_pico_protocol_generic_loop"].apply(null, arguments) + }; + + var _pico_protocol_init = Module["_pico_protocol_init"] = function() { + return Module["asm"]["_pico_protocol_init"].apply(null, arguments) + }; + + var _pico_protocol_network_loop = Module["_pico_protocol_network_loop"] = function() { + return Module["asm"]["_pico_protocol_network_loop"].apply(null, arguments) + }; + + var _pico_protocol_socket_loop = Module["_pico_protocol_socket_loop"] = function() { + return Module["asm"]["_pico_protocol_socket_loop"].apply(null, arguments) + }; + + var _pico_protocol_transport_loop = Module["_pico_protocol_transport_loop"] = function() { + return Module["asm"]["_pico_protocol_transport_loop"].apply(null, arguments) + }; + + var _pico_queue_peek = Module["_pico_queue_peek"] = function() { + return Module["asm"]["_pico_queue_peek"].apply(null, arguments) + }; + + var _pico_queue_peek_167 = Module["_pico_queue_peek_167"] = function() { + return Module["asm"]["_pico_queue_peek_167"].apply(null, arguments) + }; + + var _pico_rand = Module["_pico_rand"] = function() { + return Module["asm"]["_pico_rand"].apply(null, arguments) + }; + + var _pico_rand_feed = Module["_pico_rand_feed"] = function() { + return Module["asm"]["_pico_rand_feed"].apply(null, arguments) + }; + + var _pico_sendto_dev = Module["_pico_sendto_dev"] = function() { + return Module["asm"]["_pico_sendto_dev"].apply(null, arguments) + }; + + var _pico_seq_compare = Module["_pico_seq_compare"] = function() { + return Module["asm"]["_pico_seq_compare"].apply(null, arguments) + }; + + var _pico_socket_accept = Module["_pico_socket_accept"] = function() { + return Module["asm"]["_pico_socket_accept"].apply(null, arguments) + }; + + var _pico_socket_adapt_mss_to_proto = Module["_pico_socket_adapt_mss_to_proto"] = function() { + return Module["asm"]["_pico_socket_adapt_mss_to_proto"].apply(null, arguments) + }; + + var _pico_socket_add = Module["_pico_socket_add"] = function() { + return Module["asm"]["_pico_socket_add"].apply(null, arguments) + }; + + var _pico_socket_aggregate_mcastfilters = Module["_pico_socket_aggregate_mcastfilters"] = function() { + return Module["asm"]["_pico_socket_aggregate_mcastfilters"].apply(null, arguments) + }; + + var _pico_socket_alter_state = Module["_pico_socket_alter_state"] = function() { + return Module["asm"]["_pico_socket_alter_state"].apply(null, arguments) + }; + + var _pico_socket_bind = Module["_pico_socket_bind"] = function() { + return Module["asm"]["_pico_socket_bind"].apply(null, arguments) + }; + + var _pico_socket_check_empty_sockport = Module["_pico_socket_check_empty_sockport"] = function() { + return Module["asm"]["_pico_socket_check_empty_sockport"].apply(null, arguments) + }; + + var _pico_socket_clone = Module["_pico_socket_clone"] = function() { + return Module["asm"]["_pico_socket_clone"].apply(null, arguments) + }; + + var _pico_socket_clone_assign_address = Module["_pico_socket_clone_assign_address"] = function() { + return Module["asm"]["_pico_socket_clone_assign_address"].apply(null, arguments) + }; + + var _pico_socket_close = Module["_pico_socket_close"] = function() { + return Module["asm"]["_pico_socket_close"].apply(null, arguments) + }; + + var _pico_socket_connect = Module["_pico_socket_connect"] = function() { + return Module["asm"]["_pico_socket_connect"].apply(null, arguments) + }; + + var _pico_socket_del = Module["_pico_socket_del"] = function() { + return Module["asm"]["_pico_socket_del"].apply(null, arguments) + }; + + var _pico_socket_deliver = Module["_pico_socket_deliver"] = function() { + return Module["asm"]["_pico_socket_deliver"].apply(null, arguments) + }; + + var _pico_socket_final_xmit = Module["_pico_socket_final_xmit"] = function() { + return Module["asm"]["_pico_socket_final_xmit"].apply(null, arguments) + }; + + var _pico_socket_frame_alloc = Module["_pico_socket_frame_alloc"] = function() { + return Module["asm"]["_pico_socket_frame_alloc"].apply(null, arguments) + }; + + var _pico_socket_get_mss = Module["_pico_socket_get_mss"] = function() { + return Module["asm"]["_pico_socket_get_mss"].apply(null, arguments) + }; + + var _pico_socket_high_port = Module["_pico_socket_high_port"] = function() { + return Module["asm"]["_pico_socket_high_port"].apply(null, arguments) + }; + + var _pico_socket_listen = Module["_pico_socket_listen"] = function() { + return Module["asm"]["_pico_socket_listen"].apply(null, arguments) + }; + + var _pico_socket_mcast_filter = Module["_pico_socket_mcast_filter"] = function() { + return Module["asm"]["_pico_socket_mcast_filter"].apply(null, arguments) + }; + + var _pico_socket_mcast_filter_exclude = Module["_pico_socket_mcast_filter_exclude"] = function() { + return Module["asm"]["_pico_socket_mcast_filter_exclude"].apply(null, arguments) + }; + + var _pico_socket_mcast_filter_include = Module["_pico_socket_mcast_filter_include"] = function() { + return Module["asm"]["_pico_socket_mcast_filter_include"].apply(null, arguments) + }; + + var _pico_socket_mcast_filter_link_get = Module["_pico_socket_mcast_filter_link_get"] = function() { + return Module["asm"]["_pico_socket_mcast_filter_link_get"].apply(null, arguments) + }; + + var _pico_socket_mcast_source_filtering = Module["_pico_socket_mcast_source_filtering"] = function() { + return Module["asm"]["_pico_socket_mcast_source_filtering"].apply(null, arguments) + }; + + var _pico_socket_open = Module["_pico_socket_open"] = function() { + return Module["asm"]["_pico_socket_open"].apply(null, arguments) + }; + + var _pico_socket_read = Module["_pico_socket_read"] = function() { + return Module["asm"]["_pico_socket_read"].apply(null, arguments) + }; + + var _pico_socket_recvfrom = Module["_pico_socket_recvfrom"] = function() { + return Module["asm"]["_pico_socket_recvfrom"].apply(null, arguments) + }; + + var _pico_socket_recvfrom_extended = Module["_pico_socket_recvfrom_extended"] = function() { + return Module["asm"]["_pico_socket_recvfrom_extended"].apply(null, arguments) + }; + + var _pico_socket_send = Module["_pico_socket_send"] = function() { + return Module["asm"]["_pico_socket_send"].apply(null, arguments) + }; + + var _pico_socket_sendto = Module["_pico_socket_sendto"] = function() { + return Module["asm"]["_pico_socket_sendto"].apply(null, arguments) + }; + + var _pico_socket_sendto_dest_check = Module["_pico_socket_sendto_dest_check"] = function() { + return Module["asm"]["_pico_socket_sendto_dest_check"].apply(null, arguments) + }; + + var _pico_socket_sendto_destination = Module["_pico_socket_sendto_destination"] = function() { + return Module["asm"]["_pico_socket_sendto_destination"].apply(null, arguments) + }; + + var _pico_socket_sendto_destination_ipv4 = Module["_pico_socket_sendto_destination_ipv4"] = function() { + return Module["asm"]["_pico_socket_sendto_destination_ipv4"].apply(null, arguments) + }; + + var _pico_socket_sendto_destination_ipv6 = Module["_pico_socket_sendto_destination_ipv6"] = function() { + return Module["asm"]["_pico_socket_sendto_destination_ipv6"].apply(null, arguments) + }; + + var _pico_socket_sendto_extended = Module["_pico_socket_sendto_extended"] = function() { + return Module["asm"]["_pico_socket_sendto_extended"].apply(null, arguments) + }; + + var _pico_socket_sendto_get_ip4_src = Module["_pico_socket_sendto_get_ip4_src"] = function() { + return Module["asm"]["_pico_socket_sendto_get_ip4_src"].apply(null, arguments) + }; + + var _pico_socket_sendto_get_ip6_src = Module["_pico_socket_sendto_get_ip6_src"] = function() { + return Module["asm"]["_pico_socket_sendto_get_ip6_src"].apply(null, arguments) + }; + + var _pico_socket_sendto_get_src = Module["_pico_socket_sendto_get_src"] = function() { + return Module["asm"]["_pico_socket_sendto_get_src"].apply(null, arguments) + }; + + var _pico_socket_sendto_initial_checks = Module["_pico_socket_sendto_initial_checks"] = function() { + return Module["asm"]["_pico_socket_sendto_initial_checks"].apply(null, arguments) + }; + + var _pico_socket_sendto_set_dport = Module["_pico_socket_sendto_set_dport"] = function() { + return Module["asm"]["_pico_socket_sendto_set_dport"].apply(null, arguments) + }; + + var _pico_socket_sendto_set_localport = Module["_pico_socket_sendto_set_localport"] = function() { + return Module["asm"]["_pico_socket_sendto_set_localport"].apply(null, arguments) + }; + + var _pico_socket_sendto_transport_offset = Module["_pico_socket_sendto_transport_offset"] = function() { + return Module["asm"]["_pico_socket_sendto_transport_offset"].apply(null, arguments) + }; + + var _pico_socket_set_family = Module["_pico_socket_set_family"] = function() { + return Module["asm"]["_pico_socket_set_family"].apply(null, arguments) + }; + + var _pico_socket_set_info = Module["_pico_socket_set_info"] = function() { + return Module["asm"]["_pico_socket_set_info"].apply(null, arguments) + }; + + var _pico_socket_shutdown = Module["_pico_socket_shutdown"] = function() { + return Module["asm"]["_pico_socket_shutdown"].apply(null, arguments) + }; + + var _pico_socket_tcp_cleanup = Module["_pico_socket_tcp_cleanup"] = function() { + return Module["asm"]["_pico_socket_tcp_cleanup"].apply(null, arguments) + }; + + var _pico_socket_tcp_delete = Module["_pico_socket_tcp_delete"] = function() { + return Module["asm"]["_pico_socket_tcp_delete"].apply(null, arguments) + }; + + var _pico_socket_tcp_deliver = Module["_pico_socket_tcp_deliver"] = function() { + return Module["asm"]["_pico_socket_tcp_deliver"].apply(null, arguments) + }; + + var _pico_socket_tcp_open = Module["_pico_socket_tcp_open"] = function() { + return Module["asm"]["_pico_socket_tcp_open"].apply(null, arguments) + }; + + var _pico_socket_tcp_read = Module["_pico_socket_tcp_read"] = function() { + return Module["asm"]["_pico_socket_tcp_read"].apply(null, arguments) + }; + + var _pico_socket_transport_deliver = Module["_pico_socket_transport_deliver"] = function() { + return Module["asm"]["_pico_socket_transport_deliver"].apply(null, arguments) + }; + + var _pico_socket_transport_open = Module["_pico_socket_transport_open"] = function() { + return Module["asm"]["_pico_socket_transport_open"].apply(null, arguments) + }; + + var _pico_socket_transport_read = Module["_pico_socket_transport_read"] = function() { + return Module["asm"]["_pico_socket_transport_read"].apply(null, arguments) + }; + + var _pico_socket_udp_deliver = Module["_pico_socket_udp_deliver"] = function() { + return Module["asm"]["_pico_socket_udp_deliver"].apply(null, arguments) + }; + + var _pico_socket_udp_deliver_ipv4 = Module["_pico_socket_udp_deliver_ipv4"] = function() { + return Module["asm"]["_pico_socket_udp_deliver_ipv4"].apply(null, arguments) + }; + + var _pico_socket_udp_deliver_ipv4_mcast = Module["_pico_socket_udp_deliver_ipv4_mcast"] = function() { + return Module["asm"]["_pico_socket_udp_deliver_ipv4_mcast"].apply(null, arguments) + }; + + var _pico_socket_udp_deliver_ipv4_mcast_initial_checks = Module["_pico_socket_udp_deliver_ipv4_mcast_initial_checks"] = function() { + return Module["asm"]["_pico_socket_udp_deliver_ipv4_mcast_initial_checks"].apply(null, arguments) + }; + + var _pico_socket_udp_deliver_ipv4_unicast = Module["_pico_socket_udp_deliver_ipv4_unicast"] = function() { + return Module["asm"]["_pico_socket_udp_deliver_ipv4_unicast"].apply(null, arguments) + }; + + var _pico_socket_udp_deliver_ipv6 = Module["_pico_socket_udp_deliver_ipv6"] = function() { + return Module["asm"]["_pico_socket_udp_deliver_ipv6"].apply(null, arguments) + }; + + var _pico_socket_udp_deliver_ipv6_mcast = Module["_pico_socket_udp_deliver_ipv6_mcast"] = function() { + return Module["asm"]["_pico_socket_udp_deliver_ipv6_mcast"].apply(null, arguments) + }; + + var _pico_socket_udp_open = Module["_pico_socket_udp_open"] = function() { + return Module["asm"]["_pico_socket_udp_open"].apply(null, arguments) + }; + + var _pico_socket_update_tcp_state = Module["_pico_socket_update_tcp_state"] = function() { + return Module["asm"]["_pico_socket_update_tcp_state"].apply(null, arguments) + }; + + var _pico_socket_write = Module["_pico_socket_write"] = function() { + return Module["asm"]["_pico_socket_write"].apply(null, arguments) + }; + + var _pico_socket_write_attempt = Module["_pico_socket_write_attempt"] = function() { + return Module["asm"]["_pico_socket_write_attempt"].apply(null, arguments) + }; + + var _pico_socket_write_check_state = Module["_pico_socket_write_check_state"] = function() { + return Module["asm"]["_pico_socket_write_check_state"].apply(null, arguments) + }; + + var _pico_socket_xmit = Module["_pico_socket_xmit"] = function() { + return Module["asm"]["_pico_socket_xmit"].apply(null, arguments) + }; + + var _pico_socket_xmit_avail_space = Module["_pico_socket_xmit_avail_space"] = function() { + return Module["asm"]["_pico_socket_xmit_avail_space"].apply(null, arguments) + }; + + var _pico_socket_xmit_first_fragment_setup = Module["_pico_socket_xmit_first_fragment_setup"] = function() { + return Module["asm"]["_pico_socket_xmit_first_fragment_setup"].apply(null, arguments) + }; + + var _pico_socket_xmit_fragments = Module["_pico_socket_xmit_fragments"] = function() { + return Module["asm"]["_pico_socket_xmit_fragments"].apply(null, arguments) + }; + + var _pico_socket_xmit_next_fragment_setup = Module["_pico_socket_xmit_next_fragment_setup"] = function() { + return Module["asm"]["_pico_socket_xmit_next_fragment_setup"].apply(null, arguments) + }; + + var _pico_socket_xmit_one = Module["_pico_socket_xmit_one"] = function() { + return Module["asm"]["_pico_socket_xmit_one"].apply(null, arguments) + }; + + var _pico_sockets_loop = Module["_pico_sockets_loop"] = function() { + return Module["asm"]["_pico_sockets_loop"].apply(null, arguments) + }; + + var _pico_sockets_loop_tcp = Module["_pico_sockets_loop_tcp"] = function() { + return Module["asm"]["_pico_sockets_loop_tcp"].apply(null, arguments) + }; + + var _pico_sockets_loop_udp = Module["_pico_sockets_loop_udp"] = function() { + return Module["asm"]["_pico_sockets_loop_udp"].apply(null, arguments) + }; + + var _pico_source_is_local = Module["_pico_source_is_local"] = function() { + return Module["asm"]["_pico_source_is_local"].apply(null, arguments) + }; + + var _pico_stack_init = Module["_pico_stack_init"] = function() { + return Module["asm"]["_pico_stack_init"].apply(null, arguments) + }; + + var _pico_stack_recv = Module["_pico_stack_recv"] = function() { + return Module["asm"]["_pico_stack_recv"].apply(null, arguments) + }; + + var _pico_stack_recv_new_frame = Module["_pico_stack_recv_new_frame"] = function() { + return Module["asm"]["_pico_stack_recv_new_frame"].apply(null, arguments) + }; + + var _pico_stack_recv_zerocopy = Module["_pico_stack_recv_zerocopy"] = function() { + return Module["asm"]["_pico_stack_recv_zerocopy"].apply(null, arguments) + }; + + var _pico_stack_tick = Module["_pico_stack_tick"] = function() { + return Module["asm"]["_pico_stack_tick"].apply(null, arguments) + }; + + var _pico_store_network_origin = Module["_pico_store_network_origin"] = function() { + return Module["asm"]["_pico_store_network_origin"].apply(null, arguments) + }; + + var _pico_string_check_null_args = Module["_pico_string_check_null_args"] = function() { + return Module["asm"]["_pico_string_check_null_args"].apply(null, arguments) + }; + + var _pico_string_to_ipv4 = Module["_pico_string_to_ipv4"] = function() { + return Module["asm"]["_pico_string_to_ipv4"].apply(null, arguments) + }; + + var _pico_string_to_ipv6 = Module["_pico_string_to_ipv6"] = function() { + return Module["asm"]["_pico_string_to_ipv6"].apply(null, arguments) + }; + + var _pico_tcp_check_listen_close = Module["_pico_tcp_check_listen_close"] = function() { + return Module["asm"]["_pico_tcp_check_listen_close"].apply(null, arguments) + }; + + var _pico_tcp_checksum = Module["_pico_tcp_checksum"] = function() { + return Module["asm"]["_pico_tcp_checksum"].apply(null, arguments) + }; + + var _pico_tcp_checksum_ipv4 = Module["_pico_tcp_checksum_ipv4"] = function() { + return Module["asm"]["_pico_tcp_checksum_ipv4"].apply(null, arguments) + }; + + var _pico_tcp_checksum_ipv6 = Module["_pico_tcp_checksum_ipv6"] = function() { + return Module["asm"]["_pico_tcp_checksum_ipv6"].apply(null, arguments) + }; + + var _pico_tcp_cleanup_queues = Module["_pico_tcp_cleanup_queues"] = function() { + return Module["asm"]["_pico_tcp_cleanup_queues"].apply(null, arguments) + }; + + var _pico_tcp_flags_update = Module["_pico_tcp_flags_update"] = function() { + return Module["asm"]["_pico_tcp_flags_update"].apply(null, arguments) + }; + + var _pico_tcp_get_socket_mss = Module["_pico_tcp_get_socket_mss"] = function() { + return Module["asm"]["_pico_tcp_get_socket_mss"].apply(null, arguments) + }; + + var _pico_tcp_initconn = Module["_pico_tcp_initconn"] = function() { + return Module["asm"]["_pico_tcp_initconn"].apply(null, arguments) + }; + + var _pico_tcp_input = Module["_pico_tcp_input"] = function() { + return Module["asm"]["_pico_tcp_input"].apply(null, arguments) + }; + + var _pico_tcp_keepalive = Module["_pico_tcp_keepalive"] = function() { + return Module["asm"]["_pico_tcp_keepalive"].apply(null, arguments) + }; + + var _pico_tcp_notify_closing = Module["_pico_tcp_notify_closing"] = function() { + return Module["asm"]["_pico_tcp_notify_closing"].apply(null, arguments) + }; + + var _pico_tcp_open = Module["_pico_tcp_open"] = function() { + return Module["asm"]["_pico_tcp_open"].apply(null, arguments) + }; + + var _pico_tcp_output = Module["_pico_tcp_output"] = function() { + return Module["asm"]["_pico_tcp_output"].apply(null, arguments) + }; + + var _pico_tcp_overhead = Module["_pico_tcp_overhead"] = function() { + return Module["asm"]["_pico_tcp_overhead"].apply(null, arguments) + }; + + var _pico_tcp_process_out = Module["_pico_tcp_process_out"] = function() { + return Module["asm"]["_pico_tcp_process_out"].apply(null, arguments) + }; + + var _pico_tcp_push = Module["_pico_tcp_push"] = function() { + return Module["asm"]["_pico_tcp_push"].apply(null, arguments) + }; + + var _pico_tcp_push_nagle_enqueue = Module["_pico_tcp_push_nagle_enqueue"] = function() { + return Module["asm"]["_pico_tcp_push_nagle_enqueue"].apply(null, arguments) + }; + + var _pico_tcp_push_nagle_hold = Module["_pico_tcp_push_nagle_hold"] = function() { + return Module["asm"]["_pico_tcp_push_nagle_hold"].apply(null, arguments) + }; + + var _pico_tcp_push_nagle_on = Module["_pico_tcp_push_nagle_on"] = function() { + return Module["asm"]["_pico_tcp_push_nagle_on"].apply(null, arguments) + }; + + var _pico_tcp_queue_in_is_empty = Module["_pico_tcp_queue_in_is_empty"] = function() { + return Module["asm"]["_pico_tcp_queue_in_is_empty"].apply(null, arguments) + }; + + var _pico_tcp_read = Module["_pico_tcp_read"] = function() { + return Module["asm"]["_pico_tcp_read"].apply(null, arguments) + }; + + var _pico_tcp_reply_rst = Module["_pico_tcp_reply_rst"] = function() { + return Module["asm"]["_pico_tcp_reply_rst"].apply(null, arguments) + }; + + var _pico_timer_add = Module["_pico_timer_add"] = function() { + return Module["asm"]["_pico_timer_add"].apply(null, arguments) + }; + + var _pico_timer_cancel = Module["_pico_timer_cancel"] = function() { + return Module["asm"]["_pico_timer_cancel"].apply(null, arguments) + }; + + var _pico_timer_create = Module["_pico_timer_create"] = function() { + return Module["asm"]["_pico_timer_create"].apply(null, arguments) + }; + + var _pico_timer_ref_add = Module["_pico_timer_ref_add"] = function() { + return Module["asm"]["_pico_timer_ref_add"].apply(null, arguments) + }; + + var _pico_transport_crc_check = Module["_pico_transport_crc_check"] = function() { + return Module["asm"]["_pico_transport_crc_check"].apply(null, arguments) + }; + + var _pico_transport_error = Module["_pico_transport_error"] = function() { + return Module["asm"]["_pico_transport_error"].apply(null, arguments) + }; + + var _pico_transport_error_set_picoerr = Module["_pico_transport_error_set_picoerr"] = function() { + return Module["asm"]["_pico_transport_error_set_picoerr"].apply(null, arguments) + }; + + var _pico_transport_process_in = Module["_pico_transport_process_in"] = function() { + return Module["asm"]["_pico_transport_process_in"].apply(null, arguments) + }; + + var _pico_transport_receive = Module["_pico_transport_receive"] = function() { + return Module["asm"]["_pico_transport_receive"].apply(null, arguments) + }; + + var _pico_tree_delete = Module["_pico_tree_delete"] = function() { + return Module["asm"]["_pico_tree_delete"].apply(null, arguments) + }; + + var _pico_tree_delete_check_switch = Module["_pico_tree_delete_check_switch"] = function() { + return Module["asm"]["_pico_tree_delete_check_switch"].apply(null, arguments) + }; + + var _pico_tree_delete_implementation = Module["_pico_tree_delete_implementation"] = function() { + return Module["asm"]["_pico_tree_delete_implementation"].apply(null, arguments) + }; + + var _pico_tree_delete_node = Module["_pico_tree_delete_node"] = function() { + return Module["asm"]["_pico_tree_delete_node"].apply(null, arguments) + }; + + var _pico_tree_empty = Module["_pico_tree_empty"] = function() { + return Module["asm"]["_pico_tree_empty"].apply(null, arguments) + }; + + var _pico_tree_findKey = Module["_pico_tree_findKey"] = function() { + return Module["asm"]["_pico_tree_findKey"].apply(null, arguments) + }; + + var _pico_tree_findNode = Module["_pico_tree_findNode"] = function() { + return Module["asm"]["_pico_tree_findNode"].apply(null, arguments) + }; + + var _pico_tree_first = Module["_pico_tree_first"] = function() { + return Module["asm"]["_pico_tree_first"].apply(null, arguments) + }; + + var _pico_tree_firstNode = Module["_pico_tree_firstNode"] = function() { + return Module["asm"]["_pico_tree_firstNode"].apply(null, arguments) + }; + + var _pico_tree_insert = Module["_pico_tree_insert"] = function() { + return Module["asm"]["_pico_tree_insert"].apply(null, arguments) + }; + + var _pico_tree_insert_implementation = Module["_pico_tree_insert_implementation"] = function() { + return Module["asm"]["_pico_tree_insert_implementation"].apply(null, arguments) + }; + + var _pico_tree_insert_node = Module["_pico_tree_insert_node"] = function() { + return Module["asm"]["_pico_tree_insert_node"].apply(null, arguments) + }; + + var _pico_tree_lastNode = Module["_pico_tree_lastNode"] = function() { + return Module["asm"]["_pico_tree_lastNode"].apply(null, arguments) + }; + + var _pico_tree_next = Module["_pico_tree_next"] = function() { + return Module["asm"]["_pico_tree_next"].apply(null, arguments) + }; + + var _pico_tree_prev = Module["_pico_tree_prev"] = function() { + return Module["asm"]["_pico_tree_prev"].apply(null, arguments) + }; + + var _pico_udp_checksum_ipv4 = Module["_pico_udp_checksum_ipv4"] = function() { + return Module["asm"]["_pico_udp_checksum_ipv4"].apply(null, arguments) + }; + + var _pico_udp_checksum_ipv6 = Module["_pico_udp_checksum_ipv6"] = function() { + return Module["asm"]["_pico_udp_checksum_ipv6"].apply(null, arguments) + }; + + var _pico_udp_get_mc_ttl = Module["_pico_udp_get_mc_ttl"] = function() { + return Module["asm"]["_pico_udp_get_mc_ttl"].apply(null, arguments) + }; + + var _pico_udp_get_msginfo = Module["_pico_udp_get_msginfo"] = function() { + return Module["asm"]["_pico_udp_get_msginfo"].apply(null, arguments) + }; + + var _pico_udp_open = Module["_pico_udp_open"] = function() { + return Module["asm"]["_pico_udp_open"].apply(null, arguments) + }; + + var _pico_udp_process_out = Module["_pico_udp_process_out"] = function() { + return Module["asm"]["_pico_udp_process_out"].apply(null, arguments) + }; + + var _pico_udp_push = Module["_pico_udp_push"] = function() { + return Module["asm"]["_pico_udp_push"].apply(null, arguments) + }; + + var _pico_udp_recv = Module["_pico_udp_recv"] = function() { + return Module["asm"]["_pico_udp_recv"].apply(null, arguments) + }; + + var _pico_xmit_frame_set_nofrag = Module["_pico_xmit_frame_set_nofrag"] = function() { + return Module["asm"]["_pico_xmit_frame_set_nofrag"].apply(null, arguments) + }; + + var _ping_recv_reply = Module["_ping_recv_reply"] = function() { + return Module["asm"]["_ping_recv_reply"].apply(null, arguments) + }; + + var _ping_timeout = Module["_ping_timeout"] = function() { + return Module["asm"]["_ping_timeout"].apply(null, arguments) + }; + + var _pop_arg = Module["_pop_arg"] = function() { + return Module["asm"]["_pop_arg"].apply(null, arguments) + }; + + var _pop_arg_long_double = Module["_pop_arg_long_double"] = function() { + return Module["asm"]["_pop_arg_long_double"].apply(null, arguments) + }; + + var _printf = Module["_printf"] = function() { + return Module["asm"]["_printf"].apply(null, arguments) + }; + + var _printf_core = Module["_printf_core"] = function() { + return Module["asm"]["_printf_core"].apply(null, arguments) + }; + + var _proto_layer_rr_reset = Module["_proto_layer_rr_reset"] = function() { + return Module["asm"]["_proto_layer_rr_reset"].apply(null, arguments) + }; + + var _proto_loop = Module["_proto_loop"] = function() { + return Module["asm"]["_proto_loop"].apply(null, arguments) + }; + + var _proto_loop_in = Module["_proto_loop_in"] = function() { + return Module["asm"]["_proto_loop_in"].apply(null, arguments) + }; + + var _proto_loop_out = Module["_proto_loop_out"] = function() { + return Module["asm"]["_proto_loop_out"].apply(null, arguments) + }; + + var _pthread_self = Module["_pthread_self"] = function() { + return Module["asm"]["_pthread_self"].apply(null, arguments) + }; + + var _puts = Module["_puts"] = function() { + return Module["asm"]["_puts"].apply(null, arguments) + }; + + var _radv_process = Module["_radv_process"] = function() { + return Module["asm"]["_radv_process"].apply(null, arguments) + }; + + var _rebind = Module["_rebind"] = function() { + return Module["asm"]["_rebind"].apply(null, arguments) + }; + + var _recv_ack = Module["_recv_ack"] = function() { + return Module["asm"]["_recv_ack"].apply(null, arguments) + }; + + var _recv_offer = Module["_recv_offer"] = function() { + return Module["asm"]["_recv_offer"].apply(null, arguments) + }; + + var _release_all_until = Module["_release_all_until"] = function() { + return Module["asm"]["_release_all_until"].apply(null, arguments) + }; + + var _release_until = Module["_release_until"] = function() { + return Module["asm"]["_release_until"].apply(null, arguments) + }; + + var _renew = Module["_renew"] = function() { + return Module["asm"]["_renew"].apply(null, arguments) + }; + + var _reset = Module["_reset"] = function() { + return Module["asm"]["_reset"].apply(null, arguments) + }; + + var _retransmit = Module["_retransmit"] = function() { + return Module["asm"]["_retransmit"].apply(null, arguments) + }; + + var _rotateToLeft = Module["_rotateToLeft"] = function() { + return Module["asm"]["_rotateToLeft"].apply(null, arguments) + }; + + var _rotateToRight = Module["_rotateToRight"] = function() { + return Module["asm"]["_rotateToRight"].apply(null, arguments) + }; + + var _roundrobin_end = Module["_roundrobin_end"] = function() { + return Module["asm"]["_roundrobin_end"].apply(null, arguments) + }; + + var _roundrobin_init = Module["_roundrobin_init"] = function() { + return Module["asm"]["_roundrobin_init"].apply(null, arguments) + }; + + var _route_find = Module["_route_find"] = function() { + return Module["asm"]["_route_find"].apply(null, arguments) + }; + + var _router_adv_validity_checks = Module["_router_adv_validity_checks"] = function() { + return Module["asm"]["_router_adv_validity_checks"].apply(null, arguments) + }; + + var _rtimrtct = Module["_rtimrtct"] = function() { + return Module["asm"]["_rtimrtct"].apply(null, arguments) + }; + + var _rto_set = Module["_rto_set"] = function() { + return Module["asm"]["_rto_set"].apply(null, arguments) + }; + + var _sbrk = Module["_sbrk"] = function() { + return Module["asm"]["_sbrk"].apply(null, arguments) + }; + + var _segment_compare = Module["_segment_compare"] = function() { + return Module["asm"]["_segment_compare"].apply(null, arguments) + }; + + var _segment_from_frame = Module["_segment_from_frame"] = function() { + return Module["asm"]["_segment_from_frame"].apply(null, arguments) + }; + + var _send_ping = Module["_send_ping"] = function() { + return Module["asm"]["_send_ping"].apply(null, arguments) + }; + + var _short_be = Module["_short_be"] = function() { + return Module["asm"]["_short_be"].apply(null, arguments) + }; + + var _short_be_1 = Module["_short_be_1"] = function() { + return Module["asm"]["_short_be_1"].apply(null, arguments) + }; + + var _short_be_112 = Module["_short_be_112"] = function() { + return Module["asm"]["_short_be_112"].apply(null, arguments) + }; + + var _short_be_140 = Module["_short_be_140"] = function() { + return Module["asm"]["_short_be_140"].apply(null, arguments) + }; + + var _short_be_143 = Module["_short_be_143"] = function() { + return Module["asm"]["_short_be_143"].apply(null, arguments) + }; + + var _short_be_150 = Module["_short_be_150"] = function() { + return Module["asm"]["_short_be_150"].apply(null, arguments) + }; + + var _short_be_156 = Module["_short_be_156"] = function() { + return Module["asm"]["_short_be_156"].apply(null, arguments) + }; + + var _short_be_178 = Module["_short_be_178"] = function() { + return Module["asm"]["_short_be_178"].apply(null, arguments) + }; + + var _short_be_209 = Module["_short_be_209"] = function() { + return Module["asm"]["_short_be_209"].apply(null, arguments) + }; + + var _short_be_309 = Module["_short_be_309"] = function() { + return Module["asm"]["_short_be_309"].apply(null, arguments) + }; + + var _short_be_33 = Module["_short_be_33"] = function() { + return Module["asm"]["_short_be_33"].apply(null, arguments) + }; + + var _short_be_336 = Module["_short_be_336"] = function() { + return Module["asm"]["_short_be_336"].apply(null, arguments) + }; + + var _short_be_36 = Module["_short_be_36"] = function() { + return Module["asm"]["_short_be_36"].apply(null, arguments) + }; + + var _short_be_367 = Module["_short_be_367"] = function() { + return Module["asm"]["_short_be_367"].apply(null, arguments) + }; + + var _short_be_373 = Module["_short_be_373"] = function() { + return Module["asm"]["_short_be_373"].apply(null, arguments) + }; + + var _short_be_38 = Module["_short_be_38"] = function() { + return Module["asm"]["_short_be_38"].apply(null, arguments) + }; + + var _short_be_59 = Module["_short_be_59"] = function() { + return Module["asm"]["_short_be_59"].apply(null, arguments) + }; + + var _short_be_65 = Module["_short_be_65"] = function() { + return Module["asm"]["_short_be_65"].apply(null, arguments) + }; + + var _short_be_74 = Module["_short_be_74"] = function() { + return Module["asm"]["_short_be_74"].apply(null, arguments) + }; + + var _short_from = Module["_short_from"] = function() { + return Module["asm"]["_short_from"].apply(null, arguments) + }; + + var _short_from_153 = Module["_short_from_153"] = function() { + return Module["asm"]["_short_from_153"].apply(null, arguments) + }; + + var _slifs = Module["_slifs"] = function() { + return Module["asm"]["_slifs"].apply(null, arguments) + }; + + var _socket_clean_queues = Module["_socket_clean_queues"] = function() { + return Module["asm"]["_socket_clean_queues"].apply(null, arguments) + }; + + var _socket_cmp = Module["_socket_cmp"] = function() { + return Module["asm"]["_socket_cmp"].apply(null, arguments) + }; + + var _socket_cmp_addresses = Module["_socket_cmp_addresses"] = function() { + return Module["asm"]["_socket_cmp_addresses"].apply(null, arguments) + }; + + var _socket_cmp_family = Module["_socket_cmp_family"] = function() { + return Module["asm"]["_socket_cmp_family"].apply(null, arguments) + }; + + var _socket_cmp_ipv4 = Module["_socket_cmp_ipv4"] = function() { + return Module["asm"]["_socket_cmp_ipv4"].apply(null, arguments) + }; + + var _socket_cmp_ipv6 = Module["_socket_cmp_ipv6"] = function() { + return Module["asm"]["_socket_cmp_ipv6"].apply(null, arguments) + }; + + var _socket_cmp_remotehost = Module["_socket_cmp_remotehost"] = function() { + return Module["asm"]["_socket_cmp_remotehost"].apply(null, arguments) + }; + + var _socket_garbage_collect = Module["_socket_garbage_collect"] = function() { + return Module["asm"]["_socket_garbage_collect"].apply(null, arguments) + }; + + var _socket_tcp_deliver_ipv4 = Module["_socket_tcp_deliver_ipv4"] = function() { + return Module["asm"]["_socket_tcp_deliver_ipv4"].apply(null, arguments) + }; + + var _socket_tcp_deliver_ipv6 = Module["_socket_tcp_deliver_ipv6"] = function() { + return Module["asm"]["_socket_tcp_deliver_ipv6"].apply(null, arguments) + }; + + var _socket_tcp_do_deliver = Module["_socket_tcp_do_deliver"] = function() { + return Module["asm"]["_socket_tcp_do_deliver"].apply(null, arguments) + }; + + var _sockport_cmp = Module["_sockport_cmp"] = function() { + return Module["asm"]["_sockport_cmp"].apply(null, arguments) + }; + + var _srsf = Module["_srsf"] = function() { + return Module["asm"]["_srsf"].apply(null, arguments) + }; + + var _srsfst = Module["_srsfst"] = function() { + return Module["asm"]["_srsfst"].apply(null, arguments) + }; + + var _srst = Module["_srst"] = function() { + return Module["asm"]["_srst"].apply(null, arguments) + }; + + var _st = Module["_st"] = function() { + return Module["asm"]["_st"].apply(null, arguments) + }; + + var _stcl = Module["_stcl"] = function() { + return Module["asm"]["_stcl"].apply(null, arguments) + }; + + var _strcasecmp = Module["_strcasecmp"] = function() { + return Module["asm"]["_strcasecmp"].apply(null, arguments) + }; + + var _strcmp = Module["_strcmp"] = function() { + return Module["asm"]["_strcmp"].apply(null, arguments) + }; + + var _strlen = Module["_strlen"] = function() { + return Module["asm"]["_strlen"].apply(null, arguments) + }; + + var _strncpy = Module["_strncpy"] = function() { + return Module["asm"]["_strncpy"].apply(null, arguments) + }; + + var _stslifs = Module["_stslifs"] = function() { + return Module["asm"]["_stslifs"].apply(null, arguments) + }; + + var _switchNodes = Module["_switchNodes"] = function() { + return Module["asm"]["_switchNodes"].apply(null, arguments) + }; + + var _tcp_ack = Module["_tcp_ack"] = function() { + return Module["asm"]["_tcp_ack"].apply(null, arguments) + }; + + var _tcp_ack_advance_una = Module["_tcp_ack_advance_una"] = function() { + return Module["asm"]["_tcp_ack_advance_una"].apply(null, arguments) + }; + + var _tcp_action_by_flags = Module["_tcp_action_by_flags"] = function() { + return Module["asm"]["_tcp_action_by_flags"].apply(null, arguments) + }; + + var _tcp_action_call = Module["_tcp_action_call"] = function() { + return Module["asm"]["_tcp_action_call"].apply(null, arguments) + }; + + var _tcp_add_header = Module["_tcp_add_header"] = function() { + return Module["asm"]["_tcp_add_header"].apply(null, arguments) + }; + + var _tcp_add_options = Module["_tcp_add_options"] = function() { + return Module["asm"]["_tcp_add_options"].apply(null, arguments) + }; + + var _tcp_add_options_frame = Module["_tcp_add_options_frame"] = function() { + return Module["asm"]["_tcp_add_options_frame"].apply(null, arguments) + }; + + var _tcp_add_sack_option = Module["_tcp_add_sack_option"] = function() { + return Module["asm"]["_tcp_add_sack_option"].apply(null, arguments) + }; + + var _tcp_attempt_closewait = Module["_tcp_attempt_closewait"] = function() { + return Module["asm"]["_tcp_attempt_closewait"].apply(null, arguments) + }; + + var _tcp_closeconn = Module["_tcp_closeconn"] = function() { + return Module["asm"]["_tcp_closeconn"].apply(null, arguments) + }; + + var _tcp_closewait = Module["_tcp_closewait"] = function() { + return Module["asm"]["_tcp_closewait"].apply(null, arguments) + }; + + var _tcp_closing_ack = Module["_tcp_closing_ack"] = function() { + return Module["asm"]["_tcp_closing_ack"].apply(null, arguments) + }; + + var _tcp_congestion_control = Module["_tcp_congestion_control"] = function() { + return Module["asm"]["_tcp_congestion_control"].apply(null, arguments) + }; + + var _tcp_data_in = Module["_tcp_data_in"] = function() { + return Module["asm"]["_tcp_data_in"].apply(null, arguments) + }; + + var _tcp_data_in_expected = Module["_tcp_data_in_expected"] = function() { + return Module["asm"]["_tcp_data_in_expected"].apply(null, arguments) + }; + + var _tcp_data_in_high_segment = Module["_tcp_data_in_high_segment"] = function() { + return Module["asm"]["_tcp_data_in_high_segment"].apply(null, arguments) + }; + + var _tcp_data_in_send_ack = Module["_tcp_data_in_send_ack"] = function() { + return Module["asm"]["_tcp_data_in_send_ack"].apply(null, arguments) + }; + + var _tcp_deltcb = Module["_tcp_deltcb"] = function() { + return Module["asm"]["_tcp_deltcb"].apply(null, arguments) + }; + + var _tcp_discard_all_segments = Module["_tcp_discard_all_segments"] = function() { + return Module["asm"]["_tcp_discard_all_segments"].apply(null, arguments) + }; + + var _tcp_do_send_rst = Module["_tcp_do_send_rst"] = function() { + return Module["asm"]["_tcp_do_send_rst"].apply(null, arguments) + }; + + var _tcp_fill_rst_header = Module["_tcp_fill_rst_header"] = function() { + return Module["asm"]["_tcp_fill_rst_header"].apply(null, arguments) + }; + + var _tcp_fill_rst_payload = Module["_tcp_fill_rst_payload"] = function() { + return Module["asm"]["_tcp_fill_rst_payload"].apply(null, arguments) + }; + + var _tcp_finack = Module["_tcp_finack"] = function() { + return Module["asm"]["_tcp_finack"].apply(null, arguments) + }; + + var _tcp_finwaitack = Module["_tcp_finwaitack"] = function() { + return Module["asm"]["_tcp_finwaitack"].apply(null, arguments) + }; + + var _tcp_finwaitfin = Module["_tcp_finwaitfin"] = function() { + return Module["asm"]["_tcp_finwaitfin"].apply(null, arguments) + }; + + var _tcp_first_ack = Module["_tcp_first_ack"] = function() { + return Module["asm"]["_tcp_first_ack"].apply(null, arguments) + }; + + var _tcp_first_timeout = Module["_tcp_first_timeout"] = function() { + return Module["asm"]["_tcp_first_timeout"].apply(null, arguments) + }; + + var _tcp_force_closed = Module["_tcp_force_closed"] = function() { + return Module["asm"]["_tcp_force_closed"].apply(null, arguments) + }; + + var _tcp_halfopencon = Module["_tcp_halfopencon"] = function() { + return Module["asm"]["_tcp_halfopencon"].apply(null, arguments) + }; + + var _tcp_is_allowed_to_send = Module["_tcp_is_allowed_to_send"] = function() { + return Module["asm"]["_tcp_is_allowed_to_send"].apply(null, arguments) + }; + + var _tcp_lastackwait = Module["_tcp_lastackwait"] = function() { + return Module["asm"]["_tcp_lastackwait"].apply(null, arguments) + }; + + var _tcp_linger = Module["_tcp_linger"] = function() { + return Module["asm"]["_tcp_linger"].apply(null, arguments) + }; + + var _tcp_next_zerowindow_probe = Module["_tcp_next_zerowindow_probe"] = function() { + return Module["asm"]["_tcp_next_zerowindow_probe"].apply(null, arguments) + }; + + var _tcp_nosync_rst = Module["_tcp_nosync_rst"] = function() { + return Module["asm"]["_tcp_nosync_rst"].apply(null, arguments) + }; + + var _tcp_options_size = Module["_tcp_options_size"] = function() { + return Module["asm"]["_tcp_options_size"].apply(null, arguments) + }; + + var _tcp_options_size_frame = Module["_tcp_options_size_frame"] = function() { + return Module["asm"]["_tcp_options_size_frame"].apply(null, arguments) + }; + + var _tcp_parse_option_mss = Module["_tcp_parse_option_mss"] = function() { + return Module["asm"]["_tcp_parse_option_mss"].apply(null, arguments) + }; + + var _tcp_parse_option_sack_ok = Module["_tcp_parse_option_sack_ok"] = function() { + return Module["asm"]["_tcp_parse_option_sack_ok"].apply(null, arguments) + }; + + var _tcp_parse_option_timestamp = Module["_tcp_parse_option_timestamp"] = function() { + return Module["asm"]["_tcp_parse_option_timestamp"].apply(null, arguments) + }; + + var _tcp_parse_option_ws = Module["_tcp_parse_option_ws"] = function() { + return Module["asm"]["_tcp_parse_option_ws"].apply(null, arguments) + }; + + var _tcp_parse_options = Module["_tcp_parse_options"] = function() { + return Module["asm"]["_tcp_parse_options"].apply(null, arguments) + }; + + var _tcp_process_sack = Module["_tcp_process_sack"] = function() { + return Module["asm"]["_tcp_process_sack"].apply(null, arguments) + }; + + var _tcp_rcv_sack = Module["_tcp_rcv_sack"] = function() { + return Module["asm"]["_tcp_rcv_sack"].apply(null, arguments) + }; + + var _tcp_rcvfin = Module["_tcp_rcvfin"] = function() { + return Module["asm"]["_tcp_rcvfin"].apply(null, arguments) + }; + + var _tcp_read_check_segment_done = Module["_tcp_read_check_segment_done"] = function() { + return Module["asm"]["_tcp_read_check_segment_done"].apply(null, arguments) + }; + + var _tcp_read_finish = Module["_tcp_read_finish"] = function() { + return Module["asm"]["_tcp_read_finish"].apply(null, arguments) + }; + + var _tcp_read_in_frame_len = Module["_tcp_read_in_frame_len"] = function() { + return Module["asm"]["_tcp_read_in_frame_len"].apply(null, arguments) + }; + + var _tcp_retrans = Module["_tcp_retrans"] = function() { + return Module["asm"]["_tcp_retrans"].apply(null, arguments) + }; + + var _tcp_retrans_timeout = Module["_tcp_retrans_timeout"] = function() { + return Module["asm"]["_tcp_retrans_timeout"].apply(null, arguments) + }; + + var _tcp_retrans_timeout_check_queue = Module["_tcp_retrans_timeout_check_queue"] = function() { + return Module["asm"]["_tcp_retrans_timeout_check_queue"].apply(null, arguments) + }; + + var _tcp_rst = Module["_tcp_rst"] = function() { + return Module["asm"]["_tcp_rst"].apply(null, arguments) + }; + + var _tcp_rto_xmit = Module["_tcp_rto_xmit"] = function() { + return Module["asm"]["_tcp_rto_xmit"].apply(null, arguments) + }; + + var _tcp_rtt = Module["_tcp_rtt"] = function() { + return Module["asm"]["_tcp_rtt"].apply(null, arguments) + }; + + var _tcp_sack_marker = Module["_tcp_sack_marker"] = function() { + return Module["asm"]["_tcp_sack_marker"].apply(null, arguments) + }; + + var _tcp_sack_prepare = Module["_tcp_sack_prepare"] = function() { + return Module["asm"]["_tcp_sack_prepare"].apply(null, arguments) + }; + + var _tcp_send = Module["_tcp_send"] = function() { + return Module["asm"]["_tcp_send"].apply(null, arguments) + }; + + var _tcp_send_ack = Module["_tcp_send_ack"] = function() { + return Module["asm"]["_tcp_send_ack"].apply(null, arguments) + }; + + var _tcp_send_add_tcpflags = Module["_tcp_send_add_tcpflags"] = function() { + return Module["asm"]["_tcp_send_add_tcpflags"].apply(null, arguments) + }; + + var _tcp_send_empty = Module["_tcp_send_empty"] = function() { + return Module["asm"]["_tcp_send_empty"].apply(null, arguments) + }; + + var _tcp_send_fin = Module["_tcp_send_fin"] = function() { + return Module["asm"]["_tcp_send_fin"].apply(null, arguments) + }; + + var _tcp_send_probe = Module["_tcp_send_probe"] = function() { + return Module["asm"]["_tcp_send_probe"].apply(null, arguments) + }; + + var _tcp_send_rst = Module["_tcp_send_rst"] = function() { + return Module["asm"]["_tcp_send_rst"].apply(null, arguments) + }; + + var _tcp_send_synack = Module["_tcp_send_synack"] = function() { + return Module["asm"]["_tcp_send_synack"].apply(null, arguments) + }; + + var _tcp_send_try_enqueue = Module["_tcp_send_try_enqueue"] = function() { + return Module["asm"]["_tcp_send_try_enqueue"].apply(null, arguments) + }; + + var _tcp_set_init_point = Module["_tcp_set_init_point"] = function() { + return Module["asm"]["_tcp_set_init_point"].apply(null, arguments) + }; + + var _tcp_set_space = Module["_tcp_set_space"] = function() { + return Module["asm"]["_tcp_set_space"].apply(null, arguments) + }; + + var _tcp_set_space_check_winupdate = Module["_tcp_set_space_check_winupdate"] = function() { + return Module["asm"]["_tcp_set_space_check_winupdate"].apply(null, arguments) + }; + + var _tcp_split_segment = Module["_tcp_split_segment"] = function() { + return Module["asm"]["_tcp_split_segment"].apply(null, arguments) + }; + + var _tcp_syn = Module["_tcp_syn"] = function() { + return Module["asm"]["_tcp_syn"].apply(null, arguments) + }; + + var _tcp_synack = Module["_tcp_synack"] = function() { + return Module["asm"]["_tcp_synack"].apply(null, arguments) + }; + + var _tcp_synrecv_syn = Module["_tcp_synrecv_syn"] = function() { + return Module["asm"]["_tcp_synrecv_syn"].apply(null, arguments) + }; + + var _tcp_wakeup_pending = Module["_tcp_wakeup_pending"] = function() { + return Module["asm"]["_tcp_wakeup_pending"].apply(null, arguments) + }; + + var _tcpopt_len_check = Module["_tcpopt_len_check"] = function() { + return Module["asm"]["_tcpopt_len_check"].apply(null, arguments) + }; + + var _time_diff = Module["_time_diff"] = function() { + return Module["asm"]["_time_diff"].apply(null, arguments) + }; + + var _tolower = Module["_tolower"] = function() { + return Module["asm"]["_tolower"].apply(null, arguments) + }; + + var _transport_flags_update = Module["_transport_flags_update"] = function() { + return Module["asm"]["_transport_flags_update"].apply(null, arguments) + }; + + var _update_max_arp_reqs = Module["_update_max_arp_reqs"] = function() { + return Module["asm"]["_update_max_arp_reqs"].apply(null, arguments) + }; + + var _vfprintf = Module["_vfprintf"] = function() { + return Module["asm"]["_vfprintf"].apply(null, arguments) + }; + + var _wcrtomb = Module["_wcrtomb"] = function() { + return Module["asm"]["_wcrtomb"].apply(null, arguments) + }; + + var _wctomb = Module["_wctomb"] = function() { + return Module["asm"]["_wctomb"].apply(null, arguments) + }; + + var establishStackSpace = Module["establishStackSpace"] = function() { + return Module["asm"]["establishStackSpace"].apply(null, arguments) + }; + + var stackAlloc = Module["stackAlloc"] = function() { + return Module["asm"]["stackAlloc"].apply(null, arguments) + }; + + var stackRestore = Module["stackRestore"] = function() { + return Module["asm"]["stackRestore"].apply(null, arguments) + }; + + var stackSave = Module["stackSave"] = function() { + return Module["asm"]["stackSave"].apply(null, arguments) + }; + + var dynCall_ii = Module["dynCall_ii"] = function() { + return Module["asm"]["dynCall_ii"].apply(null, arguments) + }; + + var dynCall_iidiiii = Module["dynCall_iidiiii"] = function() { + return Module["asm"]["dynCall_iidiiii"].apply(null, arguments) + }; + + var dynCall_iii = Module["dynCall_iii"] = function() { + return Module["asm"]["dynCall_iii"].apply(null, arguments) + }; + + var dynCall_iiii = Module["dynCall_iiii"] = function() { + return Module["asm"]["dynCall_iiii"].apply(null, arguments) + }; + + var dynCall_jiji = Module["dynCall_jiji"] = function() { + return Module["asm"]["dynCall_jiji"].apply(null, arguments) + }; + + var dynCall_vi = Module["dynCall_vi"] = function() { + return Module["asm"]["dynCall_vi"].apply(null, arguments) + }; + + var dynCall_vii = Module["dynCall_vii"] = function() { + return Module["asm"]["dynCall_vii"].apply(null, arguments) + }; + + var dynCall_viiii = Module["dynCall_viiii"] = function() { + return Module["asm"]["dynCall_viiii"].apply(null, arguments) + }; + + var dynCall_vji = Module["dynCall_vji"] = function() { + return Module["asm"]["dynCall_vji"].apply(null, arguments) + }; + ; + + + + // === Auto-generated postamble setup entry stuff === + + Module['asm'] = asm; + + + + Module["ccall"] = ccall; + Module["cwrap"] = cwrap; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Module["addFunction"] = addFunction; + Module["removeFunction"] = removeFunction; + + + + + + + + + + + + + + + + + + + + + + + + + var calledRun; + + // Modularize mode returns a function, which can be called to + // create instances. The instances provide a then() method, + // must like a Promise, that receives a callback. The callback + // is called when the module is ready to run, with the module + // as a parameter. (Like a Promise, it also returns the module + // so you can use the output of .then(..)). + Module['then'] = function(func) { + // We may already be ready to run code at this time. if + // so, just queue a call to the callback. + if (calledRun) { + func(Module); + } else { + // we are not ready to call then() yet. we must call it + // at the same time we would call onRuntimeInitialized. + var old = Module['onRuntimeInitialized']; + Module['onRuntimeInitialized'] = function() { + if (old) old(); + func(Module); + }; + } + return Module; + }; + + /** + * @constructor + * @this {ExitStatus} + */ + function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status; + } + + var calledMain = false; + + + dependenciesFulfilled = function runCaller() { + // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false) + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled + }; + + function callMain(args) { + + var entryFunction = Module['_main']; + + + args = args || []; + + var argc = args.length+1; + var argv = stackAlloc((argc + 1) * 4); + HEAP32[argv >> 2] = allocateUTF8OnStack(thisProgram); + for (var i = 1; i < argc; i++) { + HEAP32[(argv >> 2) + i] = allocateUTF8OnStack(args[i - 1]); + } + HEAP32[(argv >> 2) + argc] = 0; + + + try { + + + var ret = entryFunction(argc, argv); + + + // if we're not running an evented main loop, it's time to exit + exit(ret, /* implicit = */ true); + } + catch(e) { + if (e instanceof ExitStatus) { + // exit() throws this once it's done to make sure execution + // has been stopped completely + return; + } else if (e == 'SimulateInfiniteLoop') { + // running an evented main loop, don't immediately exit + noExitRuntime = true; + return; + } else { + var toLog = e; + if (e && typeof e === 'object' && e.stack) { + toLog = [e, e.stack]; + } + err('exception thrown: ' + toLog); + quit_(1, e); + } + } finally { + calledMain = true; + } + } + + + + + /** @type {function(Array=)} */ + function run(args) { + args = args || arguments_; + + if (runDependencies > 0) { + return; + } + + + preRun(); + + if (runDependencies > 0) return; // a preRun added a dependency, run will be called later + + function doRun() { + // run may have just been called through dependencies being fulfilled just in this very frame, + // or while the async setStatus time below was happening + if (calledRun) return; + calledRun = true; + + if (ABORT) return; + + initRuntime(); + + preMain(); + + if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized'](); + + if (shouldRunNow) callMain(args); + + postRun(); + } + + if (Module['setStatus']) { + Module['setStatus']('Running...'); + setTimeout(function() { + setTimeout(function() { + Module['setStatus'](''); + }, 1); + doRun(); + }, 1); + } else + { + doRun(); + } + } + Module['run'] = run; + + + function exit(status, implicit) { + + // if this is just main exit-ing implicitly, and the status is 0, then we + // don't need to do anything here and can just leave. if the status is + // non-zero, though, then we need to report it. + // (we may have warned about this earlier, if a situation justifies doing so) + if (implicit && noExitRuntime && status === 0) { + return; + } + + if (noExitRuntime) { + } else { + + ABORT = true; + EXITSTATUS = status; + + exitRuntime(); + + if (Module['onExit']) Module['onExit'](status); + } + + quit_(status, new ExitStatus(status)); + } + + if (Module['preInit']) { + if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; + while (Module['preInit'].length > 0) { + Module['preInit'].pop()(); + } + } + + // shouldRunNow refers to calling main(), not run(). + var shouldRunNow = true; + + if (Module['noInitialRun']) shouldRunNow = false; + + + noExitRuntime = true; + + run(); + + + + + + // {{MODULE_ADDITIONS}} + + + + + + return Module + } + ); + })(); + if (typeof exports === 'object' && typeof module === 'object') + module.exports = Module; + else if (typeof define === 'function' && define['amd']) + define([], function() { return Module; }); + else if (typeof exports === 'object') + exports["Module"] = Module; + // HACK: Work around . + const _Module = new Proxy(Module, { + apply(target, thisArg, args) { + return new Promise(resolve => Reflect.apply(target, thisArg, args) + .then(m => { + delete m.then; + resolve(m); + })); + } + }); + + class SyncWritableReadableStream extends ReadableStream { + constructor(...args) { + let controller; + super({ + start: _controller => controller = _controller, + }, ...args); + this.controller = controller; + } + _write(...args) { + this.controller.enqueue(...args); + } + _close() { + if (this.isClosed) return; + this.controller.close(); + this.isClosed = true; + } + } + + const EOF = Symbol("EOF"); + + class SyncSink { + constructor({size = () => 1, highWaterMark = 1} = {}) { + this._queue = []; + this._queueTotalSize = 0; + this._strategyHWM = highWaterMark; + this._strategySizeAlgorithm = size; + this._ready = Promise.resolve(); + this._readyResolve = () => {}; + this._readyReject = () => {}; + this._isAborted = false; + } + write(chunk, controller) { + if (chunk === EOF) return; + const size = this._strategySizeAlgorithm(chunk); + this._queueTotalSize += size; + this._queue.push([chunk, size]); + if (this._queueTotalSize < this._strategyHWM) return; + this._ready = new Promise((resolve, reject) => { + this._readyResolve = resolve; + this._readyReject = reject; + }); + if (this._onData) { + this._onData(); + this._onData = null; + } + return this._ready; + } + close() { + this._queue.push([EOF, 0]); + } + abort(reason) { + this._isAborted = reason; + this._queue = []; + } + read() { + if (this._queue.length === 0) return []; + const [chunk, size] = this._queue.shift(); + this._queueTotalSize -= size; + if (this._queueTotalSize < 0) this._queueTotalSize = 0; + if (this._queueTotalSize < this._strategyHWM) this._readyResolve(); + return [chunk]; + } + } + + class SyncReadableWritableStream extends WritableStream { + constructor(sinkArgs, ...args) { + const sink = new SyncSink(sinkArgs); + super(sink, ...args); + this._sink = sink; + } + _read() { + return this._sink.read()[0]; + } + get EOF() { + return EOF; + } + get isAborted() { + return this._sink.isAborted; + } + get ready() { + return this._sink._ready; + } + set _onData(val) { + this._sink._onData = val; + } + *[Symbol.iterator]() { + for (let v; v = this._sink.read();) { + if (v.length === 0) break; + yield v[0]; + } + } + } + + // Copyright 2018 The Emulation-as-a-Service Authors. + let globalStack; + + const sleep$1 = ms => new Promise(r => setTimeout(r, ms)); + + const cidrToSubnet = (string) => { + const [ip, prefixString] = string.split("/", 2); + const prefixLength = parseInt(prefixString); + const subnet = prefixLength && (-1 << (32 - prefixLength) >>> 0); + return [ip, `${subnet >>> 24 & 0xff}.${subnet >>> 16 & 0xff}.${subnet >>> 8 & 0xff}.${subnet >>> 0 & 0xff}`]; + }; + + const parseMAC = (string) => + string.split(/:|-/).map(v => parseInt(v, 16)); + + class Stream2 { + constructor() { + return new WritableStream(this); + } + write(controller, chunk) { + console.log(chunk); + return new Promise(() => {}); + } + } + + const pcapHeader = new Blob([new Uint32Array([ + 0xa1b2c3d4, + 0x00040002, + 0x00000000, + 0x00000000, + 0x0000ffff, + 0x00000001, + ])]); + + class StreamRecorder { + constructor(data = [pcapHeader]) { + this.data = data; + } + transform(chunk, controller) { + const buffer = chunk; // .buffer || chunk; + const length = buffer.byteLength; + const now = Date.now(); + const header = new Uint32Array([ + now / 1000, + (now % 1000) * 1000, + length, + length, + ]); + this.data.push(new Blob([header, buffer])); + controller.enqueue(chunk); + } + } + + class RecordStream extends TransformStream { + constructor(data) { + const recorder = new StreamRecorder(data); + super(recorder); + this.recorder = recorder; + } + getDump() { + return new Blob(this.recorder.data); + } + } + + const blobToArrayBuffer = blob => new Promise((onload, onerror) => + Object.assign(new FileReader(), {onload, onerror}).readAsArrayBuffer(blob)) + .then(v => v.target.result); + + function saveAs(blob, name) { + const a = document.createElement("a"); + const url = URL.createObjectURL(blob); + a.href = url; + a.download = name; + // Firefox needs `a` to be connected to document. + document.head.append(a); + a.click(); + a.remove(); + URL.revokeObjectURL(url); + // setTimeout(() => URL.revokeObjectURL(url), 60 * 1000); + } + + function randomMac() { + const mac = self.crypto.getRandomValues(new Uint8Array(6)); + // Unicast, locally administered. + mac[0] = mac[0] & ~0b00000001 | 0b00000010; + return mac; + } + + class NetworkStack { + constructor({mac, ipv4} = {}) { + return (async () => { + this._picotcp = await _Module(); + this.start(); + return this; + })(); + } + + start() { + this._interval = setInterval(this.tick.bind(this), 10/*500*/); + } + stop() { + clearInterval(this._interval); + this._interval = null; + } + tick() { + this._picotcp._pico_stack_tick(); + } + async addInterface({mac = randomMac(), ip}) { + const dev = await new NIC(this, mac); + if (ip) dev.addIPv4(ip); + return dev; + } + } + + let defaultNetwork; + + const callAsync = async (emscriptenModule, executor, removeFunction = true, transform = (...args) => args) => { + let resolve; + const promise = new Promise(_resolve => resolve = _resolve); + const ptr = emscriptenModule.addFunction((...args) => resolve(transform(...args))); + executor(ptr); + await promise; + if (removeFunction) emscriptenModule.removeFunction(ptr); + return promise; + }; + + class NIC { + constructor(stack, mac = randomMac()) { + return (async () => { + if (!stack) { + if (!defaultNetwork) defaultNetwork = new NetworkStack(); + stack = await defaultNetwork; + } + this.stack = stack; + this.dev = this.stack._picotcp.ccall("pico_js_create", "number", ["string", "array"], ["", mac]); + this.stack._dev = this.dev; + this.mac = mac; + return this; + })(); + } + addIPv4(ip = "", netmask = "255.255.255.0") { + this.stack._picotcp.ccall("js_add_ipv4", "number", ["number", "string", "string"], [this.dev, ip, netmask]); + } + async ping(dst, timeout = 1000) { + return callAsync(this.stack._picotcp, ptr => this.stack._picotcp.ccall( + "pico_icmp4_ping", "number", + ["string", "number", "number", "number", "number", "number"], + [dst, 1, 1, timeout, 64, ptr])); + } + async startDHCPClient() { + const xidPtr = this.stack._picotcp._malloc(4); + const [cli, code] = await callAsync(this.stack._picotcp, ptr => this.stack._picotcp.ccall( + "pico_dhcp_initiate_negotiation", "number", + ["number", "number", "number"], + [this.dev, ptr, xidPtr]), false); + const xid = this.stack._picotcp.HEAPU32[xidPtr / 4]; + this.stack._picotcp._js_accept_nameserver(cli); + // Do not free xidPtr as picoTCP will use it again when + // renewing the DHCP lease (not documented in picoTCP documentation). + return [cli, code, xid]; + } + startDHCPServer(ip) { + const settingsPtr = this.stack._picotcp._malloc(9 * 4); + const HEAPU32 = this.stack._picotcp.HEAPU32.subarray(settingsPtr / 4); + HEAPU32[0] = 0; + HEAPU32[1] = 0; + HEAPU32[2] = 0; + HEAPU32[3] = 864000; // 10 days DHCP lease + HEAPU32[4] = this.dev; + HEAPU32[5] = 0; + HEAPU32[6] = new Uint32Array(Uint8Array.from( + ip.split(/\./).map(v => parseInt(v, 10))).buffer)[0]; + HEAPU32[7] = 0; + HEAPU32[8] = 0; + const ret = this.stack._picotcp.ccall( + "pico_dhcp_server_initiate", "number", ["number"], [settingsPtr] + ); + this.stack._picotcp._free(settingsPtr); + return ret; + } + addARPEntry(mac, ip) { + const macPtr = this.stack._picotcp._malloc(6); + this.stack._picotcp.HEAPU8.set(mac.slice(0, 6), macPtr); + + const ipPtr = this.stack._picotcp._malloc(4); + this.stack._picotcp.HEAPU8.set(ip.slice(0, 4), ipPtr); + + const ret = this.stack._picotcp.ccall( + "pico_arp_create_entry", "number", ["number", "number", "number"], [macPtr, ipPtr, this.dev] + ); + + this.stack._picotcp._free(macPtr); + //this.stack._picotcp._free(ipPtr); + + return ret; + } + + async getAddr(addr) { + // TODO: This leaks `ptr` if `pico_dns_client_getaddr() != 0`. + const {HEAPU8} = this.stack._picotcp; + // HACK: IP addresses will never be longer than 255 bytes. + const name = await callAsync(this.stack._picotcp, ptr => + this.stack._picotcp.ccall("pico_dns_client_getaddr", "number", + ["string", "number", "number"], [addr, ptr, 0]), true, + ipPtr => new TextDecoder().decode( + HEAPU8.subarray(ipPtr, ipPtr + 256)).split("\0")[0]); + return name; + } + get readable() { + return this.stack._picotcp.pointers[this.dev].readable; + } + get writable() { + return this.stack._picotcp.pointers[this.dev].writable; + } + get TCPSocket() { + const self = this; + return class extends TCPSocket { + get NIC() {return self;} + } + } + get TCPServerSocket() { + const self = this; + return class extends TCPServerSocket { + get NIC() {return self;} + } + } + } + + /** + * @see https://www.w3.org/TR/tcp-udp-sockets/#interface-tcpsocket + */ + class TCPSocket { + constructor(remoteAddress, remotePort, options = {}) { + const PICO_PROTO_IPV4 = 0, PICO_PROTO_IPV6 = 41; + this._ptr = this.NIC.stack._picotcp.ccall("js_socket_open", "number", ["number", "number"], [PICO_PROTO_IPV4, new.target._proto]); + ({readable: this.readable, writable: this.writable} = this.NIC.stack._picotcp.pointers[this._ptr]); + console.log(this.NIC.stack._picotcp.ccall("js_socket_connect", "number", ["number", "string", "number"], [this._ptr, remoteAddress, remotePort])); + console.log(this.NIC.stack._picotcp._js_pico_err()); + } + + static get _proto() { + const PICO_PROTO_TCP = 6, PICO_PROTO_UDP = 17; + return PICO_PROTO_TCP; + } + } + + /** + * @see https://www.w3.org/TR/tcp-udp-sockets/#interface-tcpserversocket + */ + class TCPServerSocket { + constructor({localAddress, localPort} = {}) { + const PICO_PROTO_IPV4 = 0, PICO_PROTO_IPV6 = 41; + this._ptr = this.NIC.stack._picotcp.ccall("js_socket_open", "number", ["number", "number"], [PICO_PROTO_IPV4, new.target._proto]); + ({readable: this.readable, writable: this.writable} = this.NIC.stack._picotcp.pointers[this._ptr]); + console.log(this.NIC.stack._picotcp.ccall("js_socket_bind", "number", ["number", "string", "number"], [this._ptr, localAddress, localPort])); + console.log(this.NIC.stack._picotcp._js_pico_err()); + } + + static get _proto() { + const PICO_PROTO_TCP = 6, PICO_PROTO_UDP = 17; + return PICO_PROTO_TCP; + } + } + + + + /* + wait = ms=>{for(const end = performance.now() + ms; performance.now() < end;);} + setInterval(()=>{console.log(++x);wait(1100*a);console.log("done",x);}, 1000);x=0;a=1 + */ + + /** @param {Uint8Array} buffer */ + self.SEND = buffer => { + const length = buffer.length; + // console.log("SENDING into VM -->", buffer, length); + const blob = new Blob([new Uint8Array([length >> 8, length & 0xff]), buffer]); + //ws.send(blob); + console.log("SEND called"); + return length; + }; + + self.POLL = (n, dev, module) => { + while (n--) { + if (!self.NET_Q.length) break; + const buf = self.NET_Q.shift(); + // TODO: When do we need to free this? + const pointer = module._malloc(buf.length); + module.writeArrayToMemory(buf, pointer); + // console.log("<-- GETTING from VM", new Uint8Array(buf), buf.length, pointer); + module.ccall("pico_stack_recv", "number", ["number", "number", "number"], + [dev, pointer, buf.length]); + } + return n; + }; + + self.NET_Q = []; + + const messages = []; + + async function start() { + let stack = _Module(); + globalStack = stack; + setInterval(() => stack._pico_stack_tick(), 500); + } + + // if (typeof TransformStream === "undefined") await import("https://rawgit.com/creatorrr/web-streams-polyfill/master/dist/polyfill.min.js"); + + //const urls = Object.entries(data).filter(([k]) => k.startsWith("ws+ethernet+")); + //const url = new URL(urls[0][1]); + //const ws = new WebSocket(url); + + /* window.ws = ws; + const stream = wrapWebSocket(ws) + .pipeThrough(new Uint8ArrayStream()) + .pipeThrough(new VDEParser()) + // VDE does not send a CRC. + .pipeThrough(new EthernetParser({crcLength: 0})) + // .pipeThrough(new EthernetPrinter()) + .pipeThrough(new IPv4Parser()) + .pipeThrough(new UDPParser()) + ; + const read = stream.getReader(); + */ + // for await (const chunk of read) { + // window.Q.push(chunk); + // try {stack._pico_stack_tick();} catch (e) {} + // // console.log(chunk); + // } + + //} + + new ReadableStream().getReader().__proto__[Symbol.asyncIterator] = function () { + return { + next: () => this.read(), + }; + }; + + class StreamPrinter extends TransformStream { + constructor(tag = "StreamPrinter") { + super({ + transform(chunk, controller) { + console.log(tag, chunk); + controller.enqueue(chunk); + } + }); + } + } + + class EthernetPrinter extends TransformStream { + constructor() { + /** + * @param {Uint8Array} frame + * @param {*} controller + */ + const transform = (frame, controller) => { + controller.enqueue({ + ...frame, + source: Array.from(frame.source).map(v => v.toString(16)), + dest: Array.from(frame.dest).map(v => v.toString(16)), + type: frame.type.toString(16), + frame, + }); + }; + super({transform}); + } + } + + function wrapWebSocket(ws) { + return new ReadableStream({ + start(controller) { + ws.addEventListener("message", ({data}) => controller.enqueue(data)); + } + }); + } + + function getPromise() { + let resolve, reject; + const promise = new Promise((_resolve, _reject) => { + resolve = _resolve; + reject = _reject; + }); + return {promise, resolve, reject}; + }; + + class Uint8ArrayStream extends TransformStream { + constructor(websocketStream) { + const reader = new FileReader(); + super({ + async transform(chunk, controller) { + let ret; + if (chunk instanceof Blob) { + reader.readAsArrayBuffer(chunk); + await ({resolve: reader.onload, reject: reader.onerror} = getPromise()).promise; + chunk = reader.result; + } + if (chunk.buffer) chunk = chunk.buffer; + if (chunk instanceof ArrayBuffer) ret = new Uint8Array(chunk); + else return; + controller.enqueue(ret); + } + }); + } + } + + // Copyright 2018 The Emulation-as-a-Service Authors. + + /** + * @see + */ + class UDPParser extends TransformStream { + /** + * @param {payload: Uint8Array} lower + * @param {*} controller + */ + static transform(lower, controller) { + const {payload} = lower; + const ret = { + source: payload[0] << 8 | payload[1], + dest: payload[2] << 8 | payload[3], + length: payload[4] << 8 | payload[5], + checksum: payload[6] << 8 | payload[7], + }; + Object.assign(ret, { + payload: payload.subarray(8, ret.length), + lower, + }); + controller.enqueue(ret); + } + constructor() {super(new.target);} + } + + /** + * @see + */ + class IPv4Parser extends TransformStream { + /** + * @param {payload: Uint8Array} lower + * @param {*} controller + */ + static transform(lower, controller) { + const {type, payload} = lower; + if (type !== 0x800) return; + const ret = { + version: payload[0] >> 4, + ihl: payload[0] & 0b1111, + dscp: payload[1] >> 2, + ecn: payload[1] & 0b11, + length: payload[2] << 8 | payload[3], + id: payload[4] << 8 | payload[5], + flags: payload[6] >> 5, + fragmentOffset: (payload[6] & 0b11111) << 8 | payload[7], + ttl: payload[8], + /** @see */ + protocol: payload[9], + headerChecksum: payload[10] << 8 | payload[11], + source: payload.subarray(12, 12 + 4), + dest: payload.subarray(16, 16 + 4), + }; + const headerLength = 20; + // TODO: options. + Object.assign(ret, { + payload: payload.subarray(headerLength, ret.length), + lower, + }); + controller.enqueue(ret); + } + constructor() {super(new.target);} + } + + self.all_packets = []; + + /** + * @see + */ + class EthernetParser extends TransformStream { + constructor({crcLength = 0} = {}) { + super({ + /** + * @param {Uint8Array} frame + * @param {*} controller + */ + transform(frame, controller) { + self.all_packets.push(frame); + const dest = frame.subarray(0, 6); + const source = frame.subarray(6, 12); + /** @see */ + const type = frame[12] << 8 | frame[13]; + const payload = frame.subarray(14, crcLength ? -crcLength : undefined); + const crc = crcLength ? frame.subarray(-4) : null; + controller.enqueue({source, dest, type, payload, crc, lower: frame}); + } + }); + } + } + + /* + Copyright 2020 Google Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + */ + + class RingBuffer { + static from(sab) { + return new RingBuffer(sab); + } + + get buffer() { + return this._sab; + } + + get remaining() { + return this._size - this.length; + } + + get size() { + return this._size; + } + + get length() { + let readIndex = Atomics.load(this._header, HEADER.READ); + let writeIndex = Atomics.load(this._header, HEADER.WRITE); + + const delta = writeIndex - readIndex; + return readIndex <= writeIndex ? delta : delta + this._size; + } + + get eof() { + return (this.length === 0 && Atomics.load(this._state, READER_STATE.EOF) === 0) ? true : false; + } + + set eof(val) { + let eofVal = !!val ? 0 : 1; + if (this.length === 0 && val) { + Atomics.notify(this._state, READER_STATE.DATA_AVAILABLE); + } + Atomics.store(this._state, READER_STATE.EOF, eofVal); + } + + /* + Create's a Ring Buffer backed by a correctly sized SAB. + + There can only be one writer and one reader. + */ + static create(length) { + const buffer = new SharedArrayBuffer( + length + + Uint32Array.BYTES_PER_ELEMENT * HEADER_LENGTH + + Int32Array.BYTES_PER_ELEMENT * READER_STATE_LENGTH + ); + + return new RingBuffer(buffer); + } + + constructor(sab) { + if (!!sab == false) throw new Error("Shared Array Buffer is undefined"); + if (sab instanceof SharedArrayBuffer == false) + throw new Error("Parameter 0 is not a Shared Array Buffer"); + + this._size = sab.byteLength + - Uint32Array.BYTES_PER_ELEMENT * HEADER_LENGTH + - Int32Array.BYTES_PER_ELEMENT * READER_STATE_LENGTH; + this._sab = sab; + this._header = new Uint32Array(sab, 0, HEADER_LENGTH); + this._state = new Int32Array(sab, Uint32Array.BYTES_PER_ELEMENT * HEADER_LENGTH, READER_STATE_LENGTH); + this._body = new Uint8Array( + sab, + Uint32Array.BYTES_PER_ELEMENT * HEADER_LENGTH + + Int32Array.BYTES_PER_ELEMENT * READER_STATE_LENGTH, + this._size + ); + } + + /* + data: An array of Uint8 + attemptToFill (deafault: false): if true, will fill as much of the array as possible + returning the items that couldn't be added. + + */ + append(data, attemptToFill = false) { + const { remaining, length, size } = this; + + if (data.length > remaining && attemptToFill == false) { + throw new Error("Data being appended will overflow the buffer"); + } + + if (data instanceof Array == false && data instanceof Uint8Array == false) { + throw new Error( + "data is not an array that can be converted to Uint8array" + ); + } + + let writeIndex = Atomics.load(this._header, HEADER.WRITE); + let writeStart = writeIndex % size; + + // We need at most two write operations. + // If the data will go past the end of the buffer, we need + // to write a 2nd batch from the start of the buffer. + // 9, 15 + // batch1, pos [9] = val [0] + // batch2, pos [0] = val [1,2,3,4,5] + + const batch1 = data.slice(0, size - writeStart); + this._body.set(batch1, writeStart); + let writeLength = batch1.length; + let slice = undefined; + + if (writeLength < data.length) { + // We are wrapping around because there was more data. + const batch2 = data.slice(writeLength, remaining - writeLength); + this._body.set(batch2, 0); + writeLength += batch2.length; + + Atomics.add(this._header, HEADER.WRITE, writeLength); + + if (attemptToFill && (writeLength < data.length)) { + slice = data.slice(writeLength); + } + } + else { + Atomics.add(this._header, HEADER.WRITE, writeLength); + } + + Atomics.store(this._state, READER_STATE.DATA_AVAILABLE, 1); + Atomics.notify(this._state, READER_STATE.DATA_AVAILABLE); + + return slice; + } + + // Reads the next byte of data. Note: Assuming 4GB of addressable buffer. + read() { + let readIndex = Atomics.load(this._header, HEADER.READ); + let writeIndex = Atomics.load(this._header, HEADER.WRITE); + + if (readIndex == writeIndex - 1) { + // The next blocking read, should wait. + console.log('next block'); + Atomics.store(this._state, READER_STATE.DATA_AVAILABLE, 0); + Atomics.notify(this._state, READER_STATE.DATA_AVAILABLE); + } + + if (readIndex == writeIndex) { + return undefined; + } + + const value = Atomics.load(this._body, readIndex % this._size); + + readIndex = Atomics.add(this._header, HEADER.READ, 1); + + return value; + } + + blockingRead() { + if (this.eof) return undefined; + + Atomics.wait(this._state, READER_STATE.DATA_AVAILABLE, 0); + return this.read(); + } + + *readToHead() { + // Feels odd to have to create a buffer the same size as the buffer. Just iterate. + let data; + while ((data = this.read()) != undefined) { + yield data; + } + } + + clear() { + Atomics.store(this._header, HEADER.READ, 0); + Atomics.store(this._header, HEADER.WRITE, 0); + } + } + + const HEADER = { + READ: 0, // 4GB buffer + WRITE: 1, // 4GB buffer + }; + + const HEADER_LENGTH = Object.keys(HEADER).length; + + const READER_STATE = { + DATA_AVAILABLE: 0, + WAITING: 1, + EOF: 2 + }; + + const READER_STATE_LENGTH = Object.keys(READER_STATE).length; + + const encoder = new TextEncoder(); + + const CORS_PREFIX = "https://wabac-cors-proxy.webrecorder.workers.dev/proxy/"; + const ARCHIVE_PREFIX = "https://web.archive.org/web/"; + + + class HttpProxyServer + { + constructor({socket, replayUrl, replayTs, homePage, proxyIP, proxyPort, updateCallback}) { + this.socket = socket; + this.replayTs = replayTs; + this.replayUrl = replayUrl; + this.homePage = homePage; + this.proxyIP = proxyIP; + this.proxyPort = proxyPort; + this.updateCallback = updateCallback; + + this.keepAlive = false; + } + + get proxyPac() { + return `\ +function FindProxyForURL(url, host) +{ + if (isInNet(host, "${this.proxyIP}") || shExpMatch(url, "http://${this.proxyIP}:${this.proxyPort}/*")) { + return "DIRECT"; + } + + return "PROXY ${this.proxyIP}:${this.proxyPort}"; +} +`; + } + + useKeepAlive(req) { + //disabled for now + return false; + + if (!req.match(/Proxy-Connection\:\skeep-alive/i)) { + return false; + } + + // only use for IE5 or IE6 for now.. + if (!req.match(/User-Agent\:.*MSIE (5|6)/)) { + return false; + } + + return true; + } + + async handleResponse() { + const writer = this.socket.writable.getWriter(); + const reader = this.socket.readable.getReader(); + + await this.handleOneResponse(writer, reader); + + while (this.keepAlive) { + await this.handleOneResponse(writer, reader); + } + + try { + writer.close(); + } catch (e) { + console.log(e); + } + } + + async handleOneResponse(writer, reader) { + let req = null; + + try { + const data = await reader.read(); + if (data.done || !data.value) { + this.keepAlive = false; + return; + } + req = new TextDecoder().decode(data.value); + } catch (e) { + console.log(e); + this.sendResponse({ + content: "Server Error", + status: 500, + statusText: "Server Error", + writer + }); + return; + } + + if (this.updateCallback) { + this.updateCallback(); + } + + //TODO: handle other methods + const m = req.match(/GET\s([^\s]+)/); + + //console.log(req); + + let requestURL = m && m[1]; + + if (requestURL === "/proxy.pac") { + this.sendResponse({ + content: this.proxyPac, + contentType: "application/x-ns-proxy-autoconfig", + writer + }); + return; + } + + this.keepAlive = this.useKeepAlive(req); + + if (requestURL === "/" || requestURL === this.homePage) { + this.sendRedirect({ + redirect: this.replayUrl, + writer + }); + return; + } + + if (!requestURL || !requestURL.startsWith("http://")) { + this.sendResponse({ + content: "Invalid URL: " + requestURL, + status: 400, + statusText: "Bad Request", + writer + }); + return; + } + + const targetUrl = m[1]; + + const resp = await this.doProxy(targetUrl); + + if (resp.status !== 200 && !resp.headers.get("memento-datetime")) { + let msg = ""; + let status = 400; + + switch (resp.status) { + case 429: + msg = "Too Many Requests. Please try again later"; + break; + + case 404: + msg = "Page Not Found"; + status = resp.status; + break; + } + + this.sendResponse({ + content: `Sorry, an error has occured.\n(Status ${resp.status}) ${msg}`, + status, + statusText: "Bad Request", + writer + }); + return; + } + + const content = await resp.arrayBuffer(); + + let { status, statusText } = resp; + + if (resp.headers.has("x-redirect-status")) { + status = resp.headers.get("x-redirect-status"); + statusText = resp.headers.get("x-redirect-statusText") || "Redirect"; + + const redirect = resp.headers.get("x-orig-location") || resp.headers.get("location"); + + if (redirect) { + this.sendRedirect({redirect, writer}); + return; + } + } + + const contentType = resp.headers.get("content-type"); + + this.sendResponse({content, status, statusText, contentType, writer}); + } + + sendResponse({writer, content, status = 200, statusText = "OK", contentType = "text/plain"}) { + const payload = typeof(content) === "string" ? encoder.encode(content) : new Uint8Array(content); + + const contentTypeStr = (status === 200 && contentType) ? `Content-Type: ${contentType}\r\n` : ""; + + try{ + writer.write(encoder.encode(`\ +HTTP/1.0 ${status} ${statusText}\r\n\ +${contentTypeStr}\ +Connection: ${this.keepAlive ? 'keep-alive' : 'close'}\r\n\ +Proxy-Connection: ${this.keepAlive ? 'keep-alive' : 'close'}\r\n\ +Content-Length: ${payload.byteLength}\r\n\ +\r\n`)); + + writer.write(payload); + + } catch (e) { + console.log(e); + } + + //this.socket.close(); + } + + sendRedirect({writer, redirect}) { + + try { + writer.write(encoder.encode(`\ +HTTP/1.0 301 Permanent Redirect\r\n\ +Content-Type: text/plain\r\n\ +Connection: ${this.keepAlive ? 'keep-alive' : 'close'}\r\n\ +Proxy-Connection: ${this.keepAlive ? 'keep-alive' : 'close'}\r\n\ +Content-Length: 0\r\n\ +Location: ${redirect}\r\n\ +\r\n`)); + + } catch (e) { + console.log(e); + } + + //this.socket.close(); + } + + doProxy(targetUrl) { + //TODO: multi archive support + const fetchUrl = CORS_PREFIX + (this.replayTs ? ARCHIVE_PREFIX + this.replayTs + "id_/" + targetUrl : targetUrl); + + return fetch(fetchUrl, {headers: {"X-OWT-No-HTTPS": "1"}}); + } + } + + // Parts Copyright 2018 The Emulation-as-a-Service Authors. + + const DEBUG = false; + + + const iterator = reader => ({ + [Symbol.asyncIterator]: function () {return this;}, + next: () => reader.read(), + return: () => ({}), + }); + + function sleep(timeout) { + return new Promise((resolve) => setTimeout(resolve, timeout)); + } + + let replayUrl; + let replayTs; + let proxyIP = "192.168.1.1"; + let proxyPort = 8080; + let homePage = "http://192.168.1.1:8080/"; + let pollSAB = false; + + // for adding ARP entry + let clientMAC = null; + let clientIP = null; + let rb = null; + let emuPort = null; + + let pingOnUpdate = false; + + function updateState(data) { + if (data.replayUrl !== undefined) { + replayUrl = data.replayUrl; + } + if (data.replayTs !== undefined) { + replayTs = data.replayTs; + } + if (data.proxyIP !== undefined) { + proxyIP = data.proxyIP; + } + if (data.proxyPort !== undefined) { + proxyPort = data.proxyPort; + } + homePage = `http://${proxyIP}:${proxyPort}/`; + pingOnUpdate = true; + } + + self.onmessage = (event) => { + if (event.data.clientIP) { + clientIP = event.data.clientIP; + } + if (event.data.clientMAC) { + clientMAC = event.data.clientMAC; + } + if (event.data.pollSAB) { + pollSAB = event.data.pollSAB; + rb = RingBuffer.create(1514 * 256); + if (event.data.port) { + emuPort = event.data.port; + emuPort.postMessage(rb.buffer); + } + } + + updateState(event.data); + main(); + }; + + const updateProxy = new BroadcastChannel("update-proxy"); + updateProxy.onmessage = (event) => { + updateState(event.data); + }; + + const sabWriter = new WritableStream({ + async write(chunk) { + let waitCount = 0; + + while (true) { + if (rb.remaining >= chunk.byteLength + 2) { + const sizeBuff = new ArrayBuffer(2); + new DataView(sizeBuff).setUint16(0, chunk.byteLength); + rb.append(new Uint8Array(sizeBuff)); + rb.append(chunk); + return true; + } else { + waitCount++; + await sleep(100); + if (waitCount > 50) { + console.warn("Dropping packets due to backup"); + rb.clear(); + } + } + } + } + }); + + function updateCallback() { + if (pingOnUpdate) { + updateProxy.postMessage({done: true}); + pingOnUpdate = false; + } + } + + + async function main() { + const nic = await new NIC(undefined, new Uint8Array([34, 250, 80, 37, 2, 130])); + + nic.readable.pipeThrough(broadcastStream("eth_to_emu")); + + broadcastStream("eth_from_emu").readable.pipeThrough(nic); + + if (DEBUG) { + monitorChannel("eth_from_emu", " -> "); + monitorChannel("eth_to_emu", " <- "); + } + + if (pollSAB) { + broadcastStream("eth_to_emu").readable.pipeTo(sabWriter); + } + + nic.addIPv4(proxyIP); + + nic.startDHCPServer(proxyIP, "255.255.255.0"); + + if (clientIP && clientMAC) { + console.log("Adding ARP Entry", clientIP, clientMAC); + nic.addARPEntry(new Uint8Array(clientMAC), new Uint8Array(clientIP)); + } + + const server = new nic.TCPServerSocket({localPort: proxyPort, localAddress: proxyIP}); + + for await (const socket of iterator(server.readable.getReader())) { + new HttpProxyServer({socket, replayUrl, replayTs, proxyIP, homePage, proxyPort, updateCallback}).handleResponse(); + } + } + + + const printer = (tag, ...args) => new TransformStream({ + transform(v, c) { + console.log(...(tag ? [tag] : []), v); + c.enqueue(v); + } + }); + + + + async function monitorChannel(name, label) { + broadcastStream(name).readable + .pipeThrough(new EthernetParser) + .pipeThrough(printer("ether " + label)) + .pipeThrough(new IPv4Parser) + .pipeThrough(printer("ip " + label)) + .pipeTo(new WritableStream); + } + +})(); diff --git a/public/lib/picotcp/network-parser.js b/public/lib/picotcp/network-parser.js new file mode 100644 index 00000000..20f080e0 --- /dev/null +++ b/public/lib/picotcp/network-parser.js @@ -0,0 +1,93 @@ +// Copyright 2018 The Emulation-as-a-Service Authors. +// SPDX-License-Identifier: GPL-2.0-or-later + +import TransformStream from "./transform-stream.js"; + +/** + * @see + */ +export class UDPParser extends TransformStream { + /** + * @param {payload: Uint8Array} lower + * @param {*} controller + */ + static transform(lower, controller) { + const {payload} = lower; + const ret = { + source: payload[0] << 8 | payload[1], + dest: payload[2] << 8 | payload[3], + length: payload[4] << 8 | payload[5], + checksum: payload[6] << 8 | payload[7], + }; + Object.assign(ret, { + payload: payload.subarray(8, ret.length), + lower, + }); + controller.enqueue(ret); + } + constructor() {super(new.target);} +} + +/** + * @see + */ +export class IPv4Parser extends TransformStream { + /** + * @param {payload: Uint8Array} lower + * @param {*} controller + */ + static transform(lower, controller) { + const {type, payload} = lower; + if (type !== 0x800) return; + const ret = { + version: payload[0] >> 4, + ihl: payload[0] & 0b1111, + dscp: payload[1] >> 2, + ecn: payload[1] & 0b11, + length: payload[2] << 8 | payload[3], + id: payload[4] << 8 | payload[5], + flags: payload[6] >> 5, + fragmentOffset: (payload[6] & 0b11111) << 8 | payload[7], + ttl: payload[8], + /** @see */ + protocol: payload[9], + headerChecksum: payload[10] << 8 | payload[11], + source: payload.subarray(12, 12 + 4), + dest: payload.subarray(16, 16 + 4), + } + const headerLength = 20; + // TODO: options. + Object.assign(ret, { + payload: payload.subarray(headerLength, ret.length), + lower, + }); + controller.enqueue(ret); + } + constructor() {super(new.target);} +} + +self.all_packets = []; + +/** + * @see + */ +export class EthernetParser extends TransformStream { + constructor({crcLength = 0} = {}) { + super({ + /** + * @param {Uint8Array} frame + * @param {*} controller + */ + transform(frame, controller) { + self.all_packets.push(frame); + const dest = frame.subarray(0, 6); + const source = frame.subarray(6, 12); + /** @see */ + const type = frame[12] << 8 | frame[13]; + const payload = frame.subarray(14, crcLength ? -crcLength : undefined); + const crc = crcLength ? frame.subarray(-4) : null; + controller.enqueue({source, dest, type, payload, crc, lower: frame}); + } + }); + } +} diff --git a/public/lib/picotcp/picotcp.js b/public/lib/picotcp/picotcp.js new file mode 100644 index 00000000..cfe2e8c7 --- /dev/null +++ b/public/lib/picotcp/picotcp.js @@ -0,0 +1,6471 @@ + +var Module = (function() { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + return ( +function(Module) { + Module = Module || {}; + +// Copyright 2010 The Emscripten Authors. All rights reserved. +// Emscripten is available under two separate licenses, the MIT license and the +// University of Illinois/NCSA Open Source License. Both these licenses can be +// found in the LICENSE file. + +// The Module object: Our interface to the outside world. We import +// and export values on it. There are various ways Module can be used: +// 1. Not defined. We create it here +// 2. A function parameter, function(Module) { ..generated code.. } +// 3. pre-run appended it, var Module = {}; ..generated code.. +// 4. External script tag defines var Module. +// We need to check if Module already exists (e.g. case 3 above). +// Substitution will be replaced with actual code on later stage of the build, +// this way Closure Compiler will not mangle it (e.g. case 4. above). +// Note that if you want to run closure, and also to use Module +// after the generated code, you will need to define var Module = {}; +// before the code. Then that object will be used in the code, and you +// can continue to use Module afterwards as well. +var Module = typeof Module !== 'undefined' ? Module : {}; + +// --pre-jses are emitted after the Module integration code, so that they can +// refer to Module (if they choose; they can also define Module) +Module["locateFile"] = function(path) { + //let url = import.meta.url; + let url = self.location.href; + url = url.replace(/^file:\/\//, ""); + // HACK: Special case for Node.js on Windows + // (`url` will look like "file:///C:/..."). + // Would properly use `require("url").fileURLToPath(url)` + // on all Node.js platforms, which is not avaible + // on older Node.js versions, though. + try { + if (process.platform === "win32") url = url.replace(/^\/+/, ""); + } catch {} + return url + "/../" + path; +}; +Module["noExitRuntime"] = true; + +// HACK: Work around https://github.com/emscripten-core/emscripten/issues/7855 +// for Node.js: turn process.on("uncaughtException" | "unhandledRejection", ...) +// into no-op. +let process; +try { + process = new Proxy(global.process, { + get(target, key, receiver) { + const ret = Reflect.get(target, key, receiver); + if (key !== "on") return ret; + return new Proxy(ret, { + apply(target, thisArg, args) { + if (args[0] !== "uncaughtException" + && args[0] !== "unhandledRejection") { + return Reflect.apply(target, thisArg, args); + } + } + }); + } + }); +} catch {} + + + +// Sometimes an existing Module object exists with properties +// meant to overwrite the default module functionality. Here +// we collect those properties and reapply _after_ we configure +// the current environment's defaults to avoid having to be so +// defensive during initialization. +var moduleOverrides = {}; +var key; +for (key in Module) { + if (Module.hasOwnProperty(key)) { + moduleOverrides[key] = Module[key]; + } +} + +var arguments_ = []; +var thisProgram = './this.program'; +var quit_ = function(status, toThrow) { + throw toThrow; +}; + +// Determine the runtime environment we are in. You can customize this by +// setting the ENVIRONMENT setting at compile time (see settings.js). + +var ENVIRONMENT_IS_WEB = false; +var ENVIRONMENT_IS_WORKER = false; +var ENVIRONMENT_IS_NODE = false; +var ENVIRONMENT_HAS_NODE = false; +var ENVIRONMENT_IS_SHELL = false; +ENVIRONMENT_IS_WEB = typeof window === 'object'; +ENVIRONMENT_IS_WORKER = typeof importScripts === 'function'; +// A web environment like Electron.js can have Node enabled, so we must +// distinguish between Node-enabled environments and Node environments per se. +// This will allow the former to do things like mount NODEFS. +// Extended check using process.versions fixes issue #8816. +// (Also makes redundant the original check that 'require' is a function.) +ENVIRONMENT_HAS_NODE = typeof process === 'object' && typeof process.versions === 'object' && typeof process.versions.node === 'string'; +ENVIRONMENT_IS_NODE = ENVIRONMENT_HAS_NODE && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER; +ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; + + + + +// `/` should be present at the end if `scriptDirectory` is not empty +var scriptDirectory = ''; +function locateFile(path) { + if (Module['locateFile']) { + return Module['locateFile'](path, scriptDirectory); + } + return scriptDirectory + path; +} + +// Hooks that are implemented differently in different runtime environments. +var read_, + readAsync, + readBinary, + setWindowTitle; + +var nodeFS; +var nodePath; + +if (ENVIRONMENT_IS_NODE) { + scriptDirectory = __dirname + '/'; + + + read_ = function shell_read(filename, binary) { + var ret; + if (!nodeFS) nodeFS = require('fs'); + if (!nodePath) nodePath = require('path'); + filename = nodePath['normalize'](filename); + return nodeFS['readFileSync'](filename, binary ? null : 'utf8'); + }; + + readBinary = function readBinary(filename) { + var ret = read_(filename, true); + if (!ret.buffer) { + ret = new Uint8Array(ret); + } + assert(ret.buffer); + return ret; + }; + + + + + if (process['argv'].length > 1) { + thisProgram = process['argv'][1].replace(/\\/g, '/'); + } + + arguments_ = process['argv'].slice(2); + + // MODULARIZE will export the module in the proper place outside, we don't need to export here + + process['on']('uncaughtException', function(ex) { + // suppress ExitStatus exceptions from showing an error + if (!(ex instanceof ExitStatus)) { + throw ex; + } + }); + + process['on']('unhandledRejection', abort); + + quit_ = function(status) { + process['exit'](status); + }; + + Module['inspect'] = function () { return '[Emscripten Module object]'; }; + + +} else +if (ENVIRONMENT_IS_SHELL) { + + + if (typeof read != 'undefined') { + read_ = function shell_read(f) { + return read(f); + }; + } + + readBinary = function readBinary(f) { + var data; + if (typeof readbuffer === 'function') { + return new Uint8Array(readbuffer(f)); + } + data = read(f, 'binary'); + assert(typeof data === 'object'); + return data; + }; + + if (typeof scriptArgs != 'undefined') { + arguments_ = scriptArgs; + } else if (typeof arguments != 'undefined') { + arguments_ = arguments; + } + + if (typeof quit === 'function') { + quit_ = function(status) { + quit(status); + }; + } + + if (typeof print !== 'undefined') { + // Prefer to use print/printErr where they exist, as they usually work better. + if (typeof console === 'undefined') console = {}; + console.log = print; + console.warn = console.error = typeof printErr !== 'undefined' ? printErr : print; + } +} else + +// Note that this includes Node.js workers when relevant (pthreads is enabled). +// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and +// ENVIRONMENT_HAS_NODE. +if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled + scriptDirectory = self.location.href; + } else if (document.currentScript) { // web + scriptDirectory = document.currentScript.src; + } + // When MODULARIZE (and not _INSTANCE), this JS may be executed later, after document.currentScript + // is gone, so we saved it, and we use it here instead of any other info. + if (_scriptDir) { + scriptDirectory = _scriptDir; + } + // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them. + // otherwise, slice off the final part of the url to find the script directory. + // if scriptDirectory does not contain a slash, lastIndexOf will return -1, + // and scriptDirectory will correctly be replaced with an empty string. + if (scriptDirectory.indexOf('blob:') !== 0) { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf('/')+1); + } else { + scriptDirectory = ''; + } + + + // Differentiate the Web Worker from the Node Worker case, as reading must + // be done differently. + { + + + read_ = function shell_read(url) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.send(null); + return xhr.responseText; + }; + + if (ENVIRONMENT_IS_WORKER) { + readBinary = function readBinary(url) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.responseType = 'arraybuffer'; + xhr.send(null); + return new Uint8Array(xhr.response); + }; + } + + readAsync = function readAsync(url, onload, onerror) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'arraybuffer'; + xhr.onload = function xhr_onload() { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0 + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + }; + + + + + } + + setWindowTitle = function(title) { document.title = title }; +} else +{ +} + + +// Set up the out() and err() hooks, which are how we can print to stdout or +// stderr, respectively. +var out = Module['print'] || console.log.bind(console); +var err = Module['printErr'] || console.warn.bind(console); + +// Merge back in the overrides +for (key in moduleOverrides) { + if (moduleOverrides.hasOwnProperty(key)) { + Module[key] = moduleOverrides[key]; + } +} +// Free the object hierarchy contained in the overrides, this lets the GC +// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array. +moduleOverrides = null; + +// Emit code to handle expected values on the Module object. This applies Module.x +// to the proper local x. This has two benefits: first, we only emit it if it is +// expected to arrive, and second, by using a local everywhere else that can be +// minified. +if (Module['arguments']) arguments_ = Module['arguments']; +if (Module['thisProgram']) thisProgram = Module['thisProgram']; +if (Module['quit']) quit_ = Module['quit']; + +// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message + +// TODO remove when SDL2 is fixed (also see above) + + + +// Copyright 2017 The Emscripten Authors. All rights reserved. +// Emscripten is available under two separate licenses, the MIT license and the +// University of Illinois/NCSA Open Source License. Both these licenses can be +// found in the LICENSE file. + +// {{PREAMBLE_ADDITIONS}} + +var STACK_ALIGN = 16; + + +function dynamicAlloc(size) { + var ret = HEAP32[DYNAMICTOP_PTR>>2]; + var end = (ret + size + 15) & -16; + if (end > _emscripten_get_heap_size()) { + abort(); + } + HEAP32[DYNAMICTOP_PTR>>2] = end; + return ret; +} + +function alignMemory(size, factor) { + if (!factor) factor = STACK_ALIGN; // stack alignment (16-byte) by default + return Math.ceil(size / factor) * factor; +} + +function getNativeTypeSize(type) { + switch (type) { + case 'i1': case 'i8': return 1; + case 'i16': return 2; + case 'i32': return 4; + case 'i64': return 8; + case 'float': return 4; + case 'double': return 8; + default: { + if (type[type.length-1] === '*') { + return 4; // A pointer + } else if (type[0] === 'i') { + var bits = parseInt(type.substr(1)); + assert(bits % 8 === 0, 'getNativeTypeSize invalid bits ' + bits + ', type ' + type); + return bits / 8; + } else { + return 0; + } + } + } +} + +function warnOnce(text) { + if (!warnOnce.shown) warnOnce.shown = {}; + if (!warnOnce.shown[text]) { + warnOnce.shown[text] = 1; + err(text); + } +} + +var asm2wasmImports = { // special asm2wasm imports + "f64-rem": function(x, y) { + return x % y; + }, + "debugger": function() { + } +}; + + + +var jsCallStartIndex = 1; +var functionPointers = new Array(20); + +// Wraps a JS function as a wasm function with a given signature. +// In the future, we may get a WebAssembly.Function constructor. Until then, +// we create a wasm module that takes the JS function as an import with a given +// signature, and re-exports that as a wasm function. +function convertJsFunctionToWasm(func, sig) { + + // The module is static, with the exception of the type section, which is + // generated based on the signature passed in. + var typeSection = [ + 0x01, // id: section, + 0x00, // length: 0 (placeholder) + 0x01, // count: 1 + 0x60, // form: func + ]; + var sigRet = sig.slice(0, 1); + var sigParam = sig.slice(1); + var typeCodes = { + 'i': 0x7f, // i32 + 'j': 0x7e, // i64 + 'f': 0x7d, // f32 + 'd': 0x7c, // f64 + }; + + // Parameters, length + signatures + typeSection.push(sigParam.length); + for (var i = 0; i < sigParam.length; ++i) { + typeSection.push(typeCodes[sigParam[i]]); + } + + // Return values, length + signatures + // With no multi-return in MVP, either 0 (void) or 1 (anything else) + if (sigRet == 'v') { + typeSection.push(0x00); + } else { + typeSection = typeSection.concat([0x01, typeCodes[sigRet]]); + } + + // Write the overall length of the type section back into the section header + // (excepting the 2 bytes for the section id and length) + typeSection[1] = typeSection.length - 2; + + // Rest of the module is static + var bytes = new Uint8Array([ + 0x00, 0x61, 0x73, 0x6d, // magic ("\0asm") + 0x01, 0x00, 0x00, 0x00, // version: 1 + ].concat(typeSection, [ + 0x02, 0x07, // import section + // (import "e" "f" (func 0 (type 0))) + 0x01, 0x01, 0x65, 0x01, 0x66, 0x00, 0x00, + 0x07, 0x05, // export section + // (export "f" (func 0 (type 0))) + 0x01, 0x01, 0x66, 0x00, 0x00, + ])); + + // We can compile this wasm module synchronously because it is very small. + // This accepts an import (at "e.f"), that it reroutes to an export (at "f") + var module = new WebAssembly.Module(bytes); + var instance = new WebAssembly.Instance(module, { + e: { + f: func + } + }); + var wrappedFunc = instance.exports.f; + return wrappedFunc; +} + +// Add a wasm function to the table. +function addFunctionWasm(func, sig) { + var table = wasmTable; + var ret = table.length; + + // Grow the table + try { + table.grow(1); + } catch (err) { + if (!err instanceof RangeError) { + throw err; + } + throw 'Unable to grow wasm table. Use a higher value for RESERVED_FUNCTION_POINTERS or set ALLOW_TABLE_GROWTH.'; + } + + // Insert new element + try { + // Attempting to call this with JS function will cause of table.set() to fail + table.set(ret, func); + } catch (err) { + if (!err instanceof TypeError) { + throw err; + } + assert(typeof sig !== 'undefined', 'Missing signature argument to addFunction'); + var wrapped = convertJsFunctionToWasm(func, sig); + table.set(ret, wrapped); + } + + return ret; +} + +function removeFunctionWasm(index) { + // TODO(sbc): Look into implementing this to allow re-using of table slots +} + +// 'sig' parameter is required for the llvm backend but only when func is not +// already a WebAssembly function. +function addFunction(func, sig) { + + + var base = 0; + for (var i = base; i < base + 20; i++) { + if (!functionPointers[i]) { + functionPointers[i] = func; + return jsCallStartIndex + i; + } + } + throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.'; + +} + +function removeFunction(index) { + + functionPointers[index-jsCallStartIndex] = null; +} + +var funcWrappers = {}; + +function getFuncWrapper(func, sig) { + if (!func) return; // on null pointer, return undefined + assert(sig); + if (!funcWrappers[sig]) { + funcWrappers[sig] = {}; + } + var sigCache = funcWrappers[sig]; + if (!sigCache[func]) { + // optimize away arguments usage in common cases + if (sig.length === 1) { + sigCache[func] = function dynCall_wrapper() { + return dynCall(sig, func); + }; + } else if (sig.length === 2) { + sigCache[func] = function dynCall_wrapper(arg) { + return dynCall(sig, func, [arg]); + }; + } else { + // general case + sigCache[func] = function dynCall_wrapper() { + return dynCall(sig, func, Array.prototype.slice.call(arguments)); + }; + } + } + return sigCache[func]; +} + + +function makeBigInt(low, high, unsigned) { + return unsigned ? ((+((low>>>0)))+((+((high>>>0)))*4294967296.0)) : ((+((low>>>0)))+((+((high|0)))*4294967296.0)); +} + +function dynCall(sig, ptr, args) { + if (args && args.length) { + return Module['dynCall_' + sig].apply(null, [ptr].concat(args)); + } else { + return Module['dynCall_' + sig].call(null, ptr); + } +} + +var tempRet0 = 0; + +var setTempRet0 = function(value) { + tempRet0 = value; +}; + +var getTempRet0 = function() { + return tempRet0; +}; + + +var Runtime = { +}; + +// The address globals begin at. Very low in memory, for code size and optimization opportunities. +// Above 0 is static memory, starting with globals. +// Then the stack. +// Then 'dynamic' memory for sbrk. +var GLOBAL_BASE = 1024; + + + + +// === Preamble library stuff === + +// Documentation for the public APIs defined in this file must be updated in: +// site/source/docs/api_reference/preamble.js.rst +// A prebuilt local version of the documentation is available at: +// site/build/text/docs/api_reference/preamble.js.txt +// You can also build docs locally as HTML or other formats in site/ +// An online HTML version (which may be of a different version of Emscripten) +// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html + + +var wasmBinary;if (Module['wasmBinary']) wasmBinary = Module['wasmBinary']; +var noExitRuntime;if (Module['noExitRuntime']) noExitRuntime = Module['noExitRuntime']; + + +if (typeof WebAssembly !== 'object') { + err('no native wasm support detected'); +} + + +// In MINIMAL_RUNTIME, setValue() and getValue() are only available when building with safe heap enabled, for heap safety checking. +// In traditional runtime, setValue() and getValue() are always available (although their use is highly discouraged due to perf penalties) + +/** @type {function(number, number, string, boolean=)} */ +function setValue(ptr, value, type, noSafe) { + type = type || 'i8'; + if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit + switch(type) { + case 'i1': HEAP8[((ptr)>>0)]=value; break; + case 'i8': HEAP8[((ptr)>>0)]=value; break; + case 'i16': HEAP16[((ptr)>>1)]=value; break; + case 'i32': HEAP32[((ptr)>>2)]=value; break; + case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math_min((+(Math_floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break; + case 'float': HEAPF32[((ptr)>>2)]=value; break; + case 'double': HEAPF64[((ptr)>>3)]=value; break; + default: abort('invalid type for setValue: ' + type); + } +} + +/** @type {function(number, string, boolean=)} */ +function getValue(ptr, type, noSafe) { + type = type || 'i8'; + if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit + switch(type) { + case 'i1': return HEAP8[((ptr)>>0)]; + case 'i8': return HEAP8[((ptr)>>0)]; + case 'i16': return HEAP16[((ptr)>>1)]; + case 'i32': return HEAP32[((ptr)>>2)]; + case 'i64': return HEAP32[((ptr)>>2)]; + case 'float': return HEAPF32[((ptr)>>2)]; + case 'double': return HEAPF64[((ptr)>>3)]; + default: abort('invalid type for getValue: ' + type); + } + return null; +} + + + + + +// Wasm globals + +var wasmMemory; + +// In fastcomp asm.js, we don't need a wasm Table at all. +// In the wasm backend, we polyfill the WebAssembly object, +// so this creates a (non-native-wasm) table for us. +var wasmTable = new WebAssembly.Table({ + 'initial': 448, + 'maximum': 448, + 'element': 'anyfunc' +}); + + +//======================================== +// Runtime essentials +//======================================== + +// whether we are quitting the application. no code should run after this. +// set in exit() and abort() +var ABORT = false; + +// set by exit() and abort(). Passed to 'onExit' handler. +// NOTE: This is also used as the process return code code in shell environments +// but only when noExitRuntime is false. +var EXITSTATUS = 0; + +/** @type {function(*, string=)} */ +function assert(condition, text) { + if (!condition) { + abort('Assertion failed: ' + text); + } +} + +// Returns the C function with a specified identifier (for C++, you need to do manual name mangling) +function getCFunc(ident) { + var func = Module['_' + ident]; // closure exported function + assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported'); + return func; +} + +// C calling interface. +function ccall(ident, returnType, argTypes, args, opts) { + // For fast lookup of conversion functions + var toC = { + 'string': function(str) { + var ret = 0; + if (str !== null && str !== undefined && str !== 0) { // null string + // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0' + var len = (str.length << 2) + 1; + ret = stackAlloc(len); + stringToUTF8(str, ret, len); + } + return ret; + }, + 'array': function(arr) { + var ret = stackAlloc(arr.length); + writeArrayToMemory(arr, ret); + return ret; + } + }; + + function convertReturnValue(ret) { + if (returnType === 'string') return UTF8ToString(ret); + if (returnType === 'boolean') return Boolean(ret); + return ret; + } + + var func = getCFunc(ident); + var cArgs = []; + var stack = 0; + if (args) { + for (var i = 0; i < args.length; i++) { + var converter = toC[argTypes[i]]; + if (converter) { + if (stack === 0) stack = stackSave(); + cArgs[i] = converter(args[i]); + } else { + cArgs[i] = args[i]; + } + } + } + var ret = func.apply(null, cArgs); + + ret = convertReturnValue(ret); + if (stack !== 0) stackRestore(stack); + return ret; +} + +function cwrap(ident, returnType, argTypes, opts) { + argTypes = argTypes || []; + // When the function takes numbers and returns a number, we can just return + // the original function + var numericArgs = argTypes.every(function(type){ return type === 'number'}); + var numericRet = returnType !== 'string'; + if (numericRet && numericArgs && !opts) { + return getCFunc(ident); + } + return function() { + return ccall(ident, returnType, argTypes, arguments, opts); + } +} + +var ALLOC_NORMAL = 0; // Tries to use _malloc() +var ALLOC_STACK = 1; // Lives for the duration of the current function call +var ALLOC_DYNAMIC = 2; // Cannot be freed except through sbrk +var ALLOC_NONE = 3; // Do not allocate + +// allocate(): This is for internal use. You can use it yourself as well, but the interface +// is a little tricky (see docs right below). The reason is that it is optimized +// for multiple syntaxes to save space in generated code. So you should +// normally not use allocate(), and instead allocate memory using _malloc(), +// initialize it with setValue(), and so forth. +// @slab: An array of data, or a number. If a number, then the size of the block to allocate, +// in *bytes* (note that this is sometimes confusing: the next parameter does not +// affect this!) +// @types: Either an array of types, one for each byte (or 0 if no type at that position), +// or a single type which is used for the entire block. This only matters if there +// is initial data - if @slab is a number, then this does not matter at all and is +// ignored. +// @allocator: How to allocate memory, see ALLOC_* +/** @type {function((TypedArray|Array|number), string, number, number=)} */ +function allocate(slab, types, allocator, ptr) { + var zeroinit, size; + if (typeof slab === 'number') { + zeroinit = true; + size = slab; + } else { + zeroinit = false; + size = slab.length; + } + + var singleType = typeof types === 'string' ? types : null; + + var ret; + if (allocator == ALLOC_NONE) { + ret = ptr; + } else { + ret = [_malloc, + stackAlloc, + dynamicAlloc][allocator](Math.max(size, singleType ? 1 : types.length)); + } + + if (zeroinit) { + var stop; + ptr = ret; + assert((ret & 3) == 0); + stop = ret + (size & ~3); + for (; ptr < stop; ptr += 4) { + HEAP32[((ptr)>>2)]=0; + } + stop = ret + size; + while (ptr < stop) { + HEAP8[((ptr++)>>0)]=0; + } + return ret; + } + + if (singleType === 'i8') { + if (slab.subarray || slab.slice) { + HEAPU8.set(/** @type {!Uint8Array} */ (slab), ret); + } else { + HEAPU8.set(new Uint8Array(slab), ret); + } + return ret; + } + + var i = 0, type, typeSize, previousType; + while (i < size) { + var curr = slab[i]; + + type = singleType || types[i]; + if (type === 0) { + i++; + continue; + } + + if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later + + setValue(ret+i, curr, type); + + // no need to look up size unless type changes, so cache it + if (previousType !== type) { + typeSize = getNativeTypeSize(type); + previousType = type; + } + i += typeSize; + } + + return ret; +} + +// Allocate memory during any stage of startup - static memory early on, dynamic memory later, malloc when ready +function getMemory(size) { + if (!runtimeInitialized) return dynamicAlloc(size); + return _malloc(size); +} + + + + +/** @type {function(number, number=)} */ +function Pointer_stringify(ptr, length) { + abort("this function has been removed - you should use UTF8ToString(ptr, maxBytesToRead) instead!"); +} + +// Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns +// a copy of that string as a Javascript String object. + +function AsciiToString(ptr) { + var str = ''; + while (1) { + var ch = HEAPU8[((ptr++)>>0)]; + if (!ch) return str; + str += String.fromCharCode(ch); + } +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP. + +function stringToAscii(str, outPtr) { + return writeAsciiToMemory(str, outPtr, false); +} + + +// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns +// a copy of that string as a Javascript String object. + +var UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined; + +/** + * @param {number} idx + * @param {number=} maxBytesToRead + * @return {string} + */ +function UTF8ArrayToString(u8Array, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. + // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. + // (As a tiny code save trick, compare endPtr against endIdx using a negation, so that undefined means Infinity) + while (u8Array[endPtr] && !(endPtr >= endIdx)) ++endPtr; + + if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) { + return UTF8Decoder.decode(u8Array.subarray(idx, endPtr)); + } else { + var str = ''; + // If building with TextDecoder, we have already computed the string length above, so test loop end condition against that + while (idx < endPtr) { + // For UTF8 byte structure, see: + // http://en.wikipedia.org/wiki/UTF-8#Description + // https://www.ietf.org/rfc/rfc2279.txt + // https://tools.ietf.org/html/rfc3629 + var u0 = u8Array[idx++]; + if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } + var u1 = u8Array[idx++] & 63; + if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } + var u2 = u8Array[idx++] & 63; + if ((u0 & 0xF0) == 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (u8Array[idx++] & 63); + } + + if (u0 < 0x10000) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } + } + } + return str; +} + +// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns a +// copy of that string as a Javascript String object. +// maxBytesToRead: an optional length that specifies the maximum number of bytes to read. You can omit +// this parameter to scan the string until the first \0 byte. If maxBytesToRead is +// passed, and the string at [ptr, ptr+maxBytesToReadr[ contains a null byte in the +// middle, then the string will cut short at that byte index (i.e. maxBytesToRead will +// not produce a string of exact length [ptr, ptr+maxBytesToRead[) +// N.B. mixing frequent uses of UTF8ToString() with and without maxBytesToRead may +// throw JS JIT optimizations off, so it is worth to consider consistently using one +// style or the other. +/** + * @param {number} ptr + * @param {number=} maxBytesToRead + * @return {string} + */ +function UTF8ToString(ptr, maxBytesToRead) { + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ''; +} + +// Copies the given Javascript String object 'str' to the given byte array at address 'outIdx', +// encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP. +// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// outU8Array: the array to copy to. Each index in this array is assumed to be one 8-byte element. +// outIdx: The starting offset in the array to begin the copying. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. +// This count should include the null terminator, +// i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else. +// maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) { + if (!(maxBytesToWrite > 0)) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes. + return 0; + + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator. + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) { + var u1 = str.charCodeAt(++i); + u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF); + } + if (u <= 0x7F) { + if (outIdx >= endIdx) break; + outU8Array[outIdx++] = u; + } else if (u <= 0x7FF) { + if (outIdx + 1 >= endIdx) break; + outU8Array[outIdx++] = 0xC0 | (u >> 6); + outU8Array[outIdx++] = 0x80 | (u & 63); + } else if (u <= 0xFFFF) { + if (outIdx + 2 >= endIdx) break; + outU8Array[outIdx++] = 0xE0 | (u >> 12); + outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); + outU8Array[outIdx++] = 0x80 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + outU8Array[outIdx++] = 0xF0 | (u >> 18); + outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63); + outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); + outU8Array[outIdx++] = 0x80 | (u & 63); + } + } + // Null-terminate the pointer to the buffer. + outU8Array[outIdx] = 0; + return outIdx - startIdx; +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP. +// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF8(str, outPtr, maxBytesToWrite) { + return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite); +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte. +function lengthBytesUTF8(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF); + if (u <= 0x7F) ++len; + else if (u <= 0x7FF) len += 2; + else if (u <= 0xFFFF) len += 3; + else len += 4; + } + return len; +} + + +// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns +// a copy of that string as a Javascript String object. + +var UTF16Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-16le') : undefined; +function UTF16ToString(ptr) { + var endPtr = ptr; + // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. + // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. + var idx = endPtr >> 1; + while (HEAP16[idx]) ++idx; + endPtr = idx << 1; + + if (endPtr - ptr > 32 && UTF16Decoder) { + return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); + } else { + var i = 0; + + var str = ''; + while (1) { + var codeUnit = HEAP16[(((ptr)+(i*2))>>1)]; + if (codeUnit == 0) return str; + ++i; + // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through. + str += String.fromCharCode(codeUnit); + } + } +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP. +// Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// outPtr: Byte address in Emscripten HEAP where to write the string to. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null +// terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else. +// maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF16(str, outPtr, maxBytesToWrite) { + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; // Null terminator. + var startPtr = outPtr; + var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + HEAP16[((outPtr)>>1)]=codeUnit; + outPtr += 2; + } + // Null-terminate the pointer to the HEAP. + HEAP16[((outPtr)>>1)]=0; + return outPtr - startPtr; +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. + +function lengthBytesUTF16(str) { + return str.length*2; +} + +function UTF32ToString(ptr) { + var i = 0; + + var str = ''; + while (1) { + var utf32 = HEAP32[(((ptr)+(i*4))>>2)]; + if (utf32 == 0) + return str; + ++i; + // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + if (utf32 >= 0x10000) { + var ch = utf32 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } else { + str += String.fromCharCode(utf32); + } + } +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP. +// Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// outPtr: Byte address in Emscripten HEAP where to write the string to. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null +// terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else. +// maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF32(str, outPtr, maxBytesToWrite) { + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF); + } + HEAP32[((outPtr)>>2)]=codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + // Null-terminate the pointer to the HEAP. + HEAP32[((outPtr)>>2)]=0; + return outPtr - startPtr; +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. + +function lengthBytesUTF32(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate. + len += 4; + } + + return len; +} + +// Allocate heap space for a JS string, and write it there. +// It is the responsibility of the caller to free() that memory. +function allocateUTF8(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = _malloc(size); + if (ret) stringToUTF8Array(str, HEAP8, ret, size); + return ret; +} + +// Allocate stack space for a JS string, and write it there. +function allocateUTF8OnStack(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = stackAlloc(size); + stringToUTF8Array(str, HEAP8, ret, size); + return ret; +} + +// Deprecated: This function should not be called because it is unsafe and does not provide +// a maximum length limit of how many bytes it is allowed to write. Prefer calling the +// function stringToUTF8Array() instead, which takes in a maximum length that can be used +// to be secure from out of bounds writes. +/** @deprecated */ +function writeStringToMemory(string, buffer, dontAddNull) { + warnOnce('writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!'); + + var /** @type {number} */ lastChar, /** @type {number} */ end; + if (dontAddNull) { + // stringToUTF8Array always appends null. If we don't want to do that, remember the + // character that existed at the location where the null will be placed, and restore + // that after the write (below). + end = buffer + lengthBytesUTF8(string); + lastChar = HEAP8[end]; + } + stringToUTF8(string, buffer, Infinity); + if (dontAddNull) HEAP8[end] = lastChar; // Restore the value under the null character. +} + +function writeArrayToMemory(array, buffer) { + HEAP8.set(array, buffer); +} + +function writeAsciiToMemory(str, buffer, dontAddNull) { + for (var i = 0; i < str.length; ++i) { + HEAP8[((buffer++)>>0)]=str.charCodeAt(i); + } + // Null-terminate the pointer to the HEAP. + if (!dontAddNull) HEAP8[((buffer)>>0)]=0; +} + + + + +// Memory management + +var PAGE_SIZE = 16384; +var WASM_PAGE_SIZE = 65536; +var ASMJS_PAGE_SIZE = 16777216; + +function alignUp(x, multiple) { + if (x % multiple > 0) { + x += multiple - (x % multiple); + } + return x; +} + +var HEAP, +/** @type {ArrayBuffer} */ + buffer, +/** @type {Int8Array} */ + HEAP8, +/** @type {Uint8Array} */ + HEAPU8, +/** @type {Int16Array} */ + HEAP16, +/** @type {Uint16Array} */ + HEAPU16, +/** @type {Int32Array} */ + HEAP32, +/** @type {Uint32Array} */ + HEAPU32, +/** @type {Float32Array} */ + HEAPF32, +/** @type {Float64Array} */ + HEAPF64; + +function updateGlobalBufferAndViews(buf) { + buffer = buf; + Module['HEAP8'] = HEAP8 = new Int8Array(buf); + Module['HEAP16'] = HEAP16 = new Int16Array(buf); + Module['HEAP32'] = HEAP32 = new Int32Array(buf); + Module['HEAPU8'] = HEAPU8 = new Uint8Array(buf); + Module['HEAPU16'] = HEAPU16 = new Uint16Array(buf); + Module['HEAPU32'] = HEAPU32 = new Uint32Array(buf); + Module['HEAPF32'] = HEAPF32 = new Float32Array(buf); + Module['HEAPF64'] = HEAPF64 = new Float64Array(buf); +} + +var STATIC_BASE = 1024, + STACK_BASE = 13360, + STACKTOP = STACK_BASE, + STACK_MAX = 5256240, + DYNAMIC_BASE = 5256240, + DYNAMICTOP_PTR = 13168; + + + + +var TOTAL_STACK = 5242880; + +var INITIAL_TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 16777216; + + + + + + + +// In standalone mode, the wasm creates the memory, and the user can't provide it. +// In non-standalone/normal mode, we create the memory here. + +// Create the main memory. (Note: this isn't used in STANDALONE_WASM mode since the wasm +// memory is created in the wasm, not in JS.) + + if (Module['wasmMemory']) { + wasmMemory = Module['wasmMemory']; + } else + { + wasmMemory = new WebAssembly.Memory({ + 'initial': INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE + , + 'maximum': INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE + }); + } + + +if (wasmMemory) { + buffer = wasmMemory.buffer; +} + +// If the user provides an incorrect length, just use that length instead rather than providing the user to +// specifically provide the memory length with Module['TOTAL_MEMORY']. +INITIAL_TOTAL_MEMORY = buffer.byteLength; +updateGlobalBufferAndViews(buffer); + +HEAP32[DYNAMICTOP_PTR>>2] = DYNAMIC_BASE; + + + + + + + + + + +function callRuntimeCallbacks(callbacks) { + while(callbacks.length > 0) { + var callback = callbacks.shift(); + if (typeof callback == 'function') { + callback(); + continue; + } + var func = callback.func; + if (typeof func === 'number') { + if (callback.arg === undefined) { + Module['dynCall_v'](func); + } else { + Module['dynCall_vi'](func, callback.arg); + } + } else { + func(callback.arg === undefined ? null : callback.arg); + } + } +} + +var __ATPRERUN__ = []; // functions called before the runtime is initialized +var __ATINIT__ = []; // functions called during startup +var __ATMAIN__ = []; // functions called when main() is to be run +var __ATEXIT__ = []; // functions called during shutdown +var __ATPOSTRUN__ = []; // functions called after the main() is called + +var runtimeInitialized = false; +var runtimeExited = false; + + +function preRun() { + + if (Module['preRun']) { + if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']]; + while (Module['preRun'].length) { + addOnPreRun(Module['preRun'].shift()); + } + } + + callRuntimeCallbacks(__ATPRERUN__); +} + +function initRuntime() { + runtimeInitialized = true; + + callRuntimeCallbacks(__ATINIT__); +} + +function preMain() { + + callRuntimeCallbacks(__ATMAIN__); +} + +function exitRuntime() { + runtimeExited = true; +} + +function postRun() { + + if (Module['postRun']) { + if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']]; + while (Module['postRun'].length) { + addOnPostRun(Module['postRun'].shift()); + } + } + + callRuntimeCallbacks(__ATPOSTRUN__); +} + +function addOnPreRun(cb) { + __ATPRERUN__.unshift(cb); +} + +function addOnInit(cb) { + __ATINIT__.unshift(cb); +} + +function addOnPreMain(cb) { + __ATMAIN__.unshift(cb); +} + +function addOnExit(cb) { +} + +function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); +} + +function unSign(value, bits, ignore) { + if (value >= 0) { + return value; + } + return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts + : Math.pow(2, bits) + value; +} +function reSign(value, bits, ignore) { + if (value <= 0) { + return value; + } + var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32 + : Math.pow(2, bits-1); + if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that + // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors + // TODO: In i64 mode 1, resign the two parts separately and safely + value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts + } + return value; +} + + + +var Math_abs = Math.abs; +var Math_cos = Math.cos; +var Math_sin = Math.sin; +var Math_tan = Math.tan; +var Math_acos = Math.acos; +var Math_asin = Math.asin; +var Math_atan = Math.atan; +var Math_atan2 = Math.atan2; +var Math_exp = Math.exp; +var Math_log = Math.log; +var Math_sqrt = Math.sqrt; +var Math_ceil = Math.ceil; +var Math_floor = Math.floor; +var Math_pow = Math.pow; +var Math_imul = Math.imul; +var Math_fround = Math.fround; +var Math_round = Math.round; +var Math_min = Math.min; +var Math_max = Math.max; +var Math_clz32 = Math.clz32; +var Math_trunc = Math.trunc; + + + +// A counter of dependencies for calling run(). If we need to +// do asynchronous work before running, increment this and +// decrement it. Incrementing must happen in a place like +// Module.preRun (used by emcc to add file preloading). +// Note that you can add dependencies in preRun, even though +// it happens right before run - run will be postponed until +// the dependencies are met. +var runDependencies = 0; +var runDependencyWatcher = null; +var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled + +function getUniqueRunDependency(id) { + return id; +} + +function addRunDependency(id) { + runDependencies++; + + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + +} + +function removeRunDependency(id) { + runDependencies--; + + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); // can add another dependenciesFulfilled + } + } +} + +Module["preloadedImages"] = {}; // maps url to image data +Module["preloadedAudios"] = {}; // maps url to audio data + + +function abort(what) { + if (Module['onAbort']) { + Module['onAbort'](what); + } + + what += ''; + out(what); + err(what); + + ABORT = true; + EXITSTATUS = 1; + + what = 'abort(' + what + '). Build with -s ASSERTIONS=1 for more info.'; + + // Throw a wasm runtime error, because a JS error might be seen as a foreign + // exception, which means we'd run destructors on it. We need the error to + // simply make the program stop. + throw new WebAssembly.RuntimeError(what); +} + + +var memoryInitializer = null; + + + + + + + +// Copyright 2017 The Emscripten Authors. All rights reserved. +// Emscripten is available under two separate licenses, the MIT license and the +// University of Illinois/NCSA Open Source License. Both these licenses can be +// found in the LICENSE file. + +// Prefix of data URIs emitted by SINGLE_FILE and related options. +var dataURIPrefix = 'data:application/octet-stream;base64,'; + +// Indicates whether filename is a base64 data URI. +function isDataURI(filename) { + return String.prototype.startsWith ? + filename.startsWith(dataURIPrefix) : + filename.indexOf(dataURIPrefix) === 0; +} + + + + +var wasmBinaryFile = 'picotcp.wasm'; +if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = locateFile(wasmBinaryFile); +} + +function getBinary() { + try { + if (wasmBinary) { + return new Uint8Array(wasmBinary); + } + + if (readBinary) { + return readBinary(wasmBinaryFile); + } else { + throw "both async and sync fetching of the wasm failed"; + } + } + catch (err) { + abort(err); + } +} + +function getBinaryPromise() { + // if we don't have the binary yet, and have the Fetch api, use that + // in some environments, like Electron's render process, Fetch api may be present, but have a different context than expected, let's only use it on the Web + if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === 'function') { + return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function(response) { + if (!response['ok']) { + throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"; + } + return response['arrayBuffer'](); + }).catch(function () { + return getBinary(); + }); + } + // Otherwise, getBinary should be able to get it synchronously + return new Promise(function(resolve, reject) { + resolve(getBinary()); + }); +} + + + +// Create the wasm instance. +// Receives the wasm imports, returns the exports. +function createWasm() { + // prepare imports + var info = { + 'env': asmLibraryArg, + 'wasi_unstable': asmLibraryArg + , + 'global': { + 'NaN': NaN, + 'Infinity': Infinity + }, + 'global.Math': Math, + 'asm2wasm': asm2wasmImports + }; + // Load the wasm module and create an instance of using native support in the JS engine. + // handle a generated wasm instance, receiving its exports and + // performing other necessary setup + function receiveInstance(instance, module) { + var exports = instance.exports; + Module['asm'] = exports; + removeRunDependency('wasm-instantiate'); + } + // we can't run yet (except in a pthread, where we have a custom sync instantiator) + addRunDependency('wasm-instantiate'); + + + function receiveInstantiatedSource(output) { + // 'output' is a WebAssemblyInstantiatedSource object which has both the module and instance. + // receiveInstance() will swap in the exports (to Module.asm) so they can be called + // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. + // When the regression is fixed, can restore the above USE_PTHREADS-enabled path. + receiveInstance(output['instance']); + } + + + function instantiateArrayBuffer(receiver) { + return getBinaryPromise().then(function(binary) { + return WebAssembly.instantiate(binary, info); + }).then(receiver, function(reason) { + err('failed to asynchronously prepare wasm: ' + reason); + abort(reason); + }); + } + + // Prefer streaming instantiation if available. + function instantiateAsync() { + if (!wasmBinary && + typeof WebAssembly.instantiateStreaming === 'function' && + !isDataURI(wasmBinaryFile) && + typeof fetch === 'function') { + fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function (response) { + var result = WebAssembly.instantiateStreaming(response, info); + return result.then(receiveInstantiatedSource, function(reason) { + // We expect the most common failure cause to be a bad MIME type for the binary, + // in which case falling back to ArrayBuffer instantiation should work. + err('wasm streaming compile failed: ' + reason); + err('falling back to ArrayBuffer instantiation'); + instantiateArrayBuffer(receiveInstantiatedSource); + }); + }); + } else { + return instantiateArrayBuffer(receiveInstantiatedSource); + } + } + // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback + // to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel + // to any other async startup actions they are performing. + if (Module['instantiateWasm']) { + try { + var exports = Module['instantiateWasm'](info, receiveInstance); + return exports; + } catch(e) { + err('Module.instantiateWasm callback failed with error: ' + e); + return false; + } + } + + instantiateAsync(); + return {}; // no exports yet; we'll fill them in later +} + +Module['asm'] = createWasm; + +// Globals used by JS i64 conversions +var tempDouble; +var tempI64; + +// === Body === + +var ASM_CONSTS = [function($0) { Module.pointers[$0] = { writable: new SyncReadableWritableStream(), readable: new SyncWritableReadableStream(), }; }, + function($0, $1, $2, $3) { Module.pointers[$0] = { writable: new SyncReadableWritableStream(), readable: new SyncWritableReadableStream(), remoteIP: $1, remotePort: $2, }; Module.pointers[$3].readable._write(Module.pointers[$0]); }, + function($0) { Module.pointers[$0].readable.error(); }, + function($0, $1, $2) { Module.pointers[$0].readable._write(HEAPU8.slice($1, $1 + $2)); }, + function($0, $1) { const device = Module.pointers[$0]; const buffer = device.writable._read(); if (buffer === device.writable.EOF) return -1; if (!buffer) device.writable._onData = () => { Module._js_wakeup($1, $0); }; if (!buffer) return 0; Module._readBuffer = buffer; return buffer.byteLength; }, + function($0) { writeArrayToMemory(Module._readBuffer, $0); }, + function($0, $1) { const _unread = (reader, value) => { reader._read = new Proxy(reader._read, { apply(target, thisArg, args) { thisArg._read = target; return value; } }); }; const device = Module.pointers[$0]; if ($1 < Module._readBuffer.byteLength) { _unread(device.writable, Module._readBuffer.subarray($1)); } Module._readBuffer = null; }, + function($0) { Module.pointers[$0] && Module.pointers[$0]._readable && Module.pointers[$0].readable._close(); }, + function($0, $1) { Module.pointers[$0] = { name: UTF8ToString($1), writable: new SyncReadableWritableStream(), readable: new SyncWritableReadableStream(), }; }, + function($0) { return Module.pointers[$0].readable.desiredSize }, + function($0, $1, $2) { Module.pointers[$0].readable._write(HEAPU8.slice($1, $1 + $2)) }, + function($0) { const device = Module.pointers[$0]; const buffer = device.writable._read(); if (!buffer) return 0; Module._readBuffer = buffer; return buffer.byteLength; }, + function($0) { writeArrayToMemory(Module._readBuffer, $0); Module._readBuffer = null; }, + function() { Module._readBuffer = null; Module.pointers = {}; }]; + +function _emscripten_asm_const_i(code) { + return ASM_CONSTS[code](); +} + +function _emscripten_asm_const_iii(code, a0, a1) { + return ASM_CONSTS[code](a0, a1); +} + +function _emscripten_asm_const_iiiii(code, a0, a1, a2, a3) { + return ASM_CONSTS[code](a0, a1, a2, a3); +} + +function _emscripten_asm_const_ii(code, a0) { + return ASM_CONSTS[code](a0); +} + +function _emscripten_asm_const_iiii(code, a0, a1, a2) { + return ASM_CONSTS[code](a0, a1, a2); +} + +function _emscripten_asm_const_di(code, a0) { + return ASM_CONSTS[code](a0); +} + + + + +// STATICTOP = STATIC_BASE + 12336; +/* global initializers */ /*__ATINIT__.push();*/ + + + + + + + + +/* no memory initializer */ +var tempDoublePtr = 13344 + +function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much + HEAP8[tempDoublePtr] = HEAP8[ptr]; + HEAP8[tempDoublePtr+1] = HEAP8[ptr+1]; + HEAP8[tempDoublePtr+2] = HEAP8[ptr+2]; + HEAP8[tempDoublePtr+3] = HEAP8[ptr+3]; +} + +function copyTempDouble(ptr) { + HEAP8[tempDoublePtr] = HEAP8[ptr]; + HEAP8[tempDoublePtr+1] = HEAP8[ptr+1]; + HEAP8[tempDoublePtr+2] = HEAP8[ptr+2]; + HEAP8[tempDoublePtr+3] = HEAP8[ptr+3]; + HEAP8[tempDoublePtr+4] = HEAP8[ptr+4]; + HEAP8[tempDoublePtr+5] = HEAP8[ptr+5]; + HEAP8[tempDoublePtr+6] = HEAP8[ptr+6]; + HEAP8[tempDoublePtr+7] = HEAP8[ptr+7]; +} + +// {{PRE_LIBRARY}} + + + function demangle(func) { + return func; + } + Module["demangle"] = demangle; + + function demangleAll(text) { + var regex = + /\b__Z[\w\d_]+/g; + return text.replace(regex, + function(x) { + var y = demangle(x); + return x === y ? x : (y + ' [' + x + ']'); + }); + } + Module["demangleAll"] = demangleAll; + + function jsStackTrace() { + var err = new Error(); + if (!err.stack) { + // IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown, + // so try that as a special-case. + try { + throw new Error(0); + } catch(e) { + err = e; + } + if (!err.stack) { + return '(no stack trace available)'; + } + } + return err.stack.toString(); + } + Module["jsStackTrace"] = jsStackTrace; + + function stackTrace() { + var js = jsStackTrace(); + if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace'](); + return demangleAll(js); + } + Module["stackTrace"] = stackTrace; + + + + function flush_NO_FILESYSTEM() { + // flush anything remaining in the buffers during shutdown + var fflush = Module["_fflush"]; + if (fflush) fflush(0); + var buffers = SYSCALLS.buffers; + if (buffers[1].length) SYSCALLS.printChar(1, 10); + if (buffers[2].length) SYSCALLS.printChar(2, 10); + } + Module["flush_NO_FILESYSTEM"] = flush_NO_FILESYSTEM; + + + var PATH={splitPath:function (filename) { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1); + },normalizeArray:function (parts, allowAboveRoot) { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift('..'); + } + } + return parts; + },normalize:function (path) { + var isAbsolute = path.charAt(0) === '/', + trailingSlash = path.substr(-1) === '/'; + // Normalize the path + path = PATH.normalizeArray(path.split('/').filter(function(p) { + return !!p; + }), !isAbsolute).join('/'); + if (!path && !isAbsolute) { + path = '.'; + } + if (path && trailingSlash) { + path += '/'; + } + return (isAbsolute ? '/' : '') + path; + },dirname:function (path) { + var result = PATH.splitPath(path), + root = result[0], + dir = result[1]; + if (!root && !dir) { + // No dirname whatsoever + return '.'; + } + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + },basename:function (path) { + // EMSCRIPTEN return '/'' for '/', not an empty string + if (path === '/') return '/'; + var lastSlash = path.lastIndexOf('/'); + if (lastSlash === -1) return path; + return path.substr(lastSlash+1); + },extname:function (path) { + return PATH.splitPath(path)[3]; + },join:function () { + var paths = Array.prototype.slice.call(arguments, 0); + return PATH.normalize(paths.join('/')); + },join2:function (l, r) { + return PATH.normalize(l + '/' + r); + }}; + Module["PATH"] = PATH;var SYSCALLS={buffers:[null,[],[]],printChar:function (stream, curr) { + var buffer = SYSCALLS.buffers[stream]; + if (curr === 0 || curr === 10) { + (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0)); + buffer.length = 0; + } else { + buffer.push(curr); + } + },varargs:0,get:function (varargs) { + SYSCALLS.varargs += 4; + var ret = HEAP32[(((SYSCALLS.varargs)-(4))>>2)]; + return ret; + },getStr:function () { + var ret = UTF8ToString(SYSCALLS.get()); + return ret; + },get64:function () { + var low = SYSCALLS.get(), high = SYSCALLS.get(); + return low; + },getZero:function () { + SYSCALLS.get(); + }}; + Module["SYSCALLS"] = SYSCALLS;function _fd_write(fd, iov, iovcnt, pnum) {try { + + // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0 + var num = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAP32[(((iov)+(i*8))>>2)]; + var len = HEAP32[(((iov)+(i*8 + 4))>>2)]; + for (var j = 0; j < len; j++) { + SYSCALLS.printChar(fd, HEAPU8[ptr+j]); + } + num += len; + } + HEAP32[((pnum)>>2)]=num + return 0; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return e.errno; + } + } + Module["_fd_write"] = _fd_write;function ___wasi_fd_write() { + return _fd_write.apply(null, arguments) + } + Module["___wasi_fd_write"] = ___wasi_fd_write; + + function _abort() { + abort(); + } + Module["_abort"] = _abort; + + var _emscripten_asm_const_double=true; + Module["_emscripten_asm_const_double"] = _emscripten_asm_const_double; + + var _emscripten_asm_const_int=true; + Module["_emscripten_asm_const_int"] = _emscripten_asm_const_int; + + function _emscripten_get_heap_size() { + return HEAP8.length; + } + Module["_emscripten_get_heap_size"] = _emscripten_get_heap_size; + + + + + function abortOnCannotGrowMemory(requestedSize) { + abort('OOM'); + } + Module["abortOnCannotGrowMemory"] = abortOnCannotGrowMemory;function _emscripten_resize_heap(requestedSize) { + abortOnCannotGrowMemory(requestedSize); + } + Module["_emscripten_resize_heap"] = _emscripten_resize_heap; + + function _gettimeofday(ptr) { + var now = Date.now(); + HEAP32[((ptr)>>2)]=(now/1000)|0; // seconds + HEAP32[(((ptr)+(4))>>2)]=((now % 1000)*1000)|0; // microseconds + return 0; + } + Module["_gettimeofday"] = _gettimeofday; + + + + + + + function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.set(HEAPU8.subarray(src, src+num), dest); + } + Module["_emscripten_memcpy_big"] = _emscripten_memcpy_big; + + + + +var ASSERTIONS = false; + +// Copyright 2017 The Emscripten Authors. All rights reserved. +// Emscripten is available under two separate licenses, the MIT license and the +// University of Illinois/NCSA Open Source License. Both these licenses can be +// found in the LICENSE file. + +/** @type {function(string, boolean=, number=)} */ +function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy)+1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) u8array.length = numBytesWritten; + return u8array; +} + +function intArrayToString(array) { + var ret = []; + for (var i = 0; i < array.length; i++) { + var chr = array[i]; + if (chr > 0xFF) { + if (ASSERTIONS) { + assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ') at offset ' + i + ' not in 0x00-0xFF.'); + } + chr &= 0xFF; + } + ret.push(String.fromCharCode(chr)); + } + return ret.join(''); +} + + +// ASM_LIBRARY EXTERN PRIMITIVES: Int8Array,Int32Array + + +function jsCall_ii(index,a1) { + return functionPointers[index](a1); +} + +function jsCall_iidiiii(index,a1,a2,a3,a4,a5,a6) { + return functionPointers[index](a1,a2,a3,a4,a5,a6); +} + +function jsCall_iii(index,a1,a2) { + return functionPointers[index](a1,a2); +} + +function jsCall_iiii(index,a1,a2,a3) { + return functionPointers[index](a1,a2,a3); +} + +function jsCall_jiji(index,a1,a2,a3) { + return functionPointers[index](a1,a2,a3); +} + +function jsCall_vi(index,a1) { + functionPointers[index](a1); +} + +function jsCall_vii(index,a1,a2) { + functionPointers[index](a1,a2); +} + +function jsCall_viiii(index,a1,a2,a3,a4) { + functionPointers[index](a1,a2,a3,a4); +} + +function jsCall_vji(index,a1,a2) { + functionPointers[index](a1,a2); +} + +var asmGlobalArg = {}; + +var asmLibraryArg = { "___wasi_fd_write": ___wasi_fd_write, "__memory_base": 1024, "__table_base": 0, "_abort": _abort, "_emscripten_asm_const_di": _emscripten_asm_const_di, "_emscripten_asm_const_i": _emscripten_asm_const_i, "_emscripten_asm_const_ii": _emscripten_asm_const_ii, "_emscripten_asm_const_iii": _emscripten_asm_const_iii, "_emscripten_asm_const_iiii": _emscripten_asm_const_iiii, "_emscripten_asm_const_iiiii": _emscripten_asm_const_iiiii, "_emscripten_get_heap_size": _emscripten_get_heap_size, "_emscripten_memcpy_big": _emscripten_memcpy_big, "_emscripten_resize_heap": _emscripten_resize_heap, "_fd_write": _fd_write, "_gettimeofday": _gettimeofday, "abort": abort, "abortOnCannotGrowMemory": abortOnCannotGrowMemory, "demangle": demangle, "demangleAll": demangleAll, "flush_NO_FILESYSTEM": flush_NO_FILESYSTEM, "getTempRet0": getTempRet0, "jsCall_ii": jsCall_ii, "jsCall_iidiiii": jsCall_iidiiii, "jsCall_iii": jsCall_iii, "jsCall_iiii": jsCall_iiii, "jsCall_jiji": jsCall_jiji, "jsCall_vi": jsCall_vi, "jsCall_vii": jsCall_vii, "jsCall_viiii": jsCall_viiii, "jsCall_vji": jsCall_vji, "jsStackTrace": jsStackTrace, "memory": wasmMemory, "setTempRet0": setTempRet0, "stackTrace": stackTrace, "table": wasmTable, "tempDoublePtr": tempDoublePtr }; +// EMSCRIPTEN_START_ASM +var asm =Module["asm"]// EMSCRIPTEN_END_ASM +(asmGlobalArg, asmLibraryArg, buffer); + +Module["asm"] = asm; +var _PICO_TIME = Module["_PICO_TIME"] = function() { + return Module["asm"]["_PICO_TIME"].apply(null, arguments) +}; + +var _PICO_TIME_MS = Module["_PICO_TIME_MS"] = function() { + return Module["asm"]["_PICO_TIME_MS"].apply(null, arguments) +}; + +var _PICO_TIME_MS_130 = Module["_PICO_TIME_MS_130"] = function() { + return Module["asm"]["_PICO_TIME_MS_130"].apply(null, arguments) +}; + +var _PICO_TIME_MS_137 = Module["_PICO_TIME_MS_137"] = function() { + return Module["asm"]["_PICO_TIME_MS_137"].apply(null, arguments) +}; + +var _PICO_TIME_MS_146 = Module["_PICO_TIME_MS_146"] = function() { + return Module["asm"]["_PICO_TIME_MS_146"].apply(null, arguments) +}; + +var _PICO_TIME_MS_231 = Module["_PICO_TIME_MS_231"] = function() { + return Module["asm"]["_PICO_TIME_MS_231"].apply(null, arguments) +}; + +var _PICO_TIME_MS_278 = Module["_PICO_TIME_MS_278"] = function() { + return Module["asm"]["_PICO_TIME_MS_278"].apply(null, arguments) +}; + +var _PICO_TIME_MS_310 = Module["_PICO_TIME_MS_310"] = function() { + return Module["asm"]["_PICO_TIME_MS_310"].apply(null, arguments) +}; + +var _PICO_TIME_MS_366 = Module["_PICO_TIME_MS_366"] = function() { + return Module["asm"]["_PICO_TIME_MS_366"].apply(null, arguments) +}; + +var _PICO_TIME_MS_376 = Module["_PICO_TIME_MS_376"] = function() { + return Module["asm"]["_PICO_TIME_MS_376"].apply(null, arguments) +}; + +var ___DOUBLE_BITS_670 = Module["___DOUBLE_BITS_670"] = function() { + return Module["asm"]["___DOUBLE_BITS_670"].apply(null, arguments) +}; + +var ___emscripten_stdout_close = Module["___emscripten_stdout_close"] = function() { + return Module["asm"]["___emscripten_stdout_close"].apply(null, arguments) +}; + +var ___emscripten_stdout_seek = Module["___emscripten_stdout_seek"] = function() { + return Module["asm"]["___emscripten_stdout_seek"].apply(null, arguments) +}; + +var ___errno_location = Module["___errno_location"] = function() { + return Module["asm"]["___errno_location"].apply(null, arguments) +}; + +var ___fwritex = Module["___fwritex"] = function() { + return Module["asm"]["___fwritex"].apply(null, arguments) +}; + +var ___lockfile = Module["___lockfile"] = function() { + return Module["asm"]["___lockfile"].apply(null, arguments) +}; + +var ___overflow = Module["___overflow"] = function() { + return Module["asm"]["___overflow"].apply(null, arguments) +}; + +var ___pthread_self_423 = Module["___pthread_self_423"] = function() { + return Module["asm"]["___pthread_self_423"].apply(null, arguments) +}; + +var ___stdio_write = Module["___stdio_write"] = function() { + return Module["asm"]["___stdio_write"].apply(null, arguments) +}; + +var ___stpncpy = Module["___stpncpy"] = function() { + return Module["asm"]["___stpncpy"].apply(null, arguments) +}; + +var ___towrite = Module["___towrite"] = function() { + return Module["asm"]["___towrite"].apply(null, arguments) +}; + +var ___unlockfile = Module["___unlockfile"] = function() { + return Module["asm"]["___unlockfile"].apply(null, arguments) +}; + +var ___vfprintf_internal = Module["___vfprintf_internal"] = function() { + return Module["asm"]["___vfprintf_internal"].apply(null, arguments) +}; + +var ___wasi_syscall_ret = Module["___wasi_syscall_ret"] = function() { + return Module["asm"]["___wasi_syscall_ret"].apply(null, arguments) +}; + +var __pico_stack_recv_zerocopy = Module["__pico_stack_recv_zerocopy"] = function() { + return Module["asm"]["__pico_stack_recv_zerocopy"].apply(null, arguments) +}; + +var _add_retransmission_timer = Module["_add_retransmission_timer"] = function() { + return Module["asm"]["_add_retransmission_timer"].apply(null, arguments) +}; + +var _aodv_dev_cmp = Module["_aodv_dev_cmp"] = function() { + return Module["asm"]["_aodv_dev_cmp"].apply(null, arguments) +}; + +var _aodv_elect_route = Module["_aodv_elect_route"] = function() { + return Module["asm"]["_aodv_elect_route"].apply(null, arguments) +}; + +var _aodv_forward = Module["_aodv_forward"] = function() { + return Module["asm"]["_aodv_forward"].apply(null, arguments) +}; + +var _aodv_lifetime = Module["_aodv_lifetime"] = function() { + return Module["asm"]["_aodv_lifetime"].apply(null, arguments) +}; + +var _aodv_make_rreq = Module["_aodv_make_rreq"] = function() { + return Module["asm"]["_aodv_make_rreq"].apply(null, arguments) +}; + +var _aodv_node_compare = Module["_aodv_node_compare"] = function() { + return Module["asm"]["_aodv_node_compare"].apply(null, arguments) +}; + +var _aodv_parse_rack = Module["_aodv_parse_rack"] = function() { + return Module["asm"]["_aodv_parse_rack"].apply(null, arguments) +}; + +var _aodv_parse_rerr = Module["_aodv_parse_rerr"] = function() { + return Module["asm"]["_aodv_parse_rerr"].apply(null, arguments) +}; + +var _aodv_parse_rrep = Module["_aodv_parse_rrep"] = function() { + return Module["asm"]["_aodv_parse_rrep"].apply(null, arguments) +}; + +var _aodv_parse_rreq = Module["_aodv_parse_rreq"] = function() { + return Module["asm"]["_aodv_parse_rreq"].apply(null, arguments) +}; + +var _aodv_peer_eval = Module["_aodv_peer_eval"] = function() { + return Module["asm"]["_aodv_peer_eval"].apply(null, arguments) +}; + +var _aodv_peer_new = Module["_aodv_peer_new"] = function() { + return Module["asm"]["_aodv_peer_new"].apply(null, arguments) +}; + +var _aodv_peer_refresh = Module["_aodv_peer_refresh"] = function() { + return Module["asm"]["_aodv_peer_refresh"].apply(null, arguments) +}; + +var _aodv_recv_valid_rreq = Module["_aodv_recv_valid_rreq"] = function() { + return Module["asm"]["_aodv_recv_valid_rreq"].apply(null, arguments) +}; + +var _aodv_retrans_rreq = Module["_aodv_retrans_rreq"] = function() { + return Module["asm"]["_aodv_retrans_rreq"].apply(null, arguments) +}; + +var _aodv_reverse_path_discover = Module["_aodv_reverse_path_discover"] = function() { + return Module["asm"]["_aodv_reverse_path_discover"].apply(null, arguments) +}; + +var _aodv_send_reply = Module["_aodv_send_reply"] = function() { + return Module["asm"]["_aodv_send_reply"].apply(null, arguments) +}; + +var _aodv_send_req = Module["_aodv_send_req"] = function() { + return Module["asm"]["_aodv_send_req"].apply(null, arguments) +}; + +var _arp_compare = Module["_arp_compare"] = function() { + return Module["asm"]["_arp_compare"].apply(null, arguments) +}; + +var _arp_expire = Module["_arp_expire"] = function() { + return Module["asm"]["_arp_expire"].apply(null, arguments) +}; + +var _calc_score = Module["_calc_score"] = function() { + return Module["asm"]["_calc_score"].apply(null, arguments) +}; + +var _calloc = Module["_calloc"] = function() { + return Module["asm"]["_calloc"].apply(null, arguments) +}; + +var _checkLocalClosing = Module["_checkLocalClosing"] = function() { + return Module["asm"]["_checkLocalClosing"].apply(null, arguments) +}; + +var _checkRemoteClosing = Module["_checkRemoteClosing"] = function() { + return Module["asm"]["_checkRemoteClosing"].apply(null, arguments) +}; + +var _check_dev_serve_interrupt = Module["_check_dev_serve_interrupt"] = function() { + return Module["asm"]["_check_dev_serve_interrupt"].apply(null, arguments) +}; + +var _check_dev_serve_polling = Module["_check_dev_serve_polling"] = function() { + return Module["asm"]["_check_dev_serve_polling"].apply(null, arguments) +}; + +var _check_socket_sanity = Module["_check_socket_sanity"] = function() { + return Module["asm"]["_check_socket_sanity"].apply(null, arguments) +}; + +var _checksum_is_ipv4 = Module["_checksum_is_ipv4"] = function() { + return Module["asm"]["_checksum_is_ipv4"].apply(null, arguments) +}; + +var _checksum_is_ipv6 = Module["_checksum_is_ipv6"] = function() { + return Module["asm"]["_checksum_is_ipv6"].apply(null, arguments) +}; + +var _cookie_compare = Module["_cookie_compare"] = function() { + return Module["asm"]["_cookie_compare"].apply(null, arguments) +}; + +var _create_dev_js = Module["_create_dev_js"] = function() { + return Module["asm"]["_create_dev_js"].apply(null, arguments) +}; + +var _create_node = Module["_create_node"] = function() { + return Module["asm"]["_create_node"].apply(null, arguments) +}; + +var _destination_is_bcast = Module["_destination_is_bcast"] = function() { + return Module["asm"]["_destination_is_bcast"].apply(null, arguments) +}; + +var _destination_is_mcast = Module["_destination_is_mcast"] = function() { + return Module["asm"]["_destination_is_mcast"].apply(null, arguments) +}; + +var _device_init_ipv6_final = Module["_device_init_ipv6_final"] = function() { + return Module["asm"]["_device_init_ipv6_final"].apply(null, arguments) +}; + +var _device_init_mac = Module["_device_init_mac"] = function() { + return Module["asm"]["_device_init_mac"].apply(null, arguments) +}; + +var _device_init_nomac = Module["_device_init_nomac"] = function() { + return Module["asm"]["_device_init_nomac"].apply(null, arguments) +}; + +var _devloop = Module["_devloop"] = function() { + return Module["asm"]["_devloop"].apply(null, arguments) +}; + +var _devloop_in = Module["_devloop_in"] = function() { + return Module["asm"]["_devloop_in"].apply(null, arguments) +}; + +var _devloop_out = Module["_devloop_out"] = function() { + return Module["asm"]["_devloop_out"].apply(null, arguments) +}; + +var _devloop_sendto_dev = Module["_devloop_sendto_dev"] = function() { + return Module["asm"]["_devloop_sendto_dev"].apply(null, arguments) +}; + +var _dhcp_action_call = Module["_dhcp_action_call"] = function() { + return Module["asm"]["_dhcp_action_call"].apply(null, arguments) +}; + +var _dhcp_cookies_cmp = Module["_dhcp_cookies_cmp"] = function() { + return Module["asm"]["_dhcp_cookies_cmp"].apply(null, arguments) +}; + +var _dhcp_get_timer_event = Module["_dhcp_get_timer_event"] = function() { + return Module["asm"]["_dhcp_get_timer_event"].apply(null, arguments) +}; + +var _dhcp_negotiation_set_ciaddr = Module["_dhcp_negotiation_set_ciaddr"] = function() { + return Module["asm"]["_dhcp_negotiation_set_ciaddr"].apply(null, arguments) +}; + +var _dhcp_negotiations_cmp = Module["_dhcp_negotiations_cmp"] = function() { + return Module["asm"]["_dhcp_negotiations_cmp"].apply(null, arguments) +}; + +var _dhcp_settings_cmp = Module["_dhcp_settings_cmp"] = function() { + return Module["asm"]["_dhcp_settings_cmp"].apply(null, arguments) +}; + +var _dhcpd_make_reply = Module["_dhcpd_make_reply"] = function() { + return Module["asm"]["_dhcpd_make_reply"].apply(null, arguments) +}; + +var _dhcps_make_reply_to_discover_or_request = Module["_dhcps_make_reply_to_discover_or_request"] = function() { + return Module["asm"]["_dhcps_make_reply_to_discover_or_request"].apply(null, arguments) +}; + +var _dhcps_make_reply_to_request_msg = Module["_dhcps_make_reply_to_request_msg"] = function() { + return Module["asm"]["_dhcps_make_reply_to_request_msg"].apply(null, arguments) +}; + +var _dhcps_parse_options_loop = Module["_dhcps_parse_options_loop"] = function() { + return Module["asm"]["_dhcps_parse_options_loop"].apply(null, arguments) +}; + +var _dhcps_set_default_lease_time_if_not_provided = Module["_dhcps_set_default_lease_time_if_not_provided"] = function() { + return Module["asm"]["_dhcps_set_default_lease_time_if_not_provided"].apply(null, arguments) +}; + +var _dhcps_set_default_pool_end_if_not_provided = Module["_dhcps_set_default_pool_end_if_not_provided"] = function() { + return Module["asm"]["_dhcps_set_default_pool_end_if_not_provided"].apply(null, arguments) +}; + +var _dhcps_set_default_pool_start_if_not_provided = Module["_dhcps_set_default_pool_start_if_not_provided"] = function() { + return Module["asm"]["_dhcps_set_default_pool_start_if_not_provided"].apply(null, arguments) +}; + +var _dhcps_try_open_socket = Module["_dhcps_try_open_socket"] = function() { + return Module["asm"]["_dhcps_try_open_socket"].apply(null, arguments) +}; + +var _discard = Module["_discard"] = function() { + return Module["asm"]["_discard"].apply(null, arguments) +}; + +var _dns_ns_cmp = Module["_dns_ns_cmp"] = function() { + return Module["asm"]["_dns_ns_cmp"].apply(null, arguments) +}; + +var _dns_ptr_ip6_nibble_hi = Module["_dns_ptr_ip6_nibble_hi"] = function() { + return Module["asm"]["_dns_ptr_ip6_nibble_hi"].apply(null, arguments) +}; + +var _dns_ptr_ip6_nibble_lo = Module["_dns_ptr_ip6_nibble_lo"] = function() { + return Module["asm"]["_dns_ptr_ip6_nibble_lo"].apply(null, arguments) +}; + +var _dns_query_cmp = Module["_dns_query_cmp"] = function() { + return Module["asm"]["_dns_query_cmp"].apply(null, arguments) +}; + +var _do_enqueue_segment = Module["_do_enqueue_segment"] = function() { + return Module["asm"]["_do_enqueue_segment"].apply(null, arguments) +}; + +var _emscripten_get_sbrk_ptr = Module["_emscripten_get_sbrk_ptr"] = function() { + return Module["asm"]["_emscripten_get_sbrk_ptr"].apply(null, arguments) +}; + +var _enqueue_segment_len = Module["_enqueue_segment_len"] = function() { + return Module["asm"]["_enqueue_segment_len"].apply(null, arguments) +}; + +var _eth_check_headroom = Module["_eth_check_headroom"] = function() { + return Module["asm"]["_eth_check_headroom"].apply(null, arguments) +}; + +var _filter_compare = Module["_filter_compare"] = function() { + return Module["asm"]["_filter_compare"].apply(null, arguments) +}; + +var _filter_compare_address_port = Module["_filter_compare_address_port"] = function() { + return Module["asm"]["_filter_compare_address_port"].apply(null, arguments) +}; + +var _filter_compare_addresses = Module["_filter_compare_addresses"] = function() { + return Module["asm"]["_filter_compare_addresses"].apply(null, arguments) +}; + +var _filter_compare_ports = Module["_filter_compare_ports"] = function() { + return Module["asm"]["_filter_compare_ports"].apply(null, arguments) +}; + +var _filter_compare_proto = Module["_filter_compare_proto"] = function() { + return Module["asm"]["_filter_compare_proto"].apply(null, arguments) +}; + +var _filter_match_packet = Module["_filter_match_packet"] = function() { + return Module["asm"]["_filter_match_packet"].apply(null, arguments) +}; + +var _filter_match_packet_addr = Module["_filter_match_packet_addr"] = function() { + return Module["asm"]["_filter_match_packet_addr"].apply(null, arguments) +}; + +var _filter_match_packet_addr_in = Module["_filter_match_packet_addr_in"] = function() { + return Module["asm"]["_filter_match_packet_addr_in"].apply(null, arguments) +}; + +var _filter_match_packet_addr_out = Module["_filter_match_packet_addr_out"] = function() { + return Module["asm"]["_filter_match_packet_addr_out"].apply(null, arguments) +}; + +var _filter_match_packet_dev = Module["_filter_match_packet_dev"] = function() { + return Module["asm"]["_filter_match_packet_dev"].apply(null, arguments) +}; + +var _filter_match_packet_dev_and_proto = Module["_filter_match_packet_dev_and_proto"] = function() { + return Module["asm"]["_filter_match_packet_dev_and_proto"].apply(null, arguments) +}; + +var _filter_match_packet_find_rule = Module["_filter_match_packet_find_rule"] = function() { + return Module["asm"]["_filter_match_packet_find_rule"].apply(null, arguments) +}; + +var _filter_match_packet_port = Module["_filter_match_packet_port"] = function() { + return Module["asm"]["_filter_match_packet_port"].apply(null, arguments) +}; + +var _filter_match_packet_port_in = Module["_filter_match_packet_port_in"] = function() { + return Module["asm"]["_filter_match_packet_port_in"].apply(null, arguments) +}; + +var _filter_match_packet_port_out = Module["_filter_match_packet_port_out"] = function() { + return Module["asm"]["_filter_match_packet_port_out"].apply(null, arguments) +}; + +var _filter_match_packet_proto = Module["_filter_match_packet_proto"] = function() { + return Module["asm"]["_filter_match_packet_proto"].apply(null, arguments) +}; + +var _first_segment = Module["_first_segment"] = function() { + return Module["asm"]["_first_segment"].apply(null, arguments) +}; + +var _fix_delete_collisions = Module["_fix_delete_collisions"] = function() { + return Module["asm"]["_fix_delete_collisions"].apply(null, arguments) +}; + +var _fix_insert_collisions = Module["_fix_insert_collisions"] = function() { + return Module["asm"]["_fix_insert_collisions"].apply(null, arguments) +}; + +var _fmt_fp = Module["_fmt_fp"] = function() { + return Module["asm"]["_fmt_fp"].apply(null, arguments) +}; + +var _fmt_o = Module["_fmt_o"] = function() { + return Module["asm"]["_fmt_o"].apply(null, arguments) +}; + +var _fmt_u = Module["_fmt_u"] = function() { + return Module["asm"]["_fmt_u"].apply(null, arguments) +}; + +var _fmt_x = Module["_fmt_x"] = function() { + return Module["asm"]["_fmt_x"].apply(null, arguments) +}; + +var _fputs = Module["_fputs"] = function() { + return Module["asm"]["_fputs"].apply(null, arguments) +}; + +var _free = Module["_free"] = function() { + return Module["asm"]["_free"].apply(null, arguments) +}; + +var _frexp = Module["_frexp"] = function() { + return Module["asm"]["_frexp"].apply(null, arguments) +}; + +var _fwrite = Module["_fwrite"] = function() { + return Module["asm"]["_fwrite"].apply(null, arguments) +}; + +var _get_node_by_addr = Module["_get_node_by_addr"] = function() { + return Module["asm"]["_get_node_by_addr"].apply(null, arguments) +}; + +var _get_sock_dev = Module["_get_sock_dev"] = function() { + return Module["asm"]["_get_sock_dev"].apply(null, arguments) +}; + +var _getint = Module["_getint"] = function() { + return Module["asm"]["_getint"].apply(null, arguments) +}; + +var _heap_first = Module["_heap_first"] = function() { + return Module["asm"]["_heap_first"].apply(null, arguments) +}; + +var _heap_get_element = Module["_heap_get_element"] = function() { + return Module["asm"]["_heap_get_element"].apply(null, arguments) +}; + +var _heap_increase_size = Module["_heap_increase_size"] = function() { + return Module["asm"]["_heap_increase_size"].apply(null, arguments) +}; + +var _heap_init = Module["_heap_init"] = function() { + return Module["asm"]["_heap_init"].apply(null, arguments) +}; + +var _heap_insert = Module["_heap_insert"] = function() { + return Module["asm"]["_heap_insert"].apply(null, arguments) +}; + +var _heap_peek = Module["_heap_peek"] = function() { + return Module["asm"]["_heap_peek"].apply(null, arguments) +}; + +var _icmp6_cookie_compare = Module["_icmp6_cookie_compare"] = function() { + return Module["asm"]["_icmp6_cookie_compare"].apply(null, arguments) +}; + +var _icmp6_initial_checks = Module["_icmp6_initial_checks"] = function() { + return Module["asm"]["_icmp6_initial_checks"].apply(null, arguments) +}; + +var _if_nodecolor_black_fix_collisions = Module["_if_nodecolor_black_fix_collisions"] = function() { + return Module["asm"]["_if_nodecolor_black_fix_collisions"].apply(null, arguments) +}; + +var _igmp_parameters_cmp = Module["_igmp_parameters_cmp"] = function() { + return Module["asm"]["_igmp_parameters_cmp"].apply(null, arguments) +}; + +var _igmp_sources_cmp = Module["_igmp_sources_cmp"] = function() { + return Module["asm"]["_igmp_sources_cmp"].apply(null, arguments) +}; + +var _igmp_timer_cmp = Module["_igmp_timer_cmp"] = function() { + return Module["asm"]["_igmp_timer_cmp"].apply(null, arguments) +}; + +var _igmpparm_group_compare = Module["_igmpparm_group_compare"] = function() { + return Module["asm"]["_igmpparm_group_compare"].apply(null, arguments) +}; + +var _igmpparm_link_compare = Module["_igmpparm_link_compare"] = function() { + return Module["asm"]["_igmpparm_link_compare"].apply(null, arguments) +}; + +var _igmpt_group_compare = Module["_igmpt_group_compare"] = function() { + return Module["asm"]["_igmpt_group_compare"].apply(null, arguments) +}; + +var _igmpt_link_compare = Module["_igmpt_link_compare"] = function() { + return Module["asm"]["_igmpt_link_compare"].apply(null, arguments) +}; + +var _igmpt_type_compare = Module["_igmpt_type_compare"] = function() { + return Module["asm"]["_igmpt_type_compare"].apply(null, arguments) +}; + +var _initconn_retry = Module["_initconn_retry"] = function() { + return Module["asm"]["_initconn_retry"].apply(null, arguments) +}; + +var _input_segment_compare = Module["_input_segment_compare"] = function() { + return Module["asm"]["_input_segment_compare"].apply(null, arguments) +}; + +var _invalid_flags = Module["_invalid_flags"] = function() { + return Module["asm"]["_invalid_flags"].apply(null, arguments) +}; + +var _ip_address_is_in_dhcp_range = Module["_ip_address_is_in_dhcp_range"] = function() { + return Module["asm"]["_ip_address_is_in_dhcp_range"].apply(null, arguments) +}; + +var _ipfilter = Module["_ipfilter"] = function() { + return Module["asm"]["_ipfilter"].apply(null, arguments) +}; + +var _ipfilter_apply_filter = Module["_ipfilter_apply_filter"] = function() { + return Module["asm"]["_ipfilter_apply_filter"].apply(null, arguments) +}; + +var _ipfilter_ptr_cmp = Module["_ipfilter_ptr_cmp"] = function() { + return Module["asm"]["_ipfilter_ptr_cmp"].apply(null, arguments) +}; + +var _ipfilter_uint16_cmp = Module["_ipfilter_uint16_cmp"] = function() { + return Module["asm"]["_ipfilter_uint16_cmp"].apply(null, arguments) +}; + +var _ipfilter_uint32_cmp = Module["_ipfilter_uint32_cmp"] = function() { + return Module["asm"]["_ipfilter_uint32_cmp"].apply(null, arguments) +}; + +var _ipfilter_uint8_cmp = Module["_ipfilter_uint8_cmp"] = function() { + return Module["asm"]["_ipfilter_uint8_cmp"].apply(null, arguments) +}; + +var _ipv4_link_compare = Module["_ipv4_link_compare"] = function() { + return Module["asm"]["_ipv4_link_compare"].apply(null, arguments) +}; + +var _ipv4_mcast_groups_cmp = Module["_ipv4_mcast_groups_cmp"] = function() { + return Module["asm"]["_ipv4_mcast_groups_cmp"].apply(null, arguments) +}; + +var _ipv4_mcast_sources_cmp = Module["_ipv4_mcast_sources_cmp"] = function() { + return Module["asm"]["_ipv4_mcast_sources_cmp"].apply(null, arguments) +}; + +var _ipv4_route_compare = Module["_ipv4_route_compare"] = function() { + return Module["asm"]["_ipv4_route_compare"].apply(null, arguments) +}; + +var _ipv6_compare_metric = Module["_ipv6_compare_metric"] = function() { + return Module["asm"]["_ipv6_compare_metric"].apply(null, arguments) +}; + +var _ipv6_duplicate_detected = Module["_ipv6_duplicate_detected"] = function() { + return Module["asm"]["_ipv6_duplicate_detected"].apply(null, arguments) +}; + +var _ipv6_frame_push_final = Module["_ipv6_frame_push_final"] = function() { + return Module["asm"]["_ipv6_frame_push_final"].apply(null, arguments) +}; + +var _ipv6_link_compare = Module["_ipv6_link_compare"] = function() { + return Module["asm"]["_ipv6_link_compare"].apply(null, arguments) +}; + +var _ipv6_mcast_groups_cmp = Module["_ipv6_mcast_groups_cmp"] = function() { + return Module["asm"]["_ipv6_mcast_groups_cmp"].apply(null, arguments) +}; + +var _ipv6_mcast_sources_cmp = Module["_ipv6_mcast_sources_cmp"] = function() { + return Module["asm"]["_ipv6_mcast_sources_cmp"].apply(null, arguments) +}; + +var _ipv6_push_hdr_adjust = Module["_ipv6_push_hdr_adjust"] = function() { + return Module["asm"]["_ipv6_push_hdr_adjust"].apply(null, arguments) +}; + +var _ipv6_pushed_frame_checks = Module["_ipv6_pushed_frame_checks"] = function() { + return Module["asm"]["_ipv6_pushed_frame_checks"].apply(null, arguments) +}; + +var _ipv6_pushed_frame_valid = Module["_ipv6_pushed_frame_valid"] = function() { + return Module["asm"]["_ipv6_pushed_frame_valid"].apply(null, arguments) +}; + +var _ipv6_route_add_link = Module["_ipv6_route_add_link"] = function() { + return Module["asm"]["_ipv6_route_add_link"].apply(null, arguments) +}; + +var _ipv6_route_compare = Module["_ipv6_route_compare"] = function() { + return Module["asm"]["_ipv6_route_compare"].apply(null, arguments) +}; + +var _isdigit = Module["_isdigit"] = function() { + return Module["asm"]["_isdigit"].apply(null, arguments) +}; + +var _isupper = Module["_isupper"] = function() { + return Module["asm"]["_isupper"].apply(null, arguments) +}; + +var _js_accept_nameserver = Module["_js_accept_nameserver"] = function() { + return Module["asm"]["_js_accept_nameserver"].apply(null, arguments) +}; + +var _js_add_ipv4 = Module["_js_add_ipv4"] = function() { + return Module["asm"]["_js_add_ipv4"].apply(null, arguments) +}; + +var _js_pico_err = Module["_js_pico_err"] = function() { + return Module["asm"]["_js_pico_err"].apply(null, arguments) +}; + +var _js_socket_bind = Module["_js_socket_bind"] = function() { + return Module["asm"]["_js_socket_bind"].apply(null, arguments) +}; + +var _js_socket_connect = Module["_js_socket_connect"] = function() { + return Module["asm"]["_js_socket_connect"].apply(null, arguments) +}; + +var _js_socket_open = Module["_js_socket_open"] = function() { + return Module["asm"]["_js_socket_open"].apply(null, arguments) +}; + +var _js_wakeup = Module["_js_wakeup"] = function() { + return Module["asm"]["_js_wakeup"].apply(null, arguments) +}; + +var _listen_find = Module["_listen_find"] = function() { + return Module["asm"]["_listen_find"].apply(null, arguments) +}; + +var _llvm_bswap_i16 = Module["_llvm_bswap_i16"] = function() { + return Module["asm"]["_llvm_bswap_i16"].apply(null, arguments) +}; + +var _llvm_bswap_i32 = Module["_llvm_bswap_i32"] = function() { + return Module["asm"]["_llvm_bswap_i32"].apply(null, arguments) +}; + +var _long_be = Module["_long_be"] = function() { + return Module["asm"]["_long_be"].apply(null, arguments) +}; + +var _long_be_133 = Module["_long_be_133"] = function() { + return Module["asm"]["_long_be_133"].apply(null, arguments) +}; + +var _long_be_147 = Module["_long_be_147"] = function() { + return Module["asm"]["_long_be_147"].apply(null, arguments) +}; + +var _long_be_162 = Module["_long_be_162"] = function() { + return Module["asm"]["_long_be_162"].apply(null, arguments) +}; + +var _long_be_311 = Module["_long_be_311"] = function() { + return Module["asm"]["_long_be_311"].apply(null, arguments) +}; + +var _long_be_329 = Module["_long_be_329"] = function() { + return Module["asm"]["_long_be_329"].apply(null, arguments) +}; + +var _long_be_340 = Module["_long_be_340"] = function() { + return Module["asm"]["_long_be_340"].apply(null, arguments) +}; + +var _long_be_368 = Module["_long_be_368"] = function() { + return Module["asm"]["_long_be_368"].apply(null, arguments) +}; + +var _long_be_37 = Module["_long_be_37"] = function() { + return Module["asm"]["_long_be_37"].apply(null, arguments) +}; + +var _long_be_381 = Module["_long_be_381"] = function() { + return Module["asm"]["_long_be_381"].apply(null, arguments) +}; + +var _long_be_39 = Module["_long_be_39"] = function() { + return Module["asm"]["_long_be_39"].apply(null, arguments) +}; + +var _long_be_69 = Module["_long_be_69"] = function() { + return Module["asm"]["_long_be_69"].apply(null, arguments) +}; + +var _long_from = Module["_long_from"] = function() { + return Module["asm"]["_long_from"].apply(null, arguments) +}; + +var _long_from_152 = Module["_long_from_152"] = function() { + return Module["asm"]["_long_from_152"].apply(null, arguments) +}; + +var _long_from_89 = Module["_long_from_89"] = function() { + return Module["asm"]["_long_from_89"].apply(null, arguments) +}; + +var _main = Module["_main"] = function() { + return Module["asm"]["_main"].apply(null, arguments) +}; + +var _malloc = Module["_malloc"] = function() { + return Module["asm"]["_malloc"].apply(null, arguments) +}; + +var _mcast_aggr_validate = Module["_mcast_aggr_validate"] = function() { + return Module["asm"]["_mcast_aggr_validate"].apply(null, arguments) +}; + +var _mcast_filter_cmp = Module["_mcast_filter_cmp"] = function() { + return Module["asm"]["_mcast_filter_cmp"].apply(null, arguments) +}; + +var _mcast_filter_cmp_ipv6 = Module["_mcast_filter_cmp_ipv6"] = function() { + return Module["asm"]["_mcast_filter_cmp_ipv6"].apply(null, arguments) +}; + +var _mcast_get_listen_tree = Module["_mcast_get_listen_tree"] = function() { + return Module["asm"]["_mcast_get_listen_tree"].apply(null, arguments) +}; + +var _mcast_get_src_tree = Module["_mcast_get_src_tree"] = function() { + return Module["asm"]["_mcast_get_src_tree"].apply(null, arguments) +}; + +var _mcast_group_update = Module["_mcast_group_update"] = function() { + return Module["asm"]["_mcast_group_update"].apply(null, arguments) +}; + +var _mcast_group_update_ipv6 = Module["_mcast_group_update_ipv6"] = function() { + return Module["asm"]["_mcast_group_update_ipv6"].apply(null, arguments) +}; + +var _mcast_parameters_cmp = Module["_mcast_parameters_cmp"] = function() { + return Module["asm"]["_mcast_parameters_cmp"].apply(null, arguments) +}; + +var _mcast_set_listen_tree_p_null = Module["_mcast_set_listen_tree_p_null"] = function() { + return Module["asm"]["_mcast_set_listen_tree_p_null"].apply(null, arguments) +}; + +var _mcast_socket_cmp = Module["_mcast_socket_cmp"] = function() { + return Module["asm"]["_mcast_socket_cmp"].apply(null, arguments) +}; + +var _mcast_sources_cmp = Module["_mcast_sources_cmp"] = function() { + return Module["asm"]["_mcast_sources_cmp"].apply(null, arguments) +}; + +var _mcast_sources_cmp_ipv6 = Module["_mcast_sources_cmp_ipv6"] = function() { + return Module["asm"]["_mcast_sources_cmp_ipv6"].apply(null, arguments) +}; + +var _memchr = Module["_memchr"] = function() { + return Module["asm"]["_memchr"].apply(null, arguments) +}; + +var _memcmp = Module["_memcmp"] = function() { + return Module["asm"]["_memcmp"].apply(null, arguments) +}; + +var _memcpy = Module["_memcpy"] = function() { + return Module["asm"]["_memcpy"].apply(null, arguments) +}; + +var _memset = Module["_memset"] = function() { + return Module["asm"]["_memset"].apply(null, arguments) +}; + +var _mld_discard = Module["_mld_discard"] = function() { + return Module["asm"]["_mld_discard"].apply(null, arguments) +}; + +var _mld_mrsrrt = Module["_mld_mrsrrt"] = function() { + return Module["asm"]["_mld_mrsrrt"].apply(null, arguments) +}; + +var _mld_rtimrtct = Module["_mld_rtimrtct"] = function() { + return Module["asm"]["_mld_rtimrtct"].apply(null, arguments) +}; + +var _mld_sources_cmp = Module["_mld_sources_cmp"] = function() { + return Module["asm"]["_mld_sources_cmp"].apply(null, arguments) +}; + +var _mld_srsf = Module["_mld_srsf"] = function() { + return Module["asm"]["_mld_srsf"].apply(null, arguments) +}; + +var _mld_srsfst = Module["_mld_srsfst"] = function() { + return Module["asm"]["_mld_srsfst"].apply(null, arguments) +}; + +var _mld_srst = Module["_mld_srst"] = function() { + return Module["asm"]["_mld_srst"].apply(null, arguments) +}; + +var _mld_stcl = Module["_mld_stcl"] = function() { + return Module["asm"]["_mld_stcl"].apply(null, arguments) +}; + +var _mld_stsdifs = Module["_mld_stsdifs"] = function() { + return Module["asm"]["_mld_stsdifs"].apply(null, arguments) +}; + +var _mld_timer_cmp = Module["_mld_timer_cmp"] = function() { + return Module["asm"]["_mld_timer_cmp"].apply(null, arguments) +}; + +var _mldparm_group_compare = Module["_mldparm_group_compare"] = function() { + return Module["asm"]["_mldparm_group_compare"].apply(null, arguments) +}; + +var _mldparm_link_compare = Module["_mldparm_link_compare"] = function() { + return Module["asm"]["_mldparm_link_compare"].apply(null, arguments) +}; + +var _mldt_group_compare = Module["_mldt_group_compare"] = function() { + return Module["asm"]["_mldt_group_compare"].apply(null, arguments) +}; + +var _mldt_link_compare = Module["_mldt_link_compare"] = function() { + return Module["asm"]["_mldt_link_compare"].apply(null, arguments) +}; + +var _mldt_type_compare = Module["_mldt_type_compare"] = function() { + return Module["asm"]["_mldt_type_compare"].apply(null, arguments) +}; + +var _mrsrrt = Module["_mrsrrt"] = function() { + return Module["asm"]["_mrsrrt"].apply(null, arguments) +}; + +var _nat_cmp_address = Module["_nat_cmp_address"] = function() { + return Module["asm"]["_nat_cmp_address"].apply(null, arguments) +}; + +var _nat_cmp_inbound = Module["_nat_cmp_inbound"] = function() { + return Module["asm"]["_nat_cmp_inbound"].apply(null, arguments) +}; + +var _nat_cmp_natport = Module["_nat_cmp_natport"] = function() { + return Module["asm"]["_nat_cmp_natport"].apply(null, arguments) +}; + +var _nat_cmp_outbound = Module["_nat_cmp_outbound"] = function() { + return Module["asm"]["_nat_cmp_outbound"].apply(null, arguments) +}; + +var _nat_cmp_proto = Module["_nat_cmp_proto"] = function() { + return Module["asm"]["_nat_cmp_proto"].apply(null, arguments) +}; + +var _nat_cmp_srcport = Module["_nat_cmp_srcport"] = function() { + return Module["asm"]["_nat_cmp_srcport"].apply(null, arguments) +}; + +var _nd_options = Module["_nd_options"] = function() { + return Module["asm"]["_nd_options"].apply(null, arguments) +}; + +var _neigh_adv_checks = Module["_neigh_adv_checks"] = function() { + return Module["asm"]["_neigh_adv_checks"].apply(null, arguments) +}; + +var _neigh_adv_mcast_validity_check = Module["_neigh_adv_mcast_validity_check"] = function() { + return Module["asm"]["_neigh_adv_mcast_validity_check"].apply(null, arguments) +}; + +var _neigh_adv_option_len_validity_check = Module["_neigh_adv_option_len_validity_check"] = function() { + return Module["asm"]["_neigh_adv_option_len_validity_check"].apply(null, arguments) +}; + +var _neigh_adv_process = Module["_neigh_adv_process"] = function() { + return Module["asm"]["_neigh_adv_process"].apply(null, arguments) +}; + +var _neigh_adv_process_incomplete = Module["_neigh_adv_process_incomplete"] = function() { + return Module["asm"]["_neigh_adv_process_incomplete"].apply(null, arguments) +}; + +var _neigh_adv_reconfirm = Module["_neigh_adv_reconfirm"] = function() { + return Module["asm"]["_neigh_adv_reconfirm"].apply(null, arguments) +}; + +var _neigh_adv_reconfirm_no_tlla = Module["_neigh_adv_reconfirm_no_tlla"] = function() { + return Module["asm"]["_neigh_adv_reconfirm_no_tlla"].apply(null, arguments) +}; + +var _neigh_adv_reconfirm_router_option = Module["_neigh_adv_reconfirm_router_option"] = function() { + return Module["asm"]["_neigh_adv_reconfirm_router_option"].apply(null, arguments) +}; + +var _neigh_adv_validity_checks = Module["_neigh_adv_validity_checks"] = function() { + return Module["asm"]["_neigh_adv_validity_checks"].apply(null, arguments) +}; + +var _neigh_options = Module["_neigh_options"] = function() { + return Module["asm"]["_neigh_options"].apply(null, arguments) +}; + +var _neigh_sol_detect_dad = Module["_neigh_sol_detect_dad"] = function() { + return Module["asm"]["_neigh_sol_detect_dad"].apply(null, arguments) +}; + +var _neigh_sol_mcast_validity_check = Module["_neigh_sol_mcast_validity_check"] = function() { + return Module["asm"]["_neigh_sol_mcast_validity_check"].apply(null, arguments) +}; + +var _neigh_sol_process = Module["_neigh_sol_process"] = function() { + return Module["asm"]["_neigh_sol_process"].apply(null, arguments) +}; + +var _neigh_sol_unicast_validity_check = Module["_neigh_sol_unicast_validity_check"] = function() { + return Module["asm"]["_neigh_sol_unicast_validity_check"].apply(null, arguments) +}; + +var _neigh_sol_validate_unspec = Module["_neigh_sol_validate_unspec"] = function() { + return Module["asm"]["_neigh_sol_validate_unspec"].apply(null, arguments) +}; + +var _neigh_sol_validity_checks = Module["_neigh_sol_validity_checks"] = function() { + return Module["asm"]["_neigh_sol_validity_checks"].apply(null, arguments) +}; + +var _next_ping = Module["_next_ping"] = function() { + return Module["asm"]["_next_ping"].apply(null, arguments) +}; + +var _next_segment = Module["_next_segment"] = function() { + return Module["asm"]["_next_segment"].apply(null, arguments) +}; + +var _out_8 = Module["_out_8"] = function() { + return Module["asm"]["_out_8"].apply(null, arguments) +}; + +var _pad_667 = Module["_pad_667"] = function() { + return Module["asm"]["_pad_667"].apply(null, arguments) +}; + +var _parse_opt_msgtype = Module["_parse_opt_msgtype"] = function() { + return Module["asm"]["_parse_opt_msgtype"].apply(null, arguments) +}; + +var _parse_opt_reqip = Module["_parse_opt_reqip"] = function() { + return Module["asm"]["_parse_opt_reqip"].apply(null, arguments) +}; + +var _parse_opt_serverid = Module["_parse_opt_serverid"] = function() { + return Module["asm"]["_parse_opt_serverid"].apply(null, arguments) +}; + +var _peek_segment = Module["_peek_segment"] = function() { + return Module["asm"]["_peek_segment"].apply(null, arguments) +}; + +var _pico_aodv_collector = Module["_pico_aodv_collector"] = function() { + return Module["asm"]["_pico_aodv_collector"].apply(null, arguments) +}; + +var _pico_aodv_expired = Module["_pico_aodv_expired"] = function() { + return Module["asm"]["_pico_aodv_expired"].apply(null, arguments) +}; + +var _pico_aodv_init = Module["_pico_aodv_init"] = function() { + return Module["asm"]["_pico_aodv_init"].apply(null, arguments) +}; + +var _pico_aodv_lookup = Module["_pico_aodv_lookup"] = function() { + return Module["asm"]["_pico_aodv_lookup"].apply(null, arguments) +}; + +var _pico_aodv_parse = Module["_pico_aodv_parse"] = function() { + return Module["asm"]["_pico_aodv_parse"].apply(null, arguments) +}; + +var _pico_aodv_refresh = Module["_pico_aodv_refresh"] = function() { + return Module["asm"]["_pico_aodv_refresh"].apply(null, arguments) +}; + +var _pico_aodv_set_dev = Module["_pico_aodv_set_dev"] = function() { + return Module["asm"]["_pico_aodv_set_dev"].apply(null, arguments) +}; + +var _pico_aodv_socket_callback = Module["_pico_aodv_socket_callback"] = function() { + return Module["asm"]["_pico_aodv_socket_callback"].apply(null, arguments) +}; + +var _pico_arp_add_entry = Module["_pico_arp_add_entry"] = function() { + return Module["asm"]["_pico_arp_add_entry"].apply(null, arguments) +}; + +var _pico_arp_check_conflict = Module["_pico_arp_check_conflict"] = function() { + return Module["asm"]["_pico_arp_check_conflict"].apply(null, arguments) +}; + +var _pico_arp_check_flooding = Module["_pico_arp_check_flooding"] = function() { + return Module["asm"]["_pico_arp_check_flooding"].apply(null, arguments) +}; + +var _pico_arp_check_incoming_hdr = Module["_pico_arp_check_incoming_hdr"] = function() { + return Module["asm"]["_pico_arp_check_incoming_hdr"].apply(null, arguments) +}; + +var _pico_arp_check_incoming_hdr_type = Module["_pico_arp_check_incoming_hdr_type"] = function() { + return Module["asm"]["_pico_arp_check_incoming_hdr_type"].apply(null, arguments) +}; + +var _pico_arp_create_entry = Module["_pico_arp_create_entry"] = function() { + return Module["asm"]["_pico_arp_create_entry"].apply(null, arguments) +}; + +var _pico_arp_get = Module["_pico_arp_get"] = function() { + return Module["asm"]["_pico_arp_get"].apply(null, arguments) +}; + +var _pico_arp_init = Module["_pico_arp_init"] = function() { + return Module["asm"]["_pico_arp_init"].apply(null, arguments) +}; + +var _pico_arp_lookup = Module["_pico_arp_lookup"] = function() { + return Module["asm"]["_pico_arp_lookup"].apply(null, arguments) +}; + +var _pico_arp_lookup_entry = Module["_pico_arp_lookup_entry"] = function() { + return Module["asm"]["_pico_arp_lookup_entry"].apply(null, arguments) +}; + +var _pico_arp_postpone = Module["_pico_arp_postpone"] = function() { + return Module["asm"]["_pico_arp_postpone"].apply(null, arguments) +}; + +var _pico_arp_process_in = Module["_pico_arp_process_in"] = function() { + return Module["asm"]["_pico_arp_process_in"].apply(null, arguments) +}; + +var _pico_arp_queued_trigger = Module["_pico_arp_queued_trigger"] = function() { + return Module["asm"]["_pico_arp_queued_trigger"].apply(null, arguments) +}; + +var _pico_arp_receive = Module["_pico_arp_receive"] = function() { + return Module["asm"]["_pico_arp_receive"].apply(null, arguments) +}; + +var _pico_arp_reply_on_request = Module["_pico_arp_reply_on_request"] = function() { + return Module["asm"]["_pico_arp_reply_on_request"].apply(null, arguments) +}; + +var _pico_arp_request = Module["_pico_arp_request"] = function() { + return Module["asm"]["_pico_arp_request"].apply(null, arguments) +}; + +var _pico_arp_request_xmit = Module["_pico_arp_request_xmit"] = function() { + return Module["asm"]["_pico_arp_request_xmit"].apply(null, arguments) +}; + +var _pico_arp_retry = Module["_pico_arp_retry"] = function() { + return Module["asm"]["_pico_arp_retry"].apply(null, arguments) +}; + +var _pico_arp_reverse_lookup = Module["_pico_arp_reverse_lookup"] = function() { + return Module["asm"]["_pico_arp_reverse_lookup"].apply(null, arguments) +}; + +var _pico_arp_unreachable = Module["_pico_arp_unreachable"] = function() { + return Module["asm"]["_pico_arp_unreachable"].apply(null, arguments) +}; + +var _pico_check_socket = Module["_pico_check_socket"] = function() { + return Module["asm"]["_pico_check_socket"].apply(null, arguments) +}; + +var _pico_check_timers = Module["_pico_check_timers"] = function() { + return Module["asm"]["_pico_check_timers"].apply(null, arguments) +}; + +var _pico_checksum = Module["_pico_checksum"] = function() { + return Module["asm"]["_pico_checksum"].apply(null, arguments) +}; + +var _pico_checksum_adder = Module["_pico_checksum_adder"] = function() { + return Module["asm"]["_pico_checksum_adder"].apply(null, arguments) +}; + +var _pico_checksum_finalize = Module["_pico_checksum_finalize"] = function() { + return Module["asm"]["_pico_checksum_finalize"].apply(null, arguments) +}; + +var _pico_datalink_receive = Module["_pico_datalink_receive"] = function() { + return Module["asm"]["_pico_datalink_receive"].apply(null, arguments) +}; + +var _pico_datalink_send = Module["_pico_datalink_send"] = function() { + return Module["asm"]["_pico_datalink_send"].apply(null, arguments) +}; + +var _pico_dequeue = Module["_pico_dequeue"] = function() { + return Module["asm"]["_pico_dequeue"].apply(null, arguments) +}; + +var _pico_dequeue_166 = Module["_pico_dequeue_166"] = function() { + return Module["asm"]["_pico_dequeue_166"].apply(null, arguments) +}; + +var _pico_dequeue_190 = Module["_pico_dequeue_190"] = function() { + return Module["asm"]["_pico_dequeue_190"].apply(null, arguments) +}; + +var _pico_dequeue_422 = Module["_pico_dequeue_422"] = function() { + return Module["asm"]["_pico_dequeue_422"].apply(null, arguments) +}; + +var _pico_dev_cmp = Module["_pico_dev_cmp"] = function() { + return Module["asm"]["_pico_dev_cmp"].apply(null, arguments) +}; + +var _pico_dev_roundrobin_end = Module["_pico_dev_roundrobin_end"] = function() { + return Module["asm"]["_pico_dev_roundrobin_end"].apply(null, arguments) +}; + +var _pico_dev_roundrobin_start = Module["_pico_dev_roundrobin_start"] = function() { + return Module["asm"]["_pico_dev_roundrobin_start"].apply(null, arguments) +}; + +var _pico_device_broadcast = Module["_pico_device_broadcast"] = function() { + return Module["asm"]["_pico_device_broadcast"].apply(null, arguments) +}; + +var _pico_device_init = Module["_pico_device_init"] = function() { + return Module["asm"]["_pico_device_init"].apply(null, arguments) +}; + +var _pico_device_ipv6_random_ll = Module["_pico_device_ipv6_random_ll"] = function() { + return Module["asm"]["_pico_device_ipv6_random_ll"].apply(null, arguments) +}; + +var _pico_device_link_state = Module["_pico_device_link_state"] = function() { + return Module["asm"]["_pico_device_link_state"].apply(null, arguments) +}; + +var _pico_devices_loop = Module["_pico_devices_loop"] = function() { + return Module["asm"]["_pico_devices_loop"].apply(null, arguments) +}; + +var _pico_dhcp_are_options_valid = Module["_pico_dhcp_are_options_valid"] = function() { + return Module["asm"]["_pico_dhcp_are_options_valid"].apply(null, arguments) +}; + +var _pico_dhcp_client_add_cookie = Module["_pico_dhcp_client_add_cookie"] = function() { + return Module["asm"]["_pico_dhcp_client_add_cookie"].apply(null, arguments) +}; + +var _pico_dhcp_client_callback = Module["_pico_dhcp_client_callback"] = function() { + return Module["asm"]["_pico_dhcp_client_callback"].apply(null, arguments) +}; + +var _pico_dhcp_client_del_cookie = Module["_pico_dhcp_client_del_cookie"] = function() { + return Module["asm"]["_pico_dhcp_client_del_cookie"].apply(null, arguments) +}; + +var _pico_dhcp_client_find_cookie = Module["_pico_dhcp_client_find_cookie"] = function() { + return Module["asm"]["_pico_dhcp_client_find_cookie"].apply(null, arguments) +}; + +var _pico_dhcp_client_init = Module["_pico_dhcp_client_init"] = function() { + return Module["asm"]["_pico_dhcp_client_init"].apply(null, arguments) +}; + +var _pico_dhcp_client_msg = Module["_pico_dhcp_client_msg"] = function() { + return Module["asm"]["_pico_dhcp_client_msg"].apply(null, arguments) +}; + +var _pico_dhcp_client_opt_parse = Module["_pico_dhcp_client_opt_parse"] = function() { + return Module["asm"]["_pico_dhcp_client_opt_parse"].apply(null, arguments) +}; + +var _pico_dhcp_client_recv_params = Module["_pico_dhcp_client_recv_params"] = function() { + return Module["asm"]["_pico_dhcp_client_recv_params"].apply(null, arguments) +}; + +var _pico_dhcp_client_reinit = Module["_pico_dhcp_client_reinit"] = function() { + return Module["asm"]["_pico_dhcp_client_reinit"].apply(null, arguments) +}; + +var _pico_dhcp_client_start_init_timer = Module["_pico_dhcp_client_start_init_timer"] = function() { + return Module["asm"]["_pico_dhcp_client_start_init_timer"].apply(null, arguments) +}; + +var _pico_dhcp_client_start_reacquisition_timers = Module["_pico_dhcp_client_start_reacquisition_timers"] = function() { + return Module["asm"]["_pico_dhcp_client_start_reacquisition_timers"].apply(null, arguments) +}; + +var _pico_dhcp_client_start_rebinding_timer = Module["_pico_dhcp_client_start_rebinding_timer"] = function() { + return Module["asm"]["_pico_dhcp_client_start_rebinding_timer"].apply(null, arguments) +}; + +var _pico_dhcp_client_start_renewing_timer = Module["_pico_dhcp_client_start_renewing_timer"] = function() { + return Module["asm"]["_pico_dhcp_client_start_renewing_timer"].apply(null, arguments) +}; + +var _pico_dhcp_client_start_requesting_timer = Module["_pico_dhcp_client_start_requesting_timer"] = function() { + return Module["asm"]["_pico_dhcp_client_start_requesting_timer"].apply(null, arguments) +}; + +var _pico_dhcp_client_stop_timers = Module["_pico_dhcp_client_stop_timers"] = function() { + return Module["asm"]["_pico_dhcp_client_stop_timers"].apply(null, arguments) +}; + +var _pico_dhcp_client_timer_handler = Module["_pico_dhcp_client_timer_handler"] = function() { + return Module["asm"]["_pico_dhcp_client_timer_handler"].apply(null, arguments) +}; + +var _pico_dhcp_client_update_link = Module["_pico_dhcp_client_update_link"] = function() { + return Module["asm"]["_pico_dhcp_client_update_link"].apply(null, arguments) +}; + +var _pico_dhcp_client_wakeup = Module["_pico_dhcp_client_wakeup"] = function() { + return Module["asm"]["_pico_dhcp_client_wakeup"].apply(null, arguments) +}; + +var _pico_dhcp_get_address = Module["_pico_dhcp_get_address"] = function() { + return Module["asm"]["_pico_dhcp_get_address"].apply(null, arguments) +}; + +var _pico_dhcp_get_nameserver = Module["_pico_dhcp_get_nameserver"] = function() { + return Module["asm"]["_pico_dhcp_get_nameserver"].apply(null, arguments) +}; + +var _pico_dhcp_initiate_negotiation = Module["_pico_dhcp_initiate_negotiation"] = function() { + return Module["asm"]["_pico_dhcp_initiate_negotiation"].apply(null, arguments) +}; + +var _pico_dhcp_next_option = Module["_pico_dhcp_next_option"] = function() { + return Module["asm"]["_pico_dhcp_next_option"].apply(null, arguments) +}; + +var _pico_dhcp_opt_broadcast = Module["_pico_dhcp_opt_broadcast"] = function() { + return Module["asm"]["_pico_dhcp_opt_broadcast"].apply(null, arguments) +}; + +var _pico_dhcp_opt_dns = Module["_pico_dhcp_opt_dns"] = function() { + return Module["asm"]["_pico_dhcp_opt_dns"].apply(null, arguments) +}; + +var _pico_dhcp_opt_end = Module["_pico_dhcp_opt_end"] = function() { + return Module["asm"]["_pico_dhcp_opt_end"].apply(null, arguments) +}; + +var _pico_dhcp_opt_leasetime = Module["_pico_dhcp_opt_leasetime"] = function() { + return Module["asm"]["_pico_dhcp_opt_leasetime"].apply(null, arguments) +}; + +var _pico_dhcp_opt_maxmsgsize = Module["_pico_dhcp_opt_maxmsgsize"] = function() { + return Module["asm"]["_pico_dhcp_opt_maxmsgsize"].apply(null, arguments) +}; + +var _pico_dhcp_opt_msgtype = Module["_pico_dhcp_opt_msgtype"] = function() { + return Module["asm"]["_pico_dhcp_opt_msgtype"].apply(null, arguments) +}; + +var _pico_dhcp_opt_netmask = Module["_pico_dhcp_opt_netmask"] = function() { + return Module["asm"]["_pico_dhcp_opt_netmask"].apply(null, arguments) +}; + +var _pico_dhcp_opt_paramlist = Module["_pico_dhcp_opt_paramlist"] = function() { + return Module["asm"]["_pico_dhcp_opt_paramlist"].apply(null, arguments) +}; + +var _pico_dhcp_opt_reqip = Module["_pico_dhcp_opt_reqip"] = function() { + return Module["asm"]["_pico_dhcp_opt_reqip"].apply(null, arguments) +}; + +var _pico_dhcp_opt_router = Module["_pico_dhcp_opt_router"] = function() { + return Module["asm"]["_pico_dhcp_opt_router"].apply(null, arguments) +}; + +var _pico_dhcp_opt_serverid = Module["_pico_dhcp_opt_serverid"] = function() { + return Module["asm"]["_pico_dhcp_opt_serverid"].apply(null, arguments) +}; + +var _pico_dhcp_server_add_negotiation = Module["_pico_dhcp_server_add_negotiation"] = function() { + return Module["asm"]["_pico_dhcp_server_add_negotiation"].apply(null, arguments) +}; + +var _pico_dhcp_server_add_setting = Module["_pico_dhcp_server_add_setting"] = function() { + return Module["asm"]["_pico_dhcp_server_add_setting"].apply(null, arguments) +}; + +var _pico_dhcp_server_find_negotiation = Module["_pico_dhcp_server_find_negotiation"] = function() { + return Module["asm"]["_pico_dhcp_server_find_negotiation"].apply(null, arguments) +}; + +var _pico_dhcp_server_initiate = Module["_pico_dhcp_server_initiate"] = function() { + return Module["asm"]["_pico_dhcp_server_initiate"].apply(null, arguments) +}; + +var _pico_dhcp_server_recv = Module["_pico_dhcp_server_recv"] = function() { + return Module["asm"]["_pico_dhcp_server_recv"].apply(null, arguments) +}; + +var _pico_dhcp_state_machine = Module["_pico_dhcp_state_machine"] = function() { + return Module["asm"]["_pico_dhcp_state_machine"].apply(null, arguments) +}; + +var _pico_dhcp_timer_add = Module["_pico_dhcp_timer_add"] = function() { + return Module["asm"]["_pico_dhcp_timer_add"].apply(null, arguments) +}; + +var _pico_dhcpd_wakeup = Module["_pico_dhcpd_wakeup"] = function() { + return Module["asm"]["_pico_dhcpd_wakeup"].apply(null, arguments) +}; + +var _pico_discard_segment = Module["_pico_discard_segment"] = function() { + return Module["asm"]["_pico_discard_segment"].apply(null, arguments) +}; + +var _pico_dns_check_namelen = Module["_pico_dns_check_namelen"] = function() { + return Module["asm"]["_pico_dns_check_namelen"].apply(null, arguments) +}; + +var _pico_dns_client_add_ns = Module["_pico_dns_client_add_ns"] = function() { + return Module["asm"]["_pico_dns_client_add_ns"].apply(null, arguments) +}; + +var _pico_dns_client_add_query = Module["_pico_dns_client_add_query"] = function() { + return Module["asm"]["_pico_dns_client_add_query"].apply(null, arguments) +}; + +var _pico_dns_client_addr_label_check_len = Module["_pico_dns_client_addr_label_check_len"] = function() { + return Module["asm"]["_pico_dns_client_addr_label_check_len"].apply(null, arguments) +}; + +var _pico_dns_client_callback = Module["_pico_dns_client_callback"] = function() { + return Module["asm"]["_pico_dns_client_callback"].apply(null, arguments) +}; + +var _pico_dns_client_check_asuffix = Module["_pico_dns_client_check_asuffix"] = function() { + return Module["asm"]["_pico_dns_client_check_asuffix"].apply(null, arguments) +}; + +var _pico_dns_client_check_header = Module["_pico_dns_client_check_header"] = function() { + return Module["asm"]["_pico_dns_client_check_header"].apply(null, arguments) +}; + +var _pico_dns_client_check_qsuffix = Module["_pico_dns_client_check_qsuffix"] = function() { + return Module["asm"]["_pico_dns_client_check_qsuffix"].apply(null, arguments) +}; + +var _pico_dns_client_check_rdlength = Module["_pico_dns_client_check_rdlength"] = function() { + return Module["asm"]["_pico_dns_client_check_rdlength"].apply(null, arguments) +}; + +var _pico_dns_client_check_url = Module["_pico_dns_client_check_url"] = function() { + return Module["asm"]["_pico_dns_client_check_url"].apply(null, arguments) +}; + +var _pico_dns_client_del_ns = Module["_pico_dns_client_del_ns"] = function() { + return Module["asm"]["_pico_dns_client_del_ns"].apply(null, arguments) +}; + +var _pico_dns_client_del_query = Module["_pico_dns_client_del_query"] = function() { + return Module["asm"]["_pico_dns_client_del_query"].apply(null, arguments) +}; + +var _pico_dns_client_find_query = Module["_pico_dns_client_find_query"] = function() { + return Module["asm"]["_pico_dns_client_find_query"].apply(null, arguments) +}; + +var _pico_dns_client_getaddr = Module["_pico_dns_client_getaddr"] = function() { + return Module["asm"]["_pico_dns_client_getaddr"].apply(null, arguments) +}; + +var _pico_dns_client_getaddr_check = Module["_pico_dns_client_getaddr_check"] = function() { + return Module["asm"]["_pico_dns_client_getaddr_check"].apply(null, arguments) +}; + +var _pico_dns_client_getaddr_init = Module["_pico_dns_client_getaddr_init"] = function() { + return Module["asm"]["_pico_dns_client_getaddr_init"].apply(null, arguments) +}; + +var _pico_dns_client_getname = Module["_pico_dns_client_getname"] = function() { + return Module["asm"]["_pico_dns_client_getname"].apply(null, arguments) +}; + +var _pico_dns_client_idcheck = Module["_pico_dns_client_idcheck"] = function() { + return Module["asm"]["_pico_dns_client_idcheck"].apply(null, arguments) +}; + +var _pico_dns_client_init = Module["_pico_dns_client_init"] = function() { + return Module["asm"]["_pico_dns_client_init"].apply(null, arguments) +}; + +var _pico_dns_client_nameserver = Module["_pico_dns_client_nameserver"] = function() { + return Module["asm"]["_pico_dns_client_nameserver"].apply(null, arguments) +}; + +var _pico_dns_client_next_ns = Module["_pico_dns_client_next_ns"] = function() { + return Module["asm"]["_pico_dns_client_next_ns"].apply(null, arguments) +}; + +var _pico_dns_client_query_header = Module["_pico_dns_client_query_header"] = function() { + return Module["asm"]["_pico_dns_client_query_header"].apply(null, arguments) +}; + +var _pico_dns_client_retransmission = Module["_pico_dns_client_retransmission"] = function() { + return Module["asm"]["_pico_dns_client_retransmission"].apply(null, arguments) +}; + +var _pico_dns_client_seek = Module["_pico_dns_client_seek"] = function() { + return Module["asm"]["_pico_dns_client_seek"].apply(null, arguments) +}; + +var _pico_dns_client_seek_suffix = Module["_pico_dns_client_seek_suffix"] = function() { + return Module["asm"]["_pico_dns_client_seek_suffix"].apply(null, arguments) +}; + +var _pico_dns_client_send = Module["_pico_dns_client_send"] = function() { + return Module["asm"]["_pico_dns_client_send"].apply(null, arguments) +}; + +var _pico_dns_client_user_callback = Module["_pico_dns_client_user_callback"] = function() { + return Module["asm"]["_pico_dns_client_user_callback"].apply(null, arguments) +}; + +var _pico_dns_create_message = Module["_pico_dns_create_message"] = function() { + return Module["asm"]["_pico_dns_create_message"].apply(null, arguments) +}; + +var _pico_dns_decompress_name = Module["_pico_dns_decompress_name"] = function() { + return Module["asm"]["_pico_dns_decompress_name"].apply(null, arguments) +}; + +var _pico_dns_fill_packet_header = Module["_pico_dns_fill_packet_header"] = function() { + return Module["asm"]["_pico_dns_fill_packet_header"].apply(null, arguments) +}; + +var _pico_dns_getname_univ = Module["_pico_dns_getname_univ"] = function() { + return Module["asm"]["_pico_dns_getname_univ"].apply(null, arguments) +}; + +var _pico_dns_ipv6_set_ptr = Module["_pico_dns_ipv6_set_ptr"] = function() { + return Module["asm"]["_pico_dns_ipv6_set_ptr"].apply(null, arguments) +}; + +var _pico_dns_mirror_addr = Module["_pico_dns_mirror_addr"] = function() { + return Module["asm"]["_pico_dns_mirror_addr"].apply(null, arguments) +}; + +var _pico_dns_name_to_dns_notation = Module["_pico_dns_name_to_dns_notation"] = function() { + return Module["asm"]["_pico_dns_name_to_dns_notation"].apply(null, arguments) +}; + +var _pico_dns_notation_to_name = Module["_pico_dns_notation_to_name"] = function() { + return Module["asm"]["_pico_dns_notation_to_name"].apply(null, arguments) +}; + +var _pico_dns_question_fill_suffix = Module["_pico_dns_question_fill_suffix"] = function() { + return Module["asm"]["_pico_dns_question_fill_suffix"].apply(null, arguments) +}; + +var _pico_dns_strlen = Module["_pico_dns_strlen"] = function() { + return Module["asm"]["_pico_dns_strlen"].apply(null, arguments) +}; + +var _pico_dns_try_fallback_cname = Module["_pico_dns_try_fallback_cname"] = function() { + return Module["asm"]["_pico_dns_try_fallback_cname"].apply(null, arguments) +}; + +var _pico_dualbuffer_checksum = Module["_pico_dualbuffer_checksum"] = function() { + return Module["asm"]["_pico_dualbuffer_checksum"].apply(null, arguments) +}; + +var _pico_endpoint_free = Module["_pico_endpoint_free"] = function() { + return Module["asm"]["_pico_endpoint_free"].apply(null, arguments) +}; + +var _pico_enqueue = Module["_pico_enqueue"] = function() { + return Module["asm"]["_pico_enqueue"].apply(null, arguments) +}; + +var _pico_enqueue_111 = Module["_pico_enqueue_111"] = function() { + return Module["asm"]["_pico_enqueue_111"].apply(null, arguments) +}; + +var _pico_enqueue_151 = Module["_pico_enqueue_151"] = function() { + return Module["asm"]["_pico_enqueue_151"].apply(null, arguments) +}; + +var _pico_enqueue_157 = Module["_pico_enqueue_157"] = function() { + return Module["asm"]["_pico_enqueue_157"].apply(null, arguments) +}; + +var _pico_enqueue_257 = Module["_pico_enqueue_257"] = function() { + return Module["asm"]["_pico_enqueue_257"].apply(null, arguments) +}; + +var _pico_enqueue_326 = Module["_pico_enqueue_326"] = function() { + return Module["asm"]["_pico_enqueue_326"].apply(null, arguments) +}; + +var _pico_enqueue_415 = Module["_pico_enqueue_415"] = function() { + return Module["asm"]["_pico_enqueue_415"].apply(null, arguments) +}; + +var _pico_enqueue_and_wakeup_if_needed = Module["_pico_enqueue_and_wakeup_if_needed"] = function() { + return Module["asm"]["_pico_enqueue_and_wakeup_if_needed"].apply(null, arguments) +}; + +var _pico_enqueue_segment = Module["_pico_enqueue_segment"] = function() { + return Module["asm"]["_pico_enqueue_segment"].apply(null, arguments) +}; + +var _pico_eth_check_bcast = Module["_pico_eth_check_bcast"] = function() { + return Module["asm"]["_pico_eth_check_bcast"].apply(null, arguments) +}; + +var _pico_eth_receive = Module["_pico_eth_receive"] = function() { + return Module["asm"]["_pico_eth_receive"].apply(null, arguments) +}; + +var _pico_ethernet_alloc = Module["_pico_ethernet_alloc"] = function() { + return Module["asm"]["_pico_ethernet_alloc"].apply(null, arguments) +}; + +var _pico_ethernet_ipv6_dst = Module["_pico_ethernet_ipv6_dst"] = function() { + return Module["asm"]["_pico_ethernet_ipv6_dst"].apply(null, arguments) +}; + +var _pico_ethernet_mcast6_translate = Module["_pico_ethernet_mcast6_translate"] = function() { + return Module["asm"]["_pico_ethernet_mcast6_translate"].apply(null, arguments) +}; + +var _pico_ethernet_mcast_translate = Module["_pico_ethernet_mcast_translate"] = function() { + return Module["asm"]["_pico_ethernet_mcast_translate"].apply(null, arguments) +}; + +var _pico_ethernet_process_in = Module["_pico_ethernet_process_in"] = function() { + return Module["asm"]["_pico_ethernet_process_in"].apply(null, arguments) +}; + +var _pico_ethernet_process_out = Module["_pico_ethernet_process_out"] = function() { + return Module["asm"]["_pico_ethernet_process_out"].apply(null, arguments) +}; + +var _pico_ethernet_receive = Module["_pico_ethernet_receive"] = function() { + return Module["asm"]["_pico_ethernet_receive"].apply(null, arguments) +}; + +var _pico_ethernet_send = Module["_pico_ethernet_send"] = function() { + return Module["asm"]["_pico_ethernet_send"].apply(null, arguments) +}; + +var _pico_ethsend_bcast = Module["_pico_ethsend_bcast"] = function() { + return Module["asm"]["_pico_ethsend_bcast"].apply(null, arguments) +}; + +var _pico_ethsend_dispatch = Module["_pico_ethsend_dispatch"] = function() { + return Module["asm"]["_pico_ethsend_dispatch"].apply(null, arguments) +}; + +var _pico_ethsend_local = Module["_pico_ethsend_local"] = function() { + return Module["asm"]["_pico_ethsend_local"].apply(null, arguments) +}; + +var _pico_frag_expire = Module["_pico_frag_expire"] = function() { + return Module["asm"]["_pico_frag_expire"].apply(null, arguments) +}; + +var _pico_fragments_check_complete = Module["_pico_fragments_check_complete"] = function() { + return Module["asm"]["_pico_fragments_check_complete"].apply(null, arguments) +}; + +var _pico_fragments_complete = Module["_pico_fragments_complete"] = function() { + return Module["asm"]["_pico_fragments_complete"].apply(null, arguments) +}; + +var _pico_fragments_empty_tree = Module["_pico_fragments_empty_tree"] = function() { + return Module["asm"]["_pico_fragments_empty_tree"].apply(null, arguments) +}; + +var _pico_fragments_get_header_length = Module["_pico_fragments_get_header_length"] = function() { + return Module["asm"]["_pico_fragments_get_header_length"].apply(null, arguments) +}; + +var _pico_fragments_get_more_flag = Module["_pico_fragments_get_more_flag"] = function() { + return Module["asm"]["_pico_fragments_get_more_flag"].apply(null, arguments) +}; + +var _pico_fragments_get_offset = Module["_pico_fragments_get_offset"] = function() { + return Module["asm"]["_pico_fragments_get_offset"].apply(null, arguments) +}; + +var _pico_fragments_reassemble = Module["_pico_fragments_reassemble"] = function() { + return Module["asm"]["_pico_fragments_reassemble"].apply(null, arguments) +}; + +var _pico_fragments_send_notify = Module["_pico_fragments_send_notify"] = function() { + return Module["asm"]["_pico_fragments_send_notify"].apply(null, arguments) +}; + +var _pico_frame_alloc = Module["_pico_frame_alloc"] = function() { + return Module["asm"]["_pico_frame_alloc"].apply(null, arguments) +}; + +var _pico_frame_alloc_skeleton = Module["_pico_frame_alloc_skeleton"] = function() { + return Module["asm"]["_pico_frame_alloc_skeleton"].apply(null, arguments) +}; + +var _pico_frame_copy = Module["_pico_frame_copy"] = function() { + return Module["asm"]["_pico_frame_copy"].apply(null, arguments) +}; + +var _pico_frame_discard = Module["_pico_frame_discard"] = function() { + return Module["asm"]["_pico_frame_discard"].apply(null, arguments) +}; + +var _pico_frame_do_alloc = Module["_pico_frame_do_alloc"] = function() { + return Module["asm"]["_pico_frame_do_alloc"].apply(null, arguments) +}; + +var _pico_frame_dst_is_unicast = Module["_pico_frame_dst_is_unicast"] = function() { + return Module["asm"]["_pico_frame_dst_is_unicast"].apply(null, arguments) +}; + +var _pico_frame_grow_head = Module["_pico_frame_grow_head"] = function() { + return Module["asm"]["_pico_frame_grow_head"].apply(null, arguments) +}; + +var _pico_frame_new_buffer = Module["_pico_frame_new_buffer"] = function() { + return Module["asm"]["_pico_frame_new_buffer"].apply(null, arguments) +}; + +var _pico_frame_skeleton_set_buffer = Module["_pico_frame_skeleton_set_buffer"] = function() { + return Module["asm"]["_pico_frame_skeleton_set_buffer"].apply(null, arguments) +}; + +var _pico_frame_update_pointers = Module["_pico_frame_update_pointers"] = function() { + return Module["asm"]["_pico_frame_update_pointers"].apply(null, arguments) +}; + +var _pico_generic_port_in_use = Module["_pico_generic_port_in_use"] = function() { + return Module["asm"]["_pico_generic_port_in_use"].apply(null, arguments) +}; + +var _pico_get_device = Module["_pico_get_device"] = function() { + return Module["asm"]["_pico_get_device"].apply(null, arguments) +}; + +var _pico_get_sockport = Module["_pico_get_sockport"] = function() { + return Module["asm"]["_pico_get_sockport"].apply(null, arguments) +}; + +var _pico_hash = Module["_pico_hash"] = function() { + return Module["asm"]["_pico_hash"].apply(null, arguments) +}; + +var _pico_hash_431 = Module["_pico_hash_431"] = function() { + return Module["asm"]["_pico_hash_431"].apply(null, arguments) +}; + +var _pico_hold_segment_make = Module["_pico_hold_segment_make"] = function() { + return Module["asm"]["_pico_hold_segment_make"].apply(null, arguments) +}; + +var _pico_icmp4_checksum = Module["_pico_icmp4_checksum"] = function() { + return Module["asm"]["_pico_icmp4_checksum"].apply(null, arguments) +}; + +var _pico_icmp4_dest_unreachable = Module["_pico_icmp4_dest_unreachable"] = function() { + return Module["asm"]["_pico_icmp4_dest_unreachable"].apply(null, arguments) +}; + +var _pico_icmp4_frag_expired = Module["_pico_icmp4_frag_expired"] = function() { + return Module["asm"]["_pico_icmp4_frag_expired"].apply(null, arguments) +}; + +var _pico_icmp4_mtu_exceeded = Module["_pico_icmp4_mtu_exceeded"] = function() { + return Module["asm"]["_pico_icmp4_mtu_exceeded"].apply(null, arguments) +}; + +var _pico_icmp4_notify = Module["_pico_icmp4_notify"] = function() { + return Module["asm"]["_pico_icmp4_notify"].apply(null, arguments) +}; + +var _pico_icmp4_param_problem = Module["_pico_icmp4_param_problem"] = function() { + return Module["asm"]["_pico_icmp4_param_problem"].apply(null, arguments) +}; + +var _pico_icmp4_ping = Module["_pico_icmp4_ping"] = function() { + return Module["asm"]["_pico_icmp4_ping"].apply(null, arguments) +}; + +var _pico_icmp4_port_unreachable = Module["_pico_icmp4_port_unreachable"] = function() { + return Module["asm"]["_pico_icmp4_port_unreachable"].apply(null, arguments) +}; + +var _pico_icmp4_process_in = Module["_pico_icmp4_process_in"] = function() { + return Module["asm"]["_pico_icmp4_process_in"].apply(null, arguments) +}; + +var _pico_icmp4_process_out = Module["_pico_icmp4_process_out"] = function() { + return Module["asm"]["_pico_icmp4_process_out"].apply(null, arguments) +}; + +var _pico_icmp4_proto_unreachable = Module["_pico_icmp4_proto_unreachable"] = function() { + return Module["asm"]["_pico_icmp4_proto_unreachable"].apply(null, arguments) +}; + +var _pico_icmp4_send_echo = Module["_pico_icmp4_send_echo"] = function() { + return Module["asm"]["_pico_icmp4_send_echo"].apply(null, arguments) +}; + +var _pico_icmp4_ttl_expired = Module["_pico_icmp4_ttl_expired"] = function() { + return Module["asm"]["_pico_icmp4_ttl_expired"].apply(null, arguments) +}; + +var _pico_icmp6_address_to_prefix = Module["_pico_icmp6_address_to_prefix"] = function() { + return Module["asm"]["_pico_icmp6_address_to_prefix"].apply(null, arguments) +}; + +var _pico_icmp6_checksum = Module["_pico_icmp6_checksum"] = function() { + return Module["asm"]["_pico_icmp6_checksum"].apply(null, arguments) +}; + +var _pico_icmp6_dest_unreachable = Module["_pico_icmp6_dest_unreachable"] = function() { + return Module["asm"]["_pico_icmp6_dest_unreachable"].apply(null, arguments) +}; + +var _pico_icmp6_frag_expired = Module["_pico_icmp6_frag_expired"] = function() { + return Module["asm"]["_pico_icmp6_frag_expired"].apply(null, arguments) +}; + +var _pico_icmp6_neigh_sol_prep = Module["_pico_icmp6_neigh_sol_prep"] = function() { + return Module["asm"]["_pico_icmp6_neigh_sol_prep"].apply(null, arguments) +}; + +var _pico_icmp6_neighbor_advertisement = Module["_pico_icmp6_neighbor_advertisement"] = function() { + return Module["asm"]["_pico_icmp6_neighbor_advertisement"].apply(null, arguments) +}; + +var _pico_icmp6_neighbor_solicitation = Module["_pico_icmp6_neighbor_solicitation"] = function() { + return Module["asm"]["_pico_icmp6_neighbor_solicitation"].apply(null, arguments) +}; + +var _pico_icmp6_notify = Module["_pico_icmp6_notify"] = function() { + return Module["asm"]["_pico_icmp6_notify"].apply(null, arguments) +}; + +var _pico_icmp6_parameter_problem = Module["_pico_icmp6_parameter_problem"] = function() { + return Module["asm"]["_pico_icmp6_parameter_problem"].apply(null, arguments) +}; + +var _pico_icmp6_ping_recv_reply = Module["_pico_icmp6_ping_recv_reply"] = function() { + return Module["asm"]["_pico_icmp6_ping_recv_reply"].apply(null, arguments) +}; + +var _pico_icmp6_pkt_too_big = Module["_pico_icmp6_pkt_too_big"] = function() { + return Module["asm"]["_pico_icmp6_pkt_too_big"].apply(null, arguments) +}; + +var _pico_icmp6_port_unreachable = Module["_pico_icmp6_port_unreachable"] = function() { + return Module["asm"]["_pico_icmp6_port_unreachable"].apply(null, arguments) +}; + +var _pico_icmp6_process_in = Module["_pico_icmp6_process_in"] = function() { + return Module["asm"]["_pico_icmp6_process_in"].apply(null, arguments) +}; + +var _pico_icmp6_process_out = Module["_pico_icmp6_process_out"] = function() { + return Module["asm"]["_pico_icmp6_process_out"].apply(null, arguments) +}; + +var _pico_icmp6_proto_unreachable = Module["_pico_icmp6_proto_unreachable"] = function() { + return Module["asm"]["_pico_icmp6_proto_unreachable"].apply(null, arguments) +}; + +var _pico_icmp6_provide_llao = Module["_pico_icmp6_provide_llao"] = function() { + return Module["asm"]["_pico_icmp6_provide_llao"].apply(null, arguments) +}; + +var _pico_icmp6_router_advertisement = Module["_pico_icmp6_router_advertisement"] = function() { + return Module["asm"]["_pico_icmp6_router_advertisement"].apply(null, arguments) +}; + +var _pico_icmp6_router_solicitation = Module["_pico_icmp6_router_solicitation"] = function() { + return Module["asm"]["_pico_icmp6_router_solicitation"].apply(null, arguments) +}; + +var _pico_icmp6_send_echoreply = Module["_pico_icmp6_send_echoreply"] = function() { + return Module["asm"]["_pico_icmp6_send_echoreply"].apply(null, arguments) +}; + +var _pico_icmp6_ttl_expired = Module["_pico_icmp6_ttl_expired"] = function() { + return Module["asm"]["_pico_icmp6_ttl_expired"].apply(null, arguments) +}; + +var _pico_igmp_analyse_packet = Module["_pico_igmp_analyse_packet"] = function() { + return Module["asm"]["_pico_igmp_analyse_packet"].apply(null, arguments) +}; + +var _pico_igmp_compatibility_mode = Module["_pico_igmp_compatibility_mode"] = function() { + return Module["asm"]["_pico_igmp_compatibility_mode"].apply(null, arguments) +}; + +var _pico_igmp_delete_parameter = Module["_pico_igmp_delete_parameter"] = function() { + return Module["asm"]["_pico_igmp_delete_parameter"].apply(null, arguments) +}; + +var _pico_igmp_find_parameter = Module["_pico_igmp_find_parameter"] = function() { + return Module["asm"]["_pico_igmp_find_parameter"].apply(null, arguments) +}; + +var _pico_igmp_find_timer = Module["_pico_igmp_find_timer"] = function() { + return Module["asm"]["_pico_igmp_find_timer"].apply(null, arguments) +}; + +var _pico_igmp_generate_report = Module["_pico_igmp_generate_report"] = function() { + return Module["asm"]["_pico_igmp_generate_report"].apply(null, arguments) +}; + +var _pico_igmp_is_checksum_valid = Module["_pico_igmp_is_checksum_valid"] = function() { + return Module["asm"]["_pico_igmp_is_checksum_valid"].apply(null, arguments) +}; + +var _pico_igmp_process_event = Module["_pico_igmp_process_event"] = function() { + return Module["asm"]["_pico_igmp_process_event"].apply(null, arguments) +}; + +var _pico_igmp_process_in = Module["_pico_igmp_process_in"] = function() { + return Module["asm"]["_pico_igmp_process_in"].apply(null, arguments) +}; + +var _pico_igmp_process_out = Module["_pico_igmp_process_out"] = function() { + return Module["asm"]["_pico_igmp_process_out"].apply(null, arguments) +}; + +var _pico_igmp_report_expired = Module["_pico_igmp_report_expired"] = function() { + return Module["asm"]["_pico_igmp_report_expired"].apply(null, arguments) +}; + +var _pico_igmp_send_report = Module["_pico_igmp_send_report"] = function() { + return Module["asm"]["_pico_igmp_send_report"].apply(null, arguments) +}; + +var _pico_igmp_state_change = Module["_pico_igmp_state_change"] = function() { + return Module["asm"]["_pico_igmp_state_change"].apply(null, arguments) +}; + +var _pico_igmp_timer_expired = Module["_pico_igmp_timer_expired"] = function() { + return Module["asm"]["_pico_igmp_timer_expired"].apply(null, arguments) +}; + +var _pico_igmp_timer_is_running = Module["_pico_igmp_timer_is_running"] = function() { + return Module["asm"]["_pico_igmp_timer_is_running"].apply(null, arguments) +}; + +var _pico_igmp_timer_reset = Module["_pico_igmp_timer_reset"] = function() { + return Module["asm"]["_pico_igmp_timer_reset"].apply(null, arguments) +}; + +var _pico_igmp_timer_start = Module["_pico_igmp_timer_start"] = function() { + return Module["asm"]["_pico_igmp_timer_start"].apply(null, arguments) +}; + +var _pico_igmp_timer_stop = Module["_pico_igmp_timer_stop"] = function() { + return Module["asm"]["_pico_igmp_timer_stop"].apply(null, arguments) +}; + +var _pico_igmp_v2querier_expired = Module["_pico_igmp_v2querier_expired"] = function() { + return Module["asm"]["_pico_igmp_v2querier_expired"].apply(null, arguments) +}; + +var _pico_igmpv2_generate_report = Module["_pico_igmpv2_generate_report"] = function() { + return Module["asm"]["_pico_igmpv2_generate_report"].apply(null, arguments) +}; + +var _pico_igmpv3_generate_filter = Module["_pico_igmpv3_generate_filter"] = function() { + return Module["asm"]["_pico_igmpv3_generate_filter"].apply(null, arguments) +}; + +var _pico_igmpv3_generate_report = Module["_pico_igmpv3_generate_report"] = function() { + return Module["asm"]["_pico_igmpv3_generate_report"].apply(null, arguments) +}; + +var _pico_ipv4_alloc = Module["_pico_ipv4_alloc"] = function() { + return Module["asm"]["_pico_ipv4_alloc"].apply(null, arguments) +}; + +var _pico_ipv4_checksum = Module["_pico_ipv4_checksum"] = function() { + return Module["asm"]["_pico_ipv4_checksum"].apply(null, arguments) +}; + +var _pico_ipv4_cleanup_routes = Module["_pico_ipv4_cleanup_routes"] = function() { + return Module["asm"]["_pico_ipv4_cleanup_routes"].apply(null, arguments) +}; + +var _pico_ipv4_compare = Module["_pico_ipv4_compare"] = function() { + return Module["asm"]["_pico_ipv4_compare"].apply(null, arguments) +}; + +var _pico_ipv4_crc_check = Module["_pico_ipv4_crc_check"] = function() { + return Module["asm"]["_pico_ipv4_crc_check"].apply(null, arguments) +}; + +var _pico_ipv4_ethernet_receive = Module["_pico_ipv4_ethernet_receive"] = function() { + return Module["asm"]["_pico_ipv4_ethernet_receive"].apply(null, arguments) +}; + +var _pico_ipv4_forward = Module["_pico_ipv4_forward"] = function() { + return Module["asm"]["_pico_ipv4_forward"].apply(null, arguments) +}; + +var _pico_ipv4_forward_check_dev = Module["_pico_ipv4_forward_check_dev"] = function() { + return Module["asm"]["_pico_ipv4_forward_check_dev"].apply(null, arguments) +}; + +var _pico_ipv4_frag_compare = Module["_pico_ipv4_frag_compare"] = function() { + return Module["asm"]["_pico_ipv4_frag_compare"].apply(null, arguments) +}; + +var _pico_ipv4_frag_match = Module["_pico_ipv4_frag_match"] = function() { + return Module["asm"]["_pico_ipv4_frag_match"].apply(null, arguments) +}; + +var _pico_ipv4_frag_timer_on = Module["_pico_ipv4_frag_timer_on"] = function() { + return Module["asm"]["_pico_ipv4_frag_timer_on"].apply(null, arguments) +}; + +var _pico_ipv4_fragments_complete = Module["_pico_ipv4_fragments_complete"] = function() { + return Module["asm"]["_pico_ipv4_fragments_complete"].apply(null, arguments) +}; + +var _pico_ipv4_frame_push = Module["_pico_ipv4_frame_push"] = function() { + return Module["asm"]["_pico_ipv4_frame_push"].apply(null, arguments) +}; + +var _pico_ipv4_frame_sock_push = Module["_pico_ipv4_frame_sock_push"] = function() { + return Module["asm"]["_pico_ipv4_frame_sock_push"].apply(null, arguments) +}; + +var _pico_ipv4_get_default_mcastlink = Module["_pico_ipv4_get_default_mcastlink"] = function() { + return Module["asm"]["_pico_ipv4_get_default_mcastlink"].apply(null, arguments) +}; + +var _pico_ipv4_is_broadcast = Module["_pico_ipv4_is_broadcast"] = function() { + return Module["asm"]["_pico_ipv4_is_broadcast"].apply(null, arguments) +}; + +var _pico_ipv4_is_invalid_loopback = Module["_pico_ipv4_is_invalid_loopback"] = function() { + return Module["asm"]["_pico_ipv4_is_invalid_loopback"].apply(null, arguments) +}; + +var _pico_ipv4_is_loopback = Module["_pico_ipv4_is_loopback"] = function() { + return Module["asm"]["_pico_ipv4_is_loopback"].apply(null, arguments) +}; + +var _pico_ipv4_is_multicast = Module["_pico_ipv4_is_multicast"] = function() { + return Module["asm"]["_pico_ipv4_is_multicast"].apply(null, arguments) +}; + +var _pico_ipv4_is_unicast = Module["_pico_ipv4_is_unicast"] = function() { + return Module["asm"]["_pico_ipv4_is_unicast"].apply(null, arguments) +}; + +var _pico_ipv4_is_valid_src = Module["_pico_ipv4_is_valid_src"] = function() { + return Module["asm"]["_pico_ipv4_is_valid_src"].apply(null, arguments) +}; + +var _pico_ipv4_link_add = Module["_pico_ipv4_link_add"] = function() { + return Module["asm"]["_pico_ipv4_link_add"].apply(null, arguments) +}; + +var _pico_ipv4_link_by_dev = Module["_pico_ipv4_link_by_dev"] = function() { + return Module["asm"]["_pico_ipv4_link_by_dev"].apply(null, arguments) +}; + +var _pico_ipv4_link_by_dev_next = Module["_pico_ipv4_link_by_dev_next"] = function() { + return Module["asm"]["_pico_ipv4_link_by_dev_next"].apply(null, arguments) +}; + +var _pico_ipv4_link_del = Module["_pico_ipv4_link_del"] = function() { + return Module["asm"]["_pico_ipv4_link_del"].apply(null, arguments) +}; + +var _pico_ipv4_link_find = Module["_pico_ipv4_link_find"] = function() { + return Module["asm"]["_pico_ipv4_link_find"].apply(null, arguments) +}; + +var _pico_ipv4_link_get = Module["_pico_ipv4_link_get"] = function() { + return Module["asm"]["_pico_ipv4_link_get"].apply(null, arguments) +}; + +var _pico_ipv4_mcast_filter = Module["_pico_ipv4_mcast_filter"] = function() { + return Module["asm"]["_pico_ipv4_mcast_filter"].apply(null, arguments) +}; + +var _pico_ipv4_mcast_join = Module["_pico_ipv4_mcast_join"] = function() { + return Module["asm"]["_pico_ipv4_mcast_join"].apply(null, arguments) +}; + +var _pico_ipv4_mcast_leave = Module["_pico_ipv4_mcast_leave"] = function() { + return Module["asm"]["_pico_ipv4_mcast_leave"].apply(null, arguments) +}; + +var _pico_ipv4_mcast_print_groups = Module["_pico_ipv4_mcast_print_groups"] = function() { + return Module["asm"]["_pico_ipv4_mcast_print_groups"].apply(null, arguments) +}; + +var _pico_ipv4_nat_add = Module["_pico_ipv4_nat_add"] = function() { + return Module["asm"]["_pico_ipv4_nat_add"].apply(null, arguments) +}; + +var _pico_ipv4_nat_find = Module["_pico_ipv4_nat_find"] = function() { + return Module["asm"]["_pico_ipv4_nat_find"].apply(null, arguments) +}; + +var _pico_ipv4_nat_find_tuple = Module["_pico_ipv4_nat_find_tuple"] = function() { + return Module["asm"]["_pico_ipv4_nat_find_tuple"].apply(null, arguments) +}; + +var _pico_ipv4_nat_generate_tuple = Module["_pico_ipv4_nat_generate_tuple"] = function() { + return Module["asm"]["_pico_ipv4_nat_generate_tuple"].apply(null, arguments) +}; + +var _pico_ipv4_nat_inbound = Module["_pico_ipv4_nat_inbound"] = function() { + return Module["asm"]["_pico_ipv4_nat_inbound"].apply(null, arguments) +}; + +var _pico_ipv4_nat_is_enabled = Module["_pico_ipv4_nat_is_enabled"] = function() { + return Module["asm"]["_pico_ipv4_nat_is_enabled"].apply(null, arguments) +}; + +var _pico_ipv4_nat_outbound = Module["_pico_ipv4_nat_outbound"] = function() { + return Module["asm"]["_pico_ipv4_nat_outbound"].apply(null, arguments) +}; + +var _pico_ipv4_nat_set_tcp_flags = Module["_pico_ipv4_nat_set_tcp_flags"] = function() { + return Module["asm"]["_pico_ipv4_nat_set_tcp_flags"].apply(null, arguments) +}; + +var _pico_ipv4_nat_sniff_session = Module["_pico_ipv4_nat_sniff_session"] = function() { + return Module["asm"]["_pico_ipv4_nat_sniff_session"].apply(null, arguments) +}; + +var _pico_ipv4_pre_forward_checks = Module["_pico_ipv4_pre_forward_checks"] = function() { + return Module["asm"]["_pico_ipv4_pre_forward_checks"].apply(null, arguments) +}; + +var _pico_ipv4_process_bcast_in = Module["_pico_ipv4_process_bcast_in"] = function() { + return Module["asm"]["_pico_ipv4_process_bcast_in"].apply(null, arguments) +}; + +var _pico_ipv4_process_finally_try_forward = Module["_pico_ipv4_process_finally_try_forward"] = function() { + return Module["asm"]["_pico_ipv4_process_finally_try_forward"].apply(null, arguments) +}; + +var _pico_ipv4_process_frag = Module["_pico_ipv4_process_frag"] = function() { + return Module["asm"]["_pico_ipv4_process_frag"].apply(null, arguments) +}; + +var _pico_ipv4_process_in = Module["_pico_ipv4_process_in"] = function() { + return Module["asm"]["_pico_ipv4_process_in"].apply(null, arguments) +}; + +var _pico_ipv4_process_local_unicast_in = Module["_pico_ipv4_process_local_unicast_in"] = function() { + return Module["asm"]["_pico_ipv4_process_local_unicast_in"].apply(null, arguments) +}; + +var _pico_ipv4_process_mcast_in = Module["_pico_ipv4_process_mcast_in"] = function() { + return Module["asm"]["_pico_ipv4_process_mcast_in"].apply(null, arguments) +}; + +var _pico_ipv4_process_out = Module["_pico_ipv4_process_out"] = function() { + return Module["asm"]["_pico_ipv4_process_out"].apply(null, arguments) +}; + +var _pico_ipv4_rebound = Module["_pico_ipv4_rebound"] = function() { + return Module["asm"]["_pico_ipv4_rebound"].apply(null, arguments) +}; + +var _pico_ipv4_rebound_large = Module["_pico_ipv4_rebound_large"] = function() { + return Module["asm"]["_pico_ipv4_rebound_large"].apply(null, arguments) +}; + +var _pico_ipv4_route_add = Module["_pico_ipv4_route_add"] = function() { + return Module["asm"]["_pico_ipv4_route_add"].apply(null, arguments) +}; + +var _pico_ipv4_route_del = Module["_pico_ipv4_route_del"] = function() { + return Module["asm"]["_pico_ipv4_route_del"].apply(null, arguments) +}; + +var _pico_ipv4_route_get_gateway = Module["_pico_ipv4_route_get_gateway"] = function() { + return Module["asm"]["_pico_ipv4_route_get_gateway"].apply(null, arguments) +}; + +var _pico_ipv4_route_set_bcast_link = Module["_pico_ipv4_route_set_bcast_link"] = function() { + return Module["asm"]["_pico_ipv4_route_set_bcast_link"].apply(null, arguments) +}; + +var _pico_ipv4_source_dev_find = Module["_pico_ipv4_source_dev_find"] = function() { + return Module["asm"]["_pico_ipv4_source_dev_find"].apply(null, arguments) +}; + +var _pico_ipv4_source_find = Module["_pico_ipv4_source_find"] = function() { + return Module["asm"]["_pico_ipv4_source_find"].apply(null, arguments) +}; + +var _pico_ipv4_to_string = Module["_pico_ipv4_to_string"] = function() { + return Module["asm"]["_pico_ipv4_to_string"].apply(null, arguments) +}; + +var _pico_ipv4_unreachable = Module["_pico_ipv4_unreachable"] = function() { + return Module["asm"]["_pico_ipv4_unreachable"].apply(null, arguments) +}; + +var _pico_ipv6_alloc = Module["_pico_ipv6_alloc"] = function() { + return Module["asm"]["_pico_ipv6_alloc"].apply(null, arguments) +}; + +var _pico_ipv6_check_aligned = Module["_pico_ipv6_check_aligned"] = function() { + return Module["asm"]["_pico_ipv6_check_aligned"].apply(null, arguments) +}; + +var _pico_ipv6_check_headers_sequence = Module["_pico_ipv6_check_headers_sequence"] = function() { + return Module["asm"]["_pico_ipv6_check_headers_sequence"].apply(null, arguments) +}; + +var _pico_ipv6_check_lifetime_expired = Module["_pico_ipv6_check_lifetime_expired"] = function() { + return Module["asm"]["_pico_ipv6_check_lifetime_expired"].apply(null, arguments) +}; + +var _pico_ipv6_cleanup_routes = Module["_pico_ipv6_cleanup_routes"] = function() { + return Module["asm"]["_pico_ipv6_cleanup_routes"].apply(null, arguments) +}; + +var _pico_ipv6_compare = Module["_pico_ipv6_compare"] = function() { + return Module["asm"]["_pico_ipv6_compare"].apply(null, arguments) +}; + +var _pico_ipv6_dec_to_char = Module["_pico_ipv6_dec_to_char"] = function() { + return Module["asm"]["_pico_ipv6_dec_to_char"].apply(null, arguments) +}; + +var _pico_ipv6_do_link_add = Module["_pico_ipv6_do_link_add"] = function() { + return Module["asm"]["_pico_ipv6_do_link_add"].apply(null, arguments) +}; + +var _pico_ipv6_ethernet_receive = Module["_pico_ipv6_ethernet_receive"] = function() { + return Module["asm"]["_pico_ipv6_ethernet_receive"].apply(null, arguments) +}; + +var _pico_ipv6_extension_headers = Module["_pico_ipv6_extension_headers"] = function() { + return Module["asm"]["_pico_ipv6_extension_headers"].apply(null, arguments) +}; + +var _pico_ipv6_forward = Module["_pico_ipv6_forward"] = function() { + return Module["asm"]["_pico_ipv6_forward"].apply(null, arguments) +}; + +var _pico_ipv6_forward_check_dev = Module["_pico_ipv6_forward_check_dev"] = function() { + return Module["asm"]["_pico_ipv6_forward_check_dev"].apply(null, arguments) +}; + +var _pico_ipv6_frag_compare = Module["_pico_ipv6_frag_compare"] = function() { + return Module["asm"]["_pico_ipv6_frag_compare"].apply(null, arguments) +}; + +var _pico_ipv6_frag_match = Module["_pico_ipv6_frag_match"] = function() { + return Module["asm"]["_pico_ipv6_frag_match"].apply(null, arguments) +}; + +var _pico_ipv6_frag_timer_on = Module["_pico_ipv6_frag_timer_on"] = function() { + return Module["asm"]["_pico_ipv6_frag_timer_on"].apply(null, arguments) +}; + +var _pico_ipv6_fragments_complete = Module["_pico_ipv6_fragments_complete"] = function() { + return Module["asm"]["_pico_ipv6_fragments_complete"].apply(null, arguments) +}; + +var _pico_ipv6_frame_push = Module["_pico_ipv6_frame_push"] = function() { + return Module["asm"]["_pico_ipv6_frame_push"].apply(null, arguments) +}; + +var _pico_ipv6_frame_sock_push = Module["_pico_ipv6_frame_sock_push"] = function() { + return Module["asm"]["_pico_ipv6_frame_sock_push"].apply(null, arguments) +}; + +var _pico_ipv6_get_default_mcastlink = Module["_pico_ipv6_get_default_mcastlink"] = function() { + return Module["asm"]["_pico_ipv6_get_default_mcastlink"].apply(null, arguments) +}; + +var _pico_ipv6_get_neighbor = Module["_pico_ipv6_get_neighbor"] = function() { + return Module["asm"]["_pico_ipv6_get_neighbor"].apply(null, arguments) +}; + +var _pico_ipv6_global_get = Module["_pico_ipv6_global_get"] = function() { + return Module["asm"]["_pico_ipv6_global_get"].apply(null, arguments) +}; + +var _pico_ipv6_hex_to_dec = Module["_pico_ipv6_hex_to_dec"] = function() { + return Module["asm"]["_pico_ipv6_hex_to_dec"].apply(null, arguments) +}; + +var _pico_ipv6_is_allhosts_multicast = Module["_pico_ipv6_is_allhosts_multicast"] = function() { + return Module["asm"]["_pico_ipv6_is_allhosts_multicast"].apply(null, arguments) +}; + +var _pico_ipv6_is_global = Module["_pico_ipv6_is_global"] = function() { + return Module["asm"]["_pico_ipv6_is_global"].apply(null, arguments) +}; + +var _pico_ipv6_is_linklocal = Module["_pico_ipv6_is_linklocal"] = function() { + return Module["asm"]["_pico_ipv6_is_linklocal"].apply(null, arguments) +}; + +var _pico_ipv6_is_localhost = Module["_pico_ipv6_is_localhost"] = function() { + return Module["asm"]["_pico_ipv6_is_localhost"].apply(null, arguments) +}; + +var _pico_ipv6_is_multicast = Module["_pico_ipv6_is_multicast"] = function() { + return Module["asm"]["_pico_ipv6_is_multicast"].apply(null, arguments) +}; + +var _pico_ipv6_is_null_address = Module["_pico_ipv6_is_null_address"] = function() { + return Module["asm"]["_pico_ipv6_is_null_address"].apply(null, arguments) +}; + +var _pico_ipv6_is_sitelocal = Module["_pico_ipv6_is_sitelocal"] = function() { + return Module["asm"]["_pico_ipv6_is_sitelocal"].apply(null, arguments) +}; + +var _pico_ipv6_is_solnode_multicast = Module["_pico_ipv6_is_solnode_multicast"] = function() { + return Module["asm"]["_pico_ipv6_is_solnode_multicast"].apply(null, arguments) +}; + +var _pico_ipv6_is_unicast = Module["_pico_ipv6_is_unicast"] = function() { + return Module["asm"]["_pico_ipv6_is_unicast"].apply(null, arguments) +}; + +var _pico_ipv6_is_uniquelocal = Module["_pico_ipv6_is_uniquelocal"] = function() { + return Module["asm"]["_pico_ipv6_is_uniquelocal"].apply(null, arguments) +}; + +var _pico_ipv6_is_unspecified = Module["_pico_ipv6_is_unspecified"] = function() { + return Module["asm"]["_pico_ipv6_is_unspecified"].apply(null, arguments) +}; + +var _pico_ipv6_lifetime_set = Module["_pico_ipv6_lifetime_set"] = function() { + return Module["asm"]["_pico_ipv6_lifetime_set"].apply(null, arguments) +}; + +var _pico_ipv6_link_add = Module["_pico_ipv6_link_add"] = function() { + return Module["asm"]["_pico_ipv6_link_add"].apply(null, arguments) +}; + +var _pico_ipv6_link_add_local = Module["_pico_ipv6_link_add_local"] = function() { + return Module["asm"]["_pico_ipv6_link_add_local"].apply(null, arguments) +}; + +var _pico_ipv6_link_by_dev = Module["_pico_ipv6_link_by_dev"] = function() { + return Module["asm"]["_pico_ipv6_link_by_dev"].apply(null, arguments) +}; + +var _pico_ipv6_link_by_dev_next = Module["_pico_ipv6_link_by_dev_next"] = function() { + return Module["asm"]["_pico_ipv6_link_by_dev_next"].apply(null, arguments) +}; + +var _pico_ipv6_link_del = Module["_pico_ipv6_link_del"] = function() { + return Module["asm"]["_pico_ipv6_link_del"].apply(null, arguments) +}; + +var _pico_ipv6_link_find = Module["_pico_ipv6_link_find"] = function() { + return Module["asm"]["_pico_ipv6_link_find"].apply(null, arguments) +}; + +var _pico_ipv6_link_get = Module["_pico_ipv6_link_get"] = function() { + return Module["asm"]["_pico_ipv6_link_get"].apply(null, arguments) +}; + +var _pico_ipv6_link_istentative = Module["_pico_ipv6_link_istentative"] = function() { + return Module["asm"]["_pico_ipv6_link_istentative"].apply(null, arguments) +}; + +var _pico_ipv6_linklocal_get = Module["_pico_ipv6_linklocal_get"] = function() { + return Module["asm"]["_pico_ipv6_linklocal_get"].apply(null, arguments) +}; + +var _pico_ipv6_mcast_filter = Module["_pico_ipv6_mcast_filter"] = function() { + return Module["asm"]["_pico_ipv6_mcast_filter"].apply(null, arguments) +}; + +var _pico_ipv6_mcast_join = Module["_pico_ipv6_mcast_join"] = function() { + return Module["asm"]["_pico_ipv6_mcast_join"].apply(null, arguments) +}; + +var _pico_ipv6_mcast_leave = Module["_pico_ipv6_mcast_leave"] = function() { + return Module["asm"]["_pico_ipv6_mcast_leave"].apply(null, arguments) +}; + +var _pico_ipv6_nd_dad = Module["_pico_ipv6_nd_dad"] = function() { + return Module["asm"]["_pico_ipv6_nd_dad"].apply(null, arguments) +}; + +var _pico_ipv6_nd_init = Module["_pico_ipv6_nd_init"] = function() { + return Module["asm"]["_pico_ipv6_nd_init"].apply(null, arguments) +}; + +var _pico_ipv6_nd_postpone = Module["_pico_ipv6_nd_postpone"] = function() { + return Module["asm"]["_pico_ipv6_nd_postpone"].apply(null, arguments) +}; + +var _pico_ipv6_nd_queued_trigger = Module["_pico_ipv6_nd_queued_trigger"] = function() { + return Module["asm"]["_pico_ipv6_nd_queued_trigger"].apply(null, arguments) +}; + +var _pico_ipv6_nd_ra_timer_callback = Module["_pico_ipv6_nd_ra_timer_callback"] = function() { + return Module["asm"]["_pico_ipv6_nd_ra_timer_callback"].apply(null, arguments) +}; + +var _pico_ipv6_nd_recv = Module["_pico_ipv6_nd_recv"] = function() { + return Module["asm"]["_pico_ipv6_nd_recv"].apply(null, arguments) +}; + +var _pico_ipv6_nd_timer_callback = Module["_pico_ipv6_nd_timer_callback"] = function() { + return Module["asm"]["_pico_ipv6_nd_timer_callback"].apply(null, arguments) +}; + +var _pico_ipv6_nd_timer_elapsed = Module["_pico_ipv6_nd_timer_elapsed"] = function() { + return Module["asm"]["_pico_ipv6_nd_timer_elapsed"].apply(null, arguments) +}; + +var _pico_ipv6_nd_unreachable = Module["_pico_ipv6_nd_unreachable"] = function() { + return Module["asm"]["_pico_ipv6_nd_unreachable"].apply(null, arguments) +}; + +var _pico_ipv6_neighbor_compare = Module["_pico_ipv6_neighbor_compare"] = function() { + return Module["asm"]["_pico_ipv6_neighbor_compare"].apply(null, arguments) +}; + +var _pico_ipv6_neighbor_compare_stored = Module["_pico_ipv6_neighbor_compare_stored"] = function() { + return Module["asm"]["_pico_ipv6_neighbor_compare_stored"].apply(null, arguments) +}; + +var _pico_ipv6_neighbor_from_sol_new = Module["_pico_ipv6_neighbor_from_sol_new"] = function() { + return Module["asm"]["_pico_ipv6_neighbor_from_sol_new"].apply(null, arguments) +}; + +var _pico_ipv6_neighbor_from_unsolicited = Module["_pico_ipv6_neighbor_from_unsolicited"] = function() { + return Module["asm"]["_pico_ipv6_neighbor_from_unsolicited"].apply(null, arguments) +}; + +var _pico_ipv6_neighbor_update = Module["_pico_ipv6_neighbor_update"] = function() { + return Module["asm"]["_pico_ipv6_neighbor_update"].apply(null, arguments) +}; + +var _pico_ipv6_pre_forward_checks = Module["_pico_ipv6_pre_forward_checks"] = function() { + return Module["asm"]["_pico_ipv6_pre_forward_checks"].apply(null, arguments) +}; + +var _pico_ipv6_prefix_configured = Module["_pico_ipv6_prefix_configured"] = function() { + return Module["asm"]["_pico_ipv6_prefix_configured"].apply(null, arguments) +}; + +var _pico_ipv6_process_destopt = Module["_pico_ipv6_process_destopt"] = function() { + return Module["asm"]["_pico_ipv6_process_destopt"].apply(null, arguments) +}; + +var _pico_ipv6_process_frag = Module["_pico_ipv6_process_frag"] = function() { + return Module["asm"]["_pico_ipv6_process_frag"].apply(null, arguments) +}; + +var _pico_ipv6_process_hopbyhop = Module["_pico_ipv6_process_hopbyhop"] = function() { + return Module["asm"]["_pico_ipv6_process_hopbyhop"].apply(null, arguments) +}; + +var _pico_ipv6_process_in = Module["_pico_ipv6_process_in"] = function() { + return Module["asm"]["_pico_ipv6_process_in"].apply(null, arguments) +}; + +var _pico_ipv6_process_mcast_in = Module["_pico_ipv6_process_mcast_in"] = function() { + return Module["asm"]["_pico_ipv6_process_mcast_in"].apply(null, arguments) +}; + +var _pico_ipv6_process_out = Module["_pico_ipv6_process_out"] = function() { + return Module["asm"]["_pico_ipv6_process_out"].apply(null, arguments) +}; + +var _pico_ipv6_process_routing = Module["_pico_ipv6_process_routing"] = function() { + return Module["asm"]["_pico_ipv6_process_routing"].apply(null, arguments) +}; + +var _pico_ipv6_route_add = Module["_pico_ipv6_route_add"] = function() { + return Module["asm"]["_pico_ipv6_route_add"].apply(null, arguments) +}; + +var _pico_ipv6_route_del = Module["_pico_ipv6_route_del"] = function() { + return Module["asm"]["_pico_ipv6_route_del"].apply(null, arguments) +}; + +var _pico_ipv6_route_find = Module["_pico_ipv6_route_find"] = function() { + return Module["asm"]["_pico_ipv6_route_find"].apply(null, arguments) +}; + +var _pico_ipv6_route_get_gateway = Module["_pico_ipv6_route_get_gateway"] = function() { + return Module["asm"]["_pico_ipv6_route_get_gateway"].apply(null, arguments) +}; + +var _pico_ipv6_router_down = Module["_pico_ipv6_router_down"] = function() { + return Module["asm"]["_pico_ipv6_router_down"].apply(null, arguments) +}; + +var _pico_ipv6_sitelocal_get = Module["_pico_ipv6_sitelocal_get"] = function() { + return Module["asm"]["_pico_ipv6_sitelocal_get"].apply(null, arguments) +}; + +var _pico_ipv6_source_dev_find = Module["_pico_ipv6_source_dev_find"] = function() { + return Module["asm"]["_pico_ipv6_source_dev_find"].apply(null, arguments) +}; + +var _pico_ipv6_source_find = Module["_pico_ipv6_source_find"] = function() { + return Module["asm"]["_pico_ipv6_source_find"].apply(null, arguments) +}; + +var _pico_ipv6_to_string = Module["_pico_ipv6_to_string"] = function() { + return Module["asm"]["_pico_ipv6_to_string"].apply(null, arguments) +}; + +var _pico_ipv6_unreachable = Module["_pico_ipv6_unreachable"] = function() { + return Module["asm"]["_pico_ipv6_unreachable"].apply(null, arguments) +}; + +var _pico_is_digit = Module["_pico_is_digit"] = function() { + return Module["asm"]["_pico_is_digit"].apply(null, arguments) +}; + +var _pico_is_hex = Module["_pico_is_hex"] = function() { + return Module["asm"]["_pico_is_hex"].apply(null, arguments) +}; + +var _pico_is_port_free = Module["_pico_is_port_free"] = function() { + return Module["asm"]["_pico_is_port_free"].apply(null, arguments) +}; + +var _pico_js_create = Module["_pico_js_create"] = function() { + return Module["asm"]["_pico_js_create"].apply(null, arguments) +}; + +var _pico_js_poll = Module["_pico_js_poll"] = function() { + return Module["asm"]["_pico_js_poll"].apply(null, arguments) +}; + +var _pico_js_send = Module["_pico_js_send"] = function() { + return Module["asm"]["_pico_js_send"].apply(null, arguments) +}; + +var _pico_mcast_filter_excl_excl = Module["_pico_mcast_filter_excl_excl"] = function() { + return Module["asm"]["_pico_mcast_filter_excl_excl"].apply(null, arguments) +}; + +var _pico_mcast_filter_excl_incl = Module["_pico_mcast_filter_excl_incl"] = function() { + return Module["asm"]["_pico_mcast_filter_excl_incl"].apply(null, arguments) +}; + +var _pico_mcast_filter_incl_excl = Module["_pico_mcast_filter_incl_excl"] = function() { + return Module["asm"]["_pico_mcast_filter_incl_excl"].apply(null, arguments) +}; + +var _pico_mcast_filter_incl_incl = Module["_pico_mcast_filter_incl_incl"] = function() { + return Module["asm"]["_pico_mcast_filter_incl_incl"].apply(null, arguments) +}; + +var _pico_mcast_generate_filter = Module["_pico_mcast_generate_filter"] = function() { + return Module["asm"]["_pico_mcast_generate_filter"].apply(null, arguments) +}; + +var _pico_mcast_src_filtering_cleanup = Module["_pico_mcast_src_filtering_cleanup"] = function() { + return Module["asm"]["_pico_mcast_src_filtering_cleanup"].apply(null, arguments) +}; + +var _pico_mcast_src_filtering_excl_excl = Module["_pico_mcast_src_filtering_excl_excl"] = function() { + return Module["asm"]["_pico_mcast_src_filtering_excl_excl"].apply(null, arguments) +}; + +var _pico_mcast_src_filtering_excl_inc = Module["_pico_mcast_src_filtering_excl_inc"] = function() { + return Module["asm"]["_pico_mcast_src_filtering_excl_inc"].apply(null, arguments) +}; + +var _pico_mcast_src_filtering_inc_excl = Module["_pico_mcast_src_filtering_inc_excl"] = function() { + return Module["asm"]["_pico_mcast_src_filtering_inc_excl"].apply(null, arguments) +}; + +var _pico_mcast_src_filtering_inc_inc = Module["_pico_mcast_src_filtering_inc_inc"] = function() { + return Module["asm"]["_pico_mcast_src_filtering_inc_inc"].apply(null, arguments) +}; + +var _pico_mld_analyse_packet = Module["_pico_mld_analyse_packet"] = function() { + return Module["asm"]["_pico_mld_analyse_packet"].apply(null, arguments) +}; + +var _pico_mld_check_hopbyhop = Module["_pico_mld_check_hopbyhop"] = function() { + return Module["asm"]["_pico_mld_check_hopbyhop"].apply(null, arguments) +}; + +var _pico_mld_checksum = Module["_pico_mld_checksum"] = function() { + return Module["asm"]["_pico_mld_checksum"].apply(null, arguments) +}; + +var _pico_mld_compatibility_mode = Module["_pico_mld_compatibility_mode"] = function() { + return Module["asm"]["_pico_mld_compatibility_mode"].apply(null, arguments) +}; + +var _pico_mld_delete_parameter = Module["_pico_mld_delete_parameter"] = function() { + return Module["asm"]["_pico_mld_delete_parameter"].apply(null, arguments) +}; + +var _pico_mld_fill_hopbyhop = Module["_pico_mld_fill_hopbyhop"] = function() { + return Module["asm"]["_pico_mld_fill_hopbyhop"].apply(null, arguments) +}; + +var _pico_mld_find_parameter = Module["_pico_mld_find_parameter"] = function() { + return Module["asm"]["_pico_mld_find_parameter"].apply(null, arguments) +}; + +var _pico_mld_find_timer = Module["_pico_mld_find_timer"] = function() { + return Module["asm"]["_pico_mld_find_timer"].apply(null, arguments) +}; + +var _pico_mld_generate_report = Module["_pico_mld_generate_report"] = function() { + return Module["asm"]["_pico_mld_generate_report"].apply(null, arguments) +}; + +var _pico_mld_is_checksum_valid = Module["_pico_mld_is_checksum_valid"] = function() { + return Module["asm"]["_pico_mld_is_checksum_valid"].apply(null, arguments) +}; + +var _pico_mld_process_event = Module["_pico_mld_process_event"] = function() { + return Module["asm"]["_pico_mld_process_event"].apply(null, arguments) +}; + +var _pico_mld_process_in = Module["_pico_mld_process_in"] = function() { + return Module["asm"]["_pico_mld_process_in"].apply(null, arguments) +}; + +var _pico_mld_report_expired = Module["_pico_mld_report_expired"] = function() { + return Module["asm"]["_pico_mld_report_expired"].apply(null, arguments) +}; + +var _pico_mld_send_done = Module["_pico_mld_send_done"] = function() { + return Module["asm"]["_pico_mld_send_done"].apply(null, arguments) +}; + +var _pico_mld_send_report = Module["_pico_mld_send_report"] = function() { + return Module["asm"]["_pico_mld_send_report"].apply(null, arguments) +}; + +var _pico_mld_state_change = Module["_pico_mld_state_change"] = function() { + return Module["asm"]["_pico_mld_state_change"].apply(null, arguments) +}; + +var _pico_mld_timer_expired = Module["_pico_mld_timer_expired"] = function() { + return Module["asm"]["_pico_mld_timer_expired"].apply(null, arguments) +}; + +var _pico_mld_timer_is_running = Module["_pico_mld_timer_is_running"] = function() { + return Module["asm"]["_pico_mld_timer_is_running"].apply(null, arguments) +}; + +var _pico_mld_timer_reset = Module["_pico_mld_timer_reset"] = function() { + return Module["asm"]["_pico_mld_timer_reset"].apply(null, arguments) +}; + +var _pico_mld_timer_start = Module["_pico_mld_timer_start"] = function() { + return Module["asm"]["_pico_mld_timer_start"].apply(null, arguments) +}; + +var _pico_mld_timer_stop = Module["_pico_mld_timer_stop"] = function() { + return Module["asm"]["_pico_mld_timer_stop"].apply(null, arguments) +}; + +var _pico_mld_v1querier_expired = Module["_pico_mld_v1querier_expired"] = function() { + return Module["asm"]["_pico_mld_v1querier_expired"].apply(null, arguments) +}; + +var _pico_mldv1_generate_report = Module["_pico_mldv1_generate_report"] = function() { + return Module["asm"]["_pico_mldv1_generate_report"].apply(null, arguments) +}; + +var _pico_mldv2_generate_filter = Module["_pico_mldv2_generate_filter"] = function() { + return Module["asm"]["_pico_mldv2_generate_filter"].apply(null, arguments) +}; + +var _pico_mldv2_generate_report = Module["_pico_mldv2_generate_report"] = function() { + return Module["asm"]["_pico_mldv2_generate_report"].apply(null, arguments) +}; + +var _pico_multicast_delete = Module["_pico_multicast_delete"] = function() { + return Module["asm"]["_pico_multicast_delete"].apply(null, arguments) +}; + +var _pico_nat_generate_tuple_trans = Module["_pico_nat_generate_tuple_trans"] = function() { + return Module["asm"]["_pico_nat_generate_tuple_trans"].apply(null, arguments) +}; + +var _pico_nd_add = Module["_pico_nd_add"] = function() { + return Module["asm"]["_pico_nd_add"].apply(null, arguments) +}; + +var _pico_nd_discover = Module["_pico_nd_discover"] = function() { + return Module["asm"]["_pico_nd_discover"].apply(null, arguments) +}; + +var _pico_nd_find_neighbor = Module["_pico_nd_find_neighbor"] = function() { + return Module["asm"]["_pico_nd_find_neighbor"].apply(null, arguments) +}; + +var _pico_nd_get = Module["_pico_nd_get"] = function() { + return Module["asm"]["_pico_nd_get"].apply(null, arguments) +}; + +var _pico_nd_get_neighbor = Module["_pico_nd_get_neighbor"] = function() { + return Module["asm"]["_pico_nd_get_neighbor"].apply(null, arguments) +}; + +var _pico_nd_neigh_adv_recv = Module["_pico_nd_neigh_adv_recv"] = function() { + return Module["asm"]["_pico_nd_neigh_adv_recv"].apply(null, arguments) +}; + +var _pico_nd_neigh_sol_recv = Module["_pico_nd_neigh_sol_recv"] = function() { + return Module["asm"]["_pico_nd_neigh_sol_recv"].apply(null, arguments) +}; + +var _pico_nd_new_expire_time = Module["_pico_nd_new_expire_time"] = function() { + return Module["asm"]["_pico_nd_new_expire_time"].apply(null, arguments) +}; + +var _pico_nd_redirect_recv = Module["_pico_nd_redirect_recv"] = function() { + return Module["asm"]["_pico_nd_redirect_recv"].apply(null, arguments) +}; + +var _pico_nd_router_adv_recv = Module["_pico_nd_router_adv_recv"] = function() { + return Module["asm"]["_pico_nd_router_adv_recv"].apply(null, arguments) +}; + +var _pico_nd_router_sol_recv = Module["_pico_nd_router_sol_recv"] = function() { + return Module["asm"]["_pico_nd_router_sol_recv"].apply(null, arguments) +}; + +var _pico_network_receive = Module["_pico_network_receive"] = function() { + return Module["asm"]["_pico_network_receive"].apply(null, arguments) +}; + +var _pico_network_send = Module["_pico_network_send"] = function() { + return Module["asm"]["_pico_network_send"].apply(null, arguments) +}; + +var _pico_notify_dest_unreachable = Module["_pico_notify_dest_unreachable"] = function() { + return Module["asm"]["_pico_notify_dest_unreachable"].apply(null, arguments) +}; + +var _pico_notify_frag_expired = Module["_pico_notify_frag_expired"] = function() { + return Module["asm"]["_pico_notify_frag_expired"].apply(null, arguments) +}; + +var _pico_notify_pkt_too_big = Module["_pico_notify_pkt_too_big"] = function() { + return Module["asm"]["_pico_notify_pkt_too_big"].apply(null, arguments) +}; + +var _pico_notify_proto_unreachable = Module["_pico_notify_proto_unreachable"] = function() { + return Module["asm"]["_pico_notify_proto_unreachable"].apply(null, arguments) +}; + +var _pico_notify_socket_unreachable = Module["_pico_notify_socket_unreachable"] = function() { + return Module["asm"]["_pico_notify_socket_unreachable"].apply(null, arguments) +}; + +var _pico_notify_ttl_expired = Module["_pico_notify_ttl_expired"] = function() { + return Module["asm"]["_pico_notify_ttl_expired"].apply(null, arguments) +}; + +var _pico_paws = Module["_pico_paws"] = function() { + return Module["asm"]["_pico_paws"].apply(null, arguments) +}; + +var _pico_port_in_use_by_nat = Module["_pico_port_in_use_by_nat"] = function() { + return Module["asm"]["_pico_port_in_use_by_nat"].apply(null, arguments) +}; + +var _pico_port_in_use_ipv4 = Module["_pico_port_in_use_ipv4"] = function() { + return Module["asm"]["_pico_port_in_use_ipv4"].apply(null, arguments) +}; + +var _pico_port_in_use_ipv6 = Module["_pico_port_in_use_ipv6"] = function() { + return Module["asm"]["_pico_port_in_use_ipv6"].apply(null, arguments) +}; + +var _pico_port_in_use_with_this_ipv4_address = Module["_pico_port_in_use_with_this_ipv4_address"] = function() { + return Module["asm"]["_pico_port_in_use_with_this_ipv4_address"].apply(null, arguments) +}; + +var _pico_port_in_use_with_this_ipv6_address = Module["_pico_port_in_use_with_this_ipv6_address"] = function() { + return Module["asm"]["_pico_port_in_use_with_this_ipv6_address"].apply(null, arguments) +}; + +var _pico_proto_cmp = Module["_pico_proto_cmp"] = function() { + return Module["asm"]["_pico_proto_cmp"].apply(null, arguments) +}; + +var _pico_protocol_datalink_loop = Module["_pico_protocol_datalink_loop"] = function() { + return Module["asm"]["_pico_protocol_datalink_loop"].apply(null, arguments) +}; + +var _pico_protocol_generic_loop = Module["_pico_protocol_generic_loop"] = function() { + return Module["asm"]["_pico_protocol_generic_loop"].apply(null, arguments) +}; + +var _pico_protocol_init = Module["_pico_protocol_init"] = function() { + return Module["asm"]["_pico_protocol_init"].apply(null, arguments) +}; + +var _pico_protocol_network_loop = Module["_pico_protocol_network_loop"] = function() { + return Module["asm"]["_pico_protocol_network_loop"].apply(null, arguments) +}; + +var _pico_protocol_socket_loop = Module["_pico_protocol_socket_loop"] = function() { + return Module["asm"]["_pico_protocol_socket_loop"].apply(null, arguments) +}; + +var _pico_protocol_transport_loop = Module["_pico_protocol_transport_loop"] = function() { + return Module["asm"]["_pico_protocol_transport_loop"].apply(null, arguments) +}; + +var _pico_queue_peek = Module["_pico_queue_peek"] = function() { + return Module["asm"]["_pico_queue_peek"].apply(null, arguments) +}; + +var _pico_queue_peek_167 = Module["_pico_queue_peek_167"] = function() { + return Module["asm"]["_pico_queue_peek_167"].apply(null, arguments) +}; + +var _pico_rand = Module["_pico_rand"] = function() { + return Module["asm"]["_pico_rand"].apply(null, arguments) +}; + +var _pico_rand_feed = Module["_pico_rand_feed"] = function() { + return Module["asm"]["_pico_rand_feed"].apply(null, arguments) +}; + +var _pico_sendto_dev = Module["_pico_sendto_dev"] = function() { + return Module["asm"]["_pico_sendto_dev"].apply(null, arguments) +}; + +var _pico_seq_compare = Module["_pico_seq_compare"] = function() { + return Module["asm"]["_pico_seq_compare"].apply(null, arguments) +}; + +var _pico_socket_accept = Module["_pico_socket_accept"] = function() { + return Module["asm"]["_pico_socket_accept"].apply(null, arguments) +}; + +var _pico_socket_adapt_mss_to_proto = Module["_pico_socket_adapt_mss_to_proto"] = function() { + return Module["asm"]["_pico_socket_adapt_mss_to_proto"].apply(null, arguments) +}; + +var _pico_socket_add = Module["_pico_socket_add"] = function() { + return Module["asm"]["_pico_socket_add"].apply(null, arguments) +}; + +var _pico_socket_aggregate_mcastfilters = Module["_pico_socket_aggregate_mcastfilters"] = function() { + return Module["asm"]["_pico_socket_aggregate_mcastfilters"].apply(null, arguments) +}; + +var _pico_socket_alter_state = Module["_pico_socket_alter_state"] = function() { + return Module["asm"]["_pico_socket_alter_state"].apply(null, arguments) +}; + +var _pico_socket_bind = Module["_pico_socket_bind"] = function() { + return Module["asm"]["_pico_socket_bind"].apply(null, arguments) +}; + +var _pico_socket_check_empty_sockport = Module["_pico_socket_check_empty_sockport"] = function() { + return Module["asm"]["_pico_socket_check_empty_sockport"].apply(null, arguments) +}; + +var _pico_socket_clone = Module["_pico_socket_clone"] = function() { + return Module["asm"]["_pico_socket_clone"].apply(null, arguments) +}; + +var _pico_socket_clone_assign_address = Module["_pico_socket_clone_assign_address"] = function() { + return Module["asm"]["_pico_socket_clone_assign_address"].apply(null, arguments) +}; + +var _pico_socket_close = Module["_pico_socket_close"] = function() { + return Module["asm"]["_pico_socket_close"].apply(null, arguments) +}; + +var _pico_socket_connect = Module["_pico_socket_connect"] = function() { + return Module["asm"]["_pico_socket_connect"].apply(null, arguments) +}; + +var _pico_socket_del = Module["_pico_socket_del"] = function() { + return Module["asm"]["_pico_socket_del"].apply(null, arguments) +}; + +var _pico_socket_deliver = Module["_pico_socket_deliver"] = function() { + return Module["asm"]["_pico_socket_deliver"].apply(null, arguments) +}; + +var _pico_socket_final_xmit = Module["_pico_socket_final_xmit"] = function() { + return Module["asm"]["_pico_socket_final_xmit"].apply(null, arguments) +}; + +var _pico_socket_frame_alloc = Module["_pico_socket_frame_alloc"] = function() { + return Module["asm"]["_pico_socket_frame_alloc"].apply(null, arguments) +}; + +var _pico_socket_get_mss = Module["_pico_socket_get_mss"] = function() { + return Module["asm"]["_pico_socket_get_mss"].apply(null, arguments) +}; + +var _pico_socket_high_port = Module["_pico_socket_high_port"] = function() { + return Module["asm"]["_pico_socket_high_port"].apply(null, arguments) +}; + +var _pico_socket_listen = Module["_pico_socket_listen"] = function() { + return Module["asm"]["_pico_socket_listen"].apply(null, arguments) +}; + +var _pico_socket_mcast_filter = Module["_pico_socket_mcast_filter"] = function() { + return Module["asm"]["_pico_socket_mcast_filter"].apply(null, arguments) +}; + +var _pico_socket_mcast_filter_exclude = Module["_pico_socket_mcast_filter_exclude"] = function() { + return Module["asm"]["_pico_socket_mcast_filter_exclude"].apply(null, arguments) +}; + +var _pico_socket_mcast_filter_include = Module["_pico_socket_mcast_filter_include"] = function() { + return Module["asm"]["_pico_socket_mcast_filter_include"].apply(null, arguments) +}; + +var _pico_socket_mcast_filter_link_get = Module["_pico_socket_mcast_filter_link_get"] = function() { + return Module["asm"]["_pico_socket_mcast_filter_link_get"].apply(null, arguments) +}; + +var _pico_socket_mcast_source_filtering = Module["_pico_socket_mcast_source_filtering"] = function() { + return Module["asm"]["_pico_socket_mcast_source_filtering"].apply(null, arguments) +}; + +var _pico_socket_open = Module["_pico_socket_open"] = function() { + return Module["asm"]["_pico_socket_open"].apply(null, arguments) +}; + +var _pico_socket_read = Module["_pico_socket_read"] = function() { + return Module["asm"]["_pico_socket_read"].apply(null, arguments) +}; + +var _pico_socket_recvfrom = Module["_pico_socket_recvfrom"] = function() { + return Module["asm"]["_pico_socket_recvfrom"].apply(null, arguments) +}; + +var _pico_socket_recvfrom_extended = Module["_pico_socket_recvfrom_extended"] = function() { + return Module["asm"]["_pico_socket_recvfrom_extended"].apply(null, arguments) +}; + +var _pico_socket_send = Module["_pico_socket_send"] = function() { + return Module["asm"]["_pico_socket_send"].apply(null, arguments) +}; + +var _pico_socket_sendto = Module["_pico_socket_sendto"] = function() { + return Module["asm"]["_pico_socket_sendto"].apply(null, arguments) +}; + +var _pico_socket_sendto_dest_check = Module["_pico_socket_sendto_dest_check"] = function() { + return Module["asm"]["_pico_socket_sendto_dest_check"].apply(null, arguments) +}; + +var _pico_socket_sendto_destination = Module["_pico_socket_sendto_destination"] = function() { + return Module["asm"]["_pico_socket_sendto_destination"].apply(null, arguments) +}; + +var _pico_socket_sendto_destination_ipv4 = Module["_pico_socket_sendto_destination_ipv4"] = function() { + return Module["asm"]["_pico_socket_sendto_destination_ipv4"].apply(null, arguments) +}; + +var _pico_socket_sendto_destination_ipv6 = Module["_pico_socket_sendto_destination_ipv6"] = function() { + return Module["asm"]["_pico_socket_sendto_destination_ipv6"].apply(null, arguments) +}; + +var _pico_socket_sendto_extended = Module["_pico_socket_sendto_extended"] = function() { + return Module["asm"]["_pico_socket_sendto_extended"].apply(null, arguments) +}; + +var _pico_socket_sendto_get_ip4_src = Module["_pico_socket_sendto_get_ip4_src"] = function() { + return Module["asm"]["_pico_socket_sendto_get_ip4_src"].apply(null, arguments) +}; + +var _pico_socket_sendto_get_ip6_src = Module["_pico_socket_sendto_get_ip6_src"] = function() { + return Module["asm"]["_pico_socket_sendto_get_ip6_src"].apply(null, arguments) +}; + +var _pico_socket_sendto_get_src = Module["_pico_socket_sendto_get_src"] = function() { + return Module["asm"]["_pico_socket_sendto_get_src"].apply(null, arguments) +}; + +var _pico_socket_sendto_initial_checks = Module["_pico_socket_sendto_initial_checks"] = function() { + return Module["asm"]["_pico_socket_sendto_initial_checks"].apply(null, arguments) +}; + +var _pico_socket_sendto_set_dport = Module["_pico_socket_sendto_set_dport"] = function() { + return Module["asm"]["_pico_socket_sendto_set_dport"].apply(null, arguments) +}; + +var _pico_socket_sendto_set_localport = Module["_pico_socket_sendto_set_localport"] = function() { + return Module["asm"]["_pico_socket_sendto_set_localport"].apply(null, arguments) +}; + +var _pico_socket_sendto_transport_offset = Module["_pico_socket_sendto_transport_offset"] = function() { + return Module["asm"]["_pico_socket_sendto_transport_offset"].apply(null, arguments) +}; + +var _pico_socket_set_family = Module["_pico_socket_set_family"] = function() { + return Module["asm"]["_pico_socket_set_family"].apply(null, arguments) +}; + +var _pico_socket_set_info = Module["_pico_socket_set_info"] = function() { + return Module["asm"]["_pico_socket_set_info"].apply(null, arguments) +}; + +var _pico_socket_shutdown = Module["_pico_socket_shutdown"] = function() { + return Module["asm"]["_pico_socket_shutdown"].apply(null, arguments) +}; + +var _pico_socket_tcp_cleanup = Module["_pico_socket_tcp_cleanup"] = function() { + return Module["asm"]["_pico_socket_tcp_cleanup"].apply(null, arguments) +}; + +var _pico_socket_tcp_delete = Module["_pico_socket_tcp_delete"] = function() { + return Module["asm"]["_pico_socket_tcp_delete"].apply(null, arguments) +}; + +var _pico_socket_tcp_deliver = Module["_pico_socket_tcp_deliver"] = function() { + return Module["asm"]["_pico_socket_tcp_deliver"].apply(null, arguments) +}; + +var _pico_socket_tcp_open = Module["_pico_socket_tcp_open"] = function() { + return Module["asm"]["_pico_socket_tcp_open"].apply(null, arguments) +}; + +var _pico_socket_tcp_read = Module["_pico_socket_tcp_read"] = function() { + return Module["asm"]["_pico_socket_tcp_read"].apply(null, arguments) +}; + +var _pico_socket_transport_deliver = Module["_pico_socket_transport_deliver"] = function() { + return Module["asm"]["_pico_socket_transport_deliver"].apply(null, arguments) +}; + +var _pico_socket_transport_open = Module["_pico_socket_transport_open"] = function() { + return Module["asm"]["_pico_socket_transport_open"].apply(null, arguments) +}; + +var _pico_socket_transport_read = Module["_pico_socket_transport_read"] = function() { + return Module["asm"]["_pico_socket_transport_read"].apply(null, arguments) +}; + +var _pico_socket_udp_deliver = Module["_pico_socket_udp_deliver"] = function() { + return Module["asm"]["_pico_socket_udp_deliver"].apply(null, arguments) +}; + +var _pico_socket_udp_deliver_ipv4 = Module["_pico_socket_udp_deliver_ipv4"] = function() { + return Module["asm"]["_pico_socket_udp_deliver_ipv4"].apply(null, arguments) +}; + +var _pico_socket_udp_deliver_ipv4_mcast = Module["_pico_socket_udp_deliver_ipv4_mcast"] = function() { + return Module["asm"]["_pico_socket_udp_deliver_ipv4_mcast"].apply(null, arguments) +}; + +var _pico_socket_udp_deliver_ipv4_mcast_initial_checks = Module["_pico_socket_udp_deliver_ipv4_mcast_initial_checks"] = function() { + return Module["asm"]["_pico_socket_udp_deliver_ipv4_mcast_initial_checks"].apply(null, arguments) +}; + +var _pico_socket_udp_deliver_ipv4_unicast = Module["_pico_socket_udp_deliver_ipv4_unicast"] = function() { + return Module["asm"]["_pico_socket_udp_deliver_ipv4_unicast"].apply(null, arguments) +}; + +var _pico_socket_udp_deliver_ipv6 = Module["_pico_socket_udp_deliver_ipv6"] = function() { + return Module["asm"]["_pico_socket_udp_deliver_ipv6"].apply(null, arguments) +}; + +var _pico_socket_udp_deliver_ipv6_mcast = Module["_pico_socket_udp_deliver_ipv6_mcast"] = function() { + return Module["asm"]["_pico_socket_udp_deliver_ipv6_mcast"].apply(null, arguments) +}; + +var _pico_socket_udp_open = Module["_pico_socket_udp_open"] = function() { + return Module["asm"]["_pico_socket_udp_open"].apply(null, arguments) +}; + +var _pico_socket_update_tcp_state = Module["_pico_socket_update_tcp_state"] = function() { + return Module["asm"]["_pico_socket_update_tcp_state"].apply(null, arguments) +}; + +var _pico_socket_write = Module["_pico_socket_write"] = function() { + return Module["asm"]["_pico_socket_write"].apply(null, arguments) +}; + +var _pico_socket_write_attempt = Module["_pico_socket_write_attempt"] = function() { + return Module["asm"]["_pico_socket_write_attempt"].apply(null, arguments) +}; + +var _pico_socket_write_check_state = Module["_pico_socket_write_check_state"] = function() { + return Module["asm"]["_pico_socket_write_check_state"].apply(null, arguments) +}; + +var _pico_socket_xmit = Module["_pico_socket_xmit"] = function() { + return Module["asm"]["_pico_socket_xmit"].apply(null, arguments) +}; + +var _pico_socket_xmit_avail_space = Module["_pico_socket_xmit_avail_space"] = function() { + return Module["asm"]["_pico_socket_xmit_avail_space"].apply(null, arguments) +}; + +var _pico_socket_xmit_first_fragment_setup = Module["_pico_socket_xmit_first_fragment_setup"] = function() { + return Module["asm"]["_pico_socket_xmit_first_fragment_setup"].apply(null, arguments) +}; + +var _pico_socket_xmit_fragments = Module["_pico_socket_xmit_fragments"] = function() { + return Module["asm"]["_pico_socket_xmit_fragments"].apply(null, arguments) +}; + +var _pico_socket_xmit_next_fragment_setup = Module["_pico_socket_xmit_next_fragment_setup"] = function() { + return Module["asm"]["_pico_socket_xmit_next_fragment_setup"].apply(null, arguments) +}; + +var _pico_socket_xmit_one = Module["_pico_socket_xmit_one"] = function() { + return Module["asm"]["_pico_socket_xmit_one"].apply(null, arguments) +}; + +var _pico_sockets_loop = Module["_pico_sockets_loop"] = function() { + return Module["asm"]["_pico_sockets_loop"].apply(null, arguments) +}; + +var _pico_sockets_loop_tcp = Module["_pico_sockets_loop_tcp"] = function() { + return Module["asm"]["_pico_sockets_loop_tcp"].apply(null, arguments) +}; + +var _pico_sockets_loop_udp = Module["_pico_sockets_loop_udp"] = function() { + return Module["asm"]["_pico_sockets_loop_udp"].apply(null, arguments) +}; + +var _pico_source_is_local = Module["_pico_source_is_local"] = function() { + return Module["asm"]["_pico_source_is_local"].apply(null, arguments) +}; + +var _pico_stack_init = Module["_pico_stack_init"] = function() { + return Module["asm"]["_pico_stack_init"].apply(null, arguments) +}; + +var _pico_stack_recv = Module["_pico_stack_recv"] = function() { + return Module["asm"]["_pico_stack_recv"].apply(null, arguments) +}; + +var _pico_stack_recv_new_frame = Module["_pico_stack_recv_new_frame"] = function() { + return Module["asm"]["_pico_stack_recv_new_frame"].apply(null, arguments) +}; + +var _pico_stack_recv_zerocopy = Module["_pico_stack_recv_zerocopy"] = function() { + return Module["asm"]["_pico_stack_recv_zerocopy"].apply(null, arguments) +}; + +var _pico_stack_tick = Module["_pico_stack_tick"] = function() { + return Module["asm"]["_pico_stack_tick"].apply(null, arguments) +}; + +var _pico_store_network_origin = Module["_pico_store_network_origin"] = function() { + return Module["asm"]["_pico_store_network_origin"].apply(null, arguments) +}; + +var _pico_string_check_null_args = Module["_pico_string_check_null_args"] = function() { + return Module["asm"]["_pico_string_check_null_args"].apply(null, arguments) +}; + +var _pico_string_to_ipv4 = Module["_pico_string_to_ipv4"] = function() { + return Module["asm"]["_pico_string_to_ipv4"].apply(null, arguments) +}; + +var _pico_string_to_ipv6 = Module["_pico_string_to_ipv6"] = function() { + return Module["asm"]["_pico_string_to_ipv6"].apply(null, arguments) +}; + +var _pico_tcp_check_listen_close = Module["_pico_tcp_check_listen_close"] = function() { + return Module["asm"]["_pico_tcp_check_listen_close"].apply(null, arguments) +}; + +var _pico_tcp_checksum = Module["_pico_tcp_checksum"] = function() { + return Module["asm"]["_pico_tcp_checksum"].apply(null, arguments) +}; + +var _pico_tcp_checksum_ipv4 = Module["_pico_tcp_checksum_ipv4"] = function() { + return Module["asm"]["_pico_tcp_checksum_ipv4"].apply(null, arguments) +}; + +var _pico_tcp_checksum_ipv6 = Module["_pico_tcp_checksum_ipv6"] = function() { + return Module["asm"]["_pico_tcp_checksum_ipv6"].apply(null, arguments) +}; + +var _pico_tcp_cleanup_queues = Module["_pico_tcp_cleanup_queues"] = function() { + return Module["asm"]["_pico_tcp_cleanup_queues"].apply(null, arguments) +}; + +var _pico_tcp_flags_update = Module["_pico_tcp_flags_update"] = function() { + return Module["asm"]["_pico_tcp_flags_update"].apply(null, arguments) +}; + +var _pico_tcp_get_socket_mss = Module["_pico_tcp_get_socket_mss"] = function() { + return Module["asm"]["_pico_tcp_get_socket_mss"].apply(null, arguments) +}; + +var _pico_tcp_initconn = Module["_pico_tcp_initconn"] = function() { + return Module["asm"]["_pico_tcp_initconn"].apply(null, arguments) +}; + +var _pico_tcp_input = Module["_pico_tcp_input"] = function() { + return Module["asm"]["_pico_tcp_input"].apply(null, arguments) +}; + +var _pico_tcp_keepalive = Module["_pico_tcp_keepalive"] = function() { + return Module["asm"]["_pico_tcp_keepalive"].apply(null, arguments) +}; + +var _pico_tcp_notify_closing = Module["_pico_tcp_notify_closing"] = function() { + return Module["asm"]["_pico_tcp_notify_closing"].apply(null, arguments) +}; + +var _pico_tcp_open = Module["_pico_tcp_open"] = function() { + return Module["asm"]["_pico_tcp_open"].apply(null, arguments) +}; + +var _pico_tcp_output = Module["_pico_tcp_output"] = function() { + return Module["asm"]["_pico_tcp_output"].apply(null, arguments) +}; + +var _pico_tcp_overhead = Module["_pico_tcp_overhead"] = function() { + return Module["asm"]["_pico_tcp_overhead"].apply(null, arguments) +}; + +var _pico_tcp_process_out = Module["_pico_tcp_process_out"] = function() { + return Module["asm"]["_pico_tcp_process_out"].apply(null, arguments) +}; + +var _pico_tcp_push = Module["_pico_tcp_push"] = function() { + return Module["asm"]["_pico_tcp_push"].apply(null, arguments) +}; + +var _pico_tcp_push_nagle_enqueue = Module["_pico_tcp_push_nagle_enqueue"] = function() { + return Module["asm"]["_pico_tcp_push_nagle_enqueue"].apply(null, arguments) +}; + +var _pico_tcp_push_nagle_hold = Module["_pico_tcp_push_nagle_hold"] = function() { + return Module["asm"]["_pico_tcp_push_nagle_hold"].apply(null, arguments) +}; + +var _pico_tcp_push_nagle_on = Module["_pico_tcp_push_nagle_on"] = function() { + return Module["asm"]["_pico_tcp_push_nagle_on"].apply(null, arguments) +}; + +var _pico_tcp_queue_in_is_empty = Module["_pico_tcp_queue_in_is_empty"] = function() { + return Module["asm"]["_pico_tcp_queue_in_is_empty"].apply(null, arguments) +}; + +var _pico_tcp_read = Module["_pico_tcp_read"] = function() { + return Module["asm"]["_pico_tcp_read"].apply(null, arguments) +}; + +var _pico_tcp_reply_rst = Module["_pico_tcp_reply_rst"] = function() { + return Module["asm"]["_pico_tcp_reply_rst"].apply(null, arguments) +}; + +var _pico_timer_add = Module["_pico_timer_add"] = function() { + return Module["asm"]["_pico_timer_add"].apply(null, arguments) +}; + +var _pico_timer_cancel = Module["_pico_timer_cancel"] = function() { + return Module["asm"]["_pico_timer_cancel"].apply(null, arguments) +}; + +var _pico_timer_create = Module["_pico_timer_create"] = function() { + return Module["asm"]["_pico_timer_create"].apply(null, arguments) +}; + +var _pico_timer_ref_add = Module["_pico_timer_ref_add"] = function() { + return Module["asm"]["_pico_timer_ref_add"].apply(null, arguments) +}; + +var _pico_transport_crc_check = Module["_pico_transport_crc_check"] = function() { + return Module["asm"]["_pico_transport_crc_check"].apply(null, arguments) +}; + +var _pico_transport_error = Module["_pico_transport_error"] = function() { + return Module["asm"]["_pico_transport_error"].apply(null, arguments) +}; + +var _pico_transport_error_set_picoerr = Module["_pico_transport_error_set_picoerr"] = function() { + return Module["asm"]["_pico_transport_error_set_picoerr"].apply(null, arguments) +}; + +var _pico_transport_process_in = Module["_pico_transport_process_in"] = function() { + return Module["asm"]["_pico_transport_process_in"].apply(null, arguments) +}; + +var _pico_transport_receive = Module["_pico_transport_receive"] = function() { + return Module["asm"]["_pico_transport_receive"].apply(null, arguments) +}; + +var _pico_tree_delete = Module["_pico_tree_delete"] = function() { + return Module["asm"]["_pico_tree_delete"].apply(null, arguments) +}; + +var _pico_tree_delete_check_switch = Module["_pico_tree_delete_check_switch"] = function() { + return Module["asm"]["_pico_tree_delete_check_switch"].apply(null, arguments) +}; + +var _pico_tree_delete_implementation = Module["_pico_tree_delete_implementation"] = function() { + return Module["asm"]["_pico_tree_delete_implementation"].apply(null, arguments) +}; + +var _pico_tree_delete_node = Module["_pico_tree_delete_node"] = function() { + return Module["asm"]["_pico_tree_delete_node"].apply(null, arguments) +}; + +var _pico_tree_empty = Module["_pico_tree_empty"] = function() { + return Module["asm"]["_pico_tree_empty"].apply(null, arguments) +}; + +var _pico_tree_findKey = Module["_pico_tree_findKey"] = function() { + return Module["asm"]["_pico_tree_findKey"].apply(null, arguments) +}; + +var _pico_tree_findNode = Module["_pico_tree_findNode"] = function() { + return Module["asm"]["_pico_tree_findNode"].apply(null, arguments) +}; + +var _pico_tree_first = Module["_pico_tree_first"] = function() { + return Module["asm"]["_pico_tree_first"].apply(null, arguments) +}; + +var _pico_tree_firstNode = Module["_pico_tree_firstNode"] = function() { + return Module["asm"]["_pico_tree_firstNode"].apply(null, arguments) +}; + +var _pico_tree_insert = Module["_pico_tree_insert"] = function() { + return Module["asm"]["_pico_tree_insert"].apply(null, arguments) +}; + +var _pico_tree_insert_implementation = Module["_pico_tree_insert_implementation"] = function() { + return Module["asm"]["_pico_tree_insert_implementation"].apply(null, arguments) +}; + +var _pico_tree_insert_node = Module["_pico_tree_insert_node"] = function() { + return Module["asm"]["_pico_tree_insert_node"].apply(null, arguments) +}; + +var _pico_tree_lastNode = Module["_pico_tree_lastNode"] = function() { + return Module["asm"]["_pico_tree_lastNode"].apply(null, arguments) +}; + +var _pico_tree_next = Module["_pico_tree_next"] = function() { + return Module["asm"]["_pico_tree_next"].apply(null, arguments) +}; + +var _pico_tree_prev = Module["_pico_tree_prev"] = function() { + return Module["asm"]["_pico_tree_prev"].apply(null, arguments) +}; + +var _pico_udp_checksum_ipv4 = Module["_pico_udp_checksum_ipv4"] = function() { + return Module["asm"]["_pico_udp_checksum_ipv4"].apply(null, arguments) +}; + +var _pico_udp_checksum_ipv6 = Module["_pico_udp_checksum_ipv6"] = function() { + return Module["asm"]["_pico_udp_checksum_ipv6"].apply(null, arguments) +}; + +var _pico_udp_get_mc_ttl = Module["_pico_udp_get_mc_ttl"] = function() { + return Module["asm"]["_pico_udp_get_mc_ttl"].apply(null, arguments) +}; + +var _pico_udp_get_msginfo = Module["_pico_udp_get_msginfo"] = function() { + return Module["asm"]["_pico_udp_get_msginfo"].apply(null, arguments) +}; + +var _pico_udp_open = Module["_pico_udp_open"] = function() { + return Module["asm"]["_pico_udp_open"].apply(null, arguments) +}; + +var _pico_udp_process_out = Module["_pico_udp_process_out"] = function() { + return Module["asm"]["_pico_udp_process_out"].apply(null, arguments) +}; + +var _pico_udp_push = Module["_pico_udp_push"] = function() { + return Module["asm"]["_pico_udp_push"].apply(null, arguments) +}; + +var _pico_udp_recv = Module["_pico_udp_recv"] = function() { + return Module["asm"]["_pico_udp_recv"].apply(null, arguments) +}; + +var _pico_xmit_frame_set_nofrag = Module["_pico_xmit_frame_set_nofrag"] = function() { + return Module["asm"]["_pico_xmit_frame_set_nofrag"].apply(null, arguments) +}; + +var _ping_recv_reply = Module["_ping_recv_reply"] = function() { + return Module["asm"]["_ping_recv_reply"].apply(null, arguments) +}; + +var _ping_timeout = Module["_ping_timeout"] = function() { + return Module["asm"]["_ping_timeout"].apply(null, arguments) +}; + +var _pop_arg = Module["_pop_arg"] = function() { + return Module["asm"]["_pop_arg"].apply(null, arguments) +}; + +var _pop_arg_long_double = Module["_pop_arg_long_double"] = function() { + return Module["asm"]["_pop_arg_long_double"].apply(null, arguments) +}; + +var _printf = Module["_printf"] = function() { + return Module["asm"]["_printf"].apply(null, arguments) +}; + +var _printf_core = Module["_printf_core"] = function() { + return Module["asm"]["_printf_core"].apply(null, arguments) +}; + +var _proto_layer_rr_reset = Module["_proto_layer_rr_reset"] = function() { + return Module["asm"]["_proto_layer_rr_reset"].apply(null, arguments) +}; + +var _proto_loop = Module["_proto_loop"] = function() { + return Module["asm"]["_proto_loop"].apply(null, arguments) +}; + +var _proto_loop_in = Module["_proto_loop_in"] = function() { + return Module["asm"]["_proto_loop_in"].apply(null, arguments) +}; + +var _proto_loop_out = Module["_proto_loop_out"] = function() { + return Module["asm"]["_proto_loop_out"].apply(null, arguments) +}; + +var _pthread_self = Module["_pthread_self"] = function() { + return Module["asm"]["_pthread_self"].apply(null, arguments) +}; + +var _puts = Module["_puts"] = function() { + return Module["asm"]["_puts"].apply(null, arguments) +}; + +var _radv_process = Module["_radv_process"] = function() { + return Module["asm"]["_radv_process"].apply(null, arguments) +}; + +var _rebind = Module["_rebind"] = function() { + return Module["asm"]["_rebind"].apply(null, arguments) +}; + +var _recv_ack = Module["_recv_ack"] = function() { + return Module["asm"]["_recv_ack"].apply(null, arguments) +}; + +var _recv_offer = Module["_recv_offer"] = function() { + return Module["asm"]["_recv_offer"].apply(null, arguments) +}; + +var _release_all_until = Module["_release_all_until"] = function() { + return Module["asm"]["_release_all_until"].apply(null, arguments) +}; + +var _release_until = Module["_release_until"] = function() { + return Module["asm"]["_release_until"].apply(null, arguments) +}; + +var _renew = Module["_renew"] = function() { + return Module["asm"]["_renew"].apply(null, arguments) +}; + +var _reset = Module["_reset"] = function() { + return Module["asm"]["_reset"].apply(null, arguments) +}; + +var _retransmit = Module["_retransmit"] = function() { + return Module["asm"]["_retransmit"].apply(null, arguments) +}; + +var _rotateToLeft = Module["_rotateToLeft"] = function() { + return Module["asm"]["_rotateToLeft"].apply(null, arguments) +}; + +var _rotateToRight = Module["_rotateToRight"] = function() { + return Module["asm"]["_rotateToRight"].apply(null, arguments) +}; + +var _roundrobin_end = Module["_roundrobin_end"] = function() { + return Module["asm"]["_roundrobin_end"].apply(null, arguments) +}; + +var _roundrobin_init = Module["_roundrobin_init"] = function() { + return Module["asm"]["_roundrobin_init"].apply(null, arguments) +}; + +var _route_find = Module["_route_find"] = function() { + return Module["asm"]["_route_find"].apply(null, arguments) +}; + +var _router_adv_validity_checks = Module["_router_adv_validity_checks"] = function() { + return Module["asm"]["_router_adv_validity_checks"].apply(null, arguments) +}; + +var _rtimrtct = Module["_rtimrtct"] = function() { + return Module["asm"]["_rtimrtct"].apply(null, arguments) +}; + +var _rto_set = Module["_rto_set"] = function() { + return Module["asm"]["_rto_set"].apply(null, arguments) +}; + +var _sbrk = Module["_sbrk"] = function() { + return Module["asm"]["_sbrk"].apply(null, arguments) +}; + +var _segment_compare = Module["_segment_compare"] = function() { + return Module["asm"]["_segment_compare"].apply(null, arguments) +}; + +var _segment_from_frame = Module["_segment_from_frame"] = function() { + return Module["asm"]["_segment_from_frame"].apply(null, arguments) +}; + +var _send_ping = Module["_send_ping"] = function() { + return Module["asm"]["_send_ping"].apply(null, arguments) +}; + +var _short_be = Module["_short_be"] = function() { + return Module["asm"]["_short_be"].apply(null, arguments) +}; + +var _short_be_1 = Module["_short_be_1"] = function() { + return Module["asm"]["_short_be_1"].apply(null, arguments) +}; + +var _short_be_112 = Module["_short_be_112"] = function() { + return Module["asm"]["_short_be_112"].apply(null, arguments) +}; + +var _short_be_140 = Module["_short_be_140"] = function() { + return Module["asm"]["_short_be_140"].apply(null, arguments) +}; + +var _short_be_143 = Module["_short_be_143"] = function() { + return Module["asm"]["_short_be_143"].apply(null, arguments) +}; + +var _short_be_150 = Module["_short_be_150"] = function() { + return Module["asm"]["_short_be_150"].apply(null, arguments) +}; + +var _short_be_156 = Module["_short_be_156"] = function() { + return Module["asm"]["_short_be_156"].apply(null, arguments) +}; + +var _short_be_178 = Module["_short_be_178"] = function() { + return Module["asm"]["_short_be_178"].apply(null, arguments) +}; + +var _short_be_209 = Module["_short_be_209"] = function() { + return Module["asm"]["_short_be_209"].apply(null, arguments) +}; + +var _short_be_309 = Module["_short_be_309"] = function() { + return Module["asm"]["_short_be_309"].apply(null, arguments) +}; + +var _short_be_33 = Module["_short_be_33"] = function() { + return Module["asm"]["_short_be_33"].apply(null, arguments) +}; + +var _short_be_336 = Module["_short_be_336"] = function() { + return Module["asm"]["_short_be_336"].apply(null, arguments) +}; + +var _short_be_36 = Module["_short_be_36"] = function() { + return Module["asm"]["_short_be_36"].apply(null, arguments) +}; + +var _short_be_367 = Module["_short_be_367"] = function() { + return Module["asm"]["_short_be_367"].apply(null, arguments) +}; + +var _short_be_373 = Module["_short_be_373"] = function() { + return Module["asm"]["_short_be_373"].apply(null, arguments) +}; + +var _short_be_38 = Module["_short_be_38"] = function() { + return Module["asm"]["_short_be_38"].apply(null, arguments) +}; + +var _short_be_59 = Module["_short_be_59"] = function() { + return Module["asm"]["_short_be_59"].apply(null, arguments) +}; + +var _short_be_65 = Module["_short_be_65"] = function() { + return Module["asm"]["_short_be_65"].apply(null, arguments) +}; + +var _short_be_74 = Module["_short_be_74"] = function() { + return Module["asm"]["_short_be_74"].apply(null, arguments) +}; + +var _short_from = Module["_short_from"] = function() { + return Module["asm"]["_short_from"].apply(null, arguments) +}; + +var _short_from_153 = Module["_short_from_153"] = function() { + return Module["asm"]["_short_from_153"].apply(null, arguments) +}; + +var _slifs = Module["_slifs"] = function() { + return Module["asm"]["_slifs"].apply(null, arguments) +}; + +var _socket_clean_queues = Module["_socket_clean_queues"] = function() { + return Module["asm"]["_socket_clean_queues"].apply(null, arguments) +}; + +var _socket_cmp = Module["_socket_cmp"] = function() { + return Module["asm"]["_socket_cmp"].apply(null, arguments) +}; + +var _socket_cmp_addresses = Module["_socket_cmp_addresses"] = function() { + return Module["asm"]["_socket_cmp_addresses"].apply(null, arguments) +}; + +var _socket_cmp_family = Module["_socket_cmp_family"] = function() { + return Module["asm"]["_socket_cmp_family"].apply(null, arguments) +}; + +var _socket_cmp_ipv4 = Module["_socket_cmp_ipv4"] = function() { + return Module["asm"]["_socket_cmp_ipv4"].apply(null, arguments) +}; + +var _socket_cmp_ipv6 = Module["_socket_cmp_ipv6"] = function() { + return Module["asm"]["_socket_cmp_ipv6"].apply(null, arguments) +}; + +var _socket_cmp_remotehost = Module["_socket_cmp_remotehost"] = function() { + return Module["asm"]["_socket_cmp_remotehost"].apply(null, arguments) +}; + +var _socket_garbage_collect = Module["_socket_garbage_collect"] = function() { + return Module["asm"]["_socket_garbage_collect"].apply(null, arguments) +}; + +var _socket_tcp_deliver_ipv4 = Module["_socket_tcp_deliver_ipv4"] = function() { + return Module["asm"]["_socket_tcp_deliver_ipv4"].apply(null, arguments) +}; + +var _socket_tcp_deliver_ipv6 = Module["_socket_tcp_deliver_ipv6"] = function() { + return Module["asm"]["_socket_tcp_deliver_ipv6"].apply(null, arguments) +}; + +var _socket_tcp_do_deliver = Module["_socket_tcp_do_deliver"] = function() { + return Module["asm"]["_socket_tcp_do_deliver"].apply(null, arguments) +}; + +var _sockport_cmp = Module["_sockport_cmp"] = function() { + return Module["asm"]["_sockport_cmp"].apply(null, arguments) +}; + +var _srsf = Module["_srsf"] = function() { + return Module["asm"]["_srsf"].apply(null, arguments) +}; + +var _srsfst = Module["_srsfst"] = function() { + return Module["asm"]["_srsfst"].apply(null, arguments) +}; + +var _srst = Module["_srst"] = function() { + return Module["asm"]["_srst"].apply(null, arguments) +}; + +var _st = Module["_st"] = function() { + return Module["asm"]["_st"].apply(null, arguments) +}; + +var _stcl = Module["_stcl"] = function() { + return Module["asm"]["_stcl"].apply(null, arguments) +}; + +var _strcasecmp = Module["_strcasecmp"] = function() { + return Module["asm"]["_strcasecmp"].apply(null, arguments) +}; + +var _strcmp = Module["_strcmp"] = function() { + return Module["asm"]["_strcmp"].apply(null, arguments) +}; + +var _strlen = Module["_strlen"] = function() { + return Module["asm"]["_strlen"].apply(null, arguments) +}; + +var _strncpy = Module["_strncpy"] = function() { + return Module["asm"]["_strncpy"].apply(null, arguments) +}; + +var _stslifs = Module["_stslifs"] = function() { + return Module["asm"]["_stslifs"].apply(null, arguments) +}; + +var _switchNodes = Module["_switchNodes"] = function() { + return Module["asm"]["_switchNodes"].apply(null, arguments) +}; + +var _tcp_ack = Module["_tcp_ack"] = function() { + return Module["asm"]["_tcp_ack"].apply(null, arguments) +}; + +var _tcp_ack_advance_una = Module["_tcp_ack_advance_una"] = function() { + return Module["asm"]["_tcp_ack_advance_una"].apply(null, arguments) +}; + +var _tcp_action_by_flags = Module["_tcp_action_by_flags"] = function() { + return Module["asm"]["_tcp_action_by_flags"].apply(null, arguments) +}; + +var _tcp_action_call = Module["_tcp_action_call"] = function() { + return Module["asm"]["_tcp_action_call"].apply(null, arguments) +}; + +var _tcp_add_header = Module["_tcp_add_header"] = function() { + return Module["asm"]["_tcp_add_header"].apply(null, arguments) +}; + +var _tcp_add_options = Module["_tcp_add_options"] = function() { + return Module["asm"]["_tcp_add_options"].apply(null, arguments) +}; + +var _tcp_add_options_frame = Module["_tcp_add_options_frame"] = function() { + return Module["asm"]["_tcp_add_options_frame"].apply(null, arguments) +}; + +var _tcp_add_sack_option = Module["_tcp_add_sack_option"] = function() { + return Module["asm"]["_tcp_add_sack_option"].apply(null, arguments) +}; + +var _tcp_attempt_closewait = Module["_tcp_attempt_closewait"] = function() { + return Module["asm"]["_tcp_attempt_closewait"].apply(null, arguments) +}; + +var _tcp_closeconn = Module["_tcp_closeconn"] = function() { + return Module["asm"]["_tcp_closeconn"].apply(null, arguments) +}; + +var _tcp_closewait = Module["_tcp_closewait"] = function() { + return Module["asm"]["_tcp_closewait"].apply(null, arguments) +}; + +var _tcp_closing_ack = Module["_tcp_closing_ack"] = function() { + return Module["asm"]["_tcp_closing_ack"].apply(null, arguments) +}; + +var _tcp_congestion_control = Module["_tcp_congestion_control"] = function() { + return Module["asm"]["_tcp_congestion_control"].apply(null, arguments) +}; + +var _tcp_data_in = Module["_tcp_data_in"] = function() { + return Module["asm"]["_tcp_data_in"].apply(null, arguments) +}; + +var _tcp_data_in_expected = Module["_tcp_data_in_expected"] = function() { + return Module["asm"]["_tcp_data_in_expected"].apply(null, arguments) +}; + +var _tcp_data_in_high_segment = Module["_tcp_data_in_high_segment"] = function() { + return Module["asm"]["_tcp_data_in_high_segment"].apply(null, arguments) +}; + +var _tcp_data_in_send_ack = Module["_tcp_data_in_send_ack"] = function() { + return Module["asm"]["_tcp_data_in_send_ack"].apply(null, arguments) +}; + +var _tcp_deltcb = Module["_tcp_deltcb"] = function() { + return Module["asm"]["_tcp_deltcb"].apply(null, arguments) +}; + +var _tcp_discard_all_segments = Module["_tcp_discard_all_segments"] = function() { + return Module["asm"]["_tcp_discard_all_segments"].apply(null, arguments) +}; + +var _tcp_do_send_rst = Module["_tcp_do_send_rst"] = function() { + return Module["asm"]["_tcp_do_send_rst"].apply(null, arguments) +}; + +var _tcp_fill_rst_header = Module["_tcp_fill_rst_header"] = function() { + return Module["asm"]["_tcp_fill_rst_header"].apply(null, arguments) +}; + +var _tcp_fill_rst_payload = Module["_tcp_fill_rst_payload"] = function() { + return Module["asm"]["_tcp_fill_rst_payload"].apply(null, arguments) +}; + +var _tcp_finack = Module["_tcp_finack"] = function() { + return Module["asm"]["_tcp_finack"].apply(null, arguments) +}; + +var _tcp_finwaitack = Module["_tcp_finwaitack"] = function() { + return Module["asm"]["_tcp_finwaitack"].apply(null, arguments) +}; + +var _tcp_finwaitfin = Module["_tcp_finwaitfin"] = function() { + return Module["asm"]["_tcp_finwaitfin"].apply(null, arguments) +}; + +var _tcp_first_ack = Module["_tcp_first_ack"] = function() { + return Module["asm"]["_tcp_first_ack"].apply(null, arguments) +}; + +var _tcp_first_timeout = Module["_tcp_first_timeout"] = function() { + return Module["asm"]["_tcp_first_timeout"].apply(null, arguments) +}; + +var _tcp_force_closed = Module["_tcp_force_closed"] = function() { + return Module["asm"]["_tcp_force_closed"].apply(null, arguments) +}; + +var _tcp_halfopencon = Module["_tcp_halfopencon"] = function() { + return Module["asm"]["_tcp_halfopencon"].apply(null, arguments) +}; + +var _tcp_is_allowed_to_send = Module["_tcp_is_allowed_to_send"] = function() { + return Module["asm"]["_tcp_is_allowed_to_send"].apply(null, arguments) +}; + +var _tcp_lastackwait = Module["_tcp_lastackwait"] = function() { + return Module["asm"]["_tcp_lastackwait"].apply(null, arguments) +}; + +var _tcp_linger = Module["_tcp_linger"] = function() { + return Module["asm"]["_tcp_linger"].apply(null, arguments) +}; + +var _tcp_next_zerowindow_probe = Module["_tcp_next_zerowindow_probe"] = function() { + return Module["asm"]["_tcp_next_zerowindow_probe"].apply(null, arguments) +}; + +var _tcp_nosync_rst = Module["_tcp_nosync_rst"] = function() { + return Module["asm"]["_tcp_nosync_rst"].apply(null, arguments) +}; + +var _tcp_options_size = Module["_tcp_options_size"] = function() { + return Module["asm"]["_tcp_options_size"].apply(null, arguments) +}; + +var _tcp_options_size_frame = Module["_tcp_options_size_frame"] = function() { + return Module["asm"]["_tcp_options_size_frame"].apply(null, arguments) +}; + +var _tcp_parse_option_mss = Module["_tcp_parse_option_mss"] = function() { + return Module["asm"]["_tcp_parse_option_mss"].apply(null, arguments) +}; + +var _tcp_parse_option_sack_ok = Module["_tcp_parse_option_sack_ok"] = function() { + return Module["asm"]["_tcp_parse_option_sack_ok"].apply(null, arguments) +}; + +var _tcp_parse_option_timestamp = Module["_tcp_parse_option_timestamp"] = function() { + return Module["asm"]["_tcp_parse_option_timestamp"].apply(null, arguments) +}; + +var _tcp_parse_option_ws = Module["_tcp_parse_option_ws"] = function() { + return Module["asm"]["_tcp_parse_option_ws"].apply(null, arguments) +}; + +var _tcp_parse_options = Module["_tcp_parse_options"] = function() { + return Module["asm"]["_tcp_parse_options"].apply(null, arguments) +}; + +var _tcp_process_sack = Module["_tcp_process_sack"] = function() { + return Module["asm"]["_tcp_process_sack"].apply(null, arguments) +}; + +var _tcp_rcv_sack = Module["_tcp_rcv_sack"] = function() { + return Module["asm"]["_tcp_rcv_sack"].apply(null, arguments) +}; + +var _tcp_rcvfin = Module["_tcp_rcvfin"] = function() { + return Module["asm"]["_tcp_rcvfin"].apply(null, arguments) +}; + +var _tcp_read_check_segment_done = Module["_tcp_read_check_segment_done"] = function() { + return Module["asm"]["_tcp_read_check_segment_done"].apply(null, arguments) +}; + +var _tcp_read_finish = Module["_tcp_read_finish"] = function() { + return Module["asm"]["_tcp_read_finish"].apply(null, arguments) +}; + +var _tcp_read_in_frame_len = Module["_tcp_read_in_frame_len"] = function() { + return Module["asm"]["_tcp_read_in_frame_len"].apply(null, arguments) +}; + +var _tcp_retrans = Module["_tcp_retrans"] = function() { + return Module["asm"]["_tcp_retrans"].apply(null, arguments) +}; + +var _tcp_retrans_timeout = Module["_tcp_retrans_timeout"] = function() { + return Module["asm"]["_tcp_retrans_timeout"].apply(null, arguments) +}; + +var _tcp_retrans_timeout_check_queue = Module["_tcp_retrans_timeout_check_queue"] = function() { + return Module["asm"]["_tcp_retrans_timeout_check_queue"].apply(null, arguments) +}; + +var _tcp_rst = Module["_tcp_rst"] = function() { + return Module["asm"]["_tcp_rst"].apply(null, arguments) +}; + +var _tcp_rto_xmit = Module["_tcp_rto_xmit"] = function() { + return Module["asm"]["_tcp_rto_xmit"].apply(null, arguments) +}; + +var _tcp_rtt = Module["_tcp_rtt"] = function() { + return Module["asm"]["_tcp_rtt"].apply(null, arguments) +}; + +var _tcp_sack_marker = Module["_tcp_sack_marker"] = function() { + return Module["asm"]["_tcp_sack_marker"].apply(null, arguments) +}; + +var _tcp_sack_prepare = Module["_tcp_sack_prepare"] = function() { + return Module["asm"]["_tcp_sack_prepare"].apply(null, arguments) +}; + +var _tcp_send = Module["_tcp_send"] = function() { + return Module["asm"]["_tcp_send"].apply(null, arguments) +}; + +var _tcp_send_ack = Module["_tcp_send_ack"] = function() { + return Module["asm"]["_tcp_send_ack"].apply(null, arguments) +}; + +var _tcp_send_add_tcpflags = Module["_tcp_send_add_tcpflags"] = function() { + return Module["asm"]["_tcp_send_add_tcpflags"].apply(null, arguments) +}; + +var _tcp_send_empty = Module["_tcp_send_empty"] = function() { + return Module["asm"]["_tcp_send_empty"].apply(null, arguments) +}; + +var _tcp_send_fin = Module["_tcp_send_fin"] = function() { + return Module["asm"]["_tcp_send_fin"].apply(null, arguments) +}; + +var _tcp_send_probe = Module["_tcp_send_probe"] = function() { + return Module["asm"]["_tcp_send_probe"].apply(null, arguments) +}; + +var _tcp_send_rst = Module["_tcp_send_rst"] = function() { + return Module["asm"]["_tcp_send_rst"].apply(null, arguments) +}; + +var _tcp_send_synack = Module["_tcp_send_synack"] = function() { + return Module["asm"]["_tcp_send_synack"].apply(null, arguments) +}; + +var _tcp_send_try_enqueue = Module["_tcp_send_try_enqueue"] = function() { + return Module["asm"]["_tcp_send_try_enqueue"].apply(null, arguments) +}; + +var _tcp_set_init_point = Module["_tcp_set_init_point"] = function() { + return Module["asm"]["_tcp_set_init_point"].apply(null, arguments) +}; + +var _tcp_set_space = Module["_tcp_set_space"] = function() { + return Module["asm"]["_tcp_set_space"].apply(null, arguments) +}; + +var _tcp_set_space_check_winupdate = Module["_tcp_set_space_check_winupdate"] = function() { + return Module["asm"]["_tcp_set_space_check_winupdate"].apply(null, arguments) +}; + +var _tcp_split_segment = Module["_tcp_split_segment"] = function() { + return Module["asm"]["_tcp_split_segment"].apply(null, arguments) +}; + +var _tcp_syn = Module["_tcp_syn"] = function() { + return Module["asm"]["_tcp_syn"].apply(null, arguments) +}; + +var _tcp_synack = Module["_tcp_synack"] = function() { + return Module["asm"]["_tcp_synack"].apply(null, arguments) +}; + +var _tcp_synrecv_syn = Module["_tcp_synrecv_syn"] = function() { + return Module["asm"]["_tcp_synrecv_syn"].apply(null, arguments) +}; + +var _tcp_wakeup_pending = Module["_tcp_wakeup_pending"] = function() { + return Module["asm"]["_tcp_wakeup_pending"].apply(null, arguments) +}; + +var _tcpopt_len_check = Module["_tcpopt_len_check"] = function() { + return Module["asm"]["_tcpopt_len_check"].apply(null, arguments) +}; + +var _time_diff = Module["_time_diff"] = function() { + return Module["asm"]["_time_diff"].apply(null, arguments) +}; + +var _tolower = Module["_tolower"] = function() { + return Module["asm"]["_tolower"].apply(null, arguments) +}; + +var _transport_flags_update = Module["_transport_flags_update"] = function() { + return Module["asm"]["_transport_flags_update"].apply(null, arguments) +}; + +var _update_max_arp_reqs = Module["_update_max_arp_reqs"] = function() { + return Module["asm"]["_update_max_arp_reqs"].apply(null, arguments) +}; + +var _vfprintf = Module["_vfprintf"] = function() { + return Module["asm"]["_vfprintf"].apply(null, arguments) +}; + +var _wcrtomb = Module["_wcrtomb"] = function() { + return Module["asm"]["_wcrtomb"].apply(null, arguments) +}; + +var _wctomb = Module["_wctomb"] = function() { + return Module["asm"]["_wctomb"].apply(null, arguments) +}; + +var establishStackSpace = Module["establishStackSpace"] = function() { + return Module["asm"]["establishStackSpace"].apply(null, arguments) +}; + +var stackAlloc = Module["stackAlloc"] = function() { + return Module["asm"]["stackAlloc"].apply(null, arguments) +}; + +var stackRestore = Module["stackRestore"] = function() { + return Module["asm"]["stackRestore"].apply(null, arguments) +}; + +var stackSave = Module["stackSave"] = function() { + return Module["asm"]["stackSave"].apply(null, arguments) +}; + +var dynCall_ii = Module["dynCall_ii"] = function() { + return Module["asm"]["dynCall_ii"].apply(null, arguments) +}; + +var dynCall_iidiiii = Module["dynCall_iidiiii"] = function() { + return Module["asm"]["dynCall_iidiiii"].apply(null, arguments) +}; + +var dynCall_iii = Module["dynCall_iii"] = function() { + return Module["asm"]["dynCall_iii"].apply(null, arguments) +}; + +var dynCall_iiii = Module["dynCall_iiii"] = function() { + return Module["asm"]["dynCall_iiii"].apply(null, arguments) +}; + +var dynCall_jiji = Module["dynCall_jiji"] = function() { + return Module["asm"]["dynCall_jiji"].apply(null, arguments) +}; + +var dynCall_vi = Module["dynCall_vi"] = function() { + return Module["asm"]["dynCall_vi"].apply(null, arguments) +}; + +var dynCall_vii = Module["dynCall_vii"] = function() { + return Module["asm"]["dynCall_vii"].apply(null, arguments) +}; + +var dynCall_viiii = Module["dynCall_viiii"] = function() { + return Module["asm"]["dynCall_viiii"].apply(null, arguments) +}; + +var dynCall_vji = Module["dynCall_vji"] = function() { + return Module["asm"]["dynCall_vji"].apply(null, arguments) +}; +; + + + +// === Auto-generated postamble setup entry stuff === + +Module['asm'] = asm; + + + +Module["ccall"] = ccall; +Module["cwrap"] = cwrap; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +Module["addFunction"] = addFunction; +Module["removeFunction"] = removeFunction; + + + + + + + + + + + + + + + + + + + + + + + + +var calledRun; + +// Modularize mode returns a function, which can be called to +// create instances. The instances provide a then() method, +// must like a Promise, that receives a callback. The callback +// is called when the module is ready to run, with the module +// as a parameter. (Like a Promise, it also returns the module +// so you can use the output of .then(..)). +Module['then'] = function(func) { + // We may already be ready to run code at this time. if + // so, just queue a call to the callback. + if (calledRun) { + func(Module); + } else { + // we are not ready to call then() yet. we must call it + // at the same time we would call onRuntimeInitialized. + var old = Module['onRuntimeInitialized']; + Module['onRuntimeInitialized'] = function() { + if (old) old(); + func(Module); + }; + } + return Module; +}; + +/** + * @constructor + * @this {ExitStatus} + */ +function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status; +} + +var calledMain = false; + + +dependenciesFulfilled = function runCaller() { + // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false) + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled +}; + +function callMain(args) { + + var entryFunction = Module['_main']; + + + args = args || []; + + var argc = args.length+1; + var argv = stackAlloc((argc + 1) * 4); + HEAP32[argv >> 2] = allocateUTF8OnStack(thisProgram); + for (var i = 1; i < argc; i++) { + HEAP32[(argv >> 2) + i] = allocateUTF8OnStack(args[i - 1]); + } + HEAP32[(argv >> 2) + argc] = 0; + + + try { + + + var ret = entryFunction(argc, argv); + + + // if we're not running an evented main loop, it's time to exit + exit(ret, /* implicit = */ true); + } + catch(e) { + if (e instanceof ExitStatus) { + // exit() throws this once it's done to make sure execution + // has been stopped completely + return; + } else if (e == 'SimulateInfiniteLoop') { + // running an evented main loop, don't immediately exit + noExitRuntime = true; + return; + } else { + var toLog = e; + if (e && typeof e === 'object' && e.stack) { + toLog = [e, e.stack]; + } + err('exception thrown: ' + toLog); + quit_(1, e); + } + } finally { + calledMain = true; + } +} + + + + +/** @type {function(Array=)} */ +function run(args) { + args = args || arguments_; + + if (runDependencies > 0) { + return; + } + + + preRun(); + + if (runDependencies > 0) return; // a preRun added a dependency, run will be called later + + function doRun() { + // run may have just been called through dependencies being fulfilled just in this very frame, + // or while the async setStatus time below was happening + if (calledRun) return; + calledRun = true; + + if (ABORT) return; + + initRuntime(); + + preMain(); + + if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized'](); + + if (shouldRunNow) callMain(args); + + postRun(); + } + + if (Module['setStatus']) { + Module['setStatus']('Running...'); + setTimeout(function() { + setTimeout(function() { + Module['setStatus'](''); + }, 1); + doRun(); + }, 1); + } else + { + doRun(); + } +} +Module['run'] = run; + + +function exit(status, implicit) { + + // if this is just main exit-ing implicitly, and the status is 0, then we + // don't need to do anything here and can just leave. if the status is + // non-zero, though, then we need to report it. + // (we may have warned about this earlier, if a situation justifies doing so) + if (implicit && noExitRuntime && status === 0) { + return; + } + + if (noExitRuntime) { + } else { + + ABORT = true; + EXITSTATUS = status; + + exitRuntime(); + + if (Module['onExit']) Module['onExit'](status); + } + + quit_(status, new ExitStatus(status)); +} + +if (Module['preInit']) { + if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; + while (Module['preInit'].length > 0) { + Module['preInit'].pop()(); + } +} + +// shouldRunNow refers to calling main(), not run(). +var shouldRunNow = true; + +if (Module['noInitialRun']) shouldRunNow = false; + + + noExitRuntime = true; + +run(); + + + + + +// {{MODULE_ADDITIONS}} + + + + + + return Module +} +); +})(); +if (typeof exports === 'object' && typeof module === 'object') + module.exports = Module; + else if (typeof define === 'function' && define['amd']) + define([], function() { return Module; }); + else if (typeof exports === 'object') + exports["Module"] = Module; + // HACK: Work around . +const _Module = new Proxy(Module, { + apply(target, thisArg, args) { + return new Promise(resolve => Reflect.apply(target, thisArg, args) + .then(m => { + delete m.then; + resolve(m); + })); + } +}); +export { _Module as default }; + +class SyncWritableReadableStream extends ReadableStream { + constructor(...args) { + let controller; + super({ + start: _controller => controller = _controller, + }, ...args); + this.controller = controller; + } + _write(...args) { + this.controller.enqueue(...args); + } + _close() { + if (this.isClosed) return; + this.controller.close(); + this.isClosed = true; + } +} + +const EOF = Symbol("EOF"); + +class SyncSink { + constructor({size = () => 1, highWaterMark = 1} = {}) { + this._queue = []; + this._queueTotalSize = 0; + this._strategyHWM = highWaterMark; + this._strategySizeAlgorithm = size; + this._ready = Promise.resolve(); + this._readyResolve = () => {}; + this._readyReject = () => {}; + this._isAborted = false; + } + write(chunk, controller) { + if (chunk === EOF) return; + const size = this._strategySizeAlgorithm(chunk); + this._queueTotalSize += size; + this._queue.push([chunk, size]); + if (this._queueTotalSize < this._strategyHWM) return; + this._ready = new Promise((resolve, reject) => { + this._readyResolve = resolve; + this._readyReject = reject; + }); + if (this._onData) { + this._onData(); + this._onData = null; + } + return this._ready; + } + close() { + this._queue.push([EOF, 0]); + } + abort(reason) { + this._isAborted = reason; + this._queue = []; + } + read() { + if (this._queue.length === 0) return []; + const [chunk, size] = this._queue.shift(); + this._queueTotalSize -= size; + if (this._queueTotalSize < 0) this._queueTotalSize = 0; + if (this._queueTotalSize < this._strategyHWM) this._readyResolve(); + return [chunk]; + } +} + +class SyncReadableWritableStream extends WritableStream { + constructor(sinkArgs, ...args) { + const sink = new SyncSink(sinkArgs); + super(sink, ...args); + this._sink = sink; + } + _read() { + return this._sink.read()[0]; + } + get EOF() { + return EOF; + } + get isAborted() { + return this._sink.isAborted; + } + get ready() { + return this._sink._ready; + } + set _onData(val) { + this._sink._onData = val; + } + *[Symbol.iterator]() { + for (let v; v = this._sink.read();) { + if (v.length === 0) break; + yield v[0]; + } + } +} diff --git a/public/lib/picotcp/picotcp.wasm b/public/lib/picotcp/picotcp.wasm new file mode 100644 index 0000000000000000000000000000000000000000..f15da92abae81efc44a9a644e710ca44e46b3f26 GIT binary patch literal 205932 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 z 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 literal 0 HcmV?d00001 diff --git a/public/lib/picotcp/sab-ring-buffer/ringbuffer.js b/public/lib/picotcp/sab-ring-buffer/ringbuffer.js new file mode 100644 index 00000000..91703d84 --- /dev/null +++ b/public/lib/picotcp/sab-ring-buffer/ringbuffer.js @@ -0,0 +1,201 @@ +/* + Copyright 2020 Google Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +export default class RingBuffer { + static from(sab) { + return new RingBuffer(sab); + } + + get buffer() { + return this._sab; + } + + get remaining() { + return this._size - this.length; + } + + get size() { + return this._size; + } + + get length() { + let readIndex = Atomics.load(this._header, HEADER.READ); + let writeIndex = Atomics.load(this._header, HEADER.WRITE); + + const delta = writeIndex - readIndex; + return readIndex <= writeIndex ? delta : delta + this._size; + } + + get eof() { + return (this.length === 0 && Atomics.load(this._state, READER_STATE.EOF) === 0) ? true : false; + } + + set eof(val) { + let eofVal = !!val ? 0 : 1; + if (this.length === 0 && val) { + Atomics.notify(this._state, READER_STATE.DATA_AVAILABLE); + } + Atomics.store(this._state, READER_STATE.EOF, eofVal); + } + + /* + Create's a Ring Buffer backed by a correctly sized SAB. + + There can only be one writer and one reader. + */ + static create(length) { + const buffer = new SharedArrayBuffer( + length + + Uint32Array.BYTES_PER_ELEMENT * HEADER_LENGTH + + Int32Array.BYTES_PER_ELEMENT * READER_STATE_LENGTH + ); + + return new RingBuffer(buffer); + } + + constructor(sab) { + if (!!sab == false) throw new Error("Shared Array Buffer is undefined"); + if (sab instanceof SharedArrayBuffer == false) + throw new Error("Parameter 0 is not a Shared Array Buffer"); + + this._size = sab.byteLength + - Uint32Array.BYTES_PER_ELEMENT * HEADER_LENGTH + - Int32Array.BYTES_PER_ELEMENT * READER_STATE_LENGTH; + this._sab = sab; + this._header = new Uint32Array(sab, 0, HEADER_LENGTH); + this._state = new Int32Array(sab, Uint32Array.BYTES_PER_ELEMENT * HEADER_LENGTH, READER_STATE_LENGTH) + this._body = new Uint8Array( + sab, + Uint32Array.BYTES_PER_ELEMENT * HEADER_LENGTH + + Int32Array.BYTES_PER_ELEMENT * READER_STATE_LENGTH, + this._size + ); + } + + /* + data: An array of Uint8 + attemptToFill (deafault: false): if true, will fill as much of the array as possible + returning the items that couldn't be added. + + */ + append(data, attemptToFill = false) { + const { remaining, length, size } = this; + + if (data.length > remaining && attemptToFill == false) { + throw new Error("Data being appended will overflow the buffer"); + } + + if (data instanceof Array == false && data instanceof Uint8Array == false) { + throw new Error( + "data is not an array that can be converted to Uint8array" + ); + } + + let writeIndex = Atomics.load(this._header, HEADER.WRITE); + let writeStart = writeIndex % size; + + // We need at most two write operations. + // If the data will go past the end of the buffer, we need + // to write a 2nd batch from the start of the buffer. + // 9, 15 + // batch1, pos [9] = val [0] + // batch2, pos [0] = val [1,2,3,4,5] + + const batch1 = data.slice(0, size - writeStart); + this._body.set(batch1, writeStart); + let writeLength = batch1.length; + let slice = undefined; + + if (writeLength < data.length) { + // We are wrapping around because there was more data. + const batch2 = data.slice(writeLength, remaining - writeLength); + this._body.set(batch2, 0); + writeLength += batch2.length; + + Atomics.add(this._header, HEADER.WRITE, writeLength); + + if (attemptToFill && (writeLength < data.length)) { + slice = data.slice(writeLength); + } + } + else { + Atomics.add(this._header, HEADER.WRITE, writeLength); + } + + Atomics.store(this._state, READER_STATE.DATA_AVAILABLE, 1); + Atomics.notify(this._state, READER_STATE.DATA_AVAILABLE); + + return slice; + } + + // Reads the next byte of data. Note: Assuming 4GB of addressable buffer. + read() { + let readIndex = Atomics.load(this._header, HEADER.READ); + let writeIndex = Atomics.load(this._header, HEADER.WRITE); + + if (readIndex == writeIndex - 1) { + // The next blocking read, should wait. + console.log('next block') + Atomics.store(this._state, READER_STATE.DATA_AVAILABLE, 0); + Atomics.notify(this._state, READER_STATE.DATA_AVAILABLE); + } + + if (readIndex == writeIndex) { + return undefined; + } + + const value = Atomics.load(this._body, readIndex % this._size); + + readIndex = Atomics.add(this._header, HEADER.READ, 1); + + return value; + } + + blockingRead() { + if (this.eof) return undefined; + + Atomics.wait(this._state, READER_STATE.DATA_AVAILABLE, 0); + return this.read(); + } + + *readToHead() { + // Feels odd to have to create a buffer the same size as the buffer. Just iterate. + let data; + while ((data = this.read()) != undefined) { + yield data; + } + } + + clear() { + Atomics.store(this._header, HEADER.READ, 0); + Atomics.store(this._header, HEADER.WRITE, 0); + } +} + +const HEADER = { + READ: 0, // 4GB buffer + WRITE: 1, // 4GB buffer +}; + +const HEADER_LENGTH = Object.keys(HEADER).length; + +const READER_STATE = { + DATA_AVAILABLE: 0, + WAITING: 1, + EOF: 2 +}; + +const READER_STATE_LENGTH = Object.keys(READER_STATE).length; diff --git a/public/lib/picotcp/streams-polyfills.js b/public/lib/picotcp/streams-polyfills.js new file mode 100644 index 00000000..e210e2fc --- /dev/null +++ b/public/lib/picotcp/streams-polyfills.js @@ -0,0 +1,8 @@ +import {WritableStream, ReadableStream} from "web-streams-polyfill/ponyfill/es6"; + +if (!self.WritableStream) { + self.WritableStream = WritableStream; + + // also need to polyfill ReadableStream as it likely doesn't support pipeTo/Through if no WritableStream + self.ReadableStream = ReadableStream; +} diff --git a/public/lib/picotcp/transform-stream.js b/public/lib/picotcp/transform-stream.js new file mode 100644 index 00000000..6cad0ebd --- /dev/null +++ b/public/lib/picotcp/transform-stream.js @@ -0,0 +1,110 @@ +// Copyright 2018 The Emulation-as-a-Service Authors. +// SPDX-License-Identifier: GPL-2.0-or-later + +const _writable = new WeakMap(); +const _readable = new WeakMap(); +const _writeController = new WeakMap(); +const _readController = new WeakMap(); + +const call = (object, method, args) => { + const fun = object[method]; + if (typeof fun === "undefined") return; + if (typeof fun !== "function") throw new TypeError(); + return Reflect.apply(fun, object, args); +} + +/** + * A polyfill for `TransformStream` that uses the native `ReadableStream` + * and `WritableStream` implementations. + */ +class TransformStream { + constructor(transformer = {}, writableStrategy = {}, readableStrategy = {}) { + let resolveRead = () => {}; + const writable = new WritableStream({ + start: (writeController) => { + _writeController.set(this, writeController); + }, + write: async (chunk) => { + const readC = _readController.get(this); + if (readC.desiredSize <= 0) { + await new Promise(r => resolveRead = r); + } + return call(transformer, "transform", [chunk, controller]); + }, + close: async () => { + await call(transformer, "flush", [controller]); + _readController.get(this).close(); + }, + abort: () => { + return _readController.get(this).error(); + } + }, writableStrategy); + const readable = new ReadableStream({ + start: (readController) => { + _readController.set(this, readController); + if (typeof transformer.start !== "function") return; + return transformer.start(controller); + }, + pull: (chunk, controller) => { + resolveRead(); + }, + cancel(reason) {}, + + }, readableStrategy); + const controller = makeTransformStreamDefaultController( + _writeController.get(this), _readController.get(this)); + + _writable.set(this, writable); + _readable.set(this, readable); + } + get writable() {return _writable.get(this);} + get readable() {return _readable.get(this);} +} + +export {TransformStream as default}; + +const _readController2 = new WeakMap(); +const _writeController2 = new WeakMap(); +const _lastWrite = new WeakMap(); + +const makeTransformStreamDefaultController = (writeController, readController) => { + const _this = Object.create(TransformStreamDefaultController.prototype); + _writeController2.set(_this, writeController); + _readController2.set(_this, readController); + return _this; +} + +class TransformStreamDefaultController { + constructor() {throw new TypeError();} + + get desiredSize() { + return _readController2.get(this).desiredSize; + } + enqueue(chunk) { + const ret = _readController2.get(this).enqueue(chunk); + _lastWrite.set(this, ret); + return ret; + } + error(reason) { + _writeController2.get(this).error(reason); + _readController2.get(this).error(reason); + } + terminate() { + _writeController2.get(this).error(); + _readController2.get(this).close(); + } +} + + +class WritableStreamDefaultWriter { + constructor(stream) {} + + get closed() {return Promise.resolve();} + get desiredSize() {return 0;} + get ready() {return Promise.resolve();} + + abort(reason) {} + close() {} + releaseLock() {} + write(chunk) {} +} diff --git a/public/lib/picotcp/webnetwork.js b/public/lib/picotcp/webnetwork.js new file mode 100644 index 00000000..5b5ec9f1 --- /dev/null +++ b/public/lib/picotcp/webnetwork.js @@ -0,0 +1,414 @@ +// Copyright 2018 The Emulation-as-a-Service Authors. +// SPDX-License-Identifier: GPL-2.0-or-later + +//import(import.meta.url).then(v=>window.mod=v); + +//import "https://rawgit.com/bellbind/web-streams-polyfill/master/dist/polyfill.min.js"; +//import "https://rawgit.com/creatorrr/web-streams-polyfill/master/dist/polyfill.min.js"; +import TransformStream from "./transform-stream.js"; + +import picotcp from "./picotcp.js"; + +export {picotcp}; +export let globalStack; + +const sleep = ms => new Promise(r => setTimeout(r, ms)); + +export const cidrToSubnet = (string) => { + const [ip, prefixString] = string.split("/", 2); + const prefixLength = parseInt(prefixString); + const subnet = prefixLength && (-1 << (32 - prefixLength) >>> 0); + return [ip, `${subnet >>> 24 & 0xff}.${subnet >>> 16 & 0xff}.${subnet >>> 8 & 0xff}.${subnet >>> 0 & 0xff}`]; +}; + +export const parseMAC = (string) => + string.split(/:|-/).map(v => parseInt(v, 16)); + +export class Stream2 { + constructor() { + return new WritableStream(this); + } + write(controller, chunk) { + console.log(chunk); + return new Promise(() => {}); + } +} + +export const pcapHeader = new Blob([new Uint32Array([ + 0xa1b2c3d4, + 0x00040002, + 0x00000000, + 0x00000000, + 0x0000ffff, + 0x00000001, +])]); + +class StreamRecorder { + constructor(data = [pcapHeader]) { + this.data = data; + } + transform(chunk, controller) { + const buffer = chunk; // .buffer || chunk; + const length = buffer.byteLength; + const now = Date.now(); + const header = new Uint32Array([ + now / 1000, + (now % 1000) * 1000, + length, + length, + ]); + this.data.push(new Blob([header, buffer])); + controller.enqueue(chunk); + } +} + +export class RecordStream extends TransformStream { + constructor(data) { + const recorder = new StreamRecorder(data); + super(recorder); + this.recorder = recorder; + } + getDump() { + return new Blob(this.recorder.data); + } +} + +export const blobToArrayBuffer = blob => new Promise((onload, onerror) => + Object.assign(new FileReader(), {onload, onerror}).readAsArrayBuffer(blob)) +.then(v => v.target.result); + +export function saveAs(blob, name) { + const a = document.createElement("a"); + const url = URL.createObjectURL(blob); + a.href = url; + a.download = name; + // Firefox needs `a` to be connected to document. + document.head.append(a); + a.click(); + a.remove(); + URL.revokeObjectURL(url); + // setTimeout(() => URL.revokeObjectURL(url), 60 * 1000); +} + +export function randomMac() { + const mac = self.crypto.getRandomValues(new Uint8Array(6)); + // Unicast, locally administered. + mac[0] = mac[0] & ~0b00000001 | 0b00000010; + return mac; +} + +export class NetworkStack { + constructor({mac, ipv4} = {}) { + return (async () => { + this._picotcp = await picotcp(); + this.start(); + return this; + })(); + } + + start() { + this._interval = setInterval(this.tick.bind(this), 10/*500*/); + } + stop() { + clearInterval(this._interval); + this._interval = null; + } + tick() { + this._picotcp._pico_stack_tick(); + } + async addInterface({mac = randomMac(), ip}) { + const dev = await new NIC(this, mac); + if (ip) dev.addIPv4(ip); + return dev; + } +} + +let defaultNetwork; + +const callAsync = async (emscriptenModule, executor, removeFunction = true, transform = (...args) => args) => { + let resolve; + const promise = new Promise(_resolve => resolve = _resolve); + const ptr = emscriptenModule.addFunction((...args) => resolve(transform(...args))); + executor(ptr); + await promise; + if (removeFunction) emscriptenModule.removeFunction(ptr); + return promise; +} + +export class NIC { + constructor(stack, mac = randomMac()) { + return (async () => { + if (!stack) { + if (!defaultNetwork) defaultNetwork = new NetworkStack(); + stack = await defaultNetwork; + } + this.stack = stack; + this.dev = this.stack._picotcp.ccall("pico_js_create", "number", ["string", "array"], ["", mac]); + this.stack._dev = this.dev; + this.mac = mac; + return this; + })(); + } + addIPv4(ip = "", netmask = "255.255.255.0") { + this.stack._picotcp.ccall("js_add_ipv4", "number", ["number", "string", "string"], [this.dev, ip, netmask]); + } + async ping(dst, timeout = 1000) { + return callAsync(this.stack._picotcp, ptr => this.stack._picotcp.ccall( + "pico_icmp4_ping", "number", + ["string", "number", "number", "number", "number", "number"], + [dst, 1, 1, timeout, 64, ptr])); + } + async startDHCPClient() { + const xidPtr = this.stack._picotcp._malloc(4); + const [cli, code] = await callAsync(this.stack._picotcp, ptr => this.stack._picotcp.ccall( + "pico_dhcp_initiate_negotiation", "number", + ["number", "number", "number"], + [this.dev, ptr, xidPtr]), false); + const xid = this.stack._picotcp.HEAPU32[xidPtr / 4]; + this.stack._picotcp._js_accept_nameserver(cli); + // Do not free xidPtr as picoTCP will use it again when + // renewing the DHCP lease (not documented in picoTCP documentation). + return [cli, code, xid]; + } + startDHCPServer(ip) { + const settingsPtr = this.stack._picotcp._malloc(9 * 4); + const HEAPU32 = this.stack._picotcp.HEAPU32.subarray(settingsPtr / 4); + HEAPU32[0] = 0 + HEAPU32[1] = 0; + HEAPU32[2] = 0; + HEAPU32[3] = 864000; // 10 days DHCP lease + HEAPU32[4] = this.dev; + HEAPU32[5] = 0; + HEAPU32[6] = new Uint32Array(Uint8Array.from( + ip.split(/\./).map(v => parseInt(v, 10))).buffer)[0]; + HEAPU32[7] = 0; + HEAPU32[8] = 0; + const ret = this.stack._picotcp.ccall( + "pico_dhcp_server_initiate", "number", ["number"], [settingsPtr] + ); + this.stack._picotcp._free(settingsPtr); + return ret; + } + addARPEntry(mac, ip) { + const macPtr = this.stack._picotcp._malloc(6); + this.stack._picotcp.HEAPU8.set(mac.slice(0, 6), macPtr); + + const ipPtr = this.stack._picotcp._malloc(4); + this.stack._picotcp.HEAPU8.set(ip.slice(0, 4), ipPtr); + + const ret = this.stack._picotcp.ccall( + "pico_arp_create_entry", "number", ["number", "number", "number"], [macPtr, ipPtr, this.dev] + ); + + this.stack._picotcp._free(macPtr); + //this.stack._picotcp._free(ipPtr); + + return ret; + } + + async getAddr(addr) { + // TODO: This leaks `ptr` if `pico_dns_client_getaddr() != 0`. + const {HEAPU8} = this.stack._picotcp; + // HACK: IP addresses will never be longer than 255 bytes. + const name = await callAsync(this.stack._picotcp, ptr => + this.stack._picotcp.ccall("pico_dns_client_getaddr", "number", + ["string", "number", "number"], [addr, ptr, 0]), true, + ipPtr => new TextDecoder().decode( + HEAPU8.subarray(ipPtr, ipPtr + 256)).split("\0")[0]); + return name; + } + get readable() { + return this.stack._picotcp.pointers[this.dev].readable; + } + get writable() { + return this.stack._picotcp.pointers[this.dev].writable; + } + get TCPSocket() { + const self = this; + return class extends TCPSocket { + get NIC() {return self;} + } + } + get TCPServerSocket() { + const self = this; + return class extends TCPServerSocket { + get NIC() {return self;} + } + } +} + +/** + * @see https://www.w3.org/TR/tcp-udp-sockets/#interface-tcpsocket + */ +class TCPSocket { + constructor(remoteAddress, remotePort, options = {}) { + const PICO_PROTO_IPV4 = 0, PICO_PROTO_IPV6 = 41; + this._ptr = this.NIC.stack._picotcp.ccall("js_socket_open", "number", ["number", "number"], [PICO_PROTO_IPV4, new.target._proto]); + ({readable: this.readable, writable: this.writable} = this.NIC.stack._picotcp.pointers[this._ptr]); + console.log(this.NIC.stack._picotcp.ccall("js_socket_connect", "number", ["number", "string", "number"], [this._ptr, remoteAddress, remotePort])); + console.log(this.NIC.stack._picotcp._js_pico_err()); + } + + static get _proto() { + const PICO_PROTO_TCP = 6, PICO_PROTO_UDP = 17; + return PICO_PROTO_TCP; + } +} + +/** + * @see https://www.w3.org/TR/tcp-udp-sockets/#interface-tcpserversocket + */ +class TCPServerSocket { + constructor({localAddress, localPort} = {}) { + const PICO_PROTO_IPV4 = 0, PICO_PROTO_IPV6 = 41; + this._ptr = this.NIC.stack._picotcp.ccall("js_socket_open", "number", ["number", "number"], [PICO_PROTO_IPV4, new.target._proto]); + ({readable: this.readable, writable: this.writable} = this.NIC.stack._picotcp.pointers[this._ptr]); + console.log(this.NIC.stack._picotcp.ccall("js_socket_bind", "number", ["number", "string", "number"], [this._ptr, localAddress, localPort])); + console.log(this.NIC.stack._picotcp._js_pico_err()); + } + + static get _proto() { + const PICO_PROTO_TCP = 6, PICO_PROTO_UDP = 17; + return PICO_PROTO_TCP; + } +} + + + +/* +wait = ms=>{for(const end = performance.now() + ms; performance.now() < end;);} +setInterval(()=>{console.log(++x);wait(1100*a);console.log("done",x);}, 1000);x=0;a=1 +*/ + +/** @param {Uint8Array} buffer */ +self.SEND = buffer => { + const length = buffer.length; + // console.log("SENDING into VM -->", buffer, length); + const blob = new Blob([new Uint8Array([length >> 8, length & 0xff]), buffer]); + //ws.send(blob); + console.log("SEND called"); + return length; +}; + +self.POLL = (n, dev, module) => { + while (n--) { + if (!self.NET_Q.length) break; + const buf = self.NET_Q.shift(); + // TODO: When do we need to free this? + const pointer = module._malloc(buf.length); + module.writeArrayToMemory(buf, pointer); + // console.log("<-- GETTING from VM", new Uint8Array(buf), buf.length, pointer); + module.ccall("pico_stack_recv", "number", ["number", "number", "number"], + [dev, pointer, buf.length]); + } + return n; +}; + +self.NET_Q = []; + +export const messages = []; + +export async function start() { + let stack = picotcp(); + globalStack = stack; + setInterval(() => stack._pico_stack_tick(), 500); +} + + // if (typeof TransformStream === "undefined") await import("https://rawgit.com/creatorrr/web-streams-polyfill/master/dist/polyfill.min.js"); + + //const urls = Object.entries(data).filter(([k]) => k.startsWith("ws+ethernet+")); + //const url = new URL(urls[0][1]); + //const ws = new WebSocket(url); + +/* window.ws = ws; + const stream = wrapWebSocket(ws) + .pipeThrough(new Uint8ArrayStream()) + .pipeThrough(new VDEParser()) + // VDE does not send a CRC. + .pipeThrough(new EthernetParser({crcLength: 0})) + // .pipeThrough(new EthernetPrinter()) + .pipeThrough(new IPv4Parser()) + .pipeThrough(new UDPParser()) + ; + const read = stream.getReader(); +*/ +// for await (const chunk of read) { +// window.Q.push(chunk); +// try {stack._pico_stack_tick();} catch (e) {} +// // console.log(chunk); +// } + +//} + +new ReadableStream().getReader().__proto__[Symbol.asyncIterator] = function () { + return { + next: () => this.read(), + }; +} + +export class StreamPrinter extends TransformStream { + constructor(tag = "StreamPrinter") { + super({ + transform(chunk, controller) { + console.log(tag, chunk); + controller.enqueue(chunk); + } + }); + } +} + +export class EthernetPrinter extends TransformStream { + constructor() { + /** + * @param {Uint8Array} frame + * @param {*} controller + */ + const transform = (frame, controller) => { + controller.enqueue({ + ...frame, + source: Array.from(frame.source).map(v => v.toString(16)), + dest: Array.from(frame.dest).map(v => v.toString(16)), + type: frame.type.toString(16), + frame, + }); + }; + super({transform}); + } +} + +export function wrapWebSocket(ws) { + return new ReadableStream({ + start(controller) { + ws.addEventListener("message", ({data}) => controller.enqueue(data)); + } + }); +} + +function getPromise() { + let resolve, reject; + const promise = new Promise((_resolve, _reject) => { + resolve = _resolve; + reject = _reject; + }); + return {promise, resolve, reject}; +}; + +export class Uint8ArrayStream extends TransformStream { + constructor(websocketStream) { + const reader = new FileReader(); + super({ + async transform(chunk, controller) { + let ret; + if (chunk instanceof Blob) { + reader.readAsArrayBuffer(chunk); + await ({resolve: reader.onload, reject: reader.onerror} = getPromise()).promise; + chunk = reader.result; + } + if (chunk.buffer) chunk = chunk.buffer; + if (chunk instanceof ArrayBuffer) ret = new Uint8Array(chunk); + else return; + controller.enqueue(ret); + } + }); + } +} diff --git a/public/lib/v86/libv86.js b/public/lib/v86/libv86.js new file mode 100644 index 00000000..4845162a --- /dev/null +++ b/public/lib/v86/libv86.js @@ -0,0 +1,835 @@ +;(function(){'use strict';var $jscomp=$jscomp||{};$jscomp.scope={};$jscomp.ASSUME_ES5=!1;$jscomp.ASSUME_NO_NATIVE_MAP=!1;$jscomp.ASSUME_NO_NATIVE_SET=!1;$jscomp.SIMPLE_FROUND_POLYFILL=!1;$jscomp.defineProperty=$jscomp.ASSUME_ES5||"function"==typeof Object.defineProperties?Object.defineProperty:function(a,b,c){a!=Array.prototype&&a!=Object.prototype&&(a[b]=c.value)};$jscomp.getGlobal=function(a){return"undefined"!=typeof window&&window===a?a:"undefined"!=typeof global&&null!=global?global:a};$jscomp.global=$jscomp.getGlobal(this); +$jscomp.polyfill=function(a,b,c,d){if(b){c=$jscomp.global;a=a.split(".");for(d=0;dy;y++)D=127y?F[y]:y,C[y]=String.fromCharCode(D);f.imageSmoothingEnabled=!1;g.style.position="absolute";g.style.backgroundColor="#ccc";g.style.width="7px";g.style.display="inline-block";k.style.display="block";e.style.display="none";this.bus=b;b.register("screen-set-mode",function(a){this.set_mode(a)},this);b.register("screen-fill-buffer-end",function(a){this.update_buffer(a)}, +this);b.register("screen-put-char",function(a){this.put_char(a[0],a[1],a[2],a[3],a[4])},this);b.register("screen-update-cursor",function(a){this.update_cursor(a[0],a[1])},this);b.register("screen-update-cursor-scanline",function(a){this.update_cursor_scanline(a[0],a[1])},this);b.register("screen-clear",function(){this.clear_screen()},this);b.register("screen-set-size-text",function(a){this.set_size_text(a[0],a[1])},this);b.register("screen-set-size-graphical",function(a){this.set_size_graphical(a[0], +a[1],a[2],a[3])},this);this.init=function(){this.set_size_text(80,25);this.timer()};this.make_screenshot=function(){try{const a=new Image;a.src=e.toDataURL("image/png");window.open("").document.write(a.outerHTML)}catch(I){}};this.put_char=function(a,b,c,d,e){ab;)k.removeChild(k.firstChild);for(;k.childNodes.length=t?2:1;this.bus.send("screen-tell-buffer",[m],[m.buffer]);d(e,r*u,q*u,!1)};this.set_scale=function(a,b){r=a;q=b;d(k,r,q,!0);d(e,r*u,q*u,!1)};this.set_scale(r,q);this.update_cursor_scanline=function(a,b){a&32?g.style.display="none":(g.style.display= +"inline",g.style.height=Math.min(15,b-a)+"px",g.style.marginTop=Math.min(15,a)+"px")};this.update_cursor=function(a,b){if(a!==n||b!==p)w[a]=1,w[n]=1,n=a,p=b};this.text_update_row=function(a){var b=3*a*x,d;var e=k.childNodes[a];var f=document.createElement("div");for(var l=0;l{f.strokeRect(a.buffer_x,a.buffer_y,a.buffer_width,a.buffer_height)}),f.lineWidth=1):a.forEach(a=>{f.putImageData(l,a.screen_x-a.buffer_x,a.screen_y-a.buffer_y,a.buffer_x,a.buffer_y,a.buffer_width,a.buffer_height)})};this.init()};const VIRTIO_9P_F_MOUNT_TAG=0,VIRTIO_9P_MAX_TAGLEN=254; +var EPERM=1,ENOENT=2,EEXIST=17,EINVAL=22,EOPNOTSUPP=95,ENOTEMPTY=39,EPROTO=71,P9_SETATTR_MODE=1,P9_SETATTR_UID=2,P9_SETATTR_GID=4,P9_SETATTR_SIZE=8,P9_SETATTR_ATIME=16,P9_SETATTR_MTIME=32,P9_SETATTR_CTIME=64,P9_SETATTR_ATIME_SET=128,P9_SETATTR_MTIME_SET=256,P9_STAT_MODE_DIR=2147483648,P9_STAT_MODE_APPEND=1073741824,P9_STAT_MODE_EXCL=536870912,P9_STAT_MODE_MOUNT=268435456,P9_STAT_MODE_AUTH=134217728,P9_STAT_MODE_TMP=67108864,P9_STAT_MODE_SYMLINK=33554432,P9_STAT_MODE_LINK=16777216,P9_STAT_MODE_DEVICE= +8388608,P9_STAT_MODE_NAMED_PIPE=2097152,P9_STAT_MODE_SOCKET=1048576,P9_STAT_MODE_SETUID=524288,P9_STAT_MODE_SETGID=262144,P9_STAT_MODE_SETVTX=65536;const P9_LOCK_TYPE_RDLCK=0,P9_LOCK_TYPE_WRLCK=1,P9_LOCK_TYPE_UNLCK=2,P9_LOCK_TYPES=Object.freeze(["shared","exclusive","unlock"]),P9_LOCK_FLAGS_BLOCK=1,P9_LOCK_FLAGS_RECLAIM=2,P9_LOCK_SUCCESS=0,P9_LOCK_BLOCKED=1,P9_LOCK_ERROR=2,P9_LOCK_GRACE=3;var FID_NONE=-1,FID_INODE=1,FID_XATTR=2; +function Virtio9p(a,b,c){this.fs=a;this.bus=c;this.configspace_tagname=[104,111,115,116,57,112];this.configspace_taglen=this.configspace_tagname.length;this.VERSION="9P2000.L";this.msize=this.BLOCKSIZE=8192;this.replybuffer=new Uint8Array(2*this.msize);this.replybuffersize=0;this.fids=[];this.virtio=new VirtIO(b,{name:"virtio-9p",pci_id:48,device_id:4169,subsystem_device_id:9,common:{initial_port:43008,queues:[{size_supported:32,notify_offset:0}],features:[VIRTIO_9P_F_MOUNT_TAG,VIRTIO_F_VERSION_1, +VIRTIO_F_RING_EVENT_IDX,VIRTIO_F_RING_INDIRECT_DESC],on_driver_ok:()=>{}},notification:{initial_port:43264,single_handler:!1,handlers:[a=>{if(0!==a)dbg_assert(!1,"Virtio9P Notified for non-existent queue: "+a+" (expected queue_id of 0)");else{for(;this.virtqueue.has_request();)a=this.virtqueue.pop_request(),this.ReceiveRequest(a);this.virtqueue.notify_me_after(0)}}]},isr_status:{initial_port:42752},device_specific:{initial_port:42496,struct:[{bytes:2,name:"mount tag length",read:()=>this.configspace_taglen, +write:a=>{}}].concat(v86util.range(VIRTIO_9P_MAX_TAGLEN).map(a=>({bytes:1,name:"mount tag name "+a,read:()=>this.configspace_tagname[a]||0,write:a=>{}})))}});this.virtqueue=this.virtio.queues[0]} +Virtio9p.prototype.get_state=function(){var a=[];a[0]=this.configspace_tagname;a[1]=this.configspace_taglen;a[2]=this.virtio;a[3]=this.VERSION;a[4]=this.BLOCKSIZE;a[5]=this.msize;a[6]=this.replybuffer;a[7]=this.replybuffersize;a[8]=this.fids.map(function(a){return[a.inodeid,a.type,a.uid,a.dbg_name]});a[9]=this.fs;return a}; +Virtio9p.prototype.set_state=function(a){this.configspace_tagname=a[0];this.configspace_taglen=a[1];this.virtio.set_state(a[2]);this.virtqueue=this.virtio.queues[0];this.VERSION=a[3];this.BLOCKSIZE=a[4];this.msize=a[5];this.replybuffer=a[6];this.replybuffersize=a[7];this.fids=a[8].map(function(a){return{inodeid:a[0],type:a[1],uid:a[2],dbg_name:a[3]}});this.fs.set_state(a[9])};Virtio9p.prototype.Createfid=function(a,b,c,d){return{inodeid:a,type:b,uid:c,dbg_name:d}}; +Virtio9p.prototype.update_dbg_name=function(a,b){for(const c of this.fids)c.inodeid===a&&(c.dbg_name=b)};Virtio9p.prototype.Reset=function(){this.fids=[]};Virtio9p.prototype.BuildReply=function(a,b,c){dbg_assert(0<=c,"9P: Negative payload size");marshall.Marshall(["w","b","h"],[c+7,a+1,b],this.replybuffer,0);c+7>=this.replybuffer.length&&message.Debug("Error in 9p: payloadsize exceeds maximum length");this.replybuffersize=c+7}; +Virtio9p.prototype.SendError=function(a,b,c){b=marshall.Marshall(["w"],[c],this.replybuffer,7);this.BuildReply(6,a,b)};Virtio9p.prototype.SendReply=function(a){dbg_assert(0<=this.replybuffersize,"9P: Negative replybuffersize");a.set_next_blob(this.replybuffer.subarray(0,this.replybuffersize));this.virtqueue.push_reply(a);this.virtqueue.flush_replies()}; +Virtio9p.prototype.ReceiveRequest=async function(a){var b=new Uint8Array(a.length_readable);a.get_next_blob(b);var c={offset:0},d=marshall.Unmarshall(["w","b","h"],b,c),e=d[0],f=d[1],k=d[2];switch(f){case 8:e=this.fs.GetTotalSize();b=this.fs.GetSpace();d=[16914839];d[1]=this.BLOCKSIZE;d[2]=Math.floor(b/d[1]);d[3]=d[2]-Math.floor(e/d[1]);d[4]=d[2]-Math.floor(e/d[1]);d[5]=this.fs.CountUsedInodes();d[6]=this.fs.CountFreeInodes();d[7]=0;d[8]=256;e=marshall.Marshall("wwddddddw".split(""),d,this.replybuffer, +7);this.BuildReply(f,k,e);this.SendReply(a);break;case 112:case 12:d=marshall.Unmarshall(["w","w"],b,c);var g=d[0];c=d[1];message.Debug("[open] fid="+g+", mode="+c);b=this.fids[g].inodeid;var l=this.fs.GetInode(b);message.Debug("file open "+this.fids[g].dbg_name);d=this.fs.OpenInode(b,c);this.fs.AddEvent(this.fids[g].inodeid,function(){message.Debug("file opened "+this.fids[g].dbg_name+" tag:"+k);var b=[];b[0]=l.qid;b[1]=this.msize-24;marshall.Marshall(["Q","w"],b,this.replybuffer,7);this.BuildReply(f, +k,17);this.SendReply(a)}.bind(this));break;case 70:d=marshall.Unmarshall(["w","w","s"],b,c);b=d[0];g=d[1];e=d[2];message.Debug("[link] dfid="+b+", name="+e);d=this.fs.Link(this.fids[b].inodeid,this.fids[g].inodeid,e);if(0>d){e="";d===-EPERM?e="Operation not permitted":(e="Unknown error: "+-d,dbg_assert(!1,"[link]: Unexpected error code: "+-d));this.SendError(k,e,-d);this.SendReply(a);break}this.BuildReply(f,k,0);this.SendReply(a);break;case 16:d=marshall.Unmarshall(["w","s","s","w"],b,c);g=d[0];e= +d[1];b=d[2];d=d[3];message.Debug("[symlink] fid="+g+", name="+e+", symgt="+b+", gid="+d);b=this.fs.CreateSymlink(e,this.fids[g].inodeid,b);l=this.fs.GetInode(b);l.uid=this.fids[g].uid;l.gid=d;marshall.Marshall(["Q"],[l.qid],this.replybuffer,7);this.BuildReply(f,k,13);this.SendReply(a);break;case 18:d=marshall.Unmarshall("wswwww".split(""),b,c);g=d[0];e=d[1];c=d[2];b=d[3];var m=d[4];d=d[5];message.Debug("[mknod] fid="+g+", name="+e+", major="+b+", minor="+m);b=this.fs.CreateNode(e,this.fids[g].inodeid, +b,m);l=this.fs.GetInode(b);l.mode=c;l.uid=this.fids[g].uid;l.gid=d;marshall.Marshall(["Q"],[l.qid],this.replybuffer,7);this.BuildReply(f,k,13);this.SendReply(a);break;case 22:d=marshall.Unmarshall(["w"],b,c);g=d[0];l=this.fs.GetInode(this.fids[g].inodeid);message.Debug("[readlink] fid="+g+" name="+this.fids[g].dbg_name+" target="+l.symlink);e=marshall.Marshall(["s"],[l.symlink],this.replybuffer,7);this.BuildReply(f,k,e);this.SendReply(a);break;case 72:d=marshall.Unmarshall(["w","s","w","w"],b,c); +g=d[0];e=d[1];c=d[2];d=d[3];message.Debug("[mkdir] fid="+g+", name="+e+", mode="+c+", gid="+d);b=this.fs.CreateDirectory(e,this.fids[g].inodeid);l=this.fs.GetInode(b);l.mode=c|S_IFDIR;l.uid=this.fids[g].uid;l.gid=d;marshall.Marshall(["Q"],[l.qid],this.replybuffer,7);this.BuildReply(f,k,13);this.SendReply(a);break;case 14:d=marshall.Unmarshall(["w","s","w","w","w"],b,c);g=d[0];e=d[1];b=d[2];c=d[3];d=d[4];this.bus.send("9p-create",[e,this.fids[g].inodeid]);message.Debug("[create] fid="+g+", name="+ +e+", flags="+b+", mode="+c+", gid="+d);b=this.fs.CreateFile(e,this.fids[g].inodeid);this.fids[g].inodeid=b;this.fids[g].type=FID_INODE;this.fids[g].dbg_name=e;l=this.fs.GetInode(b);l.uid=this.fids[g].uid;l.gid=d;l.mode=c;marshall.Marshall(["Q","w"],[l.qid,this.msize-24],this.replybuffer,7);this.BuildReply(f,k,17);this.SendReply(a);break;case 52:d=marshall.Unmarshall("wbwddws".split(""),b,c);g=d[0];b=d[2];e=0===d[4]?Infinity:d[4];e=this.fs.DescribeLock(d[1],d[3],e,d[5],d[6]);message.Debug("[lock] fid="+ +g+", type="+P9_LOCK_TYPES[e.type]+", start="+e.start+", length="+e.length+", proc_id="+e.proc_id);d=this.fs.Lock(this.fids[g].inodeid,e,b);marshall.Marshall(["b"],[d],this.replybuffer,7);this.BuildReply(f,k,1);this.SendReply(a);break;case 54:d=marshall.Unmarshall("wbddws".split(""),b,c);g=d[0];e=0===d[3]?Infinity:d[3];e=this.fs.DescribeLock(d[1],d[2],e,d[4],d[5]);message.Debug("[getlock] fid="+g+", type="+P9_LOCK_TYPES[e.type]+", start="+e.start+", length="+e.length+", proc_id="+e.proc_id);d=this.fs.GetLock(this.fids[g].inodeid, +e);d||(d=e,d.type=P9_LOCK_TYPE_UNLCK);e=marshall.Marshall(["b","d","d","w","s"],[d.type,d.start,Infinity===d.length?0:d.length,d.proc_id,d.client_id],this.replybuffer,7);this.BuildReply(f,k,e);this.SendReply(a);break;case 24:d=marshall.Unmarshall(["w","d"],b,c);g=d[0];l=this.fs.GetInode(this.fids[g].inodeid);message.Debug("[getattr]: fid="+g+" name="+this.fids[g].dbg_name+" request mask="+d[1]);if(!l||l.status===STATUS_UNLINKED){message.Debug("getattr: unlinked");this.SendError(k,"No such file or directory", +ENOENT);this.SendReply(a);break}d[0]|=4096;d[0]=d[1];d[1]=l.qid;d[2]=l.mode;d[3]=l.uid;d[4]=l.gid;d[5]=l.nlinks;d[6]=l.major<<8|l.minor;d[7]=l.size;d[8]=this.BLOCKSIZE;d[9]=Math.floor(l.size/512+1);d[10]=l.atime;d[11]=0;d[12]=l.mtime;d[13]=0;d[14]=l.ctime;d[15]=0;d[16]=0;d[17]=0;d[18]=0;d[19]=0;marshall.Marshall("dQwwwddddddddddddddd".split(""),d,this.replybuffer,7);this.BuildReply(f,k,153);this.SendReply(a);break;case 26:d=marshall.Unmarshall("wwwwwddddd".split(""),b,c);g=d[0];l=this.fs.GetInode(this.fids[g].inodeid); +message.Debug("[setattr]: fid="+g+" request mask="+d[1]+" name="+this.fids[g].dbg_name);d[1]&P9_SETATTR_MODE&&(l.mode=d[2]);d[1]&P9_SETATTR_UID&&(l.uid=d[3]);d[1]&P9_SETATTR_GID&&(l.gid=d[4]);d[1]&P9_SETATTR_ATIME&&(l.atime=Math.floor((new Date).getTime()/1E3));d[1]&P9_SETATTR_MTIME&&(l.mtime=Math.floor((new Date).getTime()/1E3));d[1]&P9_SETATTR_CTIME&&(l.ctime=Math.floor((new Date).getTime()/1E3));d[1]&P9_SETATTR_ATIME_SET&&(l.atime=d[6]);d[1]&P9_SETATTR_MTIME_SET&&(l.mtime=d[8]);d[1]&P9_SETATTR_SIZE&& +await this.fs.ChangeSize(this.fids[g].inodeid,d[5]);this.BuildReply(f,k,0);this.SendReply(a);break;case 50:d=marshall.Unmarshall(["w","d"],b,c);g=d[0];this.BuildReply(f,k,0);this.SendReply(a);break;case 40:case 116:d=marshall.Unmarshall(["w","d","w"],b,c);g=d[0];e=d[1];m=d[2];l=this.fs.GetInode(this.fids[g].inodeid);40==f&&message.Debug("[treaddir]: fid="+g+" offset="+e+" count="+m);116==f&&message.Debug("[read]: fid="+g+" ("+this.fids[g].dbg_name+") offset="+e+" count="+m+" fidtype="+this.fids[g].type); +if(!l||l.status===STATUS_UNLINKED){message.Debug("read/treaddir: unlinked");this.SendError(k,"No such file or directory",ENOENT);this.SendReply(a);break}if(this.fids[g].type==FID_XATTR)for(l.caps.lengthl.size&&(m=0),this.bus.send("9p-read-start",[this.fids[g].dbg_name]),d=await this.fs.Read(d, +e,m),this.bus.send("9p-read-end",[this.fids[g].dbg_name,m]),d&&this.replybuffer.set(d,11);marshall.Marshall(["w"],[m],this.replybuffer,7);this.BuildReply(f,k,4+m);this.SendReply(a);break;case 118:d=marshall.Unmarshall(["w","d","w"],b,c);g=d[0];e=d[1];m=d[2];d=this.fids[g].dbg_name;message.Debug("[write]: fid="+g+" ("+d+") offset="+e+" count="+m+" fidtype="+this.fids[g].type);if(this.fids[g].type===FID_XATTR){this.SendError(k,"Setxattr not supported",EOPNOTSUPP);this.SendReply(a);break}else await this.fs.Write(this.fids[g].inodeid, +e,m,b.subarray(c.offset));this.bus.send("9p-write-end",[d,m]);marshall.Marshall(["w"],[m],this.replybuffer,7);this.BuildReply(f,k,4);this.SendReply(a);break;case 74:d=marshall.Unmarshall(["w","s","w","s"],b,c);c=d[0];m=d[1];e=d[2];b=d[3];message.Debug("[renameat]: oldname="+m+" newname="+b);d=await this.fs.Rename(this.fids[c].inodeid,m,this.fids[e].inodeid,b);if(0>d){e="";d===-ENOENT?e="No such file or directory":d===-EPERM?e="Operation not permitted":d===-ENOTEMPTY?e="Directory not empty":(e="Unknown error: "+ +-d,dbg_assert(!1,"[renameat]: Unexpected error code: "+-d));this.SendError(k,e,-d);this.SendReply(a);break}TRACK_FILENAMES&&(d=this.fs.Search(this.fids[e].inodeid,b),this.update_dbg_name(d,b));this.BuildReply(f,k,0);this.SendReply(a);break;case 76:d=marshall.Unmarshall(["w","s","w"],b,c);c=d[0];e=d[1];b=d[2];message.Debug("[unlink]: dirfd="+c+" name="+e+" flags="+b);g=this.fs.Search(this.fids[c].inodeid,e);if(-1==g){this.SendError(k,"No such file or directory",ENOENT);this.SendReply(a);break}d=this.fs.Unlink(this.fids[c].inodeid, +e);if(0>d){e="";d===-ENOTEMPTY?e="Directory not empty":d===-EPERM?e="Operation not permitted":(e="Unknown error: "+-d,dbg_assert(!1,"[unlink]: Unexpected error code: "+-d));this.SendError(k,e,-d);this.SendReply(a);break}this.BuildReply(f,k,0);this.SendReply(a);break;case 100:d=marshall.Unmarshall(["w","s"],b,c);message.Debug("[version]: msize="+d[0]+" version="+d[1]);this.msize=d[0];e=marshall.Marshall(["w","s"],[this.msize,this.VERSION],this.replybuffer,7);this.BuildReply(f,k,e);this.SendReply(a); +break;case 104:d=marshall.Unmarshall(["w","w","s","s","w"],b,c);g=d[0];e=d[4];message.Debug("[attach]: fid="+g+" afid="+hex8(d[1])+" uname="+d[2]+" aname="+d[3]);this.fids[g]=this.Createfid(0,FID_INODE,e,"");l=this.fs.GetInode(this.fids[g].inodeid);marshall.Marshall(["Q"],[l.qid],this.replybuffer,7);this.BuildReply(f,k,13);this.SendReply(a);break;case 108:d=marshall.Unmarshall(["h"],b,c);message.Debug("[flush] "+k);this.BuildReply(f,k,0);this.SendReply(a);break;case 110:d=marshall.Unmarshall(["w", +"w","h"],b,c);g=d[0];m=d[1];var n=d[2];message.Debug("[walk]: fid="+d[0]+" nwfid="+d[1]+" nwname="+n);if(0==n){this.fids[m]=this.Createfid(this.fids[g].inodeid,FID_INODE,this.fids[g].uid,this.fids[g].dbg_name);marshall.Marshall(["h"],[0],this.replybuffer,7);this.BuildReply(f,k,2);this.SendReply(a);break}e=[];for(d=0;db;b++)this.ports[b]=this.create_empty_entry();var c=a.memory_size[0];for(b=0;b<>>32-c|0};c||(c=f.bind(this,8));d||(d=f.bind(this,16));e||(e=f.bind(this,32))}c&&(this.ports[a].read8=c);d&&(this.ports[a].read16=d);e&&(this.ports[a].read32= +e);this.ports[a].device=b}; +IO.prototype.register_write=function(a,b,c,d,e){dbg_assert("number"===typeof a);dbg_assert("object"===typeof b);dbg_assert(!c||"function"===typeof c);dbg_assert(!d||"function"===typeof d);dbg_assert(!e||"function"===typeof e);dbg_assert(c||d||e);if(DEBUG){var f=function(c){dbg_assert(!1,"Overlapped write"+c+" "+h(a)+" ("+b.name+")")};c||(c=f.bind(this,8));d||(d=f.bind(this,16));e||(e=f.bind(this,32))}c&&(this.ports[a].write8=c);d&&(this.ports[a].write16=d);e&&(this.ports[a].write32=e);this.ports[a].device= +b};IO.prototype.register_read_consecutive=function(a,b,c,d,e,f){function k(){return c.call(this)|d.call(this)<<8}function g(){return e.call(this)|f.call(this)<<8}function l(){return c.call(this)|d.call(this)<<8|e.call(this)<<16|f.call(this)<<24}dbg_assert(4===arguments.length||6===arguments.length);e&&f?(this.register_read(a,b,c,k,l),this.register_read(a+1,b,d),this.register_read(a+2,b,e,g),this.register_read(a+3,b,f)):(this.register_read(a,b,c,k),this.register_read(a+1,b,d))}; +IO.prototype.register_write_consecutive=function(a,b,c,d,e,f){function k(a){c.call(this,a&255);d.call(this,a>>8&255)}function g(a){e.call(this,a&255);f.call(this,a>>8&255)}function l(a){c.call(this,a&255);d.call(this,a>>8&255);e.call(this,a>>16&255);f.call(this,a>>>24)}dbg_assert(4===arguments.length||6===arguments.length);e&&f?(this.register_write(a,b,c,k,l),this.register_write(a+1,b,d),this.register_write(a+2,b,e,g),this.register_write(a+3,b,f)):(this.register_write(a,b,c,k),this.register_write(a+ +1,b,d))};IO.prototype.mmap_read32_shim=function(a){var b=this.cpu.memory_map_read8[a>>>MMAP_BLOCK_BITS];return b(a)|b(a+1)<<8|b(a+2)<<16|b(a+3)<<24};IO.prototype.mmap_write32_shim=function(a,b){var c=this.cpu.memory_map_write8[a>>>MMAP_BLOCK_BITS];c(a,b&255);c(a+1,b>>8&255);c(a+2,b>>16&255);c(a+3,b>>>24)}; +IO.prototype.mmap_register=function(a,b,c,d,e,f){dbg_log("mmap_register addr="+h(a>>>0,8)+" size="+h(b,8),LOG_IO);dbg_assert(0===(a&MMAP_BLOCK_SIZE-1));dbg_assert(b&&0===(b&MMAP_BLOCK_SIZE-1));e||(e=this.mmap_read32_shim.bind(this));f||(f=this.mmap_write32_shim.bind(this));for(a>>>=MMAP_BLOCK_BITS;0>>0,8)+this.get_port_description(a),LOG_IO);return c.write32.call(c.device,b)};IO.prototype.port_read8=function(a){var b=this.ports[a];(b.read8===this.empty_port_read8||LOG_ALL_IO)&&dbg_log("read8 port #"+h(a,4)+this.get_port_description(a),LOG_IO);b=b.read8.call(b.device);dbg_assert(256>b,"8 bit port returned large value: "+h(a));return b}; +IO.prototype.port_read16=function(a){var b=this.ports[a];(b.read16===this.empty_port_read16||LOG_ALL_IO)&&dbg_log("read16 port #"+h(a,4)+this.get_port_description(a),LOG_IO);b=b.read16.call(b.device);dbg_assert(65536>b&&0<=b,"16 bit port returned large value: "+h(a));return b}; +IO.prototype.port_read32=function(a){var b=this.ports[a];(b.read32===this.empty_port_read32||LOG_ALL_IO)&&dbg_log("read32 port #"+h(a,4)+this.get_port_description(a),LOG_IO);a=b.read32.call(b.device);dbg_assert((a|0)===a);return a}; +var debug_port_list={4:"PORT_DMA_ADDR_2",5:"PORT_DMA_CNT_2",10:"PORT_DMA1_MASK_REG",11:"PORT_DMA1_MODE_REG",12:"PORT_DMA1_CLEAR_FF_REG",13:"PORT_DMA1_MASTER_CLEAR",32:"PORT_PIC1_CMD",33:"PORT_PIC1_DATA",64:"PORT_PIT_COUNTER0",65:"PORT_PIT_COUNTER1",66:"PORT_PIT_COUNTER2",67:"PORT_PIT_MODE",96:"PORT_PS2_DATA",97:"PORT_PS2_CTRLB",100:"PORT_PS2_STATUS",112:"PORT_CMOS_INDEX",113:"PORT_CMOS_DATA",128:"PORT_DIAG",129:"PORT_DMA_PAGE_2",146:"PORT_A20",160:"PORT_PIC2_CMD",161:"PORT_PIC2_DATA",178:"PORT_SMI_CMD", +179:"PORT_SMI_STATUS",212:"PORT_DMA2_MASK_REG",214:"PORT_DMA2_MODE_REG",218:"PORT_DMA2_MASTER_CLEAR",240:"PORT_MATH_CLEAR",368:"PORT_ATA2_CMD_BASE",496:"PORT_ATA1_CMD_BASE",632:"PORT_LPT2",744:"PORT_SERIAL4",760:"PORT_SERIAL2",884:"PORT_ATA2_CTRL_BASE",888:"PORT_LPT1",1E3:"PORT_SERIAL3",1008:"PORT_FD_BASE",1010:"PORT_FD_DOR",1012:"PORT_FD_STATUS",1013:"PORT_FD_DATA",1014:"PORT_HD_DATA",1015:"PORT_FD_DIR",1016:"PORT_SERIAL1",3320:"PORT_PCI_CMD",3321:"PORT_PCI_REBOOT",3324:"PORT_PCI_DATA",1026:"PORT_BIOS_DEBUG", +1296:"PORT_QEMU_CFG_CTL",1297:"PORT_QEMU_CFG_DATA",45056:"PORT_ACPI_PM_BASE",45312:"PORT_SMB_BASE",35072:"PORT_BIOS_APM"};IO.prototype.get_port_description=function(a){return debug_port_list[a]?" ("+debug_port_list[a]+")":""};function v86(a,b){this.stopped=this.running=!1;this.cpu=new CPU(a,b);this.bus=a;a.register("cpu-init",this.init,this);a.register("cpu-run",this.run,this);a.register("cpu-stop",this.stop,this);a.register("cpu-restart",this.restart,this);this.register_tick()}v86.prototype.run=function(){this.stopped=!1;this.running||(this.bus.send("emulator-started"),this.fast_next_tick())}; +v86.prototype.do_tick=function(){if(this.stopped)this.stopped=this.running=!1,this.bus.send("emulator-stopped");else{this.running=!0;var a=this.cpu.main_run();0>=a?this.fast_next_tick():this.next_tick(a)}};v86.prototype.stop=function(){this.running&&(this.stopped=!0)};v86.prototype.destroy=function(){this.unregister_tick()};v86.prototype.restart=function(){this.cpu.reset();this.cpu.load_bios()};v86.prototype.init=function(a){this.cpu.init(a,this.bus);this.bus.send("emulator-ready")}; +if("undefined"!==typeof setImmediate)var fast_next_tick=function(){setImmediate(()=>{this.do_tick()})},register_tick=function(){},unregister_tick=function(){};else if("undefined"!==typeof window&&"undefined"!==typeof postMessage){fast_next_tick=function(){window.postMessage(43605,"*")};let a;register_tick=function(){a=a=>{a.source===window&&43605===a.data&&this.do_tick()};window.addEventListener("message",a,!1)};unregister_tick=function(){window.removeEventListener("message",a);a=null}}else fast_next_tick= +function(){setTimeout(()=>{this.do_tick()},0)},register_tick=function(){},unregister_tick=function(){};v86.prototype.fast_next_tick=fast_next_tick;v86.prototype.register_tick=register_tick;v86.prototype.unregister_tick=unregister_tick;var next_tick="undefined"!==typeof document&&"boolean"===typeof document.hidden?function(a){4>a||document.hidden?this.fast_next_tick():setTimeout(()=>{this.do_tick()},a)}:function(a){setTimeout(()=>{this.do_tick()},a)};v86.prototype.next_tick=next_tick; +v86.prototype.save_state=function(){return this.cpu.save_state()};v86.prototype.restore_state=function(a){return this.cpu.restore_state(a)};if("object"===typeof performance&&performance.now)v86.microtick=performance.now.bind(performance);else if("function"===typeof require){const {performance:a}=require("perf_hooks");v86.microtick=a.now.bind(a)}else v86.microtick="object"===typeof process&&process.hrtime?function(){var a=process.hrtime();return 1E3*a[0]+a[1]/1E6}:Date.now;var goog=goog||{};goog.exportSymbol=function(){};goog.exportProperty=function(){};var v86util=v86util||{};v86util.pads=function(a,b){return(a||0===a?a+"":"").padEnd(b," ")};v86util.pad0=function(a,b){return(a||0===a?a+"":"").padStart(b,"0")};v86util.zeros=function(a){return Array(a).fill(0)};v86util.range=function(a){return Array.from(Array(a).keys())}; +v86util.view=function(a,b,c,d){return new Proxy({},{get:function(e,f,k){e=new a(b.buffer,c,d);k=e[f];if("function"===typeof k)return k.bind(e);dbg_assert(/^\d+$/.test(f)||"buffer"===f||"length"===f||"BYTES_PER_ELEMENT"===f||"byteOffset"===f);return k},set:function(e,f,k,g){dbg_assert(/^\d+$/.test(f));(new a(b.buffer,c,d))[f]=k;return!0}})};function h(a,b){a=a?a.toString(16):"";return"0x"+v86util.pad0(a.toUpperCase(),b||1)} +if("undefined"!==typeof crypto&&crypto.getRandomValues){let a=new Int32Array(1);v86util.get_rand_int=function(){crypto.getRandomValues(a);return a[0]}}else if("undefined"!==typeof require){const a=require("crypto");v86util.get_rand_int=function(){return a.randomBytes(4).readInt32LE(0)}}else dbg_assert(!1,"Unsupported platform: No cryptographic random values");function SyncBuffer(a){dbg_assert(a instanceof ArrayBuffer);this.buffer=a;this.byteLength=a.byteLength;this.onprogress=this.onload=void 0} +SyncBuffer.prototype.load=function(){this.onload&&this.onload({buffer:this.buffer})};SyncBuffer.prototype.get=function(a,b,c){dbg_assert(a+b<=this.byteLength);c(new Uint8Array(this.buffer,a,b))};SyncBuffer.prototype.set=function(a,b,c){dbg_assert(a+b.byteLength<=this.byteLength);(new Uint8Array(this.buffer,a,b.byteLength)).set(b);c()};SyncBuffer.prototype.get_buffer=function(a){a(this.buffer)}; +SyncBuffer.prototype.get_state=function(){const a=[];a[0]=this.byteLength;a[1]=new Uint8Array(this.buffer);return a};SyncBuffer.prototype.set_state=function(a){this.byteLength=a[0];this.buffer=a[1].slice().buffer}; +(function(){if("function"===typeof Math.clz32)v86util.int_log2_byte=function(a){dbg_assert(0a);return 31-Math.clz32(a)},v86util.int_log2=function(a){dbg_assert(0b;b++)b&b-1||c++,a[b]=c;v86util.int_log2_byte=function(b){dbg_assert(0b);return a[b]};v86util.int_log2=function(b){b>>>=0;dbg_assert(0>>16;if(c){var d=c>>>8;return d?24+a[d]:16+a[c]}return(d=b>>>8)?8+a[d]:a[b]}}})(); +function ByteQueue(a){var b=new Uint8Array(a),c,d;dbg_assert(0===(a&a-1));this.length=0;this.push=function(c){this.length!==a&&this.length++;b[d]=c;d=d+1&a-1};this.shift=function(){if(this.length){var d=b[c];c=c+1&a-1;this.length--;return d}return-1};this.peek=function(){return this.length?b[c]:-1};this.clear=function(){this.length=d=c=0};this.clear()}function FloatQueue(a){this.size=a;this.data=new Float32Array(a);this.length=this.end=this.start=0;dbg_assert(0===(a&a-1))} +FloatQueue.prototype.push=function(a){this.length===this.size?this.start=this.start+1&this.size-1:this.length++;this.data[this.end]=a;this.end=this.end+1&this.size-1};FloatQueue.prototype.shift=function(){if(this.length){var a=this.data[this.start];this.start=this.start+1&this.size-1;this.length--;return a}}; +FloatQueue.prototype.shift_block=function(a){var b=new Float32Array(a);a>this.length&&(a=this.length);var c=this.start+a,d=this.data.subarray(this.start,c);b.set(d);c>=this.size&&(c-=this.size,b.set(this.data.subarray(0,c),d.length));this.start=c;this.length-=a;return b};FloatQueue.prototype.peek=function(){if(this.length)return this.data[this.start]};FloatQueue.prototype.clear=function(){this.length=this.end=this.start=0};function CircularQueue(a){this.data=[];this.index=0;this.size=a} +CircularQueue.prototype.add=function(a){this.data[this.index]=a;this.index=(this.index+1)%this.size};CircularQueue.prototype.toArray=function(){return[].slice.call(this.data,this.index).concat([].slice.call(this.data,0,this.index))};CircularQueue.prototype.clear=function(){this.data=[];this.index=0};CircularQueue.prototype.set=function(a){this.data=a;this.index=0};function dump_file(a,b){a instanceof Array||(a=[a]);a=new Blob(a);download(a,b)} +function download(a,b){var c=document.createElement("a");c.download=b;c.href=window.URL.createObjectURL(a);c.dataset.downloadurl=["application/octet-stream",c.download,c.href].join(":");document.createEvent?(a=document.createEvent("MouseEvent"),a.initMouseEvent("click",!0,!0,window,0,0,0,0,0,!1,!1,!1,!1,0,null),c.dispatchEvent(a)):c.click();window.URL.revokeObjectURL(c.href)} +v86util.Bitmap=function(a){"number"===typeof a?this.view=new Uint8Array(a+7>>3):a instanceof ArrayBuffer?this.view=new Uint8Array(a):console.assert(!1)};v86util.Bitmap.prototype.set=function(a,b){const c=a>>3;a=1<<(a&7);this.view[c]=b?this.view[c]|a:this.view[c]&~a};v86util.Bitmap.prototype.get=function(a){return this.view[a>>3]>>(a&7)&1};v86util.Bitmap.prototype.get_buffer=function(){return this.view.buffer};function hex_dump(a,b){var c=[];b=b||a.byteLength;for(var d,e,f=0;f>4;f++){d=h(f<<4,5)+" ";for(var k=0;16>k;k++)e=a[(f<<4)+k],d+=h(e,2)+" ";d+=" ";for(k=0;16>k;k++)e=a[(f<<4)+k],d+=33>e||126>8,0,0,0,0,0,0,0,0,0,0,67,16,212,130,0,0,0,0,0,0,0,0,0,0,0,0,this.irq,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];this.pci_bars=[{size:8},{size:4},void 0,void 0,{size:16}];this.name="ide"+e;this.device_control=2;a.io.register_read(this.ata_port|7,this,function(){dbg_log("lower irq",LOG_DISK);this.cpu.device_lower_irq(this.irq); +return this.read_status()});a.io.register_read(this.ata_port_high|2,this,this.read_status);a.io.register_write(this.ata_port_high|2,this,this.write_control);a.io.register_read(this.ata_port|0,this,function(){return this.current_interface.read_data(1)},function(){return this.current_interface.read_data(2)},function(){return this.current_interface.read_data(4)});a.io.register_read(this.ata_port|1,this,function(){dbg_log("Read error: "+h(this.current_interface.error&255)+" slave="+(this.current_interface=== +this.slave),LOG_DISK);return this.current_interface.error&255});a.io.register_read(this.ata_port|2,this,function(){dbg_log("Read bytecount: "+h(this.current_interface.bytecount&255),LOG_DISK);return this.current_interface.bytecount&255});a.io.register_read(this.ata_port|3,this,function(){dbg_log("Read sector: "+h(this.current_interface.sector&255),LOG_DISK);return this.current_interface.sector&255});a.io.register_read(this.ata_port|4,this,function(){dbg_log("Read 1F4: "+h(this.current_interface.cylinder_low& +255),LOG_DISK);return this.current_interface.cylinder_low&255});a.io.register_read(this.ata_port|5,this,function(){dbg_log("Read 1F5: "+h(this.current_interface.cylinder_high&255),LOG_DISK);return this.current_interface.cylinder_high&255});a.io.register_read(this.ata_port|6,this,function(){dbg_log("Read 1F6",LOG_DISK);return this.current_interface.drive_head&255});a.io.register_write(this.ata_port|0,this,function(a){this.current_interface.write_data_port8(a)},function(a){this.current_interface.write_data_port16(a)}, +function(a){this.current_interface.write_data_port32(a)});a.io.register_write(this.ata_port|1,this,function(a){dbg_log("1F1/lba_count: "+h(a),LOG_DISK);this.master.lba_count=(this.master.lba_count<<8|a)&65535;this.slave.lba_count=(this.slave.lba_count<<8|a)&65535});a.io.register_write(this.ata_port|2,this,function(a){dbg_log("1F2/bytecount: "+h(a),LOG_DISK);this.master.bytecount=(this.master.bytecount<<8|a)&65535;this.slave.bytecount=(this.slave.bytecount<<8|a)&65535});a.io.register_write(this.ata_port| +3,this,function(a){dbg_log("1F3/sector: "+h(a),LOG_DISK);this.master.sector=(this.master.sector<<8|a)&65535;this.slave.sector=(this.slave.sector<<8|a)&65535});a.io.register_write(this.ata_port|4,this,function(a){dbg_log("1F4/sector low: "+h(a),LOG_DISK);this.master.cylinder_low=(this.master.cylinder_low<<8|a)&65535;this.slave.cylinder_low=(this.slave.cylinder_low<<8|a)&65535});a.io.register_write(this.ata_port|5,this,function(a){dbg_log("1F5/sector high: "+h(a),LOG_DISK);this.master.cylinder_high= +(this.master.cylinder_high<<8|a)&65535;this.slave.cylinder_high=(this.slave.cylinder_high<<8|a)&65535});a.io.register_write(this.ata_port|6,this,function(a){var b=a&16;dbg_log("1F6/drive: "+h(a,2),LOG_DISK);b?(dbg_log("Slave",LOG_DISK),this.current_interface=this.slave):this.current_interface=this.master;this.master.drive_head=a;this.slave.drive_head=a;this.master.is_lba=this.slave.is_lba=a>>6&1;this.master.head=this.slave.head=a&15});this.dma_command=this.dma_status=this.prdt_addr=0;a.io.register_write(this.ata_port| +7,this,function(a){dbg_log("lower irq",LOG_DISK);this.cpu.device_lower_irq(this.irq);this.current_interface.ata_command(a)});a.io.register_read(this.master_port|4,this,void 0,void 0,this.dma_read_addr);a.io.register_write(this.master_port|4,this,void 0,void 0,this.dma_set_addr);a.io.register_read(this.master_port,this,this.dma_read_command8,void 0,this.dma_read_command);a.io.register_write(this.master_port,this,this.dma_write_command8,void 0,this.dma_write_command);a.io.register_read(this.master_port| +2,this,this.dma_read_status);a.io.register_write(this.master_port|2,this,this.dma_write_status);a.io.register_read(this.master_port|8,this,function(){dbg_log("DMA read 0x8",LOG_DISK);return 0});a.io.register_read(this.master_port|10,this,function(){dbg_log("DMA read 0xA",LOG_DISK);return 0});a.devices.pci.register_device(this);DEBUG&&Object.seal(this)} +IDEDevice.prototype.read_status=function(){if(this.current_interface.buffer){var a=this.current_interface.status;dbg_log("ATA read status: "+h(a,2),LOG_DISK);return a}return 0};IDEDevice.prototype.write_control=function(a){dbg_log("set device control: "+h(a,2)+" interrupts "+(a&2?"disabled":"enabled"),LOG_DISK);a&4&&(dbg_log("Reset via control port",LOG_DISK),this.cpu.device_lower_irq(this.irq),this.master.device_reset(),this.slave.device_reset());this.device_control=a}; +IDEDevice.prototype.dma_read_addr=function(){dbg_log("dma get address: "+h(this.prdt_addr,8),LOG_DISK);return this.prdt_addr};IDEDevice.prototype.dma_set_addr=function(a){dbg_log("dma set address: "+h(a,8),LOG_DISK);this.prdt_addr=a};IDEDevice.prototype.dma_read_status=function(){dbg_log("DMA read status: "+h(this.dma_status),LOG_DISK);return this.dma_status};IDEDevice.prototype.dma_write_status=function(a){dbg_log("DMA set status: "+h(a),LOG_DISK);this.dma_status&=~(a&6)}; +IDEDevice.prototype.dma_read_command=function(){return this.dma_read_command8()|this.dma_read_status()<<16};IDEDevice.prototype.dma_read_command8=function(){dbg_log("DMA read command: "+h(this.dma_command),LOG_DISK);return this.dma_command};IDEDevice.prototype.dma_write_command=function(a){dbg_log("DMA write command: "+h(a),LOG_DISK);this.dma_write_command8(a&255);this.dma_write_status(a>>16&255)}; +IDEDevice.prototype.dma_write_command8=function(a){dbg_log("DMA write command8: "+h(a),LOG_DISK);let b=this.dma_command;this.dma_command=a&9;if((b&1)!==(a&1))if(0===(a&1))this.dma_status&=-2;else switch(this.dma_status|=1,this.current_interface.current_command){case 37:case 200:this.current_interface.do_ata_read_sectors_dma();break;case 202:case 53:this.current_interface.do_ata_write_sectors_dma();break;case 160:this.current_interface.do_atapi_dma();break;default:dbg_log("Spurious dma command write, current command: "+ +h(this.current_interface.current_command),LOG_DISK),dbg_assert(!1)}};IDEDevice.prototype.push_irq=function(){0===(this.device_control&2)&&(dbg_log("push irq",LOG_DISK),this.dma_status|=4,this.cpu.device_raise_irq(this.irq))}; +IDEDevice.prototype.get_state=function(){var a=[];a[0]=this.master;a[1]=this.slave;a[2]=this.ata_port;a[3]=this.irq;a[4]=this.pci_id;a[5]=this.ata_port_high;a[6]=this.master_port;a[7]=this.name;a[8]=this.device_control;a[9]=this.prdt_addr;a[10]=this.dma_status;a[11]=this.current_interface===this.master;a[12]=this.dma_command;return a}; +IDEDevice.prototype.set_state=function(a){this.master.set_state(a[0]);this.slave.set_state(a[1]);this.ata_port=a[2];this.irq=a[3];this.pci_id=a[4];this.ata_port_high=a[5];this.master_port=a[6];this.name=a[7];this.device_control=a[8];this.prdt_addr=a[9];this.dma_status=a[10];this.current_interface=a[11]?this.master:this.slave;this.dma_command=a[12]}; +function IDEInterface(a,b,c,d,e,f,k){this.device=a;this.bus=k;this.nr=e;this.cpu=b;this.buffer=c;this.sector_size=d?CDROM_SECTOR_SIZE:HD_SECTOR_SIZE;this.is_atapi=d;this.cylinder_count=this.sectors_per_track=this.head_count=this.sector_count=0;this.buffer&&(this.sector_count=this.buffer.byteLength/this.sector_size,this.sector_count!==(this.sector_count|0)&&(dbg_log("Warning: Disk size not aligned with sector size",LOG_DISK),this.sector_count=Math.ceil(this.sector_count)),d?(this.head_count=1,this.sectors_per_track= +0):(this.head_count=16,this.sectors_per_track=63),this.cylinder_count=this.sector_count/this.head_count/this.sectors_per_track,this.cylinder_count!==(this.cylinder_count|0)&&(dbg_log("Warning: Rounding up cylinder count. Choose different head number",LOG_DISK),this.cylinder_count=Math.floor(this.cylinder_count)),a=b.devices.rtc,a.cmos_write(CMOS_BIOS_DISKTRANSFLAG,a.cmos_read(CMOS_BIOS_DISKTRANSFLAG)|1<<4*this.nr),a.cmos_write(CMOS_DISK_DATA,a.cmos_read(CMOS_DISK_DATA)&15|240),b=CMOS_DISK_DRIVE1_CYL, +a.cmos_write(b+0,this.cylinder_count&255),a.cmos_write(b+1,this.cylinder_count>>8&255),a.cmos_write(b+2,this.head_count&255),a.cmos_write(b+3,255),a.cmos_write(b+4,255),a.cmos_write(b+5,200),a.cmos_write(b+6,this.cylinder_count&255),a.cmos_write(b+7,this.cylinder_count>>8&255),a.cmos_write(b+8,this.sectors_per_track&255));this.stats={sectors_read:0,sectors_written:0,bytes_read:0,bytes_written:0,loading:!1};this.buffer=c;this.drive_head=this.head=this.cylinder_high=this.cylinder_low=this.lba_count= +this.sector=this.bytecount=this.is_lba=0;this.status=80;this.sectors_per_drq=128;this.data_pointer=this.error=0;this.data=new Uint8Array(65536);this.data16=new Uint16Array(this.data.buffer);this.data32=new Int32Array(this.data.buffer);this.data_end=this.data_length=0;this.current_atapi_command=this.current_command=-1;this.last_io_id=this.write_dest=0;this.in_progress_io_ids=new Set;this.cancelled_io_ids=new Set;Object.seal(this)} +IDEInterface.prototype.device_reset=function(){this.is_atapi?(this.status=0,this.sector=this.error=this.bytecount=1,this.cylinder_low=20,this.cylinder_high=235):(this.status=81,this.sector=this.error=this.bytecount=1,this.cylinder_high=this.cylinder_low=0);this.cancel_io_operations()};IDEInterface.prototype.push_irq=function(){this.device.push_irq()}; +IDEInterface.prototype.ata_command=function(a){dbg_log("ATA Command: "+h(a)+" slave="+(this.drive_head>>4&1),LOG_DISK);if(this.buffer)switch(this.current_command=a,this.error=0,a){case 8:dbg_log("ATA device reset",LOG_DISK);this.data_length=this.data_end=this.data_pointer=0;this.device_reset();this.push_irq();break;case 16:this.status=80;this.cylinder_low=0;this.push_irq();break;case 248:this.status=80;a=this.sector_count-1;this.sector=a&255;this.cylinder_low=a>>8&255;this.cylinder_high=a>>16&255; +this.drive_head=this.drive_head&240|a>>24&15;this.push_irq();break;case 39:this.status=80;a=this.sector_count-1;this.sector=a&255;this.cylinder_low=a>>8&255;this.cylinder_high=a>>16&255;this.sector|=a>>24<<8&65280;this.push_irq();break;case 32:case 36:case 41:case 196:this.ata_read_sectors(a);break;case 48:case 52:case 57:case 197:this.ata_write_sectors(a);break;case 144:this.push_irq();this.error=257;this.status=80;break;case 145:this.status=80;this.push_irq();break;case 160:this.is_atapi&&(this.status= +88,this.data_allocate(12),this.data_end=12,this.bytecount=1,this.push_irq());break;case 161:dbg_log("ATA identify packet device",LOG_DISK);this.is_atapi?(this.create_identify_packet(),this.status=88,this.cylinder_low=20,this.cylinder_high=235):this.status=65;this.push_irq();break;case 198:dbg_log("Logical sectors per DRQ Block: "+h(this.bytecount&255),LOG_DISK);this.sectors_per_drq=this.bytecount&255;this.status=80;this.push_irq();break;case 37:case 200:this.ata_read_sectors_dma(a);break;case 53:case 202:this.ata_write_sectors_dma(a); +break;case 64:dbg_log("read verify sectors",LOG_DISK);this.status=80;this.push_irq();break;case 218:dbg_log("Unimplemented: get media status",LOG_DISK);this.status=65;this.error=4;this.push_irq();break;case 224:dbg_log("ATA standby immediate",LOG_DISK);this.status=80;this.push_irq();break;case 225:dbg_log("ATA idle immediate",LOG_DISK);this.status=80;this.push_irq();break;case 231:dbg_log("ATA flush cache",LOG_DISK);this.status=80;this.push_irq();break;case 236:dbg_log("ATA identify device",LOG_DISK); +if(this.is_atapi){this.status=65;this.error=4;this.push_irq();break}this.create_identify_packet();this.status=88;this.push_irq();break;case 234:dbg_log("flush cache ext",LOG_DISK);this.status=80;this.push_irq();break;case 239:dbg_log("set features: "+h(this.bytecount&255),LOG_DISK);this.status=80;this.push_irq();break;case 245:dbg_log("security freeze lock",LOG_DISK);this.status=80;this.push_irq();break;case 249:dbg_log("Unimplemented: set max address",LOG_DISK);this.status=65;this.error=4;break; +default:dbg_assert(!1,"New ATA cmd on 1F7: "+h(a),LOG_DISK),this.status=65,this.error=4}else dbg_log("abort: No buffer",LOG_DISK),this.error=4,this.status=65,this.push_irq()}; +IDEInterface.prototype.atapi_handle=function(){dbg_log("ATAPI Command: "+h(this.data[0])+" slave="+(this.drive_head>>4&1),LOG_DISK);this.data_pointer=0;this.current_atapi_command=this.data[0];switch(this.current_atapi_command){case 0:dbg_log("test unit ready",LOG_DISK);this.data_allocate(0);this.data_end=this.data_length;this.status=80;break;case 3:this.data_allocate(this.data[4]);this.data_end=this.data_length;this.status=88;this.data[0]=240;this.data[2]=5;this.data[7]=8;break;case 18:var a=this.data[4]; +this.status=88;dbg_log("inquiry: "+h(this.data[1],2)+" length="+a,LOG_DISK);this.data.set([5,128,1,49,31,0,0,0,83,79,78,89,32,32,32,32,67,68,45,82,79,77,32,67,68,85,45,49,48,48,48,32,49,46,49,97]);this.data_end=this.data_length=Math.min(36,a);break;case 26:this.data_allocate(this.data[4]);this.data_end=this.data_length;this.status=88;break;case 30:this.data_allocate(0);this.data_end=this.data_length;this.status=80;break;case 37:a=this.sector_count-1;this.data_set(new Uint8Array([a>>24&255,a>>16&255, +a>>8&255,a&255,0,0,this.sector_size>>8&255,this.sector_size&255]));this.data_end=this.data_length;this.status=88;break;case 40:this.lba_count&1?this.atapi_read_dma(this.data):this.atapi_read(this.data);break;case 66:a=this.data[8];this.data_allocate(Math.min(8,a));this.data_end=this.data_length;dbg_log("read q subcode: length="+a,LOG_DISK);this.status=88;break;case 67:a=this.data[8]|this.data[7]<<8;var b=this.data[9]>>6;this.data_allocate(a);this.data_end=this.data_length;dbg_log("read toc: "+h(b, +2)+" length="+a+" "+(this.data[1]&2)+" "+h(this.data[6]),LOG_DISK);0===b?(a=this.sector_count,this.data.set(new Uint8Array([0,18,1,1,0,20,1,0,0,0,0,0,0,22,170,0,a>>24,a>>16&255,a>>8&255,a&255]))):1===b?this.data.set(new Uint8Array([0,10,1,1,0,0,0,0,0,0,0,0])):dbg_assert(!1,"Unimplemented format: "+b);this.status=88;break;case 70:a=this.data[8]|this.data[7]<<8;a=Math.min(a,32);this.data_allocate(a);this.data_end=this.data_length;this.data[0]=a-4>>24&255;this.data[1]=a-4>>16&255;this.data[2]=a-4>>8& +255;this.data[3]=a-4&255;this.data[6]=8;this.data[10]=3;this.status=88;break;case 81:this.data_allocate(0);this.data_end=this.data_length;this.status=80;break;case 82:dbg_log("Unimplemented ATAPI command: "+h(this.data[0]),LOG_DISK);this.status=81;this.data_length=0;this.error=80;break;case 90:a=this.data[8]|this.data[7]<<8;b=this.data[2];dbg_log("mode sense: "+h(b)+" length="+a,LOG_DISK);42===b&&this.data_allocate(Math.min(30,a));this.data_end=this.data_length;this.status=88;break;case 189:this.data_allocate(this.data[9]| +this.data[8]<<8);this.data_end=this.data_length;this.data[5]=1;this.status=88;break;case 74:this.status=81;this.data_length=0;this.error=80;dbg_log("Unimplemented ATAPI command: "+h(this.data[0]),LOG_DISK);break;default:this.status=81,this.data_length=0,this.error=80,dbg_log("Unimplemented ATAPI command: "+h(this.data[0]),LOG_DISK),dbg_assert(!1)}this.bytecount=this.bytecount&-8|2;0===(this.status&128)&&this.push_irq();0===(this.status&128)&&0===this.data_length&&(this.bytecount|=1,this.status&=-9)}; +IDEInterface.prototype.do_write=function(){this.status=80;dbg_assert(this.data_length<=this.data.length);var a=this.data.subarray(0,this.data_length);dbg_assert(0===this.data_length%512);this.ata_advance(this.current_command,this.data_length/512);this.push_irq();this.buffer.set(this.write_dest,a,function(){});this.report_write(this.data_length)}; +IDEInterface.prototype.atapi_read=function(a){var b=a[2]<<24|a[3]<<16|a[4]<<8|a[5],c=a[7]<<8|a[8];a=a[1];var d=c*this.sector_size,e=b*this.sector_size;dbg_log("CD read lba="+h(b)+" lbacount="+h(c)+" bytecount="+h(d)+" flags="+h(a),LOG_DISK);this.data_length=0;var f=this.cylinder_high<<8&65280|this.cylinder_low&255;dbg_log(h(this.cylinder_high,2)+" "+h(this.cylinder_low,2),LOG_DISK);this.cylinder_low=this.cylinder_high=0;65535===f&&f--;f>d&&(f=d);e>=this.buffer.byteLength?(dbg_assert(!1,"CD read: Outside of disk end="+ +h(e+d)+" size="+h(this.buffer.byteLength),LOG_DISK),this.status=255,this.push_irq()):0===d?(this.status=80,this.data_pointer=0):(d=Math.min(d,this.buffer.byteLength-e),this.status=208,this.report_read_start(),this.read_buffer(e,d,a=>{dbg_log("cd read: data arrived",LOG_DISK);this.data_set(a);this.status=88;this.bytecount=this.bytecount&-8|2;this.push_irq();this.data_end=f&=-4;this.data_end>this.data_length&&(this.data_end=this.data_length);this.cylinder_low=this.data_end&255;this.cylinder_high=this.data_end>> +8&255;this.report_read_end(d)}))}; +IDEInterface.prototype.atapi_read_dma=function(a){var b=a[2]<<24|a[3]<<16|a[4]<<8|a[5],c=a[7]<<8|a[8];a=a[1];var d=c*this.sector_size,e=b*this.sector_size;dbg_log("CD read DMA lba="+h(b)+" lbacount="+h(c)+" bytecount="+h(d)+" flags="+h(a),LOG_DISK);e>=this.buffer.byteLength?(dbg_assert(!1,"CD read: Outside of disk end="+h(e+d)+" size="+h(this.buffer.byteLength),LOG_DISK),this.status=255,this.push_irq()):(this.status=208,this.report_read_start(),this.read_buffer(e,d,a=>{dbg_log("atapi_read_dma: Data arrived"); +this.report_read_end(d);this.status=88;this.bytecount=this.bytecount&-8|2;this.data_set(a);this.do_atapi_dma()}))}; +IDEInterface.prototype.do_atapi_dma=function(){if(0===(this.device.dma_status&1))dbg_log("do_atapi_dma: Status not set",LOG_DISK);else if(0===(this.status&8))dbg_log("do_atapi_dma: DRQ not set",LOG_DISK);else{dbg_log("atapi dma transfer len="+this.data_length,LOG_DISK);var a=this.device.prdt_addr,b=0,c=this.data;do{var d=this.cpu.read32s(a),e=this.cpu.read16(a+4),f=this.cpu.read8(a+7)&128;e||(e=65536);dbg_log("dma read dest="+h(d)+" count="+h(e)+" datalen="+h(this.data_length),LOG_DISK);this.cpu.write_blob(c.subarray(b, +Math.min(b+e,this.data_length)),d);b+=e;a+=8;if(b>=this.data_length&&!f){dbg_log("leave early end="+ +f+" offset="+h(b)+" data_length="+h(this.data_length)+" cmd="+h(this.current_command),LOG_DISK);break}}while(!f);dbg_log("end offset="+b,LOG_DISK);this.status=80;this.device.dma_status&=-2;this.bytecount=this.bytecount&-8|3;this.push_irq()}}; +IDEInterface.prototype.read_data=function(a){if(this.data_pointer>>1]:this.data32[this.data_pointer>>>2];this.data_pointer+=a;0===(this.data_pointer&(0===(this.data_end&4095)?4095:255))&&dbg_log("Read 1F0: "+h(this.data[this.data_pointer],2)+" cur="+h(this.data_pointer)+" cnt="+h(this.data_length), +LOG_DISK);this.data_pointer>=this.data_end&&this.read_end();return b}dbg_log("Read 1F0: empty",LOG_DISK);this.data_pointer+=a;return 0}; +IDEInterface.prototype.read_end=function(){dbg_log("read_end cmd="+h(this.current_command)+" data_pointer="+h(this.data_pointer)+" end="+h(this.data_end)+" length="+h(this.data_length),LOG_DISK);if(160===this.current_command)if(this.data_end===this.data_length)this.status=80,this.bytecount=this.bytecount&-8|3,this.push_irq();else{this.status=88;this.bytecount=this.bytecount&-8|2;this.push_irq();var a=this.cylinder_high<<8&65280|this.cylinder_low&255;this.data_end+a>this.data_length?(this.cylinder_low= +this.data_length-this.data_end&255,this.cylinder_high=this.data_length-this.data_end>>8&255,this.data_end=this.data_length):this.data_end+=a;dbg_log("data_end="+h(this.data_end),LOG_DISK)}else this.error=0,this.data_pointer>=this.data_length?this.status=80:(196===this.current_command||41===this.current_command?(a=Math.min(this.sectors_per_drq,(this.data_length-this.data_end)/512),dbg_assert(0===a%1)):(dbg_assert(32===this.current_command||36===this.current_command),a=1),this.ata_advance(this.current_command, +a),this.data_end+=512*a,this.status=88),this.push_irq()}; +IDEInterface.prototype.write_data_port=function(a,b){dbg_assert(0===this.data_pointer%b);this.data_pointer>=this.data_end?dbg_log("Redundant write to data port: "+h(a)+" count="+h(this.data_end)+" cur="+h(this.data_pointer),LOG_DISK):((0===(this.data_pointer+b&(0===(this.data_end&4095)?4095:255))||20>this.data_end)&&dbg_log("Data port: "+h(a>>>0)+" count="+h(this.data_end)+" cur="+h(this.data_pointer),LOG_DISK),1===b?this.data[this.data_pointer++]=a:2===b?(this.data16[this.data_pointer>>>1]=a,this.data_pointer+= +2):(this.data32[this.data_pointer>>>2]=a,this.data_pointer+=4),dbg_assert(this.data_pointer<=this.data_end),this.data_pointer===this.data_end&&this.write_end())};IDEInterface.prototype.write_data_port8=function(a){this.write_data_port(a,1)};IDEInterface.prototype.write_data_port16=function(a){this.write_data_port(a,2)};IDEInterface.prototype.write_data_port32=function(a){this.write_data_port(a,4)}; +IDEInterface.prototype.write_end=function(){160===this.current_command?this.atapi_handle():(dbg_log("write_end data_pointer="+h(this.data_pointer)+" data_length="+h(this.data_length),LOG_DISK),this.data_pointer>=this.data_length?this.do_write():(dbg_assert(48===this.current_command||52===this.current_command||197===this.current_command,"Unexpected command: "+h(this.current_command)),this.status=88,this.data_end+=512,this.push_irq()))}; +IDEInterface.prototype.ata_advance=function(a,b){dbg_log("Advance sectors="+b+" old_bytecount="+this.bytecount,LOG_DISK);this.bytecount-=b;36===a||41===a||52===a||57===a||37===a||53===a?(a=b+this.get_lba48(),this.sector=a&255|a>>16&65280,this.cylinder_low=a>>8&255,this.cylinder_high=a>>16&255):this.is_lba?(a=b+this.get_lba28(),this.sector=a&255,this.cylinder_low=a>>8&255,this.cylinder_high=a>>16&255,this.head=this.head&-16|a&15):(a=b+this.get_chs(),b=a/(this.head_count*this.sectors_per_track)|0,this.cylinder_low= +b&255,this.cylinder_high=b>>8&255,this.head=(a/this.sectors_per_track|0)%this.head_count&15,this.sector=a%this.sectors_per_track+1&255,dbg_assert(a===this.get_chs()))}; +IDEInterface.prototype.ata_read_sectors=function(a){var b=36===a||41===a,c=this.get_count(b);b=this.get_lba(b);var d=32===a||36===a,e=c*this.sector_size,f=b*this.sector_size;dbg_log("ATA read cmd="+h(a)+" mode="+(this.is_lba?"lba":"chs")+" lba="+h(b)+" lbacount="+h(c)+" bytecount="+h(e),LOG_DISK);f+e>this.buffer.byteLength?(dbg_assert(!1,"ATA read: Outside of disk",LOG_DISK),this.status=255,this.push_irq()):(this.status=192,this.report_read_start(),this.read_buffer(f,e,b=>{dbg_log("ata_read: Data arrived", +LOG_DISK);this.data_set(b);this.status=88;this.data_end=d?512:Math.min(e,512*this.sectors_per_drq);this.ata_advance(a,d?1:Math.min(c,this.sectors_per_track));this.push_irq();this.report_read_end(e)}))}; +IDEInterface.prototype.ata_read_sectors_dma=function(a){var b=37===a;a=this.get_count(b);b=this.get_lba(b);var c=a*this.sector_size,d=b*this.sector_size;dbg_log("ATA DMA read lba="+h(b)+" lbacount="+h(a)+" bytecount="+h(c),LOG_DISK);d+c>this.buffer.byteLength?(dbg_assert(!1,"ATA read: Outside of disk",LOG_DISK),this.status=255,this.push_irq()):(this.status=88,this.device.dma_status|=1)}; +IDEInterface.prototype.do_ata_read_sectors_dma=function(){var a=37===this.current_command,b=this.get_count(a);a=this.get_lba(a);var c=b*this.sector_size,d=a*this.sector_size;dbg_assert(a{dbg_log("do_ata_read_sectors_dma: Data arrived",LOG_DISK);var d=this.device.prdt_addr,f=0;dbg_assert(e===d);do{var l=this.cpu.read32s(d),m=this.cpu.read16(d+4),n=this.cpu.read8(d+7)&128;m||(m=65536,dbg_log("dma: prd count was 0", +LOG_DISK));dbg_log("dma read transfer dest="+h(l)+" prd_count="+h(m),LOG_DISK);this.cpu.write_blob(a.subarray(f,f+m),l);f+=m;d+=8}while(!n);dbg_assert(f===c);this.ata_advance(this.current_command,b);this.status=80;this.device.dma_status&=-2;this.current_command=-1;this.push_irq();this.report_read_end(c)})}; +IDEInterface.prototype.ata_write_sectors=function(a){var b=52===a||57===a,c=this.get_count(b);b=this.get_lba(b);a=48===a||52===a;var d=c*this.sector_size,e=b*this.sector_size;dbg_log("ATA write lba="+h(b)+" mode="+(this.is_lba?"lba":"chs")+" lbacount="+h(c)+" bytecount="+h(d),LOG_DISK);e+d>this.buffer.byteLength?(dbg_assert(!1,"ATA write: Outside of disk",LOG_DISK),this.status=255,this.push_irq()):(this.status=88,this.data_allocate_noclear(d),this.data_end=a?512:Math.min(d,512*this.sectors_per_drq), +this.write_dest=e)};IDEInterface.prototype.ata_write_sectors_dma=function(a){var b=53===a;a=this.get_count(b);b=this.get_lba(b);var c=a*this.sector_size,d=b*this.sector_size;dbg_log("ATA DMA write lba="+h(b)+" lbacount="+h(a)+" bytecount="+h(c),LOG_DISK);d+c>this.buffer.byteLength?(dbg_assert(!1,"ATA DMA write: Outside of disk",LOG_DISK),this.status=255,this.push_irq()):(this.status=88,this.device.dma_status|=1)}; +IDEInterface.prototype.do_ata_write_sectors_dma=function(){var a=53===this.current_command,b=this.get_count(a),c=this.get_lba(a);a=b*this.sector_size;c*=this.sector_size;var d=this.device.prdt_addr,e=0;dbg_log("prdt addr: "+h(d,8),LOG_DISK);const f=new Uint8Array(a);do{var k=this.cpu.read32s(d),g=this.cpu.read16(d+4),l=this.cpu.read8(d+7)&128;g||(g=65536,dbg_log("dma: prd count was 0",LOG_DISK));dbg_log("dma write transfer dest="+h(k)+" prd_count="+h(g),LOG_DISK);k=this.cpu.mem8.subarray(k,k+g);dbg_assert(k.length=== +g);f.set(k,e);e+=g;d+=8}while(!l);dbg_assert(e===f.length);this.buffer.set(c,f,()=>{dbg_log("dma write completed",LOG_DISK);this.ata_advance(this.current_command,b);this.status=80;this.push_irq();this.device.dma_status&=-2;this.current_command=-1});this.report_write(a)}; +IDEInterface.prototype.get_chs=function(){var a=this.cylinder_low&255|this.cylinder_high<<8&65280,b=this.head,c=this.sector&255;dbg_log("get_chs: c="+a+" h="+b+" s="+c,LOG_DISK);return(a*this.head_count+b)*this.sectors_per_track+c-1};IDEInterface.prototype.get_lba28=function(){return this.sector&255|this.cylinder_low<<8&65280|this.cylinder_high<<16&16711680|(this.head&15)<<24}; +IDEInterface.prototype.get_lba48=function(){return(this.sector&255|this.cylinder_low<<8&65280|this.cylinder_high<<16&16711680|this.sector>>8<<24&4278190080)>>>0};IDEInterface.prototype.get_lba=function(a){return a?this.get_lba48():this.is_lba?this.get_lba28():this.get_chs()};IDEInterface.prototype.get_count=function(a){a?(a=this.bytecount,0===a&&(a=65536)):(a=this.bytecount&255,0===a&&(a=256));return a}; +IDEInterface.prototype.create_identify_packet=function(){if(this.drive_head&16)this.data_allocate(0);else{for(var a=0;512>a;a++)this.data[a]=0;a=Math.min(16383,this.cylinder_count);this.data_set([64,this.is_atapi?133:0,a,a>>8,0,0,this.head_count,this.head_count>>8,this.sectors_per_track/512,this.sectors_per_track/512>>8,0,2,this.sectors_per_track,this.sectors_per_track>>8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0,2,4,0,0,0,0,0,0,0,0,0,56,118,32,54,68,72,32,32,32,32,32,32,32,32,32, +32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,128,0,1,0,0,2,0,0,0,2,0,2,7,0,a,a>>8,this.head_count,this.head_count>>8,this.sectors_per_track,0,this.sector_count&255,this.sector_count>>8&255,this.sector_count>>16&255,this.sector_count>>24&255,0,0,this.sector_count&255,this.sector_count>>8&255,this.sector_count>>16&255,this.sector_count>>24&255,0,0,160===this.current_command?0:7,160===this.current_command?0:4,0,0,30,0,30,0,30,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,126,0,0,0,0,0,0,116,0,64,0,64,0,116,0,64,0,0,0,0,0,0,0,0,0,0,1,96,0,0,0,0,0,0,0,0,0,0,0,0,this.sector_count&255,this.sector_count>>8&255,this.sector_count>>16&255,this.sector_count>>24&255]);this.data_end=this.data_length=512}};IDEInterface.prototype.data_allocate=function(a){this.data_allocate_noclear(a);for(var b=0;b>2;b++)this.data32[b]=0}; +IDEInterface.prototype.data_allocate_noclear=function(a){this.data.length{if(this.cancelled_io_ids.delete(d))dbg_assert(!this.in_progress_io_ids.has(d));else{var b=this.in_progress_io_ids.delete(d);dbg_assert(b);c(a)}})};IDEInterface.prototype.cancel_io_operations=function(){for(const a of this.in_progress_io_ids)this.cancelled_io_ids.add(a);this.in_progress_io_ids.clear()}; +IDEInterface.prototype.get_state=function(){var a=[];a[0]=this.bytecount;a[1]=this.cylinder_count;a[2]=this.cylinder_high;a[3]=this.cylinder_low;a[4]=this.data_pointer;a[5]=0;a[6]=0;a[7]=0;a[8]=0;a[9]=this.drive_head;a[10]=this.error;a[11]=this.head;a[12]=this.head_count;a[13]=this.is_atapi;a[14]=this.is_lba;a[15]=this.lba_count;a[16]=this.data;a[17]=this.data_length;a[18]=this.sector;a[19]=this.sector_count;a[20]=this.sector_size;a[21]=this.sectors_per_drq;a[22]=this.sectors_per_track;a[23]=this.status; +a[24]=this.write_dest;a[25]=this.current_command;a[26]=this.data_end;a[27]=this.current_atapi_command;a[28]=this.buffer;return a}; +IDEInterface.prototype.set_state=function(a){this.bytecount=a[0];this.cylinder_count=a[1];this.cylinder_high=a[2];this.cylinder_low=a[3];this.data_pointer=a[4];this.drive_head=a[9];this.error=a[10];this.head=a[11];this.head_count=a[12];this.is_atapi=a[13];this.is_lba=a[14];this.lba_count=a[15];this.data=a[16];this.data_length=a[17];this.sector=a[18];this.sector_count=a[19];this.sector_size=a[20];this.sectors_per_drq=a[21];this.sectors_per_track=a[22];this.status=a[23];this.write_dest=a[24];this.current_command= +a[25];this.data_end=a[26];this.current_atapi_command=a[27];this.data16=new Uint16Array(this.data.buffer);this.data32=new Int32Array(this.data.buffer);this.buffer&&this.buffer.set_state(a[28])};var PCI_CONFIG_ADDRESS=3320,PCI_CONFIG_DATA=3324; +function PCI(a){this.pci_addr=new Uint8Array(4);this.pci_value=new Uint8Array(4);this.pci_response=new Uint8Array(4);this.pci_status=new Uint8Array(4);this.pci_addr32=new Int32Array(this.pci_addr.buffer);this.pci_value32=new Int32Array(this.pci_value.buffer);this.pci_response32=new Int32Array(this.pci_response.buffer);this.pci_status32=new Int32Array(this.pci_status.buffer);this.device_spaces=[];this.devices=[];this.cpu=a;for(var b=0;256>b;b++)this.device_spaces[b]=void 0,this.devices[b]=void 0;this.io= +a.io;a.io.register_write(PCI_CONFIG_DATA,this,function(a){this.pci_write8(this.pci_addr32[0],a)},function(a){this.pci_write16(this.pci_addr32[0],a)},function(a){this.pci_write32(this.pci_addr32[0],a)});a.io.register_write(PCI_CONFIG_DATA+1,this,function(a){this.pci_write8(this.pci_addr32[0]+1|0,a)});a.io.register_write(PCI_CONFIG_DATA+2,this,function(a){this.pci_write8(this.pci_addr32[0]+2|0,a)},function(a){this.pci_write16(this.pci_addr32[0]+2|0,a)});a.io.register_write(PCI_CONFIG_DATA+3,this,function(a){this.pci_write8(this.pci_addr32[0]+ +3|0,a)});a.io.register_read_consecutive(PCI_CONFIG_DATA,this,function(){return this.pci_response[0]},function(){return this.pci_response[1]},function(){return this.pci_response[2]},function(){return this.pci_response[3]});a.io.register_read_consecutive(PCI_CONFIG_ADDRESS,this,function(){return this.pci_status[0]},function(){return this.pci_status[1]},function(){return this.pci_status[2]},function(){return this.pci_status[3]});a.io.register_write_consecutive(PCI_CONFIG_ADDRESS,this,function(a){this.pci_addr[0]= +a&252},function(b){2===(this.pci_addr[1]&6)&&6===(b&6)?(dbg_log("CPU reboot via PCI"),a.reboot_internal()):this.pci_addr[1]=b},function(a){this.pci_addr[2]=a},function(a){this.pci_addr[3]=a;this.pci_query()});this.register_device({pci_id:0,pci_space:[134,128,55,18,0,0,0,0,2,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,0,0,0,0,0,0],pci_bars:[],name:"82441FX PMC"});this.isa_bridge={pci_id:8, +pci_space:[134,128,0,112,7,0,0,2,0,0,1,6,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],pci_bars:[],name:"82371SB PIIX3 ISA"};this.isa_bridge_space=this.register_device(this.isa_bridge);this.isa_bridge_space8=new Uint8Array(this.isa_bridge_space.buffer)}PCI.prototype.get_state=function(){for(var a=[],b=0;256>b;b++)a[b]=this.device_spaces[b];a[256]=this.pci_addr;a[257]=this.pci_value;a[258]=this.pci_response;a[259]=this.pci_status;return a}; +PCI.prototype.set_state=function(a){for(var b=0;256>b;b++){var c=this.devices[b],d=a[b];if(c&&d){for(var e=0;e>3&31;var d="query enabled="+(this.pci_addr[3]>>7)+(" bdf="+h(a,4));d+=" dev="+h(c,2);d+=" addr="+h(b,2);c=this.device_spaces[a];void 0!==c?(this.pci_status32[0]=-2147483648,this.pci_response32[0]=b>2]:0,d+=" "+h(this.pci_addr32[0]>>>0,8)+" -> "+h(this.pci_response32[0]>>>0,8),b>=c.byteLength&&(d+=" (undef)"),d+=" ("+this.devices[a].name+")",dbg_log(d,LOG_PCI)):(this.pci_response32[0]= +-1,this.pci_status32[0]=0)};PCI.prototype.pci_write8=function(a,b){var c=a>>8&65535;a&=255;var d=new Uint8Array(this.device_spaces[c].buffer),e=this.devices[c];d&&(dbg_assert(!(16<=a&&44>a||48<=a&&52>a),"PCI: Expected 32-bit write, got 8-bit (addr: "+h(a)+")"),dbg_log("PCI write8 dev="+h(c>>3,2)+" ("+e.name+") addr="+h(a,4)+" value="+h(b,2),LOG_PCI),d[a]=b)}; +PCI.prototype.pci_write16=function(a,b){dbg_assert(0===(a&1));var c=a>>8&65535;a&=255;var d=new Uint16Array(this.device_spaces[c].buffer),e=this.devices[c];d&&(16<=a&&44>a?dbg_log("Warning: PCI: Expected 32-bit write, got 16-bit (addr: "+h(a)+")"):(dbg_assert(!(48<=a&&52>a),"PCI: Expected 32-bit write, got 16-bit (addr: "+h(a)+")"),dbg_log("PCI writ16 dev="+h(c>>3,2)+" ("+e.name+") addr="+h(a,4)+" value="+h(b,4),LOG_PCI),d[a>>>1]=b))}; +PCI.prototype.pci_write32=function(a,b){dbg_assert(0===(a&3));var c=a>>8&65535;a&=255;var d=this.device_spaces[c],e=this.devices[c];if(d)if(16<=a&&40>a){var f=a-16>>2,k=e.pci_bars[f];dbg_log("BAR"+f+" exists="+(k?"y":"n")+" changed to "+h(b>>>0)+" dev="+h(c>>3,2)+" ("+e.name+") ",LOG_PCI);k?(dbg_assert(!(k.size&k.size-1),"bar size should be power of 2"),c=a>>2,e=d[c]&1,-1===(b|3|k.size-1)?(b=~(k.size-1)|e,0===e&&(d[c]=b)):0===e&&(f=k.original_bar,(b&-16)!==(f&-16)&&dbg_log("Warning: Changing memory bar not supported, ignored", +LOG_PCI),d[c]=f),1===e&&(dbg_assert(1===e),e=d[c]&65534,f=b&65534,dbg_log("io bar changed from "+h(e>>>0,8)+" to "+h(f>>>0,8)+" size="+k.size,LOG_PCI),this.set_io_bars(k,e,f),d[c]=b|1)):d[a>>2]=0;dbg_log("BAR effective value: "+h(d[a>>2]>>>0),LOG_PCI)}else 48===a?(dbg_log("PCI write rom address dev="+h(c>>3,2)+" ("+e.name+") value="+h(b>>>0,8),LOG_PCI),d[a>>2]=e.pci_rom_size?-1===(b|2047)?-e.pci_rom_size|0:e.pci_rom_address|0:0):4===a?dbg_log("PCI write dev="+h(c>>3,2)+" ("+e.name+") addr="+h(a,4)+ +" value="+h(b>>>0,8),LOG_PCI):(dbg_log("PCI write dev="+h(c>>3,2)+" ("+e.name+") addr="+h(a,4)+" value="+h(b>>>0,8),LOG_PCI),d[a>>>2]=b)}; +PCI.prototype.register_device=function(a){dbg_assert(void 0!==a.pci_id);dbg_assert(void 0!==a.pci_space);dbg_assert(void 0!==a.pci_bars);var b=a.pci_id;dbg_log("PCI register bdf="+h(b)+" ("+a.name+")",LOG_PCI);dbg_assert(!this.devices[b]);dbg_assert(64<=a.pci_space.length);dbg_assert(b>4),LOG_FLOPPY);dbg_log("enable dma: "+!!(a&8),LOG_FLOPPY);dbg_log("reset fdc: "+!!(a&4),LOG_FLOPPY);dbg_log("drive select: "+(a&3),LOG_FLOPPY);dbg_log("DOR = "+h(a),LOG_FLOPPY);this.dor=a};FloppyController.prototype.check_drive_status=function(a){dbg_log("check drive status",LOG_FLOPPY);this.response_index=0;this.response_length=1;this.response_data[0]=32}; +FloppyController.prototype.seek=function(a){dbg_log("seek",LOG_FLOPPY);dbg_assert(0===(a[0]&3),"Unhandled seek drive");this.last_cylinder=a[1];this.last_head=a[0]>>2&1;this.raise_irq()};FloppyController.prototype.calibrate=function(a){dbg_log("floppy calibrate",LOG_FLOPPY);this.raise_irq()};FloppyController.prototype.check_interrupt_status=function(){dbg_log("floppy check interrupt status",LOG_FLOPPY);this.response_index=0;this.response_length=2;this.response_data[0]=32;this.response_data[1]=this.last_cylinder}; +FloppyController.prototype.do_sector=function(a,b){var c=b[2],d=b[1],e=b[3],f=128<this.sectors_per_track&&(d=1,c++,c>=this.number_of_heads&&(c=0,b++)),this.last_cylinder=b,this.last_head=c,this.last_sector=d,this.response_index=0,this.response_length=7,this.response_data[0]=c<<2|32,this.response_data[1]=0,this.response_data[2]=0,this.response_data[3]=b,this.response_data[4]=c,this.response_data[5]=d,this.response_data[6]=a[4],this.raise_irq())}; +FloppyController.prototype.fix_drive_data=function(a){dbg_log("floppy fix drive data "+a,LOG_FLOPPY)};FloppyController.prototype.read_sector_id=function(a){dbg_log("floppy read sector id "+a,LOG_FLOPPY);this.response_index=0;this.response_length=7;this.response_data[0]=0;this.response_data[1]=0;this.response_data[2]=0;this.response_data[3]=0;this.response_data[4]=0;this.response_data[5]=0;this.response_data[6]=0;this.raise_irq()};FloppyController.prototype.raise_irq=function(){this.dor&8&&this.cpu.device_raise_irq(6)};CPU.prototype.mmap_read8=function(a){return this.memory_map_read8[a>>>MMAP_BLOCK_BITS](a)};CPU.prototype.mmap_write8=function(a,b){this.memory_map_write8[a>>>MMAP_BLOCK_BITS](a,b)};CPU.prototype.mmap_read16=function(a){var b=this.memory_map_read8[a>>>MMAP_BLOCK_BITS];return b(a)|b(a+1|0)<<8};CPU.prototype.mmap_write16=function(a,b){var c=this.memory_map_write8[a>>>MMAP_BLOCK_BITS];c(a,b&255);c(a+1|0,b>>8&255)};CPU.prototype.mmap_read32=function(a){return this.memory_map_read32[a>>>MMAP_BLOCK_BITS](a)}; +CPU.prototype.mmap_write32=function(a,b){this.memory_map_write32[a>>>MMAP_BLOCK_BITS](a,b)};CPU.prototype.mmap_write64=function(a,b,c){var d=a>>>MMAP_BLOCK_BITS;dbg_assert(d===a+7>>>MMAP_BLOCK_BITS);d=this.memory_map_write32[d];d(a,b);d(a+4,c)};CPU.prototype.mmap_write128=function(a,b,c,d,e){var f=a>>>MMAP_BLOCK_BITS;dbg_assert(f===a+12>>>MMAP_BLOCK_BITS);f=this.memory_map_write32[f];f(a,b);f(a+4,c);f(a+8,d);f(a+12,e)}; +CPU.prototype.write_blob=function(a,b){dbg_assert(a&&0<=a.length);a.length&&(dbg_assert(!this.in_mapped_range(b)),dbg_assert(!this.in_mapped_range(b+a.length-1)),this.jit_dirty_cache(b,b+a.length),this.mem8.set(a,b))};CPU.prototype.read_blob=function(a,b){b&&(dbg_assert(!this.in_mapped_range(a)),dbg_assert(!this.in_mapped_range(a+b-1)));return this.mem8.subarray(a,a+b)};function DMA(a){this.cpu=a;this.channel_page=new Uint8Array(8);this.channel_pagehi=new Uint8Array(8);this.channel_addr=new Uint16Array(8);this.channel_addr_init=new Uint16Array(8);this.channel_count=new Uint16Array(8);this.channel_count_init=new Uint16Array(8);this.channel_mask=new Uint8Array(8);this.channel_mode=new Uint8Array(8);this.unmask_listeners=[];this.lsb_msb_flipflop=0;a=a.io;a.register_write(0,this,this.port_addr_write.bind(this,0));a.register_write(2,this,this.port_addr_write.bind(this, +1));a.register_write(4,this,this.port_addr_write.bind(this,2));a.register_write(6,this,this.port_addr_write.bind(this,3));a.register_write(1,this,this.port_count_write.bind(this,0));a.register_write(3,this,this.port_count_write.bind(this,1));a.register_write(5,this,this.port_count_write.bind(this,2));a.register_write(7,this,this.port_count_write.bind(this,3));a.register_read(0,this,this.port_addr_read.bind(this,0));a.register_read(2,this,this.port_addr_read.bind(this,1));a.register_read(4,this,this.port_addr_read.bind(this, +2));a.register_read(6,this,this.port_addr_read.bind(this,3));a.register_read(1,this,this.port_count_read.bind(this,0));a.register_read(3,this,this.port_count_read.bind(this,1));a.register_read(5,this,this.port_count_read.bind(this,2));a.register_read(7,this,this.port_count_read.bind(this,3));a.register_write(192,this,this.port_addr_write.bind(this,4));a.register_write(196,this,this.port_addr_write.bind(this,5));a.register_write(200,this,this.port_addr_write.bind(this,6));a.register_write(204,this, +this.port_addr_write.bind(this,7));a.register_write(194,this,this.port_count_write.bind(this,4));a.register_write(198,this,this.port_count_write.bind(this,5));a.register_write(202,this,this.port_count_write.bind(this,6));a.register_write(206,this,this.port_count_write.bind(this,7));a.register_read(192,this,this.port_addr_read.bind(this,4));a.register_read(196,this,this.port_addr_read.bind(this,5));a.register_read(200,this,this.port_addr_read.bind(this,6));a.register_read(204,this,this.port_addr_read.bind(this, +7));a.register_read(194,this,this.port_count_read.bind(this,4));a.register_read(198,this,this.port_count_read.bind(this,5));a.register_read(202,this,this.port_count_read.bind(this,6));a.register_read(206,this,this.port_count_read.bind(this,7));a.register_write(135,this,this.port_page_write.bind(this,0));a.register_write(131,this,this.port_page_write.bind(this,1));a.register_write(129,this,this.port_page_write.bind(this,2));a.register_write(130,this,this.port_page_write.bind(this,3));a.register_write(143, +this,this.port_page_write.bind(this,4));a.register_write(139,this,this.port_page_write.bind(this,5));a.register_write(137,this,this.port_page_write.bind(this,6));a.register_write(138,this,this.port_page_write.bind(this,7));a.register_read(135,this,this.port_page_read.bind(this,0));a.register_read(131,this,this.port_page_read.bind(this,1));a.register_read(129,this,this.port_page_read.bind(this,2));a.register_read(130,this,this.port_page_read.bind(this,3));a.register_read(143,this,this.port_page_read.bind(this, +4));a.register_read(139,this,this.port_page_read.bind(this,5));a.register_read(137,this,this.port_page_read.bind(this,6));a.register_read(138,this,this.port_page_read.bind(this,7));a.register_write(1159,this,this.port_pagehi_write.bind(this,0));a.register_write(1155,this,this.port_pagehi_write.bind(this,1));a.register_write(1153,this,this.port_pagehi_write.bind(this,2));a.register_write(1154,this,this.port_pagehi_write.bind(this,3));a.register_write(1163,this,this.port_pagehi_write.bind(this,5)); +a.register_write(1161,this,this.port_pagehi_write.bind(this,6));a.register_write(1162,this,this.port_pagehi_write.bind(this,7));a.register_read(1159,this,this.port_pagehi_read.bind(this,0));a.register_read(1155,this,this.port_pagehi_read.bind(this,1));a.register_read(1153,this,this.port_pagehi_read.bind(this,2));a.register_read(1154,this,this.port_pagehi_read.bind(this,3));a.register_read(1163,this,this.port_pagehi_read.bind(this,5));a.register_read(1161,this,this.port_pagehi_read.bind(this,6));a.register_read(1162, +this,this.port_pagehi_read.bind(this,7));a.register_write(10,this,this.port_singlemask_write.bind(this,0));a.register_write(212,this,this.port_singlemask_write.bind(this,4));a.register_write(15,this,this.port_multimask_write.bind(this,0));a.register_write(222,this,this.port_multimask_write.bind(this,4));a.register_read(15,this,this.port_multimask_read.bind(this,0));a.register_read(222,this,this.port_multimask_read.bind(this,4));a.register_write(11,this,this.port_mode_write.bind(this,0));a.register_write(214, +this,this.port_mode_write.bind(this,4));a.register_write(12,this,this.portC_write);a.register_write(216,this,this.portC_write)}DMA.prototype.get_state=function(){return[this.channel_page,this.channel_pagehi,this.channel_addr,this.channel_addr_init,this.channel_count,this.channel_count_init,this.channel_mask,this.channel_mode,this.lsb_msb_flipflop]}; +DMA.prototype.set_state=function(a){this.channel_page=a[0];this.channel_pagehi=a[1];this.channel_addr=a[2];this.channel_addr_init=a[3];this.channel_count=a[4];this.channel_count_init=a[5];this.channel_mask=a[6];this.channel_mode=a[7];this.lsb_msb_flipflop=a[8]};DMA.prototype.port_count_write=function(a,b){dbg_log("count write ["+a+"] = "+h(b),LOG_DMA);this.channel_count[a]=this.flipflop_get(this.channel_count[a],b,!1);this.channel_count_init[a]=this.flipflop_get(this.channel_count_init[a],b,!0)}; +DMA.prototype.port_count_read=function(a){dbg_log("count read ["+a+"] -> "+h(this.channel_count[a]),LOG_DMA);return this.flipflop_read(this.channel_count[a])};DMA.prototype.port_addr_write=function(a,b){dbg_log("addr write ["+a+"] = "+h(b),LOG_DMA);this.channel_addr[a]=this.flipflop_get(this.channel_addr[a],b,!1);this.channel_addr_init[a]=this.flipflop_get(this.channel_addr_init[a],b,!0)};DMA.prototype.port_addr_read=function(a){dbg_log("addr read ["+a+"] -> "+h(this.channel_addr[a]),LOG_DMA);return this.flipflop_read(this.channel_addr[a])}; +DMA.prototype.port_pagehi_write=function(a,b){dbg_log("pagehi write ["+a+"] = "+h(b),LOG_DMA);this.channel_pagehi[a]=b};DMA.prototype.port_pagehi_read=function(a){dbg_log("pagehi read ["+a+"]",LOG_DMA);return this.channel_pagehi[a]};DMA.prototype.port_page_write=function(a,b){dbg_log("page write ["+a+"] = "+h(b),LOG_DMA);this.channel_page[a]=b};DMA.prototype.port_page_read=function(a){dbg_log("page read ["+a+"]",LOG_DMA);return this.channel_page[a]}; +DMA.prototype.port_singlemask_write=function(a,b){a=(b&3)+a;b=b&4?1:0;dbg_log("singlechannel mask write ["+a+"] = "+b,LOG_DMA);this.update_mask(a,b)};DMA.prototype.port_multimask_write=function(a,b){dbg_log("multichannel mask write: "+h(b),LOG_DMA);for(var c=0;4>c;c++)this.update_mask(a+c,b&1<a.byteLength)dbg_log("DMA read outside of buffer",LOG_DMA),e(!0);else{var g=this.cpu;this.channel_addr[d]+=f;a.get(b,f,function(a){g.write_blob(a,k);e(!1)})}}; +DMA.prototype.do_write=function(a,b,c,d,e){var f=this.channel_count[d]+1&65535,k=5<=d?2:1,g=f*k,l=this.address_get_8bit(d),m=!1,n=!1,p=this.channel_mode[d]&16;dbg_log("DMA write channel "+d,LOG_DMA);dbg_log("to "+h(l)+" len "+h(g),LOG_DMA);cg&&(dbg_log("DMA attempted to read more than provided",LOG_DMA),n=!0);b+g>a.byteLength?(dbg_log("DMA write outside of buffer",LOG_DMA),e(!0)):(this.channel_addr[d]+=f,this.channel_count[d]-= +f,!m&&p&&(dbg_log("DMA autoinit",LOG_DMA),this.channel_addr[d]=this.channel_addr_init[d],this.channel_count[d]=this.channel_count_init[d]),a.set(b,this.cpu.mem8.subarray(l,l+g),()=>{n&&p?(dbg_log("DMA continuing from start",LOG_DMA),this.do_write(a,b+g,c-g,d,e)):e(!1)}))};DMA.prototype.address_get_8bit=function(a){var b=this.channel_addr[a];5<=a&&(b<<=1);b=b&65535|this.channel_page[a]<<16;return b|=this.channel_pagehi[a]<<24}; +DMA.prototype.count_get_8bit=function(a){var b=this.channel_count[a]+1;5<=a&&(b*=2);return b};DMA.prototype.flipflop_get=function(a,b,c){c||(this.lsb_msb_flipflop^=1);return this.lsb_msb_flipflop?a&-256|b:a&-65281|b<<8};DMA.prototype.flipflop_read=function(a){return(this.lsb_msb_flipflop^=1)?a&255:a>>8&255};var OSCILLATOR_FREQ=1193.1816666; +function PIT(a,b){this.cpu=a;this.bus=b;this.counter_start_time=new Float64Array(3);this.counter_start_value=new Uint16Array(3);this.counter_next_low=new Uint8Array(4);this.counter_enabled=new Uint8Array(4);this.counter_mode=new Uint8Array(4);this.counter_read_mode=new Uint8Array(4);this.counter_latch=new Uint8Array(4);this.counter_latch_value=new Uint16Array(3);this.counter_reload=new Uint16Array(3);a.io.register_read(97,this,function(){var a=v86.microtick(),b=66.66666666666667*a&1;a=this.did_rollover(2, +a);return b<<4|a<<5});a.io.register_write(97,this,function(a){a&1?this.bus.send("pcspeaker-enable"):this.bus.send("pcspeaker-disable")});a.io.register_read(64,this,function(){return this.counter_read(0)});a.io.register_read(65,this,function(){return this.counter_read(1)});a.io.register_read(66,this,function(){return this.counter_read(2)});a.io.register_write(64,this,function(a){this.counter_write(0,a)});a.io.register_write(65,this,function(a){this.counter_write(1,a)});a.io.register_write(66,this, +function(a){this.counter_write(2,a)});a.io.register_write(67,this,this.port43_write)}PIT.prototype.get_state=function(){var a=[];a[0]=this.counter_next_low;a[1]=this.counter_enabled;a[2]=this.counter_mode;a[3]=this.counter_read_mode;a[4]=this.counter_latch;a[5]=this.counter_latch_value;a[6]=this.counter_reload;a[7]=this.counter_start_time;a[8]=this.counter_start_value;return a}; +PIT.prototype.set_state=function(a){this.counter_next_low=a[0];this.counter_enabled=a[1];this.counter_mode=a[2];this.counter_read_mode=a[3];this.counter_latch=a[4];this.counter_latch_value=a[5];this.counter_reload=a[6];this.counter_start_time=a[7];this.counter_start_value=a[8]}; +PIT.prototype.timer=function(a,b){b||(this.counter_enabled[0]&&this.did_rollover(0,a)?(this.counter_start_value[0]=this.get_counter_value(0,a),this.counter_start_time[0]=a,dbg_log("pit interrupt. new value: "+this.counter_start_value[0],LOG_PIT),this.cpu.device_lower_irq(0),this.cpu.device_raise_irq(0),0===this.counter_mode[0]&&(this.counter_enabled[0]=0)):this.cpu.device_lower_irq(0));return 0}; +PIT.prototype.get_counter_value=function(a,b){if(!this.counter_enabled[a])return 0;var c=b-this.counter_start_time[a],d=Math.floor(c*OSCILLATOR_FREQ);b=this.counter_start_value[a]-d;dbg_log("diff="+c+" dticks="+d+" value="+b+" reload="+this.counter_reload[a],LOG_PIT);c=this.counter_reload[a];b>=c?(dbg_log("Warning: Counter"+a+" value "+b+" is larger than reload "+c,LOG_PIT),b%=c):0>b&&(b=b%c+c);return b}; +PIT.prototype.did_rollover=function(a,b){b-=this.counter_start_time[a];return 0>b?(dbg_log("Warning: PIT timer difference is negative, resetting"),!0):this.counter_start_value[a]>8;b=this.counter_next_low[a];3===this.counter_mode[a]&&(this.counter_next_low[a]^=1);a=this.get_counter_value(a,v86.microtick());return b?a&255:a>>8}; +PIT.prototype.counter_write=function(a,b){this.counter_reload[a]=this.counter_next_low[a]?this.counter_reload[a]&-256|b:this.counter_reload[a]&255|b<<8;3===this.counter_read_mode[a]&&this.counter_next_low[a]||(this.counter_reload[a]||(this.counter_reload[a]=65535),this.counter_start_value[a]=this.counter_reload[a],this.counter_enabled[a]=!0,this.counter_start_time[a]=v86.microtick(),dbg_log("counter"+a+" reload="+h(this.counter_reload[a])+" tick="+(this.counter_reload[a]||65536)/OSCILLATOR_FREQ+"ms", +LOG_PIT));3===this.counter_read_mode[a]&&(this.counter_next_low[a]^=1);this.bus.send("pcspeaker-update",[this.counter_mode[2],this.counter_reload[2]])}; +PIT.prototype.port43_write=function(a){var b=a>>1&7,c=a&1,d=a>>6&3;a=a>>4&3;1===d&&dbg_log("Unimplemented timer1",LOG_PIT);3===d?dbg_log("Unimplemented read back",LOG_PIT):0===a?(this.counter_latch[d]=2,b=this.get_counter_value(d,v86.microtick()),dbg_log("latch: "+b,LOG_PIT),this.counter_latch_value[d]=b?b-1:0):(6<=b&&(b&=-5),dbg_log("Control: mode="+b+" ctr="+d+" read_mode="+a+" bcd="+c,LOG_PIT),this.counter_next_low[d]=1===a?0:1,0===d&&this.cpu.device_lower_irq(0),0!==b&&3!==b&&2!==b&&dbg_log("Unimplemented counter mode: "+ +h(b),LOG_PIT),this.counter_mode[d]=b,this.counter_read_mode[d]=a,this.bus.send("pcspeaker-update",[this.counter_mode[2],this.counter_reload[2]]))};PIT.prototype.dump=function(){const a=this.counter_reload[0];dbg_log("counter0 ticks every "+(a||65536)/OSCILLATOR_FREQ+"ms (reload="+a+")")};var VGA_BANK_SIZE=65536,MAX_XRES=2560,MAX_YRES=1600,MAX_BPP=32,VGA_LFB_ADDRESS=3758096384,VGA_PIXEL_BUFFER_START=4*VGA_BANK_SIZE,VGA_PIXEL_BUFFER_SIZE=8*VGA_BANK_SIZE,VGA_MIN_MEMORY_SIZE=VGA_PIXEL_BUFFER_START+VGA_PIXEL_BUFFER_SIZE,VGA_HOST_MEMORY_SPACE_START=Uint32Array.from([655360,655360,720896,753664]),VGA_HOST_MEMORY_SPACE_SIZE=Uint32Array.from([131072,65536,32768,32768]); +function VGAScreen(a,b,c){this.bus=b;this.vga_memory_size=c;this.cursor_address=0;this.cursor_scanline_start=14;this.cursor_scanline_end=15;this.max_cols=80;this.max_rows=25;this.virtual_height=this.virtual_width=this.screen_height=this.screen_width=0;this.layers=[];this.start_address_latched=this.start_address=0;this.crtc=new Uint8Array(25);this.line_compare=this.offset_register=this.preset_row_scan=this.underline_location_register=this.vertical_blank_start=this.vertical_display_enable_end=this.horizontal_blank_start= +this.horizontal_display_enable_end=this.crtc_mode=0;this.graphical_mode_is_linear=!0;this.graphical_mode=!1;setTimeout(()=>{b.send("screen-set-mode",this.graphical_mode)},0);this.vga256_palette=new Int32Array(256);this.svga_height=this.svga_width=this.latch_dword=0;this.svga_enabled=!1;this.svga_bpp=32;this.svga_offset=this.svga_bank_offset=0;this.pci_space=[52,18,17,17,3,1,0,0,2,0,0,3,0,0,0,0,8,VGA_LFB_ADDRESS>>>8,VGA_LFB_ADDRESS>>>16,VGA_LFB_ADDRESS>>>24,0,0,0,0,0,0,191,254,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,244,26,0,17,0,0,190,254,0,0,0,0,0,0,0,0,0,0,0,0];this.pci_id=144;this.pci_bars=[{size:c}];this.pci_rom_size=65536;this.pci_rom_address=4272947200;this.name="vga";this.stats={is_graphical:!1,res_x:0,res_y:0,bpp:0};this.dac_state=this.dac_color_index_read=this.dac_color_index_write=this.index_crtc=0;this.dac_map=new Uint8Array(16);this.attribute_controller_index=-1;this.palette_source=32;this.color_select=this.horizontal_panning=this.color_plane_enable=this.attribute_mode=0;this.sequencer_index= +-1;this.plane_write_bm=15;this.clocking_mode=this.sequencer_memory_mode=0;this.graphics_index=-1;this.planar_rotate_reg=this.planar_mode=this.plane_read=0;this.planar_bitmap=255;this.max_scan_line=this.color_dont_care=this.color_compare=this.miscellaneous_graphics_register=this.planar_setreset_enable=this.planar_setreset=0;this.port_3DA_value=this.miscellaneous_output_register=255;c=a.io;c.register_write(960,this,this.port3C0_write);c.register_read(960,this,this.port3C0_read,this.port3C0_read16); +c.register_read(961,this,this.port3C1_read);c.register_write(962,this,this.port3C2_write);c.register_write_consecutive(964,this,this.port3C4_write,this.port3C5_write);c.register_read(964,this,this.port3C4_read);c.register_read(965,this,this.port3C5_read);c.register_write_consecutive(974,this,this.port3CE_write,this.port3CF_write);c.register_read(974,this,this.port3CE_read);c.register_read(975,this,this.port3CF_read);c.register_write(967,this,this.port3C7_write);c.register_read(967,this,this.port3C7_read); +c.register_write(968,this,this.port3C8_write);c.register_read(968,this,this.port3C8_read);c.register_write(969,this,this.port3C9_write);c.register_read(969,this,this.port3C9_read);c.register_read(972,this,this.port3CC_read);c.register_write_consecutive(980,this,this.port3D4_write,this.port3D5_write);c.register_read(980,this,this.port3D4_read);c.register_read(981,this,this.port3D5_read,()=>{dbg_log("Warning: 16-bit read from 3D5",LOG_VGA);return this.port3D5_read()});c.register_read(970,this,function(){dbg_log("3CA read", +LOG_VGA);return 0});c.register_read(986,this,this.port3DA_read);c.register_read(954,this,this.port3DA_read);this.dispi_index=-1;this.dispi_enable_value=0;c.register_write(462,this,void 0,this.port1CE_write);c.register_write(463,this,void 0,this.port1CF_write);c.register_read(463,this,void 0,this.port1CF_read);void 0===this.vga_memory_size||this.vga_memory_size[a.screen_x,a.screen_y,a.buffer_x,a.buffer_y,a.buffer_width,a.buffer_height]);a[7]=this.dac_state;a[8]=this.start_address;a[9]=this.graphical_mode;a[10]=this.vga256_palette;a[11]=this.latch_dword;a[12]=this.color_compare;a[13]=this.color_dont_care;a[14]=this.miscellaneous_graphics_register; +a[15]=this.svga_width;a[16]=this.svga_height;a[17]=this.crtc_mode;a[18]=this.svga_enabled;a[19]=this.svga_bpp;a[20]=this.svga_bank_offset;a[21]=this.svga_offset;a[22]=this.index_crtc;a[23]=this.dac_color_index_write;a[24]=this.dac_color_index_read;a[25]=this.dac_map;a[26]=this.sequencer_index;a[27]=this.plane_write_bm;a[28]=this.sequencer_memory_mode;a[29]=this.graphics_index;a[30]=this.plane_read;a[31]=this.planar_mode;a[32]=this.planar_rotate_reg;a[33]=this.planar_bitmap;a[34]=this.max_scan_line; +a[35]=this.miscellaneous_output_register;a[36]=this.port_3DA_value;a[37]=this.dispi_index;a[38]=this.dispi_enable_value;a[39]=this.svga_memory;a[40]=this.graphical_mode_is_linear;a[41]=this.attribute_controller_index;a[42]=this.offset_register;a[43]=this.planar_setreset;a[44]=this.planar_setreset_enable;a[45]=this.start_address_latched;a[46]=this.crtc;a[47]=this.horizontal_display_enable_end;a[48]=this.horizontal_blank_start;a[49]=this.vertical_display_enable_end;a[50]=this.vertical_blank_start;a[51]= +this.underline_location_register;a[52]=this.preset_row_scan;a[53]=this.offset_register;a[54]=this.palette_source;a[55]=this.attribute_mode;a[56]=this.color_plane_enable;a[57]=this.horizontal_panning;a[58]=this.color_select;a[59]=this.clocking_mode;a[60]=this.line_compare;return a}; +VGAScreen.prototype.set_state=function(a){this.vga_memory_size=a[0];this.cursor_address=a[1];this.cursor_scanline_start=a[2];this.cursor_scanline_end=a[3];this.max_cols=a[4];this.max_rows=a[5];this.layers=a[6].map(a=>({screen_x:a[0],screen_y:a[1],buffer_x:a[2],buffer_y:a[3],buffer_width:a[4],buffer_height:a[5]}));this.dac_state=a[7];this.start_address=a[8];this.graphical_mode=a[9];this.vga256_palette=a[10];this.latch_dword=a[11];this.color_compare=a[12];this.color_dont_care=a[13];this.miscellaneous_graphics_register= +a[14];this.svga_width=a[15];this.svga_height=a[16];this.crtc_mode=a[17];this.svga_enabled=a[18];this.svga_bpp=a[19];this.svga_bank_offset=a[20];this.svga_offset=a[21];this.index_crtc=a[22];this.dac_color_index_write=a[23];this.dac_color_index_read=a[24];this.dac_map=a[25];this.sequencer_index=a[26];this.plane_write_bm=a[27];this.sequencer_memory_mode=a[28];this.graphics_index=a[29];this.plane_read=a[30];this.planar_mode=a[31];this.planar_rotate_reg=a[32];this.planar_bitmap=a[33];this.max_scan_line= +a[34];this.miscellaneous_output_register=a[35];this.port_3DA_value=a[36];this.dispi_index=a[37];this.dispi_enable_value=a[38];this.svga_memory.set(a[39]);this.graphical_mode_is_linear=a[40];this.attribute_controller_index=a[41];this.offset_register=a[42];this.planar_setreset=a[43];this.planar_setreset_enable=a[44];this.start_address_latched=a[45];this.crtc.set(a[46]);this.horizontal_display_enable_end=a[47];this.horizontal_blank_start=a[48];this.vertical_display_enable_end=a[49];this.vertical_blank_start= +a[50];this.underline_location_register=a[51];this.preset_row_scan=a[52];this.offset_register=a[53];this.palette_source=a[54];this.attribute_mode=a[55];this.color_plane_enable=a[56];this.horizontal_panning=a[57];this.color_select=a[58];this.clocking_mode=a[59];this.line_compare=a[60];this.bus.send("screen-set-mode",this.graphical_mode);this.graphical_mode?(this.screen_height=this.screen_width=0,this.svga_enabled?(this.set_size_graphical(this.svga_width,this.svga_height,this.svga_bpp,this.svga_width, +this.svga_height),this.update_layers()):(this.update_vga_size(),this.complete_replot())):(this.set_size_text(this.max_cols,this.max_rows),this.update_cursor_scanline(),this.update_cursor());this.complete_redraw()}; +VGAScreen.prototype.vga_memory_read=function(a){if(this.svga_enabled&&this.graphical_mode_is_linear)return a=a-655360|this.svga_bank_offset,this.svga_memory[a];var b=this.miscellaneous_graphics_register>>2&3;a-=VGA_HOST_MEMORY_SPACE_START[b];if(0>a||a>=VGA_HOST_MEMORY_SPACE_SIZE[b])return dbg_log("vga read outside memory space: addr:"+h(a),LOG_VGA),0;this.latch_dword=this.plane0[a];this.latch_dword|=this.plane1[a]<<8;this.latch_dword|=this.plane2[a]<<16;this.latch_dword|=this.plane3[a]<<24;if(this.planar_mode& +8)return b=255,this.color_dont_care&1&&(b&=this.plane0[a]^~(this.color_compare&1?255:0)),this.color_dont_care&2&&(b&=this.plane1[a]^~(this.color_compare&2?255:0)),this.color_dont_care&4&&(b&=this.plane2[a]^~(this.color_compare&4?255:0)),this.color_dont_care&8&&(b&=this.plane3[a]^~(this.color_compare&8?255:0)),b;b=this.plane_read;this.graphical_mode?this.sequencer_memory_mode&8?(b=a&3,a&=-4):this.planar_mode&16&&(b=a&1,a&=-2):b=0;return this.vga_memory[b<<16|a]}; +VGAScreen.prototype.vga_memory_write=function(a,b){if(this.svga_enabled&&this.graphical_mode&&this.graphical_mode_is_linear)this.vga_memory_write_graphical_linear(a-655360,b);else{var c=this.miscellaneous_graphics_register>>2&3;a-=VGA_HOST_MEMORY_SPACE_START[c];0>a||a>=VGA_HOST_MEMORY_SPACE_SIZE[c]?dbg_log("vga write outside memory space: addr:"+h(a)+", value:"+h(b),LOG_VGA):this.graphical_mode?this.vga_memory_write_graphical(a,b):this.plane_write_bm&3&&this.vga_memory_write_text_mode(a,b)}}; +VGAScreen.prototype.vga_memory_write_graphical_linear=function(a,b){a|=this.svga_bank_offset;this.diff_addr_min=athis.diff_addr_max?a:this.diff_addr_max;this.svga_memory[a]=b}; +VGAScreen.prototype.vga_memory_write_graphical=function(a,b){var c=this.planar_mode&3,d=this.apply_feed(this.planar_bitmap),e=this.apply_expand(this.planar_setreset),f=this.apply_expand(this.planar_setreset_enable);switch(c){case 0:b=this.apply_rotate(b);var k=this.apply_feed(b);k=this.apply_setreset(k,f);k=this.apply_logical(k,this.latch_dword);k=this.apply_bitmask(k,d);break;case 1:k=this.latch_dword;break;case 2:k=this.apply_expand(b);k=this.apply_logical(k,this.latch_dword);k=this.apply_bitmask(k, +d);break;case 3:b=this.apply_rotate(b),d&=this.apply_feed(b),k=this.apply_bitmask(e,d)}b=15;switch(this.sequencer_memory_mode&12){case 0:b=5<<(a&1);a&=-2;break;case 8:case 12:b=1<<(a&3),a&=-4}b&=this.plane_write_bm;b&1&&(this.plane0[a]=k>>0&255);b&2&&(this.plane1[a]=k>>8&255);b&4&&(this.plane2[a]=k>>16&255);b&8&&(this.plane3[a]=k>>24&255);a=this.vga_addr_to_pixel(a);this.partial_replot(a,a+7)};VGAScreen.prototype.apply_feed=function(a){return a|a<<8|a<<16|a<<24}; +VGAScreen.prototype.apply_expand=function(a){return(a&1?255:0)|(a&2?255:0)<<8|(a&4?255:0)<<16|(a&8?255:0)<<24};VGAScreen.prototype.apply_rotate=function(a){return(a|a<<8)>>>(this.planar_rotate_reg&7)&255};VGAScreen.prototype.apply_setreset=function(a,b){var c=this.apply_expand(this.planar_setreset);return(a|b&c)&(~b|c)};VGAScreen.prototype.apply_logical=function(a,b){switch(this.planar_rotate_reg&24){case 8:return a&b;case 16:return a|b;case 24:return a^b}return a}; +VGAScreen.prototype.apply_bitmask=function(a,b){return b&a|~b&this.latch_dword};VGAScreen.prototype.text_mode_redraw=function(){for(var a=this.start_address<<1,b,c,d=0;d>4&15],this.vga256_palette[c&15]]),a+=2}; +VGAScreen.prototype.vga_memory_write_text_mode=function(a,b){var c=(a>>1)-this.start_address,d=c/this.max_cols|0;c%=this.max_cols;if(a&1){var e=b;var f=this.vga_memory[a&-2]}else f=b,e=this.vga_memory[a|1];this.bus.send("screen-put-char",[d,c,f,this.vga256_palette[e>>4&15],this.vga256_palette[e&15]]);this.vga_memory[a]=b}; +VGAScreen.prototype.update_cursor=function(){var a=(this.cursor_address-this.start_address)/this.max_cols|0,b=(this.cursor_address-this.start_address)%this.max_cols;a=Math.min(this.max_rows-1,a);this.bus.send("screen-update-cursor",[a,b])};VGAScreen.prototype.svga_memory_read8=function(a){return this.svga_memory[a&268435455]}; +VGAScreen.prototype.svga_memory_read32=function(a){a&=268435455;return a&3?this.svga_memory[a]|this.svga_memory[a+1]<<8|this.svga_memory[a+2]<<16|this.svga_memory[a+3]<<24:this.svga_memory32[a>>2]};VGAScreen.prototype.svga_memory_write8=function(a,b){a&=268435455;this.svga_memory[a]=b;this.diff_addr_min=athis.diff_addr_max?a:this.diff_addr_max}; +VGAScreen.prototype.svga_memory_write32=function(a,b){a&=268435455;this.diff_addr_min=athis.diff_addr_max?a+3:this.diff_addr_max;this.svga_memory[a]=b;this.svga_memory[a+1]=b>>8;this.svga_memory[a+2]=b>>16;this.svga_memory[a+3]=b>>24}; +VGAScreen.prototype.complete_redraw=function(){dbg_log("complete redraw",LOG_VGA);this.graphical_mode?(this.diff_addr_min=0,this.diff_addr_max=this.svga_enabled?this.vga_memory_size:VGA_PIXEL_BUFFER_SIZE):this.text_mode_redraw()};VGAScreen.prototype.complete_replot=function(){dbg_log("complete replot",LOG_VGA);this.graphical_mode&&!this.svga_enabled&&(this.diff_plot_min=0,this.diff_plot_max=VGA_PIXEL_BUFFER_SIZE,this.complete_redraw())}; +VGAScreen.prototype.partial_redraw=function(a,b){athis.diff_addr_max&&(this.diff_addr_max=b)};VGAScreen.prototype.partial_replot=function(a,b){athis.diff_plot_max&&(this.diff_plot_max=b);this.partial_redraw(a,b)};VGAScreen.prototype.reset_diffs=function(){this.diff_addr_min=this.vga_memory_size;this.diff_addr_max=0;this.diff_plot_min=this.vga_memory_size;this.diff_plot_max=0};VGAScreen.prototype.destroy=function(){}; +VGAScreen.prototype.vga_bytes_per_line=function(){var a=this.offset_register<<2;this.underline_location_register&64?a<<=1:this.crtc_mode&64&&(a>>>=1);return a};VGAScreen.prototype.vga_addr_shift_count=function(){var a=128+(~this.underline_location_register&this.crtc_mode&64);a-=this.underline_location_register&64;a-=this.attribute_mode&64;return a>>>6}; +VGAScreen.prototype.vga_addr_to_pixel=function(a){var b=this.vga_addr_shift_count();if(~this.crtc_mode&3){var c=a-this.start_address;c&=this.crtc_mode<<13|-24577;c<<=b;var d=c/this.virtual_width|0;c%=this.virtual_width;switch(this.crtc_mode&3){case 2:d=d<<1|a>>13&1;break;case 1:d=d<<1|a>>14&1;break;case 0:d=d<<2|a>>13&3}return d*this.virtual_width+c+(this.start_address<>>=1);a=Math.ceil(a/(1+(this.max_scan_line&31)));this.crtc_mode&1||(a<<=1);this.crtc_mode&2||(a<<=1);return a};VGAScreen.prototype.set_size_text=function(a,b){this.max_cols=a;this.max_rows=b;this.bus.send("screen-set-size-text",[a,b])}; +VGAScreen.prototype.set_size_graphical=function(a,b,c,d,e){this.stats.is_graphical&&this.stats.bpp===c&&this.screen_width===a&&this.screen_height===b&&this.virtual_width===d&&this.virtual_height===e||(this.screen_width=a,this.screen_height=b,this.virtual_width=d,this.virtual_height=e,this.stats.bpp=c,this.stats.is_graphical=!0,this.stats.res_x=a,this.stats.res_y=b,this.bus.send("screen-set-size-graphical",[a,b,d,e,c]))}; +VGAScreen.prototype.update_vga_size=function(){if(!this.svga_enabled){var a=Math.min(1+this.horizontal_display_enable_end,this.horizontal_blank_start),b=Math.min(1+this.vertical_display_enable_end,this.vertical_blank_start);if(a&&b)if(this.graphical_mode){a<<=3;var c=this.offset_register<<4;this.attribute_mode&64&&(a>>>=1,c>>>=1);b=this.scan_line_to_screen_row(b);var d=Math.ceil(VGA_HOST_MEMORY_SPACE_SIZE[0]/this.vga_bytes_per_line());this.set_size_graphical(a,b,8,c,d);this.update_vertical_retrace(); +this.update_layers()}else this.max_scan_line&128&&(b>>>=1),c=b/(1+(this.max_scan_line&31))|0,a&&c&&this.set_size_text(a,c)}}; +VGAScreen.prototype.update_layers=function(){this.graphical_mode||this.text_mode_redraw();if(this.svga_enabled)this.layers=[];else if(this.virtual_width&&this.screen_width)if(!this.palette_source||this.clocking_mode&32)this.layers=[],this.bus.send("screen-clear");else{var a=this.start_address_latched,b=this.horizontal_panning;this.attribute_mode&64&&(b>>>=1);var c=this.preset_row_scan>>5&3,d=this.vga_addr_to_pixel(a+c);a=d/this.virtual_width|0;var e=d%this.virtual_width+b;d=this.scan_line_to_screen_row(1+ +this.line_compare);d=Math.min(d,this.screen_height);var f=this.screen_height-d;this.layers=[];e=-e;for(var k=0;ethis.attribute_controller_index)dbg_log("internal palette: "+h(this.attribute_controller_index)+" -> "+h(a),LOG_VGA),this.dac_map[this.attribute_controller_index]= +a,this.attribute_mode&64||this.complete_redraw();else switch(this.attribute_controller_index){case 16:dbg_log("3C0 / attribute mode control: "+h(a),LOG_VGA);if(this.attribute_mode!==a){var b=this.attribute_mode;this.attribute_mode=a;var c=0<(a&1);this.svga_enabled||this.graphical_mode===c||(this.graphical_mode=c,this.bus.send("screen-set-mode",this.graphical_mode));(b^a)&64&&this.complete_replot();this.update_vga_size();this.complete_redraw()}break;case 18:dbg_log("3C0 / color plane enable: "+h(a), +LOG_VGA);this.color_plane_enable!==a&&(this.color_plane_enable=a,this.complete_redraw());break;case 19:dbg_log("3C0 / horizontal panning: "+h(a),LOG_VGA);this.horizontal_panning!==a&&(this.horizontal_panning=a&15,this.update_layers());break;case 20:dbg_log("3C0 / color select: "+h(a),LOG_VGA);this.color_select!==a&&(this.color_select=a,this.complete_redraw());break;default:dbg_log("3C0 / attribute controller write "+h(this.attribute_controller_index)+": "+h(a),LOG_VGA)}this.attribute_controller_index= +-1}};VGAScreen.prototype.port3C0_read=function(){dbg_log("3C0 read",LOG_VGA);return this.attribute_controller_index|this.palette_source};VGAScreen.prototype.port3C0_read16=function(){dbg_log("3C0 read16",LOG_VGA);return this.port3C0_read()&255|this.port3C1_read()<<8&65280}; +VGAScreen.prototype.port3C1_read=function(){if(16>this.attribute_controller_index)return dbg_log("3C1 / internal palette read: "+h(this.attribute_controller_index)+" -> "+h(this.dac_map[this.attribute_controller_index]),LOG_VGA),this.dac_map[this.attribute_controller_index]&255;switch(this.attribute_controller_index){case 16:return dbg_log("3C1 / attribute mode read: "+h(this.attribute_mode),LOG_VGA),this.attribute_mode;case 18:return dbg_log("3C1 / color plane enable read: "+h(this.color_plane_enable), +LOG_VGA),this.color_plane_enable;case 19:return dbg_log("3C1 / horizontal panning read: "+h(this.horizontal_panning),LOG_VGA),this.horizontal_panning;case 20:return dbg_log("3C1 / color select read: "+h(this.color_select),LOG_VGA),this.color_select;default:dbg_log("3C1 / attribute controller read "+h(this.attribute_controller_index),LOG_VGA)}return 255};VGAScreen.prototype.port3C2_write=function(a){dbg_log("3C2 / miscellaneous output register = "+h(a),LOG_VGA);this.miscellaneous_output_register=a}; +VGAScreen.prototype.port3C4_write=function(a){this.sequencer_index=a};VGAScreen.prototype.port3C4_read=function(){return this.sequencer_index}; +VGAScreen.prototype.port3C5_write=function(a){switch(this.sequencer_index){case 1:dbg_log("clocking mode: "+h(a),LOG_VGA);var b=this.clocking_mode;this.clocking_mode=a;(b^a)&32&&this.update_layers();break;case 2:dbg_log("plane write mask: "+h(a),LOG_VGA);this.plane_write_bm=a;break;case 4:dbg_log("sequencer memory mode: "+h(a),LOG_VGA);this.sequencer_memory_mode=a;break;default:dbg_log("3C5 / sequencer write "+h(this.sequencer_index)+": "+h(a),LOG_VGA)}}; +VGAScreen.prototype.port3C5_read=function(){dbg_log("3C5 / sequencer read "+h(this.sequencer_index),LOG_VGA);switch(this.sequencer_index){case 1:return this.clocking_mode;case 2:return this.plane_write_bm;case 4:return this.sequencer_memory_mode;case 6:return 18}return 0};VGAScreen.prototype.port3C7_write=function(a){dbg_log("3C7 write: "+h(a),LOG_VGA);this.dac_color_index_read=3*a;this.dac_state&=0};VGAScreen.prototype.port3C7_read=function(){return this.dac_state}; +VGAScreen.prototype.port3C8_write=function(a){this.dac_color_index_write=3*a;this.dac_state|=3};VGAScreen.prototype.port3C8_read=function(){return this.dac_color_index_write/3|0}; +VGAScreen.prototype.port3C9_write=function(a){var b=this.dac_color_index_write/3|0,c=this.dac_color_index_write%3,d=this.vga256_palette[b];a=255*(a&63)/63|0;0===c?d=d&-16711681|a<<16:1===c?d=d&-65281|a<<8:(d=d&-256|a,dbg_log("dac set color, index="+h(b)+" value="+h(d),LOG_VGA));this.vga256_palette[b]!==d&&(this.vga256_palette[b]=d,this.complete_redraw());this.dac_color_index_write++}; +VGAScreen.prototype.port3C9_read=function(){dbg_log("3C9 read",LOG_VGA);var a=this.dac_color_index_read%3,b=this.vga256_palette[this.dac_color_index_read/3|0];this.dac_color_index_read++;return(b>>8*(2-a)&255)/255*63|0};VGAScreen.prototype.port3CC_read=function(){dbg_log("3CC read",LOG_VGA);return this.miscellaneous_output_register};VGAScreen.prototype.port3CE_write=function(a){this.graphics_index=a};VGAScreen.prototype.port3CE_read=function(){return this.graphics_index}; +VGAScreen.prototype.port3CF_write=function(a){switch(this.graphics_index){case 0:this.planar_setreset=a;dbg_log("plane set/reset: "+h(a),LOG_VGA);break;case 1:this.planar_setreset_enable=a;dbg_log("plane set/reset enable: "+h(a),LOG_VGA);break;case 2:this.color_compare=a;dbg_log("color compare: "+h(a),LOG_VGA);break;case 3:this.planar_rotate_reg=a;dbg_log("plane rotate: "+h(a),LOG_VGA);break;case 4:this.plane_read=a;dbg_log("plane read: "+h(a),LOG_VGA);break;case 5:var b=this.planar_mode;this.planar_mode= +a;dbg_log("planar mode: "+h(a),LOG_VGA);(b^a)&96&&this.complete_replot();break;case 6:dbg_log("miscellaneous graphics register: "+h(a),LOG_VGA);this.miscellaneous_graphics_register!==a&&(this.miscellaneous_graphics_register=a,this.update_vga_size());break;case 7:this.color_dont_care=a;dbg_log("color don't care: "+h(a),LOG_VGA);break;case 8:this.planar_bitmap=a;dbg_log("planar bitmap: "+h(a),LOG_VGA);break;default:dbg_log("3CF / graphics write "+h(this.graphics_index)+": "+h(a),LOG_VGA)}}; +VGAScreen.prototype.port3CF_read=function(){dbg_log("3CF / graphics read "+h(this.graphics_index),LOG_VGA);switch(this.graphics_index){case 0:return this.planar_setreset;case 1:return this.planar_setreset_enable;case 2:return this.color_compare;case 3:return this.planar_rotate_reg;case 4:return this.plane_read;case 5:return this.planar_mode;case 6:return this.miscellaneous_graphics_register;case 7:return this.color_dont_care;case 8:return this.planar_bitmap}return 0}; +VGAScreen.prototype.port3D4_write=function(a){dbg_log("3D4 / crtc index: "+a,LOG_VGA);this.index_crtc=a};VGAScreen.prototype.port3D4_read=function(){dbg_log("3D4 read / crtc index: "+this.index_crtc,LOG_VGA);return this.index_crtc}; +VGAScreen.prototype.port3D5_write=function(a){switch(this.index_crtc){case 1:dbg_log("3D5 / hdisp enable end write: "+h(a),LOG_VGA);this.horizontal_display_enable_end!==a&&(this.horizontal_display_enable_end=a,this.update_vga_size());break;case 2:this.horizontal_blank_start!==a&&(this.horizontal_blank_start=a,this.update_vga_size());break;case 7:dbg_log("3D5 / overflow register write: "+h(a),LOG_VGA);var b=this.vertical_display_enable_end;this.vertical_display_enable_end&=255;this.vertical_display_enable_end= +this.vertical_display_enable_end|a<<3&512|a<<7&256;b!=this.vertical_display_enable_end&&this.update_vga_size();this.line_compare=this.line_compare&767|a<<4&256;b=this.vertical_blank_start;this.vertical_blank_start=this.vertical_blank_start&767|a<<5&256;b!==this.vertical_blank_start&&this.update_vga_size();this.update_layers();break;case 8:dbg_log("3D5 / preset row scan write: "+h(a),LOG_VGA);this.preset_row_scan=a;this.update_layers();break;case 9:dbg_log("3D5 / max scan line write: "+h(a),LOG_VGA); +this.max_scan_line=a;this.line_compare=this.line_compare&511|a<<3&512;b=this.vertical_blank_start;this.vertical_blank_start=this.vertical_blank_start&511|a<<4&512;b!==this.vertical_blank_start&&this.update_vga_size();this.update_layers();break;case 10:dbg_log("3D5 / cursor scanline start write: "+h(a),LOG_VGA);this.cursor_scanline_start=a;this.update_cursor_scanline();break;case 11:dbg_log("3D5 / cursor scanline end write: "+h(a),LOG_VGA);this.cursor_scanline_end=a;this.update_cursor_scanline();break; +case 12:(this.start_address>>8&255)!==a&&(this.start_address=this.start_address&255|a<<8,this.update_layers(),~this.crtc_mode&3&&this.complete_replot());dbg_log("3D5 / start addr hi write: "+h(a)+" -> "+h(this.start_address,4),LOG_VGA);break;case 13:(this.start_address&255)!==a&&(this.start_address=this.start_address&65280|a,this.update_layers(),~this.crtc_mode&3&&this.complete_replot());dbg_log("3D5 / start addr lo write: "+h(a)+" -> "+h(this.start_address,4),LOG_VGA);break;case 14:dbg_log("3D5 / cursor address hi write: "+ +h(a),LOG_VGA);this.cursor_address=this.cursor_address&255|a<<8;this.update_cursor();break;case 15:dbg_log("3D5 / cursor address lo write: "+h(a),LOG_VGA);this.cursor_address=this.cursor_address&65280|a;this.update_cursor();break;case 18:dbg_log("3D5 / vdisp enable end write: "+h(a),LOG_VGA);(this.vertical_display_enable_end&255)!==a&&(this.vertical_display_enable_end=this.vertical_display_enable_end&768|a,this.update_vga_size());break;case 19:dbg_log("3D5 / offset register write: "+h(a),LOG_VGA); +this.offset_register!==a&&(this.offset_register=a,this.update_vga_size(),~this.crtc_mode&3&&this.complete_replot());break;case 20:dbg_log("3D5 / underline location write: "+h(a),LOG_VGA);this.underline_location_register!==a&&(b=this.underline_location_register,this.underline_location_register=a,this.update_vga_size(),(b^a)&64&&this.complete_replot());break;case 21:dbg_log("3D5 / vertical blank start write: "+h(a),LOG_VGA);(this.vertical_blank_start&255)!==a&&(this.vertical_blank_start=this.vertical_blank_start& +768|a,this.update_vga_size());break;case 23:dbg_log("3D5 / crtc mode write: "+h(a),LOG_VGA);this.crtc_mode!==a&&(b=this.crtc_mode,this.crtc_mode=a,this.update_vga_size(),(b^a)&67&&this.complete_replot());break;case 24:dbg_log("3D5 / line compare write: "+h(a),LOG_VGA);this.line_compare=this.line_compare&768|a;this.update_layers();break;default:this.index_crtc>7&2|this.vertical_blank_start>>5&8|this.line_compare>>4&16|this.vertical_display_enable_end>>3&64;case 8:return this.preset_row_scan;case 9:return this.max_scan_line;case 10:return this.cursor_scanline_start;case 11:return this.cursor_scanline_end; +case 12:return this.start_address&255;case 13:return this.start_address>>8;case 14:return this.cursor_address>>8;case 15:return this.cursor_address&255;case 18:return this.vertical_display_enable_end&255;case 19:return this.offset_register;case 20:return this.underline_location_register;case 21:return this.vertical_blank_start&255;case 23:return this.crtc_mode;case 24:return this.line_compare&255}return this.index_crtcMAX_XRES&&(dbg_log("svga_width reduced from "+this.svga_width+" to "+MAX_XRES,LOG_VGA),this.svga_width=MAX_XRES);break;case 2:this.svga_height=a;this.svga_height>MAX_YRES&&(dbg_log("svga_height reduced from "+this.svga_height+" to "+MAX_YRES,LOG_VGA),this.svga_height=MAX_YRES);break;case 3:this.svga_bpp=a;break;case 4:this.svga_enabled= +1===(a&1);this.dispi_enable_value=a;break;case 5:this.svga_bank_offset=a<<16;break;case 9:this.svga_offset=a*this.svga_bytes_per_line(),dbg_log("SVGA offset: "+h(this.svga_offset)+" y="+h(a),LOG_VGA),this.complete_redraw()}!this.svga_enabled||this.svga_width&&this.svga_height||(dbg_log("SVGA: disabled because of invalid width/height: "+this.svga_width+"x"+this.svga_height,LOG_VGA),this.svga_enabled=!1);dbg_assert(4!==this.svga_bpp,"unimplemented svga bpp: 4");dbg_assert(15!==this.svga_bpp,"unimplemented svga bpp: 15"); +dbg_assert(4===this.svga_bpp||8===this.svga_bpp||15===this.svga_bpp||16===this.svga_bpp||24===this.svga_bpp||32===this.svga_bpp,"unexpected svga bpp: "+this.svga_bpp);dbg_log("SVGA: enabled="+this.svga_enabled+", "+this.svga_width+"x"+this.svga_height+"x"+this.svga_bpp,LOG_VGA);this.svga_enabled&&4===this.dispi_index&&(this.set_size_graphical(this.svga_width,this.svga_height,this.svga_bpp,this.svga_width,this.svga_height),this.bus.send("screen-set-mode",!0),this.graphical_mode_is_linear=this.graphical_mode= +!0);this.svga_enabled||(this.svga_bank_offset=0);this.update_layers()};VGAScreen.prototype.port1CF_read=function(){dbg_log("1CF / dispi read "+h(this.dispi_index),LOG_VGA);return this.svga_register_read(this.dispi_index)}; +VGAScreen.prototype.svga_register_read=function(a){switch(a){case 0:return 45248;case 1:return this.dispi_enable_value&2?MAX_XRES:this.svga_width;case 2:return this.dispi_enable_value&2?MAX_YRES:this.svga_height;case 3:return this.dispi_enable_value&2?MAX_BPP:this.svga_bpp;case 4:return this.dispi_enable_value;case 5:return this.svga_bank_offset>>>16;case 6:return this.screen_width?this.screen_width:1;case 8:return 0;case 10:return this.vga_memory_size/VGA_BANK_SIZE|0}return 255}; +VGAScreen.prototype.vga_replot=function(){for(var a=this.diff_plot_min&-16,b=Math.min(this.diff_plot_max|15,VGA_PIXEL_BUFFER_SIZE-1),c=this.vga_addr_shift_count(),d=~this.crtc_mode&3,e=this.planar_mode&96,f=this.attribute_mode&64;a<=b;){var k=a>>>c;if(d){var g=a/this.virtual_width|0,l=a-this.virtual_width*g;switch(d){case 1:k=(g&1)<<13;g>>>=1;break;case 2:k=(g&1)<<14;g>>>=1;break;case 3:k=(g&3)<<13,g>>>=2}k|=(g*this.virtual_width+l>>>c)+this.start_address}g=this.plane0[k];l=this.plane1[k];var m=this.plane2[k], +n=this.plane3[k];k=new Uint8Array(8);switch(e){case 0:g<<=0;l<<=1;m<<=2;n<<=3;for(var p=7;0<=p;p--)k[7-p]=g>>p&1|l>>p&2|m>>p&4|n>>p&8;break;case 32:k[0]=g>>6&3|m>>4&12;k[1]=g>>4&3|m>>2&12;k[2]=g>>2&3|m>>0&12;k[3]=g>>0&3|m<<2&12;k[4]=l>>6&3|n>>4&12;k[5]=l>>4&3|n>>2&12;k[6]=l>>2&3|n>>0&12;k[7]=l>>0&3|n<<2&12;break;case 64:case 96:k[0]=g>>4&15,k[1]=g>>0&15,k[2]=l>>4&15,k[3]=l>>0&15,k[4]=m>>4&15,k[5]=m>>0&15,k[6]=n>>4&15,k[7]=n>>0&15}if(f)for(g=p=0;4>p;p++,a++,g+=2)this.pixel_buffer[a]=k[g]<<4|k[g+1]; +else for(p=0;8>p;p++,a++)this.pixel_buffer[a]=k[p]}}; +VGAScreen.prototype.vga_redraw=function(){var a=this.diff_addr_min,b=Math.min(this.diff_addr_max,VGA_PIXEL_BUFFER_SIZE-1),c=this.dest_buffer;if(c){var d=255,e=0;this.attribute_mode&128&&(d&=207,e|=this.color_select<<4&48);if(this.attribute_mode&64)for(;a<=b;a++){var f=this.pixel_buffer[a]&d|e;f=this.vga256_palette[f];c[a]=f&65280|f<<16|f>>16|4278190080}else for(d&=63,e|=this.color_select<<4&192;a<=b;a++)f=this.dac_map[this.pixel_buffer[a]&this.color_plane_enable]&d|e,f=this.vga256_palette[f],c[a]= +f&65280|f<<16|f>>16|4278190080}}; +VGAScreen.prototype.screen_fill_buffer=function(){if(this.graphical_mode)if(this.dest_buffer)if(this.diff_addr_max>2,f=(d-this.svga_offset>>2)+1;a=c>>2;for(c=e;c>16&255|d&65280|4278190080;break; +case 24:c-=c%3;d+=3-d%3;dbg_assert(0===this.svga_offset%3);e=(c-this.svga_offset)/3|0;f=((d-this.svga_offset)/3|0)+1;a=c;for(c=e;a>1;f=(d-this.svga_offset>>1)+1;a=c>>1;for(c=e;c>11)/31|0,g=255*(d>>5&63)/63|0,k=255*(d&31)/31|0,b[c]=k<<16|g<<8|l|4278190080;break;case 8:e=c-this.svga_offset;f=d-this.svga_offset+1; +for(a=c;c<=d;c++)g=this.vga256_palette[this.svga_memory[a++]],b[c]=g&65280|g<<16|g>>16|4278190080;break;default:dbg_assert(!1,"Unsupported BPP: "+a)}b=e/this.svga_width|0;this.bus.send("screen-fill-buffer-end",[{screen_x:0,screen_y:b,buffer_x:0,buffer_y:b,buffer_width:this.svga_width,buffer_height:(f/this.svga_width|0)-b+1}])}else this.vga_replot(),this.vga_redraw(),this.bus.send("screen-fill-buffer-end",this.layers);this.reset_diffs()}else dbg_log("Cannot fill buffer: No destination buffer",LOG_VGA); +this.update_vertical_retrace()};let PS2_LOG_VERBOSE=!1; +function PS2(a,b){this.cpu=a;this.bus=b;this.use_mouse=this.enable_mouse_stream=!1;this.have_mouse=!0;this.mouse_clicks=this.mouse_delta_y=this.mouse_delta_x=0;this.have_keyboard=!0;this.next_read_resolution=this.next_read_rate=this.next_handle_scan_code_set=this.next_read_led=this.next_read_sample=this.next_is_mouse_command=this.enable_keyboard_stream=!1;this.kbd_buffer=new ByteQueue(1024);this.last_port60_byte=0;this.sample_rate=100;this.resolution=4;this.scaling2=!1;this.last_mouse_packet=-1;this.mouse_buffer= +new ByteQueue(1024);this.next_byte_is_aux=this.next_byte_is_ready=!1;this.bus.register("keyboard-code",function(a){this.kbd_send_code(a)},this);this.bus.register("mouse-click",function(a){this.mouse_send_click(a[0],a[1],a[2])},this);this.bus.register("mouse-delta",function(a){this.mouse_send_delta(a[0],a[1])},this);this.bus.register("mouse-wheel",function(a){},this);this.command_register=5;this.read_command_register=this.read_output_register=!1;a.io.register_read(96,this,this.port60_read);a.io.register_read(100, +this,this.port64_read);a.io.register_write(96,this,this.port60_write);a.io.register_write(100,this,this.port64_write)} +PS2.prototype.get_state=function(){var a=[];a[0]=this.enable_mouse_stream;a[1]=this.use_mouse;a[2]=this.have_mouse;a[3]=this.mouse_delta_x;a[4]=this.mouse_delta_y;a[5]=this.mouse_clicks;a[6]=this.have_keyboard;a[7]=this.enable_keyboard_stream;a[8]=this.next_is_mouse_command;a[9]=this.next_read_sample;a[10]=this.next_read_led;a[11]=this.next_handle_scan_code_set;a[12]=this.next_read_rate;a[13]=this.next_read_resolution;a[15]=this.last_port60_byte;a[16]=this.sample_rate;a[17]=this.resolution;a[18]= +this.scaling2;a[20]=this.command_register;a[21]=this.read_output_register;a[22]=this.read_command_register;return a}; +PS2.prototype.set_state=function(a){this.enable_mouse_stream=a[0];this.use_mouse=a[1];this.have_mouse=a[2];this.mouse_delta_x=a[3];this.mouse_delta_y=a[4];this.mouse_clicks=a[5];this.have_keyboard=a[6];this.enable_keyboard_stream=a[7];this.next_is_mouse_command=a[8];this.next_read_sample=a[9];this.next_read_led=a[10];this.next_handle_scan_code_set=a[11];this.next_read_rate=a[12];this.next_read_resolution=a[13];this.last_port60_byte=a[15];this.sample_rate=a[16];this.resolution=a[17];this.scaling2= +a[18];this.command_register=a[20];this.read_output_register=a[21];this.read_command_register=a[22];this.next_byte_is_aux=this.next_byte_is_ready=!1;this.kbd_buffer.clear();this.mouse_buffer.clear();this.bus.send("mouse-enable",this.use_mouse)};PS2.prototype.raise_irq=function(){this.next_byte_is_ready||(this.kbd_buffer.length?this.kbd_irq():this.mouse_buffer.length&&this.mouse_irq())}; +PS2.prototype.mouse_irq=function(){this.next_byte_is_aux=this.next_byte_is_ready=!0;this.command_register&2&&(dbg_log("Mouse irq",LOG_PS2),this.cpu.device_lower_irq(12),this.cpu.device_raise_irq(12))};PS2.prototype.kbd_irq=function(){this.next_byte_is_ready=!0;this.next_byte_is_aux=!1;this.command_register&1&&(dbg_log("Keyboard irq",LOG_PS2),this.cpu.device_lower_irq(1),this.cpu.device_raise_irq(1))}; +PS2.prototype.kbd_send_code=function(a){this.enable_keyboard_stream&&(dbg_log("adding kbd code: "+h(a),LOG_PS2),this.kbd_buffer.push(a),this.raise_irq())};PS2.prototype.mouse_send_delta=function(a,b){if(this.have_mouse&&this.use_mouse){var c=this.resolution*this.sample_rate/80;this.mouse_delta_x+=a*c;this.mouse_delta_y+=b*c;this.enable_mouse_stream&&(a=this.mouse_delta_x|0,b=this.mouse_delta_y|0,a||b)&&(Date.now(),this.mouse_delta_x-=a,this.mouse_delta_y-=b,this.send_mouse_packet(a,b))}}; +PS2.prototype.mouse_send_click=function(a,b,c){this.have_mouse&&this.use_mouse&&(this.mouse_clicks=a|c<<1|b<<2,this.enable_mouse_stream&&this.send_mouse_packet(0,0))};PS2.prototype.send_mouse_packet=function(a,b){var c=(0>b)<<5|(0>a)<<4|8|this.mouse_clicks;this.last_mouse_packet=Date.now();this.mouse_buffer.push(c);this.mouse_buffer.push(a);this.mouse_buffer.push(b);PS2_LOG_VERBOSE&&dbg_log("adding mouse packets: "+[c,a,b],LOG_PS2);this.raise_irq()}; +PS2.prototype.apply_scaling2=function(a){var b=a>>31;switch(Math.abs(a)){case 0:case 1:case 3:return a;case 2:return b;case 4:return 6*b;case 5:return 9*b;default:return a<<1}}; +PS2.prototype.port60_read=function(){this.next_byte_is_ready=!1;if(!this.kbd_buffer.length&&!this.mouse_buffer.length)return dbg_log("Port 60 read: Empty",LOG_PS2),this.last_port60_byte;this.next_byte_is_aux?(this.cpu.device_lower_irq(12),this.last_port60_byte=this.mouse_buffer.shift(),dbg_log("Port 60 read (mouse): "+h(this.last_port60_byte),LOG_PS2)):(this.cpu.device_lower_irq(1),this.last_port60_byte=this.kbd_buffer.shift(),dbg_log("Port 60 read (kbd) : "+h(this.last_port60_byte),LOG_PS2));(this.kbd_buffer.length|| +this.mouse_buffer.length)&&this.raise_irq();return this.last_port60_byte};PS2.prototype.port64_read=function(){var a=16;this.next_byte_is_ready&&(a|=1);this.next_byte_is_aux&&(a|=32);dbg_log("port 64 read: "+h(a),LOG_PS2);return a}; +PS2.prototype.port60_write=function(a){dbg_log("port 60 write: "+h(a),LOG_PS2);if(this.read_command_register)this.command_register=a,this.read_command_register=!1,dbg_log("Keyboard command register = "+h(this.command_register),LOG_PS2);else if(this.read_output_register)this.read_output_register=!1,this.mouse_buffer.clear(),this.mouse_buffer.push(a),this.mouse_irq();else if(this.next_read_sample)this.next_read_sample=!1,this.mouse_buffer.clear(),this.mouse_buffer.push(250),this.sample_rate=a,dbg_log("mouse sample rate: "+ +h(a),LOG_PS2),this.sample_rate||(dbg_log("invalid sample rate, reset to 100",LOG_PS2),this.sample_rate=100),this.mouse_irq();else if(this.next_read_resolution)this.next_read_resolution=!1,this.mouse_buffer.clear(),this.mouse_buffer.push(250),3 Already requested irq: "+this.requested_irq, +LOG_PIC),this.cpu.handle_irqs();else{var a=this.irr&this.irq_mask;if(a){a&=-a;var b=this.special_mask_mode?this.irq_mask:-1;this.isr&&(this.isr&-this.isr&b)<=a?dbg_log("master> higher prio: isr="+h(this.isr,2)+" mask="+h(this.irq_mask&255,2)+" irq="+h(a,2),LOG_PIC):(dbg_assert(0!==a),b=v86util.int_log2_byte(a),dbg_assert(a===1< request irq "+b,LOG_PIC),this.requested_irq=b,this.cpu.handle_irqs())}else PIC_LOG_VERBOSE&&dbg_log("master> no unmasked irrs. irr="+h(this.irr, +2)+" mask="+h(this.irq_mask&255,2)+" isr="+h(this.isr,2),LOG_PIC)}},this.acknowledge_irq=function(){if(-1!==this.requested_irq)if(0===this.irr)PIC_LOG_VERBOSE&&dbg_log("master> spurious requested="+this.requested_irq,LOG_PIC),this.requested_irq=-1;else{dbg_assert(this.irr);dbg_assert(0<=this.requested_irq);var a=1< acknowledge "+this.requested_irq,LOG_PIC);2===this.requested_irq?this.slave.acknowledge_irq(): +this.cpu.pic_call_irq(this.irq_map|this.requested_irq);this.requested_irq=-1;this.check_irqs()}}):(this.check_irqs=function(){if(0<=this.requested_irq)PIC_LOG_VERBOSE&&dbg_log("slave > Already requested irq: "+this.requested_irq,LOG_PIC),this.cpu.handle_irqs();else{var a=this.irr&this.irq_mask;if(a){a&=-a;var b=this.special_mask_mode?this.irq_mask:-1;this.isr&&(this.isr&-this.isr&b)<=a?PIC_LOG_VERBOSE&&dbg_log("slave > higher prio: isr="+h(this.isr,2)+" irq="+h(a,2),LOG_PIC):(dbg_assert(0!==a),b= +v86util.int_log2_byte(a),dbg_assert(a===1< request irq "+b,LOG_PIC),this.requested_irq=b,this.master.set_irq(2))}else PIC_LOG_VERBOSE&&dbg_log("slave > no unmasked irrs. irr="+h(this.irr,2)+" mask="+h(this.irq_mask&255,2)+" isr="+h(this.isr,2),LOG_PIC)}},this.acknowledge_irq=function(){if(-1!==this.requested_irq)if(0===this.irr)PIC_LOG_VERBOSE&&dbg_log("slave > spurious requested="+this.requested_irq,LOG_PIC),this.requested_irq=-1,this.master.irq_value&=-5,this.cpu.pic_call_irq(this.irq_map| +7);else{dbg_assert(this.irr);dbg_assert(0<=this.requested_irq);var a=1< acknowledge "+this.requested_irq,LOG_PIC);this.cpu.pic_call_irq(this.irq_map|this.requested_irq);this.requested_irq=-1;this.check_irqs()}});this.dump=function(){dbg_log("mask: "+h(this.irq_mask&255),LOG_PIC);dbg_log("base: "+h(this.irq_map),LOG_PIC);dbg_log("requested: "+h(this.irr),LOG_PIC); +dbg_log("serviced: "+h(this.isr),LOG_PIC);this.is_master&&this.slave.dump()};this.is_master?(a=32,b=1232):(a=160,b=1233);this.cpu.io.register_write(a,this,this.port20_write);this.cpu.io.register_read(a,this,this.port20_read);this.cpu.io.register_write(a|1,this,this.port21_write);this.cpu.io.register_read(a|1,this,this.port21_read);this.cpu.io.register_write(b,this,this.port4D0_write);this.cpu.io.register_read(b,this,this.port4D0_read);this.is_master?(this.set_irq=function(a){dbg_assert(0<=a&&16>a); +if(8<=a)this.slave.set_irq(a-8);else{var b=1< set irq "+a,LOG_PIC),this.irr|=b,this.irq_value|=b,this.check_irqs()):PIC_LOG_VERBOSE&&dbg_log("master> set irq "+a+": already set!",LOG_PIC)}},this.clear_irq=function(a){dbg_assert(0<=a&&16>a);PIC_LOG_VERBOSE&&dbg_log("master> clear irq "+a,LOG_PIC);8<=a?this.slave.clear_irq(a-8):(a=1<a);var b=1< set irq "+a,LOG_PIC),this.irr|=b,this.irq_value|=b,this.check_irqs()):PIC_LOG_VERBOSE&&dbg_log("slave > set irq "+a+": already set!",LOG_PIC)},this.clear_irq=function(a){dbg_assert(0<=a&&8>a);PIC_LOG_VERBOSE&&dbg_log("slave > clear irq "+a,LOG_PIC);a=1<>5;1===b?(this.isr&= +this.isr-1,dbg_log("new isr: "+h(this.isr,2),LOG_PIC)):3===b?this.isr&=~(1<<(a&7)):192===(a&200)?dbg_log("lowest priority: "+h(a&7),LOG_PIC):(dbg_log("Unknown eoi: "+h(a),LOG_PIC),dbg_assert(!1),this.isr&=this.isr-1);this.check_irqs()}};PIC.prototype.port20_read=function(){if(this.read_isr)return dbg_log("read port 20h (isr): "+h(this.isr),LOG_PIC),this.isr;dbg_log("read port 20h (irr): "+h(this.irr),LOG_PIC);return this.irr}; +PIC.prototype.port21_write=function(a){0===this.state?this.expect_icw4?(this.expect_icw4=!1,this.auto_eoi=a&2,dbg_log("icw4: "+h(a)+" autoeoi="+this.auto_eoi,LOG_PIC),0===(a&1)&&dbg_assert(!1,"unimplemented: not 8086 mode",LOG_PIC)):(this.irq_mask=~a,PIC_LOG_VERBOSE&&dbg_log("interrupt mask: "+(this.irq_mask&255).toString(2)+" ("+this.name+")",LOG_PIC),this.check_irqs()):1===this.state?(this.irq_map=a,dbg_log("interrupts are mapped to "+h(this.irq_map)+" ("+this.name+")",LOG_PIC),this.state++):2=== +this.state&&(this.state=0,dbg_log("icw3: "+h(a),LOG_PIC))};PIC.prototype.port21_read=function(){dbg_log("21h read "+h(~this.irq_mask&255),LOG_PIC);return~this.irq_mask&255};PIC.prototype.port4D0_read=function(){dbg_log("elcr read: "+h(this.elcr,2),LOG_PIC);return this.elcr};PIC.prototype.port4D0_write=function(a){dbg_log("elcr write: "+h(a,2),LOG_PIC);this.elcr=a};var CMOS_RTC_SECONDS=0,CMOS_RTC_SECONDS_ALARM=1,CMOS_RTC_MINUTES=2,CMOS_RTC_MINUTES_ALARM=3,CMOS_RTC_HOURS=4,CMOS_RTC_HOURS_ALARM=5,CMOS_RTC_DAY_WEEK=6,CMOS_RTC_DAY_MONTH=7,CMOS_RTC_MONTH=8,CMOS_RTC_YEAR=9,CMOS_STATUS_A=10,CMOS_STATUS_B=11,CMOS_STATUS_C=12,CMOS_STATUS_D=13,CMOS_RESET_CODE=15,CMOS_FLOPPY_DRIVE_TYPE=16,CMOS_DISK_DATA=18,CMOS_EQUIPMENT_INFO=20,CMOS_MEM_BASE_LOW=21,CMOS_MEM_BASE_HIGH=22,CMOS_MEM_OLD_EXT_LOW=23,CMOS_MEM_OLD_EXT_HIGH=24,CMOS_DISK_DRIVE1_TYPE=25,CMOS_DISK_DRIVE2_TYPE=26, +CMOS_DISK_DRIVE1_CYL=27,CMOS_DISK_DRIVE2_CYL=36,CMOS_MEM_EXTMEM_LOW=48,CMOS_MEM_EXTMEM_HIGH=49,CMOS_CENTURY=50,CMOS_MEM_EXTMEM2_LOW=52,CMOS_MEM_EXTMEM2_HIGH=53,CMOS_BIOS_BOOTFLAG1=56,CMOS_BIOS_DISKTRANSFLAG=57,CMOS_BIOS_BOOTFLAG2=61,CMOS_MEM_HIGHMEM_LOW=91,CMOS_MEM_HIGHMEM_MID=92,CMOS_MEM_HIGHMEM_HIGH=93,CMOS_BIOS_SMP_COUNT=95; +function RTC(a){this.cpu=a;this.cmos_index=0;this.cmos_data=new Uint8Array(128);this.last_update=this.rtc_time=Date.now();this.next_interrupt_alarm=this.next_interrupt=0;this.periodic_interrupt=!1;this.periodic_interrupt_time=.9765625;this.cmos_a=38;this.cmos_b=2;this.nmi_disabled=this.cmos_c=0;a.io.register_write(112,this,function(a){this.cmos_index=a&127;this.nmi_disabled=a>>7});a.io.register_write(113,this,this.cmos_port_write);a.io.register_read(113,this,this.cmos_port_read)} +RTC.prototype.get_state=function(){var a=[];a[0]=this.cmos_index;a[1]=this.cmos_data;a[2]=this.rtc_time;a[3]=this.last_update;a[4]=this.next_interrupt;a[5]=this.next_interrupt_alarm;a[6]=this.periodic_interrupt;a[7]=this.periodic_interrupt_time;a[8]=this.cmos_a;a[9]=this.cmos_b;a[10]=this.cmos_c;a[11]=this.nmi_disabled;return a}; +RTC.prototype.set_state=function(a){this.cmos_index=a[0];this.cmos_data=a[1];this.rtc_time=a[2];this.last_update=a[3];this.next_interrupt=a[4];this.next_interrupt_alarm=a[5];this.periodic_interrupt=a[6];this.periodic_interrupt_time=a[7];this.cmos_a=a[8];this.cmos_b=a[9];this.cmos_c=a[10];this.nmi_disabled=a[11]}; +RTC.prototype.timer=function(a,b){a=Date.now();this.rtc_time+=a-this.last_update;this.last_update=a;if(this.periodic_interrupt&&this.next_interrupt>4&15;dbg_assert(256>a);dbg_assert(10>b);dbg_assert(10>c);return b+10*c};RTC.prototype.encode_time=function(a){return this.cmos_b&4?a:this.bcd_pack(a)};RTC.prototype.decode_time=function(a){return this.cmos_b&4?a:this.bcd_unpack(a)}; +RTC.prototype.cmos_port_read=function(){var a=this.cmos_index;switch(a){case CMOS_RTC_SECONDS:return this.encode_time((new Date(this.rtc_time)).getUTCSeconds());case CMOS_RTC_MINUTES:return this.encode_time((new Date(this.rtc_time)).getUTCMinutes());case CMOS_RTC_HOURS:return this.encode_time((new Date(this.rtc_time)).getUTCHours());case CMOS_RTC_DAY_MONTH:return this.encode_time((new Date(this.rtc_time)).getUTCDate());case CMOS_RTC_MONTH:return this.encode_time((new Date(this.rtc_time)).getUTCMonth()+ +1);case CMOS_RTC_YEAR:return this.encode_time((new Date(this.rtc_time)).getUTCFullYear()%100);case CMOS_STATUS_A:return this.cmos_a;case CMOS_STATUS_B:return this.cmos_b;case CMOS_STATUS_C:return this.cpu.device_lower_irq(8),dbg_log("cmos reg C read",LOG_RTC),a=this.cmos_c,this.cmos_c&=-241,a;case CMOS_STATUS_D:return 255;case CMOS_CENTURY:return this.encode_time((new Date(this.rtc_time)).getUTCFullYear()/100|0);default:return dbg_log("cmos read from index "+h(a),LOG_RTC),this.cmos_data[this.cmos_index]}}; +RTC.prototype.cmos_port_write=function(a){switch(this.cmos_index){case 10:this.cmos_a=a&127;this.periodic_interrupt_time=1E3/(32768>>(this.cmos_a&15)-1);dbg_log("Periodic interrupt, a="+h(this.cmos_a,2)+" t="+this.periodic_interrupt_time,LOG_RTC);break;case 11:this.cmos_b=a;this.cmos_b&64&&(this.next_interrupt=Date.now());if(this.cmos_b&32){a=new Date;const b=this.decode_time(this.cmos_data[CMOS_RTC_SECONDS_ALARM]),c=this.decode_time(this.cmos_data[CMOS_RTC_MINUTES_ALARM]),d=this.decode_time(this.cmos_data[CMOS_RTC_HOURS_ALARM]), +e=new Date(Date.UTC(a.getUTCFullYear(),a.getUTCMonth(),a.getUTCDate(),d,c,b));dbg_log("RTC alarm scheduled for "+e+" hh:mm:ss="+d+":"+c+":"+b+" ms_from_now="+(e-a),LOG_RTC);this.next_interrupt_alarm=+e}this.cmos_b&16&&dbg_log("Unimplemented: updated interrupt",LOG_RTC);dbg_log("cmos b="+h(this.cmos_b,2),LOG_RTC);break;case CMOS_RTC_SECONDS_ALARM:case CMOS_RTC_MINUTES_ALARM:case CMOS_RTC_HOURS_ALARM:this.cmos_write(this.cmos_index,a);break;default:dbg_log("cmos write index "+h(this.cmos_index)+": "+ +h(a),LOG_RTC)}this.periodic_interrupt=64===(this.cmos_b&64)&&0<(this.cmos_a&15)};RTC.prototype.cmos_read=function(a){dbg_assert(128>a);return this.cmos_data[a]};RTC.prototype.cmos_write=function(a,b){dbg_log("cmos "+h(a)+" <- "+h(b),LOG_RTC);dbg_assert(128>a);this.cmos_data[a]=b};var DLAB=128,UART_IER_MSI=8,UART_IER_THRI=2,UART_IER_RDI=1,UART_IIR_MSI=0,UART_IIR_NO_INT=1,UART_IIR_THRI=2,UART_IIR_RDI=4,UART_IIR_RLSI=6,UART_IIR_CTI=12,UART_LSR_DATA_READY=1,UART_LSR_TX_EMPTY=32,UART_LSR_TRANSMITTER_EMPTY=64; +function UART(a,b,c){this.bus=c;this.cpu=a;this.ints=1<>8)});a.register_write(b|1,this,function(a){this.line_control&DLAB?(this.baud_rate=this.baud_rate&255|a<<8,dbg_log("baud rate: "+h(this.baud_rate),LOG_SERIAL)):(this.ier=a&15,dbg_log("interrupt enable: "+h(a),LOG_SERIAL),this.CheckInterrupt())});a.register_read(b, +this,function(){if(this.line_control&DLAB)return this.baud_rate&255;var a=this.input.shift();-1===a?dbg_log("Read input empty",LOG_SERIAL):dbg_log("Read input: "+h(a),LOG_SERIAL);0===this.input.length&&(this.lsr&=~UART_LSR_DATA_READY,this.ClearInterrupt(UART_IIR_CTI));return a});a.register_read(b|1,this,function(){return this.line_control&DLAB?this.baud_rate>>8:this.ier&15});a.register_read(b|2,this,function(){var a=this.iir&15|192;dbg_log("read interrupt identification: "+h(this.iir),LOG_SERIAL); +this.iir==UART_IIR_THRI&&this.ClearInterrupt(UART_IIR_THRI);return a});a.register_write(b|2,this,function(a){dbg_log("fifo control: "+h(a),LOG_SERIAL);this.fifo_control=a});a.register_read(b|3,this,function(){dbg_log("read line control: "+h(this.line_control),LOG_SERIAL);return this.line_control});a.register_write(b|3,this,function(a){dbg_log("line control: "+h(a),LOG_SERIAL);this.line_control=a});a.register_read(b|4,this,function(){return this.modem_control});a.register_write(b|4,this,function(a){dbg_log("modem control: "+ +h(a),LOG_SERIAL);this.modem_control=a});a.register_read(b|5,this,function(){dbg_log("read line status: "+h(this.lsr),LOG_SERIAL);return this.lsr});a.register_write(b|5,this,function(a){dbg_log("Factory test write",LOG_SERIAL)});a.register_read(b|6,this,function(){dbg_log("read modem status: "+h(this.modem_status),LOG_SERIAL);return this.modem_status});a.register_write(b|6,this,function(a){dbg_log("Unkown register write (base+6)",LOG_SERIAL)});a.register_read(b|7,this,function(){return this.scratch_register}); +a.register_write(b|7,this,function(a){this.scratch_register=a})}UART.prototype.get_state=function(){var a=[];a[0]=this.ints;a[1]=this.baud_rate;a[2]=this.line_control;a[3]=this.lsr;a[4]=this.fifo_control;a[5]=this.ier;a[6]=this.iir;a[7]=this.modem_control;a[8]=this.modem_status;a[9]=this.scratch_register;a[10]=this.irq;return a}; +UART.prototype.set_state=function(a){this.ints=a[0];this.baud_rate=a[1];this.line_control=a[2];this.lsr=a[3];this.fifo_control=a[4];this.ier=a[5];this.iir=a[6];this.modem_control=a[7];this.modem_status=a[8];this.scratch_register=a[9];this.irq=a[10]}; +UART.prototype.CheckInterrupt=function(){this.ints&1<>>0;for(var d,f,g=0;g>>0,q<=c?f>q&&f<=c:f>q||f<=c)f=d&4,d&2?(f=f&&!(m&1<< +g),m|=1<>2&7,g=a-256>>5;if(256>a||g>=HPET_NUM_COUNTERS||5this.timer_last_value),this.timer_last_value+this.timer_imprecision_offset<=a?(this.timer_imprecision_offset=0,this.timer_last_value=a):dbg_log("Warning: Overshot pmtimer, waiting; current="+a+" last="+this.timer_last_value+" offset="+this.timer_imprecision_offset,LOG_ACPI));return this.timer_last_value+ +this.timer_imprecision_offset};ACPI.prototype.get_state=function(){var a=[];a[0]=this.status;a[1]=this.pm1_status;a[2]=this.pm1_enable;a[3]=this.gpe;return a};ACPI.prototype.set_state=function(a){this.status=a[0];this.pm1_status=a[1];this.pm1_enable=a[2];this.gpe=a[3]};var APIC_LOG_VERBOSE=!1,APIC_ADDRESS=4276092928,APIC_TIMER_MODE_MASK=393216,APIC_TIMER_MODE_ONE_SHOT=0,APIC_TIMER_MODE_PERIODIC=131072,APIC_TIMER_MODE_TSC=262144,DELIVERY_MODES="Fixed (0);Lowest Prio (1);SMI (2);Reserved (3);NMI (4);INIT (5);Reserved (6);ExtINT (7)".split(";"),DESTINATION_MODES=["physical","logical"]; +function APIC(a){this.cpu=a;this.timer_divider=this.apic_id=0;this.timer_divider_shift=1;this.timer_current_count=this.timer_initial_count=0;this.next_tick=v86.microtick();this.lvt_error=this.lvt_int1=this.lvt_int0=this.lvt_perf_counter=this.lvt_timer=IOAPIC_CONFIG_MASKED;this.icr1=this.icr0=this.tpr=0;this.irr=new Int32Array(8);this.isr=new Int32Array(8);this.tmr=new Int32Array(8);this.spurious_vector=254;this.destination_format=-1;this.read_error=this.error=this.local_destination=0;a.io.mmap_register(APIC_ADDRESS, +1048576,a=>{dbg_log("Unsupported read8 from apic: "+h(a>>>0),LOG_APIC);var b=a&3;return this.read32(a&-4)>>8*b&255},(a,c)=>{dbg_log("Unsupported write8 from apic: "+h(a)+" <- "+h(c),LOG_APIC);dbg_trace();dbg_assert(!1)},a=>this.read32(a),(a,c)=>this.write32(a,c))} +APIC.prototype.read32=function(a){a=a-APIC_ADDRESS|0;switch(a){case 32:return dbg_log("APIC read id",LOG_APIC),this.apic_id;case 48:return dbg_log("APIC read version",LOG_APIC),327700;case 128:return APIC_LOG_VERBOSE&&dbg_log("APIC read tpr",LOG_APIC),this.tpr;case 208:return dbg_log("Read local destination",LOG_APIC),this.local_destination;case 224:return dbg_log("Read destination format",LOG_APIC),this.destination_format;case 240:return this.spurious_vector;case 256:case 272:case 288:case 304:case 320:case 336:case 352:case 368:return a= +a-256>>4,dbg_log("Read isr "+a+": "+h(this.isr[a]>>>0,8),LOG_APIC),this.isr[a];case 384:case 400:case 416:case 432:case 448:case 464:case 480:case 496:return a=a-384>>4,dbg_log("Read tmr "+a+": "+h(this.tmr[a]>>>0,8),LOG_APIC),this.tmr[a];case 512:case 528:case 544:case 560:case 576:case 592:case 608:case 624:return a=a-512>>4,dbg_log("Read irr "+a+": "+h(this.irr[a]>>>0,8),LOG_APIC),this.irr[a];case 640:return dbg_log("Read error: "+h(this.read_error>>>0,8),LOG_APIC),this.read_error;case 768:return APIC_LOG_VERBOSE&& +dbg_log("APIC read icr0",LOG_APIC),this.icr0;case 784:return dbg_log("APIC read icr1",LOG_APIC),this.icr1;case 800:return dbg_log("read timer lvt",LOG_APIC),this.lvt_timer;case 832:return dbg_log("read lvt perf counter",LOG_APIC),this.lvt_perf_counter;case 848:return dbg_log("read lvt int0",LOG_APIC),this.lvt_int0;case 864:return dbg_log("read lvt int1",LOG_APIC),this.lvt_int1;case 880:return dbg_log("read lvt error",LOG_APIC),this.lvt_error;case 992:return dbg_log("read timer divider",LOG_APIC), +this.timer_divider;case 896:return dbg_log("read timer initial count",LOG_APIC),this.timer_initial_count;case 912:return dbg_log("read timer current count: "+h(this.timer_current_count>>>0,8),LOG_APIC),this.timer_current_count;default:return dbg_log("APIC read "+h(a),LOG_APIC),dbg_assert(!1),0}}; +APIC.prototype.write32=function(a,b){a=a-APIC_ADDRESS|0;switch(a){case 48:dbg_log("APIC write version: "+h(b>>>0,8)+", ignored",LOG_APIC);break;case 128:APIC_LOG_VERBOSE&&dbg_log("Set tpr: "+h(b&255,2),LOG_APIC);this.tpr=b&255;this.check_vector();break;case 176:a=this.highest_isr();-1!==a?(APIC_LOG_VERBOSE&&dbg_log("eoi: "+h(b>>>0,8)+" for vector "+h(a),LOG_APIC),this.register_clear_bit(this.isr,a),this.register_get_bit(this.tmr,a)&&this.cpu.devices.ioapic.remote_eoi(a),this.check_vector()):dbg_log("Bad eoi: No isr set", +LOG_APIC);break;case 208:dbg_log("Set local destination: "+h(b>>>0,8),LOG_APIC);this.local_destination=b&4278190080;break;case 224:dbg_log("Set destination format: "+h(b>>>0,8),LOG_APIC);this.destination_format=b|16777215;break;case 240:dbg_log("Set spurious vector: "+h(b>>>0,8),LOG_APIC);this.spurious_vector=b;break;case 640:dbg_log("Write error: "+h(b>>>0,8),LOG_APIC);this.read_error=this.error;this.error=0;break;case 768:a=b&255;var c=b>>8&7,d=b>>11&1,e=b>>15&1,f=b>>18&3,k=this.icr1>>>24;dbg_log("APIC write icr0: "+ +h(b,8)+" vector="+h(a,2)+" destination_mode="+DESTINATION_MODES[d]+" delivery_mode="+DELIVERY_MODES[c]+" destination_shorthand="+["no","self","all with self","all without self"][f],LOG_APIC);this.icr0=b&-4097;0===f?this.route(a,c,e,k,d):1===f?this.deliver(a,IOAPIC_DELIVERY_FIXED,e):2===f?this.deliver(a,c,e):3!==f&&dbg_assert(!1);break;case 784:dbg_log("APIC write icr1: "+h(b>>>0,8),LOG_APIC);this.icr1=b;break;case 800:dbg_log("timer lvt: "+h(b>>>0,8),LOG_APIC);this.lvt_timer=b;break;case 832:dbg_log("lvt perf counter: "+ +h(b>>>0,8),LOG_APIC);this.lvt_perf_counter=b;break;case 848:dbg_log("lvt int0: "+h(b>>>0,8),LOG_APIC);this.lvt_int0=b;break;case 864:dbg_log("lvt int1: "+h(b>>>0,8),LOG_APIC);this.lvt_int1=b;break;case 880:dbg_log("lvt error: "+h(b>>>0,8),LOG_APIC);this.lvt_error=b;break;case 992:dbg_log("timer divider: "+h(b>>>0,8),LOG_APIC);this.timer_divider=b;b=b&3|(b&8)>>1;this.timer_divider_shift=7===b?0:b+1;break;case 896:dbg_log("timer initial: "+h(b>>>0,8),LOG_APIC);this.timer_initial_count=b>>>0;this.timer_current_count= +b>>>0;this.next_tick=v86.microtick();this.timer_active=!0;break;case 912:dbg_log("timer current: "+h(b>>>0,8),LOG_APIC);dbg_assert(!1,"read-only register");break;default:dbg_log("APIC write32 "+h(a)+" <- "+h(b>>>0,8),LOG_APIC),dbg_assert(!1)}}; +APIC.prototype.timer=function(a){0!==this.timer_current_count&&(a=(a-this.next_tick)*TSC_RATE/(1<>>0,0!==a&&(this.next_tick+=a/TSC_RATE*(1<=this.timer_current_count&&(a=this.lvt_timer&APIC_TIMER_MODE_MASK,a===APIC_TIMER_MODE_PERIODIC?(this.timer_current_count%=this.timer_initial_count,0>=this.timer_current_count&&(this.timer_current_count+=this.timer_initial_count),dbg_assert(0!==this.timer_current_count),0===(this.lvt_timer& +IOAPIC_CONFIG_MASKED)&&this.deliver(this.lvt_timer&255,IOAPIC_DELIVERY_FIXED,!1)):a===APIC_TIMER_MODE_ONE_SHOT&&(this.timer_current_count=0,dbg_log("APIC timer one shot end",LOG_APIC),0===(this.lvt_timer&IOAPIC_CONFIG_MASKED)&&this.deliver(this.lvt_timer&255,IOAPIC_DELIVERY_FIXED,!1)))))};APIC.prototype.route=function(a,b,c,d,e){this.deliver(a,b,c)}; +APIC.prototype.deliver=function(a,b,c){APIC_LOG_VERBOSE&&dbg_log("Deliver "+h(a,2)+" mode="+b+" level="+c,LOG_APIC);b!==IOAPIC_DELIVERY_INIT&&b!==IOAPIC_DELIVERY_NMI&&((16>a||255===a)&&dbg_assert(!1,"TODO: Invalid vector"),this.register_get_bit(this.irr,a)?dbg_log("Not delivered: irr already set, vector="+h(a,2),LOG_APIC):(this.register_set_bit(this.irr,a),c?this.register_set_bit(this.tmr,a):this.register_clear_bit(this.tmr,a),this.check_vector()))}; +APIC.prototype.highest_irr=function(){var a=this.register_get_highest_bit(this.irr);dbg_assert(255!==a);dbg_assert(16<=a||-1===a);return a};APIC.prototype.highest_isr=function(){var a=this.register_get_highest_bit(this.isr);dbg_assert(255!==a);dbg_assert(16<=a||-1===a);return a}; +APIC.prototype.check_vector=function(){var a=this.highest_irr();if(-1!==a){var b=this.highest_isr();b>=a?APIC_LOG_VERBOSE&&dbg_log("Higher isr, isr="+h(b)+" irr="+h(a),LOG_APIC):(a&240)<=(this.tpr&240)?APIC_LOG_VERBOSE&&dbg_log("Higher tpr, tpr="+h(this.tpr&240)+" irr="+h(a),LOG_APIC):this.cpu.handle_irqs()}}; +APIC.prototype.acknowledge_irq=function(){var a=this.highest_irr();if(-1!==a){var b=this.highest_isr();b>=a?APIC_LOG_VERBOSE&&dbg_log("Higher isr, isr="+h(b)+" irr="+h(a),LOG_APIC):(a&240)<=(this.tpr&240)?APIC_LOG_VERBOSE&&dbg_log("Higher tpr, tpr="+h(this.tpr&240)+" irr="+h(a),LOG_APIC):(this.register_clear_bit(this.irr,a),this.register_set_bit(this.isr,a),APIC_LOG_VERBOSE&&dbg_log("Calling vector "+h(a),LOG_APIC),this.cpu.pic_call_irq(a),this.check_vector())}}; +APIC.prototype.get_state=function(){var a=[];a[0]=this.apic_id;a[1]=this.timer_divider;a[2]=this.timer_divider_shift;a[3]=this.timer_initial_count;a[4]=this.timer_current_count;a[5]=this.next_tick;a[6]=this.lvt_timer;a[7]=this.lvt_perf_counter;a[8]=this.lvt_int0;a[9]=this.lvt_int1;a[10]=this.lvt_error;a[11]=this.tpr;a[12]=this.icr0;a[13]=this.icr1;a[14]=this.irr;a[15]=this.isr;a[16]=this.tmr;a[17]=this.spurious_vector;a[18]=this.destination_format;a[19]=this.local_destination;a[20]=this.error;a[21]= +this.read_error;return a}; +APIC.prototype.set_state=function(a){this.apic_id=a[0];this.timer_divider=a[1];this.timer_divider_shift=a[2];this.timer_initial_count=a[3];this.timer_current_count=a[4];this.next_tick=a[5];this.lvt_timer=a[6];this.lvt_perf_counter=a[7];this.lvt_int0=a[8];this.lvt_int1=a[9];this.lvt_error=a[10];this.tpr=a[11];this.icr0=a[12];this.icr1=a[13];this.irr=a[14];this.isr=a[15];this.tmr=a[16];this.spurious_vector=a[17];this.destination_format=a[18];this.local_destination=a[19];this.error=a[20];this.read_error= +a[21]};APIC.prototype.register_get_bit=function(a,b){dbg_assert(0<=b&&256>b);return a[b>>5]>>(b&31)&1};APIC.prototype.register_set_bit=function(a,b){dbg_assert(0<=b&&256>b);a[b>>5]|=1<<(b&31)};APIC.prototype.register_clear_bit=function(a,b){dbg_assert(0<=b&&256>b);a[b>>5]&=~(1<<(b&31))};APIC.prototype.register_get_highest_bit=function(a){for(var b=7;0<=b;b--){var c=a[b];if(c)return v86util.int_log2(c>>>0)|b<<5}return-1};var IOAPIC_ADDRESS=4273995776,IOREGSEL=0,IOWIN=16,IOAPIC_IRQ_COUNT=24,IOAPIC_ID=0,IOAPIC_CONFIG_TRIGGER_MODE_LEVEL=32768,IOAPIC_CONFIG_MASKED=65536,IOAPIC_CONFIG_DELIVS=4096,IOAPIC_CONFIG_REMOTE_IRR=16384,IOAPIC_CONFIG_READONLY_MASK=IOAPIC_CONFIG_REMOTE_IRR|IOAPIC_CONFIG_DELIVS|4294836224,IOAPIC_DELIVERY_FIXED=0,IOAPIC_DELIVERY_LOWEST_PRIORITY=1,IOAPIC_DELIVERY_NMI=4,IOAPIC_DELIVERY_INIT=5; +function IOAPIC(a){this.cpu=a;this.ioredtbl_config=new Int32Array(IOAPIC_IRQ_COUNT);this.ioredtbl_destination=new Int32Array(IOAPIC_IRQ_COUNT);for(var b=0;b{a=a-IOAPIC_ADDRESS|0;if(a>=IOWIN&&a>8*a&255;dbg_log("Unexpected IOAPIC register read: "+h(a>>>0),LOG_APIC);dbg_assert(!1);return 0},(a,b)=>{dbg_assert(!1,"unsupported write8 from ioapic: "+h(a>>>0))},a=>{a=a-IOAPIC_ADDRESS|0;if(a===IOREGSEL)return this.ioregsel;if(a===IOWIN)return this.read(this.ioregsel);dbg_log("Unexpected IOAPIC register read: "+h(a>>>0),LOG_APIC);dbg_assert(!1);return 0},(a,b)=>{a=a-IOAPIC_ADDRESS|0;a===IOREGSEL?this.ioregsel=b:a===IOWIN?this.write(this.ioregsel,b):(dbg_log("Unexpected IOAPIC register write: "+ +h(a>>>0)+" <- "+h(b>>>0,8),LOG_APIC),dbg_assert(!1))})}IOAPIC.prototype.remote_eoi=function(a){for(var b=0;b=IOAPIC_IRQ_COUNT)dbg_assert(!1,"Bad irq: "+a,LOG_APIC);else{var b=1<=IOAPIC_IRQ_COUNT)dbg_assert(!1,"Bad irq: "+a,LOG_APIC);else{var b=1<>1;a&1?(a=this.ioredtbl_destination[b],dbg_log("IOAPIC Read destination irq="+h(b)+" -> "+h(a,8),LOG_APIC)):(a=this.ioredtbl_config[b],dbg_log("IOAPIC Read config irq="+h(b)+" -> "+h(a,8), +LOG_APIC));return a}dbg_log("IOAPIC register read outside of range "+h(a),LOG_APIC);dbg_assert(!1);return 0}; +IOAPIC.prototype.write=function(a,b){if(0===a)this.ioapic_id=b>>>24&15;else if(1===a||2===a)dbg_log("Invalid write: "+a,LOG_APIC);else if(16<=a&&a<16+2*IOAPIC_IRQ_COUNT){var c=a-16>>1;if(a&1)this.ioredtbl_destination[c]=b&4278190080,dbg_log("Write destination "+h(b>>>0,8)+" irq="+h(c)+" dest="+h(b>>>24,2),LOG_APIC);else{this.ioredtbl_config[c]=b&~IOAPIC_CONFIG_READONLY_MASK|this.ioredtbl_config[c]&IOAPIC_CONFIG_READONLY_MASK;a=b&255;var d=b>>8&7,e=b>>11&1,f=b>>15&1,k=b>>16&1;dbg_log("Write config "+ +h(b>>>0,8)+" irq="+h(c)+" vector="+h(a,2)+" deliverymode="+DELIVERY_MODES[d]+" destmode="+DESTINATION_MODES[e]+" is_level="+f+" disabled="+k,LOG_APIC);this.check_irq(c)}}else dbg_log("IOAPIC register write outside of range "+h(a)+": "+h(b>>>0,8),LOG_APIC),dbg_assert(!1)};IOAPIC.prototype.get_state=function(){var a=[];a[0]=this.ioredtbl_config;a[1]=this.ioredtbl_destination;a[2]=this.ioregsel;a[3]=this.ioapic_id;a[4]=this.irr;a[5]=this.irq_value;return a}; +IOAPIC.prototype.set_state=function(a){this.ioredtbl_config=a[0];this.ioredtbl_destination=a[1];this.ioregsel=a[2];this.ioapic_id=a[3];this.irr=a[4];this.irq_value=a[5]};var STATE_VERSION=6,STATE_MAGIC=-2039052682,STATE_INDEX_MAGIC=0,STATE_INDEX_VERSION=1,STATE_INDEX_TOTAL_LEN=2,STATE_INDEX_INFO_LEN=3,STATE_INFO_BLOCK_START=16;const ZSTD_MAGIC=4247762216;function StateLoadError(a){this.message=a}StateLoadError.prototype=Error();const CONSTRUCTOR_TABLE={Uint8Array,Int8Array,Uint16Array,Int16Array,Uint32Array,Int32Array,Float32Array,Float64Array}; +function save_object(a,b){if("object"!==typeof a||null===a)return dbg_assert("function"!==typeof a),a;if(a instanceof Array)return a.map(a=>save_object(a,b));a.constructor===Object&&(console.log(a),dbg_assert(a.constructor!==Object,"Expected non-object"));if(a.BYTES_PER_ELEMENT){var c=new Uint8Array(a.buffer,a.byteOffset,a.length*a.BYTES_PER_ELEMENT);a=a.constructor.name.replace("bound ","");dbg_assert(CONSTRUCTOR_TABLE[a]);return{__state_type__:a,buffer_id:b.push(c)-1}}DEBUG&&!a.get_state&&console.log("Object without get_state: ", +a);c=a.get_state();a=[];for(var d=0;d>10)+"k");dbg_log("State: Total buffers size "+(f.byteLength>>10)+"k");return d}; +CPU.prototype.restore_state=function(a){function b(a,b){const c=a.length;if(c>>0));if(a[STATE_INDEX_VERSION]!==STATE_VERSION)throw new StateLoadError("Version mismatch: dump="+a[STATE_INDEX_VERSION]+" we="+STATE_VERSION);if(b&&a[STATE_INDEX_TOTAL_LEN]!==c)throw new StateLoadError("Length doesn't match header: real="+ +c+" header="+a[STATE_INDEX_TOTAL_LEN]);return a[STATE_INDEX_INFO_LEN]}function c(a){a=(new TextDecoder).decode(a);return JSON.parse(a)}a=new Uint8Array(a);if((new Uint32Array(a.buffer,0,1))[0]===ZSTD_MAGIC){var d=this.zstd_create_ctx(a.length);(new Uint8Array(this.wasm_memory.buffer,this.zstd_get_src_ptr(d),a.length)).set(a);var e=this.zstd_read(d,16),f=new Uint8Array(this.wasm_memory.buffer,e,16),k=b(f,!1);this.zstd_read_free(e,16);e=this.zstd_read(d,k);f=new Uint8Array(this.wasm_memory.buffer,e, +k);f=c(f);this.zstd_read_free(e,k);e=f.state;var g=f.buffer_infos;f=[];k=STATE_INFO_BLOCK_START+k;for(var l of g){g=(k+3&-4)-k;if(1048576d||d+12>=a.length)throw new StateLoadError("Invalid info block length: "+d);l=a.subarray(STATE_INFO_BLOCK_START,STATE_INFO_BLOCK_START+d);e=c(l);l=e.state;e=e.buffer_infos;let f=STATE_INFO_BLOCK_START+d;f=f+3&-4;d=e.map(b=>{const c=f+b.offset;return a.buffer.slice(c,c+b.length)});l=restore_buffers(l,d);this.set_state(l)}};const NE2K_LOG_VERBOSE=!1; +var E8390_CMD=0,EN0_CLDALO=1,EN0_STARTPG=1,EN0_CLDAHI=2,EN0_STOPPG=2,EN0_BOUNDARY=3,EN0_TSR=4,EN0_TPSR=4,EN0_NCR=5,EN0_TCNTLO=5,EN0_FIFO=6,EN0_TCNTHI=6,EN0_ISR=7,EN0_CRDALO=8,EN0_RSARLO=8,EN0_CRDAHI=9,EN0_RSARHI=9,EN0_RCNTLO=10,EN0_RCNTHI=11,EN0_RSR=12,EN0_RXCR=12,EN0_TXCR=13,EN0_COUNTER0=13,EN0_DCFG=14,EN0_COUNTER1=14,EN0_IMR=15,EN0_COUNTER2=15,NE_DATAPORT=16,NE_RESET=31,ENISR_RX=1,ENISR_TX=2,ENISR_RX_ERR=4,ENISR_TX_ERR=8,ENISR_OVER=16,ENISR_COUNTERS=32,ENISR_RDC=64,ENISR_RESET=128,ENISR_ALL=63, +ENRSR_RXOK=1,START_PAGE=64,START_RX_PAGE=76,STOP_PAGE=128; +function Ne2k(a,b,c,d){this.cpu=a;this.pci=a.devices.pci;this.preserve_mac_from_state_image=c;this.bus=b;this.bus.register("net0-receive",function(a){this.receive(a)},this);this.port=768;this.name="ne2k";this.pci_space=[236,16,41,128,3,1,0,0,0,0,0,2,0,0,0,0,this.port&255|1,this.port>>8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,244,26,0,17,0,0,184,254,0,0,0,0,0,0,0,0,0,1,0,0];this.pci_id=40;this.pci_bars=[{size:32}];this.imr=this.isr=0;this.cr=1;this.tpsr=this.tcnt=this.rcnt=this.dcfg=0; +this.memory=new Uint8Array(32768);this.txcr=this.rxcr=0;this.tsr=1;this.mac=d?d:new Uint8Array([0,34,21,255*Math.random()|0,255*Math.random()|0,255*Math.random()|0]);for(b=0;6>b;b++)this.memory[b<<1]=this.memory[b<<1|1]=this.mac[b];this.memory[28]=this.memory[29]=87;this.memory[30]=this.memory[31]=87;dbg_log("Mac: "+h(this.mac[0],2)+":"+h(this.mac[1],2)+":"+h(this.mac[2],2)+":"+h(this.mac[3],2)+":"+h(this.mac[4],2)+":"+h(this.mac[5],2),LOG_NET);this.rsar=0;this.pstart=START_PAGE;this.pstop=STOP_PAGE; +this.boundary=this.curpg=START_RX_PAGE;b=a.io;b.register_read(this.port|E8390_CMD,this,function(){dbg_log("Read cmd",LOG_NET);return this.cr});b.register_write(this.port|E8390_CMD,this,function(a){this.cr=a;dbg_log("Write command: "+h(a,2)+" newpg="+(this.cr>>6)+" txcr="+h(this.txcr,2),LOG_NET);this.cr&1||(a&24&&0===this.rcnt&&this.do_interrupt(ENISR_RDC),a&4&&(a=this.tpsr<<8,a=this.memory.subarray(a,a+this.tcnt),this.bus.send("net0-send",a),this.bus.send("eth-transmit-end",[a.length]),this.cr&=-5, +this.do_interrupt(ENISR_TX),dbg_log("Command: Transfer. length="+h(a.byteLength),LOG_NET)))});b.register_read(this.port|EN0_COUNTER0,this,function(){dbg_log("Read counter0",LOG_NET);return 0});b.register_read(this.port|EN0_COUNTER1,this,function(){dbg_log("Read counter1",LOG_NET);return 0});b.register_read(this.port|EN0_COUNTER2,this,function(){dbg_log("Read counter2",LOG_NET);return 0});b.register_read(this.port|NE_RESET,this,function(){var a=this.get_page();0===a?(dbg_log("Read reset",LOG_NET), +this.do_interrupt(ENISR_RESET)):(dbg_log("Read pg"+a+"/1f",LOG_NET),dbg_assert(!1));return 0});b.register_write(this.port|NE_RESET,this,function(a){var b=this.get_page();0===b?dbg_log("Write reset: "+h(a,2),LOG_NET):(dbg_log("Write pg"+b+"/1f: "+h(a),LOG_NET),dbg_assert(!1))});b.register_read(this.port|EN0_STARTPG,this,function(){var a=this.get_page();if(0===a)return this.pstart;if(1===a)return dbg_log("Read pg1/01 (mac[0])",LOG_NET),this.mac[0];if(2===a)return this.pstart;dbg_log("Read pg"+a+"/01"); +dbg_assert(!1);return 0});b.register_write(this.port|EN0_STARTPG,this,function(a){var b=this.get_page();0===b?(dbg_log("start page: "+h(a,2),LOG_NET),this.pstart=a):1===b?(dbg_log("mac[0] = "+h(a),LOG_NET),this.mac[0]=a):3===b?dbg_log("Unimplemented: Write pg3/01 (9346CR): "+h(a),LOG_NET):(dbg_log("Write pg"+b+"/01: "+h(a),LOG_NET),dbg_assert(!1))});b.register_read(this.port|EN0_STOPPG,this,function(){var a=this.get_page();if(0===a)return this.pstop;if(1===a)return dbg_log("Read pg1/02 (mac[1])", +LOG_NET),this.mac[1];if(2===a)return this.pstop;dbg_log("Read pg"+a+"/02",LOG_NET);dbg_assert(!1);return 0});b.register_write(this.port|EN0_STOPPG,this,function(a){var b=this.get_page();0===b?(dbg_log("stop page: "+h(a,2),LOG_NET),a>this.memory.length>>8&&(a=this.memory.length>>8,dbg_log("XXX: Adjusting stop page to "+h(a),LOG_NET)),this.pstop=a):1===b?(dbg_log("mac[1] = "+h(a),LOG_NET),this.mac[1]=a):(dbg_log("Write pg"+b+"/02: "+h(a),LOG_NET),dbg_assert(!1))});b.register_read(this.port|EN0_ISR, +this,function(){var a=this.get_page();if(0===a)return dbg_log("Read isr: "+h(this.isr,2),LOG_NET),this.isr;if(1===a)return dbg_log("Read curpg: "+h(this.curpg,2),LOG_NET),this.curpg;dbg_assert(!1)});b.register_write(this.port|EN0_ISR,this,function(a){var b=this.get_page();0===b?(dbg_log("Write isr: "+h(a,2),LOG_NET),this.isr&=~a,this.update_irq()):1===b?(dbg_log("Write curpg: "+h(a,2),LOG_NET),this.curpg=a):dbg_assert(!1)});b.register_write(this.port|EN0_TXCR,this,function(a){var b=this.get_page(); +0===b?(this.txcr=a,dbg_log("Write tx config: "+h(a,2),LOG_NET)):dbg_log("Unimplemented: Write pg"+b+"/0d "+h(a,2),LOG_NET)});b.register_write(this.port|EN0_DCFG,this,function(a){var b=this.get_page();0===b?(dbg_log("Write data configuration: "+h(a,2),LOG_NET),this.dcfg=a):dbg_log("Unimplemented: Write pg"+b+"/0e "+h(a,2),LOG_NET)});b.register_read(this.port|EN0_RCNTLO,this,function(){if(0===this.get_page())return dbg_log("Read pg0/0a",LOG_NET),80;dbg_assert(!1,"TODO");return 0});b.register_write(this.port| +EN0_RCNTLO,this,function(a){var b=this.get_page();0===b?(dbg_log("Write remote byte count low: "+h(a,2),LOG_NET),this.rcnt=this.rcnt&65280|a&255):dbg_log("Unimplemented: Write pg"+b+"/0a "+h(a,2),LOG_NET)});b.register_read(this.port|EN0_RCNTHI,this,function(){if(0===this.get_page())return dbg_log("Read pg0/0b",LOG_NET),67;dbg_assert(!1,"TODO");return 0});b.register_write(this.port|EN0_RCNTHI,this,function(a){var b=this.get_page();0===b?(dbg_log("Write remote byte count high: "+h(a,2),LOG_NET),this.rcnt= +this.rcnt&255|a<<8&65280):dbg_log("Unimplemented: Write pg"+b+"/0b "+h(a,2),LOG_NET)});b.register_read(this.port|EN0_RSARLO,this,function(){var a=this.get_page();if(0===a)return dbg_log("Read remote start address low",LOG_NET),this.rsar&255;dbg_log("Unimplemented: Read pg"+a+"/08",LOG_NET);dbg_assert(!1)});b.register_write(this.port|EN0_RSARLO,this,function(a){var b=this.get_page();0===b?(dbg_log("Write remote start address low: "+h(a,2),LOG_NET),this.rsar=this.rsar&65280|a&255):dbg_log("Unimplemented: Write pg"+ +b+"/08 "+h(a,2),LOG_NET)});b.register_read(this.port|EN0_RSARHI,this,function(){var a=this.get_page();if(0===a)return dbg_log("Read remote start address high",LOG_NET),this.rsar>>8&255;dbg_log("Unimplemented: Read pg"+a+"/09",LOG_NET);dbg_assert(!1)});b.register_write(this.port|EN0_RSARHI,this,function(a){var b=this.get_page();0===b?(dbg_log("Write remote start address low: "+h(a,2),LOG_NET),this.rsar=this.rsar&255|a<<8&65280):dbg_log("Unimplemented: Write pg"+b+"/09 "+h(a,2),LOG_NET)});b.register_write(this.port| +EN0_IMR,this,function(a){var b=this.get_page();0===b?(dbg_log("Write interrupt mask register: "+h(a,2)+" isr="+h(this.isr,2),LOG_NET),this.imr=a,this.update_irq()):dbg_log("Unimplemented: Write pg"+b+"/0f "+h(a,2),LOG_NET)});b.register_read(this.port|EN0_BOUNDARY,this,function(){var a=this.get_page();if(0===a)return dbg_log("Read boundary: "+h(this.boundary,2),LOG_NET),this.boundary;if(1===a)return dbg_log("Read pg1/03 (mac[2])",LOG_NET),this.mac[2];3===a?dbg_log("Unimplemented: Read pg3/03 (CONFIG0)", +LOG_NET):(dbg_log("Read pg"+a+"/03",LOG_NET),dbg_assert(!1));return 0});b.register_write(this.port|EN0_BOUNDARY,this,function(a){var b=this.get_page();0===b?(dbg_log("Write boundary: "+h(a,2),LOG_NET),this.boundary=a):1===b?(dbg_log("mac[2] = "+h(a),LOG_NET),this.mac[2]=a):(dbg_log("Write pg"+b+"/03: "+h(a),LOG_NET),dbg_assert(!1))});b.register_read(this.port|EN0_TSR,this,function(){var a=this.get_page();if(0===a)return this.tsr;if(1===a)return dbg_log("Read pg1/04 (mac[3])",LOG_NET),this.mac[3]; +dbg_log("Read pg"+a+"/04",LOG_NET);dbg_assert(!1);return 0});b.register_write(this.port|EN0_TPSR,this,function(a){var b=this.get_page();0===b?(dbg_log("Write tpsr: "+h(a,2),LOG_NET),this.tpsr=a):1===b?(dbg_log("mac[3] = "+h(a),LOG_NET),this.mac[3]=a):(dbg_log("Write pg"+b+"/04: "+h(a),LOG_NET),dbg_assert(!1))});b.register_read(this.port|EN0_TCNTLO,this,function(){var a=this.get_page();if(0===a)return dbg_log("Unimplemented: Read pg0/05 (NCR: Number of Collisions Register)",LOG_NET),0;if(1===a)return dbg_log("Read pg1/05 (mac[4])", +LOG_NET),this.mac[4];3===a?dbg_log("Unimplemented: Read pg3/05 (CONFIG2)",LOG_NET):(dbg_log("Read pg"+a+"/05",LOG_NET),dbg_assert(!1));return 0});b.register_write(this.port|EN0_TCNTLO,this,function(a){var b=this.get_page();0===b?(dbg_log("Write tcnt low: "+h(a,2),LOG_NET),this.tcnt=this.tcnt&-256|a):1===b?(dbg_log("mac[4] = "+h(a),LOG_NET),this.mac[4]=a):3===b?dbg_log("Unimplemented: Write pg3/05 (CONFIG2): "+h(a),LOG_NET):(dbg_log("Write pg"+b+"/05: "+h(a),LOG_NET),dbg_assert(!1))});b.register_read(this.port| +EN0_TCNTHI,this,function(){var a=this.get_page();if(0===a)return dbg_assert(!1,"TODO"),0;if(1===a)return dbg_log("Read pg1/06 (mac[5])",LOG_NET),this.mac[5];3===a?dbg_log("Unimplemented: Read pg3/06 (CONFIG3)",LOG_NET):(dbg_log("Read pg"+a+"/06",LOG_NET),dbg_assert(!1));return 0});b.register_write(this.port|EN0_TCNTHI,this,function(a){var b=this.get_page();0===b?(dbg_log("Write tcnt high: "+h(a,2),LOG_NET),this.tcnt=this.tcnt&255|a<<8):1===b?(dbg_log("mac[5] = "+h(a),LOG_NET),this.mac[5]=a):3===b? +dbg_log("Unimplemented: Write pg3/06 (CONFIG3): "+h(a),LOG_NET):(dbg_log("Write pg"+b+"/06: "+h(a),LOG_NET),dbg_assert(!1))});b.register_read(this.port|EN0_RSR,this,function(){var a=this.get_page();if(0===a)return 9;dbg_log("Unimplemented: Read pg"+a+"/0c",LOG_NET);dbg_assert(!1);return 0});b.register_write(this.port|EN0_RXCR,this,function(a){var b=this.get_page();0===b?(dbg_log("RX configuration reg write: "+h(a,2),LOG_NET),this.rxcr=a):dbg_log("Unimplemented: Write pg"+b+"/0c: "+h(a),LOG_NET)}); +b.register_read(this.port|NE_DATAPORT|0,this,this.data_port_read8,this.data_port_read16,this.data_port_read32);b.register_write(this.port|NE_DATAPORT|0,this,this.data_port_write16,this.data_port_write16,this.data_port_write32);a.devices.pci.register_device(this)} +Ne2k.prototype.get_state=function(){var a=[];a[0]=this.isr;a[1]=this.imr;a[2]=this.cr;a[3]=this.dcfg;a[4]=this.rcnt;a[5]=this.tcnt;a[6]=this.tpsr;a[7]=this.rsar;a[8]=this.pstart;a[9]=this.curpg;a[10]=this.boundary;a[11]=this.pstop;a[12]=this.rxcr;a[13]=this.txcr;a[14]=this.tsr;a[15]=this.mac;a[16]=this.memory;return a}; +Ne2k.prototype.set_state=function(a){this.isr=a[0];this.imr=a[1];this.cr=a[2];this.dcfg=a[3];this.rcnt=a[4];this.tcnt=a[5];this.tpsr=a[6];this.rsar=a[7];this.pstart=a[8];this.curpg=a[9];this.boundary=a[10];this.pstop=a[11];this.rxcr=a[12];this.txcr=a[13];this.tsr=a[14];this.preserve_mac_from_state_image&&(this.mac=a[15],this.memory=a[16])};Ne2k.prototype.do_interrupt=function(a){dbg_log("Do interrupt "+h(a,2),LOG_NET);this.isr|=a;this.update_irq()}; +Ne2k.prototype.update_irq=function(){this.imr&this.isr?this.pci.raise_irq(this.pci_id):this.pci.lower_irq(this.pci_id)};Ne2k.prototype.data_port_write=function(a){NE2K_LOG_VERBOSE&&dbg_log("Write data port: data="+h(a&255,2)+" rsar="+h(this.rsar,4)+" rcnt="+h(this.rcnt,4),LOG_NET);if(16>=this.rsar||this.rsar>=START_PAGE<<8&&this.rsar=this.pstop<<8&&(this.rsar+=this.pstart-this.pstop<<8);0===this.rcnt&&this.do_interrupt(ENISR_RDC)}; +Ne2k.prototype.data_port_write16=function(a){this.data_port_write(a);this.dcfg&1&&this.data_port_write(a>>8)};Ne2k.prototype.data_port_write32=function(a){this.data_port_write(a);this.data_port_write(a>>8);this.data_port_write(a>>16);this.data_port_write(a>>24)}; +Ne2k.prototype.data_port_read=function(){let a=0;this.rsar>8),f=b+c,k=1+(c>>8),g=this.boundary>this.curpg?this.boundary-this.curpg:this.pstop- +this.curpg+this.boundary-this.pstart;g exit highspeed",LOG_SB16),this.dsp_highspeed=!1):a&&(dbg_log(" -> reset",LOG_SB16),this.dsp_reset());this.read_buffer.clear();this.read_buffer.push(170)};SB16.prototype.port2x7_write=function(a){dbg_log("227 write: undocumented",LOG_SB16)}; +SB16.prototype.port2x8_write=function(a){dbg_log("228 write: fm music register port (unimplemented)",LOG_SB16)};SB16.prototype.port2x9_write=function(a){dbg_log("229 write: fm music data port (unimplemented)",LOG_SB16)};SB16.prototype.port2xA_write=function(a){dbg_log("22A write: dsp read data port (read only)",LOG_SB16)};SB16.prototype.port2xB_write=function(a){dbg_log("22B write: undocumented",LOG_SB16)}; +SB16.prototype.port2xC_write=function(a){dbg_log("22C write: write command/data",LOG_SB16);this.command===DSP_NO_COMMAND?(dbg_log("22C write: command = "+h(a),LOG_SB16),this.command=a,this.write_buffer.clear(),this.command_size=DSP_COMMAND_SIZES[a]):(dbg_log("22C write: data: "+h(a),LOG_SB16),this.write_buffer.push(a));this.write_buffer.length>=this.command_size&&this.command_do()};SB16.prototype.port2xD_write=function(a){dbg_log("22D write: undocumented",LOG_SB16)}; +SB16.prototype.port2xE_write=function(a){dbg_log("22E write: dsp read buffer status (read only)",LOG_SB16)};SB16.prototype.port2xF_write=function(a){dbg_log("22F write: undocumented",LOG_SB16)};SB16.prototype.port3x0_read=function(){dbg_log("330 read: mpu data",LOG_SB16);this.mpu_read_buffer.length&&(this.mpu_read_buffer_lastvalue=this.mpu_read_buffer.shift());dbg_log(" <- "+h(this.mpu_read_buffer_lastvalue),LOG_SB16);return this.mpu_read_buffer_lastvalue}; +SB16.prototype.port3x0_write=function(a){dbg_log("330 write: mpu data (unimplemented) : "+h(a),LOG_SB16)};SB16.prototype.port3x1_read=function(){dbg_log("331 read: mpu status",LOG_SB16);return 0|128*!this.mpu_read_buffer.length};SB16.prototype.port3x1_write=function(a){dbg_log("331 write: mpu command: "+h(a),LOG_SB16);255==a&&(this.mpu_read_buffer.clear(),this.mpu_read_buffer.push(254))}; +SB16.prototype.command_do=function(){var a=DSP_COMMAND_HANDLERS[this.command];a||(a=this.dsp_default_handler);a.call(this);this.command=DSP_NO_COMMAND;this.command_size=0;this.write_buffer.clear()};SB16.prototype.dsp_default_handler=function(){dbg_log("Unhandled command: "+h(this.command),LOG_SB16)};function register_dsp_command(a,b,c){c||(c=SB16.prototype.dsp_default_handler);for(var d=0;dc;c++)b.push(a+c);return b}register_dsp_command([14],2,function(){this.asp_registers[this.write_buffer.shift()]=this.write_buffer.shift()});register_dsp_command([15],1,function(){this.read_buffer.clear();this.read_buffer.push(this.asp_registers[this.write_buffer.shift()])});register_dsp_command([16],1,function(){var a=audio_normalize(this.write_buffer.shift(),127.5,-1);this.dac_buffers[0].push(a);this.dac_buffers[1].push(a);this.bus.send("dac-enable")}); +register_dsp_command([20,21],2,function(){this.dma_irq=SB_IRQ_8BIT;this.dma_channel=this.dma_channel_8bit;this.dsp_highspeed=this.dsp_16bit=this.dsp_signed=this.dma_autoinit=!1;this.dma_transfer_size_set();this.dma_transfer_start()});register_dsp_command([22],2);register_dsp_command([23],2);register_dsp_command([28],0,function(){this.dma_irq=SB_IRQ_8BIT;this.dma_channel=this.dma_channel_8bit;this.dma_autoinit=!0;this.dsp_highspeed=this.dsp_16bit=this.dsp_signed=!1;this.dma_transfer_start()}); +register_dsp_command([31],0);register_dsp_command([32],0,function(){this.read_buffer.clear();this.read_buffer.push(127)});register_dsp_command([36],2);register_dsp_command([44],0);register_dsp_command([48],0);register_dsp_command([49],0);register_dsp_command([52],0);register_dsp_command([53],0);register_dsp_command([54],0);register_dsp_command([55],0);register_dsp_command([56],0);register_dsp_command([64],1,function(){this.sampling_rate_change(1E6/(256-this.write_buffer.shift())/this.get_channel_count())}); +register_dsp_command([65,66],2,function(){this.sampling_rate_change(this.write_buffer.shift()<<8|this.write_buffer.shift())});register_dsp_command([72],2,function(){this.dma_transfer_size_set()});register_dsp_command([116],2);register_dsp_command([117],2);register_dsp_command([118],2);register_dsp_command([119],2);register_dsp_command([125],0);register_dsp_command([127],0);register_dsp_command([128],2); +register_dsp_command([144],0,function(){this.dma_irq=SB_IRQ_8BIT;this.dma_channel=this.dma_channel_8bit;this.dma_autoinit=!0;this.dsp_signed=!1;this.dsp_highspeed=!0;this.dsp_16bit=!1;this.dma_transfer_start()});register_dsp_command([145],0);register_dsp_command([152],0);register_dsp_command([153],0);register_dsp_command([160],0);register_dsp_command([168],0); +register_dsp_command(any_first_digit(176),3,function(){if(this.command&8)this.dsp_default_handler();else{var a=this.write_buffer.shift();this.dma_irq=SB_IRQ_16BIT;this.dma_channel=this.dma_channel_16bit;this.dma_autoinit=!!(this.command&4);this.dsp_signed=!!(a&16);this.dsp_stereo=!!(a&32);this.dsp_16bit=!0;this.dma_transfer_size_set();this.dma_transfer_start()}}); +register_dsp_command(any_first_digit(192),3,function(){if(this.command&8)this.dsp_default_handler();else{var a=this.write_buffer.shift();this.dma_irq=SB_IRQ_8BIT;this.dma_channel=this.dma_channel_8bit;this.dma_autoinit=!!(this.command&4);this.dsp_signed=!!(a&16);this.dsp_stereo=!!(a&32);this.dsp_16bit=!1;this.dma_transfer_size_set();this.dma_transfer_start()}});register_dsp_command([208],0,function(){this.dma_paused=!0;this.bus.send("dac-disable")}); +register_dsp_command([209],0,function(){this.dummy_speaker_enabled=!0});register_dsp_command([211],0,function(){this.dummy_speaker_enabled=!1});register_dsp_command([212],0,function(){this.dma_paused=!1;this.bus.send("dac-enable")});register_dsp_command([213],0,function(){this.dma_paused=!0;this.bus.send("dac-disable")});register_dsp_command([214],0,function(){this.dma_paused=!1;this.bus.send("dac-enable")}); +register_dsp_command([216],0,function(){this.read_buffer.clear();this.read_buffer.push(255*this.dummy_speaker_enabled)});register_dsp_command([217,218],0,function(){this.dma_autoinit=!1});register_dsp_command([224],1,function(){this.read_buffer.clear();this.read_buffer.push(~this.write_buffer.shift())});register_dsp_command([225],0,function(){this.read_buffer.clear();this.read_buffer.push(4);this.read_buffer.push(5)});register_dsp_command([226],1); +register_dsp_command([227],0,function(){this.read_buffer.clear();for(var a=0;a>>4};MIXER_WRITE_HANDLERS[a]=function(d){this.mixer_registers[a]=d;var e=d<<4&240|this.mixer_registers[c]&15;this.mixer_write(b,d&240|this.mixer_registers[b]&15);this.mixer_write(c,e)}} +function register_mixer_volume(a,b,c){MIXER_READ_HANDLERS[a]=SB16.prototype.mixer_default_read;MIXER_WRITE_HANDLERS[a]=function(d){this.mixer_registers[a]=d;this.bus.send("mixer-volume",[b,c,(d>>>2)-62])}}register_mixer_read(0,function(){this.mixer_reset();return 0});register_mixer_write(0);register_mixer_legacy(4,50,51);register_mixer_legacy(34,48,49);register_mixer_legacy(38,52,53);register_mixer_legacy(40,54,55);register_mixer_legacy(46,56,57);register_mixer_volume(48,MIXER_SRC_MASTER,MIXER_CHANNEL_LEFT); +register_mixer_volume(49,MIXER_SRC_MASTER,MIXER_CHANNEL_RIGHT);register_mixer_volume(50,MIXER_SRC_DAC,MIXER_CHANNEL_LEFT);register_mixer_volume(51,MIXER_SRC_DAC,MIXER_CHANNEL_RIGHT);register_mixer_read(59);register_mixer_write(59,function(a){this.mixer_registers[59]=a;this.bus.send("mixer-volume",[MIXER_SRC_PCSPEAKER,MIXER_CHANNEL_BOTH,6*(a>>>6)-18])});register_mixer_read(65);register_mixer_write(65,function(a){this.mixer_registers[65]=a;this.bus.send("mixer-gain-left",6*(a>>>6))});register_mixer_read(66); +register_mixer_write(66,function(a){this.mixer_registers[66]=a;this.bus.send("mixer-gain-right",6*(a>>>6))});register_mixer_read(68);register_mixer_write(68,function(a){this.mixer_registers[68]=a;a>>>=3;this.bus.send("mixer-treble-left",a-(16>a?14:16))});register_mixer_read(69);register_mixer_write(69,function(a){this.mixer_registers[69]=a;a>>>=3;this.bus.send("mixer-treble-right",a-(16>a?14:16))});register_mixer_read(70); +register_mixer_write(70,function(a){this.mixer_registers[70]=a;a>>>=3;this.bus.send("mixer-bass-right",a-(16>a?14:16))});register_mixer_read(71);register_mixer_write(71,function(a){this.mixer_registers[71]=a;a>>>=3;this.bus.send("mixer-bass-right",a-(16>a?14:16))});register_mixer_read(128,function(){switch(this.irq){case SB_IRQ2:return 1;case SB_IRQ5:return 2;case SB_IRQ7:return 4;case SB_IRQ10:return 8;default:return 0}}); +register_mixer_write(128,function(a){a&1&&(this.irq=SB_IRQ2);a&2&&(this.irq=SB_IRQ5);a&4&&(this.irq=SB_IRQ7);a&8&&(this.irq=SB_IRQ10)});register_mixer_read(129,function(){var a=0;switch(this.dma_channel_8bit){case SB_DMA0:a|=1;break;case SB_DMA1:a|=2;break;case SB_DMA3:a|=8}switch(this.dma_channel_16bit){case SB_DMA5:a|=32;break;case SB_DMA6:a|=64;break;case SB_DMA7:a|=128}return a}); +register_mixer_write(129,function(a){a&1&&(this.dma_channel_8bit=SB_DMA0);a&2&&(this.dma_channel_8bit=SB_DMA1);a&8&&(this.dma_channel_8bit=SB_DMA3);a&32&&(this.dma_channel_16bit=SB_DMA5);a&64&&(this.dma_channel_16bit=SB_DMA6);a&128&&(this.dma_channel_16bit=SB_DMA7)});register_mixer_read(130,function(){for(var a=32,b=0;16>b;b++)a|=b*this.irq_triggered[b];return a});SB16.prototype.fm_default_write=function(a,b,c){dbg_log("unhandled fm register write. addr:"+b+"|"+h(c)+" data:"+h(a),LOG_SB16)}; +function register_fm_write(a,b){b||(b=SB16.prototype.fm_default_write);for(var c=0;c>2&-4,32),this.dma_bytes_block);this.dma_waiting_transfer=!0;this.dma.channel_mask[this.dma_channel]||this.dma_on_unmask(this.dma_channel)}; +SB16.prototype.dma_on_unmask=function(a){a===this.dma_channel&&this.dma_waiting_transfer&&(this.dma_waiting_transfer=!1,this.dma_bytes_left=this.dma_bytes_count,this.dma_paused=!1,this.bus.send("dac-enable"))}; +SB16.prototype.dma_transfer_next=function(){dbg_log("dma transfering next block",LOG_SB16);var a=Math.min(this.dma_bytes_left,this.dma_bytes_block),b=Math.floor(a/this.bytes_per_sample);this.dma.do_write(this.dma_syncbuffer,0,a,this.dma_channel,c=>{dbg_log("dma block transfer "+(c?"unsuccessful":"successful"),LOG_SB16);c||(this.dma_to_dac(b),this.dma_bytes_left-=a,this.dma_bytes_left||(this.raise_irq(this.dma_irq),this.dma_autoinit&&(this.dma_bytes_left=this.dma_bytes_count)))})}; +SB16.prototype.dma_to_dac=function(a){var b=this.dsp_16bit?32767.5:127.5,c=this.dsp_signed?0:-1,d=this.dsp_stereo?1:2;var e=this.dsp_16bit?this.dsp_signed?this.dma_buffer_int16:this.dma_buffer_uint16:this.dsp_signed?this.dma_buffer_int8:this.dma_buffer_uint8;for(var f=0,k=0;kc)*c+(b<=a&&a<=c)*a};const VIRTIO_PCI_VENDOR_ID=6900,VIRTIO_PCI_CAP_VENDOR=9,VIRTIO_PCI_CAP_LENGTH=16,VIRTIO_PCI_CAP_COMMON_CFG=1,VIRTIO_PCI_CAP_NOTIFY_CFG=2,VIRTIO_PCI_CAP_ISR_CFG=3,VIRTIO_PCI_CAP_DEVICE_CFG=4,VIRTIO_PCI_CAP_PCI_CFG=5,VIRTIO_STATUS_ACKNOWLEDGE=1,VIRTIO_STATUS_DRIVER=2,VIRTIO_STATUS_DRIVER_OK=4,VIRTIO_STATUS_FEATURES_OK=8,VIRTIO_STATUS_DEVICE_NEEDS_RESET=64,VIRTIO_STATUS_FAILED=128,VIRTIO_ISR_QUEUE=1,VIRTIO_ISR_DEVICE_CFG=2,VIRTIO_F_RING_INDIRECT_DESC=28,VIRTIO_F_RING_EVENT_IDX=29,VIRTIO_F_VERSION_1= +32,VIRTQ_DESC_ENTRYSIZE=16,VIRTQ_AVAIL_BASESIZE=6,VIRTQ_AVAIL_ENTRYSIZE=2,VIRTQ_USED_BASESIZE=6,VIRTQ_USED_ENTRYSIZE=8,VIRTQ_IDX_MASK=65535,VIRTQ_DESC_F_NEXT=1,VIRTQ_DESC_F_WRITE=2,VIRTQ_DESC_F_INDIRECT=4,VIRTQ_AVAIL_F_NO_INTERRUPT=1,VIRTQ_USED_F_NO_NOTIFY=1;var VirtIO_CapabilityStruct,VirtIO_CapabilityInfo,VirtQueue_Options,VirtIO_CommonCapabilityOptions,VirtIO_NotificationCapabilityOptions,VirtIO_ISRCapabilityOptions,VirtIO_DeviceSpecificCapabilityOptions,VirtIO_Options; +function VirtIO(a,b){this.cpu=a;this.pci=a.devices.pci;this.device_id=b.device_id;this.pci_space=[VIRTIO_PCI_VENDOR_ID&255,VIRTIO_PCI_VENDOR_ID>>8,b.device_id&255,b.device_id>>8,7,5,16,0,1,0,2,0,0,0,0,0,1,168,0,0,0,16,191,254,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,VIRTIO_PCI_VENDOR_ID&255,VIRTIO_PCI_VENDOR_ID>>8,b.subsystem_device_id&255,b.subsystem_device_id>>8,0,0,0,0,64,0,0,0,0,0,0,0,0,1,0,0];this.pci_space=this.pci_space.concat(v86util.zeros(256-this.pci_space.length));this.pci_id=b.pci_id;this.pci_bars= +[];this.name=b.name;this.driver_feature_select=this.device_feature_select=0;this.device_feature=new Uint32Array(4);this.driver_feature=new Uint32Array(4);for(var c of b.common.features)dbg_assert(0<=c,"VirtIO device<"+this.name+"> feature bit numbers must be non-negative"),dbg_assert(128>c,"VirtIO device<"+this.name+"> feature bit numbers assumed less than 128 in implementation"),this.device_feature[c>>>5]|=1<<(c&31),this.driver_feature[c>>>5]|=1<<(c&31);dbg_assert(b.common.features.includes(VIRTIO_F_VERSION_1), +"VirtIO device<"+this.name+"> only non-transitional devices are supported");this.features_ok=!0;this.device_status=0;this.config_has_changed=!1;this.config_generation=0;this.queues=[];for(var d of b.common.queues)this.queues.push(new VirtQueue(a,this,d));this.queue_select=0;this.queue_selected=this.queues[0];this.isr_status=0;if(DEBUG){c=new Set;for(var e of this.queues.map(a=>a.notify_offset))d=b.notification.single_handler?0:e,c.add(d),dbg_assert(b.notification.handlers[d],"VirtIO device<"+this.name+ +"> every queue's notifier must exist");for(const [a,d]of b.notification.handlers.entries())dbg_assert(!d||c.has(a),"VirtIO device<"+this.name+"> no defined notify handler should be unused")}e=[];e.push(this.create_common_capability(b.common));e.push(this.create_notification_capability(b.notification));e.push(this.create_isr_capability(b.isr_status));b.device_specific&&e.push(this.create_device_specific_capability(b.device_specific));this.init_capabilities(e);a.devices.pci.register_device(this);this.reset()} +VirtIO.prototype.create_common_capability=function(a){return{type:VIRTIO_PCI_CAP_COMMON_CFG,bar:0,port:a.initial_port,use_mmio:!1,offset:0,extra:new Uint8Array(0),struct:[{bytes:4,name:"device_feature_select",read:()=>this.device_feature_select,write:a=>{this.device_feature_select=a}},{bytes:4,name:"device_feature",read:()=>this.device_feature[this.device_feature_select]||0,write:a=>{}},{bytes:4,name:"driver_feature_select",read:()=>this.driver_feature_select,write:a=>{this.driver_feature_select= +a}},{bytes:4,name:"driver_feature",read:()=>this.driver_feature[this.driver_feature_select]||0,write:a=>{const b=this.device_feature[this.driver_feature_select];this.driver_feature_select{dbg_log("No msi-x capability supported.",LOG_VIRTIO);return 65535},write:a=>{dbg_log("No msi-x capability supported.",LOG_VIRTIO)}},{bytes:2,name:"num_queues", +read:()=>this.queues.length,write:a=>{}},{bytes:1,name:"device_status",read:()=>this.device_status,write:b=>{0===b?(dbg_log("Reset device<"+this.name+">",LOG_VIRTIO),this.reset()):b&VIRTIO_STATUS_FAILED?dbg_log("Warning: Device<"+this.name+"> status failed",LOG_VIRTIO):dbg_log("Device<"+this.name+"> status: "+(b&VIRTIO_STATUS_ACKNOWLEDGE?"ACKNOWLEDGE ":"")+(b&VIRTIO_STATUS_DRIVER?"DRIVER ":"")+(b&VIRTIO_STATUS_DRIVER_OK?"DRIVER_OK":"")+(b&VIRTIO_STATUS_FEATURES_OK?"FEATURES_OK ":"")+(b&VIRTIO_STATUS_DEVICE_NEEDS_RESET? +"DEVICE_NEEDS_RESET":""),LOG_VIRTIO);b&~this.device_status&VIRTIO_STATUS_DRIVER_OK&&this.device_status&VIRTIO_STATUS_DEVICE_NEEDS_RESET&&this.notify_config_changes();this.features_ok||(DEBUG&&b&VIRTIO_STATUS_FEATURES_OK&&dbg_log("Removing FEATURES_OK",LOG_VIRTIO),b&=~VIRTIO_STATUS_FEATURES_OK);this.device_status=b;if(b&~this.device_status&VIRTIO_STATUS_DRIVER_OK)a.on_driver_ok()}},{bytes:1,name:"config_generation",read:()=>this.config_generation,write:a=>{}},{bytes:2,name:"queue_select",read:()=> +this.queue_select,write:a=>{this.queue_select=a;this.queue_selectthis.queue_selected?this.queue_selected.size:0,write:a=>{this.queue_selected&&(a&a-1&&(dbg_log("Warning: dev<"+this.name+"> Given queue size was not a power of 2. Rounding up to next power of 2.",LOG_VIRTIO),a=1<this.queue_selected.size_supported&&(dbg_log("Warning: dev<"+ +this.name+"> Trying to set queue size greater than supported. Clamping to supported size.",LOG_VIRTIO),a=this.queue_selected.size_supported),this.queue_selected.set_size(a))}},{bytes:2,name:"queue_msix_vector",read:()=>{dbg_log("No msi-x capability supported.",LOG_VIRTIO);return 65535},write:a=>{dbg_log("No msi-x capability supported.",LOG_VIRTIO)}},{bytes:2,name:"queue_enable",read:()=>this.queue_selected?this.queue_selected.enabled|0:0,write:a=>{this.queue_selected&&(1===a?this.queue_selected.is_configured()? +this.queue_selected.enable():dbg_log("Driver bug: tried enabling unconfigured queue",LOG_VIRTIO):0===a&&dbg_log("Driver bug: tried writing 0 to queue_enable",LOG_VIRTIO))}},{bytes:2,name:"queue_notify_off",read:()=>this.queue_selected?this.queue_selected.notify_offset:0,write:a=>{}},{bytes:4,name:"queue_desc (low dword)",read:()=>this.queue_selected?this.queue_selected.desc_addr:0,write:a=>{this.queue_selected&&(this.queue_selected.desc_addr=a)}},{bytes:4,name:"queue_desc (high dword)",read:()=>0, +write:a=>{dbg_log("Warning: High dword of 64 bit queue_desc ignored",LOG_VIRTIO)}},{bytes:4,name:"queue_avail (low dword)",read:()=>this.queue_selected?this.queue_selected.avail_addr:0,write:a=>{this.queue_selected&&(this.queue_selected.avail_addr=a)}},{bytes:4,name:"queue_avail (high dword)",read:()=>0,write:a=>{dbg_log("Warning: High dword of 64 bit queue_avail ignored",LOG_VIRTIO)}},{bytes:4,name:"queue_used (low dword)",read:()=>this.queue_selected?this.queue_selected.used_addr:0,write:a=>{this.queue_selected&& +(this.queue_selected.used_addr=a)}},{bytes:4,name:"queue_used (high dword)",read:()=>0,write:a=>{dbg_log("Warning: High dword of 64 bit queue_used ignored",LOG_VIRTIO)}}]}}; +VirtIO.prototype.create_notification_capability=function(a){const b=[];let c;a.single_handler?(dbg_assert(1===a.handlers.length,"VirtIO device<"+this.name+"> too many notify handlers specified: expected single handler"),c=0):c=2;for(const [c,e]of a.handlers.entries())b.push({bytes:2,name:"notify"+c,read:()=>65535,write:e||(a=>{})});return{type:VIRTIO_PCI_CAP_NOTIFY_CFG,bar:1,port:a.initial_port,use_mmio:!1,offset:0,extra:new Uint8Array([c&255,c>>8&255,c>>16&255,c>>24]),struct:b}}; +VirtIO.prototype.create_isr_capability=function(a){return{type:VIRTIO_PCI_CAP_ISR_CFG,bar:2,port:a.initial_port,use_mmio:!1,offset:0,extra:new Uint8Array(0),struct:[{bytes:1,name:"isr_status",read:()=>{const a=this.isr_status;this.lower_irq();return a},write:a=>{}}]}}; +VirtIO.prototype.create_device_specific_capability=function(a){dbg_assert(~a.offset&3,"VirtIO device<"+this.name+"> device specific cap offset must be 4-byte aligned");return{type:VIRTIO_PCI_CAP_DEVICE_CFG,bar:3,port:a.initial_port,use_mmio:!1,offset:0,extra:new Uint8Array(0),struct:a.struct}}; +VirtIO.prototype.init_capabilities=function(a){let b=this.pci_space[52]=64;var c=b;for(const e of a){a=VIRTIO_PCI_CAP_LENGTH+e.extra.length;c=b;b=c+a;dbg_assert(256>=b,"VirtIO device<"+this.name+"> can't fit all capabilities into 256byte configspace");dbg_assert(0<=e.bar&&6>e.bar,"VirtIO device<"+this.name+"> capability invalid bar number");var d=e.struct.reduce((a,b)=>a+b.bytes,0);d+=e.offset;d=16>d?16:1< capability port should be aligned to pci bar size"); +this.pci_bars[e.bar]={size:d};this.pci_space[c]=VIRTIO_PCI_CAP_VENDOR;this.pci_space[c+1]=b;this.pci_space[c+2]=a;this.pci_space[c+3]=e.type;this.pci_space[c+4]=e.bar;this.pci_space[c+5]=0;this.pci_space[c+6]=0;this.pci_space[c+7]=0;this.pci_space[c+8]=e.offset&255;this.pci_space[c+9]=e.offset>>>8&255;this.pci_space[c+10]=e.offset>>>16&255;this.pci_space[c+11]=e.offset>>>24;this.pci_space[c+12]=d&255;this.pci_space[c+13]=d>>>8&255;this.pci_space[c+14]=d>>>16&255;this.pci_space[c+15]=d>>>24;for(const [a, +b]of e.extra.entries())this.pci_space[c+16+a]=b;c=16+4*e.bar;this.pci_space[c]=e.port&254|!e.use_mmio;this.pci_space[c+1]=e.port>>>8&255;this.pci_space[c+2]=e.port>>>16&255;this.pci_space[c+3]=e.port>>>24&255;c=e.port+e.offset;for(const b of e.struct){let f=b.read;a=b.write;DEBUG&&(f=()=>{const a=b.read();dbg_log("Device<"+this.name+"> cap["+e.type+"] read["+b.name+"] => "+h(a,8*b.bytes),LOG_VIRTIO);return a},a=a=>{dbg_log("Device<"+this.name+"> cap["+e.type+"] write["+b.name+"] <= "+h(a,8*b.bytes), +LOG_VIRTIO);b.write(a)});if(e.use_mmio)dbg_assert(!1,"VirtIO device <"+this.name+"> mmio capability not implemented.");else{d=function(a){dbg_log("Warning: 8-bit read from 16-bit virtio port",LOG_VIRTIO);return f(a&-2)>>((a&1)<<3)&255};const e=function(a){dbg_log("Warning: 8-bit read from 32-bit virtio port",LOG_VIRTIO);return f(a&-4)>>((a&3)<<3)&255};switch(b.bytes){case 4:this.cpu.io.register_read(c,this,e,void 0,f);this.cpu.io.register_write(c,this,void 0,void 0,a);break;case 2:this.cpu.io.register_read(c, +this,d,f);this.cpu.io.register_write(c,this,void 0,a);break;case 1:this.cpu.io.register_read(c,this,f);this.cpu.io.register_write(c,this,a);break;default:dbg_assert(!1,"VirtIO device <"+this.name+"> invalid capability field width of "+b.bytes+" bytes")}}c+=b.bytes}}c=VIRTIO_PCI_CAP_LENGTH+4;dbg_assert(256>=b+c,"VirtIO device<"+this.name+"> can't fit all capabilities into 256byte configspace");this.pci_space[b]=VIRTIO_PCI_CAP_VENDOR;this.pci_space[b+1]=0;this.pci_space[b+2]=c;this.pci_space[b+3]=VIRTIO_PCI_CAP_PCI_CFG; +this.pci_space[b+4]=0;this.pci_space[b+5]=0;this.pci_space[b+6]=0;this.pci_space[b+7]=0;this.pci_space[b+8]=0;this.pci_space[b+9]=0;this.pci_space[b+10]=0;this.pci_space[b+11]=0;this.pci_space[b+12]=0;this.pci_space[b+13]=0;this.pci_space[b+14]=0;this.pci_space[b+15]=0;this.pci_space[b+16]=0;this.pci_space[b+17]=0;this.pci_space[b+18]=0;this.pci_space[b+19]=0}; +VirtIO.prototype.get_state=function(){let a=[];a[0]=this.device_feature_select;a[1]=this.driver_feature_select;a[2]=this.device_feature;a[3]=this.driver_feature;a[4]=this.features_ok;a[5]=this.device_status;a[6]=this.config_has_changed;a[7]=this.config_generation;a[8]=this.isr_status;a[9]=this.queue_select;return a=a.concat(this.queues)}; +VirtIO.prototype.set_state=function(a){this.device_feature_select=a[0];this.driver_feature_select=a[1];this.device_feature=a[2];this.driver_feature=a[3];this.features_ok=a[4];this.device_status=a[5];this.config_has_changed=a[6];this.config_generation=a[7];this.isr_status=a[8];this.queue_select=a[9];let b=0;for(let c of a.slice(10))this.queues[b].set_state(c),b++;this.queue_selected=this.queues[this.queue_select]||null}; +VirtIO.prototype.reset=function(){this.driver_feature_select=this.device_feature_select=0;this.driver_feature.set(this.device_feature);this.features_ok=!0;this.queue_select=this.device_status=0;this.queue_selected=this.queues[0];for(const a of this.queues)a.reset();this.config_has_changed=!1;this.config_generation=0;this.lower_irq()}; +VirtIO.prototype.notify_config_changes=function(){this.config_has_changed=!0;this.device_status&VIRTIO_STATUS_DRIVER_OK?this.raise_irq(VIRTIO_ISR_DEVICE_CFG):dbg_assert(!1,"VirtIO device<"+this.name+"> attempted to notify driver before DRIVER_OK")};VirtIO.prototype.update_config_generation=function(){this.config_has_changed&&(this.config_generation++,this.config_generation&=255,this.config_has_changed=!1)}; +VirtIO.prototype.is_feature_negotiated=function(a){return 0<(this.driver_feature[a>>>5]&1<<(a&31))};VirtIO.prototype.needs_reset=function(){dbg_log("Device<"+this.name+"> experienced error - requires reset",LOG_VIRTIO);this.device_status|=VIRTIO_STATUS_DEVICE_NEEDS_RESET;this.device_status&VIRTIO_STATUS_DRIVER_OK&&this.notify_config_changes()};VirtIO.prototype.raise_irq=function(a){dbg_log("Raise irq "+h(a),LOG_VIRTIO);this.isr_status|=a;this.pci.raise_irq(this.pci_id)}; +VirtIO.prototype.lower_irq=function(){dbg_log("Lower irq ",LOG_VIRTIO);this.isr_status=0;this.pci.lower_irq(this.pci_id)};function VirtQueue(a,b,c){this.cpu=a;this.virtio=b;this.size_supported=this.size=c.size_supported;this.mask=this.size-1;this.enabled=!1;this.notify_offset=c.notify_offset;this.num_staged_replies=this.used_addr=this.avail_last_idx=this.avail_addr=this.desc_addr=0;this.reset()} +VirtQueue.prototype.get_state=function(){const a=[];a[0]=this.size;a[1]=this.size_supported;a[2]=this.enabled;a[3]=this.notify_offset;a[4]=this.desc_addr;a[5]=this.avail_addr;a[6]=this.avail_last_idx;a[7]=this.used_addr;a[8]=this.num_staged_replies;return a}; +VirtQueue.prototype.set_state=function(a){this.size=a[0];this.size_supported=a[1];this.enabled=a[2];this.notify_offset=a[3];this.desc_addr=a[4];this.avail_addr=a[5];this.avail_last_idx=a[6];this.used_addr=a[7];this.num_staged_replies=a[8];this.mask=this.size-1};VirtQueue.prototype.reset=function(){this.enabled=!1;this.num_staged_replies=this.used_addr=this.avail_last_idx=this.avail_addr=this.desc_addr=0;this.set_size(this.size_supported)}; +VirtQueue.prototype.is_configured=function(){return this.desc_addr&&this.avail_addr&&this.used_addr};VirtQueue.prototype.enable=function(){dbg_assert(this.is_configured(),"VirtQueue must be configured before enabled");this.enabled=!0};VirtQueue.prototype.set_size=function(a){dbg_assert(0===(a&a-1),"VirtQueue size must be power of 2 or zero");dbg_assert(a<=this.size_supported,"VirtQueue size must be within supported size");this.size=a;this.mask=a-1}; +VirtQueue.prototype.count_requests=function(){dbg_assert(this.avail_addr,"VirtQueue addresses must be configured before use");return this.avail_get_idx()-this.avail_last_idx&this.mask};VirtQueue.prototype.has_request=function(){dbg_assert(this.avail_addr,"VirtQueue addresses must be configured before use");return(this.avail_get_idx()&this.mask)!==this.avail_last_idx}; +VirtQueue.prototype.pop_request=function(){dbg_assert(this.avail_addr,"VirtQueue addresses must be configured before use");dbg_assert(this.has_request(),"VirtQueue must not pop nonexistent request");var a=this.avail_get_entry(this.avail_last_idx);dbg_log("Pop request: avail_last_idx="+this.avail_last_idx+" desc_idx="+a,LOG_VIRTIO);a=new VirtQueueBufferChain(this,a);this.avail_last_idx=this.avail_last_idx+1&this.mask;return a}; +VirtQueue.prototype.push_reply=function(a){dbg_assert(this.used_addr,"VirtQueue addresses must be configured before use");dbg_assert(this.num_staged_repliese){dbg_log("Driver bug: descriptor chain cycle detected",LOG_VIRTIO);break}if(g.flags&VIRTQ_DESC_F_NEXT)b=g.next;else break}}while(1);dbg_log("Descriptor chain end >>>",LOG_VIRTIO)} +VirtQueueBufferChain.prototype.get_next_blob=function(a){let b=0,c=a.length;for(;c;){if(this.read_buffer_idx===this.read_buffers.length){dbg_log("Device<"+this.virtio.name+"> Read more than device-readable buffers has",LOG_VIRTIO);break}var d=this.read_buffers[this.read_buffer_idx];const e=d.addr_low+this.read_buffer_offset;d=d.len-this.read_buffer_offset;d>c?(d=c,this.read_buffer_offset+=c):(this.read_buffer_idx++,this.read_buffer_offset=0);a.set(this.cpu.read_blob(e,d),b);b+=d;c-=d}return b}; +VirtQueueBufferChain.prototype.set_next_blob=function(a){let b=0,c=a.length;for(;c;){if(this.write_buffer_idx===this.write_buffers.length){dbg_log("Device<"+this.virtio.name+"> Write more than device-writable capacity",LOG_VIRTIO);break}var d=this.write_buffers[this.write_buffer_idx];const e=d.addr_low+this.write_buffer_offset;d=d.len-this.write_buffer_offset;d>c?(d=c,this.write_buffer_offset+=c):(this.write_buffer_idx++,this.write_buffer_offset=0);this.cpu.write_blob(a.subarray(b,b+d),e);b+=d;c-= +d}this.length_written+=b;return b};var Bus={};function BusConnector(){this.listeners={};this.pair=void 0}BusConnector.prototype.register=function(a,b,c){var d=this.listeners[a];void 0===d&&(d=this.listeners[a]=[]);d.push({fn:b,this_value:c})};BusConnector.prototype.unregister=function(a,b){var c=this.listeners[a];void 0!==c&&(this.listeners[a]=c.filter(function(a){return a.fn!==b}))}; +BusConnector.prototype.send=function(a,b,c){if(this.pair&&(a=this.pair.listeners[a],void 0!==a))for(c=0;cc))return;e=new Date;e=v86util.pad0(e.getHours(),2)+":"+v86util.pad0(e.getMinutes(),2)+":"+v86util.pad0(e.getSeconds(),2)+"+"+v86util.pad0(e.getMilliseconds(),3)+" ";c&&(1===c?do_the_log(e+b):do_the_log("Previous message repeated "+c+" times"),c=0);do_the_log(e+d); +b=d}}}();function dbg_trace(a){DEBUG&&dbg_log(Error().stack,a)}function dbg_assert(a,b,c){DEBUG&&(a||dbg_assert_failed(b))}function dbg_assert_failed(a){debugger;console.trace();if(a)throw"Assert failed: "+a;throw"Assert failed";};var CPU_LOG_VERBOSE=!1; +function CPU(a,b){this.wm=b;this.wasm_patch();this.create_jit_imports();this.wasm_memory=b=this.wm.exports.memory;this.memory_size=v86util.view(Uint32Array,b,812,1);this.mem8=new Uint8Array(0);this.mem32s=new Int32Array(this.mem8.buffer);this.segment_is_null=v86util.view(Uint8Array,b,724,8);this.segment_offsets=v86util.view(Int32Array,b,736,8);this.segment_limits=v86util.view(Uint32Array,b,768,8);this.protected_mode=v86util.view(Int32Array,b,800,1);this.idtr_size=v86util.view(Int32Array,b,564,1); +this.idtr_offset=v86util.view(Int32Array,b,568,1);this.gdtr_size=v86util.view(Int32Array,b,572,1);this.gdtr_offset=v86util.view(Int32Array,b,576,1);this.tss_size_32=v86util.view(Int32Array,b,1128,1);this.page_fault=v86util.view(Uint32Array,b,540,8);this.cr=v86util.view(Int32Array,b,580,8);this.cpl=v86util.view(Uint8Array,b,612,1);this.is_32=v86util.view(Int32Array,b,804,1);this.stack_size_32=v86util.view(Int32Array,b,808,1);this.in_hlt=v86util.view(Uint8Array,b,616,1);this.last_virt_eip=v86util.view(Int32Array, +b,620,1);this.eip_phys=v86util.view(Int32Array,b,624,1);this.sysenter_cs=v86util.view(Int32Array,b,636,1);this.sysenter_esp=v86util.view(Int32Array,b,640,1);this.sysenter_eip=v86util.view(Int32Array,b,644,1);this.prefixes=v86util.view(Int32Array,b,648,1);this.flags=v86util.view(Int32Array,b,120,1);this.flags_changed=v86util.view(Int32Array,b,116,1);this.last_op1=v86util.view(Int32Array,b,96,1);this.last_op_size=v86util.view(Int32Array,b,104,1);this.last_result=v86util.view(Int32Array,b,112,1);this.current_tsc= +v86util.view(Uint32Array,b,960,2);this.devices={};this.instruction_pointer=v86util.view(Int32Array,b,556,1);this.previous_ip=v86util.view(Int32Array,b,560,1);this.apic_enabled=v86util.view(Uint8Array,b,548,1);this.acpi_enabled=v86util.view(Uint8Array,b,552,1);this.memory_map_read8=[];this.memory_map_write8=[];this.memory_map_read32=[];this.memory_map_write32=[];this.bios={main:null,vga:null};this.instruction_counter=v86util.view(Uint32Array,b,664,1);this.reg32=v86util.view(Int32Array,b,64,8);this.fpu_st= +v86util.view(Int32Array,b,1152,32);this.fpu_stack_empty=v86util.view(Uint8Array,b,816,1);this.fpu_stack_empty[0]=255;this.fpu_stack_ptr=v86util.view(Uint8Array,b,1032,1);this.fpu_stack_ptr[0]=0;this.fpu_control_word=v86util.view(Uint16Array,b,1036,1);this.fpu_control_word[0]=895;this.fpu_status_word=v86util.view(Uint16Array,b,1040,1);this.fpu_status_word[0]=0;this.fpu_ip=v86util.view(Int32Array,b,1048,1);this.fpu_ip[0]=0;this.fpu_ip_selector=v86util.view(Int32Array,b,1052,1);this.fpu_ip_selector[0]= +0;this.fpu_opcode=v86util.view(Int32Array,b,1044,1);this.fpu_opcode[0]=0;this.fpu_dp=v86util.view(Int32Array,b,1056,1);this.fpu_dp[0]=0;this.fpu_dp_selector=v86util.view(Int32Array,b,1060,1);this.fpu_dp_selector[0]=0;this.reg_xmm32s=v86util.view(Int32Array,b,832,32);this.mxcsr=v86util.view(Int32Array,b,824,1);this.sreg=v86util.view(Uint16Array,b,668,8);this.dreg=v86util.view(Int32Array,b,684,8);this.fw_value=[];this.fw_pointer=0;this.option_roms=[];this.io=void 0;this.bus=a;this.set_tsc(0,0);this.debug_init()} +CPU.prototype.clear_opstats=function(){(new Uint8Array(this.wasm_memory.buffer,32768,131072)).fill(0);this.wm.exports.profiler_init()};CPU.prototype.create_jit_imports=function(){const a=Object.create(null);a.m=this.wm.exports.memory;for(let b of Object.keys(this.wm.exports))b.startsWith("_")||b.startsWith("ZSTD")||b.startsWith("zstd")||b.endsWith("_js")||(a[b]=this.wm.exports[b]);this.jit_imports=a}; +CPU.prototype.wasm_patch=function(){const a=a=>this.wm.exports[a],b=b=>{const c=a(b);console.assert(c,"Missing import: "+b);return c};this.getiopl=b("getiopl");this.vm86_mode=b("vm86_mode");this.get_eflags=b("get_eflags");this.get_eflags_no_arith=b("get_eflags_no_arith");this.update_eflags=b("update_eflags");this.trigger_gp=b("trigger_gp");this.trigger_np=b("trigger_np");this.trigger_ss=b("trigger_ss");this.switch_cs_real_mode=b("switch_cs_real_mode");this.pic_call_irq=b("pic_call_irq");this.do_many_cycles_native= +b("do_many_cycles_native");this.cycle_internal=b("cycle_internal");this.read8=b("read8");this.read16=b("read16");this.read32s=b("read32s");this.write8=b("write8");this.write16=b("write16");this.write32=b("write32");this.in_mapped_range=b("in_mapped_range");this.push16=b("push16_js");this.push32=b("push32_js");this.set_stack_reg=b("set_stack_reg");this.fpu_load_tag_word=b("fpu_load_tag_word");this.fpu_load_status_word=b("fpu_load_status_word");this.translate_address_system_read=b("translate_address_system_read_js"); +this.translate_address_system_write=b("translate_address_system_write_js");this.get_seg_cs=b("get_seg_cs");this.adjust_stack_reg=b("adjust_stack_reg");this.get_real_eip=b("get_real_eip");this.get_stack_pointer=b("get_stack_pointer");this.writable_or_pagefault=b("writable_or_pagefault_js");this.safe_write32=b("safe_write32_js");this.safe_read32s=b("safe_read32s_js");this.safe_write16=b("safe_write16_js");this.safe_read16=b("safe_read16_js");this.clear_tlb=b("clear_tlb");this.full_clear_tlb=b("full_clear_tlb"); +this.set_tsc=b("set_tsc");this.store_current_tsc=b("store_current_tsc");this.fpu_get_sti_f64=b("fpu_get_sti_f64");DEBUG&&(this.jit_force_generate_unsafe=a("jit_force_generate_unsafe"));this.jit_clear_cache=b("jit_clear_cache_js");this.jit_dirty_cache=b("jit_dirty_cache");this.codegen_finalize_finished=b("codegen_finalize_finished");this.allocate_memory=b("allocate_memory");this.zero_memory=b("zero_memory");this.zstd_create_ctx=b("zstd_create_ctx");this.zstd_get_src_ptr=b("zstd_get_src_ptr");this.zstd_free_ctx= +b("zstd_free_ctx");this.zstd_read=b("zstd_read");this.zstd_read_free=b("zstd_read_free")};CPU.prototype.jit_force_generate=function(a){this.jit_force_generate_unsafe?this.jit_force_generate_unsafe(a):dbg_assert(!1,"Not supported in this wasm build: jit_force_generate_unsafe")};CPU.prototype.jit_clear_func=function(a){dbg_assert(0<=a&&a>2)};goog.exportProperty(CPU.prototype,"create_memory",CPU.prototype.create_memory); +CPU.prototype.init=function(a,b){"number"===typeof a.log_level&&(LOG_LEVEL=a.log_level);this.create_memory("number"===typeof a.memory_size?a.memory_size:67108864);this.acpi_enabled[0]=+a.acpi;this.reset();var c=new IO(this);this.io=c;this.bios.main=a.bios;this.bios.vga=a.vga_bios;this.load_bios();if(a.bzimage){const {option_rom:b}=load_kernel(this.mem8,a.bzimage,a.initrd,a.cmdline||"");b&&this.option_roms.push(b)}c.register_read(179,this,function(){dbg_log("port 0xB3 read");return 0});var d=0;c.register_read(146, +this,function(){return d});c.register_write(146,this,function(a){d=a});c.register_read(1297,this,function(){if(this.fw_pointer>8|a<<8&65280}function d(a){return a<<24|a<<8&16711680|a>>8&65280|a>>>24}dbg_log("bios config port, index="+h(a));this.fw_pointer= +0;if(a===FW_CFG_SIGNATURE)this.fw_value=b(FW_CFG_SIGNATURE_QEMU);else if(a===FW_CFG_ID)this.fw_value=b(0);else if(a===FW_CFG_RAM_SIZE)this.fw_value=b(this.memory_size[0]);else if(a===FW_CFG_NB_CPUS)this.fw_value=b(1);else if(a===FW_CFG_MAX_CPUS)this.fw_value=b(1);else if(a===FW_CFG_NUMA)this.fw_value=new Uint8Array(16);else if(a===FW_CFG_FILE_DIR){a=new Int32Array(4+64*this.option_roms.length);const b=new Uint8Array(a.buffer);a[0]=d(this.option_roms.length);for(let e=0;eFW_CFG_FILE_START+e);a[l+0>>2]=d(f.length);a[l+4>>2]=c(FW_CFG_FILE_START+e);dbg_assert(56>g.length);for(let a=0;a=FW_CFG_CUSTOM_START&&a=FW_CFG_FILE_START&&a-FW_CFG_FILE_STARTa.byteLength){var b=new Int32Array(2048);(new Uint8Array(b.buffer)).set(new Uint8Array(a))}else b=new Int32Array(a,0,2048);for(var c=0;8192>c;c+=4)if(464367618===b[c>>2]){var d=b[c+4>>2];if(464367618+d+b[c+8>>2]|0)dbg_log("Multiboot checksum check failed",LOG_CPU);else{dbg_log("Multiboot magic found, flags: "+h(d>>>0,8),LOG_CPU);dbg_assert(0===(d&-65537),"TODO");this.reg32[reg_eax]= +732803074;this.reg32[reg_ebx]=31744;this.write32(31744,0);this.cr[0]=1;this.protected_mode[0]=1;this.flags[0]=flags_default;this.update_cs_size(!0);this.stack_size_32[0]=1;for(var e=0;6>e;e++)this.segment_is_null[e]=0,this.segment_offsets[e]=0,this.segment_limits[e]=4294967295,this.sreg[e]=45058;if(d&65536){dbg_log("Multiboot specifies its own address table",LOG_CPU);e=b[c+12>>2];var f=b[c+16>>2];d=b[c+20>>2];var k=b[c+24>>2];b=b[c+28>>2];dbg_log("header="+h(e,8)+" load="+h(f,8)+" load_end="+h(d, +8)+" bss_end="+h(k,8)+" entry="+h(b,8));dbg_assert(f<=e);c-=e-f;0===d?d=void 0:(dbg_assert(d>=f),d-=f);a=new Uint8Array(a,c,d);this.write_blob(a,f);this.instruction_pointer[0]=this.get_seg_cs()+b|0}else if(1179403647===b[0]){dbg_log("Multiboot image is in elf format",LOG_CPU);c=read_elf(a);this.instruction_pointer[0]=this.get_seg_cs()+c.header.entry|0;for(f of c.program_headers)0!==f.type&&(1===f.type?(dbg_assert(f.paddr===f.vaddr),dbg_assert(f.filesz<=f.memsz),f.paddr+f.memsz=a;a++)this.io.register_write(8192+a,this,function(b){dbg_log("kvm-unit-test: Set irq "+h(a)+" to "+h(b,2));b?this.device_raise_irq(a):this.device_lower_irq(a)});dbg_log("Starting multiboot kernel at:",LOG_CPU);this.debug.dump_state();this.debug.dump_regs();break}}}; +CPU.prototype.fill_cmos=function(a,b){var c=b.boot_order||531;a.cmos_write(CMOS_BIOS_BOOTFLAG1,1|c>>4&240);a.cmos_write(CMOS_BIOS_BOOTFLAG2,c&255);a.cmos_write(CMOS_MEM_BASE_LOW,128);a.cmos_write(CMOS_MEM_BASE_HIGH,2);c=0;1048576<=this.memory_size[0]&&(c=this.memory_size[0]-1048576>>10,c=Math.min(c,65535));a.cmos_write(CMOS_MEM_OLD_EXT_LOW,c&255);a.cmos_write(CMOS_MEM_OLD_EXT_HIGH,c>>8&255);a.cmos_write(CMOS_MEM_EXTMEM_LOW,c&255);a.cmos_write(CMOS_MEM_EXTMEM_HIGH,c>>8&255);c=0;16777216<=this.memory_size[0]&& +(c=this.memory_size[0]-16777216>>16,c=Math.min(c,65535));a.cmos_write(CMOS_MEM_EXTMEM2_LOW,c&255);a.cmos_write(CMOS_MEM_EXTMEM2_HIGH,c>>8&255);a.cmos_write(CMOS_MEM_HIGHMEM_LOW,0);a.cmos_write(CMOS_MEM_HIGHMEM_MID,0);a.cmos_write(CMOS_MEM_HIGHMEM_HIGH,0);a.cmos_write(CMOS_EQUIPMENT_INFO,47);a.cmos_write(CMOS_BIOS_SMP_COUNT,0);b.fastboot&&a.cmos_write(63,1)}; +CPU.prototype.load_bios=function(){var a=this.bios.main,b=this.bios.vga;if(a){var c=new Uint8Array(a);this.write_blob(c,1048576-a.byteLength);if(b){var d=new Uint8Array(b);this.write_blob(d,786432);this.io.mmap_register(4272947200,1048576,function(a){a=a-4272947200|0;return a>>=0;e>>>=0;dbg_assert(0<=a&&a{d=d.instance.exports.f;this.codegen_finalize_finished(a,b,c);this.wm.wasm_table.set(a+WASM_TABLE_OFFSET,d);this.test_hook_did_finalize_wasm&& +this.test_hook_did_finalize_wasm(f)});DEBUG&&d.catch(a=>{console.log(a);debugger;throw a;})}; +CPU.prototype.log_uncompiled_code=function(a,b){if(DEBUG&&DUMP_UNCOMPILED_ASSEMBLY&&100>(seen_code_uncompiled[a]||0)){seen_code_uncompiled[a]=(seen_code_uncompiled[a]||0)+1;b+=8;(a^b)&-4096&&(dbg_log("truncated disassembly start="+h(a>>>0)+" end="+h(b>>>0)),b=(a|4095)+1);b=a);const c=new Uint8Array(b-a);for(let d=a;d>2)+7*f;const b=c[e+0],g=c[e+1];e=c[e+6]&65280;const l=new Uint8Array(g-b);for(let a=b;ad.effective_limit)throw this.debug.unimpl("#NP handler"); +var k=this.segment_offsets[reg_tr],g=this.get_eflags();f&&(g&=~flag_nt);if(this.writable_or_pagefault(k,102)){this.safe_write32(k+TSR_EIP,this.get_real_eip());this.safe_write32(k+TSR_EFLAGS,g);this.safe_write32(k+TSR_EAX,this.reg32[reg_eax]);this.safe_write32(k+TSR_ECX,this.reg32[reg_ecx]);this.safe_write32(k+TSR_EDX,this.reg32[reg_edx]);this.safe_write32(k+TSR_EBX,this.reg32[reg_ebx]);this.safe_write32(k+TSR_ESP,this.reg32[reg_esp]);this.safe_write32(k+TSR_EBP,this.reg32[reg_ebp]);this.safe_write32(k+ +TSR_ESI,this.reg32[reg_esi]);this.safe_write32(k+TSR_EDI,this.reg32[reg_edi]);this.safe_write32(k+TSR_ES,this.sreg[reg_es]);this.safe_write32(k+TSR_CS,this.sreg[reg_cs]);this.safe_write32(k+TSR_SS,this.sreg[reg_ss]);this.safe_write32(k+TSR_DS,this.sreg[reg_ds]);this.safe_write32(k+TSR_FS,this.sreg[reg_fs]);this.safe_write32(k+TSR_GS,this.sreg[reg_gs]);this.write8(d.table_offset+5|0,this.read8(d.table_offset+5|0)|2);f=d.base;dbg_assert(!e,"unimplemented");this.safe_write16(f+TSR_BACKLINK,this.sreg[reg_tr]); +g=this.safe_read32s(f+TSR_CR3);this.flags[0]&=~flag_vm;var l=this.safe_read32s(f+TSR_EIP),m=this.safe_read16(f+TSR_CS),n=this.lookup_segment_selector(m);if(n.is_null)throw dbg_log("null cs",LOG_CPU),this.debug.unimpl("#TS handler");if(!n.is_valid)throw dbg_log("invalid cs: "+h(a),LOG_CPU),this.debug.unimpl("#TS handler");if(n.is_system)throw this.debug.unimpl("#TS handler");if(!n.is_executable)throw this.debug.unimpl("#TS handler");if(n.dc_bit&&n.dpl>n.rpl)throw dbg_log("cs conforming and dpl > rpl: "+ +h(a),LOG_CPU),this.debug.unimpl("#TS handler");if(!n.dc_bit&&n.dpl!==n.rpl)throw dbg_log("cs non-conforming and dpl != rpl: "+h(a),LOG_CPU),this.debug.unimpl("#TS handler");if(!n.is_present)throw dbg_log("#NP for loading not-present in cs sel="+h(a,4),LOG_CPU),this.debug.unimpl("#TS handler");this.segment_is_null[reg_cs]=0;this.segment_limits[reg_cs]=n.effective_limit;this.segment_offsets[reg_cs]=n.base;this.sreg[reg_cs]=m;this.cpl=n.dpl;this.cpl_changed();dbg_assert((this.sreg[reg_cs]&3)===this.cpl); +dbg_assert(l>>>0<=n.effective_limit,"todo: #gp");this.update_cs_size(n.size);m=this.safe_read32s(f+TSR_EFLAGS);this.safe_write32(k+TSR_BACKLINK,a);m|=flag_nt;if(m&flag_vm)throw this.debug.unimpl("task switch to VM mode");this.update_eflags(m);this.flags[0]|=flag_nt;k=this.safe_read16(f+TSR_LDT);this.load_ldt(k);this.reg32[reg_eax]=this.safe_read32s(f+TSR_EAX);this.reg32[reg_ecx]=this.safe_read32s(f+TSR_ECX);this.reg32[reg_edx]=this.safe_read32s(f+TSR_EDX);this.reg32[reg_ebx]=this.safe_read32s(f+TSR_EBX); +this.reg32[reg_esp]=this.safe_read32s(f+TSR_ESP);this.reg32[reg_ebp]=this.safe_read32s(f+TSR_EBP);this.reg32[reg_esi]=this.safe_read32s(f+TSR_ESI);this.reg32[reg_edi]=this.safe_read32s(f+TSR_EDI);this.switch_seg(reg_es,this.safe_read16(f+TSR_ES))&&this.switch_seg(reg_ss,this.safe_read16(f+TSR_SS))&&this.switch_seg(reg_ds,this.safe_read16(f+TSR_DS))&&this.switch_seg(reg_fs,this.safe_read16(f+TSR_FS))&&this.switch_seg(reg_gs,this.safe_read16(f+TSR_GS))||dbg_assert(!1);this.instruction_pointer[0]=this.get_seg_cs()+ +l|0;this.segment_offsets[reg_tr]=d.base;this.segment_limits[reg_tr]=d.effective_limit;this.sreg[reg_tr]=a;this.cr[3]=g;dbg_assert(0===(this.cr[3]&4095));this.clear_tlb();this.cr[0]|=CR0_TS;!1!==b&&(e?this.push16(c&65535):this.push32(c))}};CPU.prototype.hlt_op=function(){this.cpl[0]?(dbg_log("#gp hlt with cpl != 0",LOG_CPU),this.trigger_gp(0)):(0===(this.get_eflags_no_arith()&flag_interrupt)&&this.bus.send("cpu-event-halt"),this.in_hlt[0]=1,this.hlt_loop())}; +CPU.prototype.handle_irqs=function(){this.get_eflags_no_arith()&flag_interrupt&&this.pic_acknowledge()};CPU.prototype.pic_acknowledge=function(){dbg_assert(this.get_eflags_no_arith()&flag_interrupt);this.devices.pic&&this.devices.pic.acknowledge_irq();this.devices.apic&&this.devices.apic.acknowledge_irq()};CPU.prototype.device_raise_irq=function(a){dbg_assert(1===arguments.length);this.devices.pic&&this.devices.pic.set_irq(a);this.devices.ioapic&&this.devices.ioapic.set_irq(a)}; +CPU.prototype.device_lower_irq=function(a){this.devices.pic&&this.devices.pic.clear_irq(a);this.devices.ioapic&&this.devices.ioapic.clear_irq(a)}; +CPU.prototype.cpuid=function(){var a=0,b=0,c=0,d=0;const e=this.reg32[reg_eax];switch(e){case 0:a=22;d=1970169159;c=1231384169;b=1818588270;break;case 1:a=3939;d=67584;b=1082130432;VMWARE_HYPERVISOR_PORT&&(b|=-2147483648);c=125872441;this.acpi_enabled[0]&&(c|=512);break;case 2:a=1717260289;b=d=0;c=8024064;break;case 4:switch(this.reg32[reg_ecx]){case 0:a=289;d=29360191;b=63;c=1;break;case 1:a=290;d=29360191;b=63;c=1;break;case 2:a=323,d=96469055,b=4095,c=1}break;case 5:d=a=64;b=3;c=1319200;break; +case 7:a=0;d=512;c=b=0;break;case -2147483648:a=5;break;case 1073741824:VMWARE_HYPERVISOR_PORT&&(d=1635208534,b=1297507698,c=1701994871);break;case 21:d=a=1;b=1E3*TSC_RATE;dbg_assert(b>>>0===b);break;case 22:a=Math.floor(TSC_RATE/1E3);d=Math.floor(TSC_RATE/1E3);b=10;dbg_assert(65536>a);dbg_assert(65536>d);dbg_assert(65536>b);break;default:dbg_log("cpuid: unimplemented eax: "+h(this.reg32[reg_eax]>>>0),LOG_CPU)}4===e?dbg_log("cpuid: eax="+h(this.reg32[reg_eax]>>>0,8)+" cl="+h(this.reg32[reg_ecx]&255, +2),LOG_CPU):0!==e&&2!==e&&-2147483648!==e&&dbg_log("cpuid: eax="+h(this.reg32[reg_eax]>>>0,8),LOG_CPU);this.reg32[reg_eax]=a;this.reg32[reg_ecx]=b;this.reg32[reg_edx]=c;this.reg32[reg_ebx]=d};CPU.prototype.update_cs_size=function(a){a=!!a;!!this.is_32[0]!==a&&(this.is_32[0]=+a)}; +CPU.prototype.lookup_segment_selector=function(a){dbg_assert("number"===typeof a&&0<=a&&65536>a);var b=0===(a&4),c=a&-8;var d={rpl:a&3,from_gdt:b,is_null:!1,is_valid:!0,base:0,access:0,flags:0,type:0,dpl:0,is_system:!1,is_present:!1,is_executable:!1,rw_bit:!1,dc_bit:!1,size:!1,is_conforming_executable:!1,effective_limit:0,is_writable:!1,is_readable:!1,table_offset:0,raw0:0,raw1:0};if(b){var e=this.gdtr_offset[0];var f=this.gdtr_size[0]}else e=this.segment_offsets[reg_ldtr],f=this.segment_limits[reg_ldtr]; +if(b&&0===c)return d.is_null=!0,d;if((a|7)>f)return dbg_log("Selector "+h(a,4)+" is outside of the "+(b?"g":"l")+"dt limits",LOG_CPU),d.is_valid=!1,d;e=e+c|0;this.cr[0]&CR0_PG&&(e=this.translate_address_system_read(e));d.table_offset=e;d.base=this.read16(e+2|0)|this.read8(e+4|0)<<16|this.read8(e+7|0)<<24;d.access=this.read8(e+5|0);d.flags=this.read8(e+6|0)>>4;d.raw0=this.read32s(e|0);d.raw1=this.read32s(e+4|0);d.type=d.access&15;d.dpl=d.access>>5&3;d.is_system=0===(d.access&16);d.is_present=128=== +(d.access&128);d.is_executable=8===(d.access&8);d.rw_bit=2===(d.access&2);d.dc_bit=4===(d.access&4);d.is_conforming_executable=d.dc_bit&&d.is_executable;d.size=4===(d.flags&4);a=this.read16(e)|(this.read8(e+6|0)&15)<<16;d.effective_limit=d.flags&8?(a<<12|4095)>>>0:a;d.is_writable=d.rw_bit&&!d.is_executable;d.is_readable=d.rw_bit||!d.is_executable;return d}; +CPU.prototype.switch_seg=function(a,b){dbg_assert(0<=a&&5>=a);dbg_assert("number"===typeof b&&65536>b&&0<=b);if(!this.protected_mode[0]||this.vm86_mode())return this.sreg[a]=b,this.segment_is_null[a]=0,this.segment_offsets[a]=b<<4,a===reg_ss&&(this.stack_size_32[0]=0),!0;var c=this.lookup_segment_selector(b);if(a===reg_ss){if(c.is_null)return dbg_log("#GP for loading 0 in SS sel="+h(b,4),LOG_CPU),dbg_trace(LOG_CPU),this.trigger_gp(0),!1;if(!c.is_valid||c.is_system||c.rpl!==this.cpl[0]||!c.is_writable|| +c.dpl!==this.cpl[0])return dbg_log("#GP for loading invalid in SS sel="+h(b,4),LOG_CPU),dbg_trace(LOG_CPU),this.trigger_gp(b&-4),!1;if(!c.is_present)return dbg_log("#SS for loading non-present in SS sel="+h(b,4),LOG_CPU),dbg_trace(LOG_CPU),this.trigger_ss(b&-4),!1;this.stack_size_32[0]=c.size}else if(a===reg_cs)dbg_assert(!1);else{if(c.is_null)return this.sreg[a]=b,this.segment_is_null[a]=1,!0;if(!c.is_valid||c.is_system||!c.is_readable||!c.is_conforming_executable&&(c.rpl>c.dpl||this.cpl[0]>c.dpl))return dbg_log("#GP for loading invalid in seg "+ +a+" sel="+h(b,4),LOG_CPU),this.debug.dump_state(),this.debug.dump_regs(),dbg_trace(LOG_CPU),this.trigger_gp(b&-4),!1;if(!c.is_present)return dbg_log("#NP for loading not-present in seg "+a+" sel="+h(b,4),LOG_CPU),dbg_trace(LOG_CPU),this.trigger_np(b&-4),!1}this.segment_is_null[a]=0;this.segment_limits[a]=c.effective_limit;this.segment_offsets[a]=c.base;this.sreg[a]=b;return!0}; +CPU.prototype.load_tr=function(a){var b=this.lookup_segment_selector(a);dbg_assert(b.is_valid);if(!b.from_gdt)throw this.debug.unimpl("TR can only be loaded from GDT");if(b.is_null)throw dbg_log("#GP(0) | tried to load null selector (ltr)"),this.debug.unimpl("#GP handler");if(!b.is_system)throw dbg_log("#GP | ltr: not a system entry"),this.debug.unimpl("#GP handler (happens when running kvm-unit-test without ACPI)");if(9!==b.type&&1!==b.type)throw dbg_log("#GP | ltr: invalid type (type = "+h(b.type)+ +")"),this.debug.unimpl("#GP handler");if(!b.is_present)throw dbg_log("#NT | present bit not set (ltr)"),this.debug.unimpl("#NT handler");this.tss_size_32[0]=9===b.type;this.segment_offsets[reg_tr]=b.base;this.segment_limits[reg_tr]=b.effective_limit;this.sreg[reg_tr]=a;this.write8(b.table_offset+5|0,this.read8(b.table_offset+5|0)|2)}; +CPU.prototype.load_ldt=function(a){var b=this.lookup_segment_selector(a);if(b.is_null)this.segment_offsets[reg_ldtr]=0,this.segment_limits[reg_ldtr]=0;else{dbg_assert(b.is_valid);if(!b.from_gdt)throw this.debug.unimpl("LDTR can only be loaded from GDT");if(!b.is_present)throw dbg_log("lldt: present bit not set"),this.debug.unimpl("#GP handler");if(!b.is_system)throw dbg_log("lldt: not a system entry"),this.debug.unimpl("#GP handler");if(2!==b.type)throw dbg_log("lldt: invalid type ("+b.type+")"), +this.debug.unimpl("#GP handler");this.segment_offsets[reg_ldtr]=b.base;this.segment_limits[reg_ldtr]=b.effective_limit;this.sreg[reg_ldtr]=a}};"undefined"!==typeof window?window.CPU=CPU:"undefined"!==typeof module&&"undefined"!==typeof module.exports?module.exports.CPU=CPU:"function"===typeof importScripts&&(self.CPU=CPU);CPU.prototype.debug_init=function(){function a(){DEBUG&&(g.running||g.cycle(),d(),Date.now(),g.running=!1,f())}function b(a){if(DEBUG){for(var b=g.protected_mode[0]?"prot":"real",c=g.get_eflags(),d=g.getiopl(),e=g.cpl[0],f=h(g.sreg[reg_cs],4)+":"+h(g.get_real_eip()>>>0,8),l=h(g.sreg[reg_ss],4)+":"+h(g.reg32[reg_es]>>>0,8),k=g.is_32[0]?"32":"16",m=g.flags[0]&flag_interrupt?1:0,q={[flag_carry]:"c",[flag_parity]:"p",[flag_adjust]:"a",[flag_zero]:"z",[flag_sign]:"s",[flag_trap]:"t",[flag_interrupt]:"i", +[flag_direction]:"d",[flag_overflow]:"o"},n="",p=0;16>p;p++)q[1<e;e++)c+=b[e]+"="+h(g.reg32[a[b[e]]]>>>0,8)+" ",d+=b[e+4]+"="+h(g.reg32[a[b[e+4]]]>>>0,8)+" ";c+=" ds="+h(g.sreg[reg_ds],4)+" es="+h(g.sreg[reg_es],4)+" fs="+h(g.sreg[reg_fs],4);d+=" gs="+h(g.sreg[reg_gs],4)+" cs="+h(g.sreg[reg_cs],4)+" ss="+h(g.sreg[reg_ss],4);return[c,d]}function d(){if(DEBUG){var a=c();dbg_log(a[0],LOG_CPU);dbg_log(a[1],LOG_CPU)}}function e(){if(DEBUG){l.step_mode=!0;var a,b="";l.trace_all&&l.all_ops?a=l.all_ops:l.ops&&(a=l.ops.toArray());if(!a)return"";for(var c= +0;c>>0}}}var g=this,l={};this.debug=l;l.step_mode=!1;l.ops=void 0;l.all_ops=[];l.trace_all= +!1;l.show=function(a){if("undefined"!==typeof document){var b=document.getElementById("log");if(b){b.textContent+=a+"\n";b.style.display="block";b.scrollTop=1E9;return}}console.log(a)};l.init=function(){function a(a){10===a?(dbg_log(b,LOG_BIOS),b=""):b+=String.fromCharCode(a)}if(DEBUG&&(l.ops=new CircularQueue(2E5),g.io)){var b="";g.io.register_write(1026,this,a);g.io.register_write(1280,this,a)}};l.get_regs_short=c;l.dump_regs=d;l.dump_instructions=f;l.get_instructions=e;l.get_state=b;l.dump_state= +function(a){DEBUG&&dbg_log(b(a),LOG_CPU)};l.dump_stack=function(a,b){if(DEBUG){var c=g.reg32[reg_esp];dbg_log("========= STACK ==========");if(b>=a||void 0===b)a=5,b=-5;for(;a>b;a--){var d=" ";a||(d="=> ");d+=h(a,2)+" | ";dbg_log(d+h(c+4*a,8)+" | "+h(g.read32s(c+4*a)>>>0))}}};l.dump_page_directory=function(){if(DEBUG)for(var a=0;1024>a;a++){var b=g.read32s(g.cr[3]+4*a),c=k(b,!0);if(c)if(b="",b+=c.size?"S ":" ",b+=c.accessed?"A ":" ",b+=c.cache_disable?"Cd ":" ",b+=c.user?"U ":" ",b+=c.read_write? +"Rw ":" ",c.size)dbg_log("=== "+h(a<<22>>>0,8)+" -> "+h(c.address>>>0,8)+" | "+b);else{dbg_log("=== "+h(a<<22>>>0,8)+" | "+b);for(var d=0;1024>d;d++){var e=c.address+4*d;b=g.read32s(e);var f=k(b,!1);f&&(b="",b+=f.cache_disable?"Cd ":" ",b+=f.user?"U ":" ",b+=f.read_write?"Rw ":" ",b+=f.global?"G ":" ",b+=f.accessed?"A ":" ",b+=f.dirty?"Di ":" ",dbg_log("# "+h((a<<22|d<<12)>>>0,8)+" -> "+h(f.address,8)+" | "+b+" (at "+h(e,8)+")"))}}else dbg_log("Not present: "+h(a<<22>>>0,8))}};l.dump_gdt_ldt= +function(){function a(a,b){for(var c=0;c>4,k="",m=f>>5&3;k=f&128?k+" P ":k+"NP ";f&16?(k=l&4?k+"32b ":k+"16b ",f&8?(k+="X ",f&4&&(k+="C ")):k+="R ",k+="RW "):k+="sys: "+h(f&15);l&8&&(e=e<<12|4095);dbg_log(h(c&-8,4)+" "+h(d>>>0,8)+" ("+h(e>>>0,8)+" bytes) "+k+"; dpl = "+m+", a = "+f.toString(2)+", f = "+l.toString(2))}}DEBUG&&(dbg_log("gdt: (len = "+h(g.gdtr_size[0])+ +")"),a(g.translate_address_system_read(g.gdtr_offset[0]),g.gdtr_size[0]),dbg_log("\nldt: (len = "+h(g.segment_limits[reg_ldtr])+")"),a(g.translate_address_system_read(g.segment_offsets[reg_ldtr]),g.segment_limits[reg_ldtr]))};l.dump_idt=function(){if(DEBUG)for(var a=0;a>5&3;var f=5===(b&31)?"task gate ":14===(b&31)?"intr gate ":15===(b&31)?"trap gate ": +"invalid ";f=b&128?f+" P":f+"NP";dbg_log(h(a>>3,4)+" "+h(c>>>0,8)+", "+h(d,4)+"; "+f+"; dpl = "+e+", t = "+b.toString(2))}};l.get_memory_dump=function(a,b){if(DEBUG)return void 0===a?(a=0,b=g.memory_size[0]):void 0===b&&(b=a,a=0),g.mem8.slice(a,a+b).buffer};l.memory_hex_dump=function(a,b){if(DEBUG){b=b||64;for(var c,d,e=0;e>4;e++){c=h(a+(e<<4),5)+" ";for(var f=0;16>f;f++)d=g.read8(a+(e<<4)+f),c+=h(d,2)+" ";c+=" ";for(f=0;16>f;f++)d=g.read8(a+(e<<4)+f),c+=33>d||126c;c++){b=h(128*c*a,8)+" | ";for(var d=0;128>d;d++)b+=0>>=0,l.trace_all&&l.all_ops?l.all_ops.push(a,b):l.ops&&(l.ops.add(a),l.ops.add(b)))};l.debug_interrupt=function(a){};let n,p;l.dump_code=function(a,b,c){if(!p){if(void 0===n&&(n="function"===typeof require?require("./capstone-x86.min.js"):window.cs,void 0===n)){dbg_log("Warning: Missing capstone library, disassembly not available");return}p=[new n.Capstone(n.ARCH_X86,n.MODE_16),new n.Capstone(n.ARCH_X86,n.MODE_32)]}try{p[a].disasm(b,c).forEach(function(a){dbg_log(h(a.address>>> +0)+": "+v86util.pads(a.bytes.map(a=>h(a,2).slice(-2)).join(" "),20)+" "+a.mnemonic+" "+a.op_str)}),dbg_log("")}catch(w){dbg_log("Could not disassemble: "+Array.from(b).map(a=>h(a,2)).join(" "))}};let r;l.dump_wasm=function(a){if(void 0===r&&(r="function"===typeof require?require("./libwabt.js"):new window.WabtModule,void 0===r)){dbg_log("Warning: Missing libwabt, wasm dump not available");return}a=a.slice();try{var b=r.readWasm(a,{readDebugNames:!1});b.generateNames();b.applyNames();const c=b.toText({foldExprs:!0, +inlineExport:!0});dbg_log(c)}catch(z){var c=new Blob([a]),d=document.createElement("a");d.download="failed.wasm";d.href=window.URL.createObjectURL(c);d.dataset.downloadurl=["application/octet-stream",d.download,d.href].join(":");d.click();window.URL.revokeObjectURL(d.src);console.log(z.toString())}finally{b&&b.destroy()}}};const ELF_MAGIC=1179403647; +let types=DataView.prototype,U8={size:1,get:types.getUint8,set:types.setUint8},U16={size:2,get:types.getUint16,set:types.setUint16},U32={size:4,get:types.getUint32,set:types.setUint32},pad=function(a){return{size:a,get:a=>-1}},Header=create_struct([{magic:U32},{class:U8},{data:U8},{version0:U8},{osabi:U8},{abiversion:U8},{pad0:pad(7)},{type:U16},{machine:U16},{version1:U32},{entry:U32},{phoff:U32},{shoff:U32},{flags:U32},{ehsize:U16},{phentsize:U16},{phnum:U16},{shentsize:U16},{shnum:U16},{shstrndx:U16}]); +console.assert(52===Header.reduce((a,b)=>a+b.size,0));let ProgramHeader=create_struct([{type:U32},{offset:U32},{vaddr:U32},{paddr:U32},{filesz:U32},{memsz:U32},{flags:U32},{align:U32}]);console.assert(32===ProgramHeader.reduce((a,b)=>a+b.size,0));let SectionHeader=create_struct([{name:U32},{type:U32},{flags:U32},{addr:U32},{offset:U32},{size:U32},{link:U32},{info:U32},{addralign:U32},{entsize:U32}]);console.assert(40===SectionHeader.reduce((a,b)=>a+b.size,0)); +function create_struct(a){return a.map(function(a){var b=Object.keys(a);console.assert(1===b.length);b=b[0];a=a[b];console.assert(0>1];if(l!==LINUX_BOOT_HDR_CHECKSUM1)dbg_log("Bad checksum1: "+h(l));else if(l=f[LINUX_BOOT_HDR_HEADER>>1]|f[LINUX_BOOT_HDR_HEADER+2>>1]<<16,l!==LINUX_BOOT_HDR_CHECKSUM2)dbg_log("Bad checksum2: "+h(l));else{l=f[LINUX_BOOT_HDR_VERSION>>1];dbg_assert(514<=l);var m=e[LINUX_BOOT_HDR_LOADFLAGS];dbg_assert(m& +LINUX_BOOT_HDR_LOADFLAGS_LOADED_HIGH);var n=f[LINUX_BOOT_HDR_XLOADFLAGS>>1],p=k[LINUX_BOOT_HDR_INITRD_ADDR_MAX>>2],r=k[LINUX_BOOT_HDR_KERNEL_ALIGNMENT>>2],q=e[LINUX_BOOT_HDR_RELOCATABLE_KERNEL],u=e[LINUX_BOOT_HDR_MIN_ALIGNMENT],t=k[LINUX_BOOT_HDR_CMDLINE_SIZE>>2],w=k[LINUX_BOOT_HDR_PAYLOAD_OFFSET>>2],z=k[LINUX_BOOT_HDR_PAYLOAD_LENGTH>>2],v=k[LINUX_BOOT_HDR_PREF_ADDRESS>>2],x=k[LINUX_BOOT_HDR_PREF_ADDRESS+4>>2],A=k[LINUX_BOOT_HDR_INIT_SIZE>>2];dbg_log("kernel boot protocol version: "+h(l));dbg_log("flags="+ +h(m)+" xflags="+h(n));dbg_log("code32_start="+h(k[LINUX_BOOT_HDR_CODE32_START>>2]));dbg_log("initrd_addr_max="+h(p));dbg_log("kernel_alignment="+h(r));dbg_log("relocatable="+q);dbg_log("min_alignment="+h(u));dbg_log("cmdline max="+h(t));dbg_log("payload offset="+h(w)+" size="+h(z));dbg_log("pref_address="+h(x)+":"+h(v));dbg_log("init_size="+h(A));e[LINUX_BOOT_HDR_TYPE_OF_LOADER]=LINUX_BOOT_HDR_TYPE_OF_LOADER_NOT_ASSIGNED;e[LINUX_BOOT_HDR_LOADFLAGS]=m&~LINUX_BOOT_HDR_LOADFLAGS_QUIET_FLAG&~LINUX_BOOT_HDR_LOADFLAGS_KEEP_SEGMENTS| +LINUX_BOOT_HDR_LOADFLAGS_CAN_USE_HEAPS;f[LINUX_BOOT_HDR_HEAP_END_PTR>>1]=56832;f[LINUX_BOOT_HDR_VIDMODE>>1]=65535;dbg_log("heap_end_ptr="+h(56832));d+="\x00";dbg_assert(d.length>2]=581632;for(e=0;e>2]=g;k[LINUX_BOOT_HDR_RAMDISK_SIZE>>2]=e;dbg_assert(655360>524288+d.length);a.set(d,524288);a.set(b,1048576);return{option_rom:{name:"genroms/kernel.bin",data:make_linux_boot_rom(32768,57344)}}}} +function make_linux_boot_rom(a,b){const c=new Uint8Array(256);(new Uint16Array(c.buffer))[0]=43605;c[2]=1;var d=3;c[d++]=250;c[d++]=184;c[d++]=a>>0;c[d++]=a>>8;c[d++]=142;c[d++]=192;c[d++]=142;c[d++]=216;c[d++]=142;c[d++]=224;c[d++]=142;c[d++]=232;c[d++]=142;c[d++]=208;c[d++]=188;c[d++]=b>>0;c[d++]=b>>8;c[d++]=234;c[d++]=0;c[d++]=0;c[d++]=a+32>>0;c[d++]=a+32>>8;dbg_assert(512>d);a=d;b=c[a]=0;for(d=0;d keyCode not found: ",b,a)}};function MouseAdapter(a,b){function c(a){if(!t.enabled||!t.emu_enabled)return!1;var c=b||document.body,d;if(!(d=document.pointerLockElement))a:{for(a=a.target;a.parentNode;){if(a===c){d=!0;break a}a=a.parentNode}d=!1}return d}function d(a){c(a)&&(a=a.changedTouches)&&a.length&&(a=a[a.length-1],q=a.clientX,u=a.clientY)}function e(a){if(n||r||p)t.bus.send("mouse-click",[!1,!1,!1]),n=r=p=!1}function f(a){if(t.bus&&c(a)){var d=0,e=0,f=a.changedTouches;f?f.length&&(f=f[f.length-1],d=f.clientX-q,e=f.clientY- +u,q=f.clientX,u=f.clientY,a.preventDefault()):"number"===typeof a.movementX?(d=a.movementX,e=a.movementY):"number"===typeof a.webkitMovementX?(d=a.webkitMovementX,e=a.webkitMovementY):"number"===typeof a.mozMovementX?(d=a.mozMovementX,e=a.mozMovementY):(d=a.clientX-q,e=a.clientY-u,q=a.clientX,u=a.clientY);t.bus.send("mouse-delta",[.15*d,-(.15*e)]);b&&t.bus.send("mouse-absolute",[a.pageX-b.offsetLeft,a.pageY-b.offsetTop,b.offsetWidth,b.offsetHeight])}}function k(a){c(a)&&l(a,!0)}function g(a){c(a)&& +l(a,!1)}function l(a,b){t.bus&&(1===a.which?n=b:2===a.which?r=b:3===a.which?p=b:dbg_log("Unknown event.which: "+a.which),t.bus.send("mouse-click",[n,r,p]))}function m(a){if(c(a)){var b=a.wheelDelta||-a.detail;0>b?b=-1:0{switch(b.data.type){case "queue":a.queue_push(b.data.value);break;case "sampling-rate":a.source_samples_per_destination=b.data.value/sampleRate}};return a}var c=[new Float32Array(256),new Float32Array(256)];Reflect.setPrototypeOf(b.prototype,AudioWorkletProcessor.prototype);Reflect.setPrototypeOf(b,AudioWorkletProcessor);b.prototype.process=b.prototype.process=function(a,b,c){for(a=0;aa?(a+=this.source_buffer_previous[0].length,this.source_buffer_previous[b][a]):this.source_buffer_current[b][a]};b.prototype.ensure_enough_data=function(a){var b=this.source_buffer_current[0].length;b-this.source_block_startthis.queued_samples&&this.queue_length&&this.dbg_log("Not enough samples - should not happen during midway of playback");this.source_buffer_previous=this.source_buffer_current;this.source_buffer_current=this.queue_shift();var a=this.source_buffer_current[0].length;if(256>a){for(var b=this.queue_start,c=0;256>a&&cthis.queued_samples/this.source_samples_per_destination&&this.port.postMessage({type:"pump"})};b.prototype.queue_push=function(a){this.queue_length{URL.revokeObjectURL(f);this.node_processor=new AudioWorkletNode(this.audio_context,"dac-processor",{numberOfInputs:0,numberOfOutputs:1,outputChannelCount:[2],parameterData:{},processorOptions:{}});this.node_processor.port.postMessage({type:"sampling-rate", +value:this.sampling_rate});this.node_processor.port.onmessage=a=>{switch(a.data.type){case "pump":this.pump();break;case "debug-log":dbg_log("SpeakerWorkletDAC - Worklet: "+a.data.value)}};this.node_processor.connect(this.node_output)});this.mixer_connection=c.add_source(this.node_output,MIXER_SRC_DAC);this.mixer_connection.set_gain_hidden(3);a.register("dac-send-data",function(a){this.queue(a)},this);a.register("dac-enable",function(a){this.enabled=!0},this);a.register("dac-disable",function(){this.enabled= +!1},this);a.register("dac-tell-sampling-rate",function(a){dbg_assert(0this.pump(),1E3*b);a.start(this.buffered_time);this.buffered_time+= +c;setTimeout(()=>this.pump(),0)};SpeakerBufferSourceDAC.prototype.pump=function(){this.enabled&&(this.buffered_time-this.audio_context.currentTime>DAC_QUEUE_RESERVE||this.bus.send("dac-request-data"))}; +function SpeakerDACDebugger(a,b){this.audio_context=a;this.node_source=b;this.node_processor=null;this.node_gain=this.audio_context.createGain();this.node_gain.gain.setValueAtTime(0,this.audio_context.currentTime);this.node_gain.connect(this.audio_context.destination);this.is_active=!1;this.queued_history=[];this.output_history=[];this.queued=[[],[]];this.output=[[],[]]} +SpeakerDACDebugger.prototype.start=function(a){this.is_active=!0;this.queued=[[],[]];this.output=[[],[]];this.queued_history.push(this.queued);this.output_history.push(this.output);this.node_processor=this.audio_context.createScriptProcessor(1024,2,2);this.node_processor.onaudioprocess=a=>{this.output[0].push(a.inputBuffer.getChannelData(0).slice());this.output[1].push(a.inputBuffer.getChannelData(1).slice())};this.node_source.connect(this.node_processor);this.node_processor.connect(this.node_gain); +setTimeout(()=>{this.stop()},a)};SpeakerDACDebugger.prototype.stop=function(){this.is_active=!1;this.node_source.disconnect(this.node_processor);this.node_processor.disconnect();this.node_processor=null};SpeakerDACDebugger.prototype.push_queued_data=function(a){this.is_active&&(this.queued[0].push(a[0].slice()),this.queued[1].push(a[1].slice()))};SpeakerDACDebugger.prototype.download_txt=function(a,b){a=this.output_history[a][b].map(a=>a.join(" ")).join(" ");dump_file(a,"dacdata.txt")}; +SpeakerDACDebugger.prototype.download_csv=function(a){a=this.output_history[a];for(var b=[],c=0;cb?void 0===this.update_timer&&(this.update_timer=setTimeout(()=>{this.update_timer=void 0;var a=Date.now();dbg_assert(15<=a-this.last_update);this.last_update=a;this.render()},16-b)):(void 0!==this.update_timer&&(clearTimeout(this.update_timer),this.update_timer=void 0),this.last_update=a,this.render())};this.render=function(){a.value=this.text; +this.text_new_line&&(this.text_new_line=!1,a.scrollTop=1E9)};this.send_char=function(a){k.bus&&k.bus.send("serial0-input",a)}}function SerialRecordingAdapter(a){this.text="";a.register("serial0-output-char",function(a){this.text+=a},this)} +function SerialAdapterXtermJS(a,b){this.element=a;if(window.Terminal){var c=this.term=new window.Terminal;c.setOption("logLevel","off");c.write("This is the serial console. Whatever you type or paste here will be sent to COM1");c.onData(function(a){b.send("serial0-input",a.charCodeAt(0))});b.register("serial0-output-char",function(a){c.write(a)},this)}}SerialAdapterXtermJS.prototype.show=function(){this.term&&this.term.open(this.element)};function NetworkAdapter(a,b){this.bus=b;this.socket=void 0;this.send_queue=[];this.url=a;this.reconnect_interval=1E4;this.last_connect_attempt=Date.now()-this.reconnect_interval;this.send_queue_limit=64;this.bus.register("net0-send",function(a){this.send(a)},this)}NetworkAdapter.prototype.handle_message=function(a){this.bus&&this.bus.send("net0-receive",new Uint8Array(a.data))};NetworkAdapter.prototype.handle_close=function(a){this.connect();setTimeout(this.connect.bind(this),this.reconnect_interval)}; +NetworkAdapter.prototype.handle_open=function(a){for(a=0;aa||(this.last_connect_attempt=Date.now(),this.socket=new WebSocket(this.url),this.socket.binaryType="arraybuffer",this.socket.onopen=this.handle_open.bind(this),this.socket.onmessage=this.handle_message.bind(this),this.socket.onclose=this.handle_close.bind(this),this.socket.onerror=this.handle_error.bind(this))}}; +NetworkAdapter.prototype.send=function(a){this.socket&&1===this.socket.readyState?this.socket.send(a):(this.send_queue.push(a),this.send_queue.length>2*this.send_queue_limit&&(this.send_queue=this.send_queue.slice(-this.send_queue_limit)),this.connect())};NetworkAdapter.prototype.change_proxy=function(a){this.url=a;this.socket&&(this.socket.onclose=function(){},this.socket.onerror=function(){},this.socket.close(),this.socket=void 0)};var ASYNC_SAFE=!1; +(function(){function a(a,b){var c=new XMLHttpRequest;c.open(b.method||"get",a,!0);c.responseType=b.as_json?"json":"arraybuffer";if(b.headers)for(var d=Object.keys(b.headers),e=0;e{if(a)throw a;let e=b.range.length;var f=Buffer.allocUnsafe(e);c.read(d,f,0,e,b.range.start,(a,g)=>{if(a)throw a;dbg_assert(g===e);b.done&&b.done(new Uint8Array(f));c.close(d,a=>{if(a)throw a;})})})):c.readFile(a,{encoding:b.as_json?"utf-8":null},function(c,d){c?console.log("Could not read file:", +a,c):(c=d,c=b.as_json?JSON.parse(c):(new Uint8Array(c)).buffer,b.done(c))})}function c(a,b){this.filename=a;this.block_size=256;this.byteLength=b;this.loaded_blocks=Object.create(null);this.onprogress=this.onload=void 0}function d(a,b){const c=a.match(/(.*)(\..*)/);c?(this.basename=c[1],this.extension=c[2]):(this.basename=a,this.extension="");this.block_size=256;this.byteLength=b;this.loaded_blocks=Object.create(null);this.onprogress=this.onload=void 0}function e(a){this.file=a;this.byteLength=a.size; +1073741824>20)+" MB ...");this.buffer=new ArrayBuffer(a.size);this.onprogress=this.onload=void 0}function f(a){this.file=a;this.byteLength=a.size;this.block_size=256;this.loaded_blocks=Object.create(null);this.onprogress=this.onload=void 0}v86util.load_file="undefined"===typeof XMLHttpRequest?b:a;v86util.AsyncXHRBuffer=c;v86util.AsyncXHRPartfileBuffer=d;v86util.AsyncFileBuffer=f;v86util.SyncFileBuffer=e;v86util.read_sized_string_from_mem= +function(a,b,c){return String.fromCharCode(...new Uint8Array(a.buffer,b>>>0,c>>>0))};var k="undefined"===typeof XMLHttpRequest?function(a,b){require("fs").stat(a,(a,c)=>{a?b(a):b(null,c.size)})}:function(a,b){v86util.load_file(a,{done:(a,c)=>{a=c.getResponseHeader("Content-Range")||"";(c=a.match(/\/(\d+)\s*$/))?b(null,+c[1]):b("`Range: bytes=...` header not supported (Got `"+a+"`)")},headers:{Range:"bytes=0-0"}})};c.prototype.load=function(){void 0!==this.byteLength?this.onload&&this.onload(Object.create(null)): +k(this.filename,(a,b)=>{if(a)throw Error("Cannot use: "+this.filename+". "+a);dbg_assert(0<=b);this.byteLength=b;this.onload&&this.onload(Object.create(null))})};c.prototype.get_from_cache=function(a,b,c){c=b/this.block_size;a/=this.block_size;for(var d=0;d=d);f!==d&&(b.push(this.file.slice(d,f)),d=f);b.push(g);d+=g.length}d!==this.file.size&&b.push(this.file.slice(d));a=new File(b,a);console.assert(a.size===this.file.size);return a}})();function V86Starter(a){this.cpu_is_running=!1;const b=Bus.create();this.bus=b[0];this.emulator_bus=b[1];var c,d;const e=new WebAssembly.Table({element:"anyfunc",initial:WASM_TABLE_SIZE+WASM_TABLE_OFFSET}),f={cpu_exception_hook:a=>this.cpu_exception_hook&&this.cpu_exception_hook(a),hlt_op:function(){return c.hlt_op()},abort:function(){dbg_assert(!1)},logop:function(a,b){return c.debug.logop(a,b)},microtick:v86.microtick,get_rand_int:function(){return v86util.get_rand_int()},pic_acknowledge:function(){c.pic_acknowledge()}, +io_port_read8:function(a){return c.io.port_read8(a)},io_port_read16:function(a){return c.io.port_read16(a)},io_port_read32:function(a){return c.io.port_read32(a)},io_port_write8:function(a,b){c.io.port_write8(a,b)},io_port_write16:function(a,b){c.io.port_write16(a,b)},io_port_write32:function(a,b){c.io.port_write32(a,b)},mmap_read8:function(a){return c.mmap_read8(a)},mmap_read16:function(a){return c.mmap_read16(a)},mmap_read32:function(a){return c.mmap_read32(a)},mmap_write8:function(a,b){c.mmap_write8(a, +b)},mmap_write16:function(a,b){c.mmap_write16(a,b)},mmap_write32:function(a,b){c.mmap_write32(a,b)},mmap_write64:function(a,b,d){c.mmap_write64(a,b,d)},mmap_write128:function(a,b,d,e,f){c.mmap_write128(a,b,d,e,f)},cpuid:function(){return c.cpuid()},load_ldt:function(){return c.load_ldt.apply(c,arguments)},load_tr:function(){return c.load_tr.apply(c,arguments)},log_from_wasm:function(a,b){a=v86util.read_sized_string_from_mem(d,a,b);dbg_log(a,LOG_CPU)},console_log_from_wasm:function(a,b){a=v86util.read_sized_string_from_mem(d, +a,b);console.error(a)},dbg_trace_from_wasm:function(){dbg_trace()},codegen_finalize:(a,b,d,e,f)=>{c.codegen_finalize(a,b,d,e,f)},jit_clear_func:a=>c.jit_clear_func(a),jit_clear_all_funcs:()=>c.jit_clear_all_funcs(),do_task_switch:(a,b,d)=>{c.do_task_switch(a,b,d)},__indirect_function_table:e};let k=DEBUG?"v86-debug.wasm":"v86.wasm",g="v86-fallback.wasm";a.wasm_path?k=a.wasm_path:"undefined"===typeof window&&"string"===typeof __dirname?(k=__dirname+"/"+k,g=__dirname+"/"+g):(k="build/"+k,g="build/"+ +g);v86util.load_file(k,{done:b=>{WebAssembly.instantiate(b,{env:f}).then(({instance:b})=>{b=b.exports;d=b.memory;b.rust_init();b=this.v86=new v86(this.emulator_bus,{exports:b,wasm_table:e});c=b.cpu;this.continue_init(b,a)},b=>{v86util.load_file(g,{done:b=>{WebAssembly.instantiate(b,{env:f}).then(({instance:b})=>{b=b.exports;d=b.memory;b.rust_init();b=this.v86=new v86(this.emulator_bus,{exports:b,wasm_table:e});c=b.cpu;this.continue_init(b,a)})}})})},progress:a=>{this.emulator_bus.send("download-progress", +{file_index:0,file_count:1,file_name:k,lengthComputable:a.lengthComputable,total:a.total,loaded:a.loaded})}})} +V86Starter.prototype.continue_init=async function(a,b){function c(a,b){switch(a){case "hda":f.hda=this.disk_images.hda=b;break;case "hdb":f.hdb=this.disk_images.hdb=b;break;case "cdrom":f.cdrom=this.disk_images.cdrom=b;break;case "fda":f.fda=this.disk_images.fda=b;break;case "fdb":f.fdb=this.disk_images.fdb=b;break;case "multiboot":f.multiboot=this.disk_images.multiboot=b.buffer;break;case "bzimage":f.bzimage=this.disk_images.bzimage=b.buffer;break;case "initrd":f.initrd=this.disk_images.initrd=b.buffer; +break;case "bios":f.bios=b.buffer;break;case "vga_bios":f.vga_bios=b.buffer;break;case "initial_state":f.initial_state=b.buffer;break;case "fs9p_json":f.fs9p_json=b;break;default:dbg_assert(!1,a)}}function d(a,b){if(b)if(b.get&&b.set&&b.load)k.push({name:a,loadable:b});else{b={buffer:b.buffer,async:b.async,url:b.url,size:b.size,use_parts:b.use_parts};if("bios"===a||"vga_bios"===a||"initial_state"===a||"multiboot"===a||"bzimage"===a||"initrd"===a)b.async=!1;b.buffer instanceof ArrayBuffer?(b=new SyncBuffer(b.buffer), +k.push({name:a,loadable:b})):"undefined"!==typeof File&&b.buffer instanceof File?(void 0===b.async&&(b.async=268435456<=b.buffer.size),b=b.async?new v86util.AsyncFileBuffer(b.buffer):new v86util.SyncFileBuffer(b.buffer),k.push({name:a,loadable:b})):b.url?b.async?(b=b.use_parts?new v86util.AsyncXHRPartfileBuffer(b.url,b.size):new v86util.AsyncXHRBuffer(b.url,b.size),k.push({name:a,loadable:b})):k.push({name:a,url:b.url,size:b.size}):dbg_log("Ignored file: url="+b.url+" buffer="+b.buffer)}}function e(){function d(){this.serial_adapter&& +this.serial_adapter.show&&this.serial_adapter.show();this.bus.send("cpu-init",f);f.initial_state&&(a.restore_state(f.initial_state),f.initial_state=void 0);b.autostart&&this.bus.send("cpu-run");this.emulator_bus.send("emulator-loaded")}if(f.fs9p&&f.fs9p_json)if(f.initial_state?dbg_log("Filesystem basefs ignored: Overridden by state image"):f.fs9p.load_from_json(f.fs9p_json),b.bzimage_initrd_from_filesystem){const {bzimage:a,initrd:b}=this.get_bzimage_initrd_from_filesystem(f.fs9p);dbg_log("Found bzimage: "+ +a+" and initrd: "+b);Promise.all([f.fs9p.read_file(b),f.fs9p.read_file(a)]).then(([a,b])=>{c.call(this,"initrd",new SyncBuffer(a.buffer));c.call(this,"bzimage",new SyncBuffer(b.buffer));d.call(this)})}else d.call(this);else console.assert(!b.bzimage_initrd_from_filesystem,"bzimage_initrd_from_filesystem: Requires a filesystem"),d.call(this)}this.bus.register("emulator-stopped",function(){this.cpu_is_running=!1},this);this.bus.register("emulator-started",function(){this.cpu_is_running=!0},this);var f= +{};this.disk_images={fda:void 0,fdb:void 0,hda:void 0,hdb:void 0,cdrom:void 0};f.acpi=b.acpi;f.load_devices=!0;f.log_level=b.log_level;f.memory_size=b.memory_size||67108864;f.vga_memory_size=b.vga_memory_size||8388608;f.boot_order=b.boot_order||531;f.fastboot=b.fastboot||!1;f.fda=void 0;f.fdb=void 0;f.uart1=b.uart1;f.uart2=b.uart2;f.uart3=b.uart3;f.cmdline=b.cmdline;f.preserve_mac_from_state_image=b.preserve_mac_from_state_image;f.mac_address=b.mac_address;b.network_adapter?this.network_adapter=b.network_adapter(this.bus): +b.network_relay_url&&(this.network_adapter=new NetworkAdapter(b.network_relay_url,this.bus));f.enable_ne2k=!0;b.disable_keyboard||(this.keyboard_adapter=new KeyboardAdapter(this.bus));b.disable_mouse||(this.mouse_adapter=new MouseAdapter(this.bus,b.screen_container));b.screen_container?this.screen_adapter=new ScreenAdapter(b.screen_container,this.bus):b.screen_dummy&&(this.screen_adapter=new DummyScreenAdapter(this.bus));b.serial_container&&(this.serial_adapter=new SerialAdapter(b.serial_container, +this.bus));b.serial_container_xtermjs&&(this.serial_adapter=new SerialAdapterXtermJS(b.serial_container_xtermjs,this.bus));b.disable_speaker||(this.speaker_adapter=new SpeakerAdapter(this.bus));b.initial_state&&(f.initial_state=b.initial_state);var k=[];b.state&&console.warn("Warning: Unknown option 'state'. Did you mean 'initial_state'?");for(var g="bios vga_bios cdrom hda hdb fda fdb initial_state multiboot bzimage initrd".split(" "),l=0;l"/"+a);a=(a.read_dir("/boot/")||[]).map(a=>"/boot/"+a);let c,d;for(let e of[].concat(b,a)){const a=/old/i.test(e)||/fallback/i.test(e),b=/vmlinuz/i.test(e)||/bzimage/i.test(e),g=/initrd/i.test(e)||/initramfs/i.test(e);!b||d&&a||(d=e);!g||c&&a||(c=e)}c&&d||(console.log("Failed to find bzimage or initrd in filesystem. Files:"),console.log(b.join(" ")),console.log(a.join(" ")));return{initrd:c,bzimage:d}}; +V86Starter.prototype.run=function(){this.bus.send("cpu-run")};goog.exportProperty(V86Starter.prototype,"run",V86Starter.prototype.run);V86Starter.prototype.stop=function(){this.bus.send("cpu-stop")};goog.exportProperty(V86Starter.prototype,"stop",V86Starter.prototype.stop); +V86Starter.prototype.destroy=function(){this.stop();this.v86.destroy();this.keyboard_adapter&&this.keyboard_adapter.destroy();this.network_adapter&&this.network_adapter.destroy();this.mouse_adapter&&this.mouse_adapter.destroy();this.screen_adapter&&this.screen_adapter.destroy();this.serial_adapter&&this.serial_adapter.destroy()};goog.exportProperty(V86Starter.prototype,"destroy",V86Starter.prototype.destroy);V86Starter.prototype.restart=function(){this.bus.send("cpu-restart")}; +goog.exportProperty(V86Starter.prototype,"restart",V86Starter.prototype.restart);V86Starter.prototype.add_listener=function(a,b){this.bus.register(a,b,this)};goog.exportProperty(V86Starter.prototype,"add_listener",V86Starter.prototype.add_listener);V86Starter.prototype.remove_listener=function(a,b){this.bus.unregister(a,b)};goog.exportProperty(V86Starter.prototype,"remove_listener",V86Starter.prototype.remove_listener);V86Starter.prototype.restore_state=function(a){this.v86.restore_state(a)}; +goog.exportProperty(V86Starter.prototype,"restore_state",V86Starter.prototype.restore_state);V86Starter.prototype.save_state=function(a){setTimeout(function(){try{a(null,this.v86.save_state())}catch(b){a(b,null)}}.bind(this),0)};goog.exportProperty(V86Starter.prototype,"save_state",V86Starter.prototype.save_state); +V86Starter.prototype.get_statistics=function(){console.warn("V86Starter.prototype.get_statistics is deprecated. Use events instead.");var a={cpu:{instruction_counter:this.get_instruction_counter()}};if(!this.v86)return a;var b=this.v86.cpu.devices;b.hda&&(a.hda=b.hda.stats);b.cdrom&&(a.cdrom=b.cdrom.stats);b.ps2&&(a.mouse={enabled:b.ps2.use_mouse});b.vga&&(a.vga={is_graphical:b.vga.stats.is_graphical});return a};goog.exportProperty(V86Starter.prototype,"get_statistics",V86Starter.prototype.get_statistics); +V86Starter.prototype.get_instruction_counter=function(){return this.v86?this.v86.cpu.instruction_counter[0]>>>0:0};goog.exportProperty(V86Starter.prototype,"get_instruction_counter",V86Starter.prototype.get_instruction_counter);V86Starter.prototype.is_running=function(){return this.cpu_is_running};goog.exportProperty(V86Starter.prototype,"is_running",V86Starter.prototype.is_running);V86Starter.prototype.keyboard_send_scancodes=function(a){for(var b=0;b{const b=this.fs9p.Mount(a,f);d&&(b===-ENOENT?d(new FileNotFoundError):b===-EEXIST?d(new FileExistsError):0>b?(dbg_assert(!1,"Unexpected error code: "+-b),d(Error("Failed to mount. Error number: "+-b))):d(null))};b?(dbg_assert("object"===typeof c,"Filesystem: basefs must be a JSON object"),f.load_from_json(c,()=>k())):k()}; +goog.exportProperty(V86Starter.prototype,"mount_fs",V86Starter.prototype.mount_fs);V86Starter.prototype.create_file=function(a,b,c){c=c||function(){};var d=this.fs9p;if(d){var e=a.split("/");e=e[e.length-1];a=d.SearchPath(a).parentid;""!==e&&-1!==a?d.CreateBinaryFile(e,a,b).then(()=>c(null)):setTimeout(function(){c(new FileNotFoundError)},0)}};goog.exportProperty(V86Starter.prototype,"create_file",V86Starter.prototype.create_file); +V86Starter.prototype.read_file=function(a,b){var c=this.fs9p;c&&c.read_file(a).then(a=>{a?b(null,a):b(new FileNotFoundError,null)})};goog.exportProperty(V86Starter.prototype,"read_file",V86Starter.prototype.read_file); +V86Starter.prototype.automatically=function(a){const b=a=>{const c=a[0];if(c){var e=a.slice(1);if(c.sleep)setTimeout(()=>b(e),1E3*c.sleep);else if(c.vga_text){const d=this.screen_adapter.get_text_screen();for(let a of d)if(a.includes(c.vga_text)){b(e);return}setTimeout(()=>b(a),1E3)}else c.keyboard_send?(c.keyboard_send instanceof Array?this.keyboard_send_scancodes(c.keyboard_send):(dbg_assert("string"===typeof c.keyboard_send),this.keyboard_send_text(c.keyboard_send)),b(e)):c.call?(c.call(),b(e)): +console.assert(!1,c)}};b(a)};function FileExistsError(a){this.message=a||"File already exists"}FileExistsError.prototype=Error.prototype;function FileNotFoundError(a){this.message=a||"File not found"}FileNotFoundError.prototype=Error.prototype; +"undefined"!==typeof window?(window.V86Starter=V86Starter,window.V86=V86Starter):"undefined"!==typeof module&&"undefined"!==typeof module.exports?(module.exports.V86Starter=V86Starter,module.exports.V86=V86Starter):"function"===typeof importScripts&&(self.V86Starter=V86Starter,self.V86=V86Starter);var WorkerBus={Connector:function(a){this.listeners={};this.pair=a;a.addEventListener("message",function(a){a=a.data;for(var b=this.listeners[a[0]],d=0;d>20)+"m\n";b=b+"Config:\nMAX_PAGES="+(a.wm.exports.get_config(0)+"\n");b+="JIT_USE_LOOP_SAFETY="+a.wm.exports.get_config(1)+"\n";return b+="MAX_EXTRA_BASIC_BLOCKS="+a.wm.exports.get_config(2)+"\n"},print_instruction_counts:function(a){return[print_stats.print_instruction_counts_offset(a, +!1,!1,!1,!1),print_stats.print_instruction_counts_offset(a,!0,!1,!1,!1),print_stats.print_instruction_counts_offset(a,!1,!0,!1,!1),print_stats.print_instruction_counts_offset(a,!1,!1,!0,!1),print_stats.print_instruction_counts_offset(a,!1,!1,!1,!0)].join("\n\n")},print_instruction_counts_offset:function(a,b,c,d,e){let f="";var k=[],g=b?"compiled":c?"jit exit":d?"unguarded register":e?"wasm size":"executed";for(let f=0;256>f;f++)for(let g=0;8>g;g++)for(let m of[!1,!0]){var l=a.wm.exports.get_opstats_buffer(b, +c,d,e,f,!1,m,g);k.push({opcode:f,count:l,is_mem:m,fixed_g:g});l=a.wm.exports.get_opstats_buffer(b,c,d,e,f,!0,m,g);k.push({opcode:3840|f,count:l,is_mem:m,fixed_g:g})}a=0;b=new Set([38,46,54,62,100,101,102,103,240,242,243]);for(let {count:c,opcode:d}of k)b.has(d)||(a+=c);if(0===a)return"";c=new Uint32Array(256);b=new Uint32Array(256);for(let {opcode:a,count:d}of k)3840==(a&65280)?b[a&255]+=d:c[a&255]+=d;f=f+"------------------\nTotal: "+(a+"\n");const m=1E7 +Math.round(a/m)));d=String(d).length;f+=`Instruction counts ${g} (in ${m}):\n`;for(e=0;256>e;e++)f+=h(e,2).slice(2)+":"+v86util.pads(Math.round(c[e]/m),d),f=15==e%16?f+"\n":f+" ";f=f+"\n"+`Instruction counts ${g} (0f, in ${m}):\n`;for(g=0;256>g;g++)f+=h(g&255,2).slice(2)+":"+v86util.pads(Math.round(b[g]/m),d),f=15==g%16?f+"\n":f+" ";f+="\n";k=k.filter(({count:a})=>a).sort(({count:a},{count:b})=>b-a);for(let {opcode:b,is_mem:c,fixed_g:d,count:e}of k.slice(0,200))k=b.toString(16)+"_"+d+(c?"_m":"_r"), +f+=k+":"+(e/a*100).toFixed(2)+" ";return f+"\n"}};"undefined"!==typeof module&&"undefined"!==typeof module.exports&&(module.exports.print_stats=print_stats);function FileStorageInterface(){}FileStorageInterface.prototype.read=function(a,b,c){};FileStorageInterface.prototype.cache=function(a,b){};FileStorageInterface.prototype.uncache=function(a){};function MemoryFileStorage(){this.filedata=new Map}MemoryFileStorage.prototype.read=async function(a,b,c){dbg_assert(a,"MemoryFileStorage read: sha256sum should be a non-empty string");return(a=this.filedata.get(a))?a.subarray(b,b+c):null}; +MemoryFileStorage.prototype.cache=async function(a,b){dbg_assert(a,"MemoryFileStorage cache: sha256sum should be a non-empty string");this.filedata.set(a,b)};MemoryFileStorage.prototype.uncache=function(a){this.filedata.delete(a)};function ServerFileStorageWrapper(a,b){dbg_assert(b,"ServerMemoryFileStorage: baseurl should not be empty");this.storage=a;this.baseurl=b} +ServerFileStorageWrapper.prototype.load_from_server=function(a){return new Promise((b,c)=>{v86util.load_file(this.baseurl+a,{done:c=>{const d=new Uint8Array(c);this.cache(a,d).then(()=>b(d))}})})};ServerFileStorageWrapper.prototype.read=async function(a,b,c){const d=await this.storage.read(a,b,c);return d?d:(await this.load_from_server(a)).subarray(b,b+c)};ServerFileStorageWrapper.prototype.cache=async function(a,b){return await this.storage.cache(a,b)}; +ServerFileStorageWrapper.prototype.uncache=function(a){this.storage.uncache(a)};"undefined"!==typeof window?(window.MemoryFileStorage=MemoryFileStorage,window.ServerFileStorageWrapper=ServerFileStorageWrapper):"undefined"!==typeof module&&"undefined"!==typeof module.exports?(module.exports.MemoryFileStorage=MemoryFileStorage,module.exports.ServerFileStorageWrapper=ServerFileStorageWrapper):"function"===typeof importScripts&&(self.MemoryFileStorage=MemoryFileStorage,self.ServerFileStorageWrapper=ServerFileStorageWrapper);var S_IRWXUGO=511,S_IFMT=61440,S_IFSOCK=49152,S_IFLNK=40960,S_IFREG=32768,S_IFBLK=24576,S_IFDIR=16384,S_IFCHR=8192,O_RDONLY=0,O_WRONLY=1,O_RDWR=2,O_ACCMODE=3,STATUS_INVALID=-1,STATUS_OK=0,STATUS_ON_STORAGE=2,STATUS_UNLINKED=4,STATUS_FORWARDING=5,JSONFS_VERSION=3,JSONFS_IDX_NAME=0,JSONFS_IDX_SIZE=1,JSONFS_IDX_MTIME=2,JSONFS_IDX_MODE=3,JSONFS_IDX_UID=4,JSONFS_IDX_GID=5,JSONFS_IDX_TARGET=6,JSONFS_IDX_SHA256=6; +function FS(a,b){this.inodes=[];this.events=[];this.storage=a;this.qidcounter=b||{last_qidnumber:0};this.inodedata={};this.total_size=274877906944;this.used_size=0;this.mounts=[];this.CreateDirectory("",-1)}FS.prototype.get_state=function(){let a=[];a[0]=this.inodes;a[1]=this.qidcounter.last_qidnumber;a[2]=[];for(const [b,c]of Object.entries(this.inodedata))0===(this.inodes[b].mode&S_IFDIR)&&a[2].push([b,c]);a[3]=this.total_size;a[4]=this.used_size;return a=a.concat(this.mounts)}; +FS.prototype.set_state=function(a){this.inodes=a[0].map(a=>{const b=new Inode(0);b.set_state(a);return b});this.qidcounter.last_qidnumber=a[1];this.inodedata={};for(let [b,c]of a[2])c.buffer.byteLength!==c.byteLength&&(c=c.slice()),this.inodedata[b]=c;this.total_size=a[3];this.used_size=a[4];this.mounts=a.slice(5)}; +FS.prototype.AddEvent=function(a,b){var c=this.inodes[a];c.status==STATUS_OK||c.status==STATUS_ON_STORAGE?b():this.is_forwarder(c)?this.follow_fs(c).AddEvent(c.foreign_id,b):this.events.push({id:a,OnEvent:b})};FS.prototype.HandleEvent=function(a){var b=this.inodes[a];this.is_forwarder(b)&&this.follow_fs(b).HandleEvent(b.foreign_id);b=[];for(var c=0;c>8;this.qid.version=a[11];this.qid.path=a[12];this.nlinks=a[13]}; +FS.prototype.divert=function(a,b){const c=this.Search(a,b),d=this.inodes[c],e=new Inode(-1);dbg_assert(d,"Filesystem divert: name ("+b+") not found");dbg_assert(this.IsDirectory(c)||1>=d.nlinks,"Filesystem: can't divert hardlinked file '"+b+"' with nlinks="+d.nlinks);Object.assign(e,d);const f=this.inodes.length;this.inodes.push(e);e.fid=f;this.is_forwarder(d)&&this.mounts[d.mount_id].backtrack.set(d.foreign_id,f);this.should_be_linked(d)&&(this.unlink_from_dir(a,b),this.link_under_dir(a,f,b));if(this.IsDirectory(c)&& +!this.is_forwarder(d))for(const [a,b]of e.direntries)"."!==a&&".."!==a&&this.IsDirectory(b)&&this.inodes[b].direntries.set("..",f);this.inodedata[f]=this.inodedata[c];delete this.inodedata[c];d.direntries=new Map;d.nlinks=0;return f};FS.prototype.copy_inode=function(a,b){Object.assign(b,a,{fid:b.fid,direntries:b.direntries,nlinks:b.nlinks})};FS.prototype.CreateInode=function(){const a=Math.round(Date.now()/1E3),b=new Inode(++this.qidcounter.last_qidnumber);b.atime=b.ctime=b.mtime=a;return b}; +FS.prototype.CreateDirectory=function(a,b){var c=this.inodes[b];if(0<=b&&this.is_forwarder(c))return b=c.foreign_id,a=this.follow_fs(c).CreateDirectory(a,b),this.create_forwarder(c.mount_id,a);c=this.CreateInode();c.mode=511|S_IFDIR;0<=b&&(c.uid=this.inodes[b].uid,c.gid=this.inodes[b].gid,c.mode=this.inodes[b].mode&511|S_IFDIR);c.qid.type=S_IFDIR>>8;this.PushInode(c,b,a);this.NotifyListeners(this.inodes.length-1,"newdir");return this.inodes.length-1}; +FS.prototype.CreateFile=function(a,b){var c=this.inodes[b];if(this.is_forwarder(c))return b=c.foreign_id,a=this.follow_fs(c).CreateFile(a,b),this.create_forwarder(c.mount_id,a);c=this.CreateInode();c.uid=this.inodes[b].uid;c.gid=this.inodes[b].gid;c.qid.type=S_IFREG>>8;c.mode=this.inodes[b].mode&438|S_IFREG;this.PushInode(c,b,a);this.NotifyListeners(this.inodes.length-1,"newfile");return this.inodes.length-1}; +FS.prototype.CreateNode=function(a,b,c,d){var e=this.inodes[b];if(this.is_forwarder(e))return b=e.foreign_id,a=this.follow_fs(e).CreateNode(a,b,c,d),this.create_forwarder(e.mount_id,a);e=this.CreateInode();e.major=c;e.minor=d;e.uid=this.inodes[b].uid;e.gid=this.inodes[b].gid;e.qid.type=S_IFSOCK>>8;e.mode=this.inodes[b].mode&438;this.PushInode(e,b,a);return this.inodes.length-1}; +FS.prototype.CreateSymlink=function(a,b,c){var d=this.inodes[b];if(this.is_forwarder(d))return b=d.foreign_id,a=this.follow_fs(d).CreateSymlink(a,b,c),this.create_forwarder(d.mount_id,a);d=this.CreateInode();d.uid=this.inodes[b].uid;d.gid=this.inodes[b].gid;d.qid.type=S_IFLNK>>8;d.symlink=c;d.mode=S_IFLNK;this.PushInode(d,b,a);return this.inodes.length-1}; +FS.prototype.CreateTextFile=async function(a,b,c){var d=this.inodes[b];if(this.is_forwarder(d))return b=d.foreign_id,c=await this.follow_fs(d).CreateTextFile(a,b,c),this.create_forwarder(d.mount_id,c);d=this.CreateFile(a,b);b=this.inodes[d];a=new Uint8Array(c.length);b.size=c.length;for(b=0;bk)return k}var g=this.inodes[e],l=this.inodes[a];k=this.inodes[c];if(this.is_forwarder(l)||this.is_forwarder(k))if(this.is_forwarder(l)&&l.mount_id===k.mount_id){if(a=await this.follow_fs(l).Rename(l.foreign_id,b,k.foreign_id,d),0>a)return a}else{if(this.is_a_root(e))return dbg_log("XXX: Attempted to move mountpoint ("+ +b+") - skipped",LOG_9P),-EPERM;if(!this.IsDirectory(e)&&1k)return k;await this.DeleteData(l);a=this.Unlink(a,b);if(0>a)return a}}else this.unlink_from_dir(a,b),this.link_under_dir(c,e,d),g.qid.version++;this.NotifyListeners(e,"rename",{oldpath:f});return 0}; +FS.prototype.Write=async function(a,b,c,d){this.NotifyListeners(a,"write");var e=this.inodes[a];if(this.is_forwarder(e))a=e.foreign_id,await this.follow_fs(e).Write(a,b,c,d);else{var f=await this.get_buffer(a);!f||f.lengthb.nlinks&&message.Debug("Error in filesystem: negative nlinks="+b.nlinks+" at id ="+a);if(this.IsDirectory(a)){b=this.GetInode(a);this.IsDirectory(a)&&0>this.GetParent(a)&&message.Debug("Error in filesystem: negative parent id "+a);for(const [a,d]of b.direntries){0===a.length&&message.Debug("Error in filesystem: inode with no name and id "+d);for(const b of a)32>b&& +message.Debug("Error in filesystem: Unallowed char in filename")}}}};FS.prototype.FillDirectory=function(a){var b=this.inodes[a];if(this.is_forwarder(b))this.follow_fs(b).FillDirectory(b.foreign_id);else{var c=0;for(const a of b.direntries.keys())c+=24+UTF8.UTF8Length(a);a=this.inodedata[a]=new Uint8Array(c);b.size=c;c=0;for(const [d,e]of b.direntries)b=this.GetInode(e),c+=marshall.Marshall(["Q","d","b","s"],[b.qid,c+13+8+1+2+UTF8.UTF8Length(d),b.mode>>12,d],a,c)}}; +FS.prototype.RoundToDirentry=function(a,b){const c=this.inodedata[a];dbg_assert(c,`FS directory data for dirid=${a} should be generated`);dbg_assert(c.length,"FS directory should have at least an entry");if(b>=c.length)return c.length;for(a=0;;){const d=marshall.Unmarshall(["Q","d"],c,{offset:a})[1];if(d>b)break;a=d}return a};FS.prototype.IsDirectory=function(a){a=this.inodes[a];return this.is_forwarder(a)?this.follow_fs(a).IsDirectory(a.foreign_id):(a.mode&S_IFMT)===S_IFDIR}; +FS.prototype.IsEmpty=function(a){a=this.inodes[a];if(this.is_forwarder(a))return this.follow_fs(a).IsDirectory(a.foreign_id);for(const b of a.direntries.keys())if("."!==b&&".."!==b)return!1;return!0};FS.prototype.GetChildren=function(a){dbg_assert(this.IsDirectory(a),"Filesystem: cannot get children of non-directory inode");a=this.inodes[a];if(this.is_forwarder(a))return this.follow_fs(a).GetChildren(a.foreign_id);const b=[];for(const c of a.direntries.keys())"."!==c&&".."!==c&&b.push(c);return b}; +FS.prototype.GetParent=function(a){dbg_assert(this.IsDirectory(a),"Filesystem: cannot get parent of non-directory inode");a=this.inodes[a];if(this.should_be_linked(a))return a.direntries.get("..");{const b=this.follow_fs(a).GetParent(a.foreign_id);dbg_assert(-1!==b,"Filesystem: should not have invalid parent ids");return this.get_forwarder(a.mount_id,b)}}; +FS.prototype.PrepareCAPs=function(a){a=this.GetInode(a);if(a.caps)return a.caps.length;a.caps=new Uint8Array(20);a.caps[0]=0;a.caps[1]=0;a.caps[2]=0;a.caps[3]=2;a.caps[4]=255;a.caps[5]=255;a.caps[6]=255;a.caps[7]=255;a.caps[8]=255;a.caps[9]=255;a.caps[10]=255;a.caps[11]=255;a.caps[12]=63;a.caps[13]=0;a.caps[14]=0;a.caps[15]=0;a.caps[16]=63;a.caps[17]=0;a.caps[18]=0;a.caps[19]=0;return a.caps.length};function FSMountInfo(a){this.fs=a;this.backtrack=new Map} +FSMountInfo.prototype.get_state=function(){const a=[];a[0]=this.fs;a[1]=[...this.backtrack];return a};FSMountInfo.prototype.set_state=function(a){this.fs=a[0];this.backtrack=new Map(a[1])}; +FS.prototype.set_forwarder=function(a,b,c){const d=this.inodes[a];dbg_assert(0===d.nlinks,"Filesystem: attempted to convert an inode into forwarder before unlinking the inode");this.is_forwarder(d)&&this.mounts[d.mount_id].backtrack.delete(d.foreign_id);d.status=STATUS_FORWARDING;d.mount_id=b;d.foreign_id=c;this.mounts[b].backtrack.set(c,a)};FS.prototype.create_forwarder=function(a,b){const c=this.CreateInode(),d=this.inodes.length;this.inodes.push(c);c.fid=d;this.set_forwarder(d,a,b);return d}; +FS.prototype.is_forwarder=function(a){return a.status===STATUS_FORWARDING};FS.prototype.is_a_root=function(a){return 0===this.GetInode(a).fid};FS.prototype.get_forwarder=function(a,b){var c=this.mounts[a];dbg_assert(0<=b,"Filesystem get_forwarder: invalid foreign_id: "+b);dbg_assert(c,"Filesystem get_forwarder: invalid mount number: "+a);c=c.backtrack.get(b);return void 0===c?this.create_forwarder(a,b):c}; +FS.prototype.delete_forwarder=function(a){dbg_assert(this.is_forwarder(a),"Filesystem delete_forwarder: expected forwarder");a.status=STATUS_INVALID;this.mounts[a.mount_id].backtrack.delete(a.foreign_id)};FS.prototype.follow_fs=function(a){const b=this.mounts[a.mount_id];dbg_assert(this.is_forwarder(a),"Filesystem follow_fs: inode should be a forwarding inode");dbg_assert(b,"Filesystem follow_fs: inode should point to valid mounted FS");return b.fs}; +FS.prototype.Mount=function(a,b){dbg_assert(b.qidcounter===this.qidcounter,"Cannot mount filesystem whose qid numbers aren't synchronised with current filesystem.");var c=this.SearchPath(a);if(-1===c.parentid)return dbg_log("Mount failed: parent for path not found: "+a,LOG_9P),-ENOENT;if(-1!==c.id)return dbg_log("Mount failed: file already exists at path: "+a,LOG_9P),-EEXIST;if(c.forward_path)return a=this.inodes[c.parentid],c=this.follow_fs(a).Mount(c.forward_path,b),0>c?c:this.get_forwarder(a.mount_id, +c);a=this.mounts.length;this.mounts.push(new FSMountInfo(b));b=this.create_forwarder(a,0);this.link_under_dir(c.parentid,b,c.name);return b};function FSLockRegion(){this.type=P9_LOCK_TYPE_UNLCK;this.start=0;this.length=Infinity;this.proc_id=-1;this.client_id=""}FSLockRegion.prototype.get_state=function(){const a=[];a[0]=this.type;a[1]=this.start;a[2]=Infinity===this.length?0:this.length;a[3]=this.proc_id;a[4]=this.client_id;return a}; +FSLockRegion.prototype.set_state=function(a){this.type=a[0];this.start=a[1];this.length=0===a[2]?Infinity:a[2];this.proc_id=a[3];this.client_id=a[4]};FSLockRegion.prototype.clone=function(){const a=new FSLockRegion;a.set_state(this.get_state());return a}; +FSLockRegion.prototype.conflicts_with=function(a){return this.proc_id===a.proc_id&&this.client_id===a.client_id||this.type===P9_LOCK_TYPE_UNLCK||a.type===P9_LOCK_TYPE_UNLCK||this.type!==P9_LOCK_TYPE_WRLCK&&a.type!==P9_LOCK_TYPE_WRLCK||this.start+this.length<=a.start||a.start+a.length<=this.start?!1:!0};FSLockRegion.prototype.is_alike=function(a){return a.proc_id===this.proc_id&&a.client_id===this.client_id&&a.type===this.type}; +FSLockRegion.prototype.may_merge_after=function(a){return this.is_alike(a)&&a.start+a.length===this.start};FS.prototype.DescribeLock=function(a,b,c,d,e){dbg_assert(a===P9_LOCK_TYPE_RDLCK||a===P9_LOCK_TYPE_WRLCK||a===P9_LOCK_TYPE_UNLCK,"Filesystem: Invalid lock type: "+a);dbg_assert(0<=b,"Filesystem: Invalid negative lock starting offset: "+b);dbg_assert(0=f&&0=f&&(d.locks.splice(c,1),c--)}if(b.type!==P9_LOCK_TYPE_UNLCK){c=b;a=!1;for(e=0;e"."!==a&&".."!==a)};FS.prototype.read_file=function(a){a=this.SearchPath(a);if(-1===a.id)return Promise.resolve(null);const b=this.GetInode(a.id);return this.Read(a.id,0,b.size)};var VIRTIO_MAGIC_REG=0,VIRTIO_VERSION_REG=4,VIRTIO_DEVICE_REG=8,VIRTIO_VENDOR_REG=12,VIRTIO_HOSTFEATURES_REG=16,VIRTIO_HOSTFEATURESSEL_REG=20,VIRTIO_GUESTFEATURES_REG=32,VIRTIO_GUESTFEATURESSEL_REG=36,VIRTIO_GUEST_PAGE_SIZE_REG=40,VIRTIO_QUEUESEL_REG=48,VIRTIO_QUEUENUMMAX_REG=52,VIRTIO_QUEUENUM_REG=56,VIRTIO_QUEUEALIGN_REG=60,VIRTIO_QUEUEPFN_REG=64,VIRTIO_QUEUENOTIFY_REG=80,VIRTIO_INTERRUPTSTATUS_REG=96,VIRTIO_INTERRUPTACK_REG=100,VIRTIO_STATUS_REG=112,VRING_DESC_F_NEXT=1,VRING_DESC_F_WRITE=2,VRING_DESC_F_INDIRECT= +4;function hex8(a){return h(a)}var message={Debug:function(a){dbg_log([].slice.apply(arguments).join(" "),LOG_9P)},Abort:function(){if(DEBUG)throw Error("message.Abort()");}},LoadBinaryResource; +LoadBinaryResource="undefined"!==typeof XMLHttpRequest?function(a,b,c){var d=new XMLHttpRequest;d.open("GET",a,!0);d.responseType="arraybuffer";d.onreadystatechange=function(){if(4==d.readyState)if(200!=d.status&&0!=d.status)c("Error: Could not load file "+a);else{var e=d.response;e?b(e):c("Error: No data received from: "+a)}};d.send(null)}:function(a,b,c){require("fs").readFile(a,function(a,e){a?c(a):b(e.buffer)})};var marshall={Marshall:function(a,b,c,d){for(var e,f=0,k=0;k>8&255;c[d++]=e>>16&255;c[d++]=e>>24&255;f+=4;break;case "d":c[d++]=e&255;c[d++]=e>>8&255;c[d++]=e>>16&255;c[d++]=e>>24&255;c[d++]=0;c[d++]=0;c[d++]=0;c[d++]=0;f+=8;break;case "h":c[d++]=e&255;c[d++]=e>>8;f+=2;break;case "b":c[d++]=e;f+=1;break;case "s":var g=d,l=0;c[d++]=0;c[d++]=0;f+=2;for(var m of e)UnicodeToUTF8Stream(m.charCodeAt(0)).forEach(function(a){c[d++]=a;f+=1;l++}); +c[g+0]=l&255;c[g+1]=l>>8&255;break;case "Q":marshall.Marshall(["b","w","d"],[e.type,e.version,e.path],c,d);d+=13;f+=13;break;default:message.Debug("Marshall: Unknown type="+a[k])}return f},Unmarshall:function(a,b,c){let d=c.offset;for(var e=[],f=0;f>>0;e.push(k);break;case "d":k=b[d++];k+=b[d++]<<8;k+=b[d++]<<16;k+=b[d++]<<24>>>0;d+=4;e.push(k);break;case "h":k=b[d++];e.push(k+(b[d++]<<8));break;case "b":e.push(b[d++]); +break;case "s":k=b[d++];k+=b[d++]<<8;for(var g="",l=new UTF8StreamToUnicode,m=0;m>>0;c.push(e); +break;case "d":e=b();e+=b()<<8;e+=b()<<16;e+=b()<<24>>>0;b();b();b();b();c.push(e);break;case "h":e=b();c.push(e+(b()<<8));break;case "b":c.push(b());break;case "s":e=b();e+=b()<<8;for(var f="",k=new UTF8StreamToUnicode,g=0;g { + bus.register("net0-send", (data) => { + this.jsnet.send(data); + }); + this.jsnet.recvCallback = (data) => { + bus.send("net0-receive", data); + }; + return { + send: (data) => this.jsnet.send(data), + destroy: () => {} + }; + }, + screen_container: this.screenElement, + autostart: true, + }; + + this.emulator = new window.V86Starter(emulatorOptions); + + this.emulator.add_listener("emulator-ready", () => { + progress.close(); + this.isBooted = true; + }); + + // Forward download progress + this.emulator.add_listener("download-progress", (e) => { + if (e.lengthComputable) { + const percent = (e.loaded / e.total) * 100; + progress.update(percent); + } + }); + + } catch (err) { + console.error("Emulator failed to start", err); + progress.close(); + alert("Failed to start Internet Explorer emulator: " + err.message); + } + } + + _loadScript(url) { + return new Promise((resolve, reject) => { + const script = document.createElement("script"); + script.src = url; + script.onload = resolve; + script.onerror = reject; + document.head.appendChild(script); + }); + } + + destroy() { + if (this.emulator) { + this.emulator.destroy(); + this.emulator = null; + } + if (this.jsnet && this.jsnet.netWorker) { + this.jsnet.netWorker.terminate(); + } + } + + navigateTo(url) { + if (this.jsnet && this.jsnet.netWorker) { + this.jsnet.netWorker.postMessage({ replayUrl: url }); + } + } +} diff --git a/src/shared/components/progress-dialog.js b/src/shared/components/progress-dialog.js new file mode 100644 index 00000000..2a21a7da --- /dev/null +++ b/src/shared/components/progress-dialog.js @@ -0,0 +1,74 @@ +import { ShowDialogWindow } from "./dialog-window.js"; + +/** + * Creates and shows a progress dialog window. + * @param {object} options + * @param {string} options.title - The title of the dialog. + * @param {string} options.text - The label for the progress bar. + * @returns {object} An object with an `update(percent)` method and `close()` method. + */ +export function ShowProgressDialog(options) { + const { title, text } = options; + + const content = document.createElement("div"); + content.className = "progress-dialog-container"; + content.style.padding = "10px"; + + const label = document.createElement("div"); + label.className = "progress-dialog-label"; + label.textContent = text; + label.style.marginBottom = "10px"; + content.appendChild(label); + + const progressContainer = document.createElement("div"); + progressContainer.className = "progress-bar-container sunken-panel"; + progressContainer.style.height = "20px"; + progressContainer.style.width = "100%"; + progressContainer.style.backgroundColor = "var(--Window)"; + progressContainer.style.position = "relative"; + content.appendChild(progressContainer); + + const progressBar = document.createElement("div"); + progressBar.className = "progress-bar-fill"; + progressBar.style.height = "100%"; + progressBar.style.width = "0%"; + progressBar.style.backgroundColor = "var(--ActiveTitle)"; + progressContainer.appendChild(progressBar); + + const percentText = document.createElement("div"); + percentText.className = "progress-percent-text"; + percentText.style.position = "absolute"; + percentText.style.width = "100%"; + percentText.style.textAlign = "center"; + percentText.style.top = "0"; + percentText.style.left = "0"; + percentText.style.lineHeight = "20px"; + percentText.style.color = "var(--WindowText)"; + percentText.style.mixBlendMode = "difference"; + percentText.textContent = "0%"; + progressContainer.appendChild(percentText); + + const win = ShowDialogWindow({ + title, + content, + modal: true, + buttons: [], // No buttons for this loading dialog + }); + + return { + update: (percent) => { + const p = Math.min(100, Math.max(0, percent)); + progressBar.style.width = `${p}%`; + percentText.textContent = `${Math.round(p)}%`; + }, + close: () => { + win.close(); + }, + setTitle: (newTitle) => { + win.title(newTitle); + }, + setLabel: (newLabel) => { + label.textContent = newLabel; + } + }; +} diff --git a/src/shell/explorer/explorer-app.js b/src/shell/explorer/explorer-app.js index a264e342..c0ca6a9a 100644 --- a/src/shell/explorer/explorer-app.js +++ b/src/shell/explorer/explorer-app.js @@ -34,6 +34,7 @@ import { DesktopExtension } from './extensions/desktop-extension.js'; import { RecycleBinExtension } from './extensions/recycle-bin-extension.js'; import { NetworkNeighborhoodExtension } from './extensions/network-neighborhood-extension.js'; import { InternetExplorerExtension } from './extensions/internet-explorer-extension.js'; +import { InternetExplorerEmulator } from '../../apps/internet-explorer/ie-emulator.js'; import { isZenFSPath, getZenFSFileUrl } from '../../system/zenfs-utils.js'; import { getMenuFromZenFS, FAVORITES_PATH } from '../start-menu/start-menu-utils.js'; import "./explorer.css"; @@ -98,6 +99,7 @@ export class ZenExplorerApp extends Application { this.retroMode = true; this.blobUrl = null; this.isInWebMode = false; + this.ieEmulator = null; this._favoritesCache = null; this._favoritesLoading = false; } @@ -604,15 +606,26 @@ export class ZenExplorerApp extends Application { async _updateMode() { const isWeb = this.isInWebMode; - const wasWeb = this.iframe.style.display === "block"; + const wasWeb = !!this.ieEmulator; if (isWeb) { - this.iframe.style.display = "block"; + this.iframe.style.display = "none"; // Using emulator instead of iframe this.iconContainer.style.display = "none"; this.sidebar.element.style.display = "none"; this.content.classList.remove("with-sidebar"); if (this.logo) this.logo.classList.remove("animate-only-busy"); + + if (!this.ieEmulator) { + this.ieEmulator = new InternetExplorerEmulator(this.content); + await this.ieEmulator.init(this.currentPath); + } else { + this.ieEmulator.navigateTo(this.currentPath); + } } else { + if (this.ieEmulator) { + this.ieEmulator.destroy(); + this.ieEmulator = null; + } this.iframe.style.display = "none"; this.iconContainer.style.display = ""; this.sidebar.element.style.display = "";