1.8.1

Hqx fix (#629 )
* Optimising wasm so it doesn't break Chrome * Simpler dockerfile (thanks surma!)
2019-06-19 12:25:18 +01:00 · 2019-06-19 12:24:24 +01:00 · 2019-06-18 12:56:24 +01:00 · 2019-06-18 11:30:57 +00:00 · 2019-06-18 12:24:41 +01:00 · 2019-06-18 12:23:22 +01:00
83 changed files with 6924 additions and 5385 deletions
--- a/.nvmrc
+++ b/.nvmrc
@ -0,0 +1 @@
+10.16.0
--- a/.travis.yml
+++ b/.travis.yml
@ -1,7 +1,4 @@
 language: node_js
-node_js:
- node
- 10
- 8
 cache: npm
 script: npm run build
+after_success: npm run sizereport
--- a/codecs/hqx/.gitignore
+++ b/codecs/hqx/.gitignore
@ -0,0 +1,5 @@
+**/*.rs.bk
+target
+Cargo.lock
+bin/
+pkg/README.md
--- a/codecs/hqx/Cargo.toml
+++ b/codecs/hqx/Cargo.toml
@ -0,0 +1,37 @@
+[package]
+name = "squooshhqx"
+version = "0.1.0"
+authors = ["Surma <surma@surma.link>"]
+
+[lib]
+crate-type = ["cdylib"]
+
+[features]
+default = ["console_error_panic_hook", "wee_alloc"]
+
+[dependencies]
+cfg-if = "0.1.2"
+wasm-bindgen = "0.2.38"
+# lazy_static = "1.0.0"
+hqx = {git = "https://github.com/CryZe/wasmboy-rs", tag="v0.1.2"}
+
+# The `console_error_panic_hook` crate provides better debugging of panics by
+# logging them with `console.error`. This is great for development, but requires
+# all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
+# code size when deploying.
+console_error_panic_hook = { version = "0.1.1", optional = true }
+
+# `wee_alloc` is a tiny allocator for wasm that is only ~1K in code size
+# compared to the default allocator's ~10K. It is slower than the default
+# allocator, however.
+#
+# Unfortunately, `wee_alloc` requires nightly Rust when targeting wasm for now.
+wee_alloc = { version = "0.4.2", optional = true }
+
+[dev-dependencies]
+wasm-bindgen-test = "0.2"
+
+[profile.release]
+# Tell `rustc` to optimize for small code size.
+opt-level = "s"
+lto = true
--- a/codecs/hqx/Dockerfile
+++ b/codecs/hqx/Dockerfile
@ -0,0 +1,21 @@
+FROM ubuntu
+RUN apt-get update && \
+  apt-get install -qqy git build-essential cmake python2.7
+
+RUN git clone --depth 1 --recursive https://github.com/WebAssembly/wabt /usr/src/wabt
+RUN mkdir -p /usr/src/wabt/build
+WORKDIR /usr/src/wabt/build
+RUN cmake .. -DCMAKE_INSTALL_PREFIX=/opt/wabt && \
+  make && \
+  make install
+
+FROM rust
+RUN rustup install nightly && \
+  rustup target add --toolchain nightly wasm32-unknown-unknown && \
+  cargo install wasm-pack
+
+COPY --from=0 /opt/wabt /opt/wabt
+RUN mkdir /opt/binaryen && \
+ curl -L https://github.com/WebAssembly/binaryen/releases/download/1.38.32/binaryen-1.38.32-x86-linux.tar.gz  | tar -xzf - -C /opt/binaryen --strip 1
+ENV PATH="/opt/binaryen:/opt/wabt/bin:${PATH}"
+WORKDIR /src
--- a/codecs/hqx/build.sh
+++ b/codecs/hqx/build.sh
@ -0,0 +1,26 @@
+#!/bin/bash
+
+set -e
+
+echo "============================================="
+echo "Compiling wasm"
+echo "============================================="
+(
+  rustup run nightly \
+    wasm-pack build --target no-modules
+  wasm-strip pkg/squooshhqx_bg.wasm
+  echo "Optimising WASM so it doesn't break Chrome (this takes like 10-15mins. get a cup of tea)"
+  echo "Once https://bugs.chromium.org/p/chromium/issues/detail?id=97480 is fixed, we can remove this step"
+  wasm-opt -Os --no-validation -o pkg/squooshhqx_bg.wasm pkg/squooshhqx_bg.wasm
+  rm pkg/.gitignore
+)
+echo "============================================="
+echo "Compiling wasm  done"
+echo "============================================="
+
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+echo "Did you update your docker image?"
+echo "Run \`docker pull ubuntu\`"
+echo "Run \`docker pull rust\`"
+echo "Run \`docker build -t squoosh-hqx .\`"
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
--- a/codecs/hqx/index.html
+++ b/codecs/hqx/index.html
@ -0,0 +1,24 @@
+<!doctype html>
+<script src ="./pkg/squooshhqx.js"></script>
+<script type="module">
+  async function run() {
+    await wasm_bindgen("./pkg/squooshhqx_bg.wasm");
+    const bitmap = await createImageBitmap(await fetch("https://i.imgur.com/MNDnBSc.png").then(r => r.blob()));
+    const canvas = document.createElement("canvas");
+    canvas.width = bitmap.width;
+    canvas.height = bitmap.height;
+    const ctx = canvas.getContext("2d");
+    ctx.drawImage(bitmap, 0, 0);
+    const imgdata = ctx.getImageData(0, 0, bitmap.width, bitmap.height);
+    const factor = 4;
+    const r = wasm_bindgen.resize(new Uint32Array(imgdata.data.buffer), bitmap.width, bitmap.height, factor);
+
+    canvas.width = bitmap.width * factor;
+    canvas.height = bitmap.height * factor;
+    const output = new ImageData(new Uint8ClampedArray(r.buffer), canvas.width, canvas.height);
+    ctx.putImageData(output, 0, 0);
+    canvas.style = `width: ${canvas.width}px; height: ${canvas.height}px; image-rendering: pixelated;`;
+    document.body.append(canvas);
+  }
+  run();
+</script>
--- a/codecs/hqx/package-lock.json
+++ b/codecs/hqx/package-lock.json
@ -0,0 +1,4 @@
+{
+  "name": "hqx",
+  "lockfileVersion": 1
+}
--- a/codecs/hqx/package.json
+++ b/codecs/hqx/package.json
@ -0,0 +1,7 @@
+{
+  "name": "hqx",
+  "scripts": {
+    "build:image": "docker build -t squoosh-hqx .",
+    "build": "docker run --rm -v $(pwd):/src squoosh-hqx ./build.sh"
+  }
+}
--- a/codecs/hqx/pkg/package.json
+++ b/codecs/hqx/pkg/package.json
@ -0,0 +1,14 @@
+{
+  "name": "squooshhqx",
+  "collaborators": [
+    "Surma <surma@surma.link>"
+  ],
+  "version": "0.1.0",
+  "files": [
+    "squooshhqx_bg.wasm",
+    "squooshhqx.js",
+    "squooshhqx.d.ts"
+  ],
+  "browser": "squooshhqx.js",
+  "types": "squooshhqx.d.ts"
+}
--- a/codecs/hqx/pkg/squooshhqx.d.ts
+++ b/codecs/hqx/pkg/squooshhqx.d.ts
@ -0,0 +1,20 @@
+/* tslint:disable */
+/**
+* @param {Uint32Array} input_image 
+* @param {number} input_width 
+* @param {number} input_height 
+* @param {number} factor 
+* @returns {Uint32Array} 
+*/
+export function resize(input_image: Uint32Array, input_width: number, input_height: number, factor: number): Uint32Array;
+
+/**
+* If `module_or_path` is {RequestInfo}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {RequestInfo | BufferSource | WebAssembly.Module} module_or_path
+*
+* @returns {Promise<any>}
+*/
+export default function init (module_or_path: RequestInfo | BufferSource | WebAssembly.Module): Promise<any>;
+        
--- a/codecs/hqx/pkg/squooshhqx.js
+++ b/codecs/hqx/pkg/squooshhqx.js
@ -0,0 +1,97 @@
+(function() {
+    const __exports = {};
+    let wasm;
+
+    let cachegetUint32Memory = null;
+    function getUint32Memory() {
+        if (cachegetUint32Memory === null || cachegetUint32Memory.buffer !== wasm.memory.buffer) {
+            cachegetUint32Memory = new Uint32Array(wasm.memory.buffer);
+        }
+        return cachegetUint32Memory;
+    }
+
+    let WASM_VECTOR_LEN = 0;
+
+    function passArray32ToWasm(arg) {
+        const ptr = wasm.__wbindgen_malloc(arg.length * 4);
+        getUint32Memory().set(arg, ptr / 4);
+        WASM_VECTOR_LEN = arg.length;
+        return ptr;
+    }
+
+    function getArrayU32FromWasm(ptr, len) {
+        return getUint32Memory().subarray(ptr / 4, ptr / 4 + len);
+    }
+
+    let cachedGlobalArgumentPtr = null;
+    function globalArgumentPtr() {
+        if (cachedGlobalArgumentPtr === null) {
+            cachedGlobalArgumentPtr = wasm.__wbindgen_global_argument_ptr();
+        }
+        return cachedGlobalArgumentPtr;
+    }
+    /**
+    * @param {Uint32Array} input_image
+    * @param {number} input_width
+    * @param {number} input_height
+    * @param {number} factor
+    * @returns {Uint32Array}
+    */
+    __exports.resize = function(input_image, input_width, input_height, factor) {
+        const ptr0 = passArray32ToWasm(input_image);
+        const len0 = WASM_VECTOR_LEN;
+        const retptr = globalArgumentPtr();
+        wasm.resize(retptr, ptr0, len0, input_width, input_height, factor);
+        const mem = getUint32Memory();
+        const rustptr = mem[retptr / 4];
+        const rustlen = mem[retptr / 4 + 1];
+
+        const realRet = getArrayU32FromWasm(rustptr, rustlen).slice();
+        wasm.__wbindgen_free(rustptr, rustlen * 4);
+        return realRet;
+
+    };
+
+    function init(module) {
+
+        let result;
+        const imports = {};
+
+        if (module instanceof URL || typeof module === 'string' || module instanceof Request) {
+
+            const response = fetch(module);
+            if (typeof WebAssembly.instantiateStreaming === 'function') {
+                result = WebAssembly.instantiateStreaming(response, imports)
+                .catch(e => {
+                    console.warn("`WebAssembly.instantiateStreaming` failed. Assuming this is because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+                    return response
+                    .then(r => r.arrayBuffer())
+                    .then(bytes => WebAssembly.instantiate(bytes, imports));
+                });
+            } else {
+                result = response
+                .then(r => r.arrayBuffer())
+                .then(bytes => WebAssembly.instantiate(bytes, imports));
+            }
+        } else {
+
+            result = WebAssembly.instantiate(module, imports)
+            .then(result => {
+                if (result instanceof WebAssembly.Instance) {
+                    return { instance: result, module };
+                } else {
+                    return result;
+                }
+            });
+        }
+        return result.then(({instance, module}) => {
+            wasm = instance.exports;
+            init.__wbindgen_wasm_module = module;
+
+            return wasm;
+        });
+    }
+
+    self.wasm_bindgen = Object.assign(init, __exports);
+
+})();
--- a/codecs/hqx/pkg/squooshhqx_bg.d.ts
+++ b/codecs/hqx/pkg/squooshhqx_bg.d.ts
@ -0,0 +1,6 @@
+/* tslint:disable */
+export const memory: WebAssembly.Memory;
+export function resize(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function __wbindgen_global_argument_ptr(): number;
+export function __wbindgen_malloc(a: number): number;
+export function __wbindgen_free(a: number, b: number): void;
--- a/codecs/hqx/pkg/squooshhqx_bg.wasm
+++ b/codecs/hqx/pkg/squooshhqx_bg.wasm
--- a/codecs/hqx/src/lib.rs
+++ b/codecs/hqx/src/lib.rs
@ -0,0 +1,55 @@
+extern crate cfg_if;
+extern crate hqx;
+extern crate wasm_bindgen;
+
+mod utils;
+
+use cfg_if::cfg_if;
+use wasm_bindgen::prelude::*;
+
+cfg_if! {
+    // When the `wee_alloc` feature is enabled, use `wee_alloc` as the global
+    // allocator.
+    if #[cfg(feature = "wee_alloc")] {
+        extern crate wee_alloc;
+        #[global_allocator]
+        static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
+    }
+}
+
+#[wasm_bindgen]
+#[no_mangle]
+pub fn resize(
+    input_image: Vec<u32>,
+    input_width: usize,
+    input_height: usize,
+    factor: usize,
+) -> Vec<u32> {
+    let num_output_pixels = input_width * input_height * factor * factor;
+    let mut output_image = Vec::<u32>::with_capacity(num_output_pixels * 4);
+    output_image.resize(num_output_pixels, 0);
+
+    match factor {
+        2 => hqx::hq2x(
+            input_image.as_slice(),
+            output_image.as_mut_slice(),
+            input_width,
+            input_height,
+        ),
+        3 => hqx::hq3x(
+            input_image.as_slice(),
+            output_image.as_mut_slice(),
+            input_width,
+            input_height,
+        ),
+        4 => hqx::hq4x(
+            input_image.as_slice(),
+            output_image.as_mut_slice(),
+            input_width,
+            input_height,
+        ),
+        _ => unreachable!(),
+    };
+
+    return output_image;
+}
--- a/codecs/hqx/src/utils.rs
+++ b/codecs/hqx/src/utils.rs
@ -0,0 +1,17 @@
+use cfg_if::cfg_if;
+
+cfg_if! {
+    // When the `console_error_panic_hook` feature is enabled, we can call the
+    // `set_panic_hook` function at least once during initialization, and then
+    // we will get better error messages if our code ever panics.
+    //
+    // For more details see
+    // https://github.com/rustwasm/console_error_panic_hook#readme
+    if #[cfg(feature = "console_error_panic_hook")] {
+        extern crate console_error_panic_hook;
+        pub use self::console_error_panic_hook::set_once as set_panic_hook;
+    } else {
+        #[inline]
+        pub fn set_panic_hook() {}
+    }
+}
--- a/codecs/resize/.gitignore
+++ b/codecs/resize/.gitignore
@ -0,0 +1,6 @@
+**/*.rs.bk
+target
+Cargo.lock
+bin/
+pkg/README.md
+lut.inc
--- a/codecs/resize/Cargo.toml
+++ b/codecs/resize/Cargo.toml
@ -0,0 +1,37 @@
+[package]
+name = "squooshresize"
+version = "0.1.0"
+authors = ["Surma <surma@surma.link>"]
+
+[lib]
+#crate-type = ["cdylib", "rlib"]
+crate-type = ["cdylib"]
+
+[features]
+default = ["console_error_panic_hook", "wee_alloc"]
+
+[dependencies]
+cfg-if = "0.1.2"
+wasm-bindgen = "0.2.38"
+resize = "0.3.0"
+
+# The `console_error_panic_hook` crate provides better debugging of panics by
+# logging them with `console.error`. This is great for development, but requires
+# all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
+# code size when deploying.
+console_error_panic_hook = { version = "0.1.1", optional = true }
+
+# `wee_alloc` is a tiny allocator for wasm that is only ~1K in code size
+# compared to the default allocator's ~10K. It is slower than the default
+# allocator, however.
+#
+# Unfortunately, `wee_alloc` requires nightly Rust when targeting wasm for now.
+wee_alloc = { version = "0.4.2", optional = true }
+
+[dev-dependencies]
+wasm-bindgen-test = "0.2"
+
+[profile.release]
+# Tell `rustc` to optimize for small code size.
+opt-level = "s"
+lto = true
--- a/codecs/resize/Dockerfile
+++ b/codecs/resize/Dockerfile
@ -0,0 +1,18 @@
+FROM ubuntu
+RUN apt-get update && \
+  apt-get install -qqy git build-essential cmake python2.7
+RUN git clone --recursive https://github.com/WebAssembly/wabt /usr/src/wabt
+RUN mkdir -p /usr/src/wabt/build
+WORKDIR /usr/src/wabt/build
+RUN cmake .. -DCMAKE_INSTALL_PREFIX=/opt/wabt && \
+  make && \
+  make install
+
+FROM rust
+RUN rustup install nightly && \
+  rustup target add --toolchain nightly wasm32-unknown-unknown && \
+  cargo install wasm-pack
+
+COPY --from=0 /opt/wabt /opt/wabt
+ENV PATH="/opt/wabt/bin:${PATH}"
+WORKDIR /src
--- a/codecs/resize/benchmark.js
+++ b/codecs/resize/benchmark.js
@ -0,0 +1,53 @@
+// THIS IS NOT A NODE SCRIPT
+// This is a d8 script. Please install jsvu[1] and install v8.
+// Then run `npm run --silent benchmark`.
+// [1]: https://github.com/GoogleChromeLabs/jsvu
+
+self = global = this;
+load("./pkg/resize.js");
+
+async function init() {
+  //  Adjustable constants.
+  const inputDimensions = 2000;
+  const outputDimensions = 1500;
+  const algorithm = 3; // Lanczos
+  const iterations = new Array(100);
+
+  // Constants. Don’t change.
+  const imageByteSize = inputDimensions * inputDimensions * 4;
+  const imageBuffer = new Uint8ClampedArray(imageByteSize);
+
+  const module = await WebAssembly.compile(readbuffer("./pkg/resize_bg.wasm"));
+  await wasm_bindgen(module);
+  [[false, false], [true, false], [false, true], [true, true]].forEach(
+    opts => {
+      print(`\npremultiplication: ${opts[0]}`);
+      print(`color space conversion: ${opts[1]}`);
+      print(`==============================`);
+      for (let i = 0; i < 100; i++) {
+        const start = Date.now();
+        wasm_bindgen.resize(
+          imageBuffer,
+          inputDimensions,
+          inputDimensions,
+          outputDimensions,
+          outputDimensions,
+          algorithm,
+          ...opts
+        );
+        iterations[i] = Date.now() - start;
+      }
+      const average =
+        iterations.reduce((sum, c) => sum + c) / iterations.length;
+      const stddev = Math.sqrt(
+        iterations
+          .map(i => Math.pow(i - average, 2))
+          .reduce((sum, c) => sum + c) / iterations.length
+      );
+      print(`n = ${iterations.length}`);
+      print(`Average: ${average}`);
+      print(`StdDev: ${stddev}`);
+    }
+  );
+}
+init().catch(e => console.error(e, e.stack));
--- a/codecs/resize/build.rs
+++ b/codecs/resize/build.rs
@ -0,0 +1,23 @@
+include!("./src/srgb.rs");
+
+use std::io::Write;
+
+fn main() -> std::io::Result<()> {
+    let mut srgb_to_linear_lut = String::from("static SRGB_TO_LINEAR_LUT: [f32; 256] = [");
+    let mut linear_to_srgb_lut = String::from("static LINEAR_TO_SRGB_LUT: [f32; 256] = [");
+    for i in 0..256 {
+        srgb_to_linear_lut.push_str(&format!("{0:.7}", srgb_to_linear((i as f32) / 255.0)));
+        srgb_to_linear_lut.push_str(",");
+        linear_to_srgb_lut.push_str(&format!("{0:.7}", linear_to_srgb((i as f32) / 255.0)));
+        linear_to_srgb_lut.push_str(",");
+    }
+    srgb_to_linear_lut.pop().unwrap();
+    linear_to_srgb_lut.pop().unwrap();
+    srgb_to_linear_lut.push_str("];");
+    linear_to_srgb_lut.push_str("];");
+
+    let mut file = std::fs::File::create("src/lut.inc")?;
+    file.write_all(srgb_to_linear_lut.as_bytes())?;
+    file.write_all(linear_to_srgb_lut.as_bytes())?;
+    Ok(())
+}
--- a/codecs/resize/build.sh
+++ b/codecs/resize/build.sh
@ -0,0 +1,22 @@
+#!/bin/bash
+
+set -e
+
+echo "============================================="
+echo "Compiling wasm"
+echo "============================================="
+(
+  rustup run nightly \
+    wasm-pack build --target no-modules
+  wasm-strip pkg/resize_bg.wasm
+)
+echo "============================================="
+echo "Compiling wasm  done"
+echo "============================================="
+
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+echo "Did you update your docker image?"
+echo "Run \`docker pull ubuntu\`"
+echo "Run \`docker pull rust\`"
+echo "Run \`docker build -t squoosh-resize .\`"
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
--- a/codecs/resize/package-lock.json
+++ b/codecs/resize/package-lock.json
@ -0,0 +1,4 @@
+{
+  "name": "resize",
+  "lockfileVersion": 1
+}
--- a/codecs/resize/package.json
+++ b/codecs/resize/package.json
@ -0,0 +1,8 @@
+{
+  "name": "resize",
+  "scripts": {
+    "build:image": "docker build -t squoosh-resize .",
+    "build": "docker run --rm -v $(pwd):/src squoosh-resize ./build.sh",
+    "benchmark": "v8 --no-liftoff --no-wasm-tier-up ./benchmark.js"
+  }
+}
--- a/codecs/resize/pkg/resize.d.ts
+++ b/codecs/resize/pkg/resize.d.ts
@ -0,0 +1,13 @@
+/* tslint:disable */
+/**
+* @param {Uint8Array} arg0 
+* @param {number} arg1 
+* @param {number} arg2 
+* @param {number} arg3 
+* @param {number} arg4 
+* @param {number} arg5 
+* @param {boolean} arg6 
+* @param {boolean} arg7 
+* @returns {Uint8Array} 
+*/
+export function resize(arg0: Uint8Array, arg1: number, arg2: number, arg3: number, arg4: number, arg5: number, arg6: boolean, arg7: boolean): Uint8Array;
--- a/codecs/resize/pkg/resize.js
+++ b/codecs/resize/pkg/resize.js
@ -0,0 +1,114 @@
+(function() {
+    var wasm;
+    const __exports = {};
+
+
+    let cachegetUint8Memory = null;
+    function getUint8Memory() {
+        if (cachegetUint8Memory === null || cachegetUint8Memory.buffer !== wasm.memory.buffer) {
+            cachegetUint8Memory = new Uint8Array(wasm.memory.buffer);
+        }
+        return cachegetUint8Memory;
+    }
+
+    let WASM_VECTOR_LEN = 0;
+
+    function passArray8ToWasm(arg) {
+        const ptr = wasm.__wbindgen_malloc(arg.length * 1);
+        getUint8Memory().set(arg, ptr / 1);
+        WASM_VECTOR_LEN = arg.length;
+        return ptr;
+    }
+
+    function getArrayU8FromWasm(ptr, len) {
+        return getUint8Memory().subarray(ptr / 1, ptr / 1 + len);
+    }
+
+    let cachedGlobalArgumentPtr = null;
+    function globalArgumentPtr() {
+        if (cachedGlobalArgumentPtr === null) {
+            cachedGlobalArgumentPtr = wasm.__wbindgen_global_argument_ptr();
+        }
+        return cachedGlobalArgumentPtr;
+    }
+
+    let cachegetUint32Memory = null;
+    function getUint32Memory() {
+        if (cachegetUint32Memory === null || cachegetUint32Memory.buffer !== wasm.memory.buffer) {
+            cachegetUint32Memory = new Uint32Array(wasm.memory.buffer);
+        }
+        return cachegetUint32Memory;
+    }
+    /**
+    * @param {Uint8Array} arg0
+    * @param {number} arg1
+    * @param {number} arg2
+    * @param {number} arg3
+    * @param {number} arg4
+    * @param {number} arg5
+    * @param {boolean} arg6
+    * @param {boolean} arg7
+    * @returns {Uint8Array}
+    */
+    __exports.resize = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        const ptr0 = passArray8ToWasm(arg0);
+        const len0 = WASM_VECTOR_LEN;
+        const retptr = globalArgumentPtr();
+        wasm.resize(retptr, ptr0, len0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+        const mem = getUint32Memory();
+        const rustptr = mem[retptr / 4];
+        const rustlen = mem[retptr / 4 + 1];
+
+        const realRet = getArrayU8FromWasm(rustptr, rustlen).slice();
+        wasm.__wbindgen_free(rustptr, rustlen * 1);
+        return realRet;
+
+    };
+
+    const heap = new Array(32);
+
+    heap.fill(undefined);
+
+    heap.push(undefined, null, true, false);
+
+    let heap_next = heap.length;
+
+    function dropObject(idx) {
+        if (idx < 36) return;
+        heap[idx] = heap_next;
+        heap_next = idx;
+    }
+
+    __exports.__wbindgen_object_drop_ref = function(i) { dropObject(i); };
+
+    function init(path_or_module) {
+        let instantiation;
+        const imports = { './resize': __exports };
+        if (path_or_module instanceof WebAssembly.Module) {
+            instantiation = WebAssembly.instantiate(path_or_module, imports)
+            .then(instance => {
+            return { instance, module: path_or_module }
+        });
+    } else {
+        const data = fetch(path_or_module);
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            instantiation = WebAssembly.instantiateStreaming(data, imports)
+            .catch(e => {
+                console.warn("`WebAssembly.instantiateStreaming` failed. Assuming this is because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+                return data
+                .then(r => r.arrayBuffer())
+                .then(bytes => WebAssembly.instantiate(bytes, imports));
+            });
+        } else {
+            instantiation = data
+            .then(response => response.arrayBuffer())
+            .then(buffer => WebAssembly.instantiate(buffer, imports));
+        }
+    }
+    return instantiation.then(({instance}) => {
+        wasm = init.wasm = instance.exports;
+
+    });
+};
+self.wasm_bindgen = Object.assign(init, __exports);
+})();
--- a/codecs/resize/pkg/resize_bg.d.ts
+++ b/codecs/resize/pkg/resize_bg.d.ts
@ -0,0 +1,6 @@
+/* tslint:disable */
+export const memory: WebAssembly.Memory;
+export function __wbindgen_global_argument_ptr(): number;
+export function __wbindgen_malloc(a: number): number;
+export function __wbindgen_free(a: number, b: number): void;
+export function resize(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number): void;
--- a/codecs/resize/pkg/resize_bg.wasm
+++ b/codecs/resize/pkg/resize_bg.wasm
--- a/codecs/resize/src/lib.rs
+++ b/codecs/resize/src/lib.rs
@ -0,0 +1,121 @@
+extern crate cfg_if;
+extern crate resize;
+extern crate wasm_bindgen;
+
+mod utils;
+
+use cfg_if::cfg_if;
+use resize::Pixel::RGBA;
+use resize::Type;
+use wasm_bindgen::prelude::*;
+
+mod srgb;
+use srgb::Clamp;
+
+cfg_if! {
+    // When the `wee_alloc` feature is enabled, use `wee_alloc` as the global
+    // allocator.
+    if #[cfg(feature = "wee_alloc")] {
+        extern crate wee_alloc;
+        #[global_allocator]
+        static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
+    }
+}
+
+include!("./lut.inc");
+
+// If `with_space_conversion` is true, this function returns 2 functions that
+// convert from sRGB to linear RGB and vice versa. If `with_space_conversion` is
+// false, the 2 functions returned do nothing.
+fn converter_funcs(with_space_conversion: bool) -> ((fn(u8) -> f32), (fn(f32) -> u8)) {
+    if with_space_conversion {
+        (
+            |v| SRGB_TO_LINEAR_LUT[v as usize] * 255.0,
+            |v| (LINEAR_TO_SRGB_LUT[v as usize] * 255.0) as u8,
+        )
+    } else {
+        (|v| v as f32, |v| v as u8)
+    }
+}
+
+// If `with_alpha_premultiplication` is true, this function returns a function
+// that premultiply the alpha channel with the given channel value and another
+// function that reverses that process. If `with_alpha_premultiplication` is
+// false, the functions just return the channel value.
+fn alpha_multiplier_funcs(
+    with_alpha_premultiplication: bool,
+) -> ((fn(f32, u8) -> u8), (fn(u8, u8) -> f32)) {
+    if with_alpha_premultiplication {
+        (
+            |v, a| (v * (a as f32) / 255.0) as u8,
+            |v, a| (v as f32) * 255.0 / (a as f32).clamp(0.0, 255.0),
+        )
+    } else {
+        (|v, _a| v as u8, |v, _a| v as f32)
+    }
+}
+
+#[wasm_bindgen]
+#[no_mangle]
+pub fn resize(
+    mut input_image: Vec<u8>,
+    input_width: usize,
+    input_height: usize,
+    output_width: usize,
+    output_height: usize,
+    typ_idx: usize,
+    premultiply: bool,
+    color_space_conversion: bool,
+) -> Vec<u8> {
+    let typ = match typ_idx {
+        0 => Type::Triangle,
+        1 => Type::Catrom,
+        2 => Type::Mitchell,
+        3 => Type::Lanczos3,
+        _ => panic!("Nope"),
+    };
+    let num_input_pixels = input_width * input_height;
+    let num_output_pixels = output_width * output_height;
+
+    let (to_linear, to_color_space) = converter_funcs(color_space_conversion);
+    let (premultiplier, demultiplier) = alpha_multiplier_funcs(premultiply);
+
+    // If both options are false, there is no preprocessing on the pixel valus
+    // and we can skip the loop.
+    if premultiply || color_space_conversion {
+        for i in 0..num_input_pixels {
+            for j in 0..3 {
+                input_image[4 * i + j] =
+                    premultiplier(to_linear(input_image[4 * i + j]), input_image[4 * i + 3]);
+            }
+        }
+    }
+
+    let mut resizer = resize::new(
+        input_width,
+        input_height,
+        output_width,
+        output_height,
+        RGBA,
+        typ,
+    );
+    let mut output_image = Vec::<u8>::with_capacity(num_output_pixels * 4);
+    output_image.resize(num_output_pixels * 4, 0);
+    resizer.resize(input_image.as_slice(), output_image.as_mut_slice());
+
+    if premultiply || color_space_conversion {
+        for i in 0..num_output_pixels {
+            for j in 0..3 {
+                // We don’t need to worry about division by zero, as division by zero
+                // is well-defined on floats to return ±Inf. ±Inf is converted to 0
+                // when casting to integers.
+                output_image[4 * i + j] = to_color_space(demultiplier(
+                    output_image[4 * i + j],
+                    output_image[4 * i + 3],
+                ));
+            }
+        }
+    }
+
+    return output_image;
+}
--- a/codecs/resize/src/srgb.rs
+++ b/codecs/resize/src/srgb.rs
@ -0,0 +1,29 @@
+pub trait Clamp: std::cmp::PartialOrd + Sized {
+    fn clamp(self, min: Self, max: Self) -> Self {
+        if self.lt(&min) {
+            min
+        } else if self.gt(&max) {
+            max
+        } else {
+            self
+        }
+    }
+}
+
+impl Clamp for f32 {}
+
+pub fn srgb_to_linear(v: f32) -> f32 {
+    if v < 0.04045 {
+        v / 12.92
+    } else {
+        ((v + 0.055) / 1.055).powf(2.4).clamp(0.0, 1.0)
+    }
+}
+
+pub fn linear_to_srgb(v: f32) -> f32 {
+    if v < 0.0031308 {
+        v * 12.92
+    } else {
+        (1.055 * v.powf(1.0 / 2.4) - 0.055).clamp(0.0, 1.0)
+    }
+}
--- a/codecs/resize/src/utils.rs
+++ b/codecs/resize/src/utils.rs
@ -0,0 +1,17 @@
+use cfg_if::cfg_if;
+
+cfg_if! {
+    // When the `console_error_panic_hook` feature is enabled, we can call the
+    // `set_panic_hook` function at least once during initialization, and then
+    // we will get better error messages if our code ever panics.
+    //
+    // For more details see
+    // https://github.com/rustwasm/console_error_panic_hook#readme
+    if #[cfg(feature = "console_error_panic_hook")] {
+        extern crate console_error_panic_hook;
+        pub use self::console_error_panic_hook::set_once as set_panic_hook;
+    } else {
+        #[inline]
+        pub fn set_panic_hook() {}
+    }
+}
--- a/codecs/rotate/.gitignore
+++ b/codecs/rotate/.gitignore
@ -0,0 +1,2 @@
+target
+Cargo.lock
--- a/codecs/rotate/Cargo.toml
+++ b/codecs/rotate/Cargo.toml
@ -0,0 +1,14 @@
+[package]
+name = "rotate"
+version = "0.1.0"
+authors = ["Surma <surma@google.com>"]
+edition = "2018"
+
+[lib]
+name = "rotate"
+path = "rotate.rs"
+crate-type = ["cdylib", "rlib"]
+
+[profile.release]
+lto = true
+opt-level = "s"
--- a/codecs/rotate/Dockerfile
+++ b/codecs/rotate/Dockerfile
@ -0,0 +1,17 @@
+FROM ubuntu
+RUN apt-get update && \
+  apt-get install -qqy git build-essential cmake python2.7
+RUN git clone --recursive https://github.com/WebAssembly/wabt /usr/src/wabt
+RUN mkdir -p /usr/src/wabt/build
+WORKDIR /usr/src/wabt/build
+RUN cmake .. -DCMAKE_INSTALL_PREFIX=/opt/wabt && \
+  make && \
+  make install
+
+FROM rust
+RUN rustup install nightly && \
+  rustup target add --toolchain nightly wasm32-unknown-unknown
+
+COPY --from=0 /opt/wabt /opt/wabt
+ENV PATH="/opt/wabt/bin:${PATH}"
+WORKDIR /src
--- a/codecs/rotate/benchmark.js
+++ b/codecs/rotate/benchmark.js
@ -0,0 +1,45 @@
+// THIS IS NOT A NODE SCRIPT
+// This is a d8 script. Please install jsvu[1] and install v8.
+// Then run `npm run --silent benchmark`.
+// [1]: https://github.com/GoogleChromeLabs/jsvu
+async function init() {
+  //  Adjustable constants.
+  const imageDimensions = 4096;
+  const iterations = new Array(100);
+
+  // Constants. Don’t change.
+  const imageByteSize = imageDimensions * imageDimensions * 4;
+  const wasmPageSize = 64 * 1024;
+
+  const buffer = readbuffer("rotate.wasm");
+  const { instance } = await WebAssembly.instantiate(buffer);
+
+  const pagesAvailable = Math.floor(
+    instance.exports.memory.buffer.byteLength / wasmPageSize
+  );
+  const pagesNeeded = Math.floor((imageByteSize * 2 + 4) / wasmPageSize) + 1;
+  const additionalPagesNeeded = pagesNeeded - pagesAvailable;
+  if (additionalPagesNeeded > 0) {
+    instance.exports.memory.grow(additionalPagesNeeded);
+  }
+
+  [0, 90, 180, 270].forEach(rotation => {
+    print(`\n${rotation} degrees`);
+    print(`==============================`);
+    for (let i = 0; i < 100; i++) {
+      const start = Date.now();
+      instance.exports.rotate(imageDimensions, imageDimensions, rotation);
+      iterations[i] = Date.now() - start;
+    }
+    const average = iterations.reduce((sum, c) => sum + c) / iterations.length;
+    const stddev = Math.sqrt(
+      iterations
+        .map(i => Math.pow(i - average, 2))
+        .reduce((sum, c) => sum + c) / iterations.length
+    );
+    print(`n = ${iterations.length}`);
+    print(`Average: ${average}`);
+    print(`StdDev: ${stddev}`);
+  });
+}
+init().catch(e => console.error(e.stack));
--- a/codecs/rotate/build.sh
+++ b/codecs/rotate/build.sh
@ -0,0 +1,25 @@
+#!/bin/bash
+
+set -e
+
+echo "============================================="
+echo "Compiling wasm"
+echo "============================================="
+(
+  rustup run nightly \
+    cargo build \
+    --target wasm32-unknown-unknown \
+    --release
+  cp target/wasm32-unknown-unknown/release/rotate.wasm .
+  wasm-strip rotate.wasm
+)
+echo "============================================="
+echo "Compiling wasm  done"
+echo "============================================="
+
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+echo "Did you update your docker image?"
+echo "Run \`docker pull ubuntu\`"
+echo "Run \`docker pull rust\`"
+echo "Run \`docker build -t squoosh-rotate .\`"
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
--- a/codecs/rotate/package-lock.json
+++ b/codecs/rotate/package-lock.json
@ -1,124 +0,0 @@
-{
-  "name": "rotate",
-  "requires": true,
-  "lockfileVersion": 1,
-  "dependencies": {
-    "@protobufjs/utf8": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz",
-      "integrity": "sha1-p3c2C1s5oaLlEG+OhY8v0tBgxXA=",
-      "dev": true
-    },
-    "assemblyscript": {
-      "version": "github:AssemblyScript/assemblyscript#54b02c287c4d42092e4b01cc5d11bce1a53e9fb2",
-      "from": "github:AssemblyScript/assemblyscript",
-      "dev": true,
-      "requires": {
-        "@protobufjs/utf8": "^1.1.0",
-        "binaryen": "63.0.0-nightly.20190107",
-        "glob": "^7.1.3",
-        "long": "^4.0.0"
-      }
-    },
-    "balanced-match": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
-      "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=",
-      "dev": true
-    },
-    "binaryen": {
-      "version": "63.0.0-nightly.20190107",
-      "resolved": "https://registry.npmjs.org/binaryen/-/binaryen-63.0.0-nightly.20190107.tgz",
-      "integrity": "sha512-vck6ZESU9q6DeEK9v/Fk2O8d2jBsSrNlia8jpmdLZv5eqmNWpkNli+QMRa9Ezfb4wi3c+NVMuxT3Ck0g9GYe8A==",
-      "dev": true
-    },
-    "brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
-      "dev": true,
-      "requires": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
-      "dev": true
-    },
-    "fs.realpath": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
-      "dev": true
-    },
-    "glob": {
-      "version": "7.1.3",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz",
-      "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==",
-      "dev": true,
-      "requires": {
-        "fs.realpath": "^1.0.0",
-        "inflight": "^1.0.4",
-        "inherits": "2",
-        "minimatch": "^3.0.4",
-        "once": "^1.3.0",
-        "path-is-absolute": "^1.0.0"
-      }
-    },
-    "inflight": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
-      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
-      "dev": true,
-      "requires": {
-        "once": "^1.3.0",
-        "wrappy": "1"
-      }
-    },
-    "inherits": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
-      "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=",
-      "dev": true
-    },
-    "long": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/long/-/long-4.0.0.tgz",
-      "integrity": "sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA==",
-      "dev": true
-    },
-    "minimatch": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
-      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
-      "dev": true,
-      "requires": {
-        "brace-expansion": "^1.1.7"
-      }
-    },
-    "once": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
-      "dev": true,
-      "requires": {
-        "wrappy": "1"
-      }
-    },
-    "path-is-absolute": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
-      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
-      "dev": true
-    },
-    "wrappy": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
-      "dev": true
-    }
-  }
-}
--- a/codecs/rotate/package.json
+++ b/codecs/rotate/package.json
@ -1,9 +1,11 @@
 {
  "name": "rotate",
  "scripts": {
-    "build": "mv rotate.{as,ts} && asc rotate.ts -b rotate.wasm --validate -O3 --importMemory && mv rotate.{ts,as}"
-  },
-  "devDependencies": {
-    "assemblyscript": "github:AssemblyScript/assemblyscript"
+    "build:image": "docker build -t squoosh-rotate .",
+    "build": "docker run --rm -v $(pwd):/src squoosh-rotate ./build.sh",
+    "benchmark": "echo File size after gzip && npm run benchmark:filesize && echo Optimizing && npm run -s benchmark:optimizing",
+    "benchmark:baseline": "v8 --liftoff --no-wasm-tier-up --no-opt ./benchmark.js",
+    "benchmark:optimizing": "v8 --no-liftoff --no-wasm-tier-up ./benchmark.js",
+    "benchmark:filesize": "cat rotate.wasm | gzip -c9n | wc -c"
  }
 }
