Delete .gitignore in resize codec

This delegates loading of Wasm modules to Webpack itself, making wrapper code simpler.

Emscripten-generated modules are still using custom loading glue as they're not compatible with Webpack.

.babelrc

@@ -1,13 +0,0 @@
-{
-  "plugins": [
-    "transform-class-properties",
-    "transform-react-constant-elements",
-    "transform-react-remove-prop-types",
-    [
-      "transform-react-jsx",
-      {
-        "pragma": "h"
-      }
-    ]
-  ]
-}

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,36 @@
+---
+name: Bug report
+about: Something is not working as expected
+labels: 
+
+---
+
+**Before you start**
+Please take a look at the [FAQ](https://github.com/GoogleChromeLabs/squoosh/wiki/FAQ) as well as the already opened issues! If nothing fits your problem, go ahead and fill out the following template:
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Version:**
+ - OS w/ version: [e.g. iOS 12]
+ - Browser w/ version [e.g. Chrome 70]
+ - Node version: [e.g. 10.11.0]
+ - npm version: [e.g. 6.4.1]
+
+**Is your issue related to the quality of image compression?**
+Please attach original and output images (you can drag & drop to attach). 
+- Original image 
+- Output image from Squoosh
+
+**Additional context, screenshots, screencasts**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,18 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+labels: 
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Does other service/app have this feature?**
+Add any service you know/use that has this feature (We want to know for research)
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.nvmrc

@@ -0,0 +1 @@
+10.16.1

.travis.yml

@@ -1,5 +1,4 @@
 language: node_js
-node_js:
-- node
 cache: npm
-script: npm run build || npm run build # scss ts definitions need to be generated before an actual build
+script: npm run build
+after_success: npm run sizereport

README.md

@@ -1,5 +1,31 @@
-# Squoosh!
+# [Squoosh]!
 
-Squoosh will be an image compression web app that allows you to dive into the
-advanced options provided by various image compressors.
+[Squoosh] is an image compression web app that allows you to dive into the advanced options provided
+by various image compressors.
 
+# Privacy
+
+Google Analytics is used to record the following:
+
+* [Basic visit data](https://support.google.com/analytics/answer/6004245?ref_topic=2919631).
+* Before and after image size once an image is downloaded. These values are rounded to the nearest
+  kilobyte.
+
+Image compression is handled locally; no additional data is sent to the server.
+
+# Building locally
+
+Clone the repo, and:
+
+```sh
+npm install
+npm run build
+```
+
+You can run the development server with:
+
+```sh
+npm start
+```
+
+[Squoosh]: https://squoosh.app

_headers.ejs

@@ -0,0 +1,18 @@
+# Long-term cache by default.
+/*
+  Cache-Control: max-age=31536000
+
+# And here are the exceptions:
+/
+  Cache-Control: no-cache
+
+/serviceworker.js
+  Cache-Control: no-cache
+
+/manifest.json
+  Cache-Control: must-revalidate, max-age=3600
+
+# URLs in /assets do not include a hash and are mutable.
+# But it isn't a big deal if the user gets an old version.
+/assets/*
+  Cache-Control: must-revalidate, max-age=3600

_redirects.ejs

@@ -0,0 +1,2 @@
+/index.html / 301
+/* /index.html 301

codecs/README.md

@@ -11,6 +11,6 @@ $ npm install
 $ npm run build
 ```
 
-This will build two files: `<codec name>_<enc or dec>.js` and `<codec name>_<enc or dec>.wasm`. It will most likely be necessary to set [`Module["locateFile"]`](https://kripken.github.io/emscripten-site/docs/api_reference/module.html#affecting-execution) to sucessfully load the `.wasm` file. When the `.js` file is loaded, a global `<codec name>_<enc or dec>` is created with the same API as an [Emscripten `Module`](https://kripken.github.io/emscripten-site/docs/api_reference/module.html).
+This will build two files: `<codec name>_<enc or dec>.js` and `<codec name>_<enc or dec>.wasm`. It will most likely be necessary to set [`Module["locateFile"]`](https://kripken.github.io/emscripten-site/docs/api_reference/module.html#affecting-execution) to successfully load the `.wasm` file. When the `.js` file is loaded, a global `<codec name>_<enc or dec>` is created with the same API as an [Emscripten `Module`](https://kripken.github.io/emscripten-site/docs/api_reference/module.html).
 
 Each codec will document its API in its README.

codecs/hqx/.gitignore

@@ -0,0 +1,5 @@
+**/*.rs.bk
+target
+Cargo.lock
+bin/
+pkg/README.md

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

codecs/hqx/Dockerfile

@@ -0,0 +1,12 @@
+FROM rust
+RUN rustup target add wasm32-unknown-unknown
+RUN curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+
+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
+
+RUN mkdir /opt/wabt && \
+ curl -L https://github.com/WebAssembly/wabt/releases/download/1.0.11/wabt-1.0.11-linux.tar.gz  | tar -xzf - -C /opt/wabt --strip 1
+
+ENV PATH="/opt/binaryen:/opt/wabt:${PATH}"
+WORKDIR /src

codecs/hqx/build.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+set -e
+
+echo "============================================="
+echo "Compiling wasm"
+echo "============================================="
+(
+  wasm-pack build
+  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://crbug.com/974804 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 "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"

codecs/hqx/package-lock.json

@@ -0,0 +1,4 @@
+{
+  "name": "hqx",
+  "lockfileVersion": 1
+}

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"
+  }
+}

codecs/hqx/pkg/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "squooshhqx",
+  "collaborators": [
+    "Surma <surma@surma.link>"
+  ],
+  "version": "0.1.0",
+  "files": [
+    "squooshhqx_bg.wasm",
+    "squooshhqx.js",
+    "squooshhqx.d.ts"
+  ],
+  "module": "squooshhqx.js",
+  "types": "squooshhqx.d.ts",
+  "sideEffects": "false"
+}

codecs/hqx/pkg/squooshhqx.d.ts

@@ -0,0 +1,9 @@
+/* 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;

codecs/hqx/pkg/squooshhqx.js

@@ -0,0 +1,46 @@
+import * as wasm from './squooshhqx_bg.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;
+}
+
+let cachegetInt32Memory = null;
+function getInt32Memory() {
+    if (cachegetInt32Memory === null || cachegetInt32Memory.buffer !== wasm.memory.buffer) {
+        cachegetInt32Memory = new Int32Array(wasm.memory.buffer);
+    }
+    return cachegetInt32Memory;
+}
+
+function getArrayU32FromWasm(ptr, len) {
+    return getUint32Memory().subarray(ptr / 4, ptr / 4 + len);
+}
+/**
+* @param {Uint32Array} input_image
+* @param {number} input_width
+* @param {number} input_height
+* @param {number} factor
+* @returns {Uint32Array}
+*/
+export function resize(input_image, input_width, input_height, factor) {
+    const retptr = 8;
+    const ret = wasm.resize(retptr, passArray32ToWasm(input_image), WASM_VECTOR_LEN, input_width, input_height, factor);
+    const memi32 = getInt32Memory();
+    const v0 = getArrayU32FromWasm(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1]).slice();
+    wasm.__wbindgen_free(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1] * 4);
+    return v0;
+}
+

