lol this was meant to be 10 seconds.

* Avoid wrapping a single button

* Making the zoom controls appear on the bottom, when the controls are positioned on the bottom

.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.

.travis.yml

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

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

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/mozjpeg_enc/README.md

@@ -39,5 +39,9 @@ struct MozJpegOptions {
   bool trellis_opt_zero;
   bool trellis_opt_table;
   int trellis_loops;
+  bool auto_subsample;
+  int chroma_subsample;
+  bool separate_chroma_quality;
+  int chroma_quality;
 };
 ```

codecs/mozjpeg_enc/example.html

@@ -21,7 +21,7 @@
     console.log('Version:', module.version().toString(16));
     const image = await loadImage('../example.png');
     const result = module.encode(image.data, image.width, image.height, {
-      quality: 40,
+      quality: 75,
       baseline: false,
       arithmetic: false,
       progressive: true,
@@ -29,10 +29,14 @@
       smoothing: 0,
       color_space: 3,
       quant_table: 3,
-      trellis_multipass: true,
-      trellis_opt_zero: true,
-      trellis_opt_table: true,
+      trellis_multipass: false,
+      trellis_opt_zero: false,
+      trellis_opt_table: false,
       trellis_loops: 1,
+      auto_subsample: true,
+      chroma_subsample: 2,
+      separate_chroma_quality: false,
+      chroma_quality: 75,
     });
 
     const blob = new Blob([result], {type: 'image/jpeg'});

codecs/mozjpeg_enc/mozjpeg_enc.cpp

@@ -29,6 +29,10 @@ struct MozJpegOptions {
   bool trellis_opt_zero;
   bool trellis_opt_table;
   int trellis_loops;
+  bool auto_subsample;
+  int chroma_subsample;
+  bool separate_chroma_quality;
+  int chroma_quality;
 };
 
 int version() {
@@ -119,9 +123,6 @@ val encode(std::string image_in, int image_width, int image_height, MozJpegOptio
    */
   jpeg_set_defaults(&cinfo);
 
-  /* Now you can set any non-default parameters you wish to.
-   * Here we just illustrate the use of quality (quantization table) scaling:
-   */
   jpeg_set_colorspace(&cinfo, (J_COLOR_SPACE) opts.color_space);
 
   if (opts.quant_table != -1) {
@@ -142,11 +143,23 @@ val encode(std::string image_in, int image_width, int image_height, MozJpegOptio
   jpeg_c_set_bool_param(&cinfo, JBOOLEAN_TRELLIS_Q_OPT, opts.trellis_opt_table);
   jpeg_c_set_int_param(&cinfo, JINT_TRELLIS_NUM_LOOPS, opts.trellis_loops);
 
+  // A little hacky to build a string for this, but it means we can use set_quality_ratings which
+  // does some useful heuristic stuff.
   std::string quality_str = std::to_string(opts.quality);
+
+  if (opts.separate_chroma_quality && opts.color_space == JCS_YCbCr) {
+    quality_str += "," + std::to_string(opts.chroma_quality);
+  }
+
   char const *pqual = quality_str.c_str();
 
   set_quality_ratings(&cinfo, (char*) pqual, opts.baseline);
 
+  if (!opts.auto_subsample && opts.color_space == JCS_YCbCr) {
+    cinfo.comp_info[0].h_samp_factor = opts.chroma_subsample;
+    cinfo.comp_info[0].v_samp_factor = opts.chroma_subsample;
+  }
+
   if (!opts.baseline && opts.progressive) {
     jpeg_simple_progression(&cinfo);
   } else {
@@ -209,6 +222,10 @@ EMSCRIPTEN_BINDINGS(my_module) {
     .field("trellis_opt_zero", &MozJpegOptions::trellis_opt_zero)
     .field("trellis_opt_table", &MozJpegOptions::trellis_opt_table)
     .field("trellis_loops", &MozJpegOptions::trellis_loops)
+    .field("chroma_subsample", &MozJpegOptions::chroma_subsample)
+    .field("auto_subsample", &MozJpegOptions::auto_subsample)
+    .field("separate_chroma_quality", &MozJpegOptions::separate_chroma_quality)
+    .field("chroma_quality", &MozJpegOptions::chroma_quality)
     ;
 
   function("version", &version);

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,13 @@
 {
   "private": true,
   "name": "squoosh",
-  "version": "0.0.0",
+  "version": "1.2.2",
   "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 'src/**/*.{ts,tsx,js,jsx}'",
+    "lintfix": "tslint -c tslint.json -p tsconfig.json -t verbose --fix 'src/**/*.{ts,tsx,js,jsx}'"
   },
   "husky": {
     "hooks": {
@@ -15,56 +15,55 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^9.6.23",
+    "@types/node": "^10.12.6",
     "@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",
+    "@webcomponents/custom-elements": "^1.2.1",
+    "@webpack-cli/serve": "^0.1.2",
+    "assets-webpack-plugin": "^3.9.7",
+    "chokidar": "^2.0.4",
+    "classnames": "^2.2.6",
+    "clean-webpack-plugin": "^1.0.0",
+    "comlink": "^3.0.3",
+    "copy-webpack-plugin": "^4.6.0",
+    "critters-webpack-plugin": "^2.0.1",
+    "css-loader": "^1.0.1",
+    "ejs": "^2.6.1",
     "exports-loader": "^0.7.0",
-    "file-loader": "^1.1.11",
+    "file-drop-element": "^0.0.9",
+    "file-loader": "^2.0.0",
     "html-webpack-plugin": "^3.2.0",
-    "husky": "^1.0.0-rc.13",
-    "if-env": "^1.0.4",
+    "husky": "^1.1.4",
+    "idb-keyval": "^3.1.0",
+    "linkstate": "^1.1.1",
     "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",
+    "mini-css-extract-plugin": "^0.4.4",
+    "minimatch": "^3.0.4",
+    "node-sass": "^4.11.0",
+    "optimize-css-assets-webpack-plugin": "^5.0.1",
+    "pointer-tracker": "^2.0.3",
+    "preact": "^8.3.1",
+    "prerender-loader": "^1.2.0",
+    "pretty-bytes": "^5.1.0",
     "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",
+    "script-ext-html-webpack-plugin": "^2.1.3",
+    "source-map-loader": "^0.2.4",
+    "style-loader": "^0.23.1",
+    "terser-webpack-plugin": "^1.1.0",
+    "ts-loader": "^5.3.0",
     "tslint": "^5.11.0",
-    "tslint-config-airbnb": "^5.9.2",
+    "tslint-config-airbnb": "^5.11.0",
     "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",
+    "typed-css-modules": "^0.3.7",
+    "typescript": "^3.1.6",
+    "url-loader": "^1.1.2",
+    "webpack": "^4.25.1",
+    "webpack-bundle-analyzer": "^3.0.3",
+    "webpack-cli": "^3.1.2",
+    "webpack-dev-server": "^3.1.10",
     "worker-plugin": "^1.1.1"
   }
 }

src/codecs/browser-jpeg/encoder-meta.ts

@@ -5,4 +5,4 @@ export const type = 'browser-jpeg';
 export const label = 'Browser JPEG';
 export const mimeType = 'image/jpeg';
 export const extension = 'jpg';
-export const defaultOptions: EncodeOptions = { quality: 0.5 };
+export const defaultOptions: EncodeOptions = { quality: 0.75 };

src/codecs/browser-jpeg/options.ts

@@ -1,3 +1,3 @@
 import qualityOption from '../generic/quality-option';
 
-export default qualityOption({ min: 0, max: 1, step: 0 });
+export default qualityOption({ min: 0, max: 1, step: 0.01 });

src/codecs/browser-webp/encoder-meta.ts

@@ -7,5 +7,5 @@ export const type = 'browser-webp';
 export const label = 'Browser WebP';
 export const mimeType = 'image/webp';
 export const extension = 'webp';
-export const defaultOptions: EncodeOptions = { quality: 0.5 };
+export const defaultOptions: EncodeOptions = { quality: 0.75 };
 export const featureTest = () => canvasEncodeTest(mimeType);

src/codecs/browser-webp/options.ts

@@ -1,3 +1,3 @@
 import qualityOption from '../generic/quality-option';
 
-export default qualityOption({ min: 0, max: 1, step: 0 });
+export default qualityOption({ min: 0, max: 1, step: 0.01 });

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/generic/quality-option.tsx

@@ -1,6 +1,7 @@
 import { h, Component } from 'preact';
 import { bind } from '../../lib/initial-util';
-import '../../custom-els/RangeInput';
+import * as style from '../../components/Options/style.scss';
+import Range from '../../components/range';
 
 interface EncodeOptions {
   quality: number;
@@ -33,18 +34,19 @@ export default function qualityOption(opts: QualityOptionArg = {}) {
 
     render({ options }: Props) {
       return (
-        <div>
-          <label>
-            Quality:
-            <range-input
+        <div class={style.optionsSection}>
+          <div class={style.optionOneCell}>
+            <Range
               name="quality"
               min={min}
               max={max}
               step={step || 'any'}
-              value={'' + options.quality}
-              onChange={this.onChange}
-            />
-          </label>
+              value={options.quality}
+              onInput={this.onChange}
+            >
+              Quality:
+            </Range>
+          </div>
         </div>
       );
     }

src/codecs/imagequant/options.tsx

@@ -1,7 +1,11 @@
 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';
+import Select from '../../components/select';
+import Range from '../../components/range';
 
 const konamiPromise = konami();
 
@@ -26,50 +30,61 @@ export default class QuantizerOptions extends Component<Props, State> {
   @bind
   onChange(event: Event) {
     const form = (event.currentTarget as HTMLInputElement).closest('form') as HTMLFormElement;
+    const { options } = this.props;
 
-    const options: QuantizeOptions = {
-      zx: inputFieldValueAsNumber(form.zx),
-      maxNumColors: inputFieldValueAsNumber(form.maxNumColors),
+    const newOptions: QuantizeOptions = {
+      zx: inputFieldValueAsNumber(form.zx, options.zx),
+      maxNumColors: inputFieldValueAsNumber(form.maxNumColors, options.maxNumColors),
       dither: inputFieldValueAsNumber(form.dither),
     };
-    this.props.onChange(options);
+    this.props.onChange(newOptions);
   }
 
   render({ options }: Props, { extendedSettings }: State) {
     return (
-      <form>
-        <label style={{ display: extendedSettings ? '' : 'none' }}>
-          Type:
-          <select
-            name="zx"
-            value={'' + options.zx}
-            onChange={this.onChange}
-          >
-            <option value="0">Standard</option>
-            <option value="1">ZX</option>
-          </select>
-        </label>
-        <label style={{ display: options.zx ? 'none' : '' }}>
-          Palette Colors:
-          <range-input
-            name="maxNumColors"
-            min="2"
-            max="256"
-            value={'' + options.maxNumColors}
-            onChange={this.onChange}
-          />
-        </label>
-        <label>
-          Dithering:
-          <range-input
+      <form class={style.optionsSection} onSubmit={preventDefault}>
+        <Expander>
+          {extendedSettings ?
+            <label class={style.optionTextFirst}>
+              Type:
+              <Select
+                name="zx"
+                value={'' + options.zx}
+                onChange={this.onChange}
+              >
+                <option value="0">Standard</option>
+                <option value="1">ZX</option>
+              </Select>
+            </label>
+          : null}
+        </Expander>
+        <Expander>
+          {options.zx ? null :
+            <div class={style.optionOneCell}>
+              <Range
+                name="maxNumColors"
+                min="2"
+                max="256"
+                value={options.maxNumColors}
+                onInput={this.onChange}
+              >
+                Colors:
+              </Range>
+            </div>
+          }
+        </Expander>
+        <div class={style.optionOneCell}>
+          <Range
             name="dither"
             min="0"
             max="1"
             step="0.01"
-            value={'' + options.dither}
-            onChange={this.onChange}
-          />
-        </label>
+            value={options.dither}
+            onInput={this.onChange}
+          >
+            Dithering:
+          </Range>
+        </div>
       </form>
     );
   }

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-meta.ts

@@ -17,6 +17,10 @@ export interface EncodeOptions {
   trellis_opt_zero: boolean;
   trellis_opt_table: boolean;
   trellis_loops: number;
+  auto_subsample: boolean;
+  chroma_subsample: number;
+  separate_chroma_quality: boolean;
+  chroma_quality: number;
 }
 
 export interface EncoderState { type: typeof type; options: EncodeOptions; }
@@ -38,4 +42,8 @@ export const defaultOptions: EncodeOptions = {
   trellis_opt_zero: false,
   trellis_opt_table: false,
   trellis_loops: 1,
+  auto_subsample: true,
+  chroma_subsample: 2,
+  separate_chroma_quality: false,
+  chroma_quality: 75,
 };

src/codecs/mozjpeg/options.tsx

@@ -1,159 +1,257 @@
 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 '../../custom-els/RangeInput';
+import * as style from '../../components/Options/style.scss';
+import Checkbox from '../../components/checkbox';
+import Expander from '../../components/expander';
+import Select from '../../components/select';
+import Range from '../../components/range';
+import linkState from 'linkstate';
 
-type Props = {
-  options: EncodeOptions,
-  onChange(newOptions: EncodeOptions): void,
-};
+interface Props {
+  options: EncodeOptions;
+  onChange(newOptions: EncodeOptions): void;
+}
+
+interface State {
+  showAdvanced: boolean;
+}
+
+export default class MozJPEGEncoderOptions extends Component<Props, State> {
+  state: State = {
+    showAdvanced: false,
+  };
 
-export default class MozJPEGEncoderOptions extends Component<Props, {}> {
   @bind
   onChange(event: Event) {
     const form = (event.currentTarget as HTMLInputElement).closest('form') as HTMLFormElement;
+    const { options } = this.props;
 
-    const options: EncodeOptions = {
+    const newOptions: EncodeOptions = {
       // Copy over options the form doesn't currently care about, eg arithmetic
       ...this.props.options,
       // And now stuff from the form:
       // .checked
-      baseline: inputFieldChecked(form.baseline),
-      progressive: inputFieldChecked(form.progressive),
-      optimize_coding: inputFieldChecked(form.optimize_coding),
-      trellis_multipass: inputFieldChecked(form.trellis_multipass),
-      trellis_opt_zero: inputFieldChecked(form.trellis_opt_zero),
-      trellis_opt_table: inputFieldChecked(form.trellis_opt_table),
+      baseline: inputFieldChecked(form.baseline, options.baseline),
+      progressive: inputFieldChecked(form.progressive, options.progressive),
+      optimize_coding: inputFieldChecked(form.optimize_coding, options.optimize_coding),
+      trellis_multipass: inputFieldChecked(form.trellis_multipass, options.trellis_multipass),
+      trellis_opt_zero: inputFieldChecked(form.trellis_opt_zero, options.trellis_opt_zero),
+      trellis_opt_table: inputFieldChecked(form.trellis_opt_table, options.trellis_opt_table),
+      auto_subsample: inputFieldChecked(form.auto_subsample, options.auto_subsample),
+      separate_chroma_quality:
+        inputFieldChecked(form.separate_chroma_quality, options.separate_chroma_quality),
       // .value
-      quality: inputFieldValueAsNumber(form.quality),
-      smoothing: inputFieldValueAsNumber(form.smoothing),
-      color_space: inputFieldValueAsNumber(form.color_space),
-      quant_table: inputFieldValueAsNumber(form.quant_table),
-      trellis_loops: inputFieldValueAsNumber(form.trellis_loops),
+      quality: inputFieldValueAsNumber(form.quality, options.quality),
+      chroma_quality: inputFieldValueAsNumber(form.chroma_quality, options.chroma_quality),
+      chroma_subsample: inputFieldValueAsNumber(form.chroma_subsample, options.chroma_subsample),
+      smoothing: inputFieldValueAsNumber(form.smoothing, options.smoothing),
+      color_space: inputFieldValueAsNumber(form.color_space, options.color_space),
+      quant_table: inputFieldValueAsNumber(form.quant_table, options.quant_table),
+      trellis_loops: inputFieldValueAsNumber(form.trellis_loops, options.trellis_loops),
     };
-    this.props.onChange(options);
+    this.props.onChange(newOptions);
   }
 
-  render({ options }: Props) {
+  render({ options }: Props, { showAdvanced }: State) {
     // I'm rendering both lossy and lossless forms, as it becomes much easier when
     // gathering the data.
     return (
-      <form>
-        <label>
-          Quality:
-          <range-input
+      <form class={style.optionsSection} onSubmit={preventDefault}>
+        <div class={style.optionOneCell}>
+          <Range
             name="quality"
             min="0"
             max="100"
-            value={'' + options.quality}
-            onChange={this.onChange}
-          />
-        </label>
-        <label>
-          <input
-            name="baseline"
-            type="checkbox"
-            checked={options.baseline}
-            onChange={this.onChange}
-          />
-          <span>Baseline (worse but legacy-compatible)</span>
-        </label>
-        <label style={{ display: options.baseline ? 'none' : '' }}>
-          <input
-            name="progressive"
-            type="checkbox"
-            checked={options.progressive}
-            onChange={this.onChange}
-          />
-          <span>Progressive multi-pass rendering</span>
-        </label>
-        <label style={{ display: options.baseline ? '' : 'none' }}>
-          <input
-            name="optimize_coding"
-            type="checkbox"
-            checked={options.optimize_coding}
-            onChange={this.onChange}
-          />
-          <span>Optimize Huffman table</span>
-        </label>
-        <label>
-          Smoothing:
-          <range-input
-            name="smoothing"
-            min="0"
-            max="100"
-            value={'' + options.smoothing}
-            onChange={this.onChange}
-          />
-        </label>
-        <label>
-          Output color space:
-          <select
-            name="color_space"
-            value={'' + options.color_space}
-            onChange={this.onChange}
+            value={options.quality}
+            onInput={this.onChange}
           >
-            <option value={MozJpegColorSpace.GRAYSCALE}>Grayscale</option>
-            <option value={MozJpegColorSpace.RGB}>RGB (sub-optimal)</option>
-            <option value={MozJpegColorSpace.YCbCr}>YCbCr (optimized for color)</option>
-          </select>
-        </label>
-        <label>
-          Quantization table:
-          <select
-            name="quant_table"
-            value={'' + options.quant_table}
-            onChange={this.onChange}
-          >
-            <option value="0">JPEG Annex K</option>
-            <option value="1">Flat</option>
-            <option value="2">MSSIM-tuned Kodak</option>
-            <option value="3">ImageMagick</option>
-            <option value="4">PSNR-HVS-M-tuned Kodak</option>
-            <option value="5">Klein et al</option>
-            <option value="6">Watson et al</option>
-            <option value="7">Ahumada et al</option>
-            <option value="8">Peterson et al</option>
-          </select>
-        </label>
-        <label>
-          <input
-            name="trellis_multipass"
-            type="checkbox"
-            checked={options.trellis_multipass}
-            onChange={this.onChange}
-          />
-          <span>Consider multiple scans during trellis quantization</span>
-        </label>
-        <label style={{ display: options.trellis_multipass ? '' : 'none' }}>
-          <input
-            name="trellis_opt_zero"
-            type="checkbox"
-            checked={options.trellis_opt_zero}
-            onChange={this.onChange}
-          />
-          <span>Optimize runs of zero blocks</span>
-        </label>
-        <label>
-          <input
-            name="trellis_opt_table"
-            type="checkbox"
-            checked={options.trellis_opt_table}
-            onChange={this.onChange}
-          />
-          <span>Optimize after trellis quantization</span>
-        </label>
-        <label>
-          Trellis quantization passes:
-          <range-input
-            name="trellis_loops"
-            min="1"
-            max="50"
-            value={'' + options.trellis_loops}
-            onChange={this.onChange}
+            Quality:
+          </Range>
+        </div>
+        <label class={style.optionInputFirst}>
+          <Checkbox
+            checked={showAdvanced}
+            onChange={linkState(this, 'showAdvanced')}
           />
+          Show advanced settings
         </label>
+        <Expander>
+          {showAdvanced ?
+            <div>
+              <label class={style.optionTextFirst}>
+                Channels:
+                <Select
+                  name="color_space"
+                  value={options.color_space}
+                  onChange={this.onChange}
+                >
+                  <option value={MozJpegColorSpace.GRAYSCALE}>Grayscale</option>
+                  <option value={MozJpegColorSpace.RGB}>RGB</option>
+                  <option value={MozJpegColorSpace.YCbCr}>YCbCr</option>
+                </Select>
+              </label>
+              <Expander>
+                {options.color_space === MozJpegColorSpace.YCbCr ?
+                  <div>
+                    <label class={style.optionInputFirst}>
+                      <Checkbox
+                        name="auto_subsample"
+                        checked={options.auto_subsample}
+                        onChange={this.onChange}
+                      />
+                      Auto subsample chroma
+                    </label>
+                    <Expander>
+                      {options.auto_subsample ? null :
+                        <div class={style.optionOneCell}>
+                          <Range
+                            name="chroma_subsample"
+                            min="1"
+                            max="4"
+                            value={options.chroma_subsample}
+                            onInput={this.onChange}
+                          >
+                            Subsample chroma by:
+                          </Range>
+                        </div>
+                      }
+                    </Expander>
+                    <label class={style.optionInputFirst}>
+                      <Checkbox
+                        name="separate_chroma_quality"
+                        checked={options.separate_chroma_quality}
+                        onChange={this.onChange}
+                      />
+                      Separate chroma quality
+                    </label>
+                    <Expander>
+                      {options.separate_chroma_quality ?
+                        <div class={style.optionOneCell}>
+                          <Range
+                            name="chroma_quality"
+                            min="0"
+                            max="100"
+                            value={options.chroma_quality}
+                            onInput={this.onChange}
+                          >
+                            Chroma quality:
+                          </Range>
+                        </div>
+                        : null
+                      }
+                    </Expander>
+                  </div>
+                  : null
+                }
+              </Expander>
+              <label class={style.optionInputFirst}>
+                <Checkbox
+                  name="baseline"
+                  checked={options.baseline}
+                  onChange={this.onChange}
+                />
+                Pointless spec compliance
+              </label>
+              <Expander>
+                {options.baseline ? null :
+                  <label class={style.optionInputFirst}>
+                    <Checkbox
+                      name="progressive"
+                      checked={options.progressive}
+                      onChange={this.onChange}
+                    />
+                    Progressive rendering
+                  </label>
+                }
+              </Expander>
+              <Expander>
+                {options.baseline ?
+                  <label class={style.optionInputFirst}>
+                    <Checkbox
+                      name="optimize_coding"
+                      checked={options.optimize_coding}
+                      onChange={this.onChange}
+                    />
+                    Optimize Huffman table
+                  </label>
+                  : null
+                }
+              </Expander>
+              <div class={style.optionOneCell}>
+                <Range
+                  name="smoothing"
+                  min="0"
+                  max="100"
+                  value={options.smoothing}
+                  onInput={this.onChange}
+                >
+                  Smoothing:
+                </Range>
+              </div>
+              <label class={style.optionTextFirst}>
+                Quantization:
+                <Select
+                  name="quant_table"
+                  value={options.quant_table}
+                  onChange={this.onChange}
+                >
+                  <option value="0">JPEG Annex K</option>
+                  <option value="1">Flat</option>
+                  <option value="2">MSSIM-tuned Kodak</option>
+                  <option value="3">ImageMagick</option>
+                  <option value="4">PSNR-HVS-M-tuned Kodak</option>
+                  <option value="5">Klein et al</option>
+                  <option value="6">Watson et al</option>
+                  <option value="7">Ahumada et al</option>
+                  <option value="8">Peterson et al</option>
+                </Select>
+              </label>
+              <label class={style.optionInputFirst}>
+                <Checkbox
+                  name="trellis_multipass"
+                  checked={options.trellis_multipass}
+                  onChange={this.onChange}
+                />
+                Trellis multipass
+              </label>
+              <Expander>
+                {options.trellis_multipass ?
+                  <label class={style.optionInputFirst}>
+                    <Checkbox
+                      name="trellis_opt_zero"
+                      checked={options.trellis_opt_zero}
+                      onChange={this.onChange}
+                    />
+                    Optimize zero block runs
+                  </label>
+                  : null
+                }
+              </Expander>
+              <label class={style.optionInputFirst}>
+                <Checkbox
+                  name="trellis_opt_table"
+                  checked={options.trellis_opt_table}
+                  onChange={this.onChange}
+                />
+                Optimize after trellis quantization
+              </label>
+              <div class={style.optionOneCell}>
+                <Range
+                  name="trellis_loops"
+                  min="1"
+                  max="50"
+                  value={options.trellis_loops}
+                  onInput={this.onChange}
+                >
+                  Trellis quantization passes:
+                </Range>
+              </div>
+            </div>
+            : null
+          }
+        </Expander>
       </form>
     );
   }

src/codecs/optipng/options.tsx

@@ -1,7 +1,9 @@
 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';
 
 type Props = {
   options: EncodeOptions;
@@ -21,19 +23,19 @@ export default class OptiPNGEncoderOptions extends Component<Props, {}> {
 
   render({ options }: Props) {
     return (
-      <form>
-        <label>
-          Effort:
-          <input
+      <form class={style.optionsSection} onSubmit={preventDefault}>
+        <div class={style.optionOneCell}>
+          <Range
             name="level"
-            type="range"
             min="0"
             max="7"
             step="1"
-            value={'' + options.level}
-            onChange={this.onChange}
-          />
-        </label>
+            value={options.level}
+            onInput={this.onChange}
+          >
+            Effort:
+          </Range>
+        </div>
       </form>
     );
   }

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,65 @@
+import { expose } from 'comlink';
+
+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 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, 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,6 +1,5 @@
 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';
@@ -18,8 +17,10 @@ import * as browserTIFF from './browser-tiff/encoder';
 import * as browserJP2 from './browser-jp2/encoder';
 import * as browserPDF from './browser-pdf/encoder';
 
+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 +62,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;
         }
@@ -92,7 +96,6 @@ export default class Processor {
     // If the worker is unused for 10 seconds, remove it to save memory.
     this._workerTimeoutId = self.setTimeout(
       () => {
-        if (this._busy) throw Error("Worker shouldn't be busy");
         if (!this._worker) return;
         this._worker.terminate();
         this._worker = undefined;
@@ -104,23 +107,29 @@ export default class Processor {
   /** Abort the current job, if any */
   abortCurrent() {
     if (!this._busy) return;
-    if (!this._worker || !this._abortRejector) {
-      throw Error("There must be a worker/rejector if it's busy");
-    }
+    if (!this._abortRejector) throw Error("There must be a rejector if it's busy");
     this._abortRejector(new DOMException('Aborted', 'AbortError'));
-    this._worker.terminate();
-    this._worker = undefined;
     this._abortRejector = undefined;
     this._busy = false;
+
+    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 })
   mozjpegEncode(
     data: ImageData, opts: MozJPEGEncoderOptions,

src/codecs/resize/options.tsx

@@ -1,8 +1,12 @@
 import { h, Component } from 'preact';
 import linkState from 'linkstate';
-import { bind } from '../../lib/initial-util';
-import { inputFieldValueAsNumber } from '../../lib/util';
+import { bind, linkRef } from '../../lib/initial-util';
+import { inputFieldValueAsNumber, inputFieldValue, preventDefault } from '../../lib/util';
 import { ResizeOptions } from './processor-meta';
+import * as style from '../../components/Options/style.scss';
+import Checkbox from '../../components/checkbox';
+import Expander from '../../components/expander';
+import Select from '../../components/select';
 
 interface Props {
   isVector: Boolean;
@@ -22,23 +26,26 @@ export default class ResizerOptions extends Component<Props, State> {
 
   form?: HTMLFormElement;
 
-  reportOptions() {
-    const width = this.form!.width as HTMLInputElement;
-    const height = this.form!.height as HTMLInputElement;
+  private reportOptions() {
+    const form = this.form!;
+    const width = form.width as HTMLInputElement;
+    const height = form.height as HTMLInputElement;
+    const { options } = this.props;
 
     if (!width.checkValidity() || !height.checkValidity()) return;
 
-    const options: ResizeOptions = {
+    const newOptions: ResizeOptions = {
       width: inputFieldValueAsNumber(width),
       height: inputFieldValueAsNumber(height),
-      method: this.form!.resizeMethod.value,
-      fitMethod: this.form!.fitMethod.value,
+      method: form.resizeMethod.value,
+      // Casting, as the formfield only returns the correct values.
+      fitMethod: inputFieldValue(form.fitMethod, options.fitMethod) as ResizeOptions['fitMethod'],
     };
-    this.props.onChange(options);
+    this.props.onChange(newOptions);
   }
 
   @bind
-  onChange(event: Event) {
+  private onChange() {
     this.reportOptions();
   }
 
@@ -50,27 +57,31 @@ export default class ResizerOptions extends Component<Props, State> {
   }
 
   @bind
-  onWidthInput(event: Event) {
-    if (!this.state.maintainAspect) return;
+  private onWidthInput() {
+    if (this.state.maintainAspect) {
+      const width = inputFieldValueAsNumber(this.form!.width);
+      this.form!.height.value = Math.round(width / this.props.aspect);
+    }
 
-    const width = inputFieldValueAsNumber(this.form!.width);
-    this.form!.height.value = Math.round(width / this.props.aspect);
+    this.reportOptions();
   }
 
   @bind
-  onHeightInput(event: Event) {
-    if (!this.state.maintainAspect) return;
+  private onHeightInput() {
+    if (this.state.maintainAspect) {
+      const height = inputFieldValueAsNumber(this.form!.height);
+      this.form!.width.value = Math.round(height * this.props.aspect);
+    }
 
-    const height = inputFieldValueAsNumber(this.form!.height);
-    this.form!.width.value = Math.round(height * this.props.aspect);
+    this.reportOptions();
   }
 
-  render({ options, aspect, isVector }: Props, { maintainAspect }: State) {
+  render({ options, isVector }: Props, { maintainAspect }: State) {
     return (
-      <form ref={el => this.form = el}>
-        <label>
+      <form ref={linkRef(this, 'form')} class={style.optionsSection} onSubmit={preventDefault}>
+        <label class={style.optionTextFirst}>
           Method:
-          <select
+          <Select
             name="resizeMethod"
             value={options.method}
             onChange={this.onChange}
@@ -80,51 +91,55 @@ export default class ResizerOptions extends Component<Props, State> {
             <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>
+          </Select>
         </label>
-        <label>
+        <label class={style.optionTextFirst}>
           Width:
           <input
             required
+            class={style.textField}
             name="width"
             type="number"
             min="1"
             value={'' + options.width}
-            onChange={this.onChange}
             onInput={this.onWidthInput}
           />
         </label>
-        <label>
+        <label class={style.optionTextFirst}>
           Height:
           <input
             required
+            class={style.textField}
             name="height"
             type="number"
             min="1"
             value={'' + options.height}
-            onChange={this.onChange}
+            onInput={this.onHeightInput}
           />
         </label>
-        <label>
-          <input
+        <label class={style.optionInputFirst}>
+          <Checkbox
             name="maintainAspect"
-            type="checkbox"
             checked={maintainAspect}
             onChange={linkState(this, 'maintainAspect')}
           />
           Maintain aspect ratio
         </label>
-        <label style={{ display: maintainAspect ? 'none' : '' }}>
-          Fit method:
-          <select
-            name="fitMethod"
-            value={options.fitMethod}
-            onChange={this.onChange}
-          >
-            <option value="stretch">Stretch</option>
-            <option value="cover">Cover</option>
-          </select>
-        </label>
+        <Expander>
+          {maintainAspect ? null :
+            <label class={style.optionTextFirst}>
+              Fit method:
+              <Select
+                name="fitMethod"
+                value={options.fitMethod}
+                onChange={this.onChange}
+              >
+                <option value="stretch">Stretch</option>
+                <option value="contain">Contain</option>
+              </Select>
+            </label>
+          }
+        </Expander>
       </form>
     );
   }

src/codecs/resize/processor-meta.ts

@@ -4,7 +4,7 @@ export interface ResizeOptions {
   width: number;
   height: number;
   method: 'vector' | BitmapResizeMethods;
-  fitMethod: 'stretch' | 'cover';
+  fitMethod: 'stretch' | 'contain';
 }
 
 export interface BitmapResizeOptions extends ResizeOptions {

src/codecs/resize/processor.ts

@@ -1,7 +1,7 @@
 import { nativeResize, NativeResizeMethod, drawableToImageData } from '../../lib/util';
 import { BitmapResizeOptions, VectorResizeOptions } from './processor-meta';
 
-function getCoverOffsets(sw: number, sh: number, dw: number, dh: number) {
+function getContainOffsets(sw: number, sh: number, dw: number, dh: number) {
   const currentAspect = sw / sh;
   const endAspect = dw / dh;
 
@@ -22,8 +22,8 @@ export function resize(data: ImageData, opts: BitmapResizeOptions): ImageData {
   let sw = data.width;
   let sh = data.height;
 
-  if (opts.fitMethod === 'cover') {
-    ({ sx, sy, sw, sh } = getCoverOffsets(sw, sh, opts.width, opts.height));
+  if (opts.fitMethod === 'contain') {
+    ({ sx, sy, sw, sh } = getContainOffsets(sw, sh, opts.width, opts.height));
   }
 
   return nativeResize(
@@ -38,8 +38,8 @@ export function vectorResize(data: HTMLImageElement, opts: VectorResizeOptions):
   let sw = data.width;
   let sh = data.height;
 
-  if (opts.fitMethod === 'cover') {
-    ({ sx, sy, sw, sh } = getCoverOffsets(sw, sh, opts.width, opts.height));
+  if (opts.fitMethod === 'contain') {
+    ({ sx, sy, sw, sh } = getContainOffsets(sw, sh, opts.width, opts.height));
   }
 
   return drawableToImageData(data, {

src/codecs/rotate/processor-meta.ts

@@ -0,0 +1,5 @@
+export interface RotateOptions {
+  rotate: 0 | 90 | 180 | 270;
+}
+
+export const defaultOptions: RotateOptions = { rotate: 0 };

src/codecs/rotate/processor.ts

@@ -0,0 +1,76 @@
+import { RotateOptions } from './processor-meta';
+
+const bpp = 4;
+
+export function rotate(data: ImageData, opts: RotateOptions): ImageData {
+  const { rotate } = opts;
+  const flipDimensions = rotate % 180 !== 0;
+  const { width: inputWidth, height: inputHeight } = data;
+  const outputWidth = flipDimensions ? inputHeight : inputWidth;
+  const outputHeight = flipDimensions ? inputWidth : inputHeight;
+  const out = new ImageData(outputWidth, outputHeight);
+  let i = 0;
+
+  // In the straight-copy case, d1 is x, d2 is y.
+  // x starts at 0 and increases.
+  // y starts at 0 and increases.
+  let d1Start = 0;
+  let d1Limit = inputWidth;
+  let d1Advance = 1;
+  let d1Multiplier = 1;
+  let d2Start = 0;
+  let d2Limit = inputHeight;
+  let d2Advance = 1;
+  let d2Multiplier = inputWidth;
+
+  if (rotate === 90) {
+    // d1 is y, d2 is x.
+    // y starts at its max value and decreases.
+    // x starts at 0 and increases.
+    d1Start = inputHeight - 1;
+    d1Limit = inputHeight;
+    d1Advance = -1;
+    d1Multiplier = inputWidth;
+    d2Start = 0;
+    d2Limit = inputWidth;
+    d2Advance = 1;
+    d2Multiplier = 1;
+  } else if (rotate === 180) {
+    // d1 is x, d2 is y.
+    // x starts at its max and decreases.
+    // y starts at its max and decreases.
+    d1Start = inputWidth - 1;
+    d1Limit = inputWidth;
+    d1Advance = -1;
+    d1Multiplier = 1;
+    d2Start = inputHeight - 1;
+    d2Limit = inputHeight;
+    d2Advance = -1;
+    d2Multiplier = inputWidth;
+  } else if (rotate === 270) {
+    // d1 is y, d2 is x.
+    // y starts at 0 and increases.
+    // x starts at its max and decreases.
+    d1Start = 0;
+    d1Limit = inputHeight;
+    d1Advance = 1;
+    d1Multiplier = inputWidth;
+    d2Start = inputWidth - 1;
+    d2Limit = inputWidth;
+    d2Advance = -1;
+    d2Multiplier = 1;
+  }
+
+  for (let d2 = d2Start; d2 >= 0 && d2 < d2Limit; d2 += d2Advance) {
+    for (let d1 = d1Start; d1 >= 0 && d1 < d1Limit; d1 += d1Advance) {
+      // Iterate over channels:
+      const start = ((d1 * d1Multiplier) + (d2 * d2Multiplier)) * bpp;
+      for (let j = 0; j < bpp; j += 1) {
+        out.data[i] = data.data[start + j];
+        i += 1;
+      }
+    }
+  }
+
+  return out;
+}

src/codecs/webp/options.tsx

@@ -1,14 +1,22 @@
 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 styles from './styles.scss';
-import '../../custom-els/RangeInput';
+import * as style from '../../components/Options/style.scss';
+import Checkbox from '../../components/checkbox';
+import Expander from '../../components/expander';
+import Select from '../../components/select';
+import Range from '../../components/range';
+import linkState from 'linkstate';
 
-type Props = {
-  options: EncodeOptions,
-  onChange(newOptions: EncodeOptions): void,
-};
+interface Props {
+  options: EncodeOptions;
+  onChange(newOptions: EncodeOptions): void;
+}
+
+interface State {
+  showAdvanced: boolean;
+}
 
 // From kLosslessPresets in config_enc.c
 // The format is [method, quality].
@@ -18,257 +26,291 @@ const losslessPresets:[number, number][] = [
 ];
 const losslessPresetDefault = 6;
 
-function determineLosslessQuality(quality: number): number {
-  const index = losslessPresets.findIndex(item => item[1] === quality);
+function determineLosslessQuality(quality: number, method: number): number {
+  const index = losslessPresets.findIndex(
+    ([presetMethod, presetQuality]) => presetMethod === method && presetQuality === quality,
+  );
   if (index !== -1) return index;
   // Quality doesn't match one of the presets.
   // This can happen when toggling 'lossless'.
   return losslessPresetDefault;
 }
 
-export default class WebPEncoderOptions extends Component<Props, {}> {
+export default class WebPEncoderOptions extends Component<Props, State> {
+  state: State = {
+    showAdvanced: false,
+  };
+
   @bind
   onChange(event: Event) {
     const form = (event.currentTarget as HTMLInputElement).closest('form') as HTMLFormElement;
     const lossless = inputFieldCheckedAsNumber(form.lossless);
-    const losslessPresetInput = (form.lossless_preset as HTMLInputElement);
+    const { options } = this.props;
+    const losslessPresetValue = inputFieldValueAsNumber(
+      form.lossless_preset, determineLosslessQuality(options.quality, options.method),
+    );
 
-    const options: EncodeOptions = {
+    const newOptions: EncodeOptions = {
       // Copy over options the form doesn't care about, eg emulate_jpeg_size
-      ...this.props.options,
+      ...options,
       // And now stuff from the form:
       lossless,
       // Special-cased inputs:
       // In lossless mode, the quality is derived from the preset.
       quality: lossless ?
-        losslessPresets[Number(losslessPresetInput.value)][1] :
-        inputFieldValueAsNumber(form.quality),
+        losslessPresets[losslessPresetValue][1] :
+        inputFieldValueAsNumber(form.quality, options.quality),
       // In lossless mode, the method is derived from the preset.
       method: lossless ?
-        losslessPresets[Number(losslessPresetInput.value)][0] :
-        inputFieldValueAsNumber(form.method_input),
-      image_hint: (form.image_hint as HTMLInputElement).checked ?
+        losslessPresets[losslessPresetValue][0] :
+        inputFieldValueAsNumber(form.method_input, options.method),
+      image_hint: inputFieldCheckedAsNumber(form.image_hint, options.image_hint) ?
         WebPImageHint.WEBP_HINT_GRAPH :
         WebPImageHint.WEBP_HINT_DEFAULT,
       // .checked
-      exact: inputFieldCheckedAsNumber(form.exact),
-      alpha_compression: inputFieldCheckedAsNumber(form.alpha_compression),
-      autofilter: inputFieldCheckedAsNumber(form.autofilter),
-      filter_type: inputFieldCheckedAsNumber(form.filter_type),
-      use_sharp_yuv: inputFieldCheckedAsNumber(form.use_sharp_yuv),
+      exact: inputFieldCheckedAsNumber(form.exact, options.exact),
+      alpha_compression: inputFieldCheckedAsNumber(
+        form.alpha_compression, options.alpha_compression,
+      ),
+      autofilter: inputFieldCheckedAsNumber(form.autofilter, options.autofilter),
+      filter_type: inputFieldCheckedAsNumber(form.filter_type, options.filter_type),
+      use_sharp_yuv: inputFieldCheckedAsNumber(form.use_sharp_yuv, options.use_sharp_yuv),
       // .value
-      near_lossless: 100 - inputFieldValueAsNumber(form.near_lossless),
-      alpha_quality: inputFieldValueAsNumber(form.alpha_quality),
-      alpha_filtering: inputFieldValueAsNumber(form.alpha_filtering),
-      sns_strength: inputFieldValueAsNumber(form.sns_strength),
-      filter_strength: inputFieldValueAsNumber(form.filter_strength),
-      filter_sharpness: 7 - inputFieldValueAsNumber(form.filter_sharpness),
-      pass: inputFieldValueAsNumber(form.pass),
-      preprocessing: inputFieldValueAsNumber(form.preprocessing),
-      segments: inputFieldValueAsNumber(form.segments),
-      partitions: inputFieldValueAsNumber(form.partitions),
+      near_lossless: 100 - inputFieldValueAsNumber(form.near_lossless, 100 - options.near_lossless),
+      alpha_quality: inputFieldValueAsNumber(form.alpha_quality, options.alpha_quality),
+      alpha_filtering: inputFieldValueAsNumber(form.alpha_filtering, options.alpha_filtering),
+      sns_strength: inputFieldValueAsNumber(form.sns_strength, options.sns_strength),
+      filter_strength: inputFieldValueAsNumber(form.filter_strength, options.filter_strength),
+      filter_sharpness:
+        7 - inputFieldValueAsNumber(form.filter_sharpness, 7 - options.filter_sharpness),
+      pass: inputFieldValueAsNumber(form.pass, options.pass),
+      preprocessing: inputFieldValueAsNumber(form.preprocessing, options.preprocessing),
+      segments: inputFieldValueAsNumber(form.segments, options.segments),
+      partitions: inputFieldValueAsNumber(form.partitions, options.partitions),
     };
-    this.props.onChange(options);
+    this.props.onChange(newOptions);
   }
 
   private _losslessSpecificOptions(options: EncodeOptions) {
     return (
-      <div>
-        <label>
-          Effort:
-          <range-input
+      <div key="lossless">
+        <div class={style.optionOneCell}>
+          <Range
             name="lossless_preset"
             min="0"
             max="9"
-            value={'' + determineLosslessQuality(options.quality)}
-            onChange={this.onChange}
-          />
-        </label>
-        <label>
-          Slight loss:
-          <range-input
+            value={determineLosslessQuality(options.quality, options.method)}
+            onInput={this.onChange}
+          >
+            Effort:
+          </Range>
+        </div>
+        <div class={style.optionOneCell}>
+          <Range
             name="near_lossless"
             min="0"
             max="100"
             value={'' + (100 - options.near_lossless)}
-            onChange={this.onChange}
-          />
-        </label>
-        <label>
+            onInput={this.onChange}
+          >
+            Slight loss:
+          </Range>
+        </div>
+        <label class={style.optionInputFirst}>
           {/*
             Although there are 3 different kinds of image hint, webp only
             seems to do something with the 'graph' type, and I don't really
             understand what it does.
           */}
-          <input
+          <Checkbox
             name="image_hint"
-            type="checkbox"
             checked={options.image_hint === WebPImageHint.WEBP_HINT_GRAPH}
-            value={'' + WebPImageHint.WEBP_HINT_GRAPH}
             onChange={this.onChange}
           />
-          <span>Discrete tone image (graph, map-tile etc)</span>
+          Discrete tone image
         </label>
       </div>
     );
   }
 
   private _lossySpecificOptions(options: EncodeOptions) {
+    const { showAdvanced } = this.state;
+
     return (
-      <div>
-        <label>
-          Effort:
-          <range-input
+      <div key="lossy">
+        <div class={style.optionOneCell}>
+          <Range
             name="method_input"
             min="0"
             max="6"
-            value={'' + options.method}
-            onChange={this.onChange}
-          />
-        </label>
-        <label>
-          Quality:
-          <range-input
+            value={options.method}
+            onInput={this.onChange}
+          >
+            Effort:
+          </Range>
+        </div>
+        <div class={style.optionOneCell}>
+          <Range
             name="quality"
             min="0"
             max="100"
-            step="0.01"
-            value={'' + options.quality}
-            onChange={this.onChange}
-          />
-        </label>
-        <hr />
-        <label>
-          <input
-            name="alpha_compression"
-            type="checkbox"
-            checked={!!options.alpha_compression}
-            onChange={this.onChange}
-          />
-          Compress alpha
-        </label>
-        <label>
-          Alpha quality:
-          <range-input
-            name="alpha_quality"
-            min="0"
-            max="100"
-            value={'' + options.alpha_quality}
-            onChange={this.onChange}
-          />
-        </label>
-        <label>
-          Alpha filter quality:
-          <range-input
-            name="alpha_filtering"
-            min="0"
-            max="2"
-            value={'' + options.alpha_filtering}
-            onChange={this.onChange}
-          />
-        </label>
-        <hr />
-        <label>
-          <input
-            name="autofilter"
-            type="checkbox"
-            checked={!!options.autofilter}
-            onChange={this.onChange}
-          />
-          <span>Auto adjust filter strength</span>
-        </label>
-        <label>
-          Filter strength:
-          <range-input
-            name="filter_strength"
-            min="0"
-            max="100"
-            disabled={!!options.autofilter}
-            value={'' + options.filter_strength}
-            onChange={this.onChange}
-          />
-        </label>
-        <label>
-          <input
-            name="filter_type"
-            type="checkbox"
-            checked={!!options.filter_type}
-            onChange={this.onChange}
-          />
-          Strong filter
-        </label>
-        <label>
-          Filter sharpness:
-          <range-input
-            name="filter_sharpness"
-            min="0"
-            max="7"
-            value={'' + (7 - options.filter_sharpness)}
-            onChange={this.onChange}
-          />
-        </label>
-        <label>
-          <input
-            name="use_sharp_yuv"
-            type="checkbox"
-            checked={!!options.use_sharp_yuv}
-            onChange={this.onChange}
-          />
-          Sharp RGB->YUV conversion
-        </label>
-        <hr />
-        <label>
-          Passes:
-          <range-input
-            name="pass"
-            min="1"
-            max="10"
-            value={'' + options.pass}
-            onChange={this.onChange}
-          />
-        </label>
-        <label>
-          Spacial noise shaping:
-          <range-input
-            name="sns_strength"
-            min="0"
-            max="100"
-            value={'' + options.sns_strength}
-            onChange={this.onChange}
-          />
-        </label>
-        <label>
-          Preprocessing type:
-          <select
-            name="preprocessing"
-            value={'' + options.preprocessing}
-            onChange={this.onChange}
+            step="0.1"
+            value={options.quality}
+            onInput={this.onChange}
           >
-            <option value="0">None</option>
-            <option value="1">Segment smooth</option>
-            <option value="2">Pseudo-random dithering</option>
-          </select>
-        </label>
-        <label>
-          Segments:
-          <range-input
-            name="segments"
-            min="1"
-            max="4"
-            value={'' + options.segments}
-            onChange={this.onChange}
-          />
-        </label>
-        <label>
-          Partitions:
-          <range-input
-            name="partitions"
-            min="0"
-            max="3"
-            value={'' + options.partitions}
-            onChange={this.onChange}
+            Quality:
+          </Range>
+        </div>
+        <label class={style.optionInputFirst}>
+          <Checkbox
+            checked={showAdvanced}
+            onChange={linkState(this, 'showAdvanced')}
           />
+          Show advanced settings
         </label>
+        <Expander>
+          {showAdvanced ?
+            <div>
+              <label class={style.optionInputFirst}>
+                <Checkbox
+                  name="alpha_compression"
+                  checked={!!options.alpha_compression}
+                  onChange={this.onChange}
+                />
+                Compress alpha
+              </label>
+              <div class={style.optionOneCell}>
+                <Range
+                  name="alpha_quality"
+                  min="0"
+                  max="100"
+                  value={options.alpha_quality}
+                  onInput={this.onChange}
+                >
+                  Alpha quality:
+                </Range>
+              </div>
+              <div class={style.optionOneCell}>
+                <Range
+                  name="alpha_filtering"
+                  min="0"
+                  max="2"
+                  value={options.alpha_filtering}
+                  onInput={this.onChange}
+                >
+                  Alpha filter quality:
+                </Range>
+              </div>
+              <label class={style.optionInputFirst}>
+                <Checkbox
+                  name="autofilter"
+                  checked={!!options.autofilter}
+                  onChange={this.onChange}
+                />
+                Auto adjust filter strength
+              </label>
+              <Expander>
+                {options.autofilter ? null :
+                  <div class={style.optionOneCell}>
+                    <Range
+                      name="filter_strength"
+                      min="0"
+                      max="100"
+                      value={options.filter_strength}
+                      onInput={this.onChange}
+                    >
+                      Filter strength:
+                    </Range>
+                  </div>
+                }
+              </Expander>
+              <label class={style.optionInputFirst}>
+                <Checkbox
+                  name="filter_type"
+                  checked={!!options.filter_type}
+                  onChange={this.onChange}
+                />
+                Strong filter
+              </label>
+              <div class={style.optionOneCell}>
+                <Range
+                  name="filter_sharpness"
+                  min="0"
+                  max="7"
+                  value={7 - options.filter_sharpness}
+                  onInput={this.onChange}
+                >
+                  Filter sharpness:
+                </Range>
+              </div>
+              <label class={style.optionInputFirst}>
+                <Checkbox
+                  name="use_sharp_yuv"
+                  checked={!!options.use_sharp_yuv}
+                  onChange={this.onChange}
+                />
+                Sharp RGB→YUV conversion
+              </label>
+              <div class={style.optionOneCell}>
+                <Range
+                  name="pass"
+                  min="1"
+                  max="10"
+                  value={options.pass}
+                  onInput={this.onChange}
+                >
+                  Passes:
+                </Range>
+              </div>
+              <div class={style.optionOneCell}>
+                <Range
+                  name="sns_strength"
+                  min="0"
+                  max="100"
+                  value={options.sns_strength}
+                  onInput={this.onChange}
+                >
+                  Spacial noise shaping:
+                </Range>
+              </div>
+              <label class={style.optionTextFirst}>
+                Preprocess:
+                <Select
+                  name="preprocessing"
+                  value={options.preprocessing}
+                  onChange={this.onChange}
+                >
+                  <option value="0">None</option>
+                  <option value="1">Segment smooth</option>
+                  <option value="2">Pseudo-random dithering</option>
+                </Select>
+              </label>
+              <div class={style.optionOneCell}>
+                <Range
+                  name="segments"
+                  min="1"
+                  max="4"
+                  value={options.segments}
+                  onInput={this.onChange}
+                >
+                  Segments:
+                </Range>
+              </div>
+              <div class={style.optionOneCell}>
+                <Range
+                  name="partitions"
+                  min="0"
+                  max="3"
+                  value={options.partitions}
+                  onInput={this.onChange}
+                >
+                  Partitions:
+                </Range>
+              </div>
+            </div>
+            : null
+          }
+        </Expander>
       </div>
     );
   }
@@ -277,32 +319,26 @@ export default class WebPEncoderOptions extends Component<Props, {}> {
     // I'm rendering both lossy and lossless forms, as it becomes much easier when
     // gathering the data.
     return (
-      <form>
-        <label>
-          <input
+      <form class={style.optionsSection} onSubmit={preventDefault}>
+        <label class={style.optionInputFirst}>
+          <Checkbox
             name="lossless"
-            type="checkbox"
             checked={!!options.lossless}
             onChange={this.onChange}
           />
           Lossless
         </label>
-        <div class={options.lossless ? '' : styles.hide}>
-          {this._losslessSpecificOptions(options)}
-        </div>
-        <div class={options.lossless ? styles.hide : ''}>
-          {this._lossySpecificOptions(options)}
-        </div>
-        <label>
-          <input
+        {options.lossless
+          ? this._losslessSpecificOptions(options)
+          : this._lossySpecificOptions(options)
+        }
+        <label class={style.optionInputFirst}>
+          <Checkbox
             name="exact"
-            type="checkbox"
             checked={!!options.exact}
             onChange={this.onChange}
           />
-          <span>
-            Preserve transparent data. Otherwise, pixels with zero alpha will have RGB also zeroed.
-          </span>
+          Preserve transparent data
         </label>
       </form>
     );

src/codecs/webp/styles.scss

@@ -1,3 +0,0 @@
-.hide {
-  display: none;
-}

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,27 +2,27 @@ 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 SnackBarElement from '../../lib/SnackBar';
+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';
-
-export interface SourceImage {
-  file: File | Fileish;
-  data: ImageData;
-  vectorImage?: HTMLImageElement;
-}
+const compressPromise = import(
+  /* webpackChunkName: "main-app" */
+  '../compress',
+);
+const offlinerPromise = import(
+  /* webpackChunkName: "offliner" */
+  '../../lib/offliner',
+);
 
 interface Props {}
 
 interface State {
   file?: File | Fileish;
-  Compress?: typeof Compress;
+  Compress?: typeof import('../compress').default;
 }
 
 export default class App extends Component<Props, State> {
@@ -36,12 +36,14 @@ export default class App extends Component<Props, State> {
   constructor() {
     super();
 
-    import('../compress').then((module) => {
+    compressPromise.then((module) => {
       this.setState({ Compress: module.default });
     }).catch(() => {
-      this.showError('Failed to load app');
+      this.showSnack('Failed to load app');
     });
 
+    offlinerPromise.then(({ offliner }) => offliner(this.showSnack));
+
     // In development, persist application state across hot reloads:
     if (process.env.NODE_ENV === 'development') {
       this.setState(window.STATE);
@@ -66,19 +68,24 @@ export default class App extends Component<Props, State> {
   }
 
   @bind
-  private showError(error: string) {
+  private showSnack(message: string, options: SnackOptions = {}): Promise<string> {
     if (!this.snackbar) throw Error('Snackbar missing');
-    this.snackbar.showSnackbar({ message: error });
+    return this.snackbar.showSnackbar(message, options);
+  }
+
+  @bind
+  private onBack() {
+    this.setState({ file: undefined });
   }
 
   render({}: Props, { file, Compress }: State) {
     return (
       <div id="app" class={style.app}>
-        <file-drop accept="image/*" onfiledrop={this.onFileDrop}>
+        <file-drop accept="image/*" onfiledrop={this.onFileDrop} class={style.drop}>
           {(!file)
-            ? <Intro onFile={this.onIntroPickFile} onError={this.showError} />
+            ? <Intro onFile={this.onIntroPickFile} showSnack={this.showSnack} />
             : (Compress)
-              ? <Compress file={file} onError={this.showError} />
+              ? <Compress file={file} showSnack={this.showSnack} onBack={this.onBack} />
               : <loading-spinner class={style.appLoader}/>
           }
           <snack-bar ref={linkRef(this, 'snackbar')} />

src/components/App/style.scss

@@ -1,7 +1,3 @@
-/*
-Note: These styles are temporary. They will be replaced before going live.
-*/
-
 .app {
   position: absolute;
   left: 0;
@@ -12,14 +8,14 @@ Note: These styles are temporary. They will be replaced before going live.
   contain: strict;
 }
 
-:global {
-  file-drop {
-    overflow: hidden;
-    touch-action: none;
-    height:100%;
-    width:100%;
+.drop {
+  overflow: hidden;
+  touch-action: none;
+  height: 100%;
+  width: 100%;
 
-    &:after {
+  &:global {
+    &::after {
       content: '';
       position: absolute;
       display: block;
@@ -28,28 +24,20 @@ Note: These styles are temporary. They will be replaced before going live.
       right: 10px;
       bottom: 10px;
       border: 2px dashed #fff;
+      background-color:rgba(88, 116, 88, 0.2);
+      border-color: rgba(65, 129, 65, 0.5);
       border-radius: 10px;
       opacity: 0;
       transform: scale(0.95);
-      transition: opacity 300ms ease, transform 300ms cubic-bezier(.6,2,.6,1), background-color 300ms step-end, border-color 300ms step-end;
+      transition: all 200ms ease-in;
+      transition-property: transform, opacity;
       pointer-events: none;
     }
 
-    &.drop-valid:after,
-    &.drop-invalid:after {
+    &.drop-valid::after {
       opacity: 1;
       transform: scale(1);
-      transition: opacity 300ms ease, transform 300ms cubic-bezier(.6,2,.6,1);
-    }
-
-    &.drop-valid:after {
-      background-color:rgba(88, 116, 88, 0.2);
-      border-color: rgba(65, 129, 65, 0.5);
-    }
-
-    &.drop-invalid:after {
-      background-color:rgba(119, 85, 85, 0.2);
-      border-color:rgba(129, 63, 63, 0.5);
+      transition-timing-function: ease-out;
     }
   }
 }

src/components/FileSize.tsx

@@ -1,87 +0,0 @@
-import { h, Component } from 'preact';
-import * as prettyBytes from 'pretty-bytes';
-
-type FileContents = ArrayBuffer | Blob;
-
-interface Props extends Pick<JSX.HTMLAttributes, Exclude<keyof JSX.HTMLAttributes, 'data'>> {
-  file?: FileContents;
-  compareTo?: FileContents;
-  increaseClass?: string;
-  decreaseClass?: string;
-}
-
-interface State {
-  size?: number;
-  sizeFormatted?: string;
-  compareSize?: number;
-  compareSizeFormatted?: string;
-}
-
-function calculateSize(data: FileContents): number {
-  return data instanceof ArrayBuffer ? data.byteLength : data.size;
-}
-
-export default class FileSize extends Component<Props, State> {
-  constructor(props: Props) {
-    super(props);
-    if (props.file) {
-      this.computeSize('size', props.file);
-    }
-    if (props.compareTo) {
-      this.computeSize('compareSize', props.compareTo);
-    }
-  }
-
-  componentWillReceiveProps({ file, compareTo }: Props) {
-    if (file !== this.props.file) {
-      this.computeSize('size', file);
-    }
-    if (compareTo !== this.props.compareTo) {
-      this.computeSize('compareSize', compareTo);
-    }
-  }
-
-  componentDidMount() {
-    this.applyStyles();
-  }
-
-  componentDidUpdate() {
-    this.applyStyles();
-  }
-
-  applyStyles() {
-    const { size, compareSize = 0 } = this.state;
-    if (size != null && this.base) {
-      const delta = size && compareSize ? (size - compareSize) / compareSize : 0;
-      this.base.style.setProperty('--size', '' + size);
-      this.base.style.setProperty('--size-delta', '' + Math.round(Math.abs(delta * 100)));
-    }
-  }
-
-  computeSize(prop: keyof State, data?: FileContents) {
-    const size = data ? calculateSize(data) : 0;
-    const pretty = prettyBytes(size);
-    this.setState({
-      [prop]: size,
-      [prop + 'Formatted']: pretty,
-    });
-  }
-
-  render(
-    { file, compareTo, increaseClass, decreaseClass, ...props }: Props,
-    { size, sizeFormatted = '', compareSize }: State,
-  ) {
-    const delta = size && compareSize ? (size - compareSize) / compareSize : 0;
-    return (
-      <span {...props}>
-        {sizeFormatted}
-        {compareTo && (
-          <span class={delta > 0 ? increaseClass : decreaseClass}>
-            {delta > 0 && '+'}
-            {Math.round(delta * 100)}%
-          </span>
-        )}
-      </span>
-    );
-  }
-}

src/components/Options/index.tsx

@@ -1,7 +1,7 @@
 import { h, Component } from 'preact';
 
 import * as style from './style.scss';
-import { bind, Fileish } from '../../lib/initial-util';
+import { bind } from '../../lib/initial-util';
 import { cleanSet, cleanMerge } from '../../lib/clean-modify';
 import OptiPNGEncoderOptions from '../../codecs/optipng/options';
 import MozJpegEncoderOptions from '../../codecs/mozjpeg/options';
@@ -31,14 +31,14 @@ import {
   encoders,
   encodersSupported,
   EncoderSupportMap,
-  encoderMap,
 } from '../../codecs/encoders';
 import { QuantizeOptions } from '../../codecs/imagequant/processor-meta';
 import { ResizeOptions } from '../../codecs/resize/processor-meta';
 import { PreprocessorState } from '../../codecs/preprocessors';
-import FileSize from '../FileSize';
-import { DownloadIcon } from '../../lib/icons';
-import { SourceImage } from '../App';
+import { SourceImage } from '../compress';
+import Checkbox from '../checkbox';
+import Expander from '../expander';
+import Select from '../select';
 
 const encoderOptionsComponentMap = {
   [identity.type]: undefined,
@@ -56,23 +56,14 @@ const encoderOptionsComponentMap = {
   [browserPDF.type]: undefined,
 };
 
-const titles = {
-  horizontal: ['Left Image', 'Right Image'],
-  vertical: ['Top Image', 'Bottom Image'],
-};
-
 interface Props {
-  orientation: 'horizontal' | 'vertical';
+  mobileView: boolean;
   source?: SourceImage;
-  imageIndex: number;
-  imageFile?: Fileish;
-  downloadUrl?: string;
   encoderState: EncoderState;
   preprocessorState: PreprocessorState;
   onEncoderTypeChange(newType: EncoderType): void;
   onEncoderOptionsChange(newOptions: EncoderOptions): void;
   onPreprocessorOptionsChange(newOptions: PreprocessorState): void;
-  onCopyToOtherClick(): void;
 }
 
 interface State {
@@ -80,7 +71,9 @@ interface State {
 }
 
 export default class Options extends Component<Props, State> {
-  typeSelect?: HTMLSelectElement;
+  state: State = {
+    encoderSupportMap: undefined,
+  };
 
   constructor() {
     super();
@@ -88,7 +81,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,
@@ -98,7 +91,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;
 
@@ -108,32 +101,22 @@ 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),
     );
   }
 
-  @bind
-  onCopyToOtherClick(event: Event) {
-    event.preventDefault();
-    this.props.onCopyToOtherClick();
-  }
-
   render(
     {
       source,
-      imageIndex,
-      imageFile,
-      downloadUrl,
-      orientation,
       encoderState,
       preprocessorState,
       onEncoderOptionsChange,
@@ -144,64 +127,65 @@ export default class Options extends Component<Props, State> {
     const EncoderOptionComponent = encoderOptionsComponentMap[encoderState.type];
 
     return (
-      <div class={`${style.options} ${style[orientation]}`}>
-        <h2 class={style.title}>
-          {titles[orientation][imageIndex]}
-          {', '}
-          {encoderMap[encoderState.type].label}
-        </h2>
-
-        <div class={style.content}>
-          <section class={style.picker}>
-            {encoderSupportMap ?
-              <select value={encoderState.type} onChange={this.onEncoderTypeChange}>
-                {encoders.filter(encoder => encoderSupportMap[encoder.type]).map(encoder => (
-                  <option value={encoder.type}>{encoder.label}</option>
-                ))}
-              </select>
-              :
-              <select><option>Loading…</option></select>
-            }
-          </section>
-
-          {encoderState.type !== 'identity' && (
-            <div key="preprocessors" class={style.preprocessors}>
-              <label class={style.toggle}>
-                <input
+      <div class={style.optionsScroller}>
+        <Expander>
+          {encoderState.type === identity.type ? null :
+            <div>
+              <h3 class={style.optionsTitle}>Edit</h3>
+              <label class={style.sectionEnabler}>
+                <Checkbox
                   name="resize.enable"
-                  type="checkbox"
                   checked={!!preprocessorState.resize.enabled}
                   onChange={this.onPreprocessorEnabledChange}
                 />
                 Resize
               </label>
-              {preprocessorState.resize.enabled &&
-                <ResizeOptionsComponent
-                  isVector={Boolean(source && source.vectorImage)}
-                  aspect={source ? (source.data.width / source.data.height) : 1}
-                  options={preprocessorState.resize}
-                  onChange={this.onResizeOptionsChange}
-                />
-              }
-              <label class={style.toggle}>
-                <input
+              <Expander>
+                {preprocessorState.resize.enabled ?
+                  <ResizeOptionsComponent
+                    isVector={Boolean(source && source.vectorImage)}
+                    aspect={source ? source.processed.width / source.processed.height : 1}
+                    options={preprocessorState.resize}
+                    onChange={this.onResizeOptionsChange}
+                  />
+                : null}
+              </Expander>
+              <label class={style.sectionEnabler}>
+                <Checkbox
                   name="quantizer.enable"
-                  type="checkbox"
                   checked={!!preprocessorState.quantizer.enabled}
                   onChange={this.onPreprocessorEnabledChange}
                 />
-                Quantize
+                Reduce palette
               </label>
-              {preprocessorState.quantizer.enabled &&
-                <QuantizerOptionsComponent
-                  options={preprocessorState.quantizer}
-                  onChange={this.onQuantizerOptionsChange}
-                />
-              }
+              <Expander>
+                {preprocessorState.quantizer.enabled ?
+                  <QuantizerOptionsComponent
+                    options={preprocessorState.quantizer}
+                    onChange={this.onQuantizerOptionsChange}
+                  />
+                : null}
+              </Expander>
             </div>
-          )}
+          }
+        </Expander>
 
-          {EncoderOptionComponent &&
+        <h3 class={style.optionsTitle}>Compress</h3>
+
+        <section class={`${style.optionOneCell} ${style.optionsSection}`}>
+          {encoderSupportMap ?
+            <Select value={encoderState.type} onChange={this.onEncoderTypeChange} large>
+              {encoders.filter(encoder => encoderSupportMap[encoder.type]).map(encoder => (
+                <option value={encoder.type}>{encoder.label}</option>
+              ))}
+            </Select>
+            :
+            <Select large><option>Loading…</option></Select>
+          }
+        </section>
+
+        <Expander>
+          {EncoderOptionComponent ?
             <EncoderOptionComponent
               options={
                 // Casting options, as encoderOptionsComponentMap[encodeData.type] ensures
@@ -210,33 +194,8 @@ export default class Options extends Component<Props, State> {
               }
               onChange={onEncoderOptionsChange}
             />
-          }
-        </div>
-
-        <div class={style.row}>
-          <button onClick={this.onCopyToOtherClick}>Copy settings to other side</button>
-        </div>
-
-        <div class={style.sizeDetails}>
-          <FileSize
-            class={style.size}
-            increaseClass={style.increase}
-            decreaseClass={style.decrease}
-            file={imageFile}
-            compareTo={(source && imageFile !== source.file) ? source.file : undefined}
-          />
-
-          {(downloadUrl && imageFile) && (
-            <a
-              class={style.download}
-              href={downloadUrl}
-              download={imageFile.name}
-              title="Download"
-            >
-              <DownloadIcon />
-            </a>
-          )}
-        </div>
+          : null}
+        </Expander>
       </div>
     );
   }

src/components/Options/style.scss

@@ -1,225 +1,58 @@
-/*
-Note: These styles are temporary. They will be replaced before going live.
-*/
+$horizontalPadding: 15px;
 
-.row {
-  padding: 5px;
-  margin: 0 10px;
-}
-
-.options {
-  box-sizing: border-box;
-  padding: 0;
-  background: rgba(40,40,40,0.8);
-  box-shadow: 0 1px 3px rgba(0,0,0,0.5);
-  color: #eee;
-  overflow: auto;
-  z-index: 1;
-  opacity: 0.9;
-  transform-origin: 50% 140%;
-  transition: opacity 300ms linear;
-  animation: options-open 500ms cubic-bezier(.6,1.6,.6,1) forwards 1;
-
-  &.horizontal {
-    border-radius: 1px 1px 5px 5px;
-    width: 230px;
-
-    > .inner {
-      max-height: 80vh;
-      overflow: auto;
-      -webkit-overflow-scrolling: touch;
-      -ms-touch-action: pan-y;
-      touch-action: pan-y;
-    }
-  }
-
-  &.vertical {
-    opacity: 1;
-    margin: 0 5px 10px;
-    border-radius: 0 0 5px 5px;
-  }
-
-  &:hover, &:focus, &:focus-within {
-    opacity: 1;
-  }
-
-  @keyframes options-open {
-    from {
-      transform: translateY(100px) scale(.8);
-    }
-  }
-
-  .content {
-    max-height: calc(75vh - 100px);
-    overflow: auto;
-    touch-action: pan-y;
-    -webkit-overflow-scrolling: touch;
-  }
-
-  .picker {
-    margin: 5px 15px;
-
-    select {
-      display: block;
-      width: 100%;
-      box-sizing: border-box;
-      -webkit-appearance: none;
-      appearance: none;
-      padding: 10px 30px 10px 10px;
-      background: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="25" height="5"><polygon fill="#fff" points="10,0 5,5 0,0"/></svg>') right center no-repeat;
-      background-color: var(--gray-dark);
-      opacity: 0.9;
-      border: none;
-      font: inherit;
-      color: white;
-      transition: box-shadow 150ms ease;
-
-      &:hover {
-        opacity: 1;
-      }
-      &:focus {
-        opacity: 1;
-        outline: none;
-        box-shadow: 0 0 0 2px var(--button-fg, #ccc);
-      }
-    }
-  }
-
-  .title {
-    display: flex;
-    align-items: center;
-    padding: 10px 15px;
-    margin: 0 0 12px;
-    background: rgba(0,0,0,0.9);
-    font: inherit;
-  }
-
-  label {
-    display: block;
-    padding: 5px;
-    margin: 0 10px;
-    display: flex;
-    flex-wrap: wrap;
-
-    // prevent labels from wrapping below checkboxes
-    > span {
-      flex: 1;
-    }
-
-    input[type=checkbox],
-    input[type=radio] {
-      flex: 0;
-      margin: 2px 8px 0 0;
-    }
-
-    range-input {
-      display: block;
-      flex: 1 0 100%;
-      margin: 2px 0;
-    }
-  }
-
-  hr {
-    height: 1px;
-    border: none;
-    margin: 5px 0;
-    box-shadow: inset 0 0.5px 0 rgba(0, 0, 0, 0.4), inset 0 -0.5px 0 rgba(255, 255, 255, 0.2);
-  }
-}
-
-.picker {
-  margin: 5px 15px;
-
-  select {
-    display: block;
-    width: 100%;
-    box-sizing: border-box;
-    -webkit-appearance: none;
-    appearance: none;
-    padding: 10px 30px 10px 10px;
-    background: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="25" height="5"><polygon fill="#fff" points="10,0 5,5 0,0"/></svg>') right center no-repeat;
-    background-color: var(--gray-dark);
-    opacity: 0.9;
-    border: none;
-    font: inherit;
-    color: white;
-  }
-
-  hr {
-    height: 1px;
-    border: none;
-    margin: 5px 0;
-    box-shadow: inset 0 0.5px 0 rgba(0, 0, 0, 0.4), inset 0 -0.5px 0 rgba(255, 255, 255, 0.2);
-  }
-}
-
-.size-details {
-  display: flex;
-  align-items: center;
-  padding: 5px 15px;
-  background: rgba(0,0,0,0.5);
-}
-
-.download {
-  flex: 0;
-  margin: 0 0 0 auto;
-  background: rgba(255,255,255,0.1);
-  border-radius: 50%;
-  padding: 5px;
-  width: 16px;
-  height: 16px;
-  text-decoration: none;
-
-  > svg {
-    width: 16px;
-    height: 16px;
-    fill: #fff;
-  }
-
-  &:hover {
-    background-color: rgba(255,255,255,0.3);
-  }
-}
-
-.size-details {
-  padding: 5px 15px;
-  background: rgba(0,0,0,0.5);
-}
-
-.size {
+.options-title {
+  background: rgba(0, 0, 0, 0.9);
+  margin: 0;
+  padding: 10px $horizontalPadding;
   font-weight: normal;
+  font-size: 1.4rem;
+  border-bottom: 1px solid #000;
 }
 
-.increase,
-.decrease {
-  font-style: italic;
-  filter: #{"grayscale(calc(50% - var(--size-delta, 50) * 0.5%))"};
-
-  &:before {
-    content: ' (';
-  }
-  &:after {
-    content: ')';
-  }
+.option-text-first {
+  display: grid;
+  align-items: center;
+  grid-template-columns: 87px 1fr;
+  grid-gap: 0.7em;
+  padding: 10px $horizontalPadding;
 }
 
-.increase {
-  color: var(--negative);
-}
-.decrease {
-  color: var(--positive);
+.option-one-cell {
+  display: grid;
+  grid-template-columns: 1fr;
+  padding: 10px $horizontalPadding;
 }
 
-.preprocessors {
-  padding: 5px 0;
-  margin: 5px 0;
-  box-shadow: inset 0 -.5px 0 rgba(0,0,0,0.4), 0 .5px 0 rgba(255,255,255,0.2);
+.option-input-first,
+.section-enabler {
+  cursor: pointer;
+  display: grid;
+  align-items: center;
+  grid-template-columns: auto 1fr;
+  grid-gap: 0.7em;
+  padding: 10px $horizontalPadding;
 }
 
-.toggle {
-  display: flex;
-  position: relative;
-  align-content: center;
-  font-size: 14px;
-  box-shadow: inset 0 -.5px 0 rgba(0,0,0,0.4), 0 .5px 0 rgba(255,255,255,0.2);
+.section-enabler {
+  background: rgba(0, 0, 0, 0.8);
+}
+
+.options-section {
+  background: rgba(0, 0, 0, 0.7);
+}
+
+.text-field {
+  background: #fff;
+  font: inherit;
+  border: none;
+  padding: 2px 0 2px 10px;
+  width: 100%;
+  box-sizing: border-box;
+  box-shadow: inset 0 1px 3px rgba(0, 0, 0, 0.5);
+}
+
+.options-scroller {
+  overflow-x: hidden;
+  overflow-y: auto;
+  -webkit-overflow-scrolling: touch;
 }

src/components/Output/custom-els/PinchZoom/index.ts

@@ -1,5 +1,5 @@
+import PointerTracker, { Pointer } from 'pointer-tracker';
 import './styles.css';
-import { PointerTracker, Pointer } from '../../../../lib/PointerTracker';
 
 interface Point {
   clientX: number;
@@ -145,7 +145,7 @@ export default class PinchZoom extends HTMLElement {
     const relativeToEl = (relativeTo === 'content' ? this._positioningEl : this);
 
     // No content element? Fall back to just setting scale
-    if (!relativeToEl) {
+    if (!relativeToEl || !this._positioningEl) {
       this.setTransform({ scale, allowChangeEvent });
       return;
     }
@@ -157,6 +157,10 @@ export default class PinchZoom extends HTMLElement {
     if (relativeTo === 'content') {
       originX += this.x;
       originY += this.y;
+    } else {
+      const currentRect = this._positioningEl.getBoundingClientRect();
+      originX -= currentRect.left;
+      originY -= currentRect.top;
     }
 
     this._applyChange({
@@ -238,7 +242,7 @@ export default class PinchZoom extends HTMLElement {
   /**
    * Update transform values without checking bounds. This is only called in setTransform.
    */
-  _updateTransform(scale: number, x: number, y: number, allowChangeEvent: boolean) {
+  private _updateTransform(scale: number, x: number, y: number, allowChangeEvent: boolean) {
     // Avoid scaling to zero
     if (scale < MIN_SCALE) return;
 

src/components/Output/custom-els/TwoUp/index.ts

@@ -1,5 +1,5 @@
+import PointerTracker, { Pointer } from 'pointer-tracker';
 import * as styles from './styles.css';
-import { PointerTracker, Pointer } from '../../../../lib/PointerTracker';
 
 const legacyClipCompatAttr = 'legacy-clip-compat';
 const orientationAttr = 'orientation';
@@ -68,11 +68,14 @@ export default class TwoUp extends HTMLElement {
   }
 
   connectedCallback() {
+    this._childrenChange();
+
     this._handle.innerHTML = `<div class="${styles.scrubber}">${
-      '<svg viewBox="0 0 20 10" fill="currentColor"><path d="M8 0v10L0 5zM12 0v10l8-5z"/></svg>'
+      `<svg viewBox="0 0 27 20" fill="currentColor">${
+        '<path d="M17 19.2l9.5-9.6L16.9 0zM9.6 0L0 9.6l9.6 9.6z"/>'
+      }</svg>`
     }</div>`;
 
-    this._childrenChange();
     if (!this._everConnected) {
       this._resetPosition();
       this._everConnected = true;

src/components/Output/custom-els/TwoUp/styles.css

@@ -6,29 +6,41 @@ two-up {
   --track-color: var(--accent-color);
   --thumb-background: #fff;
   --thumb-color: var(--accent-color);
+  --thumb-size: 62px;
+  --bar-size: 6px;
+  --bar-touch-size: 30px;
 }
 
 two-up > * {
-  /* Overlay all children on top of each other, and let
-  two-up's layout contain all of them. */
+  /* Overlay all children on top of each other, and let two-up's layout contain all of them. */
   grid-area: 1/1;
 }
 
-two-up[legacy-clip-compat] > :not(.twoUpHandle) {
+two-up[legacy-clip-compat] > :not(.two-up-handle) {
+  /* Legacy mode uses clip rather than clip-path (Edge doesn't support clip-path), but clip requires
+  elements to be positioned absolutely */
   position: absolute;
 }
 
-.twoUpHandle {
+.two-up-handle {
   touch-action: none;
   position: relative;
-  width: 10px;
-  background: var(--track-color);
+  width: var(--bar-touch-size);
   transform: translateX(var(--split-point)) translateX(-50%);
-  box-shadow: inset 4px 0 0 rgba(0,0,0,0.1), 0 1px 4px rgba(0,0,0,0.4);
   will-change: transform;
   cursor: ew-resize;
 }
 
+.two-up-handle::before {
+  content: '';
+  display: block;
+  height: 100%;
+  width: var(--bar-size);
+  margin: 0 auto;
+  box-shadow: inset calc(var(--bar-size) / 2) 0 0 rgba(0,0,0,0.1), 0 1px 4px rgba(0,0,0,0.4);
+  background: var(--track-color);
+}
+
 .scrubber {
   display: flex;
   position: absolute;
@@ -36,51 +48,56 @@ two-up[legacy-clip-compat] > :not(.twoUpHandle) {
   left: 50%;
   transform-origin: 50% 50%;
   transform: translate(-50%, -50%);
-  width: 62px;
-  height: 56px;
+  width: var(--thumb-size);
+  height: calc(var(--thumb-size) * 0.9);
   background: var(--thumb-background);
   border: 1px solid rgba(0,0,0,0.2);
-  border-radius: 5px;
+  border-radius: var(--thumb-size);
   box-shadow: 0 1px 4px rgba(0,0,0,0.1);
   color: var(--thumb-color);
-}
-.scrubber svg {
-  flex: 1;
-  margin: 0 10px;
+  box-sizing: border-box;
+  padding: 0 calc(var(--thumb-size) * 0.24);
 }
 
-two-up[orientation='vertical'] .twoUpHandle {
+.scrubber svg {
+  flex: 1;
+}
+
+two-up[orientation='vertical'] .two-up-handle {
   width: auto;
-  height: 7px;
+  height: var(--bar-touch-size);
   transform: translateY(var(--split-point)) translateY(-50%);
-  box-shadow: inset 0 3px 0 rgba(0,0,0,0.1), 0 1px 4px rgba(0,0,0,0.4);
   cursor: ns-resize;
 }
 
+two-up[orientation='vertical'] .two-up-handle::before {
+  width: auto;
+  height: var(--bar-size);
+  box-shadow: inset 0 calc(var(--bar-size) / 2) 0 rgba(0,0,0,0.1), 0 1px 4px rgba(0,0,0,0.4);
+  margin: calc((var(--bar-touch-size) - var(--bar-size)) / 2) 0 0 0;
+}
+
 two-up[orientation='vertical'] .scrubber {
-  width: 46px;
-  height: 40px;
-  font-size: 18px;
   box-shadow: 1px 0 4px rgba(0,0,0,0.1);
   transform: translate(-50%, -50%) rotate(-90deg);
 }
 
-two-up > :nth-child(1):not(.twoUpHandle) {
+two-up > :nth-child(1):not(.two-up-handle) {
   -webkit-clip-path: inset(0 calc(100% - var(--split-point)) 0 0);
   clip-path: inset(0 calc(100% - var(--split-point)) 0 0);
 }
 
-two-up > :nth-child(2):not(.twoUpHandle) {
+two-up > :nth-child(2):not(.two-up-handle) {
   -webkit-clip-path: inset(0 0 0 var(--split-point));
   clip-path: inset(0 0 0 var(--split-point));
 }
 
-two-up[orientation='vertical'] > :nth-child(1):not(.twoUpHandle) {
+two-up[orientation='vertical'] > :nth-child(1):not(.two-up-handle) {
   -webkit-clip-path: inset(0 0 calc(100% - var(--split-point)) 0);
   clip-path: inset(0 0 calc(100% - var(--split-point)) 0);
 }
 
-two-up[orientation='vertical'] > :nth-child(2):not(.twoUpHandle) {
+two-up[orientation='vertical'] > :nth-child(2):not(.two-up-handle) {
   -webkit-clip-path: inset(var(--split-point) 0 0 0);
   clip-path: inset(var(--split-point) 0 0 0);
 }
@@ -90,19 +107,19 @@ two-up[orientation='vertical'] > :nth-child(2):not(.twoUpHandle) {
   It performs way better in Safari.
  */
 @supports not ((clip-path: inset(0 0 0 0)) or (-webkit-clip-path: inset(0 0 0 0))) {
-  two-up[legacy-clip-compat] > :nth-child(1):not(.twoUpHandle) {
+  two-up[legacy-clip-compat] > :nth-child(1):not(.two-up-handle) {
     clip: rect(auto var(--split-point) auto auto);
   }
 
-  two-up[legacy-clip-compat] > :nth-child(2):not(.twoUpHandle) {
+  two-up[legacy-clip-compat] > :nth-child(2):not(.two-up-handle) {
     clip: rect(auto auto auto var(--split-point));
   }
 
-  two-up[orientation='vertical'][legacy-clip-compat] > :nth-child(1):not(.twoUpHandle) {
+  two-up[orientation='vertical'][legacy-clip-compat] > :nth-child(1):not(.two-up-handle) {
     clip: rect(auto auto var(--split-point) auto);
   }
 
-  two-up[orientation='vertical'][legacy-clip-compat] > :nth-child(2):not(.twoUpHandle) {
+  two-up[orientation='vertical'][legacy-clip-compat] > :nth-child(2):not(.two-up-handle) {
     clip: rect(var(--split-point) auto auto auto);
   }
 }

src/components/Output/index.tsx

@@ -5,16 +5,29 @@ import './custom-els/TwoUp';
 import * as style from './style.scss';
 import { bind, linkRef } from '../../lib/initial-util';
 import { shallowEqual, drawDataToCanvas } from '../../lib/util';
-import { ToggleIcon, AddIcon, RemoveIcon } from '../../lib/icons';
+import {
+    ToggleBackgroundIcon,
+    AddIcon,
+    RemoveIcon,
+    BackIcon,
+    ToggleBackgroundActiveIcon,
+    RotateIcon,
+} from '../../lib/icons';
 import { twoUpHandle } from './custom-els/TwoUp/styles.css';
+import { InputProcessorState } from '../../codecs/input-processors';
+import { cleanSet } from '../../lib/clean-modify';
+import { SourceImage } from '../compress';
 
 interface Props {
-  originalImage?: ImageData;
-  orientation: 'horizontal' | 'vertical';
+  source?: SourceImage;
+  inputProcessorState?: InputProcessorState;
+  mobileView: boolean;
   leftCompressed?: ImageData;
   rightCompressed?: ImageData;
   leftImgContain: boolean;
   rightImgContain: boolean;
+  onBack: () => void;
+  onInputProcessorChange: (newState: InputProcessorState) => void;
 }
 
 interface State {
@@ -47,6 +60,15 @@ export default class Output extends Component<Props, State> {
     const leftDraw = this.leftDrawable();
     const rightDraw = this.rightDrawable();
 
+    // Reset the pinch zoom, which may have an position set from the previous view, after pressing
+    // the back button.
+    this.pinchZoomLeft!.setTransform({
+      allowChangeEvent: true,
+      x: 0,
+      y: 0,
+      scale: 1,
+    });
+
     if (this.canvasLeft && leftDraw) {
       drawDataToCanvas(this.canvasLeft, leftDraw);
     }
@@ -60,6 +82,38 @@ export default class Output extends Component<Props, State> {
     const prevRightDraw = this.rightDrawable(prevProps);
     const leftDraw = this.leftDrawable();
     const rightDraw = this.rightDrawable();
+    const sourceFileChanged =
+      // Has the value become (un)defined?
+      (!!this.props.source !== !!prevProps.source) ||
+      // Or has the file changed?
+      (this.props.source && prevProps.source && this.props.source.file !== prevProps.source.file);
+
+    const oldSourceData = prevProps.source && prevProps.source.processed;
+    const newSourceData = this.props.source && this.props.source.processed;
+    const pinchZoom = this.pinchZoomLeft!;
+
+    if (sourceFileChanged) {
+      // New image? Reset the pinch-zoom.
+      pinchZoom.setTransform({
+        allowChangeEvent: true,
+        x: 0,
+        y: 0,
+        scale: 1,
+      });
+    } else if (oldSourceData && newSourceData && oldSourceData !== newSourceData) {
+      // Since the pinch zoom transform origin is the top-left of the content, we need to flip
+      // things around a bit when the content size changes, so the new content appears as if it were
+      // central to the previous content.
+      const scaleChange = 1 - pinchZoom.scale;
+      const oldXScaleOffset = oldSourceData.width / 2 * scaleChange;
+      const oldYScaleOffset = oldSourceData.height / 2 * scaleChange;
+
+      pinchZoom.setTransform({
+        allowChangeEvent: true,
+        x: pinchZoom.x - oldXScaleOffset + oldYScaleOffset,
+        y: pinchZoom.y - oldYScaleOffset + oldXScaleOffset,
+      });
+    }
 
     if (leftDraw && leftDraw !== prevLeftDraw && this.canvasLeft) {
       drawDataToCanvas(this.canvasLeft, leftDraw);
@@ -67,16 +121,6 @@ export default class Output extends Component<Props, State> {
     if (rightDraw && rightDraw !== prevRightDraw && this.canvasRight) {
       drawDataToCanvas(this.canvasRight, rightDraw);
     }
-
-    if (this.props.originalImage !== prevProps.originalImage && this.pinchZoomLeft) {
-      // New image? Reset the pinch-zoom.
-      this.pinchZoomLeft.setTransform({
-        allowChangeEvent: true,
-        x: 0,
-        y: 0,
-        scale: 1,
-      });
-    }
   }
 
   shouldComponentUpdate(nextProps: Props, nextState: State) {
@@ -84,11 +128,11 @@ export default class Output extends Component<Props, State> {
   }
 
   private leftDrawable(props: Props = this.props): ImageData | undefined {
-    return props.leftCompressed || props.originalImage;
+    return props.leftCompressed || (props.source && props.source.processed);
   }
 
   private rightDrawable(props: Props = this.props): ImageData | undefined {
-    return props.rightCompressed || props.originalImage;
+    return props.rightCompressed || (props.source && props.source.processed);
   }
 
   @bind
@@ -113,14 +157,33 @@ export default class Output extends Component<Props, State> {
   }
 
   @bind
-  private editScale() {
+  private onRotateClick() {
+    const { inputProcessorState } = this.props;
+    if (!inputProcessorState) return;
+
+    const newState = cleanSet(
+      inputProcessorState,
+      'rotate.rotate',
+      (inputProcessorState.rotate.rotate + 90) % 360,
+    );
+
+    this.props.onInputProcessorChange(newState);
+  }
+
+  @bind
+  private onScaleValueFocus() {
     this.setState({ editingScale: true }, () => {
-      if (this.scaleInput) this.scaleInput.focus();
+      if (this.scaleInput) {
+        // Firefox unfocuses the input straight away unless I force a style calculation here. I have
+        // no idea why, but it's late and I'm quite tired.
+        getComputedStyle(this.scaleInput).transform;
+        this.scaleInput.focus();
+      }
     });
   }
 
   @bind
-  private cancelEditScale() {
+  private onScaleInputBlur() {
     this.setState({ editingScale: false });
   }
 
@@ -172,23 +235,34 @@ export default class Output extends Component<Props, State> {
     const clonedEvent = new (event.constructor as typeof Event)(event.type, event);
     this.retargetedEvents.add(clonedEvent);
     this.pinchZoomLeft.dispatchEvent(clonedEvent);
+
+    // Unfocus any active element on touchend. This fixes an issue on (at least) Android Chrome,
+    // where the software keyboard is hidden, but the input remains focused, then after interaction
+    // with this element the keyboard reappears for NO GOOD REASON. Thanks Android.
+    if (
+      event.type === 'touchend' &&
+      document.activeElement &&
+      document.activeElement instanceof HTMLElement
+    ) {
+      document.activeElement.blur();
+    }
   }
 
   render(
-    {
-      orientation, leftCompressed, rightCompressed, leftImgContain, rightImgContain,
-      originalImage,
-    }: Props,
+    { mobileView, leftImgContain, rightImgContain, source, onBack }: Props,
     { scale, editingScale, altBackground }: State,
   ) {
     const leftDraw = this.leftDrawable();
     const rightDraw = this.rightDrawable();
+    // To keep position stable, the output is put in a square using the longest dimension.
+    const originalImage = source && source.processed;
 
     return (
       <div class={`${style.output} ${altBackground ? style.altBackground : ''}`}>
         <two-up
           legacy-clip-compat
-          orientation={orientation}
+          class={style.twoUp}
+          orientation={mobileView ? 'vertical' : 'horizontal'}
           // Event redirecting. See onRetargetableEvent.
           onTouchStartCapture={this.onRetargetableEvent}
           onTouchEndCapture={this.onRetargetableEvent}
@@ -198,11 +272,12 @@ export default class Output extends Component<Props, State> {
           onWheelCapture={this.onRetargetableEvent}
         >
           <pinch-zoom
+            class={style.pinchZoom}
             onChange={this.onPinchZoomLeftChange}
             ref={linkRef(this, 'pinchZoomLeft')}
           >
             <canvas
-              class={style.outputCanvas}
+              class={style.pinchTarget}
               ref={linkRef(this, 'canvasLeft')}
               width={leftDraw && leftDraw.width}
               height={leftDraw && leftDraw.height}
@@ -213,9 +288,9 @@ export default class Output extends Component<Props, State> {
               }}
             />
           </pinch-zoom>
-          <pinch-zoom ref={linkRef(this, 'pinchZoomRight')}>
+          <pinch-zoom class={style.pinchZoom} ref={linkRef(this, 'pinchZoomRight')}>
             <canvas
-              class={style.outputCanvas}
+              class={style.pinchTarget}
               ref={linkRef(this, 'canvasRight')}
               width={rightDraw && rightDraw.width}
               height={rightDraw && rightDraw.height}
@@ -228,8 +303,14 @@ export default class Output extends Component<Props, State> {
           </pinch-zoom>
         </two-up>
 
+        <div class={style.back}>
+          <button class={style.button} onClick={onBack}>
+            <BackIcon />
+          </button>
+        </div>
+
         <div class={style.controls}>
-          <div class={style.group}>
+          <div class={style.zoomControls}>
             <button class={style.button} onClick={this.zoomOut}>
               <RemoveIcon />
             </button>
@@ -243,11 +324,11 @@ export default class Output extends Component<Props, State> {
                 class={style.zoom}
                 value={Math.round(scale * 100)}
                 onInput={this.onScaleInputChanged}
-                onBlur={this.cancelEditScale}
+                onBlur={this.onScaleInputBlur}
               />
             ) : (
-              <span class={style.zoom} tabIndex={0} onFocus={this.editScale}>
-                <strong>{Math.round(scale * 100)}</strong>
+              <span class={style.zoom} tabIndex={0} onFocus={this.onScaleValueFocus}>
+                <span class={style.zoomValue}>{Math.round(scale * 100)}</span>
                 %
               </span>
             )}
@@ -255,10 +336,21 @@ export default class Output extends Component<Props, State> {
               <AddIcon />
             </button>
           </div>
-          <button class={style.button} onClick={this.toggleBackground}>
-            <ToggleIcon />
-            Toggle Background
-          </button>
+          <div class={style.buttonsNoWrap}>
+            <button class={style.button} onClick={this.onRotateClick} title="Rotate image">
+              <RotateIcon />
+            </button>
+            <button
+              class={`${style.button} ${altBackground ? style.active : ''}`}
+              onClick={this.toggleBackground}
+              title="Change canvas color"
+            >
+              {altBackground
+                ? <ToggleBackgroundActiveIcon />
+                : <ToggleBackgroundIcon />
+              }
+            </button>
+          </div>
         </div>
       </div>
     );

src/components/Output/style.scss

@@ -1,135 +1,82 @@
-/*
-Note: These styles are temporary. They will be replaced before going live.
-*/
-
-%fill {
-  position: absolute;
-  left: 0;
-  top: 0;
-  width: 100%;
-  height: 100%;
-  overflow: hidden;
-  contain: strict;
-}
-
 .output {
-  @extend %fill;
+  composes: abs-fill from '../../lib/util.scss';
 
-  &:before {
+  &::before {
     content: '';
-    @extend %fill;
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
     background: #000;
     opacity: 0;
     transition: opacity 500ms ease;
   }
-  &.altBackground:before {
-    opacity: .6;
-  }
 
-  > two-up {
-    @extend %fill;
-    --accent-color: var(--button-fg);
-
-    > pinch-zoom {
-      @extend %fill;
-      outline: none;
-      display: flex;
-      justify-content: center;
-      align-items: center;
-    }
+  &.alt-background::before {
+    opacity: 0.6;
   }
 }
 
+.two-up {
+  composes: abs-fill from '../../lib/util.scss';
+  --accent-color: var(--button-fg);
+}
+
+.pinch-zoom {
+  composes: abs-fill from '../../lib/util.scss';
+  outline: none;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+
+.pinch-target {
+  // This fixes a severe painting bug in Chrome.
+  // We should try to remove this once the issue is fixed.
+  // https://bugs.chromium.org/p/chromium/issues/detail?id=870222#c10
+  will-change: auto;
+  // Prevent the image becoming misshapen due to default flexbox layout.
+  flex-shrink: 0;
+}
+
 .controls {
   position: absolute;
   display: flex;
   justify-content: center;
-  left: 220px;
-  right: 220px;
-  bottom: 0;
-  padding: 9px;
+  top: 0;
+  left: 0;
+  right: 0;
+  padding: 9px 84px;
   overflow: hidden;
   flex-wrap: wrap;
   contain: content;
 
-  @media (max-width: 680px) {
-    top: 0;
-    bottom: auto;
-    left: 0;
-    right: 0;
+  // Allow clicks to fall through to the pinch zoom area
+  pointer-events: none;
+  & > * {
+    pointer-events: auto;
   }
 
-  > * {
-    z-index: 2;
+  @media (min-width: 860px) {
+    padding: 9px;
+    top: auto;
+    left: 320px;
+    right: 320px;
+    bottom: 0;
+    flex-wrap: wrap-reverse;
   }
+}
 
-  .group {
-    display: flex;
-  }
+.zoom-controls {
+  display: flex;
 
-  .button,
-  .zoom {
-    display: flex;
-    align-items: center;
-    flex: 0;
-    box-sizing: border-box;
-    height: 48px;
-    padding: 0 16px;
-    margin: 4px;
-    background-color: #fff;
-    border: 1px solid rgba(0,0,0,0.2);
-    border-radius: 5px;
-    line-height: 1;
-    font-size: 110%;
-    white-space: nowrap;
-
-    &:focus {
-      box-shadow: 0 0 0 2px var(--button-fg);
-      outline: none;
-      z-index: 1;
-    }
-  }
-
-  .button {
-    text-transform: uppercase;
-    color: var(--button-fg);
-    cursor: pointer;
-    text-indent: 6px;
-  }
-
-  .button:hover {
-    background-color: #eee;
-  }
-
-  .zoom {
-    flex: 0 0 6em;
-    color: #625E80;
-    font: inherit;
-    cursor: text;
-    width: 6em;
-    text-align: center;
-    justify-content: center;
-
-    &:focus {
-      box-shadow: inset 0 1px 4px rgba(0,0,0,0.2), 0 0 0 2px var(--button-fg);
-    }
-
-    strong {
-      position: relative;
-      top: 1px;
-      margin: 0 3px 0 0;
-      color: #888;
-      font-weight: normal;
-      border-bottom: 1px dashed #999;
-    }
-  }
-
-  .group > :not(:first-child) {
+  & :not(:first-child) {
     border-top-left-radius: 0;
     border-bottom-left-radius: 0;
     margin-left: 0;
   }
-  .group > :not(:last-child) {
+  & :not(:last-child) {
     margin-right: 0;
     border-right-width: 0;
     border-top-right-radius: 0;
@@ -137,6 +84,83 @@ Note: These styles are temporary. They will be replaced before going live.
   }
 }
 
-.output-canvas {
-  flex-shrink: 0;
+.button,
+.zoom {
+  display: flex;
+  align-items: center;
+  box-sizing: border-box;
+  margin: 4px;
+  background-color: #fff;
+  border: 1px solid rgba(0,0,0,0.2);
+  border-radius: 5px;
+  line-height: 1;
+  white-space: nowrap;
+  height: 36px;
+  padding: 0 8px;
+  cursor: pointer;
+
+  @media (min-width: 600px) {
+    height: 48px;
+    padding: 0 16px;
+  }
+
+  &:focus {
+    box-shadow: 0 0 0 2px var(--button-fg);
+    outline: none;
+    z-index: 1;
+  }
+}
+
+.button {
+  color: var(--button-fg);
+
+  &:hover {
+    background-color: #eee;
+  }
+
+  &.active {
+    background: #34B9EB;
+    color: #fff;
+
+    &:hover {
+      background: #32a3ce;
+    }
+  }
+}
+
+.zoom {
+  color: #625E80;
+  cursor: text;
+  width: 6em;
+  font: inherit;
+  text-align: center;
+  justify-content: center;
+
+  &:focus {
+    box-shadow: inset 0 1px 4px rgba(0,0,0,0.2), 0 0 0 2px var(--button-fg);
+  }
+}
+
+.zoom-value {
+  position: relative;
+  top: 1px;
+  margin: 0 3px 0 0;
+  color: #888;
+  border-bottom: 1px dashed #999;
+}
+
+.back {
+  position: absolute;
+  top: 0;
+  left: 0;
+  padding: 9px;
+}
+
+.buttons-no-wrap {
+  display: flex;
+  pointer-events: none;
+
+  & > * {
+    pointer-events: auto;
+  }
 }

src/components/checkbox/index.tsx

@@ -0,0 +1,20 @@
+import { h, Component } from 'preact';
+import * as style from './style.scss';
+import { UncheckedIcon, CheckedIcon } from '../../lib/icons';
+
+interface Props extends JSX.HTMLAttributes {}
+interface State {}
+
+export default class Checkbox extends Component<Props, State> {
+  render(props: Props) {
+    return (
+      <div class={style.checkbox}>
+        {props.checked
+          ? <CheckedIcon class={`${style.icon} ${style.checked}`} />
+          : <UncheckedIcon class={style.icon} />
+        }
+        <input class={style.realCheckbox} type="checkbox" {...props}/>
+      </div>
+    );
+  }
+}

src/components/checkbox/style.scss

@@ -0,0 +1,22 @@
+.checkbox {
+  display: inline-block;
+  position: relative;
+  --size: 17px;
+}
+
+.real-checkbox {
+  top: 0;
+  position: absolute;
+  opacity: 0;
+  pointer-events: none;
+}
+
+.icon {
+  display: block;
+  width: var(--size);
+  height: var(--size);
+}
+
+.checked {
+  fill: #34B9EB;
+}

src/components/compress/custom-els/MultiPanel/index.ts

@@ -1,19 +1,75 @@
-import './styles.css';
+import * as style from './styles.css';
+import { transitionHeight } from '../../../../lib/util';
 
-function getClosestHeading(el: Element) {
-  const closestEl = el.closest('multi-panel > *');
-  if (closestEl && closestEl.classList.contains('panel-heading')) {
-    return closestEl;
+interface CloseAllOptions {
+  exceptFirst?: boolean;
+}
+
+const openOneOnlyAttr = 'open-one-only';
+
+function getClosestHeading(el: Element): HTMLElement | undefined {
+  // Look for the child of multi-panel, but stop at interactive elements like links & buttons
+  const closestEl = el.closest('multi-panel > *, a, button');
+  if (closestEl && closestEl.classList.contains(style.panelHeading)) {
+    return closestEl as HTMLElement;
   }
   return undefined;
 }
 
+async function close(heading: HTMLElement) {
+  const content = heading.nextElementSibling as HTMLElement;
+
+  // if there is no content, nothing to expand
+  if (!content) return;
+
+  const from = content.getBoundingClientRect().height;
+
+  heading.removeAttribute('content-expanded');
+  content.setAttribute('aria-expanded', 'false');
+
+  // Wait a microtask so other calls to open/close can get the final sizes.
+  await null;
+
+  await transitionHeight(content, {
+    from,
+    to: 0,
+    duration: 300,
+  });
+
+  content.style.height = '';
+}
+
+async function open(heading: HTMLElement) {
+  const content = heading.nextElementSibling as HTMLElement;
+
+  // if there is no content, nothing to expand
+  if (!content) return;
+
+  const from = content.getBoundingClientRect().height;
+
+  heading.setAttribute('content-expanded', '');
+  content.setAttribute('aria-expanded', 'true');
+
+  const to = content.getBoundingClientRect().height;
+
+  // Wait a microtask so other calls to open/close can get the final sizes.
+  await null;
+
+  await transitionHeight(content, {
+    from, to,
+    duration: 300,
+  });
+
+  content.style.height = '';
+}
+
 /**
  * A multi-panel view that the user can add any number of 'panels'.
  * 'a panel' consists of two elements. Even index element becomes heading,
  * and odd index element becomes the expandable content.
  */
 export default class MultiPanel extends HTMLElement {
+  static get observedAttributes() { return [openOneOnlyAttr]; }
 
   constructor() {
     super();
@@ -31,17 +87,23 @@ export default class MultiPanel extends HTMLElement {
     this._childrenChange();
   }
 
+  attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null) {
+    if (name === openOneOnlyAttr && newValue === null) {
+      this._closeAll({ exceptFirst: true });
+    }
+  }
+
   // Click event handler
   private _onClick(event: MouseEvent) {
-    const el = event.target as Element;
+    const el = event.target as HTMLElement;
     const heading = getClosestHeading(el);
     if (!heading) return;
-    this._expand(heading);
+    this._toggle(heading);
   }
 
   // KeyDown event handler
   private _onKeyDown(event: KeyboardEvent) {
-    const selectedEl = document.activeElement;
+    const selectedEl = document.activeElement!;
     const heading = getClosestHeading(selectedEl);
 
     // if keydown event is not on heading element, ignore
@@ -53,7 +115,8 @@ export default class MultiPanel extends HTMLElement {
     // don’t handle modifier shortcuts used by assistive technology.
     if (event.altKey) return;
 
-    let newHeading:HTMLElement | undefined;
+    let newHeading: HTMLElement | undefined;
+
     switch (event.key) {
       case 'ArrowLeft':
       case 'ArrowUp':
@@ -77,7 +140,7 @@ export default class MultiPanel extends HTMLElement {
       case 'Enter':
       case ' ':
       case 'Spacebar':
-        this._expand(heading);
+        this._toggle(heading);
         break;
 
       // Any other key press is ignored and passed back to the browser.
@@ -93,26 +156,32 @@ export default class MultiPanel extends HTMLElement {
     }
   }
 
-  private _expand(heading: Element) {
+  private _toggle(heading: HTMLElement) {
     if (!heading) return;
-    const content = heading.nextElementSibling;
-
-    // if there is no content, nothing to expand
-    if (!content) return;
 
     // toggle expanded and aria-expanded attributes
-    if (content.hasAttribute('expanded')) {
-      content.removeAttribute('expanded');
-      content.setAttribute('aria-expanded', 'false');
+    if (heading.hasAttribute('content-expanded')) {
+      close(heading);
     } else {
-      content.setAttribute('expanded', '');
-      content.setAttribute('aria-expanded', 'true');
+      if (this.openOneOnly) this._closeAll();
+      open(heading);
     }
   }
 
+  private _closeAll(options: CloseAllOptions = {}): void {
+    const { exceptFirst = false } = options;
+    let els = [...this.children].filter(el => el.matches('[content-expanded]')) as HTMLElement[];
+
+    if (exceptFirst) {
+      els = els.slice(1);
+    }
+
+    for (const el of els) close(el);
+  }
+
   // children of multi-panel should always be even number (heading/content pair)
   private _childrenChange() {
-    let preserveTabIndex : boolean = false;
+    let preserveTabIndex = false;
     let heading = this.firstElementChild;
 
     while (heading) {
@@ -123,31 +192,23 @@ export default class MultiPanel extends HTMLElement {
       // it means it has odd number of elements. log error and set heading to end the loop.
       if (!content) {
         console.error('<multi-panel> requires an even number of element children.');
-        heading = null;
-        continue;
+        break;
       }
 
       // When odd number of elements were inserted in the middle,
       // what was heading before may become content after the insertion.
       // Remove classes and attributes to prepare for this change.
-      heading.classList.remove('panel-content');
-
-      if (content.classList.contains('panel-heading')) {
-        content.classList.remove('panel-heading');
-      }
-      if (heading.hasAttribute('expanded') && heading.hasAttribute('aria-expanded')) {
-        heading.removeAttribute('expanded');
-        heading.removeAttribute('aria-expanded');
-      }
+      heading.classList.remove(style.panelContent);
+      content.classList.remove(style.panelHeading);
+      heading.removeAttribute('aria-expanded');
+      heading.removeAttribute('content-expanded');
 
       // If appreciable, remove tabindex from content which used to be header.
-      if (content.hasAttribute('tabindex')) {
-        content.removeAttribute('tabindex');
-      }
+      content.removeAttribute('tabindex');
 
       // Assign heading and content classes
-      heading.classList.add('panel-heading');
-      content.classList.add('panel-content');
+      heading.classList.add(style.panelHeading);
+      content.classList.add(style.panelContent);
 
       // Assign ids and aria-X for heading/content pair.
       heading.id = `panel-heading-${randomId}`;
@@ -163,6 +224,13 @@ export default class MultiPanel extends HTMLElement {
         heading.setAttribute('tabindex', '-1');
       }
 
+      // It's possible that the heading & content expanded attributes are now out of sync. Resync
+      // them using the heading as the source of truth.
+      content.setAttribute(
+        'aria-expanded',
+        heading.hasAttribute('content-expanded') ? 'true' : 'false',
+      );
+
       // next sibling of content = next heading
       heading = content.nextElementSibling;
     }
@@ -171,6 +239,9 @@ export default class MultiPanel extends HTMLElement {
     if (!preserveTabIndex && this.firstElementChild) {
       this.firstElementChild.setAttribute('tabindex', '0');
     }
+
+    // In case we're openOneOnly, and an additional open item has been added:
+    if (this.openOneOnly) this._closeAll({ exceptFirst: true });
   }
 
   // returns heading that is before currently selected one.
@@ -181,8 +252,8 @@ export default class MultiPanel extends HTMLElement {
       return this.firstElementChild as HTMLElement;
     }
     // previous Element of active Element is previous Content,
-    // previous Element of previous Content  is previousHeading
-    const previousContent = document.activeElement.previousElementSibling;
+    // previous Element of previous Content is previousHeading
+    const previousContent = document.activeElement!.previousElementSibling;
     if (previousContent) {
       return previousContent.previousElementSibling as HTMLElement;
     }
@@ -192,7 +263,7 @@ export default class MultiPanel extends HTMLElement {
   private _nextHeading() {
     // activeElement would be the currently selected heading
     // 2 elemements after that would be the next heading.
-    const nextContent = document.activeElement.nextElementSibling;
+    const nextContent = document.activeElement!.nextElementSibling;
     if (nextContent) {
       return nextContent.nextElementSibling as HTMLElement;
     }
@@ -208,7 +279,7 @@ export default class MultiPanel extends HTMLElement {
   private _lastHeading() {
     // if the last element is heading, return last element
     const lastEl = this.lastElementChild as HTMLElement;
-    if (lastEl && lastEl.classList.contains('panel-heading')) {
+    if (lastEl && lastEl.classList.contains(style.panelHeading)) {
       return lastEl;
     }
     // otherwise return 2nd from the last
@@ -217,6 +288,21 @@ export default class MultiPanel extends HTMLElement {
       return lastContent.previousElementSibling as HTMLElement;
     }
   }
+
+  /**
+   * If true, only one panel can be open at once. When one opens, others close.
+   */
+  get openOneOnly() {
+    return this.hasAttribute(openOneOnlyAttr);
+  }
+
+  set openOneOnly(val: boolean) {
+    if (val) {
+      this.setAttribute(openOneOnlyAttr, '');
+    } else {
+      this.removeAttribute(openOneOnlyAttr);
+    }
+  }
 }
 
 customElements.define('multi-panel', MultiPanel);

src/components/compress/custom-els/MultiPanel/missing-types.d.ts

@@ -0,0 +1,9 @@
+interface MultiPanelAttributes extends JSX.HTMLAttributes {
+  'open-one-only'?: boolean;
+}
+
+declare namespace JSX {
+  interface IntrinsicElements {
+    'multi-panel': MultiPanelAttributes;
+  }
+}

src/components/compress/custom-els/MultiPanel/styles.css

@@ -0,0 +1,10 @@
+.panel-heading {
+  background: gray;
+}
+.panel-content {
+  height: 0px;
+  overflow: auto;
+}
+.panel-content[aria-expanded=true] {
+  height: auto;
+}

src/components/compress/index.tsx

@@ -24,32 +24,40 @@ import {
     EncoderOptions,
     encoderMap,
 } from '../../codecs/encoders';
-
 import {
   PreprocessorState,
   defaultPreprocessorState,
 } from '../../codecs/preprocessors';
-
 import { decodeImage } from '../../codecs/decoders';
 import { cleanMerge, cleanSet } from '../../lib/clean-modify';
 import Processor from '../../codecs/processor';
 import { VectorResizeOptions, BitmapResizeOptions } from '../../codecs/resize/processor-meta';
-
-type Orientation = 'horizontal' | 'vertical';
+import './custom-els/MultiPanel';
+import Results from '../results';
+import { ExpandIcon, CopyAcrossIconProps } from '../../lib/icons';
+import SnackBarElement from '../../lib/SnackBar';
+import { InputProcessorState, defaultInputProcessorState } from '../../codecs/input-processors';
 
 export interface SourceImage {
   file: File | Fileish;
-  data: ImageData;
+  decoded: ImageData;
+  processed: ImageData;
   vectorImage?: HTMLImageElement;
+  inputProcessorState: InputProcessorState;
 }
 
-interface EncodedImage {
+interface SideSettings {
+  preprocessorState: PreprocessorState;
+  encoderState: EncoderState;
+}
+
+interface Side {
   preprocessed?: ImageData;
   file?: Fileish;
   downloadUrl?: string;
   data?: ImageData;
-  preprocessorState: PreprocessorState;
-  encoderState: EncoderState;
+  latestSettings: SideSettings;
+  encodedSettings?: SideSettings;
   loading: boolean;
   /** Counter of the latest bmp currently encoding */
   loadingCounter: number;
@@ -59,27 +67,45 @@ interface EncodedImage {
 
 interface Props {
   file: File | Fileish;
-  onError: (msg: string) => void;
+  showSnack: SnackBarElement['showSnackbar'];
+  onBack: () => void;
 }
 
 interface State {
   source?: SourceImage;
-  images: [EncodedImage, EncodedImage];
+  sides: [Side, Side];
+  /** Source image load */
   loading: boolean;
+  loadingCounter: number;
   error?: string;
-  orientation: Orientation;
+  mobileView: boolean;
 }
 
 interface UpdateImageOptions {
   skipPreprocessing?: boolean;
 }
 
+async function processInput(
+  data: ImageData,
+  inputProcessData: InputProcessorState,
+  processor: Processor,
+) {
+  let processedData = data;
+
+  if (inputProcessData.rotate.rotate !== 0) {
+    processedData = await processor.rotate(processedData, inputProcessData.rotate);
+  }
+
+  return processedData;
+}
+
 async function preprocessImage(
   source: SourceImage,
   preprocessData: PreprocessorState,
   processor: Processor,
 ): Promise<ImageData> {
-  let result = source.data;
+  let result = source.processed;
+
   if (preprocessData.resize.enabled) {
     if (preprocessData.resize.method === 'vector' && source.vectorImage) {
       result = processor.vectorResize(
@@ -128,6 +154,26 @@ async function compressImage(
   );
 }
 
+function stateForNewSourceData(state: State, newSource: SourceImage): State {
+  let newState = { ...state };
+
+  for (const i of [0, 1]) {
+    // Ditch previous encodings
+    const downloadUrl = state.sides[i].downloadUrl;
+    if (downloadUrl) URL.revokeObjectURL(downloadUrl!);
+
+    newState = cleanMerge(state, `sides.${i}`, {
+      preprocessed: undefined,
+      file: undefined,
+      downloadUrl: undefined,
+      data: undefined,
+      encodedSettings: undefined,
+    });
+  }
+
+  return newState;
+}
+
 async function processSvg(blob: Blob): Promise<HTMLImageElement> {
   // Firefox throws if you try to draw an SVG to canvas that doesn't have width/height.
   // In Chrome it loads, but drawImage behaves weirdly.
@@ -135,7 +181,7 @@ async function processSvg(blob: Blob): Promise<HTMLImageElement> {
   const parser = new DOMParser();
   const text = await blobToText(blob);
   const document = parser.parseFromString(text, 'image/svg+xml');
-  const svg = document.documentElement;
+  const svg = document.documentElement!;
 
   if (svg.hasAttribute('width') && svg.hasAttribute('height')) {
     return blobToImg(blob);
@@ -153,29 +199,42 @@ async function processSvg(blob: Blob): Promise<HTMLImageElement> {
   return blobToImg(new Blob([newSource], { type: 'image/svg+xml' }));
 }
 
+// These are only used in the mobile view
+const resultTitles = ['Top', 'Bottom'];
+// These are only used in the desktop view
+const buttonPositions =
+  ['download-left', 'download-right'] as ('download-left' | 'download-right')[];
+
+const originalDocumentTitle = document.title;
+
 export default class Compress extends Component<Props, State> {
-  widthQuery = window.matchMedia('(min-width: 500px)');
+  widthQuery = window.matchMedia('(max-width: 599px)');
 
   state: State = {
     source: undefined,
     loading: false,
-    images: [
+    loadingCounter: 0,
+    sides: [
       {
-        preprocessorState: defaultPreprocessorState,
-        encoderState: { type: identity.type, options: identity.defaultOptions },
+        latestSettings: {
+          preprocessorState: defaultPreprocessorState,
+          encoderState: { type: identity.type, options: identity.defaultOptions },
+        },
         loadingCounter: 0,
         loadedCounter: 0,
         loading: false,
       },
       {
-        preprocessorState: defaultPreprocessorState,
-        encoderState: { type: mozJPEG.type, options: mozJPEG.defaultOptions },
+        latestSettings: {
+          preprocessorState: defaultPreprocessorState,
+          encoderState: { type: mozJPEG.type, options: mozJPEG.defaultOptions },
+        },
         loadingCounter: 0,
         loadedCounter: 0,
         loading: false,
       },
     ],
-    orientation: this.widthQuery.matches ? 'horizontal' : 'vertical',
+    mobileView: this.widthQuery.matches,
   };
 
   private readonly encodeCache = new ResultCache();
@@ -186,16 +245,18 @@ export default class Compress extends Component<Props, State> {
     super(props);
     this.widthQuery.addListener(this.onMobileWidthChange);
     this.updateFile(props.file);
+
+    import('../../lib/offliner').then(({ mainAppLoaded }) => mainAppLoaded());
   }
 
   @bind
   private onMobileWidthChange() {
-    this.setState({ orientation: this.widthQuery.matches ? 'horizontal' : 'vertical' });
+    this.setState({ mobileView: this.widthQuery.matches });
   }
 
   private onEncoderTypeChange(index: 0 | 1, newType: EncoderType): void {
     this.setState({
-      images: cleanSet(this.state.images, `${index}.encoderState`, {
+      sides: cleanSet(this.state.sides, `${index}.latestSettings.encoderState`, {
         type: newType,
         options: encoderMap[newType].defaultOptions,
       }),
@@ -204,37 +265,50 @@ export default class Compress extends Component<Props, State> {
 
   private onPreprocessorOptionsChange(index: 0 | 1, options: PreprocessorState): void {
     this.setState({
-      images: cleanSet(this.state.images, `${index}.preprocessorState`, options),
+      sides: cleanSet(this.state.sides, `${index}.latestSettings.preprocessorState`, options),
     });
   }
 
   private onEncoderOptionsChange(index: 0 | 1, options: EncoderOptions): void {
     this.setState({
-      images: cleanSet(this.state.images, `${index}.encoderState.options`, options),
+      sides: cleanSet(this.state.sides, `${index}.latestSettings.encoderState.options`, options),
     });
   }
 
+  private updateDocumentTitle(filename: string = ''): void {
+    document.title = filename ? `${filename} - ${originalDocumentTitle}` : originalDocumentTitle;
+  }
+
   componentWillReceiveProps(nextProps: Props): void {
     if (nextProps.file !== this.props.file) {
       this.updateFile(nextProps.file);
     }
   }
 
-  componentDidUpdate(prevProps: Props, prevState: State): void {
-    const { source, images } = this.state;
+  componentWillUnmount(): void {
+    this.updateDocumentTitle();
+  }
 
-    for (const [i, image] of images.entries()) {
-      const prevImage = prevState.images[i];
-      const sourceChanged = source !== prevState.source;
-      const encoderChanged = image.encoderState !== prevImage.encoderState;
-      const preprocessorChanged = image.preprocessorState !== prevImage.preprocessorState;
+  componentDidUpdate(prevProps: Props, prevState: State): void {
+    const { source, sides } = this.state;
+
+    const sourceDataChanged =
+      // Has the source object become set/unset?
+      !!source !== !!prevState.source ||
+      // Or has the processed data changed?
+      (source && prevState.source && source.processed !== prevState.source.processed);
+
+    for (const [i, side] of sides.entries()) {
+      const prevSettings = prevState.sides[i].latestSettings;
+      const encoderChanged = side.latestSettings.encoderState !== prevSettings.encoderState;
+      const preprocessorChanged =
+        side.latestSettings.preprocessorState !== prevSettings.preprocessorState;
 
       // The image only needs updated if the encoder/preprocessor settings have changed, or the
       // source has changed.
-      if (sourceChanged || encoderChanged || preprocessorChanged) {
-        if (prevImage.downloadUrl) URL.revokeObjectURL(prevImage.downloadUrl);
+      if (sourceDataChanged || encoderChanged || preprocessorChanged) {
         this.updateImage(i, {
-          skipPreprocessing: !sourceChanged && !preprocessorChanged,
+          skipPreprocessing: !sourceDataChanged && !preprocessorChanged,
         }).catch((err) => {
           console.error(err);
         });
@@ -242,24 +316,92 @@ export default class Compress extends Component<Props, State> {
     }
   }
 
-  private onCopyToOtherClick(index: 0 | 1) {
+  private async onCopyToOtherClick(index: 0 | 1) {
     const otherIndex = (index + 1) % 2;
+    const oldSettings = this.state.sides[otherIndex];
 
     this.setState({
-      images: cleanSet(this.state.images, otherIndex, this.state.images[index]),
+      sides: cleanSet(this.state.sides, otherIndex, this.state.sides[index]),
+    });
+
+    const result = await this.props.showSnack('Settings copied across', {
+      timeout: 5000,
+      actions: ['undo', 'dismiss'],
+    });
+
+    if (result !== 'undo') return;
+
+    this.setState({
+      sides: cleanSet(this.state.sides, otherIndex, oldSettings),
     });
   }
 
   @bind
-  private async updateFile(file: File | Fileish) {
-    this.setState({ loading: true });
+  private async onInputProcessorChange(options: InputProcessorState): Promise<void> {
+    const source = this.state.source;
+    if (!source) return;
+
+    const oldRotate = source.inputProcessorState.rotate.rotate;
+    const newRotate = options.rotate.rotate;
+    const orientationChanged = oldRotate % 180 !== newRotate % 180;
+    const loadingCounter = this.state.loadingCounter + 1;
+    // Either processor is good enough here.
+    const processor = this.leftProcessor;
+
+    this.setState({
+      loadingCounter, loading: true,
+      source: cleanSet(source, 'inputProcessorState', options),
+    });
 
     // Abort any current encode jobs, as they're redundant now.
     this.leftProcessor.abortCurrent();
     this.rightProcessor.abortCurrent();
 
     try {
-      let data: ImageData;
+      const processed = await processInput(source.decoded, options, processor);
+
+      // Another file has been opened/processed before this one processed.
+      if (this.state.loadingCounter !== loadingCounter) return;
+
+      let newState = { ...this.state, loading: false };
+      newState = cleanSet(newState, 'source.processed', processed);
+      newState = stateForNewSourceData(newState, newState.source!);
+
+      if (orientationChanged) {
+        // If orientation has changed, we should flip the resize values.
+        for (const i of [0, 1]) {
+          const resizeSettings = newState.sides[i].latestSettings.preprocessorState.resize;
+          newState = cleanMerge(newState, `sides.${i}.latestSettings.preprocessorState.resize`, {
+            width: resizeSettings.height,
+            height: resizeSettings.width,
+          });
+        }
+      }
+      this.setState(newState);
+    } catch (err) {
+      if (err.name === 'AbortError') return;
+      console.error(err);
+      // Another file has been opened/processed before this one processed.
+      if (this.state.loadingCounter !== loadingCounter) return;
+      this.props.showSnack('Processing error');
+      this.setState({ loading: false });
+    }
+  }
+
+  @bind
+  private async updateFile(file: File | Fileish) {
+    const loadingCounter = this.state.loadingCounter + 1;
+    // Either processor is good enough here.
+    const processor = this.leftProcessor;
+
+    this.setState({ loadingCounter, loading: true });
+
+    // Abort any current encode jobs, as they're redundant now.
+    this.leftProcessor.abortCurrent();
+    this.rightProcessor.abortCurrent();
+
+    try {
+      let decoded: ImageData;
       let vectorImage: HTMLImageElement | undefined;
 
       // Special-case SVG. We need to avoid createImageBitmap because of
@@ -267,68 +409,75 @@ export default class Compress extends Component<Props, State> {
       // Also, we cache the HTMLImageElement so we can perform vector resizing later.
       if (file.type.startsWith('image/svg+xml')) {
         vectorImage = await processSvg(file);
-        data = drawableToImageData(vectorImage);
+        decoded = drawableToImageData(vectorImage);
       } else {
         // Either processor is good enough here.
-        data = await decodeImage(file, this.leftProcessor);
+        decoded = await decodeImage(file, processor);
       }
 
+      const processed = await processInput(decoded, defaultInputProcessorState, processor);
+
+      // Another file has been opened/processed before this one processed.
+      if (this.state.loadingCounter !== loadingCounter) return;
+
       let newState: State = {
         ...this.state,
-        source: { data, file, vectorImage },
+        source: {
+          decoded, file, vectorImage, processed,
+          inputProcessorState: defaultInputProcessorState,
+        },
         loading: false,
       };
 
+      newState = stateForNewSourceData(newState, newState.source!);
+
       for (const i of [0, 1]) {
-        // Ditch previous encodings
-        const downloadUrl = this.state.images[i].downloadUrl;
-        if (downloadUrl) URL.revokeObjectURL(downloadUrl!);
-
-        newState = cleanMerge(newState, `images.${i}`, {
-          preprocessed: undefined,
-          file: undefined,
-          downloadUrl: undefined,
-          data: undefined,
-        });
-
         // Default resize values come from the image:
-        newState = cleanMerge(newState, `images.${i}.preprocessorState.resize`, {
-          width: data.width,
-          height: data.height,
+        newState = cleanMerge(newState, `sides.${i}.latestSettings.preprocessorState.resize`, {
+          width: processed.width,
+          height: processed.height,
           method: vectorImage ? 'vector' : 'browser-high',
         });
       }
 
+      this.updateDocumentTitle(file.name);
       this.setState(newState);
     } catch (err) {
       if (err.name === 'AbortError') return;
       console.error(err);
-      this.props.onError('Invalid image');
+      // Another file has been opened/processed before this one processed.
+      if (this.state.loadingCounter !== loadingCounter) return;
+      this.props.showSnack('Invalid image');
       this.setState({ loading: false });
     }
   }
 
   private async updateImage(index: number, options: UpdateImageOptions = {}): Promise<void> {
-    const { skipPreprocessing = false } = options;
+    const {
+      skipPreprocessing = false,
+    } = options;
     const { source } = this.state;
     if (!source) return;
 
     // Each time we trigger an async encode, the counter changes.
-    const loadingCounter = this.state.images[index].loadingCounter + 1;
+    const loadingCounter = this.state.sides[index].loadingCounter + 1;
 
-    let images = cleanMerge(this.state.images, index, {
+    let sides = cleanMerge(this.state.sides, index, {
       loadingCounter,
       loading: true,
     });
 
-    this.setState({ images });
+    this.setState({ sides });
 
-    const image = images[index];
+    const side = sides[index];
+    const settings = side.latestSettings;
 
     let file: File | Fileish | undefined;
     let preprocessed: ImageData | undefined;
     let data: ImageData | undefined;
-    const cacheResult = this.encodeCache.match(source, image.preprocessorState, image.encoderState);
+    const cacheResult = this.encodeCache.match(
+      source.processed, settings.preprocessorState, settings.encoderState,
+    );
     const processor = (index === 0) ? this.leftProcessor : this.rightProcessor;
 
     // Abort anything the processor is currently doing.
@@ -341,83 +490,135 @@ export default class Compress extends Component<Props, State> {
     } else {
       try {
         // Special case for identity
-        if (image.encoderState.type === identity.type) {
-          ({ file, data } = source);
+        if (settings.encoderState.type === identity.type) {
+          file = source.file;
+          data = source.processed;
         } else {
-          preprocessed = (skipPreprocessing && image.preprocessed)
-            ? image.preprocessed
-            : await preprocessImage(source, image.preprocessorState, processor);
+          preprocessed = (skipPreprocessing && side.preprocessed)
+            ? side.preprocessed
+            : await preprocessImage(source, settings.preprocessorState, processor);
 
-          file = await compressImage(preprocessed, image.encoderState, source.file.name, processor);
+          file = await compressImage(
+            preprocessed, settings.encoderState, source.file.name, processor,
+          );
           data = await decodeImage(file, processor);
 
           this.encodeCache.add({
-            source,
             data,
             preprocessed,
             file,
-            encoderState: image.encoderState,
-            preprocessorState: image.preprocessorState,
+            sourceData: source.processed,
+            encoderState: settings.encoderState,
+            preprocessorState: settings.preprocessorState,
           });
         }
       } catch (err) {
         if (err.name === 'AbortError') return;
-        this.props.onError(`Processing error (type=${image.encoderState.type}): ${err}`);
+        this.props.showSnack(`Processing error (type=${settings.encoderState.type}): ${err}`);
         throw err;
       }
     }
 
-    const latestImage = this.state.images[index];
+    const latestData = this.state.sides[index];
     // If a later encode has landed before this one, return.
-    if (loadingCounter < latestImage.loadedCounter) {
+    if (loadingCounter < latestData.loadedCounter) {
       return;
     }
 
-    images = cleanMerge(this.state.images, index, {
+    if (latestData.downloadUrl) URL.revokeObjectURL(latestData.downloadUrl);
+
+    sides = cleanMerge(this.state.sides, index, {
       file,
       data,
       preprocessed,
       downloadUrl: URL.createObjectURL(file),
-      loading: images[index].loadingCounter !== loadingCounter,
+      loading: sides[index].loadingCounter !== loadingCounter,
       loadedCounter: loadingCounter,
+      encodedSettings: settings,
     });
 
-    this.setState({ images });
+    this.setState({ sides });
   }
 
-  render({ }: Props, { loading, images, source, orientation }: State) {
-    const [leftImage, rightImage] = images;
-    const [leftImageData, rightImageData] = images.map(i => i.data);
-    const anyLoading = loading || images.some(image => image.loading);
+  render({ onBack }: Props, { loading, sides, source, mobileView }: State) {
+    const [leftSide, rightSide] = sides;
+    const [leftImageData, rightImageData] = sides.map(i => i.data);
+
+    const options = sides.map((side, index) => (
+      <Options
+        source={source}
+        mobileView={mobileView}
+        preprocessorState={side.latestSettings.preprocessorState}
+        encoderState={side.latestSettings.encoderState}
+        onEncoderTypeChange={this.onEncoderTypeChange.bind(this, index)}
+        onEncoderOptionsChange={this.onEncoderOptionsChange.bind(this, index)}
+        onPreprocessorOptionsChange={this.onPreprocessorOptionsChange.bind(this, index)}
+      />
+    ));
+
+    const copyDirections =
+      (mobileView ? ['down', 'up'] : ['right', 'left']) as CopyAcrossIconProps['copyDirection'][];
+
+    const results = sides.map((side, index) => (
+      <Results
+        downloadUrl={side.downloadUrl}
+        imageFile={side.file}
+        source={source}
+        loading={loading || side.loading}
+        copyDirection={copyDirections[index]}
+        onCopyToOtherClick={this.onCopyToOtherClick.bind(this, index)}
+        buttonPosition={mobileView ? 'stack-right' : buttonPositions[index]}
+      >
+        {!mobileView ? null : [
+          <ExpandIcon class={style.expandIcon} key="expand-icon"/>,
+          `${resultTitles[index]} (${encoderMap[side.latestSettings.encoderState.type].label})`,
+        ]}
+      </Results>
+    ));
+
+    // For rendering, we ideally want the settings that were used to create the data, not the latest
+    // settings.
+    const leftDisplaySettings = leftSide.encodedSettings || leftSide.latestSettings;
+    const rightDisplaySettings = rightSide.encodedSettings || rightSide.latestSettings;
+    const leftImgContain = leftDisplaySettings.preprocessorState.resize.enabled &&
+      leftDisplaySettings.preprocessorState.resize.fitMethod === 'contain';
+    const rightImgContain = rightDisplaySettings.preprocessorState.resize.enabled &&
+      rightDisplaySettings.preprocessorState.resize.fitMethod === 'contain';
 
     return (
       <div class={style.compress}>
         <Output
-          originalImage={source && source.data}
-          orientation={orientation}
+          source={source}
+          mobileView={mobileView}
           leftCompressed={leftImageData}
           rightCompressed={rightImageData}
-          leftImgContain={leftImage.preprocessorState.resize.fitMethod === 'cover'}
-          rightImgContain={rightImage.preprocessorState.resize.fitMethod === 'cover'}
+          leftImgContain={leftImgContain}
+          rightImgContain={rightImgContain}
+          onBack={onBack}
+          inputProcessorState={source && source.inputProcessorState}
+          onInputProcessorChange={this.onInputProcessorChange}
         />
-        <div class={`${style.optionPair} ${style[orientation]}`}>
-          {images.map((image, index) => (
-            <Options
-              source={source}
-              orientation={orientation}
-              imageIndex={index}
-              imageFile={image.file}
-              downloadUrl={image.downloadUrl}
-              preprocessorState={image.preprocessorState}
-              encoderState={image.encoderState}
-              onEncoderTypeChange={this.onEncoderTypeChange.bind(this, index)}
-              onEncoderOptionsChange={this.onEncoderOptionsChange.bind(this, index)}
-              onPreprocessorOptionsChange={this.onPreprocessorOptionsChange.bind(this, index)}
-              onCopyToOtherClick={this.onCopyToOtherClick.bind(this, index)}
-            />
-          ))}
-        </div>
-        {anyLoading && <span style={{ position: 'fixed', top: 0, left: 0 }}>Loading...</span>}
+        {mobileView
+          ? (
+            <div class={style.options}>
+              <multi-panel class={style.multiPanel} open-one-only>
+                {results[0]}
+                {options[0]}
+                {results[1]}
+                {options[1]}
+              </multi-panel>
+            </div>
+          ) : ([
+            <div class={style.options} key="options0">
+              {options[0]}
+              {results[0]}
+            </div>,
+            <div class={style.options} key="options1">
+              {options[1]}
+              {results[1]}
+            </div>,
+          ])
+        }
       </div>
     );
   }

src/components/compress/result-cache.ts

@@ -1,7 +1,6 @@
 import { EncoderState } from '../../codecs/encoders';
 import { Fileish } from '../../lib/initial-util';
 import { shallowEqual } from '../../lib/util';
-import { SourceImage } from '.';
 import { PreprocessorState } from '../../codecs/preprocessors';
 
 import * as identity from '../../codecs/identity/encoder-meta';
@@ -15,7 +14,7 @@ interface CacheResult {
 interface CacheEntry extends CacheResult {
   preprocessorState: PreprocessorState;
   encoderState: EncoderState;
-  source: SourceImage;
+  sourceData: ImageData;
 }
 
 const SIZE = 5;
@@ -32,13 +31,13 @@ export default class ResultCache {
   }
 
   match(
-    source: SourceImage,
+    sourceData: ImageData,
     preprocessorState: PreprocessorState,
     encoderState: EncoderState,
   ): CacheResult | undefined {
     const matchingIndex = this._entries.findIndex((entry) => {
       // Check for quick exits:
-      if (entry.source !== source) return false;
+      if (entry.sourceData !== sourceData) return false;
       if (entry.encoderState.type !== encoderState.type) return false;
 
       // Check that each set of options in the preprocessor are the same

src/components/compress/style.scss

@@ -1,19 +1,74 @@
 .compress {
-  height: 100%;
-}
-
-.option-pair {
-  display: flex;
-  justify-content: flex-end;
   width: 100%;
   height: 100%;
+  contain: strict;
+  display: grid;
+  align-items: end;
+  align-content: end;
+  grid-template-rows: 1fr auto;
 
-  &.horizontal {
-    justify-content: space-between;
-    align-items: flex-end;
-  }
-
-  &.vertical {
-    flex-direction: column;
+  @media (min-width: 600px) {
+    grid-template-columns: 1fr auto;
+    grid-template-rows: 100%;
   }
 }
+
+.options {
+  color: #fff;
+  opacity: 0.9;
+  font-size: 1.2rem;
+  display: flex;
+  flex-flow: column;
+  max-width: 400px;
+  margin: 0 auto;
+  width: calc(100% - 60px);
+  max-height: calc(100% - 104px);
+  overflow: hidden;
+
+  @media (min-width: 600px) {
+    max-height: calc(100% - 75px);
+    width: 300px;
+    margin: 0;
+  }
+
+  @media (min-width: 860px) {
+    max-height: calc(100% - 40px);
+  }
+}
+
+.multi-panel {
+  position: relative;
+  display: flex;
+  flex-flow: column;
+
+  // Reorder so headings appear after content:
+  & > :nth-child(1) {
+    order: 2;
+    margin-bottom: 10px;
+  }
+
+  & > :nth-child(2) {
+    order: 1;
+  }
+
+  & > :nth-child(3) {
+    order: 4;
+  }
+
+  & > :nth-child(4) {
+    order: 3;
+  }
+}
+
+.expand-icon {
+  transform: rotate(180deg);
+  margin-left: -12px;
+}
+
+[content-expanded] .expand-icon {
+  transform: none;
+}
+
+:focus .expand-icon {
+  fill: #34B9EB;
+}

src/components/expander/index.tsx

@@ -0,0 +1,71 @@
+import { h, Component, ComponentChild, ComponentChildren } from 'preact';
+import * as style from './style.scss';
+import { transitionHeight } from '../../lib/util';
+
+interface Props {
+  children: ComponentChildren;
+}
+interface State {
+  outgoingChildren: ComponentChild[];
+}
+
+export default class Expander extends Component<Props, State> {
+  state: State = {
+    outgoingChildren: [],
+  };
+  private lastElHeight: number = 0;
+
+  componentWillReceiveProps(nextProps: Props) {
+    const children = this.props.children as ComponentChild[];
+    const nextChildren = nextProps.children as ComponentChild[];
+
+    if (!nextChildren[0] && children[0]) {
+      // Cache the current children for the shrink animation.
+      this.setState({ outgoingChildren: children });
+    }
+  }
+
+  componentWillUpdate(nextProps: Props) {
+    const children = this.props.children as ComponentChild[];
+    const nextChildren = nextProps.children as ComponentChild[];
+
+    // Only interested if going from empty to not-empty, or not-empty to empty.
+    if ((children[0] && nextChildren[0]) || (!children[0] && !nextChildren[0])) return;
+    this.lastElHeight = this.base!.getBoundingClientRect().height;
+  }
+
+  async componentDidUpdate(previousProps: Props) {
+    const children = this.props.children as ComponentChild[];
+    const previousChildren = previousProps.children as ComponentChild[];
+
+    // Only interested if going from empty to not-empty, or not-empty to empty.
+    if ((children[0] && previousChildren[0]) || (!children[0] && !previousChildren[0])) return;
+
+    // What height do we need to transition to?
+    this.base!.style.height = '';
+    this.base!.style.overflow = 'hidden';
+    const newHeight = children[0] ? this.base!.getBoundingClientRect().height : 0;
+
+    await transitionHeight(this.base!, {
+      duration: 300,
+      from: this.lastElHeight,
+      to: newHeight,
+    });
+
+    // Unset the height & overflow, so element changes do the right thing.
+    this.base!.style.height = '';
+    this.base!.style.overflow = '';
+    if (this.state.outgoingChildren[0]) this.setState({ outgoingChildren: [] });
+  }
+
+  render(props: Props, { outgoingChildren }: State) {
+    const children = props.children as ComponentChild[];
+    const childrenExiting = !children[0] && outgoingChildren[0];
+
+    return (
+      <div class={childrenExiting ? style.childrenExiting : ''}>
+        {children[0] ? children : outgoingChildren}
+      </div>
+    );
+  }
+}

src/components/expander/style.scss

@@ -0,0 +1,5 @@
+.children-exiting {
+  & > * {
+    pointer-events: none;
+  }
+}

src/components/intro/index.tsx

@@ -4,14 +4,15 @@ import { bind, linkRef, Fileish } from '../../lib/initial-util';
 import '../custom-els/LoadingSpinner';
 
 import logo from './imgs/logo.svg';
-import largePhoto from './imgs/demos/large-photo.jpg';
-import artwork from './imgs/demos/artwork.jpg';
-import deviceScreen from './imgs/demos/device-screen.png';
-import largePhotoIcon from './imgs/demos/large-photo-icon.jpg';
-import artworkIcon from './imgs/demos/artwork-icon.jpg';
-import deviceScreenIcon from './imgs/demos/device-screen-icon.jpg';
-import logoIcon from './imgs/demos/logo-icon.png';
+import largePhoto from './imgs/demos/demo-large-photo.jpg';
+import artwork from './imgs/demos/demo-artwork.jpg';
+import deviceScreen from './imgs/demos/demo-device-screen.png';
+import largePhotoIcon from './imgs/demos/icon-demo-large-photo.jpg';
+import artworkIcon from './imgs/demos/icon-demo-artwork.jpg';
+import deviceScreenIcon from './imgs/demos/icon-demo-device-screen.jpg';
+import logoIcon from './imgs/demos/icon-demo-logo.png';
 import * as style from './style.scss';
+import SnackBarElement from '../../lib/SnackBar';
 
 const demos = [
   {
@@ -42,7 +43,7 @@ const demos = [
 
 interface Props {
   onFile: (file: File | Fileish) => void;
-  onError: (error: string) => void;
+  showSnack: SnackBarElement['showSnackbar'];
 }
 interface State {
   fetchingDemoIndex?: number;
@@ -79,7 +80,7 @@ export default class Intro extends Component<Props, State> {
       this.props.onFile(file);
     } catch (err) {
       this.setState({ fetchingDemoIndex: undefined });
-      this.props.onError("Couldn't fetch demo image");
+      this.props.showSnack("Couldn't fetch demo image");
     }
   }
 
@@ -89,7 +90,7 @@ export default class Intro extends Component<Props, State> {
         <div>
           <div class={style.logoSizer}>
             <div class={style.logoContainer}>
-              <img src={logo} class={style.logo} alt="Squoosh" />
+              <img src={logo} class={style.logo} alt="Squoosh" decoding="async" />
             </div>
           </div>
           <p class={style.openImageGuide}>
@@ -110,7 +111,7 @@ export default class Intro extends Component<Props, State> {
                   <div class={style.demo}>
                     <div class={style.demoImgContainer}>
                       <div class={style.demoImgAspect}>
-                        <img class={style.demoIcon} src={demo.iconUrl} alt=""/>
+                        <img class={style.demoIcon} src={demo.iconUrl} alt="" decoding="async" />
                         {fetchingDemoIndex === i &&
                           <div class={style.demoLoading}>
                             <loading-spinner class={style.demoLoadingSpinner}/>
@@ -128,6 +129,11 @@ export default class Intro extends Component<Props, State> {
         <ul class={style.relatedLinks}>
           <li><a href="https://github.com/GoogleChromeLabs/squoosh/">View the code</a></li>
           <li><a href="https://github.com/GoogleChromeLabs/squoosh/issues">Report a bug</a></li>
+          <li>
+            <a href="https://github.com/GoogleChromeLabs/squoosh/blob/master/README.md#privacy">
+              Privacy
+            </a>
+          </li>
         </ul>
       </div>
     );

src/components/intro/style.scss

@@ -2,6 +2,7 @@
   font-family: 'intro-text';
   font-style: normal;
   font-weight: 300;
+  font-display: block;
   // This only contains the chars for "Drag & drop or"
   src: url('data:font/woff2;base64,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') format('woff2');
 }
@@ -10,6 +11,7 @@
   font-family: 'intro-text';
   font-style: normal;
   font-weight: 500;
+  font-display: block;
   // Only contains the chars for "select an image"
   src: url('data:font/woff2;base64,d09GMgABAAAAAAXMAA4AAAAACwQAAAV5AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGhYbg1IcMAZgAGwRCAqJUId/CxoAATYCJAMwBCAFgnAHIBskCcjEh6dNff8Ou/9Tj9VZGnUhJeqFzWGiVVOkxkTthr9f6kWkRdsBbkIj3YuLaloFZWr7aBg22z7IOoWqBWCW5cZU3GBrh0n+dAcBYAUlzYHAzWTYchqKXEyAT0zOLIS1qqm+B8q2ur4OhEMy0PHHUH8KklaSr8T0mp/EU7kRvXlI1E09HXA1qLN8Djxa0AsSDOg3cJARb9mtQJoSK3gvEn372/gcAigg/gOnbsT/MYv491GTReW4rJC5LA+h5FFclF6QQgoZ5Kx7GbsuGeytUgFClkOomY2Gdake3m9HegkHieAx/a0hBTALsy4jvpxBcnFXUnjC+2ZS5zHnDeEaJVwi+ZWqzOm4Uvgy4k6kGv4kFDVkfjk1gkVRRkk2zlo42PBbRJmG30cClJQjak7BnfQqHza4ITKftQZ/ZMUaEiyy1+mYCh4clKhDA5rQglZ0oG9jw+qiNvT+SfxIXCeuFdeIq8VV4gpxyRaGOl0JiChiCocfc7e93DwZIPvWgPiZJLcJugxyjW7UQyl4TJk6dWqYU7Cn0WQiWnNJCdGeprqjW63fpVS3mKy4YGZ6I3ya4nbIVgM1mwkpNEBzixlNxfPmH7owvdE4973OM9quvk11dwvnzDUy/Zn5S5Ywpn/PeqXBQI2m4lna05CRtsI6+GIENjS9K4jWRHUGYA2ozdZm2Smmf0DI3aqpeNbsJfxe7YdFmcZAn5gXLCFa2/Umqiu017APFhMZ0rfQp4sJX0ZrJ+n9UtAljr5VYWb6oj1MrpvX3qe6u8WRJg0bj7aPkDOa7m+E0Oa9Y8eY/gbRbr+efH7hcO49bMd28fbDVHcUmm3XkozQGKjeBHSJ4TQnI879LIFmF2v/BJuEQlffJPfE9oKayS/PsPE44fvM4MsBESxbuEEV39d5pw6oW4vD6S1WQC3UpSbHNbK0Jikl0bphSs+0CGW8Ew4Kzw7zarmcVz873JHTFhKYay18R8vY0ozPiHPAGyROAqlW5fLj5+HbWBn9TpgekKsOy8N+4dlFfL9i/Nk3+gY1bwzZUAvLVNiFpvqHRenetSoVrgn2obGtPsltEVxEeHJAQFhyBIcHT9rDvTJm06e0TLgase2gd2RffGJNg0o1zrdRyi9s1bYE5bi85cK+o/nUwvBR5+jweEBaSMoCub29fEFISmib9Dn5yl5kVFpoGrPQSmZhafQ7WimttNCH7Cktohb6kFpoEfIsdDF7SgvZTbaY3mKFyLXQh+wpzWE3mUNQQkWnR+lgiW9Afkunej49Nz3sYlI8XFTRdkNhUR5d6h4oOpJc8OjcItMXVqoHW2fSW6ycWuiM8NDYoICouLAZ9BYrwwmhycvKlt4Q8hUlCV5nZ7vOm2ut2rizcFpuWpSrT3K1Z3xinbuHnXBTyGAljV/XzHZaNGu6y7vLDziMpIyUdOBBRXXlxznUQiOoheZsZk9njG8er1mNmz2eOCQ3x9BbLP+Zxt+VrbEz9aWxmimRvyl4/sumyoM/nw+LNzV4/uP0/9T/P5f08cvhl38USAS/xTYs2fL/VNFF0vd+SVsRB/khPwW4SCi5SHhx8fDgVPAiAqIJRQL/EuK5bsRzNnAiezD1i7u2VyHHAKRU+E2YUaA5DUsE2ZfbApAmsJcxjBwmQ2Xk4Y2BqZJ+oxSzsNEogz1O3/xkBMKEBHSiC8PoQStaoEIflPCHL/wQBCUKoUITlMhHP+olt5ojykUPOrEQTWgY+f449KMPKnSiB72jGrLQhEZO24925LtbkG5DndTkD2/4um+NQBEyUIJsRBxX24tcDGmbWtGJjq05jhzTaMgCcR+6EA4f+KAXDay5u6RsL7xJsm3w3mzvFvggB8nI/AYBdVnxNvx/2wA=') format('woff2');
 }
@@ -19,7 +21,6 @@
 }
 
 .intro {
-  composes: abs-fill from '../../lib/util.scss';
   display: grid;
   grid-template-rows: 1fr min-content;
   align-items: center;
@@ -29,6 +30,9 @@
   -webkit-overflow-scrolling: touch;
   overflow: auto;
   padding: 20px 0 0;
+  height: 100%;
+  box-sizing: border-box;
+  overscroll-behavior: contain;
 }
 
 .logo-container {
@@ -38,16 +42,17 @@
 
 .logo-sizer {
   width: 90%;
-  max-width: 480px;
+  max-width: 52vh;
   margin: 0 auto;
 }
 
 .logo {
   composes: abs-fill from '../../lib/util.scss';
+  pointer-events: none;
 }
 
 .open-image-guide {
-  font: 300 11vw intro-text;
+  font: 300 11vw intro-text, sans-serif;
   margin-bottom: 0;
 
   @media (min-width: 460px) {
@@ -140,6 +145,7 @@
 
 .demo-icon {
   composes: abs-fill from '../../lib/util.scss';
+  pointer-events: none;
 }
 
 .demo-description {

src/components/output/custom-els/MultiPanel/styles.css

@@ -1,11 +0,0 @@
-multi-panel > .panel-heading {
-  background:gray;
-}
-multi-panel > .panel-content {
-  height:0px;
-  overflow:scroll;
-  transition: height 1s;
-}
-multi-panel > .panel-content[expanded] {
-  height:auto;
-}

src/components/range/index.tsx

@@ -0,0 +1,57 @@
+import { h, Component } from 'preact';
+import * as style from './style.scss';
+import RangeInputElement from '../../custom-els/RangeInput';
+import '../../custom-els/RangeInput';
+import { linkRef, bind } from '../../lib/initial-util';
+
+interface Props extends JSX.HTMLAttributes {}
+interface State {}
+
+export default class Range extends Component<Props, State> {
+  rangeWc?: RangeInputElement;
+
+  @bind
+  private onTextInput(event: Event) {
+    const input = event.target as HTMLInputElement;
+    const value = input.value.trim();
+    if (!value) return;
+    this.rangeWc!.value = input.value;
+    const { onInput } = this.props;
+    if (onInput) onInput(event);
+  }
+
+  render(props: Props) {
+    const {
+      children,
+      ...otherProps
+    } = props;
+
+    const {
+      value, min, max, step,
+    } = props;
+
+    return (
+      <label class={style.range}>
+        <span class={style.labelText}>{children}</span>
+        {/* On interaction, Safari gives focus to the first element in the label, so the
+        <range-input> is deliberately first. */}
+        <div class={style.rangeWcContainer}>
+          <range-input
+            ref={linkRef(this, 'rangeWc')}
+            class={style.rangeWc}
+            {...otherProps}
+          />
+        </div>
+        <input
+          type="number"
+          class={style.textInput}
+          value={value}
+          min={min}
+          max={max}
+          step={step}
+          onInput={this.onTextInput}
+        />
+      </label>
+    );
+  }
+}

src/components/range/style.scss

@@ -0,0 +1,55 @@
+.range {
+  position: relative;
+  z-index: 0;
+  display: grid;
+  grid-template-columns: 1fr auto;
+}
+
+.label-text {
+  color: #fff; /* TEMP */
+}
+
+.range-wc-container {
+  position: relative;
+  z-index: 1;
+  grid-row: 2 / 3;
+  grid-column: 1 / 3;
+}
+
+.range-wc {
+  width: 100%;
+}
+
+.text-input {
+  grid-row: 1 / 2;
+  grid-column: 2 / 3;
+
+  text-align: right;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  border: none;
+  padding: 2px 5px;
+  box-sizing: border-box;
+  text-decoration: underline;
+  text-decoration-style: dotted;
+  text-underline-position: under;
+  width: 48px;
+  position: relative;
+  left: 5px;
+
+  &:focus {
+    background: #fff;
+    color: #000;
+  }
+
+  // Remove the number controls
+  -moz-appearance: textfield;
+
+  &::-webkit-outer-spin-button,
+  &::-webkit-inner-spin-button {
+    -moz-appearance: none;
+    -webkit-appearance: none;
+    margin: 0;
+  }
+}

src/components/results/FileSize.tsx

@@ -0,0 +1,41 @@
+import { h, Component } from 'preact';
+import * as prettyBytes from 'pretty-bytes';
+import * as style from './style.scss';
+
+interface Props {
+  blob: Blob;
+  compareTo?: Blob;
+}
+
+interface State {}
+
+export default class FileSize extends Component<Props, State> {
+  render({ blob, compareTo }: Props) {
+    let comparison: JSX.Element | undefined;
+
+    if (compareTo) {
+      const delta = blob.size / compareTo.size;
+      if (delta > 1) {
+        const percent = Math.round((delta - 1) * 100) + '%';
+        comparison = (
+          <span class={`${style.sizeDelta} ${style.sizeIncrease}`}>
+            {percent === '0%' ? 'slightly' : percent} bigger
+          </span>
+        );
+      } else if (delta < 1) {
+        const percent = Math.round((1 - delta) * 100) + '%';
+        comparison = (
+          <span class={`${style.sizeDelta} ${style.sizeDecrease}`}>
+            {percent === '0%' ? 'slightly' : percent} smaller
+          </span>
+        );
+      } else {
+        comparison = (
+          <span class={style.sizeDelta}>no change</span>
+        );
+      }
+    }
+
+    return <span>{prettyBytes(blob.size)} {comparison}</span>;
+  }
+}

src/components/results/index.tsx

@@ -0,0 +1,121 @@
+import { h, Component, ComponentChildren, ComponentChild } from 'preact';
+
+import * as style from './style.scss';
+import FileSize from './FileSize';
+import { DownloadIcon, CopyAcrossIcon, CopyAcrossIconProps } from '../../lib/icons';
+import '../custom-els/LoadingSpinner';
+import { SourceImage } from '../compress';
+import { Fileish, bind } from '../../lib/initial-util';
+
+interface Props {
+  loading: boolean;
+  source?: SourceImage;
+  imageFile?: Fileish;
+  downloadUrl?: string;
+  children: ComponentChildren;
+  copyDirection: CopyAcrossIconProps['copyDirection'];
+  buttonPosition: keyof typeof buttonPositionClass;
+  onCopyToOtherClick(): void;
+}
+
+interface State {
+  showLoadingState: boolean;
+}
+
+const buttonPositionClass = {
+  'stack-right': style.stackRight,
+  'download-right': style.downloadRight,
+  'download-left': style.downloadLeft,
+};
+
+const loadingReactionDelay = 500;
+
+export default class Results extends Component<Props, State> {
+  state: State = {
+    showLoadingState: false,
+  };
+
+  /** The timeout ID between entering the loading state, and changing UI */
+  private loadingTimeoutId: number = 0;
+
+  componentDidUpdate(prevProps: Props, prevState: State) {
+    if (prevProps.loading && !this.props.loading) {
+      // Just stopped loading
+      clearTimeout(this.loadingTimeoutId);
+      this.setState({ showLoadingState: false });
+    } else if (!prevProps.loading && this.props.loading) {
+      // Just started loading
+      this.loadingTimeoutId = self.setTimeout(
+        () => this.setState({ showLoadingState: true }),
+        loadingReactionDelay,
+      );
+    }
+  }
+
+  @bind
+  private onCopyToOtherClick(event: Event) {
+    event.preventDefault();
+    this.props.onCopyToOtherClick();
+  }
+
+  @bind
+  onDownload() {
+    // GA can’t do floats. So we round to ints. We're deliberately rounding to nearest kilobyte to
+    // avoid cases where exact image sizes leak something interesting about the user.
+    const before = Math.round(this.props.source!.file.size / 1024);
+    const after = Math.round(this.props.imageFile!.size / 1024);
+    const change = Math.round(after / before * 1000);
+
+    ga('send', 'event', 'compression', 'download', {
+      metric1: before,
+      metric2: after,
+      metric3: change,
+    });
+  }
+
+  render(
+    { source, imageFile, downloadUrl, children, copyDirection, buttonPosition }: Props,
+    { showLoadingState }: State,
+  ) {
+
+    return (
+      <div class={`${style.results} ${buttonPositionClass[buttonPosition]}`}>
+        <div class={style.resultData}>
+          {(children as ComponentChild[])[0]
+            ? <div class={style.resultTitle}>{children}</div>
+            : null
+          }
+          {!imageFile || showLoadingState ? 'Working…' :
+            <FileSize
+              blob={imageFile}
+              compareTo={(source && imageFile !== source.file) ? source.file : undefined}
+            />
+          }
+        </div>
+
+        <button
+          class={style.copyToOther}
+          title="Copy settings to other side"
+          onClick={this.onCopyToOtherClick}
+        >
+          <CopyAcrossIcon class={style.copyIcon} copyDirection={copyDirection} />
+        </button>
+
+        <div class={style.download}>
+          {(downloadUrl && imageFile) && (
+            <a
+              class={`${style.downloadLink} ${showLoadingState ? style.downloadLinkDisable : ''}`}
+              href={downloadUrl}
+              download={imageFile.name}
+              title="Download"
+              onClick={this.onDownload}
+            >
+              <DownloadIcon class={style.downloadIcon} />
+            </a>
+          )}
+          {showLoadingState && <loading-spinner class={style.spinner} />}
+        </div>
+      </div>
+    );
+  }
+}

src/components/results/style.scss

@@ -0,0 +1,131 @@
+@keyframes action-enter {
+  from {
+    transform: rotate(-90deg);
+    opacity: 0;
+    animation-timing-function: ease-out;
+  }
+}
+
+@keyframes action-leave {
+  from {
+    transform: rotate(0deg);
+    opacity: 1;
+    animation-timing-function: ease-out;
+  }
+}
+
+.results {
+  display: grid;
+  grid-template-columns: [text] 1fr [copy-button] auto [download-button] auto;
+  background: rgba(0, 0, 0, 0.9);
+  font-size: 1rem;
+
+  @media (min-width: 400px) {
+    font-size: 1.2rem;
+  }
+
+  @media (min-width: 600px) {
+    font-size: 1.4rem;
+  }
+
+  &:focus {
+    outline: none;
+  }
+}
+
+.result-data {
+  grid-row: 1;
+  grid-column: text;
+  display: flex;
+  align-items: center;
+  padding: 0 10px;
+  white-space: nowrap;
+  overflow: hidden;
+}
+
+.download-right {
+  grid-template-columns: [copy-button] auto [text] 1fr [download-button] auto;
+}
+
+.download-left {
+  grid-template-columns: [download-button] auto [text] 1fr [copy-button] auto;
+}
+
+.stack-right {
+  & .result-data {
+    padding: 0 15px;
+  }
+}
+
+.result-title {
+  display: flex;
+  align-items: center;
+  margin-right: 0.4em;
+}
+
+.size-delta {
+  font-size: 0.8em;
+  font-style: italic;
+  position: relative;
+  top: -1px;
+  margin-left: 0.3em;
+}
+
+.size-increase {
+  color: #e35050;
+}
+
+.size-decrease {
+  color: #50e3c2;
+}
+
+.download {
+  grid-row: 1;
+  grid-column: download-button;
+  background: #34B9EB;
+  --size: 38px;
+  width: var(--size);
+  height: var(--size);
+  display: grid;
+  align-items: center;
+  justify-items: center;
+}
+
+.download-link {
+  animation: action-enter 0.2s;
+  grid-area: 1/1;
+}
+
+.download-link-disable {
+  pointer-events: none;
+  opacity: 0;
+  transform: rotate(90deg);
+  animation: action-leave 0.2s;
+}
+
+.download-icon,
+.copy-icon {
+  color: #fff;
+  display: block;
+  --size: 24px;
+  width: var(--size);
+  height: var(--size);
+  padding: 7px;
+  filter: drop-shadow(0 1px 0 rgba(0, 0, 0, 0.7));
+}
+
+.spinner {
+  --color: #fff;
+  --delay: 0;
+  --size: 22px;
+  grid-area: 1/1;
+}
+
+.copy-to-other {
+  grid-row: 1;
+  grid-column: copy-button;
+  composes: unbutton from '../../lib/util.scss';
+  composes: download;
+
+  background: #656565;
+}

src/components/select/index.tsx

@@ -0,0 +1,20 @@
+import { h, Component } from 'preact';
+import * as style from './style.scss';
+
+interface Props extends JSX.HTMLAttributes {
+  large?: boolean;
+}
+interface State {}
+
+export default class Select extends Component<Props, State> {
+  render(props: Props) {
+    const { large, ...otherProps } = props;
+
+    return (
+      <div class={style.select}>
+        <select class={`${style.nativeSelect} ${large ? style.large : ''}`} {...otherProps}/>
+        <svg class={style.arrow} viewBox="0 0 10 5"><path d="M0 0l5 5 5-5z"/></svg>
+      </div>
+    );
+  }
+}

src/components/select/style.scss

@@ -0,0 +1,33 @@
+.select {
+  position: relative;
+}
+
+.native-select {
+  background: #2f2f2f;
+  border-radius: 4px;
+  font: inherit;
+  padding: 4px 25px 4px 10px;
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  border: none;
+  color: #fff;
+  width: 100%;
+}
+
+.arrow {
+  position: absolute;
+  right: 8px;
+  top: 50%;
+  transform: translateY(-50%);
+  fill: #fff;
+  width: 10px;
+}
+
+.large {
+  padding: 10px 35px 10px 10px;
+  background: #151515;
+
+  & .arrow {
+    right: 13px;
+  }
+}

src/custom-els/RangeInput/index.ts

@@ -1,15 +1,20 @@
+import PointerTracker from 'pointer-tracker';
 import { bind } from '../../lib/initial-util';
-import './styles.css';
+import * as style from './styles.css';
 
 const RETARGETED_EVENTS = ['focus', 'blur'];
 const UPDATE_EVENTS = ['input', 'change'];
 const REFLECTED_PROPERTIES = ['name', 'min', 'max', 'step', 'value', 'disabled'];
 const REFLECTED_ATTRIBUTES = ['name', 'min', 'max', 'step', 'value', 'disabled'];
 
+function getPrescision(value: string): number {
+  const afterDecimal = value.split('.')[1];
+  return afterDecimal ? afterDecimal.length : 0;
+}
+
 class RangeInputElement extends HTMLElement {
-  private _input = document.createElement('input');
-  private _valueDisplayWrapper = document.createElement('div');
-  private _valueDisplay = document.createElement('span');
+  private _input: HTMLInputElement;
+  private _valueDisplay?: HTMLDivElement;
   private _ignoreChange = false;
 
   static get observedAttributes() {
@@ -18,7 +23,20 @@ class RangeInputElement extends HTMLElement {
 
   constructor() {
     super();
+    this._input = document.createElement('input');
     this._input.type = 'range';
+    this._input.className = style.input;
+
+    const tracker = new PointerTracker(this._input, {
+      start: (): boolean => {
+        if (tracker.currentPointers.length !== 0) return false;
+        this._input.classList.add(style.touchActive);
+        return true;
+      },
+      end: () => {
+        this._input.classList.remove(style.touchActive);
+      },
+    });
 
     for (const event of RETARGETED_EVENTS) {
       this._input.addEventListener(event, this._retargetEvent, true);
@@ -29,6 +47,20 @@ class RangeInputElement extends HTMLElement {
     }
   }
 
+  connectedCallback() {
+    if (this.contains(this._input)) return;
+    this.innerHTML =
+      `<div class="${style.thumbWrapper}">` +
+        `<div class="${style.thumb}"></div>` +
+        `<div class="${style.valueDisplay}"></div>` +
+      '</div>';
+
+    this.insertBefore(this._input, this.firstChild);
+    this._valueDisplay = this.querySelector('.' + style.valueDisplay) as HTMLDivElement;
+    // Set inline styles (this is useful when used with frameworks which might clear inline styles)
+    this._update();
+  }
+
   get labelPrecision(): string {
     return this.getAttribute('label-precision') || '';
   }
@@ -37,14 +69,6 @@ class RangeInputElement extends HTMLElement {
     this.setAttribute('label-precision', precision);
   }
 
-  connectedCallback() {
-    if (this._input.parentNode !== this) {
-      this.appendChild(this._input);
-      this._valueDisplayWrapper.appendChild(this._valueDisplay);
-      this.appendChild(this._valueDisplayWrapper);
-    }
-  }
-
   attributeChangedCallback(name: string, oldValue: string, newValue: string | null) {
     if (this._ignoreChange) return;
     if (newValue === null) {
@@ -65,15 +89,15 @@ class RangeInputElement extends HTMLElement {
 
   @bind
   private _update() {
-    const value = parseFloat(this.value || '0');
-    const min = parseFloat(this.min || '0');
-    const max = parseFloat(this.max || '100');
-    const labelPrecision = parseFloat(this.labelPrecision || '0');
+    const value = Number(this.value) || 0;
+    const min = Number(this.min) || 0;
+    const max = Number(this.max) || 100;
+    const labelPrecision = Number(this.labelPrecision) || getPrescision(this.step) || 0;
     const percent = 100 * (value - min) / (max - min);
-    const displayValue = labelPrecision ? value.toPrecision(labelPrecision) :
+    const displayValue = labelPrecision ? value.toFixed(labelPrecision) :
       Math.round(value).toString();
 
-    this._valueDisplay.textContent = displayValue;
+    this._valueDisplay!.textContent = displayValue;
     this.style.setProperty('--value-percent', percent + '%');
     this.style.setProperty('--value-width', '' + displayValue.length);
   }

src/custom-els/RangeInput/missing-types.d.ts

@@ -1,9 +1,5 @@
 declare namespace JSX {
-  interface RangeInputAttributes extends HTMLAttributes {
-    reversed?: boolean;
-  }
-
   interface IntrinsicElements {
-    'range-input': RangeInputAttributes;
+    'range-input': HTMLAttributes;
   }
 }

src/custom-els/RangeInput/styles.css

@@ -14,41 +14,6 @@ range-input[disabled] {
   filter: grayscale(1);
 }
 
-/* Reversed Variant */
-range-input[reversed] input,
-range-input[reversed]::before,
-range-input[reversed] > div {
-  transform: scaleX(-1);
-}
-range-input[reversed] > div > span {
-  transform: scaleX(-1) scale(.2);
-}
-range-input[reversed] input:focus + div span {
-  transform: scaleX(-1) scale(1);
-}
-
-
-range-input input {
-  position: relative;
-  flex: 1;
-  vertical-align: middle;
-  width: 100%;
-  padding: 0 !important;
-  margin: 0 !important;
-  background: none;
-  appearance: none;
-  -webkit-appearance: none;
-  outline: none;
-}
-range-input input::-webkit-slider-runnable-track,
-range-input input::-moz-range-track,
-range-input input::-ms-track {
-  appearance: none;
-  -ms-appearance: none;
-  -moz-appearance: none;
-  -webkit-appearance: none;
-}
-
 range-input::before {
   content: '';
   display: block;
@@ -57,32 +22,33 @@ range-input::before {
   left: 0;
   width: 100%;
   height: 2px;
-  outline: none;
-  border: none;
-  background: #eee;
   border-radius: 1px;
   box-shadow: 0 -.5px 0 rgba(0,0,0,0.3), inset 0 .5px 0 rgba(255,255,255,0.2), 0 .5px 0 rgba(255,255,255,0.3);
   background: linear-gradient(#34B9EB, #218ab1) 0/ var(--value-percent, 0%) 100% no-repeat #eee;
 }
 
-range-input input::-webkit-slider-thumb {
-  appearance: none;
-  -webkit-appearance: none;
-  background: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"><circle cx="5" cy="5" r="1" fill="#5D509E" /></svg>') center no-repeat #34B9EB;
-  box-sizing: content-box;
+.input {
+  position: relative;
+  width: 100%;
+  padding: 0;
+  margin: 0;
+  opacity: 0;
+}
+
+.thumb {
+  pointer-events: none;
+  position: absolute;
+  bottom: 3px;
+  left: var(--value-percent, 0%);
+  margin-left: -6px;
+  background: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"><circle cx="5" cy="5" r="1" fill="%235D509E" /></svg>') center no-repeat #34B9EB;
   border-radius: 50%;
   width: 12px;
   height: 12px;
-  border: none;
   box-shadow: 0 0.5px 2px rgba(0,0,0,0.3);
-  outline: none;
 }
 
-range-input input:focus::-webkit-slider-thumb {
-  box-shadow: 0 1px 3px rgba(0,0,0,0.5);
-}
-
-range-input > div {
+.thumb-wrapper {
   position: absolute;
   left: 6px;
   right: 6px;
@@ -91,8 +57,8 @@ range-input > div {
   overflow: visible;
 }
 
-range-input > div > span {
-  background: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="32" height="62" fill="none"><path fill="#34B9EB" d="M27.3 27.3C25 29.6 17 35.8 17 43v3c0 3 2.5 5 3.2 5.8a6 6 0 1 1-8.5 0C12.6 51 15 49 15 46v-3c0-7.2-8-13.4-10.3-15.7A16 16 0 0 1 16 0a16 16 0 0 1 11.3 27.3z"/><circle cx="16" cy="56" r="1" fill="#5D509E"/></svg>') top center no-repeat;
+.value-display {
+  background: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="32" height="62" fill="none"><path fill="%2334B9EB" d="M27.3 27.3C25 29.6 17 35.8 17 43v3c0 3 2.5 5 3.2 5.8a6 6 0 1 1-8.5 0C12.6 51 15 49 15 46v-3c0-7.2-8-13.4-10.3-15.7A16 16 0 0 1 16 0a16 16 0 0 1 11.3 27.3z"/><circle cx="16" cy="56" r="1" fill="%235D509E"/></svg>') top center no-repeat;
   position: absolute;
   box-sizing: border-box;
   left: var(--value-percent, 0%);
@@ -111,12 +77,18 @@ range-input > div > span {
   font-size: calc(100% - var(--value-width, 3) / 5 * .2em);
   text-overflow: clip;
   text-shadow: 0 -.5px 0 rgba(0,0,0,0.4);
-  transition: transform 200ms ease, opacity 200ms ease;
+  transition: all 200ms ease;
+  transition-property: opacity, transform;
   will-change: transform;
   pointer-events: none;
   overflow: hidden;
 }
-range-input input:focus + div span {
+
+.touch-active + .thumb-wrapper .value-display {
   opacity: 1;
   transform: scale(1);
 }
+
+.touch-active + .thumb-wrapper .thumb {
+  box-shadow: 0 1px 3px rgba(0,0,0,0.5);
+}

src/index.html

@@ -4,13 +4,13 @@
     <meta charset="utf-8">
     <title>Squoosh</title>
     <meta name="description" content="Compress and compare images with different codecs, right in your browser">
-    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
     <meta name="mobile-web-app-capable" content="yes">
     <meta name="apple-mobile-web-app-capable" content="yes">
-    <meta name="theme-color" content="#673ab8">
+    <link rel="shortcut icon" href="/assets/favicon.ico">
+    <meta name="theme-color" content="#f78f21">
     <link rel="manifest" href="/manifest.json">
   </head>
   <body>
-    <div id="app"></div>
   </body>
 </html>

src/index.ts

@@ -1,9 +1,25 @@
 declare module '@webcomponents/custom-elements';
 
-(async function () {
-  if (!('customElements' in self)) {
-    await import('@webcomponents/custom-elements');
-  }
-
+function init() {
   require('./init-app.tsx');
-})();
+}
+
+if (!('customElements' in self)) {
+  import(
+    /* webpackChunkName: "wc-polyfill" */
+    '@webcomponents/custom-elements',
+  ).then(init);
+} else {
+  init();
+}
+
+if (typeof PRERENDER === 'undefined') {
+  window.ga = window.ga || ((...args) => (ga.q = ga.q || []).push(args));
+  ga('create', 'UA-128752250-1', 'auto');
+  ga('set', 'transport', 'beacon');
+  ga('send', 'pageview');
+    // Load the GA script
+  const s = document.createElement('script');
+  s.src = 'https://www.google-analytics.com/analytics.js';
+  document.head!.appendChild(s);
+}

src/init-app.tsx

@@ -4,18 +4,19 @@ import './style';
 import App from './components/App';
 
 // Find the outermost Element in our server-rendered HTML structure.
-let root = document.querySelector('#app') || undefined;
+let root = document.getElementById('app_root') as Element;
 
 // "attach" the client-side rendering to it, updating the DOM in-place instead of replacing:
 root = render(<App />, document.body, root);
+root.setAttribute('id', 'app_root');
 
-// In production, this entire condition is removed.
-if (process.env.NODE_ENV === 'development') {
+if (process.env.NODE_ENV !== 'production') {
   // Enable support for React DevTools and some helpful console warnings:
   require('preact/debug');
 
   // When an update to any module is received, re-import the app and trigger a full re-render:
   module.hot.accept('./components/App', () => {
+    // The linter doesn't like the capital A in App. It is wrong.
     // tslint:disable-next-line variable-name
     import('./components/App').then(({ default: App }) => {
       root = render(<App />, document.body, root);

src/lib/PointerTracker/index.ts

@@ -1,255 +0,0 @@
-import { bind } from '../../lib/initial-util';
-const enum Button { Left }
-
-export class Pointer {
-  /** x offset from the top of the document */
-  pageX: number;
-  /** y offset from the top of the document */
-  pageY: number;
-  /** x offset from the top of the viewport */
-  clientX: number;
-  /** y offset from the top of the viewport */
-  clientY: number;
-  /** ID for this pointer */
-  id: number = -1;
-  /** The platform object used to create this Pointer */
-  nativePointer: Touch | PointerEvent | MouseEvent;
-
-  constructor (nativePointer: Touch | PointerEvent | MouseEvent) {
-    this.nativePointer = nativePointer;
-    this.pageX = nativePointer.pageX;
-    this.pageY = nativePointer.pageY;
-    this.clientX = nativePointer.clientX;
-    this.clientY = nativePointer.clientY;
-
-    if (self.Touch && nativePointer instanceof Touch) {
-      this.id = nativePointer.identifier;
-    } else if (isPointerEvent(nativePointer)) { // is PointerEvent
-      this.id = nativePointer.pointerId;
-    }
-  }
-
-  /**
-   * Returns an expanded set of Pointers for high-resolution inputs.
-   */
-  getCoalesced(): Pointer[] {
-    if ('getCoalescedEvents' in this.nativePointer) {
-      return this.nativePointer.getCoalescedEvents().map(p => new Pointer(p));
-    }
-    return [this];
-  }
-}
-
-const isPointerEvent = (event: any): event is PointerEvent =>
-  self.PointerEvent && event instanceof PointerEvent;
-
-const noop = () => {};
-
-export type InputEvent = TouchEvent | PointerEvent | MouseEvent;
-type StartCallback = (pointer: Pointer, event: InputEvent) => boolean;
-type MoveCallback = (
-  previousPointers: Pointer[],
-  changedPointers: Pointer[],
-  event: InputEvent,
-) => void;
-type EndCallback = (pointer: Pointer, event: InputEvent) => void;
-
-interface PointerTrackerCallbacks {
-  /**
-   * Called when a pointer is pressed/touched within the element.
-   *
-   * @param pointer The new pointer.
-   * This pointer isn't included in this.currentPointers or this.startPointers yet.
-   * @param event The event related to this pointer.
-   *
-   * @returns Whether you want to track this pointer as it moves.
-   */
-  start?: StartCallback;
-  /**
-   * Called when pointers have moved.
-   *
-   * @param previousPointers The state of the pointers before this event.
-   * This contains the same number of pointers, in the same order, as
-   * this.currentPointers and this.startPointers.
-   * @param changedPointers The pointers that have changed since the last move callback.
-   * @param event The event related to the pointer changes.
-   */
-  move?: MoveCallback;
-  /**
-   * Called when a pointer is released.
-   *
-   * @param pointer The final state of the pointer that ended. This
-   * pointer is now absent from this.currentPointers and
-   * this.startPointers.
-   * @param event The event related to this pointer.
-   */
-  end?: EndCallback;
-}
-
-/**
- * Track pointers across a particular element
- */
-export class PointerTracker {
-  /**
-   * State of the tracked pointers when they were pressed/touched.
-   */
-  readonly startPointers: Pointer[] = [];
-  /**
-   * Latest state of the tracked pointers. Contains the same number
-   * of pointers, and in the same order as this.startPointers.
-   */
-  readonly currentPointers: Pointer[] = [];
-
-  private _startCallback: StartCallback;
-  private _moveCallback: MoveCallback;
-  private _endCallback: EndCallback;
-
-  /**
-   * Track pointers across a particular element
-   *
-   * @param element Element to monitor.
-   * @param callbacks
-   */
-  constructor (private _element: HTMLElement, callbacks: PointerTrackerCallbacks) {
-    const {
-      start = () => true,
-      move = noop,
-      end = noop,
-    } = callbacks;
-
-    this._startCallback = start;
-    this._moveCallback = move;
-    this._endCallback = end;
-
-    // Add listeners
-    if (self.PointerEvent) {
-      this._element.addEventListener('pointerdown', this._pointerStart);
-    } else {
-      this._element.addEventListener('mousedown', this._pointerStart);
-      this._element.addEventListener('touchstart', this._touchStart);
-      this._element.addEventListener('touchmove', this._move);
-      this._element.addEventListener('touchend', this._touchEnd);
-    }
-  }
-
-  /**
-   * Call the start callback for this pointer, and track it if the user wants.
-   *
-   * @param pointer Pointer
-   * @param event Related event
-   * @returns Whether the pointer is being tracked.
-   */
-  private _triggerPointerStart (pointer: Pointer, event: InputEvent): boolean {
-    if (!this._startCallback(pointer, event)) return false;
-    this.currentPointers.push(pointer);
-    this.startPointers.push(pointer);
-    return true;
-  }
-
-  /**
-   * Listener for mouse/pointer starts. Bound to the class in the constructor.
-   *
-   * @param event This will only be a MouseEvent if the browser doesn't support
-   * pointer events.
-   */
-  @bind
-  private _pointerStart (event: PointerEvent | MouseEvent) {
-    if (event.button !== Button.Left) return;
-    if (!this._triggerPointerStart(new Pointer(event), event)) return;
-
-    // Add listeners for additional events.
-    // The listeners may already exist, but no harm in adding them again.
-    if (isPointerEvent(event)) {
-      this._element.setPointerCapture(event.pointerId);
-      this._element.addEventListener('pointermove', this._move);
-      this._element.addEventListener('pointerup', this._pointerEnd);
-    } else { // MouseEvent
-      window.addEventListener('mousemove', this._move);
-      window.addEventListener('mouseup', this._pointerEnd);
-    }
-  }
-
-  /**
-   * Listener for touchstart. Bound to the class in the constructor.
-   * Only used if the browser doesn't support pointer events.
-   */
-  @bind
-  private _touchStart (event: TouchEvent) {
-    for (const touch of Array.from(event.changedTouches)) {
-      this._triggerPointerStart(new Pointer(touch), event);
-    }
-  }
-
-  /**
-   * Listener for pointer/mouse/touch move events.
-   * Bound to the class in the constructor.
-   */
-  @bind
-  private _move (event: PointerEvent | MouseEvent | TouchEvent) {
-    const previousPointers = this.currentPointers.slice();
-    const changedPointers = ('changedTouches' in event) ? // Shortcut for 'is touch event'.
-      Array.from(event.changedTouches).map(t => new Pointer(t)) :
-      [new Pointer(event)];
-    const trackedChangedPointers = [];
-
-    for (const pointer of changedPointers) {
-      const index = this.currentPointers.findIndex(p => p.id === pointer.id);
-      if (index === -1) continue; // Not a pointer we're tracking
-      trackedChangedPointers.push(pointer);
-      this.currentPointers[index] = pointer;
-    }
-
-    if (trackedChangedPointers.length === 0) return;
-
-    this._moveCallback(previousPointers, trackedChangedPointers, event);
-  }
-
-  /**
-   * Call the end callback for this pointer.
-   *
-   * @param pointer Pointer
-   * @param event Related event
-   */
-  @bind
-  private _triggerPointerEnd (pointer: Pointer, event: InputEvent): boolean {
-    const index = this.currentPointers.findIndex(p => p.id === pointer.id);
-    // Not a pointer we're interested in?
-    if (index === -1) return false;
-
-    this.currentPointers.splice(index, 1);
-    this.startPointers.splice(index, 1);
-
-    this._endCallback(pointer, event);
-    return true;
-  }
-
-  /**
-   * Listener for mouse/pointer ends. Bound to the class in the constructor.
-   * @param event This will only be a MouseEvent if the browser doesn't support
-   * pointer events.
-   */
-  @bind
-  private _pointerEnd (event: PointerEvent | MouseEvent) {
-    if (!this._triggerPointerEnd(new Pointer(event), event)) return;
-
-    if (isPointerEvent(event)) {
-      if (this.currentPointers.length) return;
-      this._element.removeEventListener('pointermove', this._move);
-      this._element.removeEventListener('pointerup', this._pointerEnd);
-    } else { // MouseEvent
-      window.removeEventListener('mousemove', this._move);
-      window.removeEventListener('mouseup', this._pointerEnd);
-    }
-  }
-
-  /**
-   * Listener for touchend. Bound to the class in the constructor.
-   * Only used if the browser doesn't support pointer events.
-   */
-  @bind
-  private _touchEnd (event: TouchEvent) {
-    for (const touch of Array.from(event.changedTouches)) {
-      this._triggerPointerEnd(new Pointer(touch), event);
-    }
-  }
-}

src/lib/PointerTracker/missing-types.d.ts

@@ -1,10 +0,0 @@
-// TypeScript, you make me sad.
-// https://github.com/Microsoft/TypeScript/issues/18756
-interface Window {
-  PointerEvent: typeof PointerEvent;
-  Touch: typeof Touch;
-}
-
-interface PointerEvent {
-  getCoalescedEvents(): PointerEvent[];
-}

src/lib/SnackBar/index.ts

@@ -1,114 +1,93 @@
-import './styles.css';
-
-const DEFAULT_TIMEOUT = 2750;
+import * as style from './styles.css';
 
 export interface SnackOptions {
-  message: string;
   timeout?: number;
-  actionText?: string;
-  actionHandler?: () => boolean | null;
+  actions?: string[];
 }
 
-export interface SnackShowResult {
-  action: boolean;
-}
+function createSnack(message: string, options: SnackOptions): [Element, Promise<string>] {
+  const {
+    timeout = 0,
+    actions = ['dismiss'],
+  } = options;
 
-class Snack {
-  private _onremove: ((result: SnackShowResult) => void)[] = [];
-  private _options: SnackOptions;
-  private _element: Element = document.createElement('div');
-  private _text: Element = document.createElement('div');
-  private _button: Element = document.createElement('button');
-  private _showing = false;
-  private _closeTimer?: number;
-  private _result: SnackShowResult = {
-    action: false,
-  };
+  const el = document.createElement('div');
+  el.className = style.snackbar;
+  el.setAttribute('aria-live', 'assertive');
+  el.setAttribute('aria-atomic', 'true');
+  el.setAttribute('aria-hidden', 'false');
 
-  constructor (options: SnackOptions, callback?: (result: SnackShowResult) => void) {
-    this._options = options;
+  const text = document.createElement('div');
+  text.className = style.text;
+  text.textContent = message;
+  el.appendChild(text);
 
-    this._element.className = 'snackbar';
-    this._element.setAttribute('aria-live', 'assertive');
-    this._element.setAttribute('aria-atomic', 'true');
-    this._element.setAttribute('aria-hidden', 'true');
+  const result = new Promise<string>((resolve) => {
+    let timeoutId: number;
 
-    this._text.className = 'snackbar--text';
-    this._text.textContent = options.message;
-    this._element.appendChild(this._text);
-
-    if (options.actionText) {
-      this._button.className = 'snackbar--button';
-      this._button.textContent = options.actionText;
-      this._button.addEventListener('click', () => {
-        if (this._showing) {
-          if (options.actionHandler && options.actionHandler() === false) return;
-          this._result.action = true;
-        }
-        this.hide();
+    // Add action buttons
+    for (const action of actions) {
+      const button = document.createElement('button');
+      button.className = style.button;
+      button.textContent = action;
+      button.addEventListener('click', () => {
+        clearTimeout(timeoutId);
+        resolve(action);
       });
-      this._element.appendChild(this._button);
+      el.appendChild(button);
     }
 
-    if (callback) {
-      this._onremove.push(callback);
+    // Add timeout
+    if (timeout) {
+      timeoutId = self.setTimeout(
+        () => resolve(''),
+        timeout,
+      );
     }
-  }
+  });
 
-  cancelTimer () {
-    if (this._closeTimer != null) clearTimeout(this._closeTimer);
-  }
-
-  show (parent: Element): Promise<SnackShowResult> {
-    if (this._showing) return Promise.resolve(this._result);
-    this._showing = true;
-    this.cancelTimer();
-    if (parent !== this._element.parentNode) {
-      parent.appendChild(this._element);
-    }
-    this._element.removeAttribute('aria-hidden');
-    this._closeTimer = setTimeout(this.hide.bind(this), this._options.timeout || DEFAULT_TIMEOUT);
-    return new Promise((resolve) => {
-      this._onremove.push(resolve);
-    });
-  }
-
-  hide () {
-    if (!this._showing) return;
-    this._showing = false;
-    this.cancelTimer();
-    this._element.addEventListener('animationend', this.remove.bind(this));
-    this._element.setAttribute('aria-hidden', 'true');
-  }
-
-  remove () {
-    this.cancelTimer();
-    const parent = this._element.parentNode;
-    if (parent) parent.removeChild(this._element);
-    this._onremove.forEach(f => f(this._result));
-    this._onremove = [];
-  }
+  return [el, result];
 }
 
 export default class SnackBarElement extends HTMLElement {
-  private _snackbars: Snack[] = [];
-  private _processingStack = false;
+  private _snackbars: [string, SnackOptions, (action: Promise<string>) => void][] = [];
+  private _processingQueue = false;
 
-  showSnackbar (options: SnackOptions): Promise<SnackShowResult> {
-    return new Promise((resolve) => {
-      const snack = new Snack(options, resolve);
-      this._snackbars.push(snack);
-      this._processStack();
+  /**
+   * Show a snackbar. Returns a promise for the name of the action clicked, or an empty string if no
+   * action is clicked.
+   */
+  showSnackbar(message: string, options: SnackOptions = {}): Promise<string> {
+    return new Promise<string>((resolve) => {
+      this._snackbars.push([message, options, resolve]);
+      if (!this._processingQueue) this._processQueue();
     });
   }
 
-  private async _processStack () {
-    if (this._processingStack === true || this._snackbars.length === 0) return;
-    this._processingStack = true;
-    await this._snackbars[0].show(this);
-    this._snackbars.shift();
-    this._processingStack = false;
-    this._processStack();
+  private async _processQueue() {
+    this._processingQueue = true;
+
+    while (this._snackbars[0]) {
+      const [message, options, resolver] = this._snackbars[0];
+      const [el, result] = createSnack(message, options);
+      // Pass the result back to the original showSnackbar call.
+      resolver(result);
+      this.appendChild(el);
+
+      // Wait for the user to click an action, or for the snack to timeout.
+      await result;
+
+      // Transition the snack away.
+      el.setAttribute('aria-hidden', 'true');
+      await new Promise((resolve) => {
+        el.addEventListener('animationend', () => resolve());
+      });
+      el.remove();
+
+      this._snackbars.shift();
+    }
+
+    this._processingQueue = false;
   }
 }
 

src/lib/SnackBar/styles.css

@@ -22,7 +22,6 @@ snack-bar {
   transform-origin: center;
   color: #eee;
   z-index: 100;
-  pointer-events: none;
   cursor: default;
   will-change: transform;
   animation: snackbar-show 300ms ease forwards 1;
@@ -53,13 +52,13 @@ snack-bar {
   }
 }
 
-.snackbar--text {
+.text {
   flex: 1 1 auto;
   padding: 16px;
   font-size: 100%;
 }
 
-.snackbar--button {
+.button {
   position: relative;
   flex: 0 1 auto;
   padding: 8px;
@@ -75,16 +74,15 @@ snack-bar {
   font-size: 100%;
   text-transform: uppercase;
   text-align: center;
-  pointer-events: all;
   cursor: pointer;
   overflow: hidden;
   transition: background-color 200ms ease;
   outline: none;
 }
-.snackbar--button:hover {
+.button:hover {
   background-color: rgba(0,0,0,0.15);
 }
-.snackbar--button:focus:before {
+.button:focus:before {
   content: '';
   position: absolute;
   left: 50%;

src/lib/icons.tsx

@@ -2,32 +2,91 @@ import { h } from 'preact';
 
 // tslint:disable:max-line-length variable-name
 
-export interface IconProps extends JSX.HTMLAttributes {}
-
-const Icon = (props: IconProps) => (
+const Icon = (props: JSX.HTMLAttributes) => (
   <svg width="24" height="24" viewBox="0 0 24 24" fill="currentColor" {...props} />
 );
 
-export const DownloadIcon = (props: IconProps) => (
+export const DownloadIcon = (props: JSX.HTMLAttributes) => (
   <Icon {...props}>
-    <path d="M19.35 10.04A7.49 7.49 0 0 0 12 4C9.11 4 6.6 5.64 5.35 8.04A5.994 5.994 0 0 0 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM17 13l-5 5-5-5h3V9h4v4h3z" />
+    <path d="M19 12v7H5v-7H3v7c0 1.1.9 2 2 2h14a2 2 0 0 0 2-2v-7h-2zm-6 .7l2.6-2.6 1.4 1.4-5 5-5-5 1.4-1.4 2.6 2.6V3h2z"/>
   </Icon>
 );
 
-export const ToggleIcon = (props: IconProps) => (
+export const ToggleBackgroundIcon = (props: JSX.HTMLAttributes) => (
   <Icon {...props}>
-    <path d="M3 13h2v-2H3v2zm0 4h2v-2H3v2zm2 4v-2H3c0 1.1.89 2 2 2zM3 9h2V7H3v2zm12 12h2v-2h-2v2zm4-18H9c-1.11 0-2 .9-2 2v10c0 1.1.89 2 2 2h10c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 12H9V5h10v10zm-8 6h2v-2h-2v2zm-4 0h2v-2H7v2z" />
+    <path d="M3 13h2v-2H3v2zm0 4h2v-2H3v2zm2 4v-2H3c0 1.1.9 2 2 2zM3 9h2V7H3v2zm12 12h2v-2h-2v2zm4-18H9a2 2 0 0 0-2 2v10c0 1.1.9 2 2 2h10a2 2 0 0 0 2-2V5a2 2 0 0 0-2-2zm0 12H9V5h10v10zm-8 6h2v-2h-2v2zm-4 0h2v-2H7v2z"/>
   </Icon>
 );
 
-export const AddIcon = (props: IconProps) => (
+export const ToggleBackgroundActiveIcon = (props: JSX.HTMLAttributes) => (
+  <Icon {...props}>
+    <path d="M9 7H7v2h2V7zm0 4H7v2h2v-2zm0-8a2 2 0 0 0-2 2h2V3zm4 12h-2v2h2v-2zm6-12v2h2a2 2 0 0 0-2-2zm-6 0h-2v2h2V3zM9 17v-2H7c0 1.1.9 2 2 2zm10-4h2v-2h-2v2zm0-4h2V7h-2v2zm0 8a2 2 0 0 0 2-2h-2v2zM5 7H3v12c0 1.1.9 2 2 2h12v-2H5V7zm10-2h2V3h-2v2zm0 12h2v-2h-2v2z"/>
+  </Icon>
+);
+
+export const RotateIcon = (props: JSX.HTMLAttributes) => (
+  <Icon {...props}>
+    <path d="M15.6 5.5L11 1v3a8 8 0 0 0 0 16v-2a6 6 0 0 1 0-12v4l4.5-4.5zm4.3 5.5a8 8 0 0 0-1.6-3.9L17 8.5c.5.8.9 1.6 1 2.5h2zM13 17.9v2a8 8 0 0 0 3.9-1.6L15.5 17c-.8.5-1.6.9-2.5 1zm3.9-2.4l1.4 1.4A8 8 0 0 0 20 13h-2c-.1.9-.5 1.7-1 2.5z"/>
+  </Icon>
+);
+
+export const AddIcon = (props: JSX.HTMLAttributes) => (
   <Icon {...props}>
     <path d="M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z"/>
   </Icon>
 );
 
-export const RemoveIcon = (props: IconProps) => (
+export const RemoveIcon = (props: JSX.HTMLAttributes) => (
   <Icon {...props}>
     <path d="M19 13H5v-2h14v2z"/>
   </Icon>
 );
+
+export const UncheckedIcon = (props: JSX.HTMLAttributes) => (
+  <Icon {...props}>
+    <path d="M21.3 2.7v18.6H2.7V2.7h18.6m0-2.7H2.7A2.7 2.7 0 0 0 0 2.7v18.6A2.7 2.7 0 0 0 2.7 24h18.6a2.7 2.7 0 0 0 2.7-2.7V2.7A2.7 2.7 0 0 0 21.3 0z"/>
+  </Icon>
+);
+
+export const CheckedIcon = (props: JSX.HTMLAttributes) => (
+  <Icon {...props}>
+    <path d="M21.3 0H2.7A2.7 2.7 0 0 0 0 2.7v18.6A2.7 2.7 0 0 0 2.7 24h18.6a2.7 2.7 0 0 0 2.7-2.7V2.7A2.7 2.7 0 0 0 21.3 0zm-12 18.7L2.7 12l1.8-1.9L9.3 15 19.5 4.8l1.8 1.9z"/>
+  </Icon>
+);
+
+export const ExpandIcon = (props: JSX.HTMLAttributes) => (
+  <Icon {...props}>
+    <path d="M16.6 8.6L12 13.2 7.4 8.6 6 10l6 6 6-6z"/>
+  </Icon>
+);
+
+export const BackIcon = (props: JSX.HTMLAttributes) => (
+  <Icon {...props}>
+    <path d="M20 11H7.8l5.6-5.6L12 4l-8 8 8 8 1.4-1.4L7.8 13H20v-2z"/>
+  </Icon>
+);
+
+const copyAcrossRotations = {
+  up: 90, right: 180, down: -90, left: 0,
+};
+
+export interface CopyAcrossIconProps extends JSX.HTMLAttributes {
+  copyDirection: keyof typeof copyAcrossRotations;
+}
+
+export const CopyAcrossIcon = (props: CopyAcrossIconProps) => {
+  const { copyDirection, ...otherProps } = props;
+  const id = 'point-' + copyDirection;
+  const rotation = copyAcrossRotations[copyDirection];
+
+  return (
+    <Icon {...otherProps}>
+      <defs>
+        <clipPath id={id}>
+          <path d="M-12-12v24h24v-24zM4.5 2h-4v3l-5-5 5-5v3h4z" transform={`translate(12 13) rotate(${rotation})`}/>
+        </clipPath>
+      </defs>
+      <path clip-path={`url(#${id})`} d="M19 3h-4.2c-.4-1.2-1.5-2-2.8-2s-2.4.8-2.8 2H5a2 2 0 0 0-2 2v14c0 1.1.9 2 2 2h14a2 2 0 0 0 2-2V5a2 2 0 0 0-2-2zm-7 0a1 1 0 0 1 0 2c-.6 0-1-.4-1-1s.4-1 1-1z"/>
+    </Icon>
+  );
+};