--- a/codecs/rotate/rotate.as
+++ b/codecs/rotate/rotate.as
@ -1,64 +0,0 @@
-export function rotate(inputWidth: i32, inputHeight: i32, rotate: i32): void {
-  const bpp = 4;
-  let offset = inputWidth * inputHeight * bpp;
-  let i = 0;
-
-  // In the straight-copy case, d1 is x, d2 is y.
-  // x starts at 0 and increases.
-  // y starts at 0 and increases.
-  let d1Start = 0;
-  let d1Limit = inputWidth;
-  let d1Advance = 1;
-  let d1Multiplier = 1;
-  let d2Start = 0;
-  let d2Limit = inputHeight;
-  let d2Advance = 1;
-  let d2Multiplier = inputWidth;
-
-  if (rotate === 90) {
-    // d1 is y, d2 is x.
-    // y starts at its max value and decreases.
-    // x starts at 0 and increases.
-    d1Start = inputHeight - 1;
-    d1Limit = inputHeight;
-    d1Advance = -1;
-    d1Multiplier = inputWidth;
-    d2Start = 0;
-    d2Limit = inputWidth;
-    d2Advance = 1;
-    d2Multiplier = 1;
-  } else if (rotate === 180) {
-    // d1 is x, d2 is y.
-    // x starts at its max and decreases.
-    // y starts at its max and decreases.
-    d1Start = inputWidth - 1;
-    d1Limit = inputWidth;
-    d1Advance = -1;
-    d1Multiplier = 1;
-    d2Start = inputHeight - 1;
-    d2Limit = inputHeight;
-    d2Advance = -1;
-    d2Multiplier = inputWidth;
-  } else if (rotate === 270) {
-    // d1 is y, d2 is x.
-    // y starts at 0 and increases.
-    // x starts at its max and decreases.
-    d1Start = 0;
-    d1Limit = inputHeight;
-    d1Advance = 1;
-    d1Multiplier = inputWidth;
-    d2Start = inputWidth - 1;
-    d2Limit = inputWidth;
-    d2Advance = -1;
-    d2Multiplier = 1;
-  }
-
-  for (let d2 = d2Start; d2 >= 0 && d2 < d2Limit; d2 += d2Advance) {
-    let d2offset = d2 * d2Multiplier;
-    for (let d1 = d1Start; d1 >= 0 && d1 < d1Limit; d1 += d1Advance) {
-      let start = ((d1 * d1Multiplier) + d2offset);
-      store<u32>(offset + i * 4, load<u32>(start * 4));
-      i += 1;
-    }
-  }
-}
--- a/codecs/rotate/rotate.rs
+++ b/codecs/rotate/rotate.rs
@ -0,0 +1,113 @@
+use std::slice::{from_raw_parts, from_raw_parts_mut};
+
+// This function is taken from Zachary Dremann
+// https://github.com/GoogleChromeLabs/squoosh/pull/462
+trait HardUnwrap<T> {
+    fn unwrap_hard(self) -> T;
+}
+
+impl<T> HardUnwrap<T> for Option<T> {
+    #[cfg(not(debug_assertions))]
+    #[inline]
+    fn unwrap_hard(self) -> T {
+        match self {
+            Some(t) => t,
+            None => std::process::abort(),
+        }
+    }
+
+    #[cfg(debug_assertions)]
+    fn unwrap_hard(self) -> T {
+        self.unwrap()
+    }
+}
+
+const TILE_SIZE: usize = 16;
+
+fn get_buffers<'a>(width: usize, height: usize) -> (&'a [u32], &'a mut [u32]) {
+    let num_pixels = width * height;
+    let in_b: &[u32];
+    let out_b: &mut [u32];
+    unsafe {
+        in_b = from_raw_parts::<u32>(8 as *const u32, num_pixels);
+        out_b = from_raw_parts_mut::<u32>((num_pixels * 4 + 8) as *mut u32, num_pixels);
+    }
+    return (in_b, out_b);
+}
+
+#[inline(never)]
+fn rotate_0(width: usize, height: usize) {
+    let (in_b, out_b) = get_buffers(width, height);
+    for (in_p, out_p) in in_b.iter().zip(out_b.iter_mut()) {
+        *out_p = *in_p;
+    }
+}
+
+#[inline(never)]
+fn rotate_90(width: usize, height: usize) {
+    let (in_b, out_b) = get_buffers(width, height);
+    let new_width = height;
+    let _new_height = width;
+    for y_start in (0..height).step_by(TILE_SIZE) {
+        for x_start in (0..width).step_by(TILE_SIZE) {
+            for y in y_start..(y_start + TILE_SIZE).min(height) {
+                let in_offset = y * width;
+                let in_bounds = if x_start + TILE_SIZE < width {
+                    (in_offset + x_start)..(in_offset + x_start + TILE_SIZE)
+                } else {
+                    (in_offset + x_start)..(in_offset + width)
+                };
+                let in_chunk = in_b.get(in_bounds).unwrap_hard();
+                for (x, in_p) in in_chunk.iter().enumerate() {
+                    let new_x = (new_width - 1) - y;
+                    let new_y = x + x_start;
+                    *out_b.get_mut(new_y * new_width + new_x).unwrap_hard() = *in_p;
+                }
+            }
+        }
+    }
+}
+
+#[inline(never)]
+fn rotate_180(width: usize, height: usize) {
+    let (in_b, out_b) = get_buffers(width, height);
+    for (in_p, out_p) in in_b.iter().zip(out_b.iter_mut().rev()) {
+        *out_p = *in_p;
+    }
+}
+
+#[inline(never)]
+fn rotate_270(width: usize, height: usize) {
+    let (in_b, out_b) = get_buffers(width, height);
+    let new_width = height;
+    let new_height = width;
+    for y_start in (0..height).step_by(TILE_SIZE) {
+        for x_start in (0..width).step_by(TILE_SIZE) {
+            for y in y_start..(y_start + TILE_SIZE).min(height) {
+                let in_offset = y * width;
+                let in_bounds = if x_start + TILE_SIZE < width {
+                    (in_offset + x_start)..(in_offset + x_start + TILE_SIZE)
+                } else {
+                    (in_offset + x_start)..(in_offset + width)
+                };
+                let in_chunk = in_b.get(in_bounds).unwrap_hard();
+                for (x, in_p) in in_chunk.iter().enumerate() {
+                    let new_x = y;
+                    let new_y = new_height - 1 - (x_start + x);
+                    *out_b.get_mut(new_y * new_width + new_x).unwrap_hard() = *in_p;
+                }
+            }
+        }
+    }
+}
+
+#[no_mangle]
+fn rotate(width: usize, height: usize, rotate: usize) {
+    match rotate {
+        0 => rotate_0(width, height),
+        90 => rotate_90(width, height),
+        180 => rotate_180(width, height),
+        270 => rotate_270(width, height),
+        _ => std::process::abort(),
+    }
+}
--- a/codecs/rotate/rotate.wasm
+++ b/codecs/rotate/rotate.wasm
--- a/codecs/rotate/tsconfig.json
+++ b/codecs/rotate/tsconfig.json
@ -1,6 +0,0 @@
-{
-  "extends": "./node_modules/assemblyscript/std/assembly.json",
-  "include": [
-    "./**/*.ts"
-  ]
-}
--- a/codecs/webp_dec/README.md
+++ b/codecs/webp_dec/README.md
@ -1,7 +1,7 @@
 # WebP decoder

 - Source: <https://github.com/webmproject/libwebp>