codecs/hqx/pkg/squooshhqx_bg.d.ts

@@ -0,0 +1,5 @@
+/* tslint:disable */
+export const memory: WebAssembly.Memory;
+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): void;

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;
+}

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() {}
+    }
+}

codecs/imagequant/package.json

@@ -8,6 +8,6 @@
     "libimagequant": "ImageOptim/libimagequant#2.12.1"
   },
   "devDependencies": {
-    "napa": "^3.0.0"
+    "napa": "3.0.0"
   }
 }

codecs/mozjpeg_enc/package.json

@@ -8,6 +8,6 @@
     "mozjpeg": "mozilla/mozjpeg#v3.3.1"
   },
   "devDependencies": {
-    "napa": "^3.0.0"
+    "napa": "3.0.0"
   }
 }

codecs/optipng/README.md

@@ -1,6 +1,6 @@
 # OptiPNG
 
-- Source: <https://sourceforge.net/project/optipng>
+- Source: <http://optipng.sourceforge.net/>
 - Version: v0.7.7
 
 ## Dependencies

codecs/optipng/package.json

@@ -16,7 +16,7 @@
     "zlib": "emscripten-ports/zlib"
   },
   "dependencies": {
-    "napa": "^3.0.0",
+    "napa": "3.0.0",
     "tar-dependency": "0.0.3"
   }
 }

codecs/resize/.gitignore

@@ -0,0 +1,6 @@
+**/*.rs.bk
+target
+Cargo.lock
+bin/
+pkg/README.md
+lut.inc

codecs/resize/Cargo.toml

@@ -0,0 +1,37 @@
+[package]
+name = "resize"
+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

codecs/resize/Dockerfile

@@ -0,0 +1,9 @@
+FROM rust
+RUN rustup target add wasm32-unknown-unknown
+RUN curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+
+RUN mkdir /opt/wabt && \
+ curl -L https://github.com/WebAssembly/wabt/releases/download/1.0.11/wabt-1.0.11-linux.tar.gz  | tar -xzf - -C /opt/wabt --strip 1
+
+ENV PATH="/opt/wabt:${PATH}"
+WORKDIR /src

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(())
+}

codecs/resize/build.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+set -e
+
+echo "============================================="
+echo "Compiling wasm"
+echo "============================================="
+(
+  wasm-pack build
+  wasm-strip pkg/resize_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-resize .\`"
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"

codecs/resize/package-lock.json

@@ -0,0 +1,4 @@
+{
+  "name": "resize",
+  "lockfileVersion": 1
+}

codecs/resize/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "resize",
+  "scripts": {
+    "build:image": "docker build -t squoosh-resize .",
+    "build": "docker run --rm -v $(pwd):/src squoosh-resize ./build.sh"
+  }
+}

codecs/resize/pkg/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "resize",
+  "collaborators": [
+    "Surma <surma@surma.link>"
+  ],
+  "version": "0.1.0",
+  "files": [
+    "resize_bg.wasm",
+    "resize.js",
+    "resize.d.ts"
+  ],
+  "module": "resize.js",
+  "types": "resize.d.ts",
+  "sideEffects": "false"
+}

codecs/resize/pkg/resize.d.ts

@@ -0,0 +1,13 @@
+/* tslint:disable */
+/**
+* @param {Uint8Array} input_image 
+* @param {number} input_width 
+* @param {number} input_height 
+* @param {number} output_width 
+* @param {number} output_height 
+* @param {number} typ_idx 
+* @param {boolean} premultiply 
+* @param {boolean} color_space_conversion 
+* @returns {Uint8Array} 
+*/
+export function resize(input_image: Uint8Array, input_width: number, input_height: number, output_width: number, output_height: number, typ_idx: number, premultiply: boolean, color_space_conversion: boolean): Uint8Array;

codecs/resize/pkg/resize.js

@@ -0,0 +1,50 @@
+import * as wasm from './resize_bg.wasm';
+
+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;
+}
+
+let cachegetInt32Memory = null;
+function getInt32Memory() {
+    if (cachegetInt32Memory === null || cachegetInt32Memory.buffer !== wasm.memory.buffer) {
+        cachegetInt32Memory = new Int32Array(wasm.memory.buffer);
+    }
+    return cachegetInt32Memory;
+}
+
+function getArrayU8FromWasm(ptr, len) {
+    return getUint8Memory().subarray(ptr / 1, ptr / 1 + len);
+}
+/**
+* @param {Uint8Array} input_image
+* @param {number} input_width
+* @param {number} input_height
+* @param {number} output_width
+* @param {number} output_height
+* @param {number} typ_idx
+* @param {boolean} premultiply
+* @param {boolean} color_space_conversion
+* @returns {Uint8Array}
+*/
+export function resize(input_image, input_width, input_height, output_width, output_height, typ_idx, premultiply, color_space_conversion) {
+    const retptr = 8;
+    const ret = wasm.resize(retptr, passArray8ToWasm(input_image), WASM_VECTOR_LEN, input_width, input_height, output_width, output_height, typ_idx, premultiply, color_space_conversion);
+    const memi32 = getInt32Memory();
+    const v0 = getArrayU8FromWasm(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1]).slice();
+    wasm.__wbindgen_free(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1] * 1);
+    return v0;
+}
+

codecs/resize/pkg/resize_bg.d.ts

@@ -0,0 +1,5 @@
+/* tslint:disable */
+export const memory: WebAssembly.Memory;
+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;

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;
+}

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)
+    }
+}

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() {}
+    }
+}

codecs/rotate/.gitignore

@@ -0,0 +1,2 @@
+target
+Cargo.lock

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"

codecs/rotate/Dockerfile

@@ -0,0 +1,8 @@
+FROM rust
+RUN rustup target add wasm32-unknown-unknown
+
+RUN mkdir /opt/wabt && \
+ curl -L https://github.com/WebAssembly/wabt/releases/download/1.0.11/wabt-1.0.11-linux.tar.gz  | tar -xzf - -C /opt/wabt --strip 1
+
+ENV PATH="/opt/wabt:${PATH}"
+WORKDIR /src

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));

codecs/rotate/build.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+set -e
+
+echo "============================================="
+echo "Compiling wasm"
+echo "============================================="
+(
+  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 "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"

codecs/rotate/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "rotate",
+  "scripts": {
+    "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"
+  }
+}

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(),
+    }
+}

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
 

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"

codecs/webp_dec/package.json

@@ -5,9 +5,9 @@
     "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"
+    "napa": "3.0.0"
   }
 }

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
 

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"

codecs/webp_enc/package.json

@@ -5,9 +5,9 @@
     "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"
+    "napa": "3.0.0"
   }
 }

codecs/webp_enc/webp_enc.cpp

@@ -26,7 +26,8 @@ val encode(std::string img, int width, int height, WebPConfig config) {
     throw std::runtime_error("Unexpected error");
   }
 
-  pic.use_argb = !!config.lossless;
+  // Only use use_argb if we really need it, as it's slower.
+  pic.use_argb = config.lossless || config.use_sharp_yuv || config.preprocessing > 0;
   pic.width = width;
   pic.height = height;
   pic.writer = WebPMemoryWrite;

config/add-css-types.js