src/lib/offliner.ts

@@ -0,0 +1,98 @@
+import { get, set } from 'idb-keyval';
+
+// Just for TypeScript
+import SnackBarElement from './SnackBar';
+
+/** Tell the service worker to skip waiting */
+async function skipWaiting() {
+  const reg = await navigator.serviceWorker.getRegistration();
+  if (!reg || !reg.waiting) return;
+  reg.waiting.postMessage('skip-waiting');
+}
+
+/** Find the service worker that's 'active' or closest to 'active' */
+async function getMostActiveServiceWorker() {
+  const reg = await navigator.serviceWorker.getRegistration();
+  if (!reg) return null;
+  return reg.active || reg.waiting || reg.installing;
+}
+
+/** Wait for an installing worker */
+async function installingWorker(reg: ServiceWorkerRegistration): Promise<ServiceWorker> {
+  if (reg.installing) return reg.installing;
+  return new Promise<ServiceWorker>((resolve) => {
+    reg.addEventListener(
+      'updatefound',
+      () => resolve(reg.installing!),
+      { once: true },
+    );
+  });
+}
+
+/** Wait a service worker to become waiting */
+async function updateReady(reg: ServiceWorkerRegistration): Promise<void> {
+  if (reg.waiting) return;
+  const installing = await installingWorker(reg);
+  return new Promise<void>((resolve) => {
+    installing.addEventListener('statechange', () => {
+      if (installing.state === 'installed') resolve();
+    });
+  });
+}
+
+/** Set up the service worker and monitor changes */
+export async function offliner(showSnack: SnackBarElement['showSnackbar']) {
+  // This needs to be a typeof because Webpack.
+  if (typeof PRERENDER === 'boolean') return;
+
+  if (process.env.NODE_ENV === 'production') {
+    navigator.serviceWorker.register('../sw');
+  }
+
+  const hasController = !!navigator.serviceWorker.controller;
+
+  // Look for changes in the controller
+  navigator.serviceWorker.addEventListener('controllerchange', async () => {
+    // Is it the first install?
+    if (!hasController) {
+      showSnack('Ready to work offline', { timeout: 5000 });
+      return;
+    }
+
+    // Otherwise reload (the user will have agreed to this).
+    location.reload();
+  });
+
+  // If we don't have a controller, we don't need to check for updates – we've just loaded from the
+  // network.
+  if (!hasController) return;
+
+  const reg = await navigator.serviceWorker.getRegistration();
+  // Service worker not registered yet.
+  if (!reg) return;
+  // Look for updates
+  await updateReady(reg);
+
+  // Ask the user if they want to update.
+  const result = await showSnack('Update available', {
+    actions: ['reload', 'dismiss'],
+  });
+
+  // Tell the waiting worker to activate, this will change the controller and cause a reload (see
+  // 'controllerchange')
+  if (result === 'reload') skipWaiting();
+}
+
+/**
+ * Tell the service worker the main app has loaded. If it's the first time the service worker has
+ * heard about this, cache the heavier assets like codecs.
+ */
+export async function mainAppLoaded() {
+  // If the user has already interacted, no need to tell the service worker anything.
+  const userInteracted = await get<boolean | undefined>('user-interacted');
+  if (userInteracted) return;
+  set('user-interacted', true);
+  const serviceWorker = await getMostActiveServiceWorker();
+  if (!serviceWorker) return; // Service worker not installing yet.
+  serviceWorker.postMessage('cache-all');
+}