- Version: v0.6.1
+- Version: v1.0.2

 ## Example

--- a/codecs/webp_dec/build.sh
+++ b/codecs/webp_dec/build.sh
@ -6,7 +6,33 @@ export OPTIMIZE="-Os"
 export LDFLAGS="${OPTIMIZE}"
 export CFLAGS="${OPTIMIZE}"
 export CPPFLAGS="${OPTIMIZE}"
+apt-get update
+apt-get install -qqy autoconf libtool libpng-dev pkg-config

+echo "============================================="
+echo "Compiling libwebp"
+echo "============================================="
+test -n "$SKIP_LIBWEBP" || (
+  cd node_modules/libwebp
+  autoreconf -fiv
+  rm -rf build || true
+  mkdir -p build && cd build
+  emconfigure ../configure \
+    --disable-libwebpdemux \
+    --disable-wic \
+    --disable-gif \
+    --disable-tiff \
+    --disable-jpeg \
+    --disable-png \
+    --disable-sdl \
+    --disable-gl \
+    --disable-threading \
+    --disable-neon-rtcd \
+    --disable-neon \
+    --disable-sse2 \
+    --disable-sse4.1
+  emmake make
+)
 echo "============================================="
 echo "Compiling wasm bindings"
 echo "============================================="
@ -20,9 +46,9 @@ echo "============================================="
    --std=c++11 \
    -I node_modules/libwebp \
    -o ./webp_dec.js \