@@ -0,0 +1,74 @@
+const DtsCreator = require('typed-css-modules');
+const chokidar = require('chokidar');
+const util = require('util');
+const sass = require('node-sass');
+
+const sassRender = util.promisify(sass.render);
+
+async function sassToCss(path) {
+  const result = await sassRender({ file: path });
+  return result.css;
+}
+
+/**
+ * @typedef {Object} Opts
+ * @property {boolean} watch Watch for changes
+ */
+/**
+ * Create typing files for CSS & SCSS.
+ *
+ * @param {string[]} rootPaths Paths to search within
+ * @param {Opts} [opts={}] Options.
+ */
+function addCssTypes(rootPaths, opts = {}) {
+  return new Promise((resolve) => {
+    const { watch = false } = opts;
+
+    const paths = [];
+    const preReadyPromises = [];
+    let ready = false;
+
+    for (const rootPath of rootPaths) {
+      // Look for scss & css in each path.
+      paths.push(rootPath + '/**/*.scss');
+      paths.push(rootPath + '/**/*.css');
+    }
+
+    // For simplicity, the watcher is used even if we're not watching.
+    // If we're not watching, we stop the watcher after the initial files are found.
+    const watcher = chokidar.watch(paths, {
+      // Avoid processing already-processed files.
+      ignored: '*.d.*',
+      // Without this, travis and netlify builds never complete. I'm not sure why, but it might be
+      // related to https://github.com/paulmillr/chokidar/pull/758
+      persistent: watch,
+    });
+
+    function change(path) {
+      const promise = (async function() {
+        const creator = new DtsCreator({ camelCase: true });
+        const result = path.endsWith('.scss') ?
+          await creator.create(path, await sassToCss(path)) :
+          await creator.create(path);
+
+        await result.writeFile();
+      })();
+
+      if (!ready) preReadyPromises.push(promise);
+    }
+
+    watcher.on('change', change);
+    watcher.on('add', change);
+
+    // 'ready' is when events have been fired for file discovery.
+    watcher.on('ready', () => {
+      ready = true;
+      // Wait for the current set of processing to finish.
+      Promise.all(preReadyPromises).then(resolve);
+      // And if we're not watching, close the watcher.
+      if (!watch) watcher.close();
+    });
+  })
+}
+
+module.exports = addCssTypes;

config/asset-template-plugin.js

@@ -0,0 +1,47 @@
+const path = require('path');
+const fs = require('fs');
+const ejs = require('ejs');
+const AssetsPlugin = require('assets-webpack-plugin');
+
+module.exports = class AssetTemplatePlugin extends AssetsPlugin {
+  constructor(options) {
+    options = options || {};
+    if (!options.template) throw Error('AssetTemplatePlugin: template option is required.');
+    super({
+      useCompilerPath: true,
+      filename: options.filename,
+      processOutput: files => this._processOutput(files)
+    });
+    this._template = path.resolve(process.cwd(), options.template);
+    const ignore = options.ignore || /(manifest\.json|\.DS_Store)$/;
+    this._ignore = typeof ignore === 'function' ? ({ test: ignore }) : ignore;
+  }
+
+  _processOutput(files) {
+    const mapping = {
+      all: [],
+      byType: {},
+      entries: {}
+    };
+    for (const entryName in files) {
+      // non-entry-point-derived assets are collected under an empty string key
+      // since that's a bit awkward, we'll call them "assets"
+      const name = entryName === '' ? 'assets' : entryName;
+      const listing = files[entryName];
+      const entry = mapping.entries[name] = {
+        all: [],
+        byType: {}
+      };
+      for (let type in listing) {
+        const list = [].concat(listing[type]).filter(file => !this._ignore.test(file));
+        if (!list.length) continue;
+        mapping.all = mapping.all.concat(list);
+        mapping.byType[type] = (mapping.byType[type] || []).concat(list);
+        entry.all = entry.all.concat(list);
+        entry.byType[type] = (entry.byType[type] || []).concat(list);
+      }
+    }
+    mapping.files = mapping.all;
+    return ejs.render(fs.readFileSync(this._template, 'utf8'), mapping);
+  }
+};

config/auto-sw-plugin.js