src/lib/util.scss

@@ -5,6 +5,7 @@
   width: 100%;
   height: 100%;
   box-sizing: border-box;
+  contain: strict;
 }
 
 .unbutton {

src/lib/util.ts

@@ -57,16 +57,32 @@ export async function canvasEncode(data: ImageData, type: string, quality?: numb
   return blob;
 }
 
+async function decodeImage(url: string): Promise<HTMLImageElement> {
+  const img = new Image();
+  img.decoding = 'async';
+  img.src = url;
+  const loaded = new Promise((resolve, reject) => {
+    img.onload = () => resolve();
+    img.onerror = () => reject(Error('Image loading error'));
+  });
+
+  if (img.decode) {
+    // Nice off-thread way supported in Safari/Chrome.
+    // Safari throws on decode if the source is SVG.
+    // https://bugs.webkit.org/show_bug.cgi?id=188347
+    await img.decode().catch(() => null);
+  }
+
+  // Always await loaded, as we may have bailed due to the Safari bug above.
+  await loaded;
+  return img;
+}
+
 /**
  * Attempts to load the given URL as an image.
  */
-export function canDecodeImage(data: string): Promise<boolean> {
-  return new Promise((resolve) => {
-    const img = document.createElement('img');
-    img.src = data;
-    img.onload = _ => resolve(true);
-    img.onerror = _ => resolve(false);
-  });
+export function canDecodeImage(url: string): Promise<boolean> {
+  return decodeImage(url).then(() => true, () => false);
 }
 
 export function blobToArrayBuffer(blob: Blob): Promise<ArrayBuffer> {
@@ -108,24 +124,7 @@ export async function blobToImg(blob: Blob): Promise<HTMLImageElement> {
   const url = URL.createObjectURL(blob);
 
   try {
-    const img = new Image();
-    img.decoding = 'async';
-    img.src = url;
-    const loaded = new Promise((resolve, reject) => {
-      img.onload = () => resolve();
-      img.onerror = () => reject(Error('Image loading error'));
-    });
-
-    if (img.decode) {
-      // Nice off-thread way supported in Safari/Chrome.
-      // Safari throws on decode if the source is SVG.
-      // https://bugs.webkit.org/show_bug.cgi?id=188347
-      await img.decode().catch(() => null);
-    }
-
-    // Always await loaded, as we may have bailed due to the Safari bug above.
-    await loaded;
-    return img;
+    return await decodeImage(url);
   } finally {
     URL.revokeObjectURL(url);
   }
@@ -203,25 +202,40 @@ export function nativeResize(
 
 /**
  * @param field An HTMLInputElement, but the casting is done here to tidy up onChange.
+ * @param defaultVal Value to return if 'field' doesn't exist.
  */
-export function inputFieldValueAsNumber(field: any): number {
-  return Number((field as HTMLInputElement).value);
+export function inputFieldValueAsNumber(field: any, defaultVal: number = 0): number {
+  if (!field) return defaultVal;
+  return Number(inputFieldValue(field));
 }
 
 /**
  * @param field An HTMLInputElement, but the casting is done here to tidy up onChange.
+ * @param defaultVal Value to return if 'field' doesn't exist.
  */
-export function inputFieldCheckedAsNumber(field: any): number {
+export function inputFieldCheckedAsNumber(field: any, defaultVal: number = 0): number {
+  if (!field) return defaultVal;
   return Number(inputFieldChecked(field));
 }
 
 /**
  * @param field An HTMLInputElement, but the casting is done here to tidy up onChange.
+ * @param defaultVal Value to return if 'field' doesn't exist.
  */
-export function inputFieldChecked(field: any): boolean {
+export function inputFieldChecked(field: any, defaultVal: boolean = false): boolean {
+  if (!field) return defaultVal;
   return (field as HTMLInputElement).checked;
 }
 
+/**
+ * @param field An HTMLInputElement, but the casting is done here to tidy up onChange.
+ * @param defaultVal Value to return if 'field' doesn't exist.
+ */
+export function inputFieldValue(field: any, defaultVal: string = ''): string {
+  if (!field) return defaultVal;
+  return (field as HTMLInputElement).value;
+}
+
 /**
  * Creates a promise that resolves when the user types the konami code.
  */
@@ -243,3 +257,50 @@ export function konami(): Promise<void> {
     window.addEventListener('keydown', listener);
   });
 }
+
+interface TransitionOptions {
+  from?: number;
+  to?: number;
+  duration?: number;
+  easing?: string;
+}
+
+export async function transitionHeight(el: HTMLElement, opts: TransitionOptions): Promise<void> {
+  const {
+    from = el.getBoundingClientRect().height,
+    to = el.getBoundingClientRect().height,
+    duration = 1000,
+    easing = 'ease-in-out',
+  } = opts;
+
+  if (from === to || duration === 0) {
+    el.style.height = to + 'px';
+    return;
+  }
+
+  el.style.height = from + 'px';
+  // Force a style calc so the browser picks up the start value.
+  getComputedStyle(el).transform;
+  el.style.transition = `height ${duration}ms ${easing}`;
+  el.style.height = to + 'px';
+
+  return new Promise<void>((resolve) => {
+    const listener = (event: Event) => {
+      if (event.target !== el) return;
+      el.style.transition = '';
+      el.removeEventListener('transitionend', listener);
+      el.removeEventListener('transitioncancel', listener);
+      resolve();
+    };
+
+    el.addEventListener('transitionend', listener);
+    el.addEventListener('transitioncancel', listener);
+  });
+}
+
+/**
+ * Simple event listener that prevents the default.
+ */
+export function preventDefault(event: Event) {
+  event.preventDefault();
+}

src/manifest.json

@@ -3,14 +3,14 @@
   "short_name": "Squoosh",
   "start_url": "/",
   "display": "standalone",
-  "orientation": "portrait",
+  "orientation": "any",
   "background_color": "#fff",
-  "theme_color": "#673ab8",
+  "theme_color": "#f78f21",
   "icons": [
     {
-      "src": "/assets/icon.png",
+      "src": "/assets/icon-large.png",
       "type": "image/png",
-      "sizes": "512x512"
+      "sizes": "1024x1024"
     }
   ]
-}
+}

src/missing-types.d.ts

@@ -27,3 +27,15 @@ declare module '*.wasm' {
   const content: string;
   export default content;
 }
+
+declare module 'url-loader!*' {
+  const value: string;
+  export default value;
+}
+
+declare var VERSION: string;
+
+declare var ga: {
+  (...args: any[]): void;
+  q: any[];
+};

src/style/index.scss

@@ -1,12 +1,7 @@
-/*
-Note: These styles are temporary. They will be replaced before going live.
-*/
-
 @import './reset.scss';
 
 html, body {
   height: 100%;
-  width: 100%;
   padding: 0;
   margin: 0;
   font: 12px/1.3 system-ui, -apple-system, BlinkMacSystemFont, Roboto, Helvetica, sans-serif;

src/style/reset.scss

@@ -1,7 +1,3 @@
-/*
-Note: These styles are temporary. They will be replaced before going live.
-*/
-
 button, a, img, input, select, textarea {
   -webkit-tap-highlight-color: rgba(0,0,0,0);
 }