Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+benchmark/benchmark.image filter=lfs diff=lfs merge=lfs -text
+demo/mini.image filter=lfs diff=lfs merge=lfs -text
+demo/squeakjs.image filter=lfs diff=lfs merge=lfs -text
+headless/headless.image filter=lfs diff=lfs merge=lfs -text
+ws/client/cuis.image filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+node_modules/
+gh-pages
+dist/*.min.js*
+*.code-workspace

.gitpod.yml

@@ -0,0 +1,2 @@
+tasks:
+  - init: nvm install && npm install && npm run build

.nvmrc

@@ -0,0 +1 @@
+v22.14.0

.travis.yml

@@ -0,0 +1,21 @@
+language: node_js
+node_js:
+  - "6"
+before_install:
+  - export CHROME_URL=https://storage.googleapis.com/chromium-browser-snapshots/Linux_x64
+  - export CHROME_REV=$(curl -s ${CHROME_URL}/LAST_CHANGE)
+  - curl ${CHROME_URL}/${CHROME_REV}/chrome-linux.zip --create-dirs -o out/chrome-linux.zip
+  - unzip -q out/chrome-linux.zip -d out
+  - export CHROME_CANARY_BIN=$PWD/out/chrome-linux/chrome
+  - export DISPLAY=:99.0
+  - sh -e /etc/init.d/xvfb start
+install:
+  - cd tests
+  - npm install
+before_script:
+  - curl -f -s -L --retry 3 -o Squeak-5.1.tgz https://dl.bintray.com/squeakjs/testing/Squeak-5.1.tgz
+  - tar xzf Squeak-5.1.tgz -C ./resources
+script: npm test
+cache:
+  directories:
+  - tests/node_modules

LICENSE.md

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2013-2025 Vanessa Freudenberg
+Copyright (c) 2016 Fabio Niephaus, Google Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,10 +1,229 @@
----
-title: Scratch0 5
-emoji: 🦀
-colorFrom: blue
-colorTo: green
-sdk: static
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+SqueakJS: A Squeak VM for the Web and Node.js
+=============================================
+
+SqueakJS is a runtime engine for [Squeak][squeak]</a> Smalltalk written in pure JavaScript. It also works for many other OpenSmalltalk-compatible images.
+
+Embedding a Smalltalk application in your webpage can be as simple as:
+
+    SqueakJS.runSqueak(imageUrl);
+
+but you probably want to give it some more options (refer to the examples).
+
+The interpreter core is divided in a number of `vm.*.js` modules, internal plugins in `vm.plugins.*.js` modules and external plugins in the "plugins" directory. The Just-in-Time compiler is optional ("jit.js") and can be replaced with your own.
+
+There are a number of interfaces:
+* browser: the regular HTML interface lets you use SqueakJS on your own web page. Just include "squeak.js".
+* headless browser: a headless VM. It lets you use SqueakJS in your browser without a direct UI (you can create your own UI with a plugin). Include "squeak_headless.js" and add an "imageName" parameter to your website URL (eg. https://example.com/my/page.html?imageName=./example.image) or call the Javascript function "fetchImageAndRun('https://example.com/my/example.image')" to start the specified image.
+* Node.js: another headless VM. It lets you use SqueakJS as a Node.js application via "node squeak_node.js <image name>".
+
+For discussions, please use the [vm-dev mailing list][vm-dev]. Also, please visit the [project home page][homepage]!
+
+Running it
+----------
+**Simplest**
+
+* [Run a minimal image][mini]. This is the simple demo included in this repo.
+* Or run [Etoys][etoys]. Everything except the image and template files is in this repo.
+* Or similarly, [Scratch][scratch], also in here.
+
+**Run your own Squeak image in the browser**
+
+* Drag an image from your local files into the [launcher][run].
+* ... and all the other demo pages (see above) accept dropped images, too.
+
+**Run your own Squeak image from the command line**
+
+* Install a recent version of Node.js
+* Run example image: `node squeak_node.js headless/headless.image`
+
+**Run an interactive shell based on WebSocket communication with Cuis image**
+
+* Install a recent version of Node.js
+* Go to [ws][ws] and execute `start_server.sh` in a first shell and `start_client.sh` in a second shell.
+* After initialization it should be possible to issue Smalltalk statements which will be executed in the Smalltalk image.
+* Try commands like: `Object allSubclasses size` `1837468731248764723 * 321653125376153761` `Collection allSubclasses collect: [ :c | c name ]`
+
+**Which Browser**
+
+All modern desktop browsers should work. Mobile browsers work too, but most Squeak images assume a keyboard and mouse. YMMV.
+
+Fixes to improve browser compatibility are highly welcome!
+
+If your browser does not support ES6 modules try the full or headless SqueakJS VM as a single file (aka bundle) in the [Distribution][dist] directory.
+
+
+Installing locally
+------------------
+* clone the [github repo][repo]:
+  ```
+  git clone https://github.com/codefrau/SqueakJS.git
+  ```
+  or download and unpack the [ZIP archive][zip]
+* serve the SqueakJS directory using a local web server.
+
+  TIP: If you have Node.js, try
+  ```
+  cd SqueakJS
+  npx serve
+  ```
+  which will run a webserver on port 3000.
+* in a web browser, open http://localhost:3000/run/ and pick one of the images, or drag and drop your own
+
+Now Squeak should be running.
+The reason for having to run from a web server is because the image is loaded with an XMLHttpRequest which does not work with a file URL. Alternatively, you could just open SqueakJS/run/index.html and drop in a local image.
+
+Using (self contained) bundled files
+------------------------------------
+* select your preferred type of interface (browser or headless)
+* use the appropriate file (`squeak_bundle.js` resp. `squeak_headless_bundle.js`) from the [Distribution][dist] directory
+* you can also build minified bundles using `npm run build`
+
+How to modify it
+----------------
+* use any text editor
+* you have to reload the page for your changes to take effect
+
+How to share your changes
+-------------------------
+* easiest for me is if you create a [pull request][pullreq]
+* otherwise, send me patches
+
+Contributions are very welcome!
+
+Things to work on
+-----------------
+SqueakJS is intended to run any Squeak image. It can already load any image from the original 1996 Squeak release to the latest Cog-Spur release, including 64-bit and Sista variants. But various pieces (primitives in various plugins) are still missing, in particular 3D graphics and networking (however, see [Croquet][jasmine] which supports both, but should be generalized). Also, we should make pre-Spur 64 bit images load. And, it would be nice to make it work on as many browsers as possible, especially on mobile touch devices.
+
+As for optimizing the way to go is an optimizing JIT compiler. The current JIT is very simple and does not optimize at all, it only eloiminates the interpreter's instruction decoding overhead. Since we can't access or manipulate the JavaScript stack, we might want that compiler to inline as much as possible, but keep the call sequence flat so we can return to the browser at any time. Even better (but potentially more complicated) is actually using the JavaScript stack, just like Eliot's Stack VM uses the C stack. I have done some [advanced JIT mockups][jit]. To make BitBlt fast, we could probably use WASM or even WebGL.
+
+To make SqueakJS useful beyond running existing Squeak images, we should use the JavaScript bridge to write a native HTML UI which would certainly be much faster than BitBlt (Craig Latta has done some interesting work towards that in [Caffeine][caffeine]).
+
+Better Networking would be interesting, too. The SocketPlugin currently does allows HTTP(S) requests and WebSockets. How about implementing low level Socket support based on HTTP-tunneling? The VM can run in a WebWorker. How about parallelizing the VM with WebWorkers?
+
+Also interesting would be wrapping it in a native app, maybe via [Electron][electron] similar to [Sugarizer][sugarizer], which uses SqueakJS to run Etoys.
+
+There's a gazillion exciting things to do :)
+
+  --  Vanessa Freudenberg (codefrau)
+
+  [squeak]:   https://squeak.org/
+  [repo]:     https://github.com/codefrau/SqueakJS
+  [vm-dev]:   http://lists.squeakfoundation.org/mailman/listinfo/vm-dev
+  [homepage]: https://squeak.js.org/
+  [run]:      https://squeak.js.org/run/
+  [mini]:     https://squeak.js.org/demo/simple.html
+  [etoys]:    https://squeak.js.org/etoys/
+  [scratch]:  https://squeak.js.org/scratch/
+  [jasmine]:  https://github.com/codefrau/jasmine
+  [caffeine]: https://caffeine.js.org/
+  [jit]:      https://squeak.js.org/docs/jit.md.html
+  [ws]:       https://github.com/codefrau/SqueakJS/tree/main/ws
+  [dist]:     https://github.com/codefrau/SqueakJS/tree/main/dist
+  [zip]:      https://github.com/codefrau/SqueakJS/archive/main.zip
+  [pullreq]:  https://help.github.com/articles/using-pull-requests
+  [electron]: https://www.electronjs.org
+  [sugarizer]: https://github.com/llaske/sugarizer
+
+
+Changelog
+---------
+    2025-05-04: 1.3.3 minor FFI, OpenGL, and other fixes/improvements
+    2025-04-06: 1.3.2 use our own CORS proxy, add welcome=false option, minor fixes
+    2025-03-29: 1.3.1 add 'w', 'h', 'embedded' canvas options, minor fixes
+    2025-03-28: 1.3.0 add OpenGL support, canvas is optional, fix socket plugin bug
+    2025-02-19: 1.2.4 fix isAssociation for JS Bridge, optimize loading image with many objects
+    2024-09-28: 1.2.3 fix primitiveInputSemaphore, fix iOS keyboard
+    2024-06-22: 1.2.2 make copy/paste work on mobile
+    2024-05-27: 1.2.1 add virtual cmd button, fix touch events
+    2024-03-25: 1.2.0 add FFI and MIDI plugins, JIT for Sista bytecodes, JPEG write prim, fix keyboard input, copy/paste, scroll wheel, highdpi, allow ES6 in source
+    2023-11-24: 1.1.2 fixed BitBlt bug (symptom reported 9 years ago, thanks to Agustin Martinez for narrowing it down), add object pinning, support keyboard in ancient Scratch images
+    2023-10-24: 1.1.1 workarounds for Cuis 6
+    2023-10-23: 1.1.0 implement Etoys project saving (image segment export), drag-n-drop directories
+    2023-09-30: 1.0.6 fixes
+    2022-11-19: 1.0.5 fixes, add highdpi mode, add image format for Squeak 6
+    2021-05-31: 1.0.4 fixes
+    2021-03-21: 1.0.3 headless fixes (Erik Stel); fixes object-as-method
+    2021-02-07: 1.0.2 new one-way become prim (Christoph Tiede); JIT-compile Array at:/at:put:
+    2021-01-05: 1.0.1 fixes some primitives to properly pop the stack
+    2020-12-20: 1.0 supports 64 bits and Sista
+    2020-06-20: renamed "master" branch to "main"
+    2020-06-20: 0.9.9 JSBridge additions (Bill Burdick), fixes
+    2020-04-08: renamed github account to "codefrau"
+    2020-01-26: 0.9.8 split into modules (Erik Stel), fixes
+    2019-01-03: 0.9.7 minor fixes
+    2018-03-13: 0.9.6 minor fixes
+    2016-11-08: 0.9.5 more fixes
+    2016-10-20: 0.9.4 fixes
+    2016-09-08: 0.9.3 add partial GC (5x faster become / allInstances)
+    2016-08-25: 0.9.2 add keyboard on iOS
+    2016-08-03: 0.9.1 fixes
+    2016-07-29: 0.9 Spur support, stdout, SpeechPlugin, zipped images
+    2016-06-28: 0.8.3 add SocketPlugin for http/https connections
+    2016-04-07: 0.8.2 better touch handling, debugging, CORS, lint
+    2016-01-08: 0.8.1 windows keyboard fixes, 'new' operator fixed
+    2015-11-24: 0.8 minor fixes
+    2015-08-13: 0.7.9 make work on iOS again
+    2015-07-18: 0.7.8 fix keyboard
+    2015-06-09: 0.7.7 fix thisContext
+    2015-04-27: 0.7.6 revert JIT, minor fixes
+    2015-04-14: 0.7.5 JIT optimizations by HPI students (reverted in 0.7.6)
+    2015-02-18: 0.7.4 make pre-release image work
+    2015-01-30: 0.7.3 JSBridge: fix closure callbacks
+    2015-01-25: 0.7.2 JSBridge: add asJSObject
+    2014-12-22: 0.7.1 cursor shapes
+    2014-12-04: 0.7 support finalization of weak references
+    2014-11-28: 0.6.8 JSBridge with callbacks
+    2014-11-20: 0.6.7 implement JavaScriptPlugin
+    2014-11-18: 0.6.6 implement DropPlugin
+    2014-11-14: 0.6.5 add generated Balloon2D plugin
+    2014-11-06: 0.6.4 add generic run page
+    2014-10-28: 0.6.3 pass options via URL
+    2014-10-27: add JPEG plugin
+    2014-10-25: add template files
+    2014-10-23: 0.6.2 fixes
+    2014-10-21: 0.6.1 add image segment loading
+    2014-10-18: 0.6 move squeak.js out of lib dir
+    2014-10-13: 0.5.9 microphone support
+    2014-10-09: 0.5.8 fixes
+    2014-10-07: 0.5.7 even more plugins generated
+    2014-10-07: 0.5.6 add quitSqueak and onQuit
+    2014-10-07: 0.5.5 generated ScratchPlugin
+    2014-10-06: 0.5.4 replace BitBltPlugin by generated
+    2014-10-06: 0.5.3 SoundGenerationPlugin, Matrix2x3Plugin, FloatArrayPlugin
+    2014-10-05: ZipPlugin
+    2014-10-04: MiscPrimitivePlugin
+    2014-10-03: VMMakerJS generates LargeIntegersPlugin
+    2014-09-30: 0.5.2 more JIT
+    2014-09-28: 0.5.1 JIT fixes
+    2014-09-26: 0.5 add JIT compiler
+    2014-09-22: v8 optimizations
+    2014-09-20: 0.4.6 sound output support
+    2014-09-13: 0.4.5 clipboartd fixes
+    2014-09-12: 0.4.4 cut/copy/paste in stand-alone
+    2014-09-09: 0.4.3 some scratch prims
+    2014-09-09: 0.4.2 idle fixes
+    2014-09-05: 0.4.1 scratch fixes
+    2014-09-04: 0.4.0 runs scratch
+    2014-08-31: switch old/new primitives
+    2014-08-27: event-based input
+    2014-08-21: exception handling
+    2014-07-25: 0.3.3 fullscreen support
+    2014-07-18: 0.3.2 benchmarking (timfel)
+    2014-07-18: 0.3.1 deferred display
+    2014-07-16: 0.3.0 closure support
+    2014-07-14: 0.2.3 IE optimization (timfel)
+    2014-07-11: 0.2.2 drag-n-drop
+    2014-07-07: 0.2.1 fixes for IE11 (timfel)
+    2014-07-04: 0.2 runs Etoys
+    2014-06-27: Balloon2D (krono)
+    2014-06-03: stand-alone version
+    2014-05-29: 0.1 added version number
+    2014-05-27: WarpBlt
+    2014-05-07: image saving
+    2014-04-23: file support
+    2013-12-20: public release
+    2013-12-14: colored bitblt
+    2013-12-03: first pixels on screen
+    2013-11-29: GC
+    2013-11-22: runs 43 byte codes and 8 sends successfully
+    2013-11-07: initial commit

benchmark/benchmark.css

@@ -0,0 +1,36 @@
+body {
+    background-color: #eae6d1;
+    font-family: sans-serif;
+}
+canvas {
+    display: block;
+    margin-left: auto;
+    margin-right: auto;
+    cursor: default;
+}
+canvas.pixelated {
+    image-rendering: -moz-crisp-edges;
+    image-rendering: -webkit-optimize-contrast;
+    image-rendering: pixelated;
+    -ms-interpolation-mode: nearest-neighbor;
+}
+div#sqSpinner {
+    position: fixed;
+    margin: auto; top: 0; left: 0; bottom: 0; right: 0;
+    width: 100px;
+    height: 100px;
+    border-radius: 50px;
+    background: rgba(0, 0, 0, 0.3);
+    box-shadow: 0 0 5px 5px #F90;
+    display: none;
+    transform: rotate(30deg);
+}
+div#sqSpinner > div {
+    position: absolute;
+    top: 45px;
+    left: 5px;
+    width: 90px; 
+    height: 10px;
+    border-radius: 5px;
+    box-shadow: 0 0 5px 5px #F90;
+}

benchmark/benchmark.html

@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<html>
+<!--
+Copyright (c) 2013-2025 Vanessa Freudenberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-->
+<head>
+<title>SqueakJS Benchmarks</title>
+<link rel="stylesheet" href="benchmark.css">
+<script type="text/javascript" src="http://www.google.com/jsapi"></script>
+<script type="module" src="../squeak.js"></script>
+<script src="benchmark.js"></script>
+
+</head>
+<body>
+    <h1>SqueakJS Benchmarks</h1>
+    <p id="results">
+        This is Tim Felgentreff's page for <a href="../">SqueakJS</a> benchmarking.
+        Please wait until the runs are finished.
+    </p>
+    <canvas id="sqCanvas" width="800" height="600"></canvas>
+    <div id="sqSpinner"><div></div></div>
+</body>
+</html>

benchmark/benchmark.image

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f9252e14a52e916675451f46e3505d1f659e902e3f2defc9aa2993c2b1565d86
+size 650948

benchmark/benchmark.js

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2013-2025 Vanessa Freudenberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+window.stopVM = false;
+
+window.onload = function() {
+
+    // Wrap the file close primitive to stop after the benchmark
+    // output file has been written
+    var origFileClose = Squeak.Primitives.prototype.fileClose
+    Squeak.Primitives.prototype.fileClose = (function (file) {
+        var contents = Squeak.bytesAsString(new Uint8Array(file.contents.buffer));
+        var r = document.getElementById("results");
+        r.innerHTML = "Your machine: " + navigator.userAgent + "<br>" +
+            "Your results:<br>" + contents.replace(/\r/g, "<br>") + "<br>"
+        saveToLively(contents);
+        SqueakJS.quitSqueak();
+        return origFileClose.apply(this, arguments);
+    });
+
+    if (!Date.now) {
+        Date.now = function now() {
+            return new Date().getTime();
+        };
+    }
+
+    function saveToLively(contents) {
+        var address = (window.google &&
+            google.loader &&
+            google.loader.ClientLocation &&
+            google.loader.ClientLocation.address) || {city: "unknown city", country: "unknown country"};
+        contents = navigator.userAgent + "\n" +
+            address.city + "\n" +
+            address.country + "\n" +
+            Date.now() + "\n" +
+            Squeak.vmVersion + "\n" +
+            contents;
+        var oReq = new XMLHttpRequest();
+        oReq.open(
+            "get",
+            "http://www.lively-kernel.org/babelsberg/nodejs/SqueakJSServer/?benchmarkResults=" +
+                encodeURIComponent(contents),
+            true);
+        oReq.send();
+    };
+
+    SqueakJS.runSqueak('benchmark.image', sqCanvas, {
+        spinner: sqSpinner,
+        onQuit: function() {
+            sqCanvas.style.display = "none";
+        },
+    });
+};

demo/JSBridge.st

@@ -0,0 +1 @@
+Exception subclass: #JSException

demo/SimplePlugin.js

@@ -0,0 +1,61 @@
+/*
+ * SimplePlugin.js: Example for an external Squeak VM module
+ *
+ * primNavigatorInfo: anInteger
+ *     <primitive: 'primitiveNavigatorInfo' module: 'SimplePlugin'>
+ *     ^ self primitiveFailed
+ */
+ 
+function SimplePlugin() {
+    var interpreterProxy,
+        primHandler;
+
+    function setInterpreter(anInterpreterProxy) {
+        // Slang interface
+        interpreterProxy = anInterpreterProxy;
+        // PrimHandler methods for convenience
+        primHandler = interpreterProxy.vm.primHandler;
+        // success
+        return true;
+    };
+
+    function primitiveNavigatorInfo(argCount) {
+        if (argCount !== 1) return false; // fail
+        var which = interpreterProxy.stackIntegerValue(0);
+        if (interpreterProxy.failed()) return false; // fail
+        var result = getNavigatorInfo(which);
+        if (!result) return false; // fail
+        var resultObj = primHandler.makeStString(result);
+        interpreterProxy.popthenPush(1 + argCount, resultObj);
+        return true; // success
+    };
+
+    function getNavigatorInfo(index) {
+        switch (index) {
+            case 1: return navigator.userAgent;
+            case 2: return navigator.language;
+        }
+    };
+
+    // hide private functions
+    return {
+        setInterpreter: setInterpreter,
+        primitiveNavigatorInfo: primitiveNavigatorInfo,
+    }
+};
+
+// register plugin in global Squeak object
+window.addEventListener("load", function() {
+    Squeak.registerExternalModule('SimplePlugin', SimplePlugin());
+});
+
+/**********************************
+NOTE: the mini.image does not have compiler support for
+named primitives, yet. You need to declare it manually 
+using prim 117:
+
+primNavigatorInfo: anInteger
+    <primitive: 117>
+    #(SimplePlugin primitiveNavigatorInfo 0 0) at: 1.
+    ^ self primitiveFailed
+***********************************/

demo/index.html

@@ -0,0 +1,46 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>SqueakJS</title>
+<!--
+Copyright (c) 2013-2025 Vanessa Freudenberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-->
+<link rel="icon" type="image/png" href="icon.png">
+<link rel="apple-touch-icon" href="icon.png" sizes="152x152">
+<meta name="viewport" content="minimum-scale=1,maximum-scale=1,width=device-width">
+<meta name="apple-mobile-web-app-capable" content="yes">
+<meta name="msapplication-TileImage" content="icon.png">
+
+<link rel="stylesheet" href="../lib/addtohomescreen.css">
+<script src="../lib/addtohomescreen.js"></script>
+
+<link rel="stylesheet" href="simple.css">
+<script type="module" src="../squeak.js"></script>
+<script src="simple.js"></script>
+<script src="SimplePlugin.js"></script>
+
+</head>
+<body>
+    <canvas id="sqCanvas"></canvas>
+    <div id="sqSpinner"><div></div></div>
+</body>
+</html>

demo/mini.image

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec22448856129313ceac51968edabf25fe6819f33812bd8f2943a60bc292c9ea
+size 624444

demo/simple.css

@@ -0,0 +1,38 @@
+body {
+    background-color: #333;
+    font-family: sans-serif;
+}
+canvas {
+    position: fixed;
+    background: #000;
+    cursor: default;
+    user-select: none;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+}
+canvas.pixelated {
+    image-rendering: -moz-crisp-edges;
+    image-rendering: -webkit-optimize-contrast;
+    image-rendering: pixelated;
+    -ms-interpolation-mode: nearest-neighbor;
+}
+div#sqSpinner {
+    position: fixed;
+    margin: auto; top: 0; left: 0; bottom: 0; right: 0;
+    width: 100px;
+    height: 100px;
+    border-radius: 50px;
+    background: rgba(0, 0, 0, 0.3);
+    box-shadow: 0 0 5px 5px #F90;
+    display: none;
+    transform: rotate(30deg);
+}
+div#sqSpinner > div {
+    position: absolute;
+    top: 45px;
+    left: 5px;
+    width: 90px;
+    height: 10px;
+    border-radius: 5px;
+    box-shadow: 0 0 5px 5px #F90;
+}

demo/simple.html

@@ -0,0 +1,46 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>SqueakJS</title>
+<!--
+Copyright (c) 2013-2025 Vanessa Freudenberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-->
+<link rel="icon" type="image/png" href="icon.png">
+<link rel="apple-touch-icon" href="icon.png" sizes="152x152">
+<meta name="viewport" content="minimum-scale=1,maximum-scale=1,width=device-width">
+<meta name="apple-mobile-web-app-capable" content="yes">
+<meta name="msapplication-TileImage" content="icon.png">
+
+<link rel="stylesheet" href="../lib/addtohomescreen.css">
+<script src="../lib/addtohomescreen.js"></script>
+
+<link rel="stylesheet" href="simple.css">
+<script type="module" src="../squeak.js"></script>
+<script src="simple.js"></script>
+<script src="SimplePlugin.js"></script>
+
+</head>
+<body>
+    <canvas id="sqCanvas"></canvas>
+    <div id="sqSpinner"><div></div></div>
+</body>
+</html>

demo/simple.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2013-2025 Vanessa Freudenberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+
+window.onload = function() {
+    SqueakJS.runSqueak('squeakjs.image', sqCanvas, {
+        appName: "SqueakJS",
+        files: ['squeakjs.image', 'squeakjs.changes'],
+        spinner: sqSpinner,
+    });
+};
+
+if (!addToHomescreen.isStandalone) addToHomescreen({
+    appID: 'squeakjs.demo.add2home',
+});

demo/squeakjs.image

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec22448856129313ceac51968edabf25fe6819f33812bd8f2943a60bc292c9ea
+size 624444

etoys/etoys.css

@@ -0,0 +1,38 @@
+body {
+    background-color: #333;
+    font-family: sans-serif;
+}
+canvas {
+    position: fixed;
+    background: #000;
+    cursor: default;
+    user-select: none;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+}
+canvas.pixelated {
+    image-rendering: -moz-crisp-edges;
+    image-rendering: -webkit-optimize-contrast;
+    image-rendering: pixelated;
+    -ms-interpolation-mode: nearest-neighbor;
+}
+div#sqSpinner {
+    position: fixed;
+    margin: auto; top: 0; left: 0; bottom: 0; right: 0;
+    width: 100px;
+    height: 100px;
+    border-radius: 50px;
+    background: rgba(0, 0, 0, 0.3);
+    box-shadow: 0 0 5px 5px #F90;
+    display: none;
+    transform: rotate(30deg);
+}
+div#sqSpinner > div {
+    position: absolute;
+    top: 45px;
+    left: 5px;
+    width: 90px;
+    height: 10px;
+    border-radius: 5px;
+    box-shadow: 0 0 5px 5px #F90;
+}

etoys/etoys.js

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2013-2025 Vanessa Freudenberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+
+window.onload = function() {
+    var url = "https://freudenbergs.de/vanessa/squeakjs/etoys.image";
+    SqueakJS.runSqueak(url, sqCanvas, {
+        appName: "Etoys",
+        fixedWidth: 1200,
+        fixedHeight: 900,
+        spinner: sqSpinner,
+        files: ["Etoys/EtoysV5.stc"],
+        root: "/Etoys",
+        templates: { "/Etoys": "Etoys" },
+        onStart: function(vm, display, options) {
+            // debugger
+            // vm.breakOn("Latin1Environment class>>systemConverterClass");
+        },
+    });
+};
+
+if (!addToHomescreen.isStandalone) addToHomescreen({
+    appID: 'squeakjs.etoys.add2home',
+});

etoys/index.html