@@ -0,0 +1,158 @@
+const util = require('util');
+const minimatch = require('minimatch');
+const SingleEntryPlugin = require('webpack/lib/SingleEntryPlugin');
+const WebWorkerTemplatePlugin = require('webpack/lib/webworker/WebWorkerTemplatePlugin');
+const ParserHelpers = require('webpack/lib/ParserHelpers');
+
+const NAME = 'auto-sw-plugin';
+const JS_TYPES = ['auto', 'esm', 'dynamic'];
+
+/**
+ * Automatically finds and bundles Service Workers by looking for navigator.serviceWorker.register(..).
+ * An Array of webpack assets is injected into the Service Worker bundle as a `BUILD_ASSETS` global.
+ * Hidden and `.map` files are excluded by default, and this can be customized using the include & exclude options.
+ * @example
+ *  // webpack config
+ *  plugins: [
+ *    new AutoSWPlugin({
+ *      exclude: [
+ *        '**\/.*',     // don't expose hidden files (default)
+ *        '**\/*.map',  // don't precache sourcemaps (default)
+ *        'index.html'  // don't cache the page itself
+ *      ]
+ *    })
+ *  ]
+ * @param {Object} [options={}]
+ * @param {string[]} [options.exclude]  Minimatch pattern(s) of which assets to omit from BUILD_ASSETS.
+ * @param {string[]} [options.include]  Minimatch pattern(s) of assets to allow in BUILD_ASSETS.
+ */
+module.exports = class AutoSWPlugin {
+  constructor(options) {
+    this.options = Object.assign({
+      exclude: [
+        '**/*.map',
+        '**/.*'
+      ]
+    }, options || {});
+  }
+
+  apply(compiler) {
+    const serviceWorkers = [];
+
+    compiler.hooks.emit.tapPromise(NAME, compilation => this.emit(compiler, compilation, serviceWorkers));
+
+    compiler.hooks.normalModuleFactory.tap(NAME, (factory) => {
+      for (const type of JS_TYPES) {
+        factory.hooks.parser.for(`javascript/${type}`).tap(NAME, parser => {
+          let counter = 0;
+
+          const processRegisterCall = expr => {
+            const dep = parser.evaluateExpression(expr.arguments[0]);
+
+            if (!dep.isString()) {
+              parser.state.module.warnings.push({
+                message: 'navigator.serviceWorker.register() will only be bundled if passed a String literal.'
+              });
+              return false;
+            }
+
+            const filename = dep.string;
+            const outputFilename = this.options.filename || 'serviceworker.js'
+            const context = parser.state.current.context;
+            serviceWorkers.push({
+              outputFilename,
+              filename,
+              context
+            });
+
+            const id = `__webpack__serviceworker__${++counter}`;
+            ParserHelpers.toConstantDependency(parser, id)(expr.arguments[0]);
+            return ParserHelpers.addParsedVariableToModule(parser, id, '__webpack_public_path__ + ' + JSON.stringify(outputFilename));
+          };
+
+          parser.hooks.call.for('navigator.serviceWorker.register').tap(NAME, processRegisterCall);
+          parser.hooks.call.for('self.navigator.serviceWorker.register').tap(NAME, processRegisterCall);
+          parser.hooks.call.for('window.navigator.serviceWorker.register').tap(NAME, processRegisterCall);
+        });
+      }
+    });
+  }
+
+  createFilter(list) {
+    const filters = [].concat(list);
+    for (let i=0; i<filters.length; i++) {
+      if (typeof filters[i] === 'string') {
+        filters[i] = minimatch.filter(filters[i]);
+      }
+    }
+    return filters;
+  }
+
+  async emit(compiler, compilation, serviceWorkers) {
+    let assetMapping = Object.keys(compilation.assets);
+    if (this.options.include) {
+      const filters = this.createFilter(this.options.include);
+      assetMapping = assetMapping.filter(filename => {
+        for (const filter of filters) {
+          if (filter(filename)) return true;
+        }
+        return false;
+      });
+    }
+    if (this.options.exclude) {
+      const filters = this.createFilter(this.options.exclude);
+      assetMapping = assetMapping.filter(filename => {
+        for (const filter of filters) {
+          if (filter(filename)) return false;
+        }
+        return true;
+      });
+    }
+    await Promise.all(serviceWorkers.map(
+      (serviceWorker, index) => this.compileServiceWorker(compiler, compilation, serviceWorker, index, assetMapping)
+    ));
+  }
+
+  async compileServiceWorker(compiler, compilation, options, index, assetMapping) {
+    const entryFilename = options.filename;
+
+    const chunkFilename = compiler.options.output.chunkFilename.replace(/\.([a-z]+)$/i, '.serviceworker.$1');
+    const workerOptions = {
+      filename: options.outputFilename, // chunkFilename.replace(/\.?\[(?:chunkhash|contenthash|hash)(:\d+(?::\d+)?)?\]/g, ''),
+      chunkFilename: this.options.chunkFilename || chunkFilename,
+      globalObject: 'self'
+    };
+
+    const childCompiler = compilation.createChildCompiler(NAME, { filename: workerOptions.filename });
+    (new WebWorkerTemplatePlugin(workerOptions)).apply(childCompiler);
+
+    /* The duplication DefinePlugin ends up causing is problematic (it doesn't hoist injections), so we'll do it manually. */
+    // (new DefinePlugin({
+    //   BUILD_ASSETS: JSON.stringify(assetMapping)
+    // })).apply(childCompiler);
+    (new SingleEntryPlugin(options.context, entryFilename, workerOptions.filename)).apply(childCompiler);
+
+    const subCache = `subcache ${__dirname} ${entryFilename} ${index}`;
+    let childCompilation;
+    childCompiler.hooks.compilation.tap(NAME, c => {
+      childCompilation = c;
+      if (childCompilation.cache) {
+        if (!childCompilation.cache[subCache]) childCompilation.cache[subCache] = {};
+        childCompilation.cache = childCompilation.cache[subCache];
+      }
+    });
+
+    await (util.promisify(childCompiler.runAsChild.bind(childCompiler)))();
+
+    const versionVar = this.options.version ?
+      `var VERSION = ${JSON.stringify(this.options.version)};` : '';
+    const original = childCompilation.assets[workerOptions.filename].source();
+    const source = `${versionVar}var BUILD_ASSETS=${JSON.stringify(assetMapping)};${original}`;
+    childCompilation.assets[workerOptions.filename] = {
+      source: () => source,
+      size: () => Buffer.byteLength(source, 'utf8')
+    };
+
+    Object.assign(compilation.assets, childCompilation.assets);
+  }
+};

global.d.ts

@@ -1,16 +1,21 @@
 declare const __webpack_public_path__: string;
+declare const PRERENDER: boolean;
 
 declare interface NodeModule {
   hot: any;
 }
 
 declare interface Window {
-  STATE: any
+  STATE: any;
+  ga: typeof ga;
 }
 
 declare namespace JSX {
   interface Element { }
   interface IntrinsicElements { }
+  interface HTMLAttributes {
+    decoding?: string;
+  }
 }
 
 declare module 'classnames' {

package.json

@@ -1,13 +1,14 @@
 {
   "private": true,
   "name": "squoosh",
-  "version": "0.0.0",
+  "version": "1.8.1",
   "license": "apache-2.0",
   "scripts": {
-    "start": "webpack serve --host 0.0.0.0 --hot",
+    "start": "webpack-dev-server --host 0.0.0.0 --hot",
     "build": "webpack -p",
-    "lint": "tslint -c tslint.json -t verbose 'src/**/*.{ts,tsx,js,jsx}'",
-    "lintfix": "tslint -c tslint.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,56 +16,61 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^9.6.23",
-    "@types/pretty-bytes": "^5.1.0",
-    "@types/webassembly-js-api": "0.0.1",
-    "@webcomponents/custom-elements": "^1.2.0",
-    "babel-loader": "^7.1.5",
-    "babel-plugin-jsx-pragmatic": "^1.0.2",
-    "babel-plugin-syntax-dynamic-import": "^6.18.0",
-    "babel-plugin-transform-class-properties": "^6.24.1",
-    "babel-plugin-transform-decorators-legacy": "^1.3.5",
-    "babel-plugin-transform-object-rest-spread": "^6.26.0",
-    "babel-plugin-transform-react-constant-elements": "^6.23.0",
-    "babel-plugin-transform-react-jsx": "^6.24.1",
-    "babel-plugin-transform-react-remove-prop-types": "^0.4.14",
-    "babel-preset-env": "^1.7.0",
-    "babel-register": "^6.26.0",
-    "clean-webpack-plugin": "^0.1.19",
-    "copy-webpack-plugin": "^4.5.2",
-    "css-loader": "^0.28.11",
-    "exports-loader": "^0.7.0",
-    "file-loader": "^1.1.11",
-    "html-webpack-plugin": "^3.2.0",
-    "husky": "^1.0.0-rc.13",
-    "if-env": "^1.0.4",
-    "loader-utils": "^1.1.0",
-    "mini-css-extract-plugin": "^0.3.0",
-    "node-sass": "^4.9.3",
-    "optimize-css-assets-webpack-plugin": "^4.0.3",
-    "progress-bar-webpack-plugin": "^1.11.0",
-    "raw-loader": "^0.5.1",
-    "sass-loader": "^7.1.0",
-    "script-ext-html-webpack-plugin": "^2.0.1",
-    "source-map-loader": "^0.2.3",
-    "style-loader": "^0.22.1",
-    "ts-loader": "^4.4.2",
-    "tslint": "^5.11.0",
-    "tslint-config-airbnb": "^5.9.2",
-    "tslint-config-semistandard": "^7.0.0",
-    "tslint-react": "^3.6.0",
-    "typescript": "^2.9.2",
-    "typings-for-css-modules-loader": "^1.7.0",
-    "webpack": "^4.19.1",
-    "webpack-bundle-analyzer": "^2.13.1",
-    "webpack-cli": "^2.1.5",
-    "webpack-dev-server": "^3.1.5",
-    "webpack-plugin-replace": "^1.1.1",
-    "classnames": "^2.2.6",
-    "comlink": "^3.0.3",
-    "linkstate": "^1.1.1",
-    "preact": "^8.3.1",
-    "pretty-bytes": "^5.1.0",
-    "worker-plugin": "^1.1.1"
+    "@types/node": "10.14.14",
+    "@types/pretty-bytes": "5.1.0",
+    "@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.2",
+    "classnames": "2.2.6",
+    "clean-webpack-plugin": "1.0.1",
+    "comlink": "3.1.1",
+    "copy-webpack-plugin": "5.0.4",
+    "critters-webpack-plugin": "2.4.0",
+    "css-loader": "1.0.1",
+    "ejs": "2.6.2",
+    "escape-string-regexp": "2.0.0",
+    "exports-loader": "0.7.0",
+    "file-drop-element": "0.2.0",
+    "file-loader": "4.1.0",
+    "gzip-size": "5.1.1",
+    "html-webpack-plugin": "3.2.0",
+    "husky": "3.0.2",
+    "idb-keyval": "3.2.0",
+    "linkstate": "1.1.1",
+    "loader-utils": "1.2.3",
+    "mini-css-extract-plugin": "0.8.0",
+    "minimatch": "3.0.4",
+    "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.3.0",
+    "pretty-bytes": "5.3.0",
+    "progress-bar-webpack-plugin": "1.12.1",
+    "raw-loader": "3.1.0",
+    "readdirp": "3.1.1",
+    "sass-loader": "7.1.0",
+    "script-ext-html-webpack-plugin": "2.1.4",
+    "source-map-loader": "0.2.4",
+    "style-loader": "0.23.1",
+    "terser-webpack-plugin": "1.4.1",
+    "travis-size-report": "1.1.0",
+    "ts-loader": "6.0.3",
+    "tslint": "5.18.0",
+    "tslint-config-airbnb": "5.11.1",
+    "tslint-config-semistandard": "8.0.1",
+    "tslint-react": "4.0.0",
+    "typed-css-modules": "0.4.2",
+    "typescript": "3.5.3",
+    "url-loader": "2.1.0",
+    "webpack": "4.28.0",
+    "webpack-bundle-analyzer": "3.4.1",
+    "webpack-cli": "3.3.4",
+    "webpack-dev-server": "3.7.2",
+    "worker-plugin": "3.1.0"
   }
 }

renovate.json

@@ -0,0 +1,5 @@
+{
+  "extends": [
+    "config:base"
+  ]
+}

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));
+  }
+};