-    node_modules/libwebp/src/{dec,dsp,demux,enc,mux,utils}/*.c \
    -x c++ \
-    webp_dec.cpp
+    webp_dec.cpp \
+    node_modules/libwebp/build/src/.libs/libwebp.a
 )
 echo "============================================="
 echo "Compiling wasm bindings done"
--- a/codecs/webp_dec/package.json
+++ b/codecs/webp_dec/package.json
@ -5,7 +5,7 @@
    "build": "docker run --rm -v $(pwd):/src trzeci/emscripten ./build.sh"
  },
  "napa": {
-    "libwebp": "webmproject/libwebp#v1.0.0"
+    "libwebp": "webmproject/libwebp#v1.0.2"
  },
  "devDependencies": {
    "napa": "3.0.0"
--- a/codecs/webp_dec/webp_dec.js
+++ b/codecs/webp_dec/webp_dec.js
--- a/codecs/webp_dec/webp_dec.wasm
+++ b/codecs/webp_dec/webp_dec.wasm
--- a/codecs/webp_enc/README.md
+++ b/codecs/webp_enc/README.md
@ -1,7 +1,7 @@
 # WebP encoder

 - Source: <https://github.com/webmproject/libwebp>
- Version: v0.6.1
+- Version: v1.0.2

 ## Dependencies

--- a/codecs/webp_enc/build.sh
+++ b/codecs/webp_enc/build.sh
@ -7,6 +7,33 @@ export LDFLAGS="${OPTIMIZE}"
 export CFLAGS="${OPTIMIZE}"
 export CPPFLAGS="${OPTIMIZE}"

+apt-get update
+apt-get install -qqy autoconf libtool libpng-dev pkg-config
+
+echo "============================================="
+echo "Compiling libwebp"
+echo "============================================="
+test -n "$SKIP_LIBWEBP" || (
+  cd node_modules/libwebp
+  autoreconf -fiv
+  rm -rf build || true
+  mkdir -p build && cd build
+  emconfigure ../configure \
+    --disable-libwebpdemux \
+    --disable-wic \
+    --disable-gif \
+    --disable-tiff \
+    --disable-jpeg \
+    --disable-png \
+    --disable-sdl \
+    --disable-gl \
+    --disable-threading \
+    --disable-neon-rtcd \
+    --disable-neon \
+    --disable-sse2 \
+    --disable-sse4.1
+  emmake make
+)
 echo "============================================="
 echo "Compiling wasm bindings"
 echo "============================================="
@ -20,9 +47,9 @@ echo "============================================="
    --std=c++11 \
    -I node_modules/libwebp \
    -o ./webp_enc.js \
-    node_modules/libwebp/src/{dec,dsp,demux,enc,mux,utils}/*.c \
    -x c++ \
-    webp_enc.cpp
+    webp_enc.cpp \
+    node_modules/libwebp/build/src/.libs/libwebp.a
 )
 echo "============================================="
 echo "Compiling wasm bindings done"
--- a/codecs/webp_enc/package.json
+++ b/codecs/webp_enc/package.json
@ -5,7 +5,7 @@
    "build": "docker run --rm -v $(pwd):/src trzeci/emscripten ./build.sh"
  },
  "napa": {
-    "libwebp": "webmproject/libwebp#v1.0.0"
+    "libwebp": "webmproject/libwebp#v1.0.2"
  },
  "devDependencies": {
    "napa": "3.0.0"
--- a/codecs/webp_enc/webp_enc.js
+++ b/codecs/webp_enc/webp_enc.js
--- a/codecs/webp_enc/webp_enc.wasm
+++ b/codecs/webp_enc/webp_enc.wasm
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -1,13 +1,14 @@
 {
  "private": true,
  "name": "squoosh",
-  "version": "1.3.1",
+  "version": "1.8.1",
  "license": "apache-2.0",
  "scripts": {
    "start": "webpack-dev-server --host 0.0.0.0 --hot",
    "build": "webpack -p",
-    "lint": "tslint -c tslint.json  -p tsconfig.json -t verbose 'src/**/*.{ts,tsx,js,jsx}'",
-    "lintfix": "tslint -c tslint.json -p tsconfig.json -t verbose --fix 'src/**/*.{ts,tsx,js,jsx}'"
+    "lint": "tslint -c tslint.json  -p tsconfig.json -t verbose",
+    "lintfix": "tslint -c tslint.json -p tsconfig.json -t verbose --fix 'src/**/*.{ts,tsx,js,jsx}'",
+    "sizereport": "sizereport --config"
  },
  "husky": {
    "hooks": {
@ -15,55 +16,61 @@
    }
  },
  "devDependencies": {
-    "@types/node": "10.12.18",
+    "@types/node": "10.14.9",
    "@types/pretty-bytes": "5.1.0",
-    "@types/webassembly-js-api": "0.0.2",
-    "@webcomponents/custom-elements": "1.2.1",
-    "@webpack-cli/serve": "0.1.3",
-    "assets-webpack-plugin": "3.9.7",
-    "chokidar": "2.0.4",
+    "@types/webassembly-js-api": "0.0.3",
+    "@webcomponents/custom-elements": "1.2.4",
+    "@webpack-cli/serve": "0.1.8",
+    "assets-webpack-plugin": "3.9.10",
+    "chalk": "2.4.2",
+    "chokidar": "3.0.1",
    "classnames": "2.2.6",
    "clean-webpack-plugin": "1.0.1",
    "comlink": "3.1.1",
-    "copy-webpack-plugin": "4.6.0",
-    "critters-webpack-plugin": "2.2.0",
+    "copy-webpack-plugin": "5.0.3",
+    "critters-webpack-plugin": "2.3.0",
    "css-loader": "1.0.1",
-    "ejs": "2.6.1",
+    "ejs": "2.6.2",
+    "escape-string-regexp": "2.0.0",
    "exports-loader": "0.7.0",
-    "file-drop-element": "0.0.9",
-    "file-loader": "3.0.1",
+    "file-drop-element": "0.2.0",
+    "file-loader": "4.0.0",
+    "gzip-size": "5.1.1",
    "html-webpack-plugin": "3.2.0",
-    "husky": "1.3.1",
-    "idb-keyval": "3.1.0",
+    "husky": "2.4.1",
+    "idb-keyval": "3.2.0",
    "linkstate": "1.1.1",
-    "loader-utils": "1.2.0",
-    "mini-css-extract-plugin": "0.5.0",
+    "loader-utils": "1.2.3",
+    "mini-css-extract-plugin": "0.7.0",
    "minimatch": "3.0.4",
-    "node-sass": "4.11.0",
+    "node-fetch": "2.6.0",
+    "node-sass": "4.12.0",
    "optimize-css-assets-webpack-plugin": "5.0.1",
    "pointer-tracker": "2.0.3",
    "preact": "8.4.2",
-    "prerender-loader": "1.2.0",
-    "pretty-bytes": "5.1.0",
-    "progress-bar-webpack-plugin": "1.12.0",
-    "raw-loader": "1.0.0",
+    "prerender-loader": "1.3.0",
+    "pretty-bytes": "5.2.0",
+    "progress-bar-webpack-plugin": "1.12.1",
+    "raw-loader": "3.0.0",
+    "readdirp": "3.0.2",
    "sass-loader": "7.1.0",
    "script-ext-html-webpack-plugin": "2.1.3",
    "source-map-loader": "0.2.4",
    "style-loader": "0.23.1",
-    "terser-webpack-plugin": "1.2.1",
-    "ts-loader": "5.3.3",
-    "tslint": "5.12.1",
+    "terser-webpack-plugin": "1.3.0",
+    "travis-size-report": "1.0.1",
+    "ts-loader": "6.0.3",
+    "tslint": "5.17.0",
    "tslint-config-airbnb": "5.11.1",
-    "tslint-config-semistandard": "7.0.0",
-    "tslint-react": "3.6.0",
-    "typed-css-modules": "0.3.7",
-    "typescript": "3.2.4",
-    "url-loader": "1.1.2",
+    "tslint-config-semistandard": "8.0.1",
+    "tslint-react": "4.0.0",
+    "typed-css-modules": "0.4.2",
+    "typescript": "3.5.2",
+    "url-loader": "2.0.0",
    "webpack": "4.28.0",
-    "webpack-bundle-analyzer": "3.0.3",
-    "webpack-cli": "3.2.1",
-    "webpack-dev-server": "3.1.14",
-    "worker-plugin": "3.0.0"
+    "webpack-bundle-analyzer": "3.3.2",
+    "webpack-cli": "3.3.4",
+    "webpack-dev-server": "3.7.1",
+    "worker-plugin": "3.1.0"
  }
 }