@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>EtoysJS</title>
+<!--
+Copyright (c) 2013-2025 Vanessa Freudenberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-->
+<link rel="icon" type="image/png" href="etoys.png">
+<link rel="apple-touch-icon" href="etoys.png" sizes="152x152">
+<meta name="viewport" content="minimum-scale=1,maximum-scale=1,width=device-width">
+<meta name="apple-mobile-web-app-capable" content="yes">
+<meta name="msapplication-TileImage" content="etoys.png">
+
+<link rel="stylesheet" href="../lib/addtohomescreen.css">
+<script src="../lib/addtohomescreen.js"></script>
+
+<link rel="stylesheet" href="etoys.css">
+<script type="module" src="../squeak.js"></script>
+<script src="etoys.js"></script>
+
+</head>
+<body>
+    <canvas id="sqCanvas" width="1200" height="900"></canvas>
+    <div id="sqSpinner"><div></div></div>
+</body>
+</html>

ffi/libc.js

@@ -0,0 +1,71 @@
+"use strict";
+/*
+ * Copyright (c) 2013-2025 Vanessa Freudenberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// This is a minimal libc module for SqueakJS
+// serving mostly as a demo for FFI
+
+function libc() {
+    return {
+        // LIBC module
+        getModuleName() { return "libc (SqueakJS)"; },
+        setInterpreter(proxy) { this.vm = proxy.vm; return true; },
+
+        // helper functions
+        bytesToString(bytes) {
+            const zero = bytes.indexOf(0);
+            if (zero >= 0) bytes = bytes.subarray(0, zero);
+            return String.fromCharCode.apply(null, bytes);
+        },
+        stringToBytes(string, bytes) {
+            for (let i = 0; i < string.length; i++) bytes[i] = string.charCodeAt(i);
+            bytes[string.length] = 0;
+            return bytes;
+        },
+
+        // LIBC emulation functions called via FFI
+        getenv(v) {
+            v = this.bytesToString(v);
+            switch (v) {
+                case "USER": return this.vm.options.user || "squeak";
+                case "HOME": return this.vm.options.root || "/";
+            }
+            this.vm.warnOnce("UNIMPLEMENTED getenv: " + v);
+            return null;
+        },
+        getcwd(buf, size) {
+            const cwd = this.vm.options.root || "/";
+            if (!buf) buf = new Uint8Array(cwd.length + 1);
+            if (size < cwd.length + 1) return 0; // should set errno to ERANGE
+            this.stringToBytes(cwd, buf);
+            return buf; // converted to Smalltalk String by FFI if declared as char*
+        },
+    };
+}
+
+function registerLibC() {
+    if (typeof Squeak === "object" && Squeak.registerExternalModule) {
+        Squeak.registerExternalModule('libc', libc());
+    } else self.setTimeout(registerLibC, 100);
+};
+
+registerLibC();

globals.js

@@ -0,0 +1,90 @@
+"use strict";
+/*
+ * Copyright (c) 2013-2025 Vanessa Freudenberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// Create Squeak VM namespace
+if (!self.Squeak) self.Squeak = {};
+
+// Setup a storage for settings
+if (!Squeak.Settings) {
+    // Try (a working) localStorage and fall back to regular dictionary otherwise
+    var settings;
+    try {
+        // fails in restricted iframe
+        settings = self.localStorage;
+        settings["squeak-foo:"] = "bar";
+        if (settings["squeak-foo:"] !== "bar") throw Error();
+        delete settings["squeak-foo:"];
+    } catch(e) {
+        settings = {};
+    }
+    Squeak.Settings = settings;
+}
+
+if (!Object.extend) {
+    // Extend object by adding specified properties
+    Object.extend = function(obj /* + more args */ ) {
+        // skip arg 0, copy properties of other args to obj
+        for (var i = 1; i < arguments.length; i++)
+            if (typeof arguments[i] == 'object')
+                for (var name in arguments[i])
+                    obj[name] = arguments[i][name];
+    };
+}
+
+
+// This mimics the Lively Kernel's subclassing scheme.
+// When running there, Lively's subclasses and modules are used.
+// Modules serve as namespaces in Lively. SqueakJS uses a flat namespace
+// named "Squeak", but the code below still supports hierarchical names.
+if (!Function.prototype.subclass) {
+    // Create subclass using specified class path and given properties
+    Function.prototype.subclass = function(classPath /* + more args */ ) {
+        // create subclass
+        var subclass = function() {
+            if (this.initialize) {
+                var result = this.initialize.apply(this, arguments);
+                if (result !== undefined) return result;
+            }
+            return this;
+        };
+        // set up prototype
+        var protoclass = function() { };
+        protoclass.prototype = this.prototype;
+        subclass.prototype = new protoclass();
+        // skip arg 0, copy properties of other args to prototype
+        for (var i = 1; i < arguments.length; i++)
+            Object.extend(subclass.prototype, arguments[i]);
+        // add class to namespace
+        var path = classPath.split("."),
+            className = path.pop(),
+            // Walk path starting at the global namespace (self)
+            // creating intermediate namespaces if necessary
+            namespace = path.reduce(function(namespace, path) {
+                if (!namespace[path]) namespace[path] = {};
+                return namespace[path];
+            }, self);
+        namespace[className] = subclass;
+        return subclass;
+    };
+
+}

headless/headless.image

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:29621e0880d7cef148d17065934aca4ea993cb936ed51f98827d3bb97b18025c
+size 135472

headless/index.html

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+<head>
+	<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+	<!-- For browser that do support ES6 modules for WebWorkers -->
+<!--
+	<script type="module">
+		new Worker("../squeak_headless.js?imageName=../headless/headless.image", { type: "module" });
+	</script>
+-->
+	<!-- For browsers without support for ES6 modules for WebWorkers use bundled JS file -->
+	<script>
+		console.log("Starting SqueakJS in a WebWorker...");
+		new Worker("../dist/squeak_headless_bundle.js?imageName=../headless/headless.image");
+	</script>
+</head>
+<body>
+	Please open the developer console to see the console messages produced by the Smalltalk image.
+</body>
+</html>

jit.js