src/codecs/decoders.ts

@@ -1,9 +1,8 @@
 import { nativeDecode, sniffMimeType, canDecodeImage } from '../lib/util';
 import Processor from './processor';
+import webpDataUrl from 'url-loader!./tiny.webp';
 
-// tslint:disable-next-line:max-line-length It’s a data URL. Whatcha gonna do?
-const webpFile = 'data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAAAAAAfQ//73v/+BiOh/AAA=';
-const nativeWebPSupported = canDecodeImage(webpFile);
+const nativeWebPSupported = canDecodeImage(webpDataUrl);
 
 export async function decodeImage(blob: Blob, processor: Processor): Promise<ImageData> {
   const mimeType = await sniffMimeType(blob);

src/codecs/hqx/processor-meta.ts

@@ -0,0 +1,3 @@
+export interface HqxOptions {
+  factor: 2 | 3 | 4;
+}

src/codecs/hqx/processor.ts

@@ -0,0 +1,20 @@
+import { resize } from '../../../codecs/hqx/pkg';
+import { HqxOptions } from './processor-meta';
+
+export async function hqx(
+  data: ImageData,
+  opts: HqxOptions,
+): Promise<ImageData> {
+  const input = data;
+  const result = 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,
+  );
+}

src/codecs/imagequant/options.tsx

@@ -1,6 +1,6 @@
 import { h, Component } from 'preact';
 import { bind } from '../../lib/initial-util';
-import { inputFieldValueAsNumber, konami } from '../../lib/util';
+import { inputFieldValueAsNumber, konami, preventDefault } from '../../lib/util';
 import { QuantizeOptions } from './processor-meta';
 import * as style from '../../components/Options/style.scss';
 import Expander from '../../components/expander';