--- a/sizereport.config.js
+++ b/sizereport.config.js
@ -0,0 +1,14 @@
+const escapeRE = require("escape-string-regexp");
+
+module.exports = {
+  repo: "GoogleChromeLabs/squoosh",
+  path: "build/**/!(*.map)",
+  branch: "master",
+  findRenamed(path, newPaths) {
+    const nameParts = /^(.+\.)[a-f0-9]+(\..+)$/.exec(path);
+    if (!nameParts) return;
+
+    const matchRe = new RegExp(`^${escapeRE(nameParts[1])}[a-f0-9]+${escapeRE(nameParts[2])}$`);
+    return newPaths.find(newPath => matchRe.test(newPath));
+  }
+};
--- a/src/codecs/hqx/processor-meta.ts
+++ b/src/codecs/hqx/processor-meta.ts
@ -0,0 +1,3 @@
+export interface HqxOptions {
+  factor: 2 | 3 | 4;
+}
--- a/src/codecs/hqx/processor.ts
+++ b/src/codecs/hqx/processor.ts
@ -0,0 +1,32 @@
+import wasmUrl from '../../../codecs/hqx/pkg/squooshhqx_bg.wasm';
+import '../../../codecs/hqx/pkg/squooshhqx';
+import { HqxOptions } from './processor-meta';
+
+interface WasmBindgenExports {
+  resize: typeof import('../../../codecs/hqx/pkg/squooshhqx').resize;
+}
+
+type WasmBindgen = ((url: string) => Promise<void>) & WasmBindgenExports;
+
+declare var wasm_bindgen: WasmBindgen;
+
+const ready = wasm_bindgen(wasmUrl);
+
+export async function hqx(
+  data: ImageData,
+  opts: HqxOptions,
+): Promise<ImageData> {
+  const input = data;
+  await ready;
+  const result = wasm_bindgen.resize(
+    new Uint32Array(input.data.buffer),
+    input.width,
+    input.height,
+    opts.factor,
+  );
+  return new ImageData(
+    new Uint8ClampedArray(result.buffer),
+    data.width * opts.factor,
+    data.height * opts.factor,
+  );
+}
--- a/src/codecs/imagequant/processor.ts
+++ b/src/codecs/imagequant/processor.ts
@ -1,12 +1,12 @@
 import imagequant, { QuantizerModule } from '../../../codecs/imagequant/imagequant';
 import wasmUrl from '../../../codecs/imagequant/imagequant.wasm';
 import { QuantizeOptions } from './processor-meta';
-import { initWasmModule } from '../util';
+import { initEmscriptenModule } from '../util';

 let emscriptenModule: Promise<QuantizerModule>;

 export async function process(data: ImageData, opts: QuantizeOptions): Promise<ImageData> {
-  if (!emscriptenModule) emscriptenModule = initWasmModule(imagequant, wasmUrl);
+  if (!emscriptenModule) emscriptenModule = initEmscriptenModule(imagequant, wasmUrl);

  const module = await emscriptenModule;

--- a/src/codecs/mozjpeg/encoder.ts
+++ b/src/codecs/mozjpeg/encoder.ts
@ -1,12 +1,12 @@
 import mozjpeg_enc, { MozJPEGModule } from '../../../codecs/mozjpeg_enc/mozjpeg_enc';
 import wasmUrl from '../../../codecs/mozjpeg_enc/mozjpeg_enc.wasm';
 import { EncodeOptions } from './encoder-meta';
-import { initWasmModule } from '../util';
+import { initEmscriptenModule } from '../util';

 let emscriptenModule: Promise<MozJPEGModule>;

 export async function encode(data: ImageData, options: EncodeOptions): Promise<ArrayBuffer> {
-  if (!emscriptenModule) emscriptenModule = initWasmModule(mozjpeg_enc, wasmUrl);
+  if (!emscriptenModule) emscriptenModule = initEmscriptenModule(mozjpeg_enc, wasmUrl);

  const module = await emscriptenModule;
  const resultView = module.encode(data.data, data.width, data.height, options);
--- a/src/codecs/optipng/encoder.ts
+++ b/src/codecs/optipng/encoder.ts
@ -1,12 +1,12 @@
 import optipng, { OptiPngModule } from '../../../codecs/optipng/optipng';
 import wasmUrl from '../../../codecs/optipng/optipng.wasm';
 import { EncodeOptions } from './encoder-meta';
-import { initWasmModule } from '../util';
+import { initEmscriptenModule } from '../util';

 let emscriptenModule: Promise<OptiPngModule>;

 export async function compress(data: BufferSource, options: EncodeOptions): Promise<ArrayBuffer> {
-  if (!emscriptenModule) emscriptenModule = initWasmModule(optipng, wasmUrl);
+  if (!emscriptenModule) emscriptenModule = initEmscriptenModule(optipng, wasmUrl);

  const module = await emscriptenModule;
  const resultView = module.compress(data, options);
--- a/src/codecs/processor-worker/index.ts
+++ b/src/codecs/processor-worker/index.ts
@ -1,12 +1,13 @@
 import { expose } from 'comlink';
+import { isHqx } from '../resize/processor-meta';
+import { clamp } from '../util';

 async function mozjpegEncode(
  data: ImageData, options: import('../mozjpeg/encoder-meta').EncodeOptions,
 ): Promise<ArrayBuffer> {
  const { encode } = await import(
    /* webpackChunkName: "process-mozjpeg-enc" */
-    '../mozjpeg/encoder',
-  );
+    '../mozjpeg/encoder');
  return encode(data, options);
 }

@ -15,8 +16,7 @@ async function quantize(
 ): Promise<ImageData> {
  const { process } = await import(
    /* webpackChunkName: "process-imagequant" */
-    '../imagequant/processor',
-  );
+    '../imagequant/processor');
  return process(data, opts);
 }

@ -25,19 +25,39 @@ async function rotate(
 ): Promise<ImageData> {
  const { rotate } = await import(
    /* webpackChunkName: "process-rotate" */
-    '../rotate/processor',
-  );
+    '../rotate/processor');

  return rotate(data, opts);
 }

+async function resize(
+  data: ImageData, opts: import('../resize/processor-meta').WorkerResizeOptions,
+): Promise<ImageData> {
+  if (isHqx(opts)) {
+    const { hqx } = await import(
+      /* webpackChunkName: "process-hqx" */
+      '../hqx/processor');
+
+    const widthRatio = opts.width / data.width;
+    const heightRatio = opts.height / data.height;
+    const ratio = Math.max(widthRatio, heightRatio);
+    if (ratio <= 1) return data;
+    const factor = clamp(Math.ceil(ratio), { min: 2, max: 4 }) as 2|3|4;
+    return hqx(data, { factor });
+  }
+  const { resize } = await import(
+    /* webpackChunkName: "process-resize" */
+    '../resize/processor');
+
+  return resize(data, opts);
+}
+
 async function optiPngEncode(
  data: BufferSource, options: import('../optipng/encoder-meta').EncodeOptions,
 ): Promise<ArrayBuffer> {
  const { compress } = await import(
    /* webpackChunkName: "process-optipng" */
-    '../optipng/encoder',
-  );
+    '../optipng/encoder');
  return compress(data, options);
 }

@ -46,20 +66,26 @@ async function webpEncode(
 ): Promise<ArrayBuffer> {
  const { encode } = await import(
    /* webpackChunkName: "process-webp-enc" */
-    '../webp/encoder',
-  );
+    '../webp/encoder');
  return encode(data, options);
 }

 async function webpDecode(data: ArrayBuffer): Promise<ImageData> {
  const { decode } = await import(
    /* webpackChunkName: "process-webp-dec" */
-    '../webp/decoder',
-  );
+    '../webp/decoder');
  return decode(data);
 }

-const exports = { mozjpegEncode, quantize, rotate, optiPngEncode, webpEncode, webpDecode };
+const exports = {
+  mozjpegEncode,
+  quantize,
+  rotate,
+  resize,
+  optiPngEncode,
+  webpEncode,
+  webpDecode,
+};
 export type ProcessorWorkerApi = typeof exports;

 expose(exports, self);