@@ -0,0 +1,1169 @@
+"use strict";
+/*
+ * Copyright (c) 2014-2025 Vanessa Freudenberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+Object.subclass('Squeak.Compiler',
+
+/****************************************************************************
+
+VM and Compiler
+===============
+
+The VM has an interpreter, it will work fine (and much more memory-efficient)
+without loading a compiler. The compiler plugs into the VM by providing the
+Squeak.Compiler global. It can be easily replaced by just loading a different
+script providing Squeak.Compiler.
+
+The VM creates the compiler instance after an image has been loaded and the VM
+been initialized. Whenever a method is activated that was not compiled yet, the
+compiler gets a chance to compile it. The compiler may decide to wait for a couple
+of activations before actually compiling it. This might prevent do-its from ever
+getting compiled, because they are only activated once. Therefore, the compiler
+is also called when a long-running non-optimized loop calls checkForInterrupts.
+Finally, whenever the interpreter is about to execute a bytecode, it calls the
+compiled method instead (which typically will execute many bytecodes):
+
+    initialize:
+        compiler = new Squeak.Compiler(vm);
+
+    executeNewMethod, checkForInterrupts:
+        if (!method.compiled && compiler)
+            compiler.compile(method);
+
+    interpret:
+        if (method.compiled) method.compiled(vm);
+
+Note that a compiler could hook itself into a compiled method by dispatching
+to vm.compiler in the generated code. This would allow gathering statistics,
+recompiling with optimized code etc.
+
+
+About This Compiler
+===================
+
+The compiler in this file is meant to be simple, fast-compiling, and general.
+It transcribes bytecodes 1-to-1 into equivalent JavaScript code using
+templates (and thus can even support single-stepping). It uses the
+interpreter's stack pointer (SP) and program counter (PC), actual context
+objects just like the interpreter, no register mapping, it does not optimize
+sends, etc.
+
+Jumps are handled by wrapping the whole method in a loop and switch. This also
+enables continuing in the middle of a compiled method: whenever another context
+is activated, the method returns to the main loop, and is entered again later
+with a different PC. Here is an example method, its bytecodes, and a simplified
+version of the generated JavaScript code:
+
+    method
+        [value selector] whileFalse.
+        ^ 42
+
+    0 <00> pushInstVar: 0
+    1 <D0> send: #selector
+    2 <A8 02> jumpIfTrue: 6
+    4 <A3 FA> jumpTo: 0
+    6 <21> pushConst: 42
+    7 <7C> return: topOfStack
+
+    context = vm.activeContext
+    while (true) switch (vm.pc) {
+    case 0:
+        stack[++vm.sp] = inst[0];
+        vm.pc = 2; vm.send(#selector); // activate new method
+        return; // return to main loop
+        // Main loop will execute the activated method. When
+        // that method returns, this method will be called
+        // again with vm.pc == 2 and jump directly to case 2
+    case 2:
+        if (stack[vm.sp--] === vm.trueObj) {
+            vm.pc = 6;
+            continue; // jump to case 6
+        }
+        // otherwise fall through to next case
+    case 4:
+        vm.pc = 0;
+        continue; // jump to case 0
+    case 6:
+        stack[++vm.sp] = 42;
+        vm.pc = 7; vm.doReturn(stack[vm.sp]);
+        return;
+    }
+
+Debugging support
+=================
+
+This compiler supports generating single-stepping code and comments, which are
+rather helpful during debugging.
+
+Normally, only bytecodes that can be a jump target are given a label. Also,
+bytecodes following a send operation need a label, to enable returning to that
+spot after the context switch. All other bytecodes are executed continuously.
+
+When compiling for single-stepping, each bytecode gets a label, and after each
+bytecode a flag is checked and the method returns if needed. Because this is
+a performance penalty, methods are first compiled without single-step support,
+and recompiled for single-stepping on demand.
+
+This is optional, another compiler can answer false from enableSingleStepping().
+In that case the VM will delete the compiled method and invoke the interpreter
+to single-step.
+
+*****************************************************************************/
+
+'initialization', {
+    initialize: function(vm) {
+        this.vm = vm;
+        this.comments = !!Squeak.Compiler.comments, // generate comments
+        // for debug-printing only
+        this.specialSelectors = ['+', '-', '<', '>', '<=', '>=', '=', '~=', '*', '/', '\\\\', '@',
+            'bitShift:', '//', 'bitAnd:', 'bitOr:', 'at:', 'at:put:', 'size', 'next', 'nextPut:',
+            'atEnd', '==', 'class', 'blockCopy:', 'value', 'value:', 'do:', 'new', 'new:', 'x', 'y'];
+        this.doitCounter = 0;
+        this.blockCounter = 0;
+    },
+},
+'accessing', {
+    compile: function(method, optClassObj, optSelObj) {
+        if (method.compiled === undefined) {
+            // 1st time
+            method.compiled = false;
+        } else {
+            // 2nd time
+            this.singleStep = false;
+            this.debug = this.comments;
+            var clsName, sel, instVars;
+            if (this.debug && !optClassObj) {
+                // this is expensive, so only do it when debugging
+                var isMethod = method.sqClass === this.vm.specialObjects[Squeak.splOb_ClassCompiledMethod];
+                this.vm.allMethodsDo(function(classObj, methodObj, selectorObj) {
+                    if (isMethod ? methodObj === method : methodObj.pointers.includes(method)) {
+                        optClassObj = classObj;
+                        optSelObj = selectorObj;
+                        return true;
+                    }
+                });
+            }
+            if (optClassObj) {
+                clsName = optClassObj.className();
+                sel = optSelObj.bytesAsString();
+                if (this.debug) {
+                    // only when debugging
+                    var isMethod = method.sqClass === this.vm.specialObjects[Squeak.splOb_ClassCompiledMethod];
+                    if (!isMethod) {
+                        clsName = "[] in " + clsName;
+                    }
+                    instVars = optClassObj.allInstVarNames();
+                }
+            }
+            method.compiled = this.generate(method, clsName, sel, instVars);
+        }
+    },
+    enableSingleStepping: function(method, optClass, optSel) {
+        // recompile method for single-stepping
+        if (!method.compiled || !method.compiled.canSingleStep) {
+            this.singleStep = true; // generate breakpoint support
+            this.debug = true;
+            if (!optClass) {
+                this.vm.allMethodsDo(function(classObj, methodObj, selectorObj) {
+                    if (methodObj === method) {
+                        optClass = classObj;
+                        optSel = selectorObj;
+                        return true;
+                    }
+                });
+            }
+            var cls = optClass && optClass.className();
+            var sel = optSel && optSel.bytesAsString();
+            var instVars = optClass && optClass.allInstVarNames();
+            method.compiled = this.generate(method, cls, sel, instVars);
+            method.compiled.canSingleStep = true;
+        }
+        // if a compiler does not support single-stepping, return false
+        return true;
+    },
+    functionNameFor: function(cls, sel) {
+        if (cls === undefined || cls === '?') {
+            var isMethod = this.method.sqClass === this.vm.specialObjects[Squeak.splOb_ClassCompiledMethod];
+            return isMethod ? "DOIT_" + ++this.doitCounter : "BLOCK_" + ++this.blockCounter;
+        }
+        cls = cls.replace(/ /g, "_").replace("[]", "Block");
+        if (!/[^a-zA-Z0-9:_]/.test(sel))
+            return cls + "_" + sel.replace(/:/g, "ː"); // unicode colon is valid in JS identifiers
+        var op = sel.replace(/./g, function(char) {
+            var repl = {'|': "OR", '~': "NOT", '<': "LT", '=': "EQ", '>': "GT",
+                    '&': "AND", '@': "AT", '*': "TIMES", '+': "PLUS", '\\': "MOD",
+                    '-': "MINUS", ',': "COMMA", '/': "DIV", '?': "IF"}[char];
+            return repl || 'OPERATOR';
+        });
+        return cls + "__" + op + "__";
+    },
+},
+'generating', {
+    generate: function(method, optClass, optSel, optInstVarNames) {
+        this.method = method;
+        this.sista = method.methodSignFlag();
+        this.pc = 0;                // next bytecode
+        this.endPC = 0;             // pc of furthest jump target
+        this.prevPC = 0;            // pc at start of current instruction
+        this.source = [];           // snippets will be joined in the end
+        this.sourceLabels = {};     // source pos of generated jump labels
+        this.needsLabel = {};       // jump targets
+        this.sourcePos = {};        // source pos of optional vars / statements
+        this.needsVar = {};         // true if var was used
+        this.needsBreak = false;    // insert break check for previous bytecode
+        if (optClass && optSel)
+            this.source.push("// ", optClass, ">>", optSel, "\n");
+        this.instVarNames = optInstVarNames;
+        this.allVars = ['context', 'stack', 'rcvr', 'inst[', 'temp[', 'lit['];
+        this.sourcePos['context']    = this.source.length; this.source.push("var context = vm.activeContext;\n");
+        this.sourcePos['stack']      = this.source.length; this.source.push("var stack = context.pointers;\n");
+        this.sourcePos['rcvr']       = this.source.length; this.source.push("var rcvr = vm.receiver;\n");
+        this.sourcePos['inst[']      = this.source.length; this.source.push("var inst = rcvr.pointers;\n");
+        this.sourcePos['temp[']      = this.source.length; this.source.push("var temp = vm.homeContext.pointers;\n");
+        this.sourcePos['lit[']       = this.source.length; this.source.push("var lit = vm.method.pointers;\n");
+        this.sourcePos['loop-start'] = this.source.length; this.source.push("while (true) switch (vm.pc) {\ncase 0:\n");
+        if (this.sista) this.generateSista(method);
+        else this.generateV3(method);
+        var funcName = this.functionNameFor(optClass, optSel);
+        if (this.singleStep) {
+            if (this.debug) this.source.push("// all valid PCs have a label;\n");
+            this.source.push("default: throw Error('invalid PC');\n}"); // all PCs handled
+        } else {
+            this.sourcePos['loop-end'] = this.source.length; this.source.push("default: vm.interpretOne(true); return;\n}");
+            this.deleteUnneededLabels();
+        }
+        this.deleteUnneededVariables();
+        var source = "'use strict';\nreturn function " + funcName + "(vm) {\n" + this.source.join("") + "}";
+        return new Function(source)();
+    },
+    generateV3: function(method) {
+        this.done = false;
+        while (!this.done) {
+            var byte = method.bytes[this.pc++],
+                byte2 = 0;
+            switch (byte & 0xF8) {
+                // load inst var
+                case 0x00: case 0x08:
+                    this.generatePush("inst[", byte & 0x0F, "]");
+                    break;
+                // load temp var
+                case 0x10: case 0x18:
+                    this.generatePush("temp[", 6 + (byte & 0xF), "]");
+                    break;
+                // loadLiteral
+                case 0x20: case 0x28: case 0x30: case 0x38:
+                    this.generatePush("lit[", 1 + (byte & 0x1F), "]");
+                    break;
+                // loadLiteralIndirect
+                case 0x40: case 0x48: case 0x50: case 0x58:
+                    this.generatePush("lit[", 1 + (byte & 0x1F), "].pointers[1]");
+                    break;
+                // storeAndPop inst var
+                case 0x60:
+                    this.generatePopInto("inst[", byte & 0x07, "]");
+                    break;
+                // storeAndPop temp var
+                case 0x68:
+                    this.generatePopInto("temp[", 6 + (byte & 0x07), "]");
+                    break;
+                // Quick push
+                case 0x70:
+                    switch (byte) {
+                        case 0x70: this.generatePush("rcvr"); break;
+                        case 0x71: this.generatePush("vm.trueObj"); break;
+                        case 0x72: this.generatePush("vm.falseObj"); break;
+                        case 0x73: this.generatePush("vm.nilObj"); break;
+                        case 0x74: this.generatePush("-1"); break;
+                        case 0x75: this.generatePush("0"); break;
+                        case 0x76: this.generatePush("1"); break;
+                        case 0x77: this.generatePush("2"); break;
+                    }
+                    break;
+                // Quick return
+                case 0x78:
+                    switch (byte) {
+                        case 0x78: this.generateReturn("rcvr"); break;
+                        case 0x79: this.generateReturn("vm.trueObj"); break;
+                        case 0x7A: this.generateReturn("vm.falseObj"); break;
+                        case 0x7B: this.generateReturn("vm.nilObj"); break;
+                        case 0x7C: this.generateReturn("stack[vm.sp]"); break;
+                        case 0x7D: this.generateBlockReturn(); break;
+                        default: throw Error("unusedBytecode " + byte);
+                    }
+                    break;
+                // Extended bytecodes
+                case 0x80: case 0x88:
+                    this.generateV3Extended(byte);
+                    break;
+                // short jump
+                case 0x90:
+                    this.generateJump((byte & 0x07) + 1);
+                    break;
+                // short conditional jump
+                case 0x98:
+                    this.generateJumpIf(false, (byte & 0x07) + 1);
+                    break;
+                // long jump, forward and back
+                case 0xA0:
+                    byte2 = method.bytes[this.pc++];
+                    this.generateJump(((byte&7)-4) * 256 + byte2);
+                    break;
+                // long conditional jump
+                case 0xA8:
+                    byte2 = method.bytes[this.pc++];
+                    this.generateJumpIf(byte < 0xAC, (byte & 3) * 256 + byte2);
+                    break;
+                // SmallInteger ops: + - < > <= >= = ~= * /  @ lshift: lxor: land: lor:
+                case 0xB0: case 0xB8:
+                    this.generateNumericOp(byte);
+                    break;
+                // quick primitives: // at:, at:put:, size, next, nextPut:, ...
+                case 0xC0: case 0xC8:
+                    this.generateQuickPrim(byte);
+                    break;
+                // send literal selector
+                case 0xD0: case 0xD8:
+                    this.generateSend("lit[", 1 + (byte & 0x0F), "]", 0, false);
+                    break;
+                case 0xE0: case 0xE8:
+                    this.generateSend("lit[", 1 + (byte & 0x0F), "]", 1, false);
+                    break;
+                case 0xF0: case 0xF8:
+                    this.generateSend("lit[", 1 + (byte & 0x0F), "]", 2, false);
+                    break;
+            }
+        }
+    },
+    generateV3Extended: function(bytecode) {
+        var byte2, byte3;
+        switch (bytecode) {
+            // extended push
+            case 0x80:
+                byte2 = this.method.bytes[this.pc++];
+                switch (byte2 >> 6) {
+                    case 0: this.generatePush("inst[", byte2 & 0x3F, "]"); return;
+                    case 1: this.generatePush("temp[", 6 + (byte2 & 0x3F), "]"); return;
+                    case 2: this.generatePush("lit[", 1 + (byte2 & 0x3F), "]"); return;
+                    case 3: this.generatePush("lit[", 1 + (byte2 & 0x3F), "].pointers[1]"); return;
+                }
+            // extended store
+            case 0x81:
+                byte2 = this.method.bytes[this.pc++];
+                switch (byte2 >> 6) {
+                    case 0: this.generateStoreInto("inst[", byte2 & 0x3F, "]"); return;
+                    case 1: this.generateStoreInto("temp[", 6 + (byte2 & 0x3F), "]"); return;
+                    case 2: throw Error("illegal store into literal");
+                    case 3: this.generateStoreInto("lit[", 1 + (byte2 & 0x3F), "].pointers[1]"); return;
+                }
+                return;
+            // extended pop into
+            case 0x82:
+                byte2 = this.method.bytes[this.pc++];
+                switch (byte2 >> 6) {
+                    case 0: this.generatePopInto("inst[", byte2 & 0x3F, "]"); return;
+                    case 1: this.generatePopInto("temp[", 6 + (byte2 & 0x3F), "]"); return;
+                    case 2: throw Error("illegal pop into literal");
+                    case 3: this.generatePopInto("lit[", 1 + (byte2 & 0x3F), "].pointers[1]"); return;
+                }
+            // Single extended send
+            case 0x83:
+                byte2 = this.method.bytes[this.pc++];
+                this.generateSend("lit[", 1 + (byte2 & 0x1F), "]", byte2 >> 5, false);
+                return;
+            // Double extended do-anything
+            case 0x84:
+                byte2 = this.method.bytes[this.pc++];
+                byte3 = this.method.bytes[this.pc++];
+                switch (byte2 >> 5) {
+                    case 0: this.generateSend("lit[", 1 + byte3, "]", byte2 & 31, false); return;
+                    case 1: this.generateSend("lit[", 1 + byte3, "]", byte2 & 31, true); return;
+                    case 2: this.generatePush("inst[", byte3, "]"); return;
+                    case 3: this.generatePush("lit[", 1 + byte3, "]"); return;
+                    case 4: this.generatePush("lit[", 1 + byte3, "].pointers[1]"); return;
+                    case 5: this.generateStoreInto("inst[", byte3, "]"); return;
+                    case 6: this.generatePopInto("inst[", byte3, "]"); return;
+                    case 7: this.generateStoreInto("lit[", 1 + byte3, "].pointers[1]"); return;
+                }
+            // Single extended send to super
+            case 0x85:
+                byte2 = this.method.bytes[this.pc++];
+                this.generateSend("lit[", 1 + (byte2 & 0x1F), "]", byte2 >> 5, true);
+                return;
+            // Second extended send
+            case 0x86:
+                 byte2 = this.method.bytes[this.pc++];
+                 this.generateSend("lit[", 1 + (byte2 & 0x3F), "]", byte2 >> 6, false);
+                 return;
+            // pop
+            case 0x87:
+                this.generateInstruction("pop", "vm.sp--");
+                return;
+            // dup
+            case 0x88:
+                this.needsVar['stack'] = true;
+                this.generateInstruction("dup", "var dup = stack[vm.sp]; stack[++vm.sp] = dup");
+                return;
+            // thisContext
+            case 0x89:
+                this.needsVar['stack'] = true;
+                this.generateInstruction("push thisContext", "stack[++vm.sp] = vm.exportThisContext()");
+                return;
+            // closures
+            case 0x8A:
+                byte2 = this.method.bytes[this.pc++];
+                var popValues = byte2 > 127,
+                    count = byte2 & 127;
+                this.generateClosureTemps(count, popValues);
+                return;
+            // call primitive
+            case 0x8B:
+                byte2 = this.method.bytes[this.pc++];
+                byte3 = this.method.bytes[this.pc++];
+                this.generateCallPrimitive(byte2 + 256 * byte3, 0x81);
+                return
+            // remote push from temp vector
+            case 0x8C:
+                byte2 = this.method.bytes[this.pc++];
+                byte3 = this.method.bytes[this.pc++];
+                this.generatePush("temp[", 6 + byte3, "].pointers[", byte2, "]");
+                return;
+            // remote store into temp vector
+            case 0x8D:
+                byte2 = this.method.bytes[this.pc++];
+                byte3 = this.method.bytes[this.pc++];
+                this.generateStoreInto("temp[", 6 + byte3, "].pointers[", byte2, "]");
+                return;
+            // remote store and pop into temp vector
+            case 0x8E:
+                byte2 = this.method.bytes[this.pc++];
+                byte3 = this.method.bytes[this.pc++];
+                this.generatePopInto("temp[", 6 + byte3, "].pointers[", byte2, "]");
+                return;
+            // pushClosureCopy
+            case 0x8F:
+                byte2 = this.method.bytes[this.pc++];
+                byte3 = this.method.bytes[this.pc++];
+                var byte4 = this.method.bytes[this.pc++];
+                var numArgs = byte2 & 0xF,
+                    numCopied = byte2 >> 4,
+                    blockSize = byte3 << 8 | byte4;
+                this.generateClosureCopy(numArgs, numCopied, blockSize);
+                return;
+        }
+    },
+    generateSista: function() {
+        var bytes = this.method.bytes,
+            b,
+            b2,
+            b3,
+            extA = 0,
+            extB = 0;
+        this.done = false;
+        while (!this.done) {
+            b = bytes[this.pc++];
+            switch (b) {
+                // 1 Byte Bytecodes
+
+                // load receiver variable
+                case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07:
+                case 0x08: case 0x09: case 0x0A: case 0x0B: case 0x0C: case 0x0D: case 0x0E: case 0x0F:
+                    this.generatePush("inst[", b & 0x0F, "]");
+                    break;
+                // load literal variable
+                case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17:
+                case 0x18: case 0x19: case 0x1A: case 0x1B: case 0x1C: case 0x1D: case 0x1E: case 0x1F:
+                    this.generatePush("lit[", 1 + (b & 0x0F), "].pointers[1]");
+                    break;
+                // load literal constant
+                case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27:
+                case 0x28: case 0x29: case 0x2A: case 0x2B: case 0x2C: case 0x2D: case 0x2E: case 0x2F:
+                case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37:
+                case 0x38: case 0x39: case 0x3A: case 0x3B: case 0x3C: case 0x3D: case 0x3E: case 0x3F:
+                    this.generatePush("lit[", 1 + (b & 0x1F), "]");
+                    break;
+                // load temporary variable
+                case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47:
+                    this.generatePush("temp[", 6 + (b & 0x07), "]");
+                    break;
+                case 0x48: case 0x49: case 0x4A: case 0x4B:
+                    this.generatePush("temp[", 6 + (b & 0x03) + 8, "]");
+                    break;
+                case 0x4C: this.generatePush("rcvr");
+                    break;
+                case 0x4D: this.generatePush("vm.trueObj");
+                    break;
+                case 0x4E: this.generatePush("vm.falseObj");
+                    break;
+                case 0x4F: this.generatePush("vm.nilObj");
+                    break;
+                case 0x50: this.generatePush(0);
+                    break;
+                case 0x51: this.generatePush(1);
+                    break;
+                case 0x52:
+                    this.needsVar['stack'] = true;
+                    this.generateInstruction("push thisContext", "stack[++vm.sp] = vm.exportThisContext()");
+                    break;
+                case 0x53:
+                    this.needsVar['stack'] = true;
+                    this.generateInstruction("dup", "var dup = stack[vm.sp]; stack[++vm.sp] = dup");
+                    break;
+                case 0x54: case 0x55: case 0x56: case 0x57:
+                    throw Error("unusedBytecode " + b);
+                case 0x58: this.generateReturn("rcvr");
+                    break;
+                case 0x59: this.generateReturn("vm.trueObj");
+                    break;
+                case 0x5A: this.generateReturn("vm.falseObj");
+                    break;
+                case 0x5B: this.generateReturn("vm.nilObj");
+                    break;
+                case 0x5C: this.generateReturn("stack[vm.sp]");
+                    break;
+                case 0x5D: this.generateBlockReturn("vm.nilObj");
+                    break;
+                case 0x5E: this.generateBlockReturn();
+                    break;
+                case 0x5F: break; // nop
+                case 0x60: case 0x61: case 0x62: case 0x63: case 0x64: case 0x65: case 0x66: case 0x67:
+                case 0x68: case 0x69: case 0x6A: case 0x6B: case 0x6C: case 0x6D: case 0x6E: case 0x6F:
+                    this.generateNumericOp(b);
+                    break;
+                case 0x70: case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x77:
+                case 0x78: case 0x79: case 0x7A: case 0x7B: case 0x7C: case 0x7D: case 0x7E: case 0x7F:
+                    this.generateQuickPrim(b);
+                    break;
+                case 0x80: case 0x81: case 0x82: case 0x83: case 0x84: case 0x85: case 0x86: case 0x87:
+                case 0x88: case 0x89: case 0x8A: case 0x8B: case 0x8C: case 0x8D: case 0x8E: case 0x8F:
+                    this.generateSend("lit[", 1 + (b & 0x0F), "]", 0, false);
+                    break;
+                case 0x90: case 0x91: case 0x92: case 0x93: case 0x94: case 0x95: case 0x96: case 0x97:
+                case 0x98: case 0x99: case 0x9A: case 0x9B: case 0x9C: case 0x9D: case 0x9E: case 0x9F:
+                    this.generateSend("lit[", 1 + (b & 0x0F), "]", 1, false);
+                    break;
+                case 0xA0: case 0xA1: case 0xA2: case 0xA3: case 0xA4: case 0xA5: case 0xA6: case 0xA7:
+                case 0xA8: case 0xA9: case 0xAA: case 0xAB: case 0xAC: case 0xAD: case 0xAE: case 0xAF:
+                    this.generateSend("lit[", 1 + (b & 0x0F), "]", 2, false);
+                    break;
+                case 0xB0: case 0xB1: case 0xB2: case 0xB3: case 0xB4: case 0xB5: case 0xB6: case 0xB7:
+                    this.generateJump((b & 0x07) + 1);
+                    break;
+                case 0xB8: case 0xB9: case 0xBA: case 0xBB: case 0xBC: case 0xBD: case 0xBE: case 0xBF:
+                    this.generateJumpIf(true, (b & 0x07) + 1);
+                    break;
+                case 0xC0: case 0xC1: case 0xC2: case 0xC3: case 0xC4: case 0xC5: case 0xC6: case 0xC7:
+                    this.generateJumpIf(false, (b & 0x07) + 1);
+                    break;
+                case 0xC8: case 0xC9: case 0xCA: case 0xCB: case 0xCC: case 0xCD: case 0xCE: case 0xCF:
+                    this.generatePopInto("inst[", b & 0x07, "]");
+                    break;
+                case 0xD0: case 0xD1: case 0xD2: case 0xD3: case 0xD4: case 0xD5: case 0xD6: case 0xD7:
+                    this.generatePopInto("temp[", 6 + (b & 0x07), "]");
+                    break;
+                case 0xD8: this.generateInstruction("pop", "vm.sp--");
+                    break;
+                case 0xD9:
+                    throw Error("unumplementedBytecode: 0xD9 (unconditional trap)");
+                case 0xDA: case 0xDB: case 0xDC: case 0xDD: case 0xDE: case 0xDF:
+                    throw Error("unusedBytecode " + b);
+
+                // 2 Byte Bytecodes
+                case 0xE0:
+                    b2 = bytes[this.pc++];
+                    extA = extA * 256 + b2;
+                    continue;
+                case 0xE1:
+                    b2 = bytes[this.pc++];
+                    extB = extB * 256 + (b2 < 128 ? b2 : b2 - 256);
+                    continue;
+                case 0xE2:
+                    b2 = bytes[this.pc++];
+                    this.generatePush("inst[", b2 + extA * 256, "]");
+                    break;
+                case 0xE3:
+                    b2 = bytes[this.pc++];
+                    this.generatePush("lit[", 1 + b2 + extA * 256, "].pointers[1]");
+                    break;
+                case 0xE4:
+                    b2 = bytes[this.pc++];
+                    this.generatePush("lit[", 1 + b2 + extA * 256, "]");
+                    break;
+                case 0xE5:
+                    b2 = bytes[this.pc++];
+                    this.generatePush("temp[", 6 + b2, "]");
+                    break;
+                case 0xE6:
+                    throw Error("unusedBytecode 0xE6");
+                case 0xE7:
+                    b2 = bytes[this.pc++];
+                    var popValues = b2 > 127,
+                        count = b2 & 127;
+                    this.generateClosureTemps(count, popValues);
+                    break;
+                case 0xE8:
+                    b2 = bytes[this.pc++];
+                    this.generatePush(b2 + extB * 256);
+                    break;
+                case 0xE9:
+                    b2 = bytes[this.pc++];
+                    this.generatePush("vm.image.getCharacter(", b2 + extB * 256, ")");
+                    break;
+                case 0xEA:
+                    b2 = bytes[this.pc++];
+                    this.generateSend("lit[", 1 + (b2 >> 3) + (extA << 5), "]", (b2 & 7) + (extB << 3), false);
+                    break;
+                case 0xEB:
+                    b2 = bytes[this.pc++];
+                    var lit = (b2 >> 3) + (extA << 5),
+                        numArgs = (b2 & 7) + ((extB & 63) << 3),
+                        directed = extB >= 64;
+                        this.generateSend("lit[", 1 + lit, "]", numArgs, directed ? "directed" : true);
+                    break;
+                case 0xEC:
+                    throw Error("unimplemented bytecode: 0xEC (class trap)");
+                case 0xED:
+                    b2 = bytes[this.pc++];
+                    this.generateJump(b2 + extB * 256);
+                    break;
+                case 0xEE:
+                    b2 = bytes[this.pc++];
+                    this.generateJumpIf(true, b2 + extB * 256);
+                    break;
+                case 0xEF:
+                    b2 = bytes[this.pc++];
+                    this.generateJumpIf(false, b2 + extB * 256);
+                    break;
+                case 0xF0:
+                    b2 = bytes[this.pc++];
+                    this.generatePopInto("inst[", b2 + extA * 256, "]");
+                    break;
+                case 0xF1:
+                    b2 = bytes[this.pc++];
+                    this.generatePopInto("lit[", 1 + b2 + extA * 256, "].pointers[1]");
+                    break;
+                case 0xF2:
+                    b2 = bytes[this.pc++];
+                    this.generatePopInto("temp[", 6 + b2, "]");
+                    break;
+                case 0xF3:
+                    b2 = bytes[this.pc++];
+                    this.generateStoreInto("inst[", b2 + extA * 256, "]");
+                    break;
+                case 0xF4:
+                    b2 = bytes[this.pc++];
+                    this.generateStoreInto("lit[", 1 + b2 + extA * 256, "].pointers[1]");
+                    break;
+                case 0xF5:
+                    b2 = bytes[this.pc++];
+                    this.generateStoreInto("temp[", 6 + b2, "]");
+                    break;
+                case 0xF6: case 0xF7:
+                    throw Error("unusedBytecode " + b);
+
+                // 3 Byte Bytecodes
+
+                case 0xF8:
+                    b2 = bytes[this.pc++];
+                    b3 = bytes[this.pc++];
+                    this.generateCallPrimitive(b2 + b3 * 256, 0xF5);
+                    break;
+                case 0xF9:
+                    b2 = bytes[this.pc++];
+                    b3 = bytes[this.pc++];
+                    this.generatePushFullClosure(b2 + extA * 255, b3);
+                    break;
+                case 0xFA:
+                    b2 = bytes[this.pc++];
+                    b3 = bytes[this.pc++];
+                    var numArgs = (b2 & 0x07) + (extA & 0x0F) * 8,
+                        numCopied = (b2 >> 3 & 0x7) + (extA >> 4) * 8,
+                        blockSize = b3 + (extB << 8);
+                    this.generateClosureCopy(numArgs, numCopied, blockSize);
+                    break;
+                case 0xFB:
+                    b2 = bytes[this.pc++];
+                    b3 = bytes[this.pc++];
+                    this.generatePush("temp[", 6 + b3, "].pointers[", b2, "]");
+                    break;
+                case 0xFC:
+                    b2 = bytes[this.pc++];
+                    b3 = bytes[this.pc++];
+                    this.generateStoreInto("temp[", 6 + b3, "].pointers[", b2, "]");
+                    break;
+                case 0xFD:
+                    b2 = bytes[this.pc++];
+                    b3 = bytes[this.pc++];
+                    this.generatePopInto("temp[", 6 + b3, "].pointers[", b2, "]");
+                    break;
+                case 0xFE: case 0xFF:
+                    throw Error("unusedBytecode " + b);
+                default:
+                    throw Error("illegal bytecode: " + b);
+            }
+            extA = 0;
+            extB = 0;
+        }
+    },
+    generatePush: function(target, arg1, suffix1, arg2, suffix2) {
+        if (this.debug) this.generateDebugCode("push", target, arg1, suffix1, arg2, suffix2);
+        this.generateLabel();
+        this.needsVar[target] = true;
+        this.needsVar['stack'] = true;
+        this.source.push("stack[++vm.sp] = ", target);
+        if (arg1 !== undefined) {
+            this.source.push(arg1, suffix1);
+            if (arg2 !== undefined) {
+                this.source.push(arg2, suffix2);
+            }
+        }
+        this.source.push(";\n");
+    },
+    generateStoreInto: function(target, arg1, suffix1, arg2, suffix2) {
+        if (this.debug) this.generateDebugCode("store into", target, arg1, suffix1, arg2, suffix2);
+        this.generateLabel();
+        this.needsVar[target] = true;
+        this.needsVar['stack'] = true;
+        this.source.push(target);
+        if (arg1 !== undefined) {
+            this.source.push(arg1, suffix1);
+            if (arg2 !== undefined) {
+                this.source.push(arg2, suffix2);
+            }
+        }
+        this.source.push(" = stack[vm.sp];\n");
+        this.generateDirty(target, arg1, suffix1);
+    },
+    generatePopInto: function(target, arg1, suffix1, arg2, suffix2) {
+        if (this.debug) this.generateDebugCode("pop into", target, arg1, suffix1, arg2, suffix2);
+        this.generateLabel();
+        this.needsVar[target] = true;
+        this.needsVar['stack'] = true;
+        this.source.push(target);
+        if (arg1 !== undefined) {
+            this.source.push(arg1, suffix1);
+            if (arg2 !== undefined) {
+                this.source.push(arg2, suffix2);
+            }
+        }
+        this.source.push(" = stack[vm.sp--];\n");
+        this.generateDirty(target, arg1, suffix1);
+    },
+    generateReturn: function(what) {
+        if (this.debug) this.generateDebugCode("return", what);
+        this.generateLabel();
+        this.needsVar[what] = true;
+        this.source.push(
+            "vm.pc = ", this.pc, "; vm.doReturn(", what, "); return;\n");
+        this.needsBreak = false; // returning anyway
+        this.done = this.pc > this.endPC;
+    },
+    generateBlockReturn: function(retVal) {
+        if (this.debug) this.generateDebugCode("block return");
+        this.generateLabel();
+        if (!retVal) {
+            this.needsVar['stack'] = true;
+            retVal = "stack[vm.sp--]";
+        }
+        // actually stack === context.pointers but that would look weird
+        this.needsVar['context'] = true;
+        this.source.push(
+            "vm.pc = ", this.pc, "; vm.doReturn(", retVal, ", context.pointers[0]); return;\n");
+        this.needsBreak = false; // returning anyway
+        this.done = this.pc > this.endPC;
+    },
+    generateJump: function(distance) {
+        var destination = this.pc + distance;
+        if (this.debug) this.generateDebugCode("jump to " + destination);
+        this.generateLabel();
+        this.needsVar['context'] = true;
+        this.source.push("vm.pc = ", destination, "; ");
+        if (distance < 0) this.source.push(
+            "\nif (vm.interruptCheckCounter-- <= 0) {\n",
+            "   vm.checkForInterrupts();\n",
+            "   if (context !== vm.activeContext || vm.breakOutOfInterpreter !== false) return;\n",
+            "}\n");
+        if (this.singleStep) this.source.push("\nif (vm.breakOutOfInterpreter) return;\n");
+        this.source.push("continue;\n");
+        this.needsBreak = false; // already checked
+        this.needsLabel[destination] = true;
+        if (destination > this.endPC) this.endPC = destination;
+    },
+    generateJumpIf: function(condition, distance) {
+        var destination = this.pc + distance;
+        if (this.debug) this.generateDebugCode("jump if " + condition + " to " + destination);
+        this.generateLabel();
+        this.needsVar['stack'] = true;
+        this.source.push(
+            "var cond = stack[vm.sp--]; if (cond === vm.", condition, "Obj) {vm.pc = ", destination, "; ");
+        if (this.singleStep) this.source.push("if (vm.breakOutOfInterpreter) return; else ");
+        this.source.push("continue}\n",
+            "else if (cond !== vm.", !condition, "Obj) {vm.sp++; vm.pc = ", this.pc, "; vm.send(vm.specialObjects[25], 0, false); return}\n");
+        this.needsLabel[this.pc] = true; // for coming back after #mustBeBoolean send
+        this.needsLabel[destination] = true; // obviously
+        if (destination > this.endPC) this.endPC = destination;
+    },
+    generateQuickPrim: function(byte) {
+        if (this.debug) this.generateDebugCode("quick send #" + this.specialSelectors[(byte & 0x0F) + 16]);
+        this.generateLabel();
+        switch (byte & 0x0F) {
+            case 0x0: // at:
+                this.needsVar['stack'] = true;
+                this.source.push(
+                    "var a, b; if ((a=stack[vm.sp-1]).sqClass === vm.specialObjects[7] && a.pointers && typeof (b=stack[vm.sp]) === 'number' && b>0 && b<=a.pointers.length) {\n",
+                    "  stack[--vm.sp] = a.pointers[b-1];",
+                    "} else { var c = vm.primHandler.objectAt(true,true,false); if (vm.primHandler.success) stack[--vm.sp] = c; else {\n",
+                    "  vm.pc = ", this.pc, "; vm.sendSpecial(16); if (context !== vm.activeContext || vm.breakOutOfInterpreter !== false) return; }}\n");
+                this.needsLabel[this.pc] = true;
+                return;
+            case 0x1: // at:put:
+                this.needsVar['stack'] = true;
+                this.source.push(
+                    "var a, b; if ((a=stack[vm.sp-2]).sqClass === vm.specialObjects[7] && a.pointers && typeof (b=stack[vm.sp-1]) === 'number' && b>0 && b<=a.pointers.length) {\n",
+                    "  var c = stack[vm.sp]; stack[vm.sp-=2] = a.pointers[b-1] = c; a.dirty = true;",
+                    "} else { vm.primHandler.objectAtPut(true,true,false); if (vm.primHandler.success) stack[vm.sp-=2] = c; else {\n",
+                    "  vm.pc = ", this.pc, "; vm.sendSpecial(17); if (context !== vm.activeContext || vm.breakOutOfInterpreter !== false) return; }}\n");
+                this.needsLabel[this.pc] = true;
+                return;
+            case 0x2: // size
+                this.needsVar['stack'] = true;
+                this.source.push(
+                    "if (stack[vm.sp].sqClass === vm.specialObjects[7]) stack[vm.sp] = stack[vm.sp].pointersSize();\n",     // Array
+                    "else if (stack[vm.sp].sqClass === vm.specialObjects[6]) stack[vm.sp] = stack[vm.sp].bytesSize();\n",   // ByteString
+                    "else { vm.pc = ", this.pc, "; vm.sendSpecial(18); if (context !== vm.activeContext || vm.breakOutOfInterpreter !== false) return; }\n");
+                this.needsLabel[this.pc] = true;
+                return;
+            //case 0x3: return false; // next
+            //case 0x4: return false; // nextPut:
+            //case 0x5: return false; // atEnd
+            case 0x6: // ==
+                this.needsVar['stack'] = true;
+                this.source.push("var cond = stack[vm.sp-1] === stack[vm.sp];\nstack[--vm.sp] = cond ? vm.trueObj : vm.falseObj;\n");
+                return;
+            case 0x7: // class
+                this.needsVar['stack'] = true;
+                this.source.push("stack[vm.sp] = typeof stack[vm.sp] === 'number' ? vm.specialObjects[5] : stack[vm.sp].sqClass;\n");
+                return;
+            case 0x8: // blockCopy:
+                this.needsVar['rcvr'] = true;
+                this.source.push(
+                    "vm.pc = ", this.pc, "; if (!vm.primHandler.quickSendOther(rcvr, ", (byte & 0x0F), ")) ",
+                    "{vm.sendSpecial(", ((byte & 0x0F) + 16), "); return}\n");
+                this.needsLabel[this.pc] = true;        // for send
+                this.needsLabel[this.pc + 2] = true;    // for start of block
+                return;
+            case 0x9: // value
+            case 0xA: // value:
+            case 0xB: // do:
+                this.needsVar['rcvr'] = true;
+                this.source.push(
+                    "vm.pc = ", this.pc, "; if (!vm.primHandler.quickSendOther(rcvr, ", (byte & 0x0F), ")) vm.sendSpecial(", ((byte & 0x0F) + 16), "); return;\n");
+                this.needsLabel[this.pc] = true;
+                return;
+            //case 0xC: return false; // new
+            //case 0xD: return false; // new:
+            //case 0xE: return false; // x
+            //case 0xF: return false; // y
+        }
+        // generic version for the bytecodes not yet handled above
+        this.needsVar['rcvr'] = true;
+        this.needsVar['context'] = true;
+        this.source.push(
+            "vm.pc = ", this.pc, "; if (!vm.primHandler.quickSendOther(rcvr, ", (byte & 0x0F), "))",
+            " vm.sendSpecial(", ((byte & 0x0F) + 16), ");\n",
+            "if (context !== vm.activeContext || vm.breakOutOfInterpreter !== false) return;\n");
+        this.needsBreak = false; // already checked
+        // if falling back to a full send we need a label for coming back
+        this.needsLabel[this.pc] = true;
+    },
+    generateNumericOp: function(byte) {
+        if (this.debug) this.generateDebugCode("quick send #" + this.specialSelectors[byte & 0x0F]);
+        this.generateLabel();
+        // if the op cannot be executed here, do a full send and return to main loop
+        // we need a label for coming back
+        this.needsLabel[this.pc] = true;
+        switch (byte & 0x0F) {
+            case 0x0: // PLUS +
+                this.needsVar['stack'] = true;
+                this.source.push("var a = stack[vm.sp - 1], b = stack[vm.sp];\n",
+                "if (typeof a === 'number' && typeof b === 'number') {\n",
+                "   stack[--vm.sp] = vm.primHandler.signed32BitIntegerFor(a + b);\n",
+                "} else { vm.pc = ", this.pc, "; vm.sendSpecial(0); if (context !== vm.activeContext || vm.breakOutOfInterpreter !== false) return}\n");
+                return;
+            case 0x1: // MINUS -
+                this.needsVar['stack'] = true;
+                this.source.push("var a = stack[vm.sp - 1], b = stack[vm.sp];\n",
+                "if (typeof a === 'number' && typeof b === 'number') {\n",
+                "   stack[--vm.sp] = vm.primHandler.signed32BitIntegerFor(a - b);\n",
+                "} else { vm.pc = ", this.pc, "; vm.sendSpecial(1); if (context !== vm.activeContext || vm.breakOutOfInterpreter !== false) return}\n");
+                return;
+            case 0x2: // LESS <
+                this.needsVar['stack'] = true;
+                this.source.push("var a = stack[vm.sp - 1], b = stack[vm.sp];\n",
+                "if (typeof a === 'number' && typeof b === 'number') {\n",
+                "   stack[--vm.sp] = a < b ? vm.trueObj : vm.falseObj;\n",
+                "} else { vm.pc = ", this.pc, "; vm.sendSpecial(2); if (context !== vm.activeContext || vm.breakOutOfInterpreter !== false) return}\n");
+                return;
+            case 0x3: // GRTR >
+                this.needsVar['stack'] = true;
+                this.source.push("var a = stack[vm.sp - 1], b = stack[vm.sp];\n",
+                "if (typeof a === 'number' && typeof b === 'number') {\n",
+                "   stack[--vm.sp] = a > b ? vm.trueObj : vm.falseObj;\n",
+                "} else { vm.pc = ", this.pc, "; vm.sendSpecial(3); if (context !== vm.activeContext || vm.breakOutOfInterpreter !== false) return}\n");
+                return;
+            case 0x4: // LEQ <=
+                this.needsVar['stack'] = true;
+                this.source.push("var a = stack[vm.sp - 1], b = stack[vm.sp];\n",
+                "if (typeof a === 'number' && typeof b === 'number') {\n",
+                "   stack[--vm.sp] = a <= b ? vm.trueObj : vm.falseObj;\n",
+                "} else { vm.pc = ", this.pc, "; vm.sendSpecial(4); if (context !== vm.activeContext || vm.breakOutOfInterpreter !== false) return}\n");
+                return;
+            case 0x5: // GEQ >=
+                this.needsVar['stack'] = true;
+                this.source.push("var a = stack[vm.sp - 1], b = stack[vm.sp];\n",
+                "if (typeof a === 'number' && typeof b === 'number') {\n",
+                "   stack[--vm.sp] = a >= b ? vm.trueObj : vm.falseObj;\n",
+                "} else { vm.pc = ", this.pc, "; vm.sendSpecial(5); if (context !== vm.activeContext || vm.breakOutOfInterpreter !== false) return}\n");
+                return;
+            case 0x6: // EQU =
+                this.needsVar['stack'] = true;
+                this.source.push("var a = stack[vm.sp - 1], b = stack[vm.sp];\n",
+                "if (typeof a === 'number' && typeof b === 'number') {\n",
+                "   stack[--vm.sp] = a === b ? vm.trueObj : vm.falseObj;\n",
+                "} else if (a === b && a.float === a.float) {\n",   // NaN check
+                "   stack[--vm.sp] = vm.trueObj;\n",
+                "} else { vm.pc = ", this.pc, "; vm.sendSpecial(6); if (context !== vm.activeContext || vm.breakOutOfInterpreter !== false) return}\n");
+                return;
+            case 0x7: // NEQ ~=
+                this.needsVar['stack'] = true;
+                this.source.push("var a = stack[vm.sp - 1], b = stack[vm.sp];\n",
+                "if (typeof a === 'number' && typeof b === 'number') {\n",
+                "   stack[--vm.sp] = a !== b ? vm.trueObj : vm.falseObj;\n",
+                "} else if (a === b && a.float === a.float) {\n",   // NaN check
+                "   stack[--vm.sp] = vm.falseObj;\n",
+                "} else { vm.pc = ", this.pc, "; vm.sendSpecial(7); if (context !== vm.activeContext || vm.breakOutOfInterpreter !== false) return}\n");
+                return;
+            case 0x8: // TIMES *
+                this.source.push("vm.success = true; vm.resultIsFloat = false; if(!vm.pop2AndPushNumResult(vm.stackIntOrFloat(1) * vm.stackIntOrFloat(0))) { vm.pc = ", this.pc, "; vm.sendSpecial(8); return}\n");
+                return;
+            case 0x9: // DIV /
+                this.source.push("vm.success = true; if(!vm.pop2AndPushIntResult(vm.quickDivide(vm.stackInteger(1),vm.stackInteger(0)))) { vm.pc = ", this.pc, "; vm.sendSpecial(9); return}\n");
+                return;
+            case 0xA: // MOD \
+                this.source.push("vm.success = true; if(!vm.pop2AndPushIntResult(vm.mod(vm.stackInteger(1),vm.stackInteger(0)))) { vm.pc = ", this.pc, "; vm.sendSpecial(10); return}\n");
+                return;
+            case 0xB:  // MakePt int@int
+                this.source.push("vm.success = true; if(!vm.primHandler.primitiveMakePoint(1, true)) { vm.pc = ", this.pc, "; vm.sendSpecial(11); return}\n");
+                return;
+            case 0xC: // bitShift:
+                this.source.push("vm.success = true; if(!vm.pop2AndPushIntResult(vm.safeShift(vm.stackInteger(1),vm.stackInteger(0)))) { vm.pc = ", this.pc, "; vm.sendSpecial(12); return}\n");
+                return;
+            case 0xD: // Divide //
+                this.source.push("vm.success = true; if(!vm.pop2AndPushIntResult(vm.div(vm.stackInteger(1),vm.stackInteger(0)))) { vm.pc = ", this.pc, "; vm.sendSpecial(13); return}\n");
+                return;
+            case 0xE: // bitAnd:
+                this.source.push("vm.success = true; if(!vm.pop2AndPushIntResult(vm.stackInteger(1) & vm.stackInteger(0))) { vm.pc = ", this.pc, "; vm.sendSpecial(14); return}\n");
+                return;
+            case 0xF: // bitOr:
+                this.source.push("vm.success = true; if(!vm.pop2AndPushIntResult(vm.stackInteger(1) | vm.stackInteger(0))) { vm.pc = ", this.pc, "; vm.sendSpecial(15); return}\n");
+                return;
+        }
+    },
+    generateSend: function(prefix, num, suffix, numArgs, superSend) {
+        if (this.debug) this.generateDebugCode(
+            (superSend === "directed" ? "directed super send " : superSend ? "super send " : "send ")
+            + (prefix === "lit[" ? this.method.pointers[num].bytesAsString() : "..."));
+        this.generateLabel();
+        this.needsVar[prefix] = true;
+        this.needsVar['context'] = true;
+        // set pc, activate new method, and return to main loop
+        // unless the method was a successfull primitive call (no context change)
+        this.source.push("vm.pc = ", this.pc);
+        if (superSend === "directed") {
+            this.source.push("; vm.sendSuperDirected(", prefix, num, suffix, ", ", numArgs, "); ");
+        } else {
+            this.source.push("; vm.send(", prefix, num, suffix, ", ", numArgs, ", ", superSend, "); ");
+        }
+        this.source.push("if (context !== vm.activeContext || vm.breakOutOfInterpreter !== false) return;\n");
+        this.needsBreak = false; // already checked
+        // need a label for coming back after send
+        this.needsLabel[this.pc] = true;
+    },
+    generateClosureTemps: function(count, popValues) {
+        if (this.debug) this.generateDebugCode("closure temps");
+        this.generateLabel();
+        this.needsVar['stack'] = true;
+        this.source.push("var array = vm.instantiateClass(vm.specialObjects[7], ", count, ");\n");
+        if (popValues) {
+            for (var i = 0; i < count; i++)
+                this.source.push("array.pointers[", i, "] = stack[vm.sp - ", count - i - 1, "];\n");
+            this.source.push("stack[vm.sp -= ", count - 1, "] = array;\n");
+        } else {
+            this.source.push("stack[++vm.sp] = array;\n");
+        }
+    },
+    generateClosureCopy: function(numArgs, numCopied, blockSize) {
+        var from = this.pc,
+            to = from + blockSize;
+        if (this.debug) this.generateDebugCode("push closure(" + from + "-" + (to-1) + "): " + numCopied + " copied, " + numArgs + " args");
+        this.generateLabel();
+        this.needsVar['stack'] = true;
+        this.source.push(
+            "var closure = vm.instantiateClass(vm.specialObjects[36], ", numCopied, ");\n",
+            "closure.pointers[0] = context; vm.reclaimableContextCount = 0;\n",
+            "closure.pointers[1] = ", from + this.method.pointers.length * 4 + 1, ";\n",  // encodeSqueakPC
+            "closure.pointers[2] = ", numArgs, ";\n");
+        if (numCopied > 0) {
+            for (var i = 0; i < numCopied; i++)
+                this.source.push("closure.pointers[", i + 3, "] = stack[vm.sp - ", numCopied - i - 1,"];\n");
+            this.source.push("stack[vm.sp -= ", numCopied - 1,"] = closure;\n");
+        } else {
+            this.source.push("stack[++vm.sp] = closure;\n");
+        }
+        this.source.push("vm.pc = ", to, ";\n");
+        if (this.singleStep) this.source.push("if (vm.breakOutOfInterpreter) return;\n");
+        this.source.push("continue;\n");
+        this.needsBreak = false; // already checked
+        this.needsLabel[from] = true;   // initial pc when activated
+        this.needsLabel[to] = true;     // for jump over closure
+        if (to > this.endPC) this.endPC = to;
+    },
+    generatePushFullClosure: function(index, b3) {
+        if (this.debug) this.generateDebugCode("push full closure " + (index + 1));
+        this.generateLabel();
+        this.needsVar['lit['] = true;
+        this.needsVar['rcvr'] = true;
+        this.needsVar['stack'] = true;
+        var numCopied = b3 & 63;
+        var outer;
+        if ((b3 >> 6 & 1) === 1) {
+            outer = "vm.nilObj";
+        } else {
+            outer = "context";
+        }
+        if ((b3 >> 7 & 1) === 1) {
+            throw Error("on-stack receiver not yet supported");
+        }
+        this.source.push("var closure = vm.newFullClosure(", outer, ", ", numCopied, ", lit[", 1 + index, "]);\n");
+        this.source.push("closure.pointers[", Squeak.ClosureFull_receiver, "] = rcvr;\n");
+        if (outer === "context") this.source.push("vm.reclaimableContextCount = 0;\n");
+        if (numCopied > 0) {
+            for (var i = 0; i < numCopied; i++)
+                this.source.push("closure.pointers[", i + Squeak.ClosureFull_firstCopiedValue, "] = stack[vm.sp - ", numCopied - i - 1,"];\n");
+            this.source.push("stack[vm.sp -= ", numCopied - 1,"] = closure;\n");
+        } else {
+            this.source.push("stack[++vm.sp] = closure;\n");
+        }
+    },
+    generateCallPrimitive: function(index, extendedStoreBytecode) {
+        if (this.debug) this.generateDebugCode("call primitive " + index);
+        this.generateLabel();
+        if (this.method.bytes[this.pc] === extendedStoreBytecode)  {
+            this.needsVar['stack'] = true;
+            this.source.push("if (vm.primFailCode) {stack[vm.sp] = vm.getErrorObjectFromPrimFailCode(); vm.primFailCode = 0;}\n");
+        }
+    },
+    generateDirty: function(target, arg, suffix) {
+        switch(target) {
+            case "inst[": this.source.push("rcvr.dirty = true;\n"); break;
+            case "lit[": this.source.push(target, arg, "].dirty = true;\n"); break;
+            case "temp[": if (suffix !== "]") this.source.push(target, arg, "].dirty = true;\n"); break;
+            default:
+                throw Error("unexpected target " + target);
+        }
+    },
+    generateLabel: function() {
+        // remember label position for deleteUnneededLabels()
+        if (this.prevPC) {
+            this.sourceLabels[this.prevPC] = this.source.length;
+            this.source.push("case ", this.prevPC, ":\n");           // must match deleteUnneededLabels
+        }
+        this.prevPC = this.pc;
+    },
+    generateDebugCode: function(command, what, arg1, suffix1, arg2, suffix2) {
+        // single-step for previous instructiuon
+        if (this.needsBreak) {
+             this.source.push("if (vm.breakOutOfInterpreter) {vm.pc = ", this.prevPC, "; return}\n");
+             this.needsLabel[this.prevPC] = true;
+        }
+        // comment for this instruction
+        var bytecodes = [];
+        for (var i = this.prevPC; i < this.pc; i++)
+            bytecodes.push((this.method.bytes[i] + 0x100).toString(16).slice(-2).toUpperCase());
+        this.source.push("// ", this.prevPC, " <", bytecodes.join(" "), "> ", command);
+        // append argument to comment
+        if (what !== undefined) {
+            this.source.push(" ");
+            switch (what) {
+                case 'vm.nilObj':    this.source.push('nil'); break;
+                case 'vm.trueObj':   this.source.push('true'); break;
+                case 'vm.falseObj':  this.source.push('false'); break;
+                case 'rcvr':         this.source.push('self'); break;
+                case 'stack[vm.sp]': this.source.push('top of stack'); break;
+                case 'inst[':
+                    if (!this.instVarNames) this.source.push('inst var ', arg1);
+                    else this.source.push(this.instVarNames[arg1]);
+                    break;
+                case 'temp[':
+                    this.source.push('tmp', arg1 - 6);
+                    if (suffix1 !== ']') this.source.push('[', arg2, ']');
+                    break;
+                case 'lit[':
+                    var lit = this.method.pointers[arg1];
+                    if (suffix1 === ']') this.source.push(lit);
+                    else this.source.push(lit.pointers[0].bytesAsString());
+                    break;
+                default:
+                    this.source.push(what);
+            }
+        }
+        this.source.push("\n");
+        // enable single-step for next instruction
+        this.needsBreak = this.singleStep;
+    },
+    generateInstruction: function(comment, instr) {
+        if (this.debug) this.generateDebugCode(comment);
+        this.generateLabel();
+        this.source.push(instr, ";\n");
+    },
+    deleteUnneededLabels: function() {
+        // switch statement is more efficient with fewer labels
+        var hasAnyLabel = false;
+        for (var i in this.sourceLabels)
+            if (this.needsLabel[i])
+                hasAnyLabel = true;
+            else for (var j = 0; j < 3; j++)
+               this.source[this.sourceLabels[i] + j] = "";
+        if (!hasAnyLabel) {
+            this.source[this.sourcePos['loop-start']] = "";
+            this.source[this.sourcePos['loop-end']] = "";
+        }
+    },
+    deleteUnneededVariables: function() {
+        if (this.needsVar['stack']) this.needsVar['context'] = true;
+        if (this.needsVar['inst[']) this.needsVar['rcvr'] = true;
+        for (var i = 0; i < this.allVars.length; i++) {
+            var v = this.allVars[i];
+            if (!this.needsVar[v])
+                this.source[this.sourcePos[v]] = "";
+        }
+    },
+});