@@ -42,7 +42,7 @@ export default class QuantizerOptions extends Component<Props, State> {
 
   render({ options }: Props, { extendedSettings }: State) {
     return (
-      <form class={style.optionsSection}>
+      <form class={style.optionsSection} onSubmit={preventDefault}>
         <Expander>
           {extendedSettings ?
             <label class={style.optionTextFirst}>

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;
 

src/codecs/input-processors.ts

@@ -0,0 +1,9 @@
+import { defaultOptions as rotateDefaultOptions } from './rotate/processor-meta';
+
+export interface InputProcessorState {
+  rotate: import('./rotate/processor-meta').RotateOptions;
+}
+
+export const defaultInputProcessorState: InputProcessorState = {
+  rotate: rotateDefaultOptions,
+};

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);

src/codecs/mozjpeg/options.tsx

@@ -1,6 +1,6 @@
 import { h, Component } from 'preact';
 import { bind } from '../../lib/initial-util';
-import { inputFieldChecked, inputFieldValueAsNumber } from '../../lib/util';
+import { inputFieldChecked, inputFieldValueAsNumber, preventDefault } from '../../lib/util';
 import { EncodeOptions, MozJpegColorSpace } from './encoder-meta';
 import * as style from '../../components/Options/style.scss';
 import Checkbox from '../../components/checkbox';
@@ -58,7 +58,7 @@ export default class MozJPEGEncoderOptions extends Component<Props, State> {
     // I'm rendering both lossy and lossless forms, as it becomes much easier when
     // gathering the data.
     return (
-      <form class={style.optionsSection}>
+      <form class={style.optionsSection} onSubmit={preventDefault}>
         <div class={style.optionOneCell}>
           <Range
             name="quality"

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);

src/codecs/optipng/options.tsx

@@ -1,6 +1,6 @@
 import { h, Component } from 'preact';
 import { bind } from '../../lib/initial-util';
-import { inputFieldValueAsNumber } from '../../lib/util';
+import { inputFieldValueAsNumber, preventDefault } from '../../lib/util';
 import { EncodeOptions } from './encoder-meta';
 import Range from '../../components/range';
 import * as style from '../../components/Options/style.scss';
@@ -23,7 +23,7 @@ export default class OptiPNGEncoderOptions extends Component<Props, {}> {
 
   render({ options }: Props) {
     return (
-      <form class={style.optionsSection}>
+      <form class={style.optionsSection} onSubmit={preventDefault}>
         <div class={style.optionOneCell}>
           <Range
             name="level"

src/codecs/processor-worker.ts

@@ -1,41 +0,0 @@
-import { expose } from 'comlink';
-import { EncodeOptions as MozJPEGEncoderOptions } from './mozjpeg/encoder-meta';
-import { QuantizeOptions } from './imagequant/processor-meta';
-import { EncodeOptions as OptiPNGEncoderOptions } from './optipng/encoder-meta';
-import { EncodeOptions as WebPEncoderOptions } from './webp/encoder-meta';
-
-async function mozjpegEncode(
-  data: ImageData, options: MozJPEGEncoderOptions,
-): Promise<ArrayBuffer> {
-  const { encode } = await import('./mozjpeg/encoder');
-  return encode(data, options);
-}
-
-async function quantize(data: ImageData, opts: QuantizeOptions): Promise<ImageData> {
-  const { process } = await import('./imagequant/processor');
-  return process(data, opts);
-}
-
-async function optiPngEncode(
-  data: BufferSource, options: OptiPNGEncoderOptions,
-): Promise<ArrayBuffer> {
-  const { compress } = await import('./optipng/encoder');
-  return compress(data, options);
-}
-
-async function webpEncode(
-  data: ImageData, options: WebPEncoderOptions,
-): Promise<ArrayBuffer> {
-  const { encode } = await import('./webp/encoder');
-  return encode(data, options);
-}
-
-async function webpDecode(data: ArrayBuffer): Promise<ImageData> {
-  const { decode } = await import('./webp/decoder');
-  return decode(data);
-}
-
-const exports = { mozjpegEncode, quantize, optiPngEncode, webpEncode, webpDecode };
-export type ProcessorWorkerApi = typeof exports;
-
-expose(exports, self);

src/codecs/processor-worker/index.ts

@@ -0,0 +1,91 @@
+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');
+  return encode(data, options);
+}
+
+async function quantize(
+  data: ImageData, opts: import('../imagequant/processor-meta').QuantizeOptions,
+): Promise<ImageData> {
+  const { process } = await import(
+    /* webpackChunkName: "process-imagequant" */
+    '../imagequant/processor');
+  return process(data, opts);
+}
+
+async function rotate(
+  data: ImageData, opts: import('../rotate/processor-meta').RotateOptions,
+): Promise<ImageData> {
+  const { rotate } = await import(
+    /* webpackChunkName: "process-rotate" */
+    '../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');
+  return compress(data, options);
+}
+
+async function webpEncode(
+  data: ImageData, options: import('../webp/encoder-meta').EncodeOptions,
+): Promise<ArrayBuffer> {
+  const { encode } = await import(
+    /* webpackChunkName: "process-webp-enc" */
+    '../webp/encoder');
+  return encode(data, options);
+}
+
+async function webpDecode(data: ArrayBuffer): Promise<ImageData> {
+  const { decode } = await import(
+    /* webpackChunkName: "process-webp-dec" */
+    '../webp/decoder');
+  return decode(data);
+}
+
+const exports = {
+  mozjpegEncode,
+  quantize,
+  rotate,
+  resize,
+  optiPngEncode,
+  webpEncode,
+  webpDecode,
+};
+export type ProcessorWorkerApi = typeof exports;
+
+expose(exports, self);

src/codecs/processor-worker/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "strict": true,
+    "target": "esnext",
+    "module": "esnext",
+    "lib": [
+      "webworker",
+      "esnext"
+    ],
+    "moduleResolution": "node",
+    "experimentalDecorators": true,
+    "noUnusedLocals": true,
+    "sourceMap": true,
+    "allowJs": false,
+    "baseUrl": "."
+  }
+}

src/codecs/processor.ts

@@ -1,14 +1,13 @@
 import { proxy } from 'comlink';
 import { QuantizeOptions } from './imagequant/processor-meta';
-import { ProcessorWorkerApi } from './processor-worker';
 import { canvasEncode, blobToArrayBuffer } from '../lib/util';
 import { EncodeOptions as MozJPEGEncoderOptions } from './mozjpeg/encoder-meta';
 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';
@@ -17,9 +16,12 @@ 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;
 
 /** How long the worker should be idle before terminating. */
-const workerTimeout = 1000;
+const workerTimeout = 10000;
 
 interface ProcessingJobOptions {
   needsWorker?: boolean;
@@ -61,7 +63,10 @@ export default class Processor {
           // worker-loader does magic here.
           // @ts-ignore - Typescript doesn't know about the 2nd param to new Worker, and the
           // definition can't be overwritten.
-          this._worker = new Worker('./processor-worker.ts', { type: 'module' }) as Worker;
+          this._worker = new Worker(
+            './processor-worker',
+            { name: 'processor-worker', type: 'module' },
+          ) as Worker;
           // Need to do some TypeScript trickery to make the type match.
           this._workerApi = proxy(this._worker) as any as ProcessorWorkerApi;
         }
@@ -90,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 */
@@ -107,19 +105,36 @@ 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;
   }
 
   // Off main thread jobs:
-
   @Processor._processingJob({ needsWorker: true })
   imageQuant(data: ImageData, opts: QuantizeOptions): Promise<ImageData> {
     return this._workerApi!.quantize(data, opts);
   }
 
+  @Processor._processingJob({ needsWorker: true })
+  rotate(
+    data: ImageData, opts: import('./rotate/processor-meta').RotateOptions,
+  ): Promise<ImageData> {
+    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,
@@ -192,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) {

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 } 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,15 +97,47 @@ 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}>
+      <form ref={linkRef(this, 'form')} class={style.optionsSection} onSubmit={preventDefault}>
         <label class={style.optionTextFirst}>
           Method:
           <Select
@@ -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"
@@ -135,7 +232,7 @@ export default class ResizerOptions extends Component<Props, State> {
                 onChange={this.onChange}
               >
                 <option value="stretch">Stretch</option>
-                <option value="cover">Cover</option>
+                <option value="contain">Contain</option>
               </Select>
             </label>
           }

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' | 'cover';
+  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,
 };

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,
+  });
+}

src/codecs/resize/processor.ts

@@ -1,49 +1,39 @@
-import { nativeResize, NativeResizeMethod, drawableToImageData } from '../../lib/util';
-import { BitmapResizeOptions, VectorResizeOptions } from './processor-meta';
+import { WorkerResizeOptions } from './processor-meta';
+import { getContainOffsets } from './util';
+import { resize as codecResize } from '../../../codecs/resize/pkg';
 
-function getCoverOffsets(sw: number, sh: number, dw: number, dh: number) {
-  const currentAspect = sw / sh;
-  const endAspect = dw / dh;
+function crop(data: ImageData, sx: number, sy: number, sw: number, sh: number): ImageData {
+  const inputPixels = new Uint32Array(data.data.buffer);
 
-  if (endAspect > currentAspect) {
-    const newSh = sw / endAspect;
-    const newSy = (sh - newSh) / 2;
-    return { sw, sh: newSh, sx: 0, sy: newSy };
+  // 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);
   }
 
-  const newSw = sh * endAspect;
-  const newSx = (sw - newSw) / 2;
-  return { sh, sw: newSw, sx: newSx, sy: 0 };
-}
-
-export function resize(data: ImageData, opts: BitmapResizeOptions): ImageData {
-  let sx = 0;
-  let sy = 0;
-  let sw = data.width;
-  let sh = data.height;
-
-  if (opts.fitMethod === 'cover') {
-    ({ sx, sy, sw, sh } = getCoverOffsets(sw, sh, opts.width, opts.height));
-  }
-
-  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',
+];
 
-  if (opts.fitMethod === 'cover') {
-    ({ sx, sy, sw, sh } = getCoverOffsets(sw, sh, opts.width, opts.height));
+export async function resize(data: ImageData, opts: WorkerResizeOptions): Promise<ImageData> {
+  let input = data;
+
+  if (opts.fitMethod === 'contain') {
+    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,
-  });
+  const result = codecResize(
+    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);
 }

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 };
+}