--- a/src/codecs/processor.ts
+++ b/src/codecs/processor.ts
@ -6,8 +6,8 @@ import { EncodeOptions as OptiPNGEncoderOptions } from './optipng/encoder-meta';
 import { EncodeOptions as WebPEncoderOptions } from './webp/encoder-meta';
 import { EncodeOptions as BrowserJPEGOptions } from './browser-jpeg/encoder-meta';
 import { EncodeOptions as BrowserWebpEncodeOptions } from './browser-webp/encoder-meta';
-import { BitmapResizeOptions, VectorResizeOptions } from './resize/processor-meta';
-import { resize, vectorResize } from './resize/processor';
+import { BrowserResizeOptions, VectorResizeOptions } from './resize/processor-meta';
+import { browserResize, vectorResize } from './resize/processor-sync';
 import * as browserBMP from './browser-bmp/encoder';
 import * as browserPNG from './browser-png/encoder';
 import * as browserJPEG from './browser-jpeg/encoder';
@ -16,6 +16,7 @@ import * as browserGIF from './browser-gif/encoder';
 import * as browserTIFF from './browser-tiff/encoder';
 import * as browserJP2 from './browser-jp2/encoder';
 import * as browserPDF from './browser-pdf/encoder';
+import { bind } from '../lib/initial-util';

 type ProcessorWorkerApi = import('./processor-worker').ProcessorWorkerApi;

@ -94,14 +95,7 @@ export default class Processor {
    if (!this._worker) return;

    // If the worker is unused for 10 seconds, remove it to save memory.
-    this._workerTimeoutId = self.setTimeout(
-      () => {
-        if (!this._worker) return;
-        this._worker.terminate();
-        this._worker = undefined;
-      },
-      workerTimeout,
-    );
+    this._workerTimeoutId = self.setTimeout(this.terminateWorker, workerTimeout);
  }

  /** Abort the current job, if any */
@ -111,7 +105,11 @@ export default class Processor {
    this._abortRejector(new DOMException('Aborted', 'AbortError'));
    this._abortRejector = undefined;
    this._busy = false;
+    this.terminateWorker();
+  }