lib/FileSaver.js

@@ -0,0 +1,182 @@
+/* FileSaver.js
+ * A saveAs() FileSaver implementation.
+ * 1.3.8
+ * 2018-03-22 14:03:47
+ *
+ * By Eli Grey, https://eligrey.com
+ * License: MIT
+ *   See https://github.com/eligrey/FileSaver.js/blob/master/LICENSE.md
+ */
+
+/*global self */
+/*jslint bitwise: true, indent: 4, laxbreak: true, laxcomma: true, smarttabs: true, plusplus: true */
+
+/*! @source http://purl.eligrey.com/github/FileSaver.js/blob/master/src/FileSaver.js */
+
+(function(view) {
+	"use strict";
+	// IE <10 is explicitly unsupported
+	if (typeof view === "undefined" || typeof navigator !== "undefined" && /MSIE [1-9]\./.test(navigator.userAgent)) {
+		return;
+	}
+	var
+		  doc = view.document
+		  // only get URL when necessary in case Blob.js hasn't overridden it yet
+		, get_URL = function() {
+			return view.URL || view.webkitURL || view;
+		}
+		, save_link = doc.createElementNS("http://www.w3.org/1999/xhtml", "a")
+		, can_use_save_link = "download" in save_link
+		, click = function(node) {
+			var event = new MouseEvent("click");
+			node.dispatchEvent(event);
+		}
+		, is_safari = /constructor/i.test(view.HTMLElement) || view.safari
+		, is_chrome_ios =/CriOS\/[\d]+/.test(navigator.userAgent)
+		, setImmediate = view.setImmediate || view.setTimeout
+		, throw_outside = function(ex) {
+			setImmediate(function() {
+				throw ex;
+			}, 0);
+		}
+		, force_saveable_type = "application/octet-stream"
+		// the Blob API is fundamentally broken as there is no "downloadfinished" event to subscribe to
+		, arbitrary_revoke_timeout = 1000 * 40 // in ms
+		, revoke = function(file) {
+			var revoker = function() {
+				if (typeof file === "string") { // file is an object URL
+					get_URL().revokeObjectURL(file);
+				} else { // file is a File
+					file.remove();
+				}
+			};
+			setTimeout(revoker, arbitrary_revoke_timeout);
+		}
+		, dispatch = function(filesaver, event_types, event) {
+			event_types = [].concat(event_types);
+			var i = event_types.length;
+			while (i--) {
+				var listener = filesaver["on" + event_types[i]];
+				if (typeof listener === "function") {
+					try {
+						listener.call(filesaver, event || filesaver);
+					} catch (ex) {
+						throw_outside(ex);
+					}
+				}
+			}
+		}
+		, auto_bom = function(blob) {
+			// prepend BOM for UTF-8 XML and text/* types (including HTML)
+			// note: your browser will automatically convert UTF-16 U+FEFF to EF BB BF
+			if (/^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(blob.type)) {
+				return new Blob([String.fromCharCode(0xFEFF), blob], {type: blob.type});
+			}
+			return blob;
+		}
+		, FileSaver = function(blob, name, no_auto_bom) {
+			if (!no_auto_bom) {
+				blob = auto_bom(blob);
+			}
+			// First try a.download, then web filesystem, then object URLs
+			var
+				  filesaver = this
+				, type = blob.type
+				, force = type === force_saveable_type
+				, object_url
+				, dispatch_all = function() {
+					dispatch(filesaver, "writestart progress write writeend".split(" "));
+				}
+				// on any filesys errors revert to saving with object URLs
+				, fs_error = function() {
+					if ((is_chrome_ios || (force && is_safari)) && view.FileReader) {
+						// Safari doesn't allow downloading of blob urls
+						var reader = new FileReader();
+						reader.onloadend = function() {
+							var url = is_chrome_ios ? reader.result : reader.result.replace(/^data:[^;]*;/, 'data:attachment/file;');
+							var popup = view.open(url, '_blank');
+							if(!popup) view.location.href = url;
+							url=undefined; // release reference before dispatching
+							filesaver.readyState = filesaver.DONE;
+							dispatch_all();
+						};
+						reader.readAsDataURL(blob);
+						filesaver.readyState = filesaver.INIT;
+						return;
+					}
+					// don't create more object URLs than needed
+					if (!object_url) {
+						object_url = get_URL().createObjectURL(blob);
+					}
+					if (force) {
+						view.location.href = object_url;
+					} else {
+						var opened = view.open(object_url, "_blank");
+						if (!opened) {
+							// Apple does not allow window.open, see https://developer.apple.com/library/safari/documentation/Tools/Conceptual/SafariExtensionGuide/WorkingwithWindowsandTabs/WorkingwithWindowsandTabs.html
+							view.location.href = object_url;
+						}
+					}
+					filesaver.readyState = filesaver.DONE;
+					dispatch_all();
+					revoke(object_url);
+				}
+			;
+			filesaver.readyState = filesaver.INIT;
+
+			if (can_use_save_link) {
+				object_url = get_URL().createObjectURL(blob);
+				setImmediate(function() {
+					save_link.href = object_url;
+					save_link.download = name;
+					click(save_link);
+					dispatch_all();
+					revoke(object_url);
+					filesaver.readyState = filesaver.DONE;
+				}, 0);
+				return;
+			}
+
+			fs_error();
+		}
+		, FS_proto = FileSaver.prototype
+		, saveAs = function(blob, name, no_auto_bom) {
+			return new FileSaver(blob, name || blob.name || "download", no_auto_bom);
+		}
+	;
+
+	// IE 10+ (native saveAs)
+	if (typeof navigator !== "undefined" && navigator.msSaveOrOpenBlob) {
+		return function(blob, name, no_auto_bom) {
+			name = name || blob.name || "download";
+
+			if (!no_auto_bom) {
+				blob = auto_bom(blob);
+			}
+			return navigator.msSaveOrOpenBlob(blob, name);
+		};
+	}
+
+	// todo: detect chrome extensions & packaged apps
+	//save_link.target = "_blank";
+
+	FS_proto.abort = function(){};
+	FS_proto.readyState = FS_proto.INIT = 0;
+	FS_proto.WRITING = 1;
+	FS_proto.DONE = 2;
+
+	FS_proto.error =
+	FS_proto.onwritestart =
+	FS_proto.onprogress =
+	FS_proto.onwrite =
+	FS_proto.onabort =
+	FS_proto.onerror =
+	FS_proto.onwriteend =
+		null;
+
+	view.FileSaver_saveAs = saveAs;
+}(
+	   typeof self !== "undefined" && self
+	|| typeof window !== "undefined" && window
+	|| this
+));

lib/addtohomescreen.css

@@ -0,0 +1,257 @@
+.ath-viewport * {
+	-webkit-box-sizing: border-box;
+	-moz-box-sizing: border-box;
+	box-sizing: border-box;
+}
+
+.ath-viewport {
+	position: relative;
+	z-index: 2147483641;
+	pointer-events: none;
+
+	-webkit-tap-highlight-color: rgba(0,0,0,0);
+	-webkit-touch-callout: none;
+	-webkit-user-select: none;
+	-moz-user-select: none;
+	-ms-user-select: none;
+	user-select: none;
+	-webkit-text-size-adjust: none;
+	-moz-text-size-adjust: none;
+	-ms-text-size-adjust: none;
+	-o-text-size-adjust: none;
+	text-size-adjust: none;
+}
+
+.ath-modal {
+	pointer-events: auto !important;
+	background: rgba(0,0,0,0.6);
+}
+
+.ath-mandatory {
+	background: #000;
+}
+
+.ath-container {
+	pointer-events: auto !important;
+	position: absolute;
+	z-index: 2147483641;
+	padding: 0.7em 0.6em;
+	width: 18em;
+
+	background: #eee;
+	background-size: 100% auto;
+
+	box-shadow: 0 0.2em 0 #d1d1d1;
+
+	font-family: sans-serif;
+	font-size: 15px;
+	line-height: 1.5em;
+	text-align: center;
+}
+
+.ath-container small {
+	font-size: 0.8em;
+	line-height: 1.3em;
+	display: block;
+	margin-top: 0.5em;
+}
+
+.ath-ios.ath-phone {
+	bottom: 1.8em;
+	left: 50%;
+	margin-left: -9em;
+}
+
+.ath-ios6.ath-tablet {
+	left: 5em;
+	top: 1.8em;
+}
+
+.ath-ios7.ath-tablet {
+	left: 0.7em;
+	top: 1.8em;
+}
+
+.ath-ios8.ath-tablet,
+.ath-ios9.ath-tablet{
+	right: 0.4em;
+	top: 1.8em;
+}
+
+.ath-android {
+	bottom: 1.8em;
+	left: 50%;
+	margin-left: -9em;
+}
+
+/* close icon */
+.ath-container:before {
+	content: '';
+	position: relative;
+	display: block;
+	float: right;
+	margin: -0.7em -0.6em 0 0.5em;
+	background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIQAAACECAMAAABmmnOVAAAAdVBMVEUAAAA5OTkzMzM7Ozs3NzdBQUFAQEA/Pz8+Pj5BQUFAQEA/Pz8+Pj5BQUFAQEA/Pz9BQUE+Pj4/Pz8/Pz8+Pj4/Pz8/Pz8/Pz8+Pj4/Pz8+Pj4/Pz8/Pz8/Pz8/Pz8/Pz8+Pj4/Pz8/Pz8/Pz8/Pz9AQEA/Pz+fdCaPAAAAJnRSTlMACQoNDjM4OTo7PEFCQ0RFS6ytsbS1tru8vcTFxu7x8vX19vf4+C5yomAAAAJESURBVHgBvdzLTsJAGEfxr4C2KBcVkQsIDsK8/yPaqIsPzVlyzrKrX/5p0kkXEz81L23otc9NpIbbWia2YVLqdnhlqFlhGWpSDHe1aopsSIpRb8gK0dC3G30b9rVmhWZIimTICsvQtx/FsuYOrWHoDjX3Gu31gzJxdki934WrAIOsAIOsAIOiAMPhPsJTgKGN0BVsYIVsYIVpYIVpYIVpYIVpYIVpYIVpYIVpYIVlAIVgEBRs8BRs8BRs8BRs8BRs8BRs8BRs8BRTNmgKNngKNngKNngKNngKNhiKGxgiOlZoBlaYBlaYBlaYBlaYBlaYBlaYBlaYBlZIBlBMfQMrVAMr2KAqBENSHFHhGEABhi5CV6gGUKgGUKgGUKgGUFwuqgEUvoEVsoEVpoEUpgEUggF+gKTKY+h1fxSlC7/Z+RrxOQ3fcEoAPPHZBlaYBlaYBlaYBlZYBlYIhvLBCstw7PgM7hkiWOEZWGEaWGEaWGEaIsakEAysmHkGVpxmvoEVqoEVpoEVpoEVpoEVpoEVpoEVkoEVgkFQsEFSsEFQsGEcoSvY4CnY4CnY4CnY4CnY4CnY4CnY4CnY4CnY4CnY4CnY4CnY4CnY4CnY4CnY4CnY4CnY4CnY4CnmbNAUT2c2WAo2eAo2eAo2eAo2eAo2eArNEPFACjZ4CjZ4CjZ4CjaIird/rBvFH6llNCvewdli1URWCIakSIZesUaDoFg36dKFWk9zCZDei3TtwmCj7pC22AwikiIZPEU29IpFNliKxa/hC9DFITjQPYhcAAAAAElFTkSuQmCC);
+	background-color: rgba(255,255,255,0.8);
+	background-size: 50%;
+	background-repeat: no-repeat;
+	background-position: 50%;
+	width: 2.7em;
+	height: 2.7em;
+	text-align: center;
+	overflow: hidden;
+	color: #a33;
+	z-index: 2147483642;
+}
+
+.ath-container.ath-icon:before {
+	position: absolute;
+	top: 0;
+	right: 0;
+	margin: 0;
+	float: none;
+}
+
+.ath-mandatory .ath-container:before {
+	display: none;
+}
+
+.ath-container.ath-android:before {
+	float: left;
+	margin: -0.7em 0.5em 0 -0.6em;
+}
+
+.ath-container.ath-android.ath-icon:before {
+	position: absolute;
+	right: auto;
+	left: 0;
+	margin: 0;
+	float: none;
+}
+
+
+/* applied only if the application icon is shown */
+.ath-container.ath-icon {
+
+}
+
+.ath-action-icon {
+	display: inline-block;
+	vertical-align: middle;
+	background-position: 50%;
+	background-repeat: no-repeat;
+	text-indent: -9999em;
+	overflow: hidden;
+}
+
+.ath-ios7 .ath-action-icon,
+.ath-ios8 .ath-action-icon,
+.ath-ios9 .ath-action-icon{
+	width: 1.6em;
+	height: 1.6em;
+	background-image:url(data:image/png;base64,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);
+	margin-top: -0.3em;
+	background-size: auto 100%;
+}
+
+.ath-ios6 .ath-action-icon {
+	width: 1.8em;
+	height: 1.8em;
+	background-image:url(data:image/png;base64,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);
+	margin-bottom: 0.4em;
+	background-size: 100% auto;
+}
+
+.ath-android .ath-action-icon {
+	width: 1.4em;
+	height: 1.5em;
+	background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAMAAABg3Am1AAAANlBMVEVmZmb///9mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZW6fJrAAAAEXRSTlMAAAYHG21ub8fLz9DR8/T4+RrZ9owAAAB3SURBVHja7dNLDoAgDATQWv4gKve/rEajJOJiWLgg6WzpSyB0aHqHiNj6nL1lovb4C+hYzkSNAT7mryQFAVOeGAj4CjwEtgrWXpD/uZKtwEJApXt+Vn0flzRhgNiFZQkOXY0aADQZCOCPlsZJ46Rx0jhp3IiN2wGDHhxtldrlwQAAAABJRU5ErkJggg==);
+	background-size: 100% auto;
+}
+
+.ath-container p {
+	margin: 0;
+	padding: 0;
+	position: relative;
+	z-index: 2147483642;
+	text-shadow: 0 0.1em 0 #fff;
+	font-size: 1.1em;
+}
+
+.ath-ios.ath-phone:after {
+	content: '';
+	background: #eee;
+	position: absolute;
+	width: 2em;
+	height: 2em;
+	bottom: -0.9em;
+	left: 50%;
+	margin-left: -1em;
+	-webkit-transform: scaleX(0.9) rotate(45deg);
+	transform: scaleX(0.9) rotate(45deg);
+	box-shadow: 0.2em 0.2em 0 #d1d1d1;
+}
+
+.ath-ios.ath-tablet:after {
+	content: '';
+	background: #eee;
+	position: absolute;
+	width: 2em;
+	height: 2em;
+	top: -0.9em;
+	left: 50%;
+	margin-left: -1em;
+	-webkit-transform: scaleX(0.9) rotate(45deg);
+	transform: scaleX(0.9) rotate(45deg);
+	z-index: 2147483641;
+}
+
+.ath-application-icon {
+	position: relative;
+	padding: 0;
+	border: 0;
+	margin: 0 auto 0.2em auto;
+	height: 6em;
+	width: 6em;
+	z-index: 2147483642;
+}
+
+.ath-container.ath-ios .ath-application-icon {
+	border-radius: 1em;
+	box-shadow: 0 0.2em 0.4em rgba(0,0,0,0.3),
+		inset 0 0.07em 0 rgba(255,255,255,0.5);
+	margin: 0 auto 0.4em auto;
+}
+
+@media only screen and (orientation: landscape) {
+	.ath-container.ath-phone {
+		width: 24em;
+	}
+
+	.ath-android.ath-phone {
+		margin-left: -12em;
+	}
+
+	.ath-ios.ath-phone {
+		margin-left: -12em;
+	}
+
+	.ath-ios6:after {
+		left: 39%;
+	}
+
+	.ath-ios8.ath-phone {
+		left: auto;
+		bottom: auto;
+		right: 0.4em;
+		top: 1.8em;
+	}
+
+	.ath-ios8.ath-phone:after {
+		bottom: auto;
+		top: -0.9em;
+		left: 68%;
+		z-index: 2147483641;
+		box-shadow: none;
+	}
+}

lib/addtohomescreen.js