src/codecs/rotate/processor-meta.ts

@@ -0,0 +1,12 @@
+export interface RotateOptions {
+  rotate: 0 | 90 | 180 | 270;
+}
+
+export const defaultOptions: RotateOptions = { rotate: 0 };
+
+export interface RotateModuleInstance {
+  exports: {
+    memory: WebAssembly.Memory;
+    rotate(width: number, height: number, rotate: 0 | 90 | 180 | 270): void;
+  };
+}

src/codecs/rotate/processor.ts

@@ -0,0 +1,43 @@
+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 { 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 + 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, 8);
+
+  instance.exports.rotate(data.width, data.height, opts.rotate);
+
+  const flipDimensions = opts.rotate % 180 !== 0;
+  return new ImageData(
+    view.slice(bytesPerImage + 8, bytesPerImage * 2 + 8),
+    flipDimensions ? data.height : data.width,
+    flipDimensions ? data.width : data.height,
+  );
+}

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);
+}

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);

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);

src/codecs/webp/options.tsx

@@ -1,6 +1,6 @@
 import { h, Component } from 'preact';
 import { bind } from '../../lib/initial-util';
-import { inputFieldCheckedAsNumber, inputFieldValueAsNumber } from '../../lib/util';
+import { inputFieldCheckedAsNumber, inputFieldValueAsNumber, preventDefault } from '../../lib/util';
 import { EncodeOptions, WebPImageHint } from './encoder-meta';
 import * as style from '../../components/Options/style.scss';
 import Checkbox from '../../components/checkbox';