+  @bind
+  terminateWorker() {
    if (!this._worker) return;
    this._worker.terminate();
    this._worker = undefined;
@ -130,6 +128,13 @@ export default class Processor {
    return this._workerApi!.rotate(data, opts);
  }

+  @Processor._processingJob({ needsWorker: true })
+  workerResize(
+    data: ImageData, opts: import('./resize/processor-meta').WorkerResizeOptions,
+  ): Promise<ImageData> {
+    return this._workerApi!.resize(data, opts);
+  }
+
  @Processor._processingJob({ needsWorker: true })
  mozjpegEncode(
    data: ImageData, opts: MozJPEGEncoderOptions,
@ -202,9 +207,9 @@ export default class Processor {

  // Synchronous jobs

-  resize(data: ImageData, opts: BitmapResizeOptions) {
+  resize(data: ImageData, opts: BrowserResizeOptions) {
    this.abortCurrent();
-    return resize(data, opts);
+    return browserResize(data, opts);
  }

  vectorResize(data: HTMLImageElement, opts: VectorResizeOptions) {
--- a/src/codecs/resize/options.tsx
+++ b/src/codecs/resize/options.tsx
@ -1,8 +1,10 @@
 import { h, Component } from 'preact';
 import linkState from 'linkstate';
 import { bind, linkRef } from '../../lib/initial-util';
-import { inputFieldValueAsNumber, inputFieldValue, preventDefault } from '../../lib/util';
-import { ResizeOptions } from './processor-meta';
+import {
+  inputFieldValueAsNumber, inputFieldValue, preventDefault, inputFieldChecked,
+} from '../../lib/util';
+import { ResizeOptions, isWorkerOptions } from './processor-meta';
 import * as style from '../../components/Options/style.scss';
 import Checkbox from '../../components/checkbox';
 import Expander from '../../components/expander';
@ -10,8 +12,9 @@ import Select from '../../components/select';

 interface Props {
  isVector: Boolean;
+  inputWidth: number;
+  inputHeight: number;
  options: ResizeOptions;
-  aspect: number;
  onChange(newOptions: ResizeOptions): void;
 }

@ -19,12 +22,21 @@ interface State {
  maintainAspect: boolean;
 }

+const sizePresets = [0.25, 0.3333, 0.5, 1, 2, 3, 4];
+
 export default class ResizerOptions extends Component<Props, State> {
  state: State = {
    maintainAspect: true,
  };

-  form?: HTMLFormElement;
+  private form?: HTMLFormElement;
+  private presetWidths: { [idx: number]: number } = {};
+  private presetHeights: { [idx: number]: number } = {};
+
+  constructor(props: Props) {
+    super(props);
+    this.generatePresetValues(props.inputWidth, props.inputHeight);
+  }

  private reportOptions() {
    const form = this.form!;
@ -38,6 +50,8 @@ export default class ResizerOptions extends Component<Props, State> {
      width: inputFieldValueAsNumber(width),
      height: inputFieldValueAsNumber(height),
      method: form.resizeMethod.value,
+      premultiply: inputFieldChecked(form.premultiply, true),
+      linearRGB: inputFieldChecked(form.linearRGB, true),
      // Casting, as the formfield only returns the correct values.
      fitMethod: inputFieldValue(form.fitMethod, options.fitMethod) as ResizeOptions['fitMethod'],
    };
@ -49,18 +63,31 @@ export default class ResizerOptions extends Component<Props, State> {
    this.reportOptions();
  }

+  private getAspect() {
+    return this.props.inputWidth / this.props.inputHeight;
+  }
+
  componentDidUpdate(prevProps: Props, prevState: State) {
    if (!prevState.maintainAspect && this.state.maintainAspect) {
-      this.form!.height.value = Math.round(Number(this.form!.width.value) / this.props.aspect);
+      this.form!.height.value = Math.round(Number(this.form!.width.value) / this.getAspect());
      this.reportOptions();
    }
  }

+  componentWillReceiveProps(nextProps: Props) {
+    if (
+      this.props.inputWidth !== nextProps.inputWidth ||
+      this.props.inputHeight !== nextProps.inputHeight
+    ) {
+      this.generatePresetValues(nextProps.inputWidth, nextProps.inputHeight);
+    }
+  }
+
  @bind
  private onWidthInput() {
    if (this.state.maintainAspect) {
      const width = inputFieldValueAsNumber(this.form!.width);
-      this.form!.height.value = Math.round(width / this.props.aspect);
+      this.form!.height.value = Math.round(width / this.getAspect());
    }

    this.reportOptions();
@ -70,12 +97,44 @@ export default class ResizerOptions extends Component<Props, State> {
  private onHeightInput() {
    if (this.state.maintainAspect) {
      const height = inputFieldValueAsNumber(this.form!.height);
-      this.form!.width.value = Math.round(height * this.props.aspect);
+      this.form!.width.value = Math.round(height * this.getAspect());
    }

    this.reportOptions();
  }

+  private generatePresetValues(width: number, height: number) {
+    for (const preset of sizePresets) {
+      this.presetWidths[preset] = Math.round(width * preset);
+      this.presetHeights[preset] = Math.round(height * preset);
+    }
+  }
+
+  private getPreset(): number | string {
+    const { width, height } = this.props.options;
+
+    for (const preset of sizePresets) {
+      if (
+        width === this.presetWidths[preset] &&
+        height === this.presetHeights[preset]
+      ) return preset;
+    }
+
+    return 'custom';
+  }
+
+  @bind
+  private onPresetChange(event: Event) {
+    const select = event.target as HTMLSelectElement;
+    if (select.value === 'custom') return;
+    const multiplier = Number(select.value);
+    (this.form!.width as HTMLInputElement).value =
+      Math.round(this.props.inputWidth * multiplier) + '';
+    (this.form!.height as HTMLInputElement).value =
+      Math.round(this.props.inputHeight * multiplier) + '';
+    this.reportOptions();
+  }
+
  render({ options, isVector }: Props, { maintainAspect }: State) {
    return (
      <form ref={linkRef(this, 'form')} class={style.optionsSection} onSubmit={preventDefault}>
@ -87,12 +146,26 @@ export default class ResizerOptions extends Component<Props, State> {
            onChange={this.onChange}
          >
            {isVector && <option value="vector">Vector</option>}
+            <option value="lanczos3">Lanczos3</option>
+            <option value="mitchell">Mitchell</option>
+            <option value="catrom">Catmull-Rom</option>
+            <option value="triangle">Triangle (bilinear)</option>
+            <option value="hqx">hqx (pixel art)</option>
            <option value="browser-pixelated">Browser pixelated</option>
            <option value="browser-low">Browser low quality</option>
            <option value="browser-medium">Browser medium quality</option>
            <option value="browser-high">Browser high quality</option>
          </Select>
        </label>
+        <label class={style.optionTextFirst}>
+          Preset:
+          <Select value={this.getPreset()} onChange={this.onPresetChange}>
+            {sizePresets.map(preset =>
+              <option value={preset}>{preset * 100}%</option>,
+            )}
+            <option value="custom">Custom</option>
+          </Select>
+        </label>
        <label class={style.optionTextFirst}>
          Width:
          <input
@ -117,6 +190,30 @@ export default class ResizerOptions extends Component<Props, State> {
            onInput={this.onHeightInput}
          />
        </label>
+        <Expander>
+          {isWorkerOptions(options) ?
+            <label class={style.optionInputFirst}>
+              <Checkbox
+                name="premultiply"
+                checked={options.premultiply}
+                onChange={this.onChange}
+              />
+              Premultiply alpha channel
+            </label>
+            : null
+          }
+          {isWorkerOptions(options) ?
+            <label class={style.optionInputFirst}>
+              <Checkbox
+                name="linearRGB"
+                checked={options.linearRGB}
+                onChange={this.onChange}
+              />
+              Linear RGB
+            </label>
+            : null
+          }
+        </Expander>
        <label class={style.optionInputFirst}>
          <Checkbox
            name="maintainAspect"
--- a/src/codecs/resize/processor-meta.ts
+++ b/src/codecs/resize/processor-meta.ts
@ -1,26 +1,75 @@
-type BitmapResizeMethods = 'browser-pixelated' | 'browser-low' | 'browser-medium' | 'browser-high';
+type BrowserResizeMethods =
+  | 'browser-pixelated'
+  | 'browser-low'
+  | 'browser-medium'
+  | 'browser-high';
+type WorkerResizeMethods =
+  | 'triangle'
+  | 'catrom'
+  | 'mitchell'
+  | 'lanczos3'
+  | 'hqx';
+const workerResizeMethods: WorkerResizeMethods[] = [
+  'triangle',
+  'catrom',
+  'mitchell',
+  'lanczos3',
+  'hqx',
+];

-export interface ResizeOptions {
+export type ResizeOptions =
+  | BrowserResizeOptions
+  | WorkerResizeOptions
+  | VectorResizeOptions;
+
+export interface ResizeOptionsCommon {
  width: number;
  height: number;
-  method: 'vector' | BitmapResizeMethods;
  fitMethod: 'stretch' | 'contain';
 }

-export interface BitmapResizeOptions extends ResizeOptions {
-  method: BitmapResizeMethods;
+export interface BrowserResizeOptions extends ResizeOptionsCommon {
+  method: BrowserResizeMethods;
 }

-export interface VectorResizeOptions extends ResizeOptions {
+export interface WorkerResizeOptions extends ResizeOptionsCommon {
+  method: WorkerResizeMethods;
+  premultiply: boolean;
+  linearRGB: boolean;
+}
+
+export interface VectorResizeOptions extends ResizeOptionsCommon {
  method: 'vector';
 }

+/**
+ * Return whether a set of options are worker resize options.
+ *
+ * @param opts
+ */
+export function isWorkerOptions(
+  opts: ResizeOptions,
+): opts is WorkerResizeOptions {
+  return (workerResizeMethods as string[]).includes(opts.method);
+}
+
+/**
+ * Return whether a set of options are from the HQ<n>X set
+ *
+ * @param opts
+ */
+export function isHqx(opts: ResizeOptions): opts is WorkerResizeOptions {
+  return opts.method === 'hqx';
+}
+
 export const defaultOptions: ResizeOptions = {
  // Width and height will always default to the image size.
  // This is set elsewhere.
  width: 1,
  height: 1,
  // This will be set to 'vector' if the input is SVG.
-  method: 'browser-high',
+  method: 'lanczos3',
  fitMethod: 'stretch',
+  premultiply: true,
+  linearRGB: true,
 };
--- a/src/codecs/resize/processor-sync.ts
+++ b/src/codecs/resize/processor-sync.ts
@ -0,0 +1,35 @@
+import { nativeResize, NativeResizeMethod, drawableToImageData } from '../../lib/util';
+import { BrowserResizeOptions, VectorResizeOptions } from './processor-meta';
+import { getContainOffsets } from './util';
+
+export function browserResize(data: ImageData, opts: BrowserResizeOptions): ImageData {
+  let sx = 0;
+  let sy = 0;
+  let sw = data.width;
+  let sh = data.height;
+
+  if (opts.fitMethod === 'contain') {
+    ({ sx, sy, sw, sh } = getContainOffsets(sw, sh, opts.width, opts.height));
+  }
+
+  return nativeResize(
+    data, sx, sy, sw, sh, opts.width, opts.height,
+    opts.method.slice('browser-'.length) as NativeResizeMethod,
+  );
+}
+
+export function vectorResize(data: HTMLImageElement, opts: VectorResizeOptions): ImageData {
+  let sx = 0;
+  let sy = 0;
+  let sw = data.width;
+  let sh = data.height;
+
+  if (opts.fitMethod === 'contain') {
+    ({ sx, sy, sw, sh } = getContainOffsets(sw, sh, opts.width, opts.height));
+  }
+
+  return drawableToImageData(data, {
+    sx, sy, sw, sh,
+    width: opts.width, height: opts.height,
+  });
+}
--- a/src/codecs/resize/processor.ts
+++ b/src/codecs/resize/processor.ts
@ -1,49 +1,52 @@
-import { nativeResize, NativeResizeMethod, drawableToImageData } from '../../lib/util';
-import { BitmapResizeOptions, VectorResizeOptions } from './processor-meta';
+import wasmUrl from '../../../codecs/resize/pkg/resize_bg.wasm';
+import '../../../codecs/resize/pkg/resize';
+import { WorkerResizeOptions } from './processor-meta';
+import { getContainOffsets } from './util';

-function getContainOffsets(sw: number, sh: number, dw: number, dh: number) {
-  const currentAspect = sw / sh;
-  const endAspect = dw / dh;
-
-  if (endAspect > currentAspect) {
-    const newSh = sw / endAspect;
-    const newSy = (sh - newSh) / 2;
-    return { sw, sh: newSh, sx: 0, sy: newSy };
-  }
-
-  const newSw = sh * endAspect;
-  const newSx = (sw - newSw) / 2;
-  return { sh, sw: newSw, sx: newSx, sy: 0 };
+interface WasmBindgenExports {
+  resize: typeof import('../../../codecs/resize/pkg/resize').resize;
 }

-export function resize(data: ImageData, opts: BitmapResizeOptions): ImageData {
-  let sx = 0;
-  let sy = 0;
-  let sw = data.width;
-  let sh = data.height;
+type WasmBindgen = ((url: string) => Promise<void>) & WasmBindgenExports;

-  if (opts.fitMethod === 'contain') {
-    ({ sx, sy, sw, sh } = getContainOffsets(sw, sh, opts.width, opts.height));
+declare var wasm_bindgen: WasmBindgen;
+
+const ready = wasm_bindgen(wasmUrl);
+
+function crop(data: ImageData, sx: number, sy: number, sw: number, sh: number): ImageData {
+  const inputPixels = new Uint32Array(data.data.buffer);
+
+  // Copy within the same buffer for speed and memory efficiency.
+  for (let y = 0; y < sh; y += 1) {
+    const start = ((y + sy) * data.width) + sx;
+    inputPixels.copyWithin(y * sw, start, start + sw);
  }

-  return nativeResize(
-    data, sx, sy, sw, sh, opts.width, opts.height,
-    opts.method.slice('browser-'.length) as NativeResizeMethod,
+  return new ImageData(
+    new Uint8ClampedArray(inputPixels.buffer.slice(0, sw * sh * 4)),
+    sw, sh,
  );
 }

-export function vectorResize(data: HTMLImageElement, opts: VectorResizeOptions): ImageData {
-  let sx = 0;
-  let sy = 0;
-  let sw = data.width;
-  let sh = data.height;
+/** Resize methods by index */
+const resizeMethods: WorkerResizeOptions['method'][] = [
+  'triangle', 'catrom', 'mitchell', 'lanczos3',
+];
+
+export async function resize(data: ImageData, opts: WorkerResizeOptions): Promise<ImageData> {
+  let input = data;

  if (opts.fitMethod === 'contain') {
-    ({ sx, sy, sw, sh } = getContainOffsets(sw, sh, opts.width, opts.height));
+    const { sx, sy, sw, sh } = getContainOffsets(data.width, data.height, opts.width, opts.height);
+    input = crop(input, Math.round(sx), Math.round(sy), Math.round(sw), Math.round(sh));
  }

-  return drawableToImageData(data, {
-    sx, sy, sw, sh,
-    width: opts.width, height: opts.height,
-  });
+  await ready;
+
+  const result = wasm_bindgen.resize(
+    new Uint8Array(input.data.buffer), input.width, input.height, opts.width, opts.height,
+    resizeMethods.indexOf(opts.method), opts.premultiply, opts.linearRGB,
+  );
+
+  return new ImageData(new Uint8ClampedArray(result.buffer), opts.width, opts.height);
 }
--- a/src/codecs/resize/util.ts
+++ b/src/codecs/resize/util.ts
@ -0,0 +1,14 @@
+export function getContainOffsets(sw: number, sh: number, dw: number, dh: number) {
+  const currentAspect = sw / sh;
+  const endAspect = dw / dh;
+
+  if (endAspect > currentAspect) {
+    const newSh = sw / endAspect;
+    const newSy = (sh - newSh) / 2;
+    return { sw, sh: newSh, sx: 0, sy: newSy };
+  }
+
+  const newSw = sh * endAspect;
+  const newSx = (sw - newSw) / 2;
+  return { sh, sw: newSw, sx: newSx, sy: 0 };
+}
--- a/src/codecs/rotate/processor.ts
+++ b/src/codecs/rotate/processor.ts
@ -1,29 +1,42 @@
 import wasmUrl from '../../../codecs/rotate/rotate.wasm';
 import { RotateOptions, RotateModuleInstance } from './processor-meta';

+// We are loading a 500B module here. Loading the code to feature-detect
+// `instantiateStreaming` probably takes longer to load than the time we save by
+// using `instantiateStreaming` in the first place. So let’s just use
+// `ArrayBuffer`s here.
+const instancePromise = fetch(wasmUrl)
+  .then(r => r.arrayBuffer())
+  .then(buf => WebAssembly.instantiate(buf));
+
 export async function rotate(
  data: ImageData,
  opts: RotateOptions,
 ): Promise<ImageData> {
-  const flipDimensions = opts.rotate % 180 !== 0;
+  const { instance } = (await instancePromise) as {
+    instance: RotateModuleInstance;
+  };
+
  // Number of wasm memory pages (á 64KiB) needed to store the image twice.
  const bytesPerImage = data.width * data.height * 4;
-  const numPagesNeeded = Math.ceil(bytesPerImage * 2 / (64 * 1024));
-  const { instance } = (await (WebAssembly as any).instantiateStreaming(
-    fetch(wasmUrl),
-    {
-      env: {
-        memory: new WebAssembly.Memory({ initial: numPagesNeeded }),
-      },
-    },
-  )) as { instance: RotateModuleInstance };
+  const numPagesNeeded = Math.ceil((bytesPerImage * 2 + 8) / (64 * 1024));
+  // Only count full pages, just to be safe.
+  const numPagesAvailable = Math.floor(
+    instance.exports.memory.buffer.byteLength / (64 * 1024),
+  );
+  const additionalPagesToAllocate = numPagesNeeded - numPagesAvailable;

+  if (additionalPagesToAllocate > 0) {
+    instance.exports.memory.grow(additionalPagesToAllocate);
+  }
  const view = new Uint8ClampedArray(instance.exports.memory.buffer);
-  view.set(data.data);
+  view.set(data.data, 8);

  instance.exports.rotate(data.width, data.height, opts.rotate);
+
+  const flipDimensions = opts.rotate % 180 !== 0;
  return new ImageData(
-    view.slice(bytesPerImage, bytesPerImage * 2),
+    view.slice(bytesPerImage + 8, bytesPerImage * 2 + 8),
    flipDimensions ? data.height : data.width,
    flipDimensions ? data.width : data.height,
  );
--- a/src/codecs/util.ts
+++ b/src/codecs/util.ts
@ -2,7 +2,7 @@ type ModuleFactory<M extends EmscriptenWasm.Module> = (
  opts: EmscriptenWasm.ModuleOpts,
 ) => M;

-export function initWasmModule<T extends EmscriptenWasm.Module>(
+export function initEmscriptenModule<T extends EmscriptenWasm.Module>(
  moduleFactory: ModuleFactory<T>,
  wasmUrl: string,
 ): Promise<T> {
@ -25,3 +25,12 @@ export function initWasmModule<T extends EmscriptenWasm.Module>(
    });
  });
 }
+
+interface ClampOpts {
+  min?: number;
+  max?: number;
+}
+
+export function clamp(x: number, opts: ClampOpts): number {
+  return Math.min(Math.max(x, opts.min || Number.MIN_VALUE), opts.max || Number.MAX_VALUE);
+}
--- a/src/codecs/webp/decoder.ts
+++ b/src/codecs/webp/decoder.ts
@ -1,11 +1,11 @@
 import webp_dec, { WebPModule } from '../../../codecs/webp_dec/webp_dec';
 import wasmUrl from '../../../codecs/webp_dec/webp_dec.wasm';
-import { initWasmModule } from '../util';
+import { initEmscriptenModule } from '../util';

 let emscriptenModule: Promise<WebPModule>;

 export async function decode(data: ArrayBuffer): Promise<ImageData> {
-  if (!emscriptenModule) emscriptenModule = initWasmModule(webp_dec, wasmUrl);
+  if (!emscriptenModule) emscriptenModule = initEmscriptenModule(webp_dec, wasmUrl);

  const module = await emscriptenModule;
  const rawImage = module.decode(data);
--- a/src/codecs/webp/encoder.ts
+++ b/src/codecs/webp/encoder.ts
@ -1,12 +1,12 @@
 import webp_enc, { WebPModule } from '../../../codecs/webp_enc/webp_enc';
 import wasmUrl from '../../../codecs/webp_enc/webp_enc.wasm';
 import { EncodeOptions } from './encoder-meta';
-import { initWasmModule } from '../util';
+import { initEmscriptenModule } from '../util';

 let emscriptenModule: Promise<WebPModule>;

 export async function encode(data: ImageData, options: EncodeOptions): Promise<ArrayBuffer> {
-  if (!emscriptenModule) emscriptenModule = initWasmModule(webp_enc, wasmUrl);
+  if (!emscriptenModule) emscriptenModule = initEmscriptenModule(webp_enc, wasmUrl);

  const module = await emscriptenModule;
  const resultView = module.encode(data.data, data.width, data.height, options);
--- a/src/components/App/index.tsx
+++ b/src/components/App/index.tsx
@ -13,12 +13,11 @@ const ROUTE_EDITOR = '/editor';

 const compressPromise = import(
  /* webpackChunkName: "main-app" */
-  '../compress',
-);
-const offlinerPromise = import(
-  /* webpackChunkName: "offliner" */
-  '../../lib/offliner',
-);
+  '../compress');
+
+const swBridgePromise = import(
+  /* webpackChunkName: "sw-bridge" */
+  '../../lib/sw-bridge');

 function back() {
  window.history.back();
@ -27,6 +26,7 @@ function back() {
 interface Props {}

 interface State {
+  awaitingShareTarget: boolean;
  file?: File | Fileish;
  isEditorOpen: Boolean;
  Compress?: typeof import('../compress').default;
@ -34,6 +34,7 @@ interface State {

 export default class App extends Component<Props, State> {
  state: State = {
+    awaitingShareTarget: new URL(location.href).searchParams.has('share-target'),
    isEditorOpen: false,
    file: undefined,
    Compress: undefined,
@ -50,7 +51,15 @@ export default class App extends Component<Props, State> {
      this.showSnack('Failed to load app');
    });

-    offlinerPromise.then(({ offliner }) => offliner(this.showSnack));
+    swBridgePromise.then(async ({ offliner, getSharedImage }) => {
+      offliner(this.showSnack);
+      if (!this.state.awaitingShareTarget) return;
+      const file = await getSharedImage();
+      // Remove the ?share-target from the URL
+      history.replaceState('', '', '/');
+      this.openEditor();
+      this.setState({ file, awaitingShareTarget: false });
+    });

    // In development, persist application state across hot reloads:
    if (process.env.NODE_ENV === 'development') {
@ -74,8 +83,9 @@ export default class App extends Component<Props, State> {
  }

  @bind
-  private onFileDrop({ file }: FileDropEvent) {
-    if (!file) return;
+  private onFileDrop({ files }: FileDropEvent) {
+    if (!files || files.length === 0) return;
+    const file = files[0];
    this.openEditor();
    this.setState({ file });
  }
@ -100,19 +110,25 @@ export default class App extends Component<Props, State> {
  @bind
  private openEditor() {
    if (this.state.isEditorOpen) return;
-    history.pushState(null, '', ROUTE_EDITOR);
+    // Change path, but preserve query string.
+    const editorURL = new URL(location.href);
+    editorURL.pathname = ROUTE_EDITOR;
+    history.pushState(null, '', editorURL.href);
    this.setState({ isEditorOpen: true });
  }

-  render({}: Props, { file, isEditorOpen, Compress }: State) {
+  render({}: Props, { file, isEditorOpen, Compress, awaitingShareTarget }: State) {
+    const showSpinner = awaitingShareTarget || (isEditorOpen && !Compress);
+
    return (
      <div id="app" class={style.app}>
        <file-drop accept="image/*" onfiledrop={this.onFileDrop} class={style.drop}>
-          {!isEditorOpen
-            ? <Intro onFile={this.onIntroPickFile} showSnack={this.showSnack} />
-            : (Compress)
-              ? <Compress file={file!} showSnack={this.showSnack} onBack={back} />
-              : <loading-spinner class={style.appLoader}/>
+          {
+            showSpinner
+              ? <loading-spinner class={style.appLoader}/>
+              : isEditorOpen
+                ? Compress && <Compress file={file!} showSnack={this.showSnack} onBack={back} />
+                : <Intro onFile={this.onIntroPickFile} showSnack={this.showSnack} />
          }
          <snack-bar ref={linkRef(this, 'snackbar')} />
        </file-drop>
--- a/src/components/Options/index.tsx
+++ b/src/components/Options/index.tsx
@ -146,12 +146,14 @@ export default class Options extends Component<Props, State> {
                {preprocessorState.resize.enabled ?
                  <ResizeOptionsComponent
                    isVector={Boolean(source && source.vectorImage)}
-                    aspect={source ? source.processed.width / source.processed.height : 1}
+                    inputWidth={source ? source.processed.width : 1}
+                    inputHeight={source ? source.processed.height : 1}
                    options={preprocessorState.resize}
                    onChange={this.onResizeOptionsChange}
                  />
                : null}
              </Expander>
+
              <label class={style.sectionEnabler}>
                <Checkbox
                  name="quantizer.enable"
@ -178,6 +180,7 @@ export default class Options extends Component<Props, State> {
          {encoderSupportMap ?
            <Select value={encoderState.type} onChange={this.onEncoderTypeChange} large>
              {encoders.filter(encoder => encoderSupportMap[encoder.type]).map(encoder => (
+                // tslint:disable-next-line:jsx-key
                <option value={encoder.type}>{encoder.label}</option>
              ))}
            </Select>
--- a/src/components/compress/index.tsx
+++ b/src/components/compress/index.tsx
@ -18,20 +18,14 @@ import * as browserTIFF from '../../codecs/browser-tiff/encoder-meta';
 import * as browserJP2 from '../../codecs/browser-jp2/encoder-meta';
 import * as browserBMP from '../../codecs/browser-bmp/encoder-meta';
 import * as browserPDF from '../../codecs/browser-pdf/encoder-meta';
-import {
-    EncoderState,
-    EncoderType,
-    EncoderOptions,
-    encoderMap,
-} from '../../codecs/encoders';
-import {
-  PreprocessorState,
-  defaultPreprocessorState,
-} from '../../codecs/preprocessors';
+import { EncoderState, EncoderType, EncoderOptions, encoderMap } from '../../codecs/encoders';
+import { PreprocessorState, defaultPreprocessorState } from '../../codecs/preprocessors';
 import { decodeImage } from '../../codecs/decoders';
 import { cleanMerge, cleanSet } from '../../lib/clean-modify';
 import Processor from '../../codecs/processor';
-import { VectorResizeOptions, BitmapResizeOptions } from '../../codecs/resize/processor-meta';
+import {
+  BrowserResizeOptions, isWorkerOptions as isWorkerResizeOptions, isHqx, WorkerResizeOptions,
+} from '../../codecs/resize/processor-meta';
 import './custom-els/MultiPanel';
 import Results from '../results';
 import { ExpandIcon, CopyAcrossIconProps } from '../../lib/icons';
@ -110,10 +104,24 @@ async function preprocessImage(
    if (preprocessData.resize.method === 'vector' && source.vectorImage) {
      result = processor.vectorResize(
        source.vectorImage,
-        preprocessData.resize as VectorResizeOptions,
+        preprocessData.resize,
      );
+    } else if (isHqx(preprocessData.resize)) {
+      // Hqx can only do x2, x3 or x4.
+      result = await processor.workerResize(result, preprocessData.resize);
+      // Seems like the globals from Rust from hqx and resize are conflicting.
+      // For now we can fix that by terminating the worker.
+      // TODO: Use wasm-bindgen’s new --web target to create a proper ES6 module
+      // and remove this.
+      processor.terminateWorker();
+      // If the target size is not a clean x2, x3 or x4, use Catmull-Rom
+      // for the remaining scaling.
+      const pixelOpts = { ...preprocessData.resize, method: 'catrom' };
+      result = await processor.workerResize(result, pixelOpts as WorkerResizeOptions);
+    } else if (isWorkerResizeOptions(preprocessData.resize)) {
+      result = await processor.workerResize(result, preprocessData.resize);
    } else {
-      result = processor.resize(result, preprocessData.resize as BitmapResizeOptions);
+      result = processor.resize(result, preprocessData.resize as BrowserResizeOptions);
    }
  }
  if (preprocessData.quantizer.enabled) {
@ -248,7 +256,7 @@ export default class Compress extends Component<Props, State> {
    this.widthQuery.addListener(this.onMobileWidthChange);
    this.updateFile(props.file);

-    import('../../lib/offliner').then(({ mainAppLoaded }) => mainAppLoaded());
+    import('../../lib/sw-bridge').then(({ mainAppLoaded }) => mainAppLoaded());
  }

  @bind
@ -441,7 +449,7 @@ export default class Compress extends Component<Props, State> {
        newState = cleanMerge(newState, `sides.${i}.latestSettings.preprocessorState.resize`, {
          width: processed.width,
          height: processed.height,
-          method: vectorImage ? 'vector' : 'browser-high',
+          method: vectorImage ? 'vector' : 'lanczos3',
        });
      }

@ -571,6 +579,7 @@ export default class Compress extends Component<Props, State> {
    const [leftImageData, rightImageData] = sides.map(i => i.data);

    const options = sides.map((side, index) => (
+      // tslint:disable-next-line:jsx-key
      <Options
        source={source}
        mobileView={mobileView}
@ -586,6 +595,7 @@ export default class Compress extends Component<Props, State> {
      (mobileView ? ['down', 'up'] : ['right', 'left']) as CopyAcrossIconProps['copyDirection'][];

    const results = sides.map((side, index) => (
+      // tslint:disable-next-line:jsx-key
      <Results
        downloadUrl={side.downloadUrl}
        imageFile={side.file}
--- a/src/components/compress/style.scss
+++ b/src/components/compress/style.scss
@ -40,6 +40,7 @@
  position: relative;
  display: flex;
  flex-flow: column;
+  overflow: hidden;

  // Reorder so headings appear after content:
  & > :nth-child(1) {
--- a/src/components/intro/imgs/logo.svg
+++ b/src/components/intro/imgs/logo.svg
--- a/src/components/intro/index.tsx
+++ b/src/components/intro/index.tsx
@ -53,11 +53,17 @@ export default class Intro extends Component<Props, State> {
  state: State = {};
  private fileInput?: HTMLInputElement;

+  @bind
+  private resetFileInput() {
+    this.fileInput!.value = '';
+  }
+
  @bind
  private onFileChange(event: Event): void {
    const fileInput = event.target as HTMLInputElement;
    const file = fileInput.files && fileInput.files[0];
    if (!file) return;
+    this.resetFileInput();
    this.props.onFile(file);
  }

--- a/src/index.ts
+++ b/src/index.ts
@ -7,8 +7,7 @@ function init() {
 if (!('customElements' in self)) {
  import(
    /* webpackChunkName: "wc-polyfill" */
-    '@webcomponents/custom-elements',
-  ).then(init);
+    '@webcomponents/custom-elements').then(init);
 } else {
  init();
 }
--- a/src/lib/sw-bridge.ts
+++ b/src/lib/sw-bridge.ts
@ -40,6 +40,23 @@ async function updateReady(reg: ServiceWorkerRegistration): Promise<void> {
  });
 }

+/** Wait for a shared image */
+export function getSharedImage(): Promise<File> {
+  return new Promise((resolve) => {
+    const onmessage = (event: MessageEvent) => {
+      if (event.data.action !== 'load-image') return;
+      resolve(event.data.file);
+      navigator.serviceWorker.removeEventListener('message', onmessage);
+    };
+
+    navigator.serviceWorker.addEventListener('message', onmessage);
+
+    // This message is picked up by the service worker - it's how it knows we're ready to receive
+    // the file.
+    navigator.serviceWorker.controller!.postMessage('share-ready');
+  });
+}
+
 /** Set up the service worker and monitor changes */
 export async function offliner(showSnack: SnackBarElement['showSnackbar']) {
  // This needs to be a typeof because Webpack.
--- a/src/manifest.json
+++ b/src/manifest.json
@ -12,5 +12,18 @@
      "type": "image/png",
      "sizes": "1024x1024"
    }
-  ]
+  ],
+  "share_target": {
+    "action": "/?share-target",
+    "method": "POST",
+    "enctype": "multipart/form-data",
+    "params": {
+      "files": [
+        {
+          "name": "file",
+          "accept": ["image/*"]
+        }
+      ]
+    }
+  }
 }
--- a/src/sw/index.ts
+++ b/src/sw/index.ts
@ -1,5 +1,6 @@
 import {
  cacheOrNetworkAndCache, cleanupCache, cacheOrNetwork, cacheBasics, cacheAdditionalProcessors,
+  serveShareTarget,
 } from './util';
 import { get } from 'idb-keyval';

@ -40,14 +41,23 @@ self.addEventListener('activate', (event) => {
 });

 self.addEventListener('fetch', (event) => {
-  // We only care about GET.
-  if (event.request.method !== 'GET') return;
-
  const url = new URL(event.request.url);

  // Don't care about other-origin URLs
  if (url.origin !== location.origin) return;

+  if (
+    url.pathname === '/' &&
+    url.searchParams.has('share-target') &&
+    event.request.method === 'POST'
+  ) {
+    serveShareTarget(event);
+    return;
+  }
+
+  // We only care about GET from here on in.
+  if (event.request.method !== 'GET') return;
+
  if (url.pathname.startsWith('/demo-') || url.pathname.startsWith('/wc-polyfill')) {
    cacheOrNetworkAndCache(event, dynamicCache);
    cleanupCache(event, dynamicCache, BUILD_ASSETS);
--- a/src/sw/util.ts
+++ b/src/sw/util.ts
@ -1,8 +1,11 @@
 import webpDataUrl from 'url-loader!../codecs/tiny.webp';

+// Give TypeScript the correct global.
+declare var self: ServiceWorkerGlobalScope;
+
 export function cacheOrNetwork(event: FetchEvent): void {
  event.respondWith(async function () {
-    const cachedResponse = await caches.match(event.request);
+    const cachedResponse = await caches.match(event.request, { ignoreSearch: true });
    return cachedResponse || fetch(event.request);
  }());
 }
@ -29,6 +32,23 @@ export function cacheOrNetworkAndCache(event: FetchEvent, cacheName: string): vo
  }());
 }

+export function serveShareTarget(event: FetchEvent): void {
+  const dataPromise = event.request.formData();
+
+  // Redirect so the user can refresh the page without resending data.
+  // @ts-ignore It doesn't like me giving a response to respondWith, although it's allowed.
+  event.respondWith(Response.redirect('/?share-target'));
+
+  event.waitUntil(async function () {
+    // The page sends this message to tell the service worker it's ready to receive the file.
+    await nextMessage('share-ready');
+    const client = await self.clients.get(event.resultingClientId);
+    const data = await dataPromise;
+    const file = data.get('file');
+    client.postMessage({ file, action: 'load-image' });
+  }());
+}
+
 export function cleanupCache(event: FetchEvent, cacheName: string, keepAssets: string[]) {
  event.waitUntil(async function () {
    const cache = await caches.open(cacheName);
@ -104,3 +124,26 @@ export async function cacheAdditionalProcessors(cacheName: string, buildAssets:
  const cache = await caches.open(cacheName);
  await cache.addAll(toCache);
 }
+
+const nextMessageResolveMap = new Map<string, (() => void)[]>();
+
+/**
+ * Wait on a message with a particular event.data value.
+ *
+ * @param dataVal The event.data value.
+ */
+function nextMessage(dataVal: string): Promise<void> {
+  return new Promise((resolve) => {
+    if (!nextMessageResolveMap.has(dataVal)) {
+      nextMessageResolveMap.set(dataVal, []);
+    }
+    nextMessageResolveMap.get(dataVal)!.push(resolve);
+  });
+}
+
+self.addEventListener('message', (event) => {
+  const resolvers = nextMessageResolveMap.get(event.data);
+  if (!resolvers) return;
+  nextMessageResolveMap.delete(event.data);
+  for (const resolve of resolvers) resolve();
+});
--- a/tslint.json
+++ b/tslint.json
@ -12,7 +12,8 @@
    "variable-name": [true, "check-format", "allow-leading-underscore"],
    "no-duplicate-imports": false,
    "prefer-template": [true, "allow-single-concat"],
-    "import-name": false
+    "import-name": false,
+    "jsx-key": false
  },
  "linterOptions": {
    "exclude": [