@@ -0,0 +1,725 @@
+/* Add to Homescreen v3.2.2 ~ (c) 2015 Matteo Spinelli ~ @license: http://cubiq.org/license */
+(function (window, document) {
+/*
+       _   _ _____     _____
+ ___ _| |_| |_   _|___|  |  |___ _____ ___ ___ ___ ___ ___ ___ ___
+| .'| . | . | | | | . |     | . |     | -_|_ -|  _|  _| -_| -_|   |
+|__,|___|___| |_| |___|__|__|___|_|_|_|___|___|___|_| |___|___|_|_|
+                              by Matteo Spinelli ~ http://cubiq.org
+*/
+
+// Check for addEventListener browser support (prevent errors in IE<9)
+var _eventListener = 'addEventListener' in window;
+
+// Check if document is loaded, needed by autostart
+var _DOMReady = false;
+if ( document.readyState === 'complete' ) {
+	_DOMReady = true;
+} else if ( _eventListener ) {
+	window.addEventListener('load', loaded, false);
+}
+
+function loaded () {
+	window.removeEventListener('load', loaded, false);
+	_DOMReady = true;
+}
+
+// regex used to detect if app has been added to the homescreen
+var _reSmartURL = /\/ath(\/)?$/;
+var _reQueryString = /([\?&]ath=[^&]*$|&ath=[^&]*(&))/;
+
+// singleton
+var _instance;
+function ath (options) {
+	_instance = _instance || new ath.Class(options);
+
+	return _instance;
+}
+
+// message in all supported languages
+ath.intl = {
+	de_de: {
+		ios: 'Um diese Web-App zum Home-Bildschirm hinzuzufügen, tippen Sie auf %icon und dann <strong>Zum Home-Bildschirm</strong>.',
+		android: 'Um diese Web-App zum Home-Bildschirm hinzuzufügen, öffnen Sie das Menü und tippen dann auf <strong>Zum Startbildschirm hinzufügen</strong>. <small>Wenn Ihr Gerät eine Menütaste hat, lässt sich das Browsermenü über diese öffnen. Ansonsten tippen Sie auf %icon.</small>'
+	},
+
+	da_dk: {
+		ios: 'For at tilføje denne web app til hjemmeskærmen: Tryk %icon og derefter <strong>Føj til hjemmeskærm</strong>.',
+		android: 'For at tilføje denne web app til hjemmeskærmen, åbn browser egenskaber menuen og tryk på <strong>Føj til hjemmeskærm</strong>. <small>Denne menu kan tilgås ved at trykke på menu knappen, hvis din enhed har en, eller ved at trykke på det øverste højre menu ikon %icon.</small>'
+	},
+
+	en_us: {
+		ios: 'To add this web app to the home screen: tap %icon and then <strong>Add to Home Screen</strong>.',
+		android: 'To add this web app to the home screen open the browser option menu and tap on <strong>Add to homescreen</strong>. <small>The menu can be accessed by pressing the menu hardware button if your device has one, or by tapping the top right menu icon %icon.</small>'
+	},
+
+	es_es: {
+		ios: 'Para añadir esta aplicación web a la pantalla de inicio: pulsa %icon y selecciona <strong>Añadir a pantalla de inicio</strong>.',
+		android: 'Para añadir esta aplicación web a la pantalla de inicio, abre las opciones y pulsa <strong>Añadir a pantalla inicio</strong>. <small>El menú se puede acceder pulsando el botón táctil en caso de tenerlo, o bien el icono de la parte superior derecha de la pantalla %icon.</small>'
+	},
+
+	fi_fi: {
+		ios: 'Liitä tämä sovellus kotivalikkoon: klikkaa %icon ja tämän jälkeen <strong>Lisää kotivalikkoon</strong>.',
+		android: 'Lisätäksesi tämän sovelluksen aloitusnäytölle, avaa selaimen valikko ja klikkaa tähti -ikonia tai <strong>Lisää aloitusnäytölle tekstiä</strong>. <small>Valikkoon pääsee myös painamalla menuvalikkoa, jos laitteessasi on sellainen tai koskettamalla oikealla yläkulmassa menu ikonia %icon.</small>'
+	},
+
+	fr_fr: {
+		ios: 'Pour ajouter cette application web sur l\'écran d\'accueil : Appuyez %icon et sélectionnez <strong>Ajouter sur l\'écran d\'accueil</strong>.',
+		android: 'Pour ajouter cette application web sur l\'écran d\'accueil : Appuyez sur le bouton "menu", puis sur <strong>Ajouter sur l\'écran d\'accueil</strong>. <small>Le menu peut-être accessible en appyant sur le bouton "menu" du téléphone s\'il en possède un <i class="fa fa-bars"></i>. Sinon, il se trouve probablement dans la coin supérieur droit du navigateur %icon.</small>'
+	},
+
+	he_il: {
+		ios: '<span dir="rtl">להוספת האפליקציה למסך הבית: ללחוץ על %icon ואז <strong>הוסף למסך הבית</strong>.</span>',
+		android: 'To add this web app to the home screen open the browser option menu and tap on <strong>Add to homescreen</strong>. <small>The menu can be accessed by pressing the menu hardware button if your device has one, or by tapping the top right menu icon %icon.</small>'
+	},
+
+	hu_hu: {
+		ios: 'Ha hozzá szeretné adni ezt az alkalmazást a kezdőképernyőjéhez, érintse meg a következő ikont: %icon , majd a <strong>Hozzáadás a kezdőképernyőhöz</strong> menüpontot.',
+		android: 'Ha hozzá szeretné adni ezt az alkalmazást a kezdőképernyőjéhez, a böngésző menüjében kattintson a <strong>Hozzáadás a kezdőképernyőhöz</strong> menüpontra. <small>A böngésző menüjét a következő ikon megérintésével tudja megnyitni: %icon.</small>'
+	},
+
+	it_it: {
+		ios: 'Per aggiungere questa web app alla schermata iniziale: premi %icon e poi <strong>Aggiungi a Home</strong>.',
+		android: 'Per aggiungere questa web app alla schermata iniziale, apri il menu opzioni del browser e premi su <strong>Aggiungi alla homescreen</strong>. <small>Puoi accedere al menu premendo il pulsante hardware delle opzioni se la tua device ne ha uno, oppure premendo l\'icona %icon in alto a destra.</small>'
+	},
+
+	ja_jp: {
+		ios: 'このウェプアプリをホーム画面に追加するために%iconを押して<strong>ホーム画面に追加</strong>。',
+		android: 'To add this web app to the home screen open the browser option menu and tap on <strong>Add to homescreen</strong>. <small>The menu can be accessed by pressing the menu hardware button if your device has one, or by tapping the top right menu icon %icon.</small>'
+ 	},
+
+	ko_kr: {
+		ios: '홈 화면에 바로가기 생성: %icon 을 클릭한 후 <strong>홈 화면에 추가</strong>.',
+		android: '브라우저 옵션 메뉴의 <string>홈 화면에 추가</string>를 클릭하여 홈화면에 바로가기를 생성할 수 있습니다. <small>옵션 메뉴는 장치의 메뉴 버튼을 누르거나 오른쪽 상단의 메뉴 아이콘 %icon을 클릭하여 접근할 수 있습니다.</small>'
+	},
+
+	nb_no: {
+		ios: 'For å installere denne appen på hjem-skjermen: trykk på %icon og deretter <strong>Legg til på Hjem-skjerm</strong>.',
+		android: 'For å legge til denne webappen på startsiden åpner en nettlesermenyen og velger <strong>Legg til på startsiden</strong>. <small>Menyen åpnes ved å trykke på den fysiske menyknappen hvis enheten har det, eller ved å trykke på menyikonet øverst til høyre %icon.</small>'
+	},
+
+	pt_br: {
+		ios: 'Para adicionar este app à tela de início: clique %icon e então <strong>Tela de início</strong>.',
+		android: 'To add this web app to the home screen open the browser option menu and tap on <strong>Add to homescreen</strong>. <small>The menu can be accessed by pressing the menu hardware button if your device has one, or by tapping the top right menu icon %icon.</small>'
+	},
+
+	pt_pt: {
+		ios: 'Para adicionar esta app ao ecrã principal: clique %icon e depois <strong>Ecrã principal</strong>.',
+		android: 'To add this web app to the home screen open the browser option menu and tap on <strong>Add to homescreen</strong>. <small>The menu can be accessed by pressing the menu hardware button if your device has one, or by tapping the top right menu icon %icon.</small>'
+	},
+
+	nl_nl: {
+		ios: 'Om deze webapp op je telefoon te installeren, klik op %icon en dan <strong>Zet in beginscherm</strong>.',
+		android: 'To add this web app to the home screen open the browser option menu and tap on <strong>Add to homescreen</strong>. <small>The menu can be accessed by pressing the menu hardware button if your device has one, or by tapping the top right menu icon %icon.</small>'
+	},
+
+	ru_ru: {
+		ios: 'Чтобы добавить этот сайт на свой домашний экран, нажмите на иконку %icon и затем <strong>На экран "Домой"</strong>.',
+		android: 'Чтобы добавить сайт на свой домашний экран, откройте меню браузера и нажмите на <strong>Добавить на главный экран</strong>. <small>Меню можно вызвать, нажав на кнопку меню вашего телефона, если она есть. Или найдите иконку сверху справа %icon[иконка].</small>'
+	},
+
+	sv_se: {
+		ios: 'För att lägga till denna webbapplikation på hemskärmen: tryck på %icon och därefter <strong>Lägg till på hemskärmen</strong>.',
+		android: 'För att lägga till den här webbappen på hemskärmen öppnar du webbläsarens alternativ-meny och väljer <strong>Lägg till på startskärmen</strong>. <small>Man hittar menyn genom att trycka på hårdvaruknappen om din enhet har en sådan, eller genom att trycka på menyikonen högst upp till höger %icon.</small>'
+	},
+
+	zh_cn: {
+		ios: '如要把应用程序加至主屏幕,请点击%icon, 然后<strong>添加到主屏幕</strong>',
+		android: 'To add this web app to the home screen open the browser option menu and tap on <strong>Add to homescreen</strong>. <small>The menu can be accessed by pressing the menu hardware button if your device has one, or by tapping the top right menu icon %icon.</small>'
+	},
+
+	zh_tw: {
+		ios: '如要把應用程式加至主屏幕, 請點擊%icon, 然後<strong>加至主屏幕</strong>.',
+		android: 'To add this web app to the home screen open the browser option menu and tap on <strong>Add to homescreen</strong>. <small>The menu can be accessed by pressing the menu hardware button if your device has one, or by tapping the top right menu icon %icon.</small>'
+	}
+};
+
+// Add 2 characters language support (Android mostly)
+for ( var lang in ath.intl ) {
+	ath.intl[lang.substr(0, 2)] = ath.intl[lang];
+}
+
+// default options
+ath.defaults = {
+	appID: 'org.cubiq.addtohome',		// local storage name (no need to change)
+	fontSize: 15,				// base font size, used to properly resize the popup based on viewport scale factor
+	debug: false,				// override browser checks
+	logging: false,				// log reasons for showing or not showing to js console; defaults to true when debug is true
+	modal: false,				// prevent further actions until the message is closed
+	mandatory: false,			// you can't proceed if you don't add the app to the homescreen
+	autostart: true,			// show the message automatically
+	skipFirstVisit: false,		// show only to returning visitors (ie: skip the first time you visit)
+	startDelay: 1,				// display the message after that many seconds from page load
+	lifespan: 15,				// life of the message in seconds
+	displayPace: 1440,			// minutes before the message is shown again (0: display every time, default 24 hours)
+	maxDisplayCount: 0,			// absolute maximum number of times the message will be shown to the user (0: no limit)
+	icon: true,					// add touch icon to the message
+	message: '',				// the message can be customized
+	validLocation: [],			// list of pages where the message will be shown (array of regexes)
+	onInit: null,				// executed on instance creation
+	onShow: null,				// executed when the message is shown
+	onRemove: null,				// executed when the message is removed
+	onAdd: null,				// when the application is launched the first time from the homescreen (guesstimate)
+	onPrivate: null,			// executed if user is in private mode
+	privateModeOverride: false,	// show the message even in private mode (very rude)
+	detectHomescreen: false		// try to detect if the site has been added to the homescreen (false | true | 'hash' | 'queryString' | 'smartURL')
+};
+
+// browser info and capability
+var _ua = window.navigator.userAgent;
+
+var _nav = window.navigator;
+_extend(ath, {
+	hasToken: document.location.hash == '#ath' || _reSmartURL.test(document.location.href) || _reQueryString.test(document.location.search),
+	isRetina: window.devicePixelRatio && window.devicePixelRatio > 1,
+	isIDevice: (/iphone|ipod|ipad/i).test(_ua),
+	isMobileChrome: _ua.indexOf('Android') > -1 && (/Chrome\/[.0-9]*/).test(_ua) && _ua.indexOf("Version") == -1,
+	isMobileIE: _ua.indexOf('Windows Phone') > -1,
+	language: _nav.language && _nav.language.toLowerCase().replace('-', '_') || ''
+});
+
+// falls back to en_us if language is unsupported
+ath.language = ath.language && ath.language in ath.intl ? ath.language : 'en_us';
+
+ath.isMobileSafari = ath.isIDevice && _ua.indexOf('Safari') > -1 && _ua.indexOf('CriOS') < 0;
+ath.OS = ath.isIDevice ? 'ios' : ath.isMobileChrome ? 'android' : ath.isMobileIE ? 'windows' : 'unsupported';
+
+ath.OSVersion = _ua.match(/(OS|Android) (\d+[_\.]\d+)/);
+ath.OSVersion = ath.OSVersion && ath.OSVersion[2] ? +ath.OSVersion[2].replace('_', '.') : 0;
+
+ath.isStandalone = 'standalone' in window.navigator && window.navigator.standalone;
+ath.isTablet = (ath.isMobileSafari && _ua.indexOf('iPad') > -1) || (ath.isMobileChrome && _ua.indexOf('Mobile') < 0);
+
+ath.isCompatible = (ath.isMobileSafari && ath.OSVersion >= 6) || ath.isMobileChrome;	// TODO: add winphone
+
+var _defaultSession = {
+	lastDisplayTime: 0,			// last time we displayed the message
+	returningVisitor: false,	// is this the first time you visit
+	displayCount: 0,			// number of times the message has been shown
+	optedout: false,			// has the user opted out
+	added: false				// has been actually added to the homescreen
+};
+
+ath.removeSession = function (appID) {
+	try {
+		if (!localStorage) {
+			throw new Error('localStorage is not defined');
+		}
+
+		localStorage.removeItem(appID || ath.defaults.appID);
+	} catch (e) {
+		// we are most likely in private mode
+	}
+};
+
+ath.doLog = function (logStr) {
+	if ( this.options.logging ) {
+		console.log(logStr);
+	}
+};
+
+ath.Class = function (options) {
+	// class methods
+	this.doLog = ath.doLog;
+
+	// merge default options with user config
+	this.options = _extend({}, ath.defaults);
+	_extend(this.options, options);
+	// override defaults that are dependent on each other
+	if ( options && options.debug && (typeof options.logging === "undefined") ) {
+		this.options.logging = true;
+	}
+
+	// IE<9 so exit (I hate you, really)
+	if ( !_eventListener ) {
+		return;
+	}
+
+	// normalize some options
+	this.options.mandatory = this.options.mandatory && ( 'standalone' in window.navigator || this.options.debug );
+	this.options.modal = this.options.modal || this.options.mandatory;
+	if ( this.options.mandatory ) {
+		this.options.startDelay = -0.5;		// make the popup hasty
+	}
+	this.options.detectHomescreen = this.options.detectHomescreen === true ? 'hash' : this.options.detectHomescreen;
+
+	// setup the debug environment
+	if ( this.options.debug ) {
+		ath.isCompatible = true;
+		ath.OS = typeof this.options.debug == 'string' ? this.options.debug : ath.OS == 'unsupported' ? 'android' : ath.OS;
+		ath.OSVersion = ath.OS == 'ios' ? '8' : '4';
+	}
+
+	// the element the message will be appended to
+	this.container = document.documentElement;
+
+	// load session
+	this.session = this.getItem(this.options.appID);
+	this.session = this.session ? JSON.parse(this.session) : undefined;
+
+	// user most likely came from a direct link containing our token, we don't need it and we remove it
+	if ( ath.hasToken && ( !ath.isCompatible || !this.session ) ) {
+		ath.hasToken = false;
+		_removeToken();
+	}
+
+	// the device is not supported
+	if ( !ath.isCompatible ) {
+ 		this.doLog("Add to homescreen: not displaying callout because device not supported");
+		return;
+	}
+
+	this.session = this.session || _defaultSession;
+
+	// check if we can use the local storage
+	try {
+		if (!localStorage) {
+			throw new Error('localStorage is not defined');
+		}
+
+		localStorage.setItem(this.options.appID, JSON.stringify(this.session));
+		ath.hasLocalStorage = true;
+	} catch (e) {
+		// we are most likely in private mode
+		ath.hasLocalStorage = false;
+
+		if ( this.options.onPrivate ) {
+			this.options.onPrivate.call(this);
+		}
+	}
+
+	// check if this is a valid location
+	var isValidLocation = !this.options.validLocation.length;
+	for ( var i = this.options.validLocation.length; i--; ) {
+		if ( this.options.validLocation[i].test(document.location.href) ) {
+			isValidLocation = true;
+			break;
+		}
+	}
+
+	// check compatibility with old versions of add to homescreen. Opt-out if an old session is found
+	if ( this.getItem('addToHome') ) {
+		this.optOut();
+	}
+
+	// critical errors:
+	if ( this.session.optedout ) {
+		this.doLog("Add to homescreen: not displaying callout because user opted out");
+		return;
+	}
+	if ( this.session.added ) {
+		this.doLog("Add to homescreen: not displaying callout because already added to the homescreen");
+		return;
+	}
+	if ( !isValidLocation ) {
+		this.doLog("Add to homescreen: not displaying callout because not a valid location");
+		return;
+	}
+
+	// check if the app is in stand alone mode
+	if ( ath.isStandalone ) {
+		// execute the onAdd event if we haven't already
+		if ( !this.session.added ) {
+			this.session.added = true;
+			this.updateSession();
+
+			if ( this.options.onAdd && ath.hasLocalStorage ) {	// double check on localstorage to avoid multiple calls to the custom event
+				this.options.onAdd.call(this);
+			}
+		}
+
+		this.doLog("Add to homescreen: not displaying callout because in standalone mode");
+		return;
+	}
+
+	// (try to) check if the page has been added to the homescreen
+	if ( this.options.detectHomescreen ) {
+		// the URL has the token, we are likely coming from the homescreen
+		if ( ath.hasToken ) {
+			_removeToken();		// we don't actually need the token anymore, we remove it to prevent redistribution
+
+			// this is called the first time the user opens the app from the homescreen
+			if ( !this.session.added ) {
+				this.session.added = true;
+				this.updateSession();
+
+				if ( this.options.onAdd && ath.hasLocalStorage ) {	// double check on localstorage to avoid multiple calls to the custom event
+					this.options.onAdd.call(this);
+				}
+			}
+
+			this.doLog("Add to homescreen: not displaying callout because URL has token, so we are likely coming from homescreen");
+			return;
+		}
+
+		// URL doesn't have the token, so add it
+		if ( this.options.detectHomescreen == 'hash' ) {
+			history.replaceState('', window.document.title, document.location.href + '#ath');
+		} else if ( this.options.detectHomescreen == 'smartURL' ) {
+			history.replaceState('', window.document.title, document.location.href.replace(/(\/)?$/, '/ath$1'));
+		} else {
+			history.replaceState('', window.document.title, document.location.href + (document.location.search ? '&' : '?' ) + 'ath=');
+		}
+	}
+
+	// check if this is a returning visitor
+	if ( !this.session.returningVisitor ) {
+		this.session.returningVisitor = true;
+		this.updateSession();
+
+		// we do not show the message if this is your first visit
+		if ( this.options.skipFirstVisit ) {
+			this.doLog("Add to homescreen: not displaying callout because skipping first visit");
+			return;
+		}
+	}
+
+	// we do no show the message in private mode
+	if ( !this.options.privateModeOverride && !ath.hasLocalStorage ) {
+		this.doLog("Add to homescreen: not displaying callout because browser is in private mode");
+		return;
+	}
+
+	// all checks passed, ready to display
+	this.ready = true;
+
+	if ( this.options.onInit ) {
+		this.options.onInit.call(this);
+	}
+
+	if ( this.options.autostart ) {
+		this.doLog("Add to homescreen: autostart displaying callout");
+		this.show();
+	}
+};
+
+ath.Class.prototype = {
+	// event type to method conversion
+	events: {
+		load: '_delayedShow',
+		error: '_delayedShow',
+		orientationchange: 'resize',
+		resize: 'resize',
+		scroll: 'resize',
+		click: 'remove',
+		touchmove: '_preventDefault',
+		transitionend: '_removeElements',
+		webkitTransitionEnd: '_removeElements',
+		MSTransitionEnd: '_removeElements'
+	},
+
+	handleEvent: function (e) {
+		var type = this.events[e.type];
+		if ( type ) {
+			this[type](e);
+		}
+	},
+
+	show: function (force) {
+		// in autostart mode wait for the document to be ready
+		if ( this.options.autostart && !_DOMReady ) {
+			setTimeout(this.show.bind(this), 50);
+			// we are not displaying callout because DOM not ready, but don't log that because
+			// it would log too frequently
+			return;
+		}
+
+		// message already on screen
+		if ( this.shown ) {
+			this.doLog("Add to homescreen: not displaying callout because already shown on screen");
+			return;
+		}
+
+		var now = Date.now();
+		var lastDisplayTime = this.session.lastDisplayTime;
+
+		if ( force !== true ) {
+			// this is needed if autostart is disabled and you programmatically call the show() method
+			if ( !this.ready ) {
+				this.doLog("Add to homescreen: not displaying callout because not ready");
+				return;
+			}
+
+			// we obey the display pace (prevent the message to popup too often)
+			if ( now - lastDisplayTime < this.options.displayPace * 60000 ) {
+				this.doLog("Add to homescreen: not displaying callout because displayed recently");
+				return;
+			}
+
+			// obey the maximum number of display count
+			if ( this.options.maxDisplayCount && this.session.displayCount >= this.options.maxDisplayCount ) {
+				this.doLog("Add to homescreen: not displaying callout because displayed too many times already");
+				return;
+			}
+		}
+
+		this.shown = true;
+
+		// increment the display count
+		this.session.lastDisplayTime = now;
+		this.session.displayCount++;
+		this.updateSession();
+
+		// try to get the highest resolution application icon
+		if ( !this.applicationIcon ) {
+			if ( ath.OS == 'ios' ) {
+				this.applicationIcon = document.querySelector('head link[rel^=apple-touch-icon][sizes="152x152"],head link[rel^=apple-touch-icon][sizes="144x144"],head link[rel^=apple-touch-icon][sizes="120x120"],head link[rel^=apple-touch-icon][sizes="114x114"],head link[rel^=apple-touch-icon]');
+			} else {
+				this.applicationIcon = document.querySelector('head link[rel^="shortcut icon"][sizes="196x196"],head link[rel^=apple-touch-icon]');
+			}
+		}
+
+		var message = '';
+
+		if ( typeof this.options.message == 'object' && ath.language in this.options.message ) {		// use custom language message
+			message = this.options.message[ath.language][ath.OS];
+		} else if ( typeof this.options.message == 'object' && ath.OS in this.options.message ) {		// use custom os message
+			message = this.options.message[ath.OS];
+		} else if ( this.options.message in ath.intl ) {				// you can force the locale
+			message = ath.intl[this.options.message][ath.OS];
+		} else if ( this.options.message !== '' ) {						// use a custom message
+			message = this.options.message;
+		} else if ( ath.OS in ath.intl[ath.language] ) {				// otherwise we use our message
+			message = ath.intl[ath.language][ath.OS];
+		}
+
+		// add the action icon
+		message = '<p>' + message.replace(/%icon(?:\[([^\]]+)\])?/gi, function(matches, group1) {
+			return '<span class="ath-action-icon">' + (!!group1 ? group1 : 'icon') + '</span>';
+		}); + '</p>';
+
+		// create the message container
+		this.viewport = document.createElement('div');
+		this.viewport.className = 'ath-viewport';
+		if ( this.options.modal ) {
+			this.viewport.className += ' ath-modal';
+		}
+		if ( this.options.mandatory ) {
+			this.viewport.className += ' ath-mandatory';
+		}
+		this.viewport.style.position = 'absolute';
+
+		// create the actual message element
+		this.element = document.createElement('div');
+		this.element.className = 'ath-container ath-' + ath.OS + ' ath-' + ath.OS + (ath.OSVersion + '').substr(0,1) + ' ath-' + (ath.isTablet ? 'tablet' : 'phone');
+		this.element.style.cssText = '-webkit-transition-property:-webkit-transform,opacity;-webkit-transition-duration:0s;-webkit-transition-timing-function:ease-out;transition-property:transform,opacity;transition-duration:0s;transition-timing-function:ease-out;';
+		this.element.style.webkitTransform = 'translate3d(0,-' + window.innerHeight + 'px,0)';
+		this.element.style.transform = 'translate3d(0,-' + window.innerHeight + 'px,0)';
+
+		// add the application icon
+		if ( this.options.icon && this.applicationIcon ) {
+			this.element.className += ' ath-icon';
+			this.img = document.createElement('img');
+			this.img.className = 'ath-application-icon';
+			this.img.addEventListener('load', this, false);
+			this.img.addEventListener('error', this, false);
+
+			this.img.src = this.applicationIcon.href;
+			this.element.appendChild(this.img);
+		}
+
+		this.element.innerHTML += message;
+
+		// we are not ready to show, place the message out of sight
+		this.viewport.style.left = '-99999em';
+
+		// attach all elements to the DOM
+		this.viewport.appendChild(this.element);
+		this.container.appendChild(this.viewport);
+
+		// if we don't have to wait for an image to load, show the message right away
+		if ( this.img ) {
+			this.doLog("Add to homescreen: not displaying callout because waiting for img to load");
+		} else {
+			this._delayedShow();
+		}
+	},
+
+	_delayedShow: function (e) {
+		setTimeout(this._show.bind(this), this.options.startDelay * 1000 + 500);
+	},
+
+	_show: function () {
+		var that = this;
+
+		// update the viewport size and orientation
+		this.updateViewport();
+
+		// reposition/resize the message on orientation change
+		window.addEventListener('resize', this, false);
+		window.addEventListener('scroll', this, false);
+		window.addEventListener('orientationchange', this, false);
+
+		if ( this.options.modal ) {
+			// lock any other interaction
+			document.addEventListener('touchmove', this, true);
+		}
+
+		// Enable closing after 1 second
+		if ( !this.options.mandatory ) {
+			setTimeout(function () {
+				that.element.addEventListener('click', that, true);
+			}, 1000);
+		}
+
+		// kick the animation
+		setTimeout(function () {
+			that.element.style.webkitTransitionDuration = '1.2s';
+			that.element.style.transitionDuration = '1.2s';
+			that.element.style.webkitTransform = 'translate3d(0,0,0)';
+			that.element.style.transform = 'translate3d(0,0,0)';
+		}, 0);
+
+		// set the destroy timer
+		if ( this.options.lifespan ) {
+			this.removeTimer = setTimeout(this.remove.bind(this), this.options.lifespan * 1000);
+		}
+
+		// fire the custom onShow event
+		if ( this.options.onShow ) {
+			this.options.onShow.call(this);
+		}
+	},
+
+	remove: function () {
+		clearTimeout(this.removeTimer);
+
+		// clear up the event listeners
+		if ( this.img ) {
+			this.img.removeEventListener('load', this, false);
+			this.img.removeEventListener('error', this, false);
+		}
+
+		window.removeEventListener('resize', this, false);
+		window.removeEventListener('scroll', this, false);
+		window.removeEventListener('orientationchange', this, false);
+		document.removeEventListener('touchmove', this, true);
+		this.element.removeEventListener('click', this, true);
+
+		// remove the message element on transition end
+		this.element.addEventListener('transitionend', this, false);
+		this.element.addEventListener('webkitTransitionEnd', this, false);
+		this.element.addEventListener('MSTransitionEnd', this, false);
+
+		// start the fade out animation
+		this.element.style.webkitTransitionDuration = '0.3s';
+		this.element.style.opacity = '0';
+	},
+
+	_removeElements: function () {
+		this.element.removeEventListener('transitionend', this, false);
+		this.element.removeEventListener('webkitTransitionEnd', this, false);
+		this.element.removeEventListener('MSTransitionEnd', this, false);
+
+		// remove the message from the DOM
+		this.container.removeChild(this.viewport);
+
+		this.shown = false;
+
+		// fire the custom onRemove event
+		if ( this.options.onRemove ) {
+			this.options.onRemove.call(this);
+		}
+	},
+
+	updateViewport: function () {
+		if ( !this.shown ) {
+			return;
+		}
+
+		this.viewport.style.width = window.innerWidth + 'px';
+		this.viewport.style.height = window.innerHeight + 'px';
+		this.viewport.style.left = window.scrollX + 'px';
+		this.viewport.style.top = window.scrollY + 'px';
+
+		var clientWidth = document.documentElement.clientWidth;
+
+		this.orientation = clientWidth > document.documentElement.clientHeight ? 'landscape' : 'portrait';
+
+		var screenWidth = ath.OS == 'ios' ? this.orientation == 'portrait' ? screen.width : screen.height : screen.width;
+		this.scale = screen.width > clientWidth ? 1 : screenWidth / window.innerWidth;
+
+		this.element.style.fontSize = this.options.fontSize / this.scale + 'px';
+	},
+
+	resize: function () {
+		clearTimeout(this.resizeTimer);
+		this.resizeTimer = setTimeout(this.updateViewport.bind(this), 100);
+	},
+
+	updateSession: function () {
+		if ( ath.hasLocalStorage === false ) {
+			return;
+		}
+
+        if (localStorage) {
+            localStorage.setItem(this.options.appID, JSON.stringify(this.session));
+        }
+	},
+
+	clearSession: function () {
+		this.session = _defaultSession;
+		this.updateSession();
+	},
+
+	getItem: function(item) {
+		try {
+			if (!localStorage) {
+				throw new Error('localStorage is not defined');
+			}
+
+			return localStorage.getItem(item);
+		} catch(e) {
+			// Preventing exception for some browsers when fetching localStorage key
+			ath.hasLocalStorage = false;
+		}
+	},
+
+	optOut: function () {
+		this.session.optedout = true;
+		this.updateSession();
+	},
+
+	optIn: function () {
+		this.session.optedout = false;
+		this.updateSession();
+	},
+
+	clearDisplayCount: function () {
+		this.session.displayCount = 0;
+		this.updateSession();
+	},
+
+	_preventDefault: function (e) {
+		e.preventDefault();
+		e.stopPropagation();
+	}
+};
+
+// utility
+function _extend (target, obj) {
+	for ( var i in obj ) {
+		target[i] = obj[i];
+	}
+
+	return target;
+}
+
+function _removeToken () {
+	if ( document.location.hash == '#ath' ) {
+		history.replaceState('', window.document.title, document.location.href.split('#')[0]);
+	}
+
+	if ( _reSmartURL.test(document.location.href) ) {
+		history.replaceState('', window.document.title, document.location.href.replace(_reSmartURL, '$1'));
+	}
+
+	if ( _reQueryString.test(document.location.search) ) {
+		history.replaceState('', window.document.title, document.location.href.replace(_reQueryString, '$2'));
+	}
+}
+
+// expose to the world
+window.addToHomescreen = ath;
+
+})(window, document);