@@ -319,7 +319,7 @@ export default class WebPEncoderOptions extends Component<Props, State> {
     // I'm rendering both lossy and lossless forms, as it becomes much easier when
     // gathering the data.
     return (
-      <form class={style.optionsSection}>
+      <form class={style.optionsSection} onSubmit={preventDefault}>
         <label class={style.optionInputFirst}>
           <Checkbox
             name="lossless"

src/components/App/custom-els/FileDrop/index.ts

@@ -1,153 +0,0 @@
-import { bind } from '../../../../lib/initial-util';
-import './styles.css';
-
-// tslint:disable-next-line:max-line-length
-function firstMatchingItem(list: DataTransferItemList, acceptVal: string): DataTransferItem | undefined {
-  // Split accepts values by ',' then by '/'. Trim everything & lowercase.
-  const accepts = acceptVal.toLowerCase().split(',').map((accept) => {
-    return accept.trim().split('/').map(part => part.trim());
-  }).filter(acceptParts => acceptParts.length === 2); // Filter invalid values
-
-  return Array.from(list).find((item) => {
-    if (item.kind !== 'file') return false;
-
-    // 'Parse' the type.
-    const [typeMain, typeSub] = item.type.toLowerCase().split('/').map(s => s.trim());
-
-    for (const [acceptMain, acceptSub] of accepts) {
-      // Look for an exact match, or a partial match if * is accepted, eg image/*.
-      if (typeMain === acceptMain && (acceptSub === '*' || typeSub === acceptSub)) {
-        return true;
-      }
-    }
-    return false;
-  });
-}
-
-function getFileData(data: DataTransfer, accept: string): File | undefined {
-  const dragDataItem = firstMatchingItem(data.items, accept);
-  if (!dragDataItem) return;
-
-  return dragDataItem.getAsFile() || undefined;
-}
-
-interface FileDropEventInit extends EventInit {
-  action: FileDropAccept;
-  file: File;
-}
-
-type FileDropAccept = 'drop' | 'paste';
-
-// Safari and Edge don't quite support extending Event, this works around it.
-function fixExtendedEvent(instance: Event, type: Function) {
-  if (!(instance instanceof type)) {
-    Object.setPrototypeOf(instance, type.prototype);
-  }
-}
-
-export class FileDropEvent extends Event {
-  private _action: FileDropAccept;
-  private _file: File;
-  constructor(typeArg: string, eventInitDict: FileDropEventInit) {
-    super(typeArg, eventInitDict);
-    fixExtendedEvent(this, FileDropEvent);
-    this._file = eventInitDict.file;
-    this._action = eventInitDict.action;
-  }
-
-  get action() {
-    return this._action;
-  }
-
-  get file() {
-    return this._file;
-  }
-}
-
-/*
-  Example Usage.
-  <file-drop
-    accept='image/*'
-    class='drop-valid|drop-invalid'
-  >
-   [everything in here is a drop target.]
-  </file-drop>
-
-  dropElement.addEventListner('dropfile', (event) => console.log(event.detail))
-*/
-export class FileDrop extends HTMLElement {
-
-  private _dragEnterCount = 0;
-
-  constructor() {
-    super();
-    this.addEventListener('dragover', event => event.preventDefault());
-    this.addEventListener('drop', this._onDrop);
-    this.addEventListener('dragenter', this._onDragEnter);
-    this.addEventListener('dragend', () => this._reset());
-    this.addEventListener('dragleave', this._onDragLeave);
-    this.addEventListener('paste', this._onPaste);
-  }
-
-  get accept() {
-    return this.getAttribute('accept') || '';
-  }
-
-  set accept(val: string) {
-    this.setAttribute('accept', val);
-  }
-
-  @bind
-  private _onDragEnter(event: DragEvent) {
-    this._dragEnterCount += 1;
-    if (this._dragEnterCount > 1) return;
-
-    // We don't have data, attempt to get it and if it matches, set the correct state.
-    const validDrop: boolean = event.dataTransfer.items.length ?
-      !!firstMatchingItem(event.dataTransfer.items, this.accept) :
-      // Safari doesn't give file information on drag enter, so the best we can do is return valid.
-      true;
-
-    if (validDrop) {
-      this.classList.add('drop-valid');
-    } else {
-      this.classList.add('drop-invalid');
-    }
-  }
-
-  @bind
-  private _onDragLeave() {
-    this._dragEnterCount -= 1;
-    if (this._dragEnterCount === 0) {
-      this._reset();
-    }
-  }
-
-  @bind
-  private _onDrop(event: DragEvent) {
-    event.preventDefault();
-    this._reset();
-    const action = 'drop';
-    const file = getFileData(event.dataTransfer, this.accept);
-    if (file === undefined) return;
-
-    this.dispatchEvent(new FileDropEvent('filedrop', { action, file }));
-  }
-
-  @bind
-  private _onPaste(event: ClipboardEvent) {
-    const action = 'paste';
-    const file = getFileData(event.clipboardData, this.accept);
-    if (file === undefined) return;
-
-    this.dispatchEvent(new FileDropEvent('filedrop', { action, file }));
-  }
-
-  private _reset() {
-    this._dragEnterCount = 0;
-    this.classList.remove('drop-valid');
-    this.classList.remove('drop-invalid');
-  }
-}
-
-customElements.define('file-drop', FileDrop);

src/components/App/custom-els/FileDrop/missing-types.d.ts

@@ -1,19 +0,0 @@
-import { FileDropEvent, FileDrop } from '.';
-
-declare global {
-
-  interface HTMLElementEventMap {
-    'filedrop': FileDropEvent;
-  }
-
-  namespace JSX {
-    interface IntrinsicElements {
-      'file-drop': FileDropAttributes;
-    }
-
-    interface FileDropAttributes extends HTMLAttributes {
-      accept?: string;
-      onfiledrop?: ((this: FileDrop, ev: FileDropEvent) => any) | null;
-    }
-  }
-}

src/components/App/custom-els/FileDrop/styles.css

@@ -1,3 +0,0 @@
-file-drop {
-  display: block;
-}

src/components/App/index.tsx

@@ -2,31 +2,40 @@ import { h, Component } from 'preact';
 
 import { bind, linkRef, Fileish } from '../../lib/initial-util';
 import * as style from './style.scss';
-import { FileDropEvent } from './custom-els/FileDrop';
-import './custom-els/FileDrop';
+import { FileDropEvent } from 'file-drop-element';
+import 'file-drop-element';
 import SnackBarElement, { SnackOptions } from '../../lib/SnackBar';
 import '../../lib/SnackBar';
 import Intro from '../intro';
 import '../custom-els/LoadingSpinner';
 
-// This is imported for TypeScript only. It isn't used.
-import Compress from '../compress';
+const ROUTE_EDITOR = '/editor';
 
-export interface SourceImage {
-  file: File | Fileish;
-  data: ImageData;
-  vectorImage?: HTMLImageElement;
+const compressPromise = import(
+  /* webpackChunkName: "main-app" */
+  '../compress');
+
+const swBridgePromise = import(
+  /* webpackChunkName: "sw-bridge" */
+  '../../lib/sw-bridge');
+
+function back() {
+  window.history.back();
 }
 
 interface Props {}
 
 interface State {
+  awaitingShareTarget: boolean;
   file?: File | Fileish;
-  Compress?: typeof Compress;
+  isEditorOpen: Boolean;
+  Compress?: typeof import('../compress').default;
 }
 
 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,
   };
@@ -36,32 +45,54 @@ export default class App extends Component<Props, State> {
   constructor() {
     super();
 
-    import('../compress').then((module) => {
+    compressPromise.then((module) => {
       this.setState({ Compress: module.default });
     }).catch(() => {
       this.showSnack('Failed to load app');
     });
 
+    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') {
       this.setState(window.STATE);
       const oldCDU = this.componentDidUpdate;
-      this.componentDidUpdate = (props, state) => {
-        if (oldCDU) oldCDU.call(this, props, state);
+      this.componentDidUpdate = (props, state, prev) => {
+        if (oldCDU) oldCDU.call(this, props, state, prev);
         window.STATE = this.state;
       };
     }
+
+    // Since iOS 10, Apple tries to prevent disabling pinch-zoom. This is great in theory, but
+    // really breaks things on Squoosh, as you can easily end up zooming the UI when you mean to
+    // zoom the image. Once you've done this, it's really difficult to undo. Anyway, this seems to
+    // prevent it.
+    document.body.addEventListener('gesturestart', (event) => {
+      event.preventDefault();
+    });
+
+    window.addEventListener('popstate', this.onPopState);
   }
 
   @bind
-  private onFileDrop(event: FileDropEvent) {
-    const { file } = event;
-    if (!file) return;
+  private onFileDrop({ files }: FileDropEvent) {
+    if (!files || files.length === 0) return;
+    const file = files[0];
+    this.openEditor();
     this.setState({ file });
   }
 
   @bind
   private onIntroPickFile(file: File | Fileish) {
+    this.openEditor();
     this.setState({ file });
   }
 
@@ -71,15 +102,33 @@ export default class App extends Component<Props, State> {
     return this.snackbar.showSnackbar(message, options);
   }
 
-  render({}: Props, { file, Compress }: State) {
+  @bind
+  private onPopState() {
+    this.setState({ isEditorOpen: location.pathname === ROUTE_EDITOR });
+  }
+
+  @bind
+  private openEditor() {
+    if (this.state.isEditorOpen) return;
+    // 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, awaitingShareTarget }: State) {
+    const showSpinner = awaitingShareTarget || (isEditorOpen && !Compress);
+
     return (
       <div id="app" class={style.app}>
         <file-drop accept="image/*" onfiledrop={this.onFileDrop} class={style.drop}>
-          {(!file)
-            ? <Intro onFile={this.onIntroPickFile} showSnack={this.showSnack} />
-            : (Compress)
-              ? <Compress file={file} showSnack={this.showSnack} />
-              : <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>

src/components/Options/index.tsx

@@ -35,12 +35,14 @@ import {
 import { QuantizeOptions } from '../../codecs/imagequant/processor-meta';
 import { ResizeOptions } from '../../codecs/resize/processor-meta';
 import { PreprocessorState } from '../../codecs/preprocessors';
-import { SourceImage } from '../App';
+import { SourceImage } from '../compress';
 import Checkbox from '../checkbox';
 import Expander from '../expander';
 import Select from '../select';
 
-const encoderOptionsComponentMap = {
+const encoderOptionsComponentMap: {
+  [x: string]: (new (...args: any[]) => Component<any, any>) | undefined;
+} = {
   [identity.type]: undefined,
   [optiPNG.type]: OptiPNGEncoderOptions,
   [mozJPEG.type]: MozJpegEncoderOptions,
@@ -81,7 +83,7 @@ export default class Options extends Component<Props, State> {
   }
 
   @bind
-  onEncoderTypeChange(event: Event) {
+  private onEncoderTypeChange(event: Event) {
     const el = event.currentTarget as HTMLSelectElement;
 
     // The select element only has values matching encoder types,
@@ -91,7 +93,7 @@ export default class Options extends Component<Props, State> {
   }
 
   @bind
-  onPreprocessorEnabledChange(event: Event) {
+  private onPreprocessorEnabledChange(event: Event) {
     const el = event.currentTarget as HTMLInputElement;
     const preprocessor = el.name.split('.')[0] as keyof PreprocessorState;
 
@@ -101,14 +103,14 @@ export default class Options extends Component<Props, State> {
   }
 
   @bind
-  onQuantizerOptionsChange(opts: QuantizeOptions) {
+  private onQuantizerOptionsChange(opts: QuantizeOptions) {
     this.props.onPreprocessorOptionsChange(
       cleanMerge(this.props.preprocessorState, 'quantizer', opts),
     );
   }
 
   @bind
-  onResizeOptionsChange(opts: ResizeOptions) {
+  private onResizeOptionsChange(opts: ResizeOptions) {
     this.props.onPreprocessorOptionsChange(
       cleanMerge(this.props.preprocessorState, 'resize', opts),
     );
@@ -144,12 +146,14 @@ export default class Options extends Component<Props, State> {
                 {preprocessorState.resize.enabled ?
                   <ResizeOptionsComponent
                     isVector={Boolean(source && source.vectorImage)}
-                    aspect={source ? (source.data.width / source.data.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"
@@ -176,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>

src/components/Options/style.scss

@@ -43,6 +43,7 @@ $horizontalPadding: 15px;
 
 .text-field {
   background: #fff;
+  color: #000;
   font: inherit;
   border: none;
   padding: 2px 0 2px 10px;
@@ -54,4 +55,5 @@ $horizontalPadding: 15px;
 .options-scroller {
   overflow-x: hidden;
   overflow-y: auto;
+  -webkit-overflow-scrolling: touch;
 }