lib/gh-fork-ribbon.css

@@ -0,0 +1,140 @@
+/*!
+ * "Fork me on GitHub" CSS ribbon v0.1.1 | MIT License
+ * https://github.com/simonwhitaker/github-fork-ribbon-css
+*/
+
+/* Left will inherit from right (so we don't need to duplicate code) */
+.github-fork-ribbon {
+  /* The right and left classes determine the side we attach our banner to */
+  position: absolute;
+
+  /* Add a bit of padding to give some substance outside the "stitching" */
+  padding: 2px 0;
+
+  /* Set the base colour */
+  background-color: #a00;
+
+  /* Set a gradient: transparent black at the top to almost-transparent black at the bottom */
+  background-image: -webkit-gradient(linear, left top, left bottom, from(rgba(0, 0, 0, 0)), to(rgba(0, 0, 0, 0.15)));
+  background-image: -webkit-linear-gradient(top, rgba(0, 0, 0, 0), rgba(0, 0, 0, 0.15));
+  background-image: -moz-linear-gradient(top, rgba(0, 0, 0, 0), rgba(0, 0, 0, 0.15));
+  background-image: -ms-linear-gradient(top, rgba(0, 0, 0, 0), rgba(0, 0, 0, 0.15));
+  background-image: -o-linear-gradient(top, rgba(0, 0, 0, 0), rgba(0, 0, 0, 0.15));
+  background-image: linear-gradient(to bottom, rgba(0, 0, 0, 0), rgba(0, 0, 0, 0.15));
+
+  /* Add a drop shadow */
+  -webkit-box-shadow: 0 2px 3px 0 rgba(0, 0, 0, 0.5);
+  -moz-box-shadow: 0 2px 3px 0 rgba(0, 0, 0, 0.5);
+  box-shadow: 0 2px 3px 0 rgba(0, 0, 0, 0.5);
+
+  /* Set the font */
+  font: 700 13px "Helvetica Neue", Helvetica, Arial, sans-serif;
+
+  z-index: 9999;
+  pointer-events: auto;
+}
+
+.github-fork-ribbon a,
+.github-fork-ribbon a:hover {
+  /* Set the text properties */
+  color: #fff;
+  text-decoration: none;
+  text-shadow: 0 -1px rgba(0, 0, 0, 0.5);
+  text-align: center;
+
+  /* Set the geometry. If you fiddle with these you'll also need
+     to tweak the top and right values in .github-fork-ribbon. */
+  width: 200px;
+  line-height: 20px;
+
+  /* Set the layout properties */
+  display: inline-block;
+  padding: 2px 0;
+
+  /* Add "stitching" effect */
+  border-width: 1px 0;
+  border-style: dotted;
+  border-color: #fff;
+  border-color: rgba(255, 255, 255, 0.7);
+}
+
+.github-fork-ribbon-wrapper {
+  width: 150px;
+  height: 150px;
+  position: absolute;
+  overflow: hidden;
+  top: 0;
+  z-index: 9999;
+  pointer-events: none;
+}
+
+.github-fork-ribbon-wrapper.fixed {
+  position: fixed;
+}
+
+.github-fork-ribbon-wrapper.left {
+  left: 0;
+}
+
+.github-fork-ribbon-wrapper.right {
+  right: 0;
+}
+
+.github-fork-ribbon-wrapper.left-bottom {
+  position: fixed;
+  top: inherit;
+  bottom: 0;
+  left: 0;
+}
+
+.github-fork-ribbon-wrapper.right-bottom {
+  position: fixed;
+  top: inherit;
+  bottom: 0;
+  right: 0;
+}
+
+.github-fork-ribbon-wrapper.right .github-fork-ribbon {
+  top: 42px;
+  right: -43px;
+
+  -webkit-transform: rotate(45deg);
+  -moz-transform: rotate(45deg);
+  -ms-transform: rotate(45deg);
+  -o-transform: rotate(45deg);
+  transform: rotate(45deg);
+}
+
+.github-fork-ribbon-wrapper.left .github-fork-ribbon {
+  top: 42px;
+  left: -43px;
+
+  -webkit-transform: rotate(-45deg);
+  -moz-transform: rotate(-45deg);
+  -ms-transform: rotate(-45deg);
+  -o-transform: rotate(-45deg);
+  transform: rotate(-45deg);
+}
+
+
+.github-fork-ribbon-wrapper.left-bottom .github-fork-ribbon {
+  top: 80px;
+  left: -43px;
+
+  -webkit-transform: rotate(45deg);
+  -moz-transform: rotate(45deg);
+  -ms-transform: rotate(45deg);
+  -o-transform: rotate(45deg);
+  transform: rotate(45deg);
+}
+
+.github-fork-ribbon-wrapper.right-bottom .github-fork-ribbon {
+  top: 80px;
+  right: -43px;
+
+  -webkit-transform: rotate(-45deg);
+  -moz-transform: rotate(-45deg);
+  -ms-transform: rotate(-45deg);
+  -o-transform: rotate(-45deg);
+  transform: rotate(-45deg);
+}

lib/lz-string.js

@@ -0,0 +1,665 @@
+// Copyright (c) 2013 Pieroxy <[email protected]>
+// This work is free. You can redistribute it and/or modify it
+// under the terms of the WTFPL, Version 2
+// For more information see LICENSE.txt or http://www.wtfpl.net/
+//
+// For more information, the home page:
+// http://pieroxy.net/blog/pages/lz-string/testing.html
+//
+// LZ-based compression algorithm, version 1.3.3
+var LZString = {
+  
+  
+  // private property
+  _keyStr : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
+  _f : String.fromCharCode,
+  
+  compressToBase64 : function (input) {
+    if (input == null) return "";
+    var output = "";
+    var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
+    var i = 0;
+    
+    input = LZString.compress(input);
+    
+    while (i < input.length*2) {
+      
+      if (i%2==0) {
+        chr1 = input.charCodeAt(i/2) >> 8;
+        chr2 = input.charCodeAt(i/2) & 255;
+        if (i/2+1 < input.length) 
+          chr3 = input.charCodeAt(i/2+1) >> 8;
+        else 
+          chr3 = NaN;
+      } else {
+        chr1 = input.charCodeAt((i-1)/2) & 255;
+        if ((i+1)/2 < input.length) {
+          chr2 = input.charCodeAt((i+1)/2) >> 8;
+          chr3 = input.charCodeAt((i+1)/2) & 255;
+        } else 
+          chr2=chr3=NaN;
+      }
+      i+=3;
+      
+      enc1 = chr1 >> 2;
+      enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+      enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+      enc4 = chr3 & 63;
+      
+      if (isNaN(chr2)) {
+        enc3 = enc4 = 64;
+      } else if (isNaN(chr3)) {
+        enc4 = 64;
+      }
+      
+      output = output +
+        LZString._keyStr.charAt(enc1) + LZString._keyStr.charAt(enc2) +
+          LZString._keyStr.charAt(enc3) + LZString._keyStr.charAt(enc4);
+      
+    }
+    
+    return output;
+  },
+  
+  decompressFromBase64 : function (input) {
+    if (input == null) return "";
+    var output = "",
+        ol = 0, 
+        output_,
+        chr1, chr2, chr3,
+        enc1, enc2, enc3, enc4,
+        i = 0, f=LZString._f;
+    
+    input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
+    
+    while (i < input.length) {
+      
+      enc1 = LZString._keyStr.indexOf(input.charAt(i++));
+      enc2 = LZString._keyStr.indexOf(input.charAt(i++));
+      enc3 = LZString._keyStr.indexOf(input.charAt(i++));
+      enc4 = LZString._keyStr.indexOf(input.charAt(i++));
+      
+      chr1 = (enc1 << 2) | (enc2 >> 4);
+      chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+      chr3 = ((enc3 & 3) << 6) | enc4;
+      
+      if (ol%2==0) {
+        output_ = chr1 << 8;
+        
+        if (enc3 != 64) {
+          output += f(output_ | chr2);
+        }
+        if (enc4 != 64) {
+          output_ = chr3 << 8;
+        }
+      } else {
+        output = output + f(output_ | chr1);
+        
+        if (enc3 != 64) {
+          output_ = chr2 << 8;
+        }
+        if (enc4 != 64) {
+          output += f(output_ | chr3);
+        }
+      }
+      ol+=3;
+    }
+    
+    return LZString.decompress(output);
+    
+  },
+
+  compressToUTF16 : function (input) {
+    if (input == null) return "";
+    var output = "",
+        i,c,
+        current,
+        status = 0,
+        f = LZString._f;
+    
+    input = LZString.compress(input);
+    
+    for (i=0 ; i<input.length ; i++) {
+      c = input.charCodeAt(i);
+      switch (status++) {
+        case 0:
+          output += f((c >> 1)+32);
+          current = (c & 1) << 14;
+          break;
+        case 1:
+          output += f((current + (c >> 2))+32);
+          current = (c & 3) << 13;
+          break;
+        case 2:
+          output += f((current + (c >> 3))+32);
+          current = (c & 7) << 12;
+          break;
+        case 3:
+          output += f((current + (c >> 4))+32);
+          current = (c & 15) << 11;
+          break;
+        case 4:
+          output += f((current + (c >> 5))+32);
+          current = (c & 31) << 10;
+          break;
+        case 5:
+          output += f((current + (c >> 6))+32);
+          current = (c & 63) << 9;
+          break;
+        case 6:
+          output += f((current + (c >> 7))+32);
+          current = (c & 127) << 8;
+          break;
+        case 7:
+          output += f((current + (c >> 8))+32);
+          current = (c & 255) << 7;
+          break;
+        case 8:
+          output += f((current + (c >> 9))+32);
+          current = (c & 511) << 6;
+          break;
+        case 9:
+          output += f((current + (c >> 10))+32);
+          current = (c & 1023) << 5;
+          break;
+        case 10:
+          output += f((current + (c >> 11))+32);
+          current = (c & 2047) << 4;
+          break;
+        case 11:
+          output += f((current + (c >> 12))+32);
+          current = (c & 4095) << 3;
+          break;
+        case 12:
+          output += f((current + (c >> 13))+32);
+          current = (c & 8191) << 2;
+          break;
+        case 13:
+          output += f((current + (c >> 14))+32);
+          current = (c & 16383) << 1;
+          break;
+        case 14:
+          output += f((current + (c >> 15))+32, (c & 32767)+32);
+          status = 0;
+          break;
+      }
+    }
+    
+    return output + f(current + 32);
+  },
+  
+
+  decompressFromUTF16 : function (input) {
+    if (input == null) return "";
+    var output = "",
+        current,c,
+        status=0,
+        i = 0,
+        f = LZString._f;
+    
+    while (i < input.length) {
+      c = input.charCodeAt(i) - 32;
+      
+      switch (status++) {
+        case 0:
+          current = c << 1;
+          break;
+        case 1:
+          output += f(current | (c >> 14));
+          current = (c&16383) << 2;
+          break;
+        case 2:
+          output += f(current | (c >> 13));
+          current = (c&8191) << 3;
+          break;
+        case 3:
+          output += f(current | (c >> 12));
+          current = (c&4095) << 4;
+          break;
+        case 4:
+          output += f(current | (c >> 11));
+          current = (c&2047) << 5;
+          break;
+        case 5:
+          output += f(current | (c >> 10));
+          current = (c&1023) << 6;
+          break;
+        case 6:
+          output += f(current | (c >> 9));
+          current = (c&511) << 7;
+          break;
+        case 7:
+          output += f(current | (c >> 8));
+          current = (c&255) << 8;
+          break;
+        case 8:
+          output += f(current | (c >> 7));
+          current = (c&127) << 9;
+          break;
+        case 9:
+          output += f(current | (c >> 6));
+          current = (c&63) << 10;
+          break;
+        case 10:
+          output += f(current | (c >> 5));
+          current = (c&31) << 11;
+          break;
+        case 11:
+          output += f(current | (c >> 4));
+          current = (c&15) << 12;
+          break;
+        case 12:
+          output += f(current | (c >> 3));
+          current = (c&7) << 13;
+          break;
+        case 13:
+          output += f(current | (c >> 2));
+          current = (c&3) << 14;
+          break;
+        case 14:
+          output += f(current | (c >> 1));
+          current = (c&1) << 15;
+          break;
+        case 15:
+          output += f(current | c);
+          status=0;
+          break;
+      }
+      
+      
+      i++;
+    }
+    
+    return LZString.decompress(output);
+    //return output;
+    
+  },
+
+
+  
+  compress: function (uncompressed) {
+    if (uncompressed == null) return "";
+    var i, value,
+        context_dictionary= {},
+        context_dictionaryToCreate= {},
+        context_c="",
+        context_wc="",
+        context_w="",
+        context_enlargeIn= 2, // Compensate for the first entry which should not count
+        context_dictSize= 3,
+        context_numBits= 2,
+        context_data_string="", 
+        context_data_val=0, 
+        context_data_position=0,
+        ii,
+        f=LZString._f;
+    
+    for (ii = 0; ii < uncompressed.length; ii += 1) {
+      context_c = uncompressed.charAt(ii);
+      if (!Object.prototype.hasOwnProperty.call(context_dictionary,context_c)) {
+        context_dictionary[context_c] = context_dictSize++;
+        context_dictionaryToCreate[context_c] = true;
+      }
+      
+      context_wc = context_w + context_c;
+      if (Object.prototype.hasOwnProperty.call(context_dictionary,context_wc)) {
+        context_w = context_wc;
+      } else {
+        if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate,context_w)) {
+          if (context_w.charCodeAt(0)<256) {
+            for (i=0 ; i<context_numBits ; i++) {
+              context_data_val = (context_data_val << 1);
+              if (context_data_position == 15) {
+                context_data_position = 0;
+                context_data_string += f(context_data_val);
+                context_data_val = 0;
+              } else {
+                context_data_position++;
+              }
+            }
+            value = context_w.charCodeAt(0);
+            for (i=0 ; i<8 ; i++) {
+              context_data_val = (context_data_val << 1) | (value&1);
+              if (context_data_position == 15) {
+                context_data_position = 0;
+                context_data_string += f(context_data_val);
+                context_data_val = 0;
+              } else {
+                context_data_position++;
+              }
+              value = value >> 1;
+            }
+          } else {
+            value = 1;
+            for (i=0 ; i<context_numBits ; i++) {
+              context_data_val = (context_data_val << 1) | value;
+              if (context_data_position == 15) {
+                context_data_position = 0;
+                context_data_string += f(context_data_val);
+                context_data_val = 0;
+              } else {
+                context_data_position++;
+              }
+              value = 0;
+            }
+            value = context_w.charCodeAt(0);
+            for (i=0 ; i<16 ; i++) {
+              context_data_val = (context_data_val << 1) | (value&1);
+              if (context_data_position == 15) {
+                context_data_position = 0;
+                context_data_string += f(context_data_val);
+                context_data_val = 0;
+              } else {
+                context_data_position++;
+              }
+              value = value >> 1;
+            }
+          }
+          context_enlargeIn--;
+          if (context_enlargeIn == 0) {
+            context_enlargeIn = Math.pow(2, context_numBits);
+            context_numBits++;
+          }
+          delete context_dictionaryToCreate[context_w];
+        } else {
+          value = context_dictionary[context_w];
+          for (i=0 ; i<context_numBits ; i++) {
+            context_data_val = (context_data_val << 1) | (value&1);
+            if (context_data_position == 15) {
+              context_data_position = 0;
+              context_data_string += f(context_data_val);
+              context_data_val = 0;
+            } else {
+              context_data_position++;
+            }
+            value = value >> 1;
+          }
+          
+          
+        }
+        context_enlargeIn--;
+        if (context_enlargeIn == 0) {
+          context_enlargeIn = Math.pow(2, context_numBits);
+          context_numBits++;
+        }
+        // Add wc to the dictionary.
+        context_dictionary[context_wc] = context_dictSize++;
+        context_w = String(context_c);
+      }
+    }
+    
+    // Output the code for w.
+    if (context_w !== "") {
+      if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate,context_w)) {
+        if (context_w.charCodeAt(0)<256) {
+          for (i=0 ; i<context_numBits ; i++) {
+            context_data_val = (context_data_val << 1);
+            if (context_data_position == 15) {
+              context_data_position = 0;
+              context_data_string += f(context_data_val);
+              context_data_val = 0;
+            } else {
+              context_data_position++;
+            }
+          }
+          value = context_w.charCodeAt(0);
+          for (i=0 ; i<8 ; i++) {
+            context_data_val = (context_data_val << 1) | (value&1);
+            if (context_data_position == 15) {
+              context_data_position = 0;
+              context_data_string += f(context_data_val);
+              context_data_val = 0;
+            } else {
+              context_data_position++;
+            }
+            value = value >> 1;
+          }
+        } else {
+          value = 1;
+          for (i=0 ; i<context_numBits ; i++) {
+            context_data_val = (context_data_val << 1) | value;
+            if (context_data_position == 15) {
+              context_data_position = 0;
+              context_data_string += f(context_data_val);
+              context_data_val = 0;
+            } else {
+              context_data_position++;
+            }
+            value = 0;
+          }
+          value = context_w.charCodeAt(0);
+          for (i=0 ; i<16 ; i++) {
+            context_data_val = (context_data_val << 1) | (value&1);
+            if (context_data_position == 15) {
+              context_data_position = 0;
+              context_data_string += f(context_data_val);
+              context_data_val = 0;
+            } else {
+              context_data_position++;
+            }
+            value = value >> 1;
+          }
+        }
+        context_enlargeIn--;
+        if (context_enlargeIn == 0) {
+          context_enlargeIn = Math.pow(2, context_numBits);
+          context_numBits++;
+        }
+        delete context_dictionaryToCreate[context_w];
+      } else {
+        value = context_dictionary[context_w];
+        for (i=0 ; i<context_numBits ; i++) {
+          context_data_val = (context_data_val << 1) | (value&1);
+          if (context_data_position == 15) {
+            context_data_position = 0;
+            context_data_string += f(context_data_val);
+            context_data_val = 0;
+          } else {
+            context_data_position++;
+          }
+          value = value >> 1;
+        }
+        
+        
+      }
+      context_enlargeIn--;
+      if (context_enlargeIn == 0) {
+        context_enlargeIn = Math.pow(2, context_numBits);
+        context_numBits++;
+      }
+    }
+    
+    // Mark the end of the stream
+    value = 2;
+    for (i=0 ; i<context_numBits ; i++) {
+      context_data_val = (context_data_val << 1) | (value&1);
+      if (context_data_position == 15) {
+        context_data_position = 0;
+        context_data_string += f(context_data_val);
+        context_data_val = 0;
+      } else {
+        context_data_position++;
+      }
+      value = value >> 1;
+    }
+    
+    // Flush the last char
+    while (true) {
+      context_data_val = (context_data_val << 1);
+      if (context_data_position == 15) {
+        context_data_string += f(context_data_val);
+        break;
+      }
+      else context_data_position++;
+    }
+    return context_data_string;
+  },
+  
+  decompress: function (compressed) {
+    if (compressed == null) return "";
+    if (compressed == "") return null;
+    var dictionary = [],
+        next,
+        enlargeIn = 4,
+        dictSize = 4,
+        numBits = 3,
+        entry = "",
+        result = "",
+        i,
+        w,
+        bits, resb, maxpower, power,
+        c,
+        f = LZString._f,
+        data = {string:compressed, val:compressed.charCodeAt(0), position:32768, index:1};
+    
+    for (i = 0; i < 3; i += 1) {
+      dictionary[i] = i;
+    }
+    
+    bits = 0;
+    maxpower = Math.pow(2,2);
+    power=1;
+    while (power!=maxpower) {
+      resb = data.val & data.position;
+      data.position >>= 1;
+      if (data.position == 0) {
+        data.position = 32768;
+        data.val = data.string.charCodeAt(data.index++);
+      }
+      bits |= (resb>0 ? 1 : 0) * power;
+      power <<= 1;
+    }
+    
+    switch (next = bits) {
+      case 0: 
+          bits = 0;
+          maxpower = Math.pow(2,8);
+          power=1;
+          while (power!=maxpower) {
+            resb = data.val & data.position;
+            data.position >>= 1;
+            if (data.position == 0) {
+              data.position = 32768;
+              data.val = data.string.charCodeAt(data.index++);
+            }
+            bits |= (resb>0 ? 1 : 0) * power;
+            power <<= 1;
+          }
+        c = f(bits);
+        break;
+      case 1: 
+          bits = 0;
+          maxpower = Math.pow(2,16);
+          power=1;
+          while (power!=maxpower) {
+            resb = data.val & data.position;
+            data.position >>= 1;
+            if (data.position == 0) {
+              data.position = 32768;
+              data.val = data.string.charCodeAt(data.index++);
+            }
+            bits |= (resb>0 ? 1 : 0) * power;
+            power <<= 1;
+          }
+        c = f(bits);
+        break;
+      case 2: 
+        return "";
+    }
+    dictionary[3] = c;
+    w = result = c;
+    while (true) {
+      if (data.index > data.string.length) {
+        return "";
+      }
+      
+      bits = 0;
+      maxpower = Math.pow(2,numBits);
+      power=1;
+      while (power!=maxpower) {
+        resb = data.val & data.position;
+        data.position >>= 1;
+        if (data.position == 0) {
+          data.position = 32768;
+          data.val = data.string.charCodeAt(data.index++);
+        }
+        bits |= (resb>0 ? 1 : 0) * power;
+        power <<= 1;
+      }
+
+      switch (c = bits) {
+        case 0: 
+          bits = 0;
+          maxpower = Math.pow(2,8);
+          power=1;
+          while (power!=maxpower) {
+            resb = data.val & data.position;
+            data.position >>= 1;
+            if (data.position == 0) {
+              data.position = 32768;
+              data.val = data.string.charCodeAt(data.index++);
+            }
+            bits |= (resb>0 ? 1 : 0) * power;
+            power <<= 1;
+          }
+
+          dictionary[dictSize++] = f(bits);
+          c = dictSize-1;
+          enlargeIn--;
+          break;
+        case 1: 
+          bits = 0;
+          maxpower = Math.pow(2,16);
+          power=1;
+          while (power!=maxpower) {
+            resb = data.val & data.position;
+            data.position >>= 1;
+            if (data.position == 0) {
+              data.position = 32768;
+              data.val = data.string.charCodeAt(data.index++);
+            }
+            bits |= (resb>0 ? 1 : 0) * power;
+            power <<= 1;
+          }
+          dictionary[dictSize++] = f(bits);
+          c = dictSize-1;
+          enlargeIn--;
+          break;
+        case 2: 
+          return result;
+      }
+      
+      if (enlargeIn == 0) {
+        enlargeIn = Math.pow(2, numBits);
+        numBits++;
+      }
+      
+      if (dictionary[c]) {
+        entry = dictionary[c];
+      } else {
+        if (c === dictSize) {
+          entry = w + w.charAt(0);
+        } else {
+          return null;
+        }
+      }
+      result += entry;
+      
+      // Add w+entry[0] to the dictionary.
+      dictionary[dictSize++] = w + entry.charAt(0);
+      enlargeIn--;
+      
+      w = entry;
+      
+      if (enlargeIn == 0) {
+        enlargeIn = Math.pow(2, numBits);
+        numBits++;
+      }
+      
+    }
+  }
+};
+
+if( typeof module !== 'undefined' && module != null ) {
+  module.exports = LZString
+}

lib/sha1.js

@@ -0,0 +1,371 @@
+/*
+ * [js-sha1]{@link https://github.com/emn178/js-sha1}
+ *
+ * @version 0.6.0
+ * @author Chen, Yi-Cyuan [[email protected]]
+ * @copyright Chen, Yi-Cyuan 2014-2017
+ * @license MIT
+ */
+/*jslint bitwise: true */
+(function() {
+  'use strict';
+
+  var root = typeof window === 'object' ? window : {};
+  var NODE_JS = !root.JS_SHA1_NO_NODE_JS && typeof process === 'object' && process.versions && process.versions.node;
+  if (NODE_JS) {
+    root = global;
+  }
+  var COMMON_JS = !root.JS_SHA1_NO_COMMON_JS && typeof module === 'object' && module.exports;
+  var AMD = typeof define === 'function' && define.amd;
+  var HEX_CHARS = '0123456789abcdef'.split('');
+  var EXTRA = [-2147483648, 8388608, 32768, 128];
+  var SHIFT = [24, 16, 8, 0];
+  var OUTPUT_TYPES = ['hex', 'array', 'digest', 'arrayBuffer'];
+
+  var blocks = [];
+
+  var createOutputMethod = function (outputType) {
+    return function (message) {
+      return new Sha1(true).update(message)[outputType]();
+    };
+  };
+
+  var createMethod = function () {
+    var method = createOutputMethod('hex');
+    if (NODE_JS) {
+      method = nodeWrap(method);
+    }
+    method.create = function () {
+      return new Sha1();
+    };
+    method.update = function (message) {
+      return method.create().update(message);
+    };
+    for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
+      var type = OUTPUT_TYPES[i];
+      method[type] = createOutputMethod(type);
+    }
+    return method;
+  };
+
+  var nodeWrap = function (method) {
+    var crypto = eval("require('crypto')");
+    var Buffer = eval("require('buffer').Buffer");
+    var nodeMethod = function (message) {
+      if (typeof message === 'string') {
+        return crypto.createHash('sha1').update(message, 'utf8').digest('hex');
+      } else if (message.constructor === ArrayBuffer) {
+        message = new Uint8Array(message);
+      } else if (message.length === undefined) {
+        return method(message);
+      }
+      return crypto.createHash('sha1').update(new Buffer(message)).digest('hex');
+    };
+    return nodeMethod;
+  };
+
+  function Sha1(sharedMemory) {
+    if (sharedMemory) {
+      blocks[0] = blocks[16] = blocks[1] = blocks[2] = blocks[3] =
+      blocks[4] = blocks[5] = blocks[6] = blocks[7] =
+      blocks[8] = blocks[9] = blocks[10] = blocks[11] =
+      blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+      this.blocks = blocks;
+    } else {
+      this.blocks = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    }
+
+    this.h0 = 0x67452301;
+    this.h1 = 0xEFCDAB89;
+    this.h2 = 0x98BADCFE;
+    this.h3 = 0x10325476;
+    this.h4 = 0xC3D2E1F0;
+
+    this.block = this.start = this.bytes = this.hBytes = 0;
+    this.finalized = this.hashed = false;
+    this.first = true;
+  }
+
+  Sha1.prototype.update = function (message) {
+    if (this.finalized) {
+      return;
+    }
+    var notString = typeof(message) !== 'string';
+    if (notString && message.constructor === root.ArrayBuffer) {
+      message = new Uint8Array(message);
+    }
+    var code, index = 0, i, length = message.length || 0, blocks = this.blocks;
+
+    while (index < length) {
+      if (this.hashed) {
+        this.hashed = false;
+        blocks[0] = this.block;
+        blocks[16] = blocks[1] = blocks[2] = blocks[3] =
+        blocks[4] = blocks[5] = blocks[6] = blocks[7] =
+        blocks[8] = blocks[9] = blocks[10] = blocks[11] =
+        blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+      }
+
+      if(notString) {
+        for (i = this.start; index < length && i < 64; ++index) {
+          blocks[i >> 2] |= message[index] << SHIFT[i++ & 3];
+        }
+      } else {
+        for (i = this.start; index < length && i < 64; ++index) {
+          code = message.charCodeAt(index);
+          if (code < 0x80) {
+            blocks[i >> 2] |= code << SHIFT[i++ & 3];
+          } else if (code < 0x800) {
+            blocks[i >> 2] |= (0xc0 | (code >> 6)) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
+          } else if (code < 0xd800 || code >= 0xe000) {
+            blocks[i >> 2] |= (0xe0 | (code >> 12)) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
+          } else {
+            code = 0x10000 + (((code & 0x3ff) << 10) | (message.charCodeAt(++index) & 0x3ff));
+            blocks[i >> 2] |= (0xf0 | (code >> 18)) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | ((code >> 12) & 0x3f)) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
+          }
+        }
+      }
+
+      this.lastByteIndex = i;
+      this.bytes += i - this.start;
+      if (i >= 64) {
+        this.block = blocks[16];
+        this.start = i - 64;
+        this.hash();
+        this.hashed = true;
+      } else {
+        this.start = i;
+      }
+    }
+    if (this.bytes > 4294967295) {
+      this.hBytes += this.bytes / 4294967296 << 0;
+      this.bytes = this.bytes % 4294967296;
+    }
+    return this;
+  };
+
+  Sha1.prototype.finalize = function () {
+    if (this.finalized) {
+      return;
+    }
+    this.finalized = true;
+    var blocks = this.blocks, i = this.lastByteIndex;
+    blocks[16] = this.block;
+    blocks[i >> 2] |= EXTRA[i & 3];
+    this.block = blocks[16];
+    if (i >= 56) {
+      if (!this.hashed) {
+        this.hash();
+      }
+      blocks[0] = this.block;
+      blocks[16] = blocks[1] = blocks[2] = blocks[3] =
+      blocks[4] = blocks[5] = blocks[6] = blocks[7] =
+      blocks[8] = blocks[9] = blocks[10] = blocks[11] =
+      blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+    }
+    blocks[14] = this.hBytes << 3 | this.bytes >>> 29;
+    blocks[15] = this.bytes << 3;
+    this.hash();
+  };
+
+  Sha1.prototype.hash = function () {
+    var a = this.h0, b = this.h1, c = this.h2, d = this.h3, e = this.h4;
+    var f, j, t, blocks = this.blocks;
+
+    for(j = 16; j < 80; ++j) {
+      t = blocks[j - 3] ^ blocks[j - 8] ^ blocks[j - 14] ^ blocks[j - 16];
+      blocks[j] =  (t << 1) | (t >>> 31);
+    }
+
+    for(j = 0; j < 20; j += 5) {
+      f = (b & c) | ((~b) & d);
+      t = (a << 5) | (a >>> 27);
+      e = t + f + e + 1518500249 + blocks[j] << 0;
+      b = (b << 30) | (b >>> 2);
+
+      f = (a & b) | ((~a) & c);
+      t = (e << 5) | (e >>> 27);
+      d = t + f + d + 1518500249 + blocks[j + 1] << 0;
+      a = (a << 30) | (a >>> 2);
+
+      f = (e & a) | ((~e) & b);
+      t = (d << 5) | (d >>> 27);
+      c = t + f + c + 1518500249 + blocks[j + 2] << 0;
+      e = (e << 30) | (e >>> 2);
+
+      f = (d & e) | ((~d) & a);
+      t = (c << 5) | (c >>> 27);
+      b = t + f + b + 1518500249 + blocks[j + 3] << 0;
+      d = (d << 30) | (d >>> 2);
+
+      f = (c & d) | ((~c) & e);
+      t = (b << 5) | (b >>> 27);
+      a = t + f + a + 1518500249 + blocks[j + 4] << 0;
+      c = (c << 30) | (c >>> 2);
+    }
+
+    for(; j < 40; j += 5) {
+      f = b ^ c ^ d;
+      t = (a << 5) | (a >>> 27);
+      e = t + f + e + 1859775393 + blocks[j] << 0;
+      b = (b << 30) | (b >>> 2);
+
+      f = a ^ b ^ c;
+      t = (e << 5) | (e >>> 27);
+      d = t + f + d + 1859775393 + blocks[j + 1] << 0;
+      a = (a << 30) | (a >>> 2);
+
+      f = e ^ a ^ b;
+      t = (d << 5) | (d >>> 27);
+      c = t + f + c + 1859775393 + blocks[j + 2] << 0;
+      e = (e << 30) | (e >>> 2);
+
+      f = d ^ e ^ a;
+      t = (c << 5) | (c >>> 27);
+      b = t + f + b + 1859775393 + blocks[j + 3] << 0;
+      d = (d << 30) | (d >>> 2);
+
+      f = c ^ d ^ e;
+      t = (b << 5) | (b >>> 27);
+      a = t + f + a + 1859775393 + blocks[j + 4] << 0;
+      c = (c << 30) | (c >>> 2);
+    }
+
+    for(; j < 60; j += 5) {
+      f = (b & c) | (b & d) | (c & d);
+      t = (a << 5) | (a >>> 27);
+      e = t + f + e - 1894007588 + blocks[j] << 0;
+      b = (b << 30) | (b >>> 2);
+
+      f = (a & b) | (a & c) | (b & c);
+      t = (e << 5) | (e >>> 27);
+      d = t + f + d - 1894007588 + blocks[j + 1] << 0;
+      a = (a << 30) | (a >>> 2);
+
+      f = (e & a) | (e & b) | (a & b);
+      t = (d << 5) | (d >>> 27);
+      c = t + f + c - 1894007588 + blocks[j + 2] << 0;
+      e = (e << 30) | (e >>> 2);
+
+      f = (d & e) | (d & a) | (e & a);
+      t = (c << 5) | (c >>> 27);
+      b = t + f + b - 1894007588 + blocks[j + 3] << 0;
+      d = (d << 30) | (d >>> 2);
+
+      f = (c & d) | (c & e) | (d & e);
+      t = (b << 5) | (b >>> 27);
+      a = t + f + a - 1894007588 + blocks[j + 4] << 0;
+      c = (c << 30) | (c >>> 2);
+    }
+
+    for(; j < 80; j += 5) {
+      f = b ^ c ^ d;
+      t = (a << 5) | (a >>> 27);
+      e = t + f + e - 899497514 + blocks[j] << 0;
+      b = (b << 30) | (b >>> 2);
+
+      f = a ^ b ^ c;
+      t = (e << 5) | (e >>> 27);
+      d = t + f + d - 899497514 + blocks[j + 1] << 0;
+      a = (a << 30) | (a >>> 2);
+
+      f = e ^ a ^ b;
+      t = (d << 5) | (d >>> 27);
+      c = t + f + c - 899497514 + blocks[j + 2] << 0;
+      e = (e << 30) | (e >>> 2);
+
+      f = d ^ e ^ a;
+      t = (c << 5) | (c >>> 27);
+      b = t + f + b - 899497514 + blocks[j + 3] << 0;
+      d = (d << 30) | (d >>> 2);
+
+      f = c ^ d ^ e;
+      t = (b << 5) | (b >>> 27);
+      a = t + f + a - 899497514 + blocks[j + 4] << 0;
+      c = (c << 30) | (c >>> 2);
+    }
+
+    this.h0 = this.h0 + a << 0;
+    this.h1 = this.h1 + b << 0;
+    this.h2 = this.h2 + c << 0;
+    this.h3 = this.h3 + d << 0;
+    this.h4 = this.h4 + e << 0;
+  };
+
+  Sha1.prototype.hex = function () {
+    this.finalize();
+
+    var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4;
+
+    return HEX_CHARS[(h0 >> 28) & 0x0F] + HEX_CHARS[(h0 >> 24) & 0x0F] +
+           HEX_CHARS[(h0 >> 20) & 0x0F] + HEX_CHARS[(h0 >> 16) & 0x0F] +
+           HEX_CHARS[(h0 >> 12) & 0x0F] + HEX_CHARS[(h0 >> 8) & 0x0F] +
+           HEX_CHARS[(h0 >> 4) & 0x0F] + HEX_CHARS[h0 & 0x0F] +
+           HEX_CHARS[(h1 >> 28) & 0x0F] + HEX_CHARS[(h1 >> 24) & 0x0F] +
+           HEX_CHARS[(h1 >> 20) & 0x0F] + HEX_CHARS[(h1 >> 16) & 0x0F] +
+           HEX_CHARS[(h1 >> 12) & 0x0F] + HEX_CHARS[(h1 >> 8) & 0x0F] +
+           HEX_CHARS[(h1 >> 4) & 0x0F] + HEX_CHARS[h1 & 0x0F] +
+           HEX_CHARS[(h2 >> 28) & 0x0F] + HEX_CHARS[(h2 >> 24) & 0x0F] +
+           HEX_CHARS[(h2 >> 20) & 0x0F] + HEX_CHARS[(h2 >> 16) & 0x0F] +
+           HEX_CHARS[(h2 >> 12) & 0x0F] + HEX_CHARS[(h2 >> 8) & 0x0F] +
+           HEX_CHARS[(h2 >> 4) & 0x0F] + HEX_CHARS[h2 & 0x0F] +
+           HEX_CHARS[(h3 >> 28) & 0x0F] + HEX_CHARS[(h3 >> 24) & 0x0F] +
+           HEX_CHARS[(h3 >> 20) & 0x0F] + HEX_CHARS[(h3 >> 16) & 0x0F] +
+           HEX_CHARS[(h3 >> 12) & 0x0F] + HEX_CHARS[(h3 >> 8) & 0x0F] +
+           HEX_CHARS[(h3 >> 4) & 0x0F] + HEX_CHARS[h3 & 0x0F] +
+           HEX_CHARS[(h4 >> 28) & 0x0F] + HEX_CHARS[(h4 >> 24) & 0x0F] +
+           HEX_CHARS[(h4 >> 20) & 0x0F] + HEX_CHARS[(h4 >> 16) & 0x0F] +
+           HEX_CHARS[(h4 >> 12) & 0x0F] + HEX_CHARS[(h4 >> 8) & 0x0F] +
+           HEX_CHARS[(h4 >> 4) & 0x0F] + HEX_CHARS[h4 & 0x0F];
+  };
+
+  Sha1.prototype.toString = Sha1.prototype.hex;
+
+  Sha1.prototype.digest = function () {
+    this.finalize();
+
+    var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4;
+
+    return [
+      (h0 >> 24) & 0xFF, (h0 >> 16) & 0xFF, (h0 >> 8) & 0xFF, h0 & 0xFF,
+      (h1 >> 24) & 0xFF, (h1 >> 16) & 0xFF, (h1 >> 8) & 0xFF, h1 & 0xFF,
+      (h2 >> 24) & 0xFF, (h2 >> 16) & 0xFF, (h2 >> 8) & 0xFF, h2 & 0xFF,
+      (h3 >> 24) & 0xFF, (h3 >> 16) & 0xFF, (h3 >> 8) & 0xFF, h3 & 0xFF,
+      (h4 >> 24) & 0xFF, (h4 >> 16) & 0xFF, (h4 >> 8) & 0xFF, h4 & 0xFF
+    ];
+  };
+
+  Sha1.prototype.array = Sha1.prototype.digest;
+
+  Sha1.prototype.arrayBuffer = function () {
+    this.finalize();
+
+    var buffer = new ArrayBuffer(20);
+    var dataView = new DataView(buffer);
+    dataView.setUint32(0, this.h0);
+    dataView.setUint32(4, this.h1);
+    dataView.setUint32(8, this.h2);
+    dataView.setUint32(12, this.h3);
+    dataView.setUint32(16, this.h4);
+    return buffer;
+  };
+
+  var exports = createMethod();
+
+  if (COMMON_JS) {
+    module.exports = exports;
+  } else {
+    root.sha1 = exports;
+    if (AMD) {
+      define(function () {
+        return exports;
+      });
+    }
+  }
+})();

lib_node/WebSocket.js

@@ -0,0 +1,11 @@
+// This a Wrapper for the node ws WebSocket implementation to resemble the
+// browser WebSocket implementation better. 
+var WebSocket = require("./ws/websocket");
+
+class SafeWebSocketClient extends WebSocket {
+	constructor(url, protocols) {
+		super(url, protocols, { perMessageDeflate: false });
+	}
+}
+
+module.exports = SafeWebSocketClient;

lib_node/ws/README.txt

@@ -0,0 +1 @@
+Source used from https://github.com/websockets/ws (MIT licensed)

lib_node/ws/buffer-util.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const { EMPTY_BUFFER } = require('./constants');
+
+/**
+ * Merges an array of buffers into a new buffer.
+ *
+ * @param {Buffer[]} list The array of buffers to concat
+ * @param {Number} totalLength The total length of buffers in the list
+ * @return {Buffer} The resulting buffer
+ * @public
+ */
+function concat(list, totalLength) {
+  if (list.length === 0) return EMPTY_BUFFER;
+  if (list.length === 1) return list[0];
+
+  const target = Buffer.allocUnsafe(totalLength);
+  let offset = 0;
+
+  for (let i = 0; i < list.length; i++) {
+    const buf = list[i];
+    target.set(buf, offset);
+    offset += buf.length;
+  }
+
+  return target;
+}
+
+/**
+ * Masks a buffer using the given mask.
+ *
+ * @param {Buffer} source The buffer to mask
+ * @param {Buffer} mask The mask to use
+ * @param {Buffer} output The buffer where to store the result
+ * @param {Number} offset The offset at which to start writing
+ * @param {Number} length The number of bytes to mask.
+ * @public
+ */
+function _mask(source, mask, output, offset, length) {
+  for (let i = 0; i < length; i++) {
+    output[offset + i] = source[i] ^ mask[i & 3];
+  }
+}
+
+/**
+ * Unmasks a buffer using the given mask.
+ *
+ * @param {Buffer} buffer The buffer to unmask
+ * @param {Buffer} mask The mask to use
+ * @public
+ */
+function _unmask(buffer, mask) {
+  // Required until https://github.com/nodejs/node/issues/9006 is resolved.
+  const length = buffer.length;
+  for (let i = 0; i < length; i++) {
+    buffer[i] ^= mask[i & 3];
+  }
+}
+
+/**
+ * Converts a buffer to an `ArrayBuffer`.
+ *
+ * @param {Buffer} buf The buffer to convert
+ * @return {ArrayBuffer} Converted buffer
+ * @public
+ */
+function toArrayBuffer(buf) {
+  if (buf.byteLength === buf.buffer.byteLength) {
+    return buf.buffer;
+  }
+
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+
+/**
+ * Converts `data` to a `Buffer`.
+ *
+ * @param {*} data The data to convert
+ * @return {Buffer} The buffer
+ * @throws {TypeError}
+ * @public
+ */
+function toBuffer(data) {
+  toBuffer.readOnly = true;
+
+  if (Buffer.isBuffer(data)) return data;
+
+  let buf;
+
+  if (data instanceof ArrayBuffer) {
+    buf = Buffer.from(data);
+  } else if (ArrayBuffer.isView(data)) {
+    buf = viewToBuffer(data);
+  } else {
+    buf = Buffer.from(data);
+    toBuffer.readOnly = false;
+  }
+
+  return buf;
+}
+
+/**
+ * Converts an `ArrayBuffer` view into a buffer.
+ *
+ * @param {(DataView|TypedArray)} view The view to convert
+ * @return {Buffer} Converted view
+ * @private
+ */
+function viewToBuffer(view) {
+  const buf = Buffer.from(view.buffer);
+
+  if (view.byteLength !== view.buffer.byteLength) {
+    return buf.slice(view.byteOffset, view.byteOffset + view.byteLength);
+  }
+
+  return buf;
+}
+
+try {
+  const bufferUtil = require('bufferutil');
+  const bu = bufferUtil.BufferUtil || bufferUtil;
+
+  module.exports = {
+    concat,
+    mask(source, mask, output, offset, length) {
+      if (length < 48) _mask(source, mask, output, offset, length);
+      else bu.mask(source, mask, output, offset, length);
+    },
+    toArrayBuffer,
+    toBuffer,
+    unmask(buffer, mask) {
+      if (buffer.length < 32) _unmask(buffer, mask);
+      else bu.unmask(buffer, mask);
+    }
+  };
+} catch (e) /* istanbul ignore next */ {
+  module.exports = {
+    concat,
+    mask: _mask,
+    toArrayBuffer,
+    toBuffer,
+    unmask: _unmask
+  };
+}

lib_node/ws/constants.js

@@ -0,0 +1,10 @@
+'use strict';
+
+module.exports = {
+  BINARY_TYPES: ['nodebuffer', 'arraybuffer', 'fragments'],
+  GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
+  kStatusCode: Symbol('status-code'),
+  kWebSocket: Symbol('websocket'),
+  EMPTY_BUFFER: Buffer.alloc(0),
+  NOOP: () => {}
+};

lib_node/ws/event-target.js

@@ -0,0 +1,170 @@
+'use strict';
+
+/**
+ * Class representing an event.
+ *
+ * @private
+ */
+class Event {
+  /**
+   * Create a new `Event`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} target A reference to the target to which the event was dispatched
+   */
+  constructor(type, target) {
+    this.target = target;
+    this.type = type;
+  }
+}
+
+/**
+ * Class representing a message event.
+ *
+ * @extends Event
+ * @private
+ */
+class MessageEvent extends Event {
+  /**
+   * Create a new `MessageEvent`.
+   *
+   * @param {(String|Buffer|ArrayBuffer|Buffer[])} data The received data
+   * @param {WebSocket} target A reference to the target to which the event was dispatched
+   */
+  constructor(data, target) {
+    super('message', target);
+
+    this.data = data;
+  }
+}
+
+/**
+ * Class representing a close event.
+ *
+ * @extends Event
+ * @private
+ */
+class CloseEvent extends Event {
+  /**
+   * Create a new `CloseEvent`.
+   *
+   * @param {Number} code The status code explaining why the connection is being closed
+   * @param {String} reason A human-readable string explaining why the connection is closing
+   * @param {WebSocket} target A reference to the target to which the event was dispatched
+   */
+  constructor(code, reason, target) {
+    super('close', target);
+
+    this.wasClean = target._closeFrameReceived && target._closeFrameSent;
+    this.reason = reason;
+    this.code = code;
+  }
+}
+
+/**
+ * Class representing an open event.
+ *
+ * @extends Event
+ * @private
+ */
+class OpenEvent extends Event {
+  /**
+   * Create a new `OpenEvent`.
+   *
+   * @param {WebSocket} target A reference to the target to which the event was dispatched
+   */
+  constructor(target) {
+    super('open', target);
+  }
+}
+
+/**
+ * Class representing an error event.
+ *
+ * @extends Event
+ * @private
+ */
+class ErrorEvent extends Event {
+  /**
+   * Create a new `ErrorEvent`.
+   *
+   * @param {Object} error The error that generated this event
+   * @param {WebSocket} target A reference to the target to which the event was dispatched
+   */
+  constructor(error, target) {
+    super('error', target);
+
+    this.message = error.message;
+    this.error = error;
+  }
+}
+
+/**
+ * This provides methods for emulating the `EventTarget` interface. It's not
+ * meant to be used directly.
+ *
+ * @mixin
+ */
+const EventTarget = {
+  /**
+   * Register an event listener.
+   *
+   * @param {String} method A string representing the event type to listen for
+   * @param {Function} listener The listener to add
+   * @public
+   */
+  addEventListener(method, listener) {
+    if (typeof listener !== 'function') return;
+
+    function onMessage(data) {
+      listener.call(this, new MessageEvent(data, this));
+    }
+
+    function onClose(code, message) {
+      listener.call(this, new CloseEvent(code, message, this));
+    }
+
+    function onError(error) {
+      listener.call(this, new ErrorEvent(error, this));
+    }
+
+    function onOpen() {
+      listener.call(this, new OpenEvent(this));
+    }
+
+    if (method === 'message') {
+      onMessage._listener = listener;
+      this.on(method, onMessage);
+    } else if (method === 'close') {
+      onClose._listener = listener;
+      this.on(method, onClose);
+    } else if (method === 'error') {
+      onError._listener = listener;
+      this.on(method, onError);
+    } else if (method === 'open') {
+      onOpen._listener = listener;
+      this.on(method, onOpen);
+    } else {
+      this.on(method, listener);
+    }
+  },
+
+  /**
+   * Remove an event listener.
+   *
+   * @param {String} method A string representing the event type to remove
+   * @param {Function} listener The listener to remove
+   * @public
+   */
+  removeEventListener(method, listener) {
+    const listeners = this.listeners(method);
+
+    for (let i = 0; i < listeners.length; i++) {
+      if (listeners[i] === listener || listeners[i]._listener === listener) {
+        this.removeListener(method, listeners[i]);
+      }
+    }
+  }
+};
+
+module.exports = EventTarget;

lib_node/ws/extension.js

@@ -0,0 +1,223 @@
+'use strict';
+
+//
+// Allowed token characters:
+//
+// '!', '#', '$', '%', '&', ''', '*', '+', '-',
+// '.', 0-9, A-Z, '^', '_', '`', a-z, '|', '~'
+//
+// tokenChars[32] === 0 // ' '
+// tokenChars[33] === 1 // '!'
+// tokenChars[34] === 0 // '"'
+// ...
+//
+// prettier-ignore
+const tokenChars = [
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 - 15
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31
+  0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, // 32 - 47
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, // 48 - 63
+  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 - 79
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, // 80 - 95
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 - 111
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0 // 112 - 127
+];
+
+/**
+ * Adds an offer to the map of extension offers or a parameter to the map of
+ * parameters.
+ *
+ * @param {Object} dest The map of extension offers or parameters
+ * @param {String} name The extension or parameter name
+ * @param {(Object|Boolean|String)} elem The extension parameters or the
+ *     parameter value
+ * @private
+ */
+function push(dest, name, elem) {
+  if (dest[name] === undefined) dest[name] = [elem];
+  else dest[name].push(elem);
+}
+
+/**
+ * Parses the `Sec-WebSocket-Extensions` header into an object.
+ *
+ * @param {String} header The field value of the header
+ * @return {Object} The parsed object
+ * @public
+ */
+function parse(header) {
+  const offers = Object.create(null);
+
+  if (header === undefined || header === '') return offers;
+
+  let params = Object.create(null);
+  let mustUnescape = false;
+  let isEscaping = false;
+  let inQuotes = false;
+  let extensionName;
+  let paramName;
+  let start = -1;
+  let end = -1;
+  let i = 0;
+
+  for (; i < header.length; i++) {
+    const code = header.charCodeAt(i);
+
+    if (extensionName === undefined) {
+      if (end === -1 && tokenChars[code] === 1) {
+        if (start === -1) start = i;
+      } else if (code === 0x20 /* ' ' */ || code === 0x09 /* '\t' */) {
+        if (end === -1 && start !== -1) end = i;
+      } else if (code === 0x3b /* ';' */ || code === 0x2c /* ',' */) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        const name = header.slice(start, end);
+        if (code === 0x2c) {
+          push(offers, name, params);
+          params = Object.create(null);
+        } else {
+          extensionName = name;
+        }
+
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    } else if (paramName === undefined) {
+      if (end === -1 && tokenChars[code] === 1) {
+        if (start === -1) start = i;
+      } else if (code === 0x20 || code === 0x09) {
+        if (end === -1 && start !== -1) end = i;
+      } else if (code === 0x3b || code === 0x2c) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        push(params, header.slice(start, end), true);
+        if (code === 0x2c) {
+          push(offers, extensionName, params);
+          params = Object.create(null);
+          extensionName = undefined;
+        }
+
+        start = end = -1;
+      } else if (code === 0x3d /* '=' */ && start !== -1 && end === -1) {
+        paramName = header.slice(start, i);
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    } else {
+      //
+      // The value of a quoted-string after unescaping must conform to the
+      // token ABNF, so only token characters are valid.
+      // Ref: https://tools.ietf.org/html/rfc6455#section-9.1
+      //
+      if (isEscaping) {
+        if (tokenChars[code] !== 1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+        if (start === -1) start = i;
+        else if (!mustUnescape) mustUnescape = true;
+        isEscaping = false;
+      } else if (inQuotes) {
+        if (tokenChars[code] === 1) {
+          if (start === -1) start = i;
+        } else if (code === 0x22 /* '"' */ && start !== -1) {
+          inQuotes = false;
+          end = i;
+        } else if (code === 0x5c /* '\' */) {
+          isEscaping = true;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+      } else if (code === 0x22 && header.charCodeAt(i - 1) === 0x3d) {
+        inQuotes = true;
+      } else if (end === -1 && tokenChars[code] === 1) {
+        if (start === -1) start = i;
+      } else if (start !== -1 && (code === 0x20 || code === 0x09)) {
+        if (end === -1) end = i;
+      } else if (code === 0x3b || code === 0x2c) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        let value = header.slice(start, end);
+        if (mustUnescape) {
+          value = value.replace(/\\/g, '');
+          mustUnescape = false;
+        }
+        push(params, paramName, value);
+        if (code === 0x2c) {
+          push(offers, extensionName, params);
+          params = Object.create(null);
+          extensionName = undefined;
+        }
+
+        paramName = undefined;
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    }
+  }
+
+  if (start === -1 || inQuotes) {
+    throw new SyntaxError('Unexpected end of input');
+  }
+
+  if (end === -1) end = i;
+  const token = header.slice(start, end);
+  if (extensionName === undefined) {
+    push(offers, token, params);
+  } else {
+    if (paramName === undefined) {
+      push(params, token, true);
+    } else if (mustUnescape) {
+      push(params, paramName, token.replace(/\\/g, ''));
+    } else {
+      push(params, paramName, token);
+    }
+    push(offers, extensionName, params);
+  }
+
+  return offers;
+}
+
+/**
+ * Builds the `Sec-WebSocket-Extensions` header field value.
+ *
+ * @param {Object} extensions The map of extensions and parameters to format
+ * @return {String} A string representing the given object
+ * @public
+ */
+function format(extensions) {
+  return Object.keys(extensions)
+    .map((extension) => {
+      let configurations = extensions[extension];
+      if (!Array.isArray(configurations)) configurations = [configurations];
+      return configurations
+        .map((params) => {
+          return [extension]
+            .concat(
+              Object.keys(params).map((k) => {
+                let values = params[k];
+                if (!Array.isArray(values)) values = [values];
+                return values
+                  .map((v) => (v === true ? k : `${k}=${v}`))
+                  .join('; ');
+              })
+            )
+            .join('; ');
+        })
+        .join(', ');
+    })
+    .join(', ');
+}
+
+module.exports = { format, parse };

lib_node/ws/permessage-deflate.js

@@ -0,0 +1,5 @@
+// ErikOnBike
+// The original code is removed since its usage might degrade performance and memory usage.
+module.exports = {
+  extensionName: "PerMessageDeflate"
+};

lib_node/ws/receiver.js

@@ -0,0 +1,493 @@
+'use strict';
+
+const { Writable } = require('stream');
+
+const PerMessageDeflate = require('./permessage-deflate');
+const {
+  BINARY_TYPES,
+  EMPTY_BUFFER,
+  kStatusCode,
+  kWebSocket
+} = require('./constants');
+const { concat, toArrayBuffer, unmask } = require('./buffer-util');
+const { isValidStatusCode, isValidUTF8 } = require('./validation');
+
+const GET_INFO = 0;
+const GET_PAYLOAD_LENGTH_16 = 1;
+const GET_PAYLOAD_LENGTH_64 = 2;
+const GET_MASK = 3;
+const GET_DATA = 4;
+const INFLATING = 5;
+
+/**
+ * HyBi Receiver implementation.
+ *
+ * @extends stream.Writable
+ */
+class Receiver extends Writable {
+  /**
+   * Creates a Receiver instance.
+   *
+   * @param {String} binaryType The type for binary data
+   * @param {Object} extensions An object containing the negotiated extensions
+   * @param {Number} maxPayload The maximum allowed message length
+   */
+  constructor(binaryType, extensions, maxPayload) {
+    super();
+
+    this._binaryType = binaryType || BINARY_TYPES[0];
+    this[kWebSocket] = undefined;
+    this._extensions = extensions || {};
+    this._maxPayload = maxPayload | 0;
+
+    this._bufferedBytes = 0;
+    this._buffers = [];
+
+    this._compressed = false;
+    this._payloadLength = 0;
+    this._mask = undefined;
+    this._fragmented = 0;
+    this._masked = false;
+    this._fin = false;
+    this._opcode = 0;
+
+    this._totalPayloadLength = 0;
+    this._messageLength = 0;
+    this._fragments = [];
+
+    this._state = GET_INFO;
+    this._loop = false;
+  }
+
+  /**
+   * Implements `Writable.prototype._write()`.
+   *
+   * @param {Buffer} chunk The chunk of data to write
+   * @param {String} encoding The character encoding of `chunk`
+   * @param {Function} cb Callback
+   */
+  _write(chunk, encoding, cb) {
+    if (this._opcode === 0x08 && this._state == GET_INFO) return cb();
+
+    this._bufferedBytes += chunk.length;
+    this._buffers.push(chunk);
+    this.startLoop(cb);
+  }
+
+  /**
+   * Consumes `n` bytes from the buffered data.
+   *
+   * @param {Number} n The number of bytes to consume
+   * @return {Buffer} The consumed bytes
+   * @private
+   */
+  consume(n) {
+    this._bufferedBytes -= n;
+
+    if (n === this._buffers[0].length) return this._buffers.shift();
+
+    if (n < this._buffers[0].length) {
+      const buf = this._buffers[0];
+      this._buffers[0] = buf.slice(n);
+      return buf.slice(0, n);
+    }
+
+    const dst = Buffer.allocUnsafe(n);
+
+    do {
+      const buf = this._buffers[0];
+      const offset = dst.length - n;
+
+      if (n >= buf.length) {
+        dst.set(this._buffers.shift(), offset);
+      } else {
+        dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
+        this._buffers[0] = buf.slice(n);
+      }
+
+      n -= buf.length;
+    } while (n > 0);
+
+    return dst;
+  }
+
+  /**
+   * Starts the parsing loop.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  startLoop(cb) {
+    let err;
+    this._loop = true;
+
+    do {
+      switch (this._state) {
+        case GET_INFO:
+          err = this.getInfo();
+          break;
+        case GET_PAYLOAD_LENGTH_16:
+          err = this.getPayloadLength16();
+          break;
+        case GET_PAYLOAD_LENGTH_64:
+          err = this.getPayloadLength64();
+          break;
+        case GET_MASK:
+          this.getMask();
+          break;
+        case GET_DATA:
+          err = this.getData(cb);
+          break;
+        default:
+          // `INFLATING`
+          this._loop = false;
+          return;
+      }
+    } while (this._loop);
+
+    cb(err);
+  }
+
+  /**
+   * Reads the first two bytes of a frame.
+   *
+   * @return {(RangeError|undefined)} A possible error
+   * @private
+   */
+  getInfo() {
+    if (this._bufferedBytes < 2) {
+      this._loop = false;
+      return;
+    }
+
+    const buf = this.consume(2);
+
+    if ((buf[0] & 0x30) !== 0x00) {
+      this._loop = false;
+      return error(RangeError, 'RSV2 and RSV3 must be clear', true, 1002);
+    }
+
+    const compressed = (buf[0] & 0x40) === 0x40;
+
+    if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
+      this._loop = false;
+      return error(RangeError, 'RSV1 must be clear', true, 1002);
+    }
+
+    this._fin = (buf[0] & 0x80) === 0x80;
+    this._opcode = buf[0] & 0x0f;
+    this._payloadLength = buf[1] & 0x7f;
+
+    if (this._opcode === 0x00) {
+      if (compressed) {
+        this._loop = false;
+        return error(RangeError, 'RSV1 must be clear', true, 1002);
+      }
+
+      if (!this._fragmented) {
+        this._loop = false;
+        return error(RangeError, 'invalid opcode 0', true, 1002);
+      }
+
+      this._opcode = this._fragmented;
+    } else if (this._opcode === 0x01 || this._opcode === 0x02) {
+      if (this._fragmented) {
+        this._loop = false;
+        return error(RangeError, `invalid opcode ${this._opcode}`, true, 1002);
+      }
+
+      this._compressed = compressed;
+    } else if (this._opcode > 0x07 && this._opcode < 0x0b) {
+      if (!this._fin) {
+        this._loop = false;
+        return error(RangeError, 'FIN must be set', true, 1002);
+      }
+
+      if (compressed) {
+        this._loop = false;
+        return error(RangeError, 'RSV1 must be clear', true, 1002);
+      }
+
+      if (this._payloadLength > 0x7d) {
+        this._loop = false;
+        return error(
+          RangeError,
+          `invalid payload length ${this._payloadLength}`,
+          true,
+          1002
+        );
+      }
+    } else {
+      this._loop = false;
+      return error(RangeError, `invalid opcode ${this._opcode}`, true, 1002);
+    }
+
+    if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
+    this._masked = (buf[1] & 0x80) === 0x80;
+
+    if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
+    else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
+    else return this.haveLength();
+  }
+
+  /**
+   * Gets extended payload length (7+16).
+   *
+   * @return {(RangeError|undefined)} A possible error
+   * @private
+   */
+  getPayloadLength16() {
+    if (this._bufferedBytes < 2) {
+      this._loop = false;
+      return;
+    }
+
+    this._payloadLength = this.consume(2).readUInt16BE(0);
+    return this.haveLength();
+  }
+
+  /**
+   * Gets extended payload length (7+64).
+   *
+   * @return {(RangeError|undefined)} A possible error
+   * @private
+   */
+  getPayloadLength64() {
+    if (this._bufferedBytes < 8) {
+      this._loop = false;
+      return;
+    }
+
+    const buf = this.consume(8);
+    const num = buf.readUInt32BE(0);
+
+    //
+    // The maximum safe integer in JavaScript is 2^53 - 1. An error is returned
+    // if payload length is greater than this number.
+    //
+    if (num > Math.pow(2, 53 - 32) - 1) {
+      this._loop = false;
+      return error(
+        RangeError,
+        'Unsupported WebSocket frame: payload length > 2^53 - 1',
+        false,
+        1009
+      );
+    }
+
+    this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
+    return this.haveLength();
+  }
+
+  /**
+   * Payload length has been read.
+   *
+   * @return {(RangeError|undefined)} A possible error
+   * @private
+   */
+  haveLength() {
+    if (this._payloadLength && this._opcode < 0x08) {
+      this._totalPayloadLength += this._payloadLength;
+      if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
+        this._loop = false;
+        return error(RangeError, 'Max payload size exceeded', false, 1009);
+      }
+    }
+
+    if (this._masked) this._state = GET_MASK;
+    else this._state = GET_DATA;
+  }
+
+  /**
+   * Reads mask bytes.
+   *
+   * @private
+   */
+  getMask() {
+    if (this._bufferedBytes < 4) {
+      this._loop = false;
+      return;
+    }
+
+    this._mask = this.consume(4);
+    this._state = GET_DATA;
+  }
+
+  /**
+   * Reads data bytes.
+   *
+   * @param {Function} cb Callback
+   * @return {(Error|RangeError|undefined)} A possible error
+   * @private
+   */
+  getData(cb) {
+    let data = EMPTY_BUFFER;
+
+    if (this._payloadLength) {
+      if (this._bufferedBytes < this._payloadLength) {
+        this._loop = false;
+        return;
+      }
+
+      data = this.consume(this._payloadLength);
+      if (this._masked) unmask(data, this._mask);
+    }
+
+    if (this._opcode > 0x07) return this.controlMessage(data);
+
+    if (this._compressed) {
+      this._state = INFLATING;
+      this.decompress(data, cb);
+      return;
+    }
+
+    if (data.length) {
+      //
+      // This message is not compressed so its lenght is the sum of the payload
+      // length of all fragments.
+      //
+      this._messageLength = this._totalPayloadLength;
+      this._fragments.push(data);
+    }
+
+    return this.dataMessage();
+  }
+
+  /**
+   * Decompresses data.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Function} cb Callback
+   * @private
+   */
+  decompress(data, cb) {
+    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+
+    perMessageDeflate.decompress(data, this._fin, (err, buf) => {
+      if (err) return cb(err);
+
+      if (buf.length) {
+        this._messageLength += buf.length;
+        if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
+          return cb(
+            error(RangeError, 'Max payload size exceeded', false, 1009)
+          );
+        }
+
+        this._fragments.push(buf);
+      }
+
+      const er = this.dataMessage();
+      if (er) return cb(er);
+
+      this.startLoop(cb);
+    });
+  }
+
+  /**
+   * Handles a data message.
+   *
+   * @return {(Error|undefined)} A possible error
+   * @private
+   */
+  dataMessage() {
+    if (this._fin) {
+      const messageLength = this._messageLength;
+      const fragments = this._fragments;
+
+      this._totalPayloadLength = 0;
+      this._messageLength = 0;
+      this._fragmented = 0;
+      this._fragments = [];
+
+      if (this._opcode === 2) {
+        let data;
+
+        if (this._binaryType === 'nodebuffer') {
+          data = concat(fragments, messageLength);
+        } else if (this._binaryType === 'arraybuffer') {
+          data = toArrayBuffer(concat(fragments, messageLength));
+        } else {
+          data = fragments;
+        }
+
+        this.emit('message', data);
+      } else {
+        const buf = concat(fragments, messageLength);
+
+        if (!isValidUTF8(buf)) {
+          this._loop = false;
+          return error(Error, 'invalid UTF-8 sequence', true, 1007);
+        }
+
+        this.emit('message', buf.toString());
+      }
+    }
+
+    this._state = GET_INFO;
+  }
+
+  /**
+   * Handles a control message.
+   *
+   * @param {Buffer} data Data to handle
+   * @return {(Error|RangeError|undefined)} A possible error
+   * @private
+   */
+  controlMessage(data) {
+    if (this._opcode === 0x08) {
+      this._loop = false;
+
+      if (data.length === 0) {
+        this.emit('conclude', 1005, '');
+        this.end();
+      } else if (data.length === 1) {
+        return error(RangeError, 'invalid payload length 1', true, 1002);
+      } else {
+        const code = data.readUInt16BE(0);
+
+        if (!isValidStatusCode(code)) {
+          return error(RangeError, `invalid status code ${code}`, true, 1002);
+        }
+
+        const buf = data.slice(2);
+
+        if (!isValidUTF8(buf)) {
+          return error(Error, 'invalid UTF-8 sequence', true, 1007);
+        }
+
+        this.emit('conclude', code, buf.toString());
+        this.end();
+      }
+    } else if (this._opcode === 0x09) {
+      this.emit('ping', data);
+    } else {
+      this.emit('pong', data);
+    }
+
+    this._state = GET_INFO;
+  }
+}
+
+module.exports = Receiver;
+
+/**
+ * Builds an error object.
+ *
+ * @param {(Error|RangeError)} ErrorCtor The error constructor
+ * @param {String} message The error message
+ * @param {Boolean} prefix Specifies whether or not to add a default prefix to
+ *     `message`
+ * @param {Number} statusCode The status code
+ * @return {(Error|RangeError)} The error
+ * @private
+ */
+function error(ErrorCtor, message, prefix, statusCode) {
+  const err = new ErrorCtor(
+    prefix ? `Invalid WebSocket frame: ${message}` : message
+  );
+
+  Error.captureStackTrace(err, error);
+  err[kStatusCode] = statusCode;
+  return err;
+}

lib_node/ws/sender.js

@@ -0,0 +1,360 @@
+'use strict';
+
+const { randomFillSync } = require('crypto');
+
+const PerMessageDeflate = require('./permessage-deflate');
+const { EMPTY_BUFFER } = require('./constants');
+const { isValidStatusCode } = require('./validation');
+const { mask: applyMask, toBuffer } = require('./buffer-util');
+
+const mask = Buffer.alloc(4);
+
+/**
+ * HyBi Sender implementation.
+ */
+class Sender {
+  /**
+   * Creates a Sender instance.
+   *
+   * @param {net.Socket} socket The connection socket
+   * @param {Object} extensions An object containing the negotiated extensions
+   */
+  constructor(socket, extensions) {
+    this._extensions = extensions || {};
+    this._socket = socket;
+
+    this._firstFragment = true;
+    this._compress = false;
+
+    this._bufferedBytes = 0;
+    this._deflating = false;
+    this._queue = [];
+  }
+
+  /**
+   * Frames a piece of data according to the HyBi WebSocket protocol.
+   *
+   * @param {Buffer} data The data to frame
+   * @param {Object} options Options object
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} options.readOnly Specifies whether `data` can be modified
+   * @param {Boolean} options.fin Specifies whether or not to set the FIN bit
+   * @param {Boolean} options.mask Specifies whether or not to mask `data`
+   * @param {Boolean} options.rsv1 Specifies whether or not to set the RSV1 bit
+   * @return {Buffer[]} The framed data as a list of `Buffer` instances
+   * @public
+   */
+  static frame(data, options) {
+    const merge = options.mask && options.readOnly;
+    let offset = options.mask ? 6 : 2;
+    let payloadLength = data.length;
+
+    if (data.length >= 65536) {
+      offset += 8;
+      payloadLength = 127;
+    } else if (data.length > 125) {
+      offset += 2;
+      payloadLength = 126;
+    }
+
+    const target = Buffer.allocUnsafe(merge ? data.length + offset : offset);
+
+    target[0] = options.fin ? options.opcode | 0x80 : options.opcode;
+    if (options.rsv1) target[0] |= 0x40;
+
+    target[1] = payloadLength;
+
+    if (payloadLength === 126) {
+      target.writeUInt16BE(data.length, 2);
+    } else if (payloadLength === 127) {
+      target.writeUInt32BE(0, 2);
+      target.writeUInt32BE(data.length, 6);
+    }
+
+    if (!options.mask) return [target, data];
+
+    randomFillSync(mask, 0, 4);
+
+    target[1] |= 0x80;
+    target[offset - 4] = mask[0];
+    target[offset - 3] = mask[1];
+    target[offset - 2] = mask[2];
+    target[offset - 1] = mask[3];
+
+    if (merge) {
+      applyMask(data, mask, target, offset, data.length);
+      return [target];
+    }
+
+    applyMask(data, mask, data, 0, data.length);
+    return [target, data];
+  }
+
+  /**
+   * Sends a close message to the other peer.
+   *
+   * @param {(Number|undefined)} code The status code component of the body
+   * @param {String} data The message component of the body
+   * @param {Boolean} mask Specifies whether or not to mask the message
+   * @param {Function} cb Callback
+   * @public
+   */
+  close(code, data, mask, cb) {
+    let buf;
+
+    if (code === undefined) {
+      buf = EMPTY_BUFFER;
+    } else if (typeof code !== 'number' || !isValidStatusCode(code)) {
+      throw new TypeError('First argument must be a valid error code number');
+    } else if (data === undefined || data === '') {
+      buf = Buffer.allocUnsafe(2);
+      buf.writeUInt16BE(code, 0);
+    } else {
+      buf = Buffer.allocUnsafe(2 + Buffer.byteLength(data));
+      buf.writeUInt16BE(code, 0);
+      buf.write(data, 2);
+    }
+
+    if (this._deflating) {
+      this.enqueue([this.doClose, buf, mask, cb]);
+    } else {
+      this.doClose(buf, mask, cb);
+    }
+  }
+
+  /**
+   * Frames and sends a close message.
+   *
+   * @param {Buffer} data The message to send
+   * @param {Boolean} mask Specifies whether or not to mask `data`
+   * @param {Function} cb Callback
+   * @private
+   */
+  doClose(data, mask, cb) {
+    this.sendFrame(
+      Sender.frame(data, {
+        fin: true,
+        rsv1: false,
+        opcode: 0x08,
+        mask,
+        readOnly: false
+      }),
+      cb
+    );
+  }
+
+  /**
+   * Sends a ping message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Boolean} mask Specifies whether or not to mask `data`
+   * @param {Function} cb Callback
+   * @public
+   */
+  ping(data, mask, cb) {
+    const buf = toBuffer(data);
+
+    if (this._deflating) {
+      this.enqueue([this.doPing, buf, mask, toBuffer.readOnly, cb]);
+    } else {
+      this.doPing(buf, mask, toBuffer.readOnly, cb);
+    }
+  }
+
+  /**
+   * Frames and sends a ping message.
+   *
+   * @param {*} data The message to send
+   * @param {Boolean} mask Specifies whether or not to mask `data`
+   * @param {Boolean} readOnly Specifies whether `data` can be modified
+   * @param {Function} cb Callback
+   * @private
+   */
+  doPing(data, mask, readOnly, cb) {
+    this.sendFrame(
+      Sender.frame(data, {
+        fin: true,
+        rsv1: false,
+        opcode: 0x09,
+        mask,
+        readOnly
+      }),
+      cb
+    );
+  }
+
+  /**
+   * Sends a pong message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Boolean} mask Specifies whether or not to mask `data`
+   * @param {Function} cb Callback
+   * @public
+   */
+  pong(data, mask, cb) {
+    const buf = toBuffer(data);
+
+    if (this._deflating) {
+      this.enqueue([this.doPong, buf, mask, toBuffer.readOnly, cb]);
+    } else {
+      this.doPong(buf, mask, toBuffer.readOnly, cb);
+    }
+  }
+
+  /**
+   * Frames and sends a pong message.
+   *
+   * @param {*} data The message to send
+   * @param {Boolean} mask Specifies whether or not to mask `data`
+   * @param {Boolean} readOnly Specifies whether `data` can be modified
+   * @param {Function} cb Callback
+   * @private
+   */
+  doPong(data, mask, readOnly, cb) {
+    this.sendFrame(
+      Sender.frame(data, {
+        fin: true,
+        rsv1: false,
+        opcode: 0x0a,
+        mask,
+        readOnly
+      }),
+      cb
+    );
+  }
+
+  /**
+   * Sends a data message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Object} options Options object
+   * @param {Boolean} options.compress Specifies whether or not to compress `data`
+   * @param {Boolean} options.binary Specifies whether `data` is binary or text
+   * @param {Boolean} options.fin Specifies whether the fragment is the last one
+   * @param {Boolean} options.mask Specifies whether or not to mask `data`
+   * @param {Function} cb Callback
+   * @public
+   */
+  send(data, options, cb) {
+    const buf = toBuffer(data);
+    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+    let opcode = options.binary ? 2 : 1;
+    let rsv1 = options.compress;
+
+    if (this._firstFragment) {
+      this._firstFragment = false;
+      if (rsv1 && perMessageDeflate) {
+        rsv1 = buf.length >= perMessageDeflate._threshold;
+      }
+      this._compress = rsv1;
+    } else {
+      rsv1 = false;
+      opcode = 0;
+    }
+
+    if (options.fin) this._firstFragment = true;
+
+    if (perMessageDeflate) {
+      const opts = {
+        fin: options.fin,
+        rsv1,
+        opcode,
+        mask: options.mask,
+        readOnly: toBuffer.readOnly
+      };
+
+      if (this._deflating) {
+        this.enqueue([this.dispatch, buf, this._compress, opts, cb]);
+      } else {
+        this.dispatch(buf, this._compress, opts, cb);
+      }
+    } else {
+      this.sendFrame(
+        Sender.frame(buf, {
+          fin: options.fin,
+          rsv1: false,
+          opcode,
+          mask: options.mask,
+          readOnly: toBuffer.readOnly
+        }),
+        cb
+      );
+    }
+  }
+
+  /**
+   * Dispatches a data message.
+   *
+   * @param {Buffer} data The message to send
+   * @param {Boolean} compress Specifies whether or not to compress `data`
+   * @param {Object} options Options object
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} options.readOnly Specifies whether `data` can be modified
+   * @param {Boolean} options.fin Specifies whether or not to set the FIN bit
+   * @param {Boolean} options.mask Specifies whether or not to mask `data`
+   * @param {Boolean} options.rsv1 Specifies whether or not to set the RSV1 bit
+   * @param {Function} cb Callback
+   * @private
+   */
+  dispatch(data, compress, options, cb) {
+    if (!compress) {
+      this.sendFrame(Sender.frame(data, options), cb);
+      return;
+    }
+
+    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+
+    this._deflating = true;
+    perMessageDeflate.compress(data, options.fin, (_, buf) => {
+      this._deflating = false;
+      options.readOnly = false;
+      this.sendFrame(Sender.frame(buf, options), cb);
+      this.dequeue();
+    });
+  }
+
+  /**
+   * Executes queued send operations.
+   *
+   * @private
+   */
+  dequeue() {
+    while (!this._deflating && this._queue.length) {
+      const params = this._queue.shift();
+
+      this._bufferedBytes -= params[1].length;
+      Reflect.apply(params[0], this, params.slice(1));
+    }
+  }
+
+  /**
+   * Enqueues a send operation.
+   *
+   * @param {Array} params Send operation parameters.
+   * @private
+   */
+  enqueue(params) {
+    this._bufferedBytes += params[1].length;
+    this._queue.push(params);
+  }
+
+  /**
+   * Sends a frame.
+   *
+   * @param {Buffer[]} list The frame to send
+   * @param {Function} cb Callback
+   * @private
+   */
+  sendFrame(list, cb) {
+    if (list.length === 2) {
+      this._socket.cork();
+      this._socket.write(list[0]);
+      this._socket.write(list[1], cb);
+      this._socket.uncork();
+    } else {
+      this._socket.write(list[0], cb);
+    }
+  }
+}
+
+module.exports = Sender;

lib_node/ws/stream.js

@@ -0,0 +1,150 @@
+'use strict';
+
+const { Duplex } = require('stream');
+
+/**
+ * Emits the `'close'` event on a stream.
+ *
+ * @param {stream.Duplex} The stream.
+ * @private
+ */
+function emitClose(stream) {
+  stream.emit('close');
+}
+
+/**
+ * The listener of the `'end'` event.
+ *
+ * @private
+ */
+function duplexOnEnd() {
+  if (!this.destroyed && this._writableState.finished) {
+    this.destroy();
+  }
+}
+
+/**
+ * The listener of the `'error'` event.
+ *
+ * @private
+ */
+function duplexOnError(err) {
+  this.removeListener('error', duplexOnError);
+  this.destroy();
+  if (this.listenerCount('error') === 0) {
+    // Do not suppress the throwing behavior.
+    this.emit('error', err);
+  }
+}
+
+/**
+ * Wraps a `WebSocket` in a duplex stream.
+ *
+ * @param {WebSocket} ws The `WebSocket` to wrap
+ * @param {Object} options The options for the `Duplex` constructor
+ * @return {stream.Duplex} The duplex stream
+ * @public
+ */
+function createWebSocketStream(ws, options) {
+  let resumeOnReceiverDrain = true;
+
+  function receiverOnDrain() {
+    if (resumeOnReceiverDrain) ws._socket.resume();
+  }
+
+  if (ws.readyState === ws.CONNECTING) {
+    ws.once('open', function open() {
+      ws._receiver.removeAllListeners('drain');
+      ws._receiver.on('drain', receiverOnDrain);
+    });
+  } else {
+    ws._receiver.removeAllListeners('drain');
+    ws._receiver.on('drain', receiverOnDrain);
+  }
+
+  const duplex = new Duplex({
+    ...options,
+    autoDestroy: false,
+    emitClose: false,
+    objectMode: false,
+    readableObjectMode: false,
+    writableObjectMode: false
+  });
+
+  ws.on('message', function message(msg) {
+    if (!duplex.push(msg)) {
+      resumeOnReceiverDrain = false;
+      ws._socket.pause();
+    }
+  });
+
+  ws.once('error', function error(err) {
+    duplex.destroy(err);
+  });
+
+  ws.once('close', function close() {
+    if (duplex.destroyed) return;
+
+    duplex.push(null);
+  });
+
+  duplex._destroy = function(err, callback) {
+    if (ws.readyState === ws.CLOSED) {
+      callback(err);
+      process.nextTick(emitClose, duplex);
+      return;
+    }
+
+    ws.once('close', function close() {
+      callback(err);
+      process.nextTick(emitClose, duplex);
+    });
+    ws.terminate();
+  };
+
+  duplex._final = function(callback) {
+    if (ws.readyState === ws.CONNECTING) {
+      ws.once('open', function open() {
+        duplex._final(callback);
+      });
+      return;
+    }
+
+    if (ws._socket._writableState.finished) {
+      if (duplex._readableState.endEmitted) duplex.destroy();
+      callback();
+    } else {
+      ws._socket.once('finish', function finish() {
+        // `duplex` is not destroyed here because the `'end'` event will be
+        // emitted on `duplex` after this `'finish'` event. The EOF signaling
+        // `null` chunk is, in fact, pushed when the WebSocket emits `'close'`.
+        callback();
+      });
+      ws.close();
+    }
+  };
+
+  duplex._read = function() {
+    if (ws.readyState === ws.OPEN && !resumeOnReceiverDrain) {
+      resumeOnReceiverDrain = true;
+      if (!ws._receiver._writableState.needDrain) ws._socket.resume();
+    }
+  };
+
+  duplex._write = function(chunk, encoding, callback) {
+    if (ws.readyState === ws.CONNECTING) {
+      ws.once('open', function open() {
+        duplex._write(chunk, encoding, callback);
+      });
+      return;
+    }
+
+    ws.send(chunk, callback);
+  };
+
+  duplex.on('end', duplexOnEnd);
+  duplex.on('error', duplexOnError);
+  return duplex;
+}
+
+module.exports = createWebSocketStream;