1.7.0

* Quick test

* More testing

* More testing

* Removing transfer for now

* Changing name so it's easier to tell them apart when installed

* Disable minification to ease debugging

* Adding navigate lock

* lol oops

* Add minifying back

* Removing minification again, for debugging

* Removing broadcast channel bits, to simplify the code

* Revert "Removing broadcast channel bits, to simplify the code"

This reverts commit 0b2a3ecf2986aae0dd65fdd1ddda2bd9e4e1eac7.

* I think this fixes it

* Refactor

* Suppress flash of home screen during share target

* Almost ready, so switching to real name

* Removing log

* Ahh yes the trailing comma thing

* Removing use of BroadcastChannel

* Reducing ternary

.babelrc

@@ -1,31 +0,0 @@
-{
-	"presets": [
-		[
-			"env",
-			{
-				"loose": true,
-				"uglify": false,
-				"modules": false,
-				"targets": {
-					"browsers": "last 2 versions"
-				},
-				"exclude": [
-					"transform-regenerator",
-					"transform-es2015-typeof-symbol"
-				]
-			}
-		]
-	],
-	"plugins": [
-		"transform-decorators-legacy",
-		"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.

.gitignore

@@ -1,3 +1,6 @@
 node_modules
 /build
-/*.log
+/*.log
+*.scss.d.ts
+*.css.d.ts
+*.o

.nvmrc

@@ -0,0 +1 @@
+10.16.0

.travis.yml

@@ -0,0 +1,4 @@
+language: node_js
+cache: npm
+script: npm run build
+after_success: npm run sizereport

README.md

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

_headers.ejs

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

_redirects.ejs

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

codecs/README.md

@@ -0,0 +1,16 @@
+# Codecs
+
+This folder contains a self-contained sub-project for each encoder and decoder that squoosh supplies.
+
+## Build
+
+Each subproject can be built using [Docker](https://www.docker.com/) the following commands:
+
+```
+$ 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 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/imagequant/README.md

@@ -0,0 +1,30 @@
+# ImageQuant
+
+- Source: <https://github.com/ImageOptim/libimagequant>
+- Version: v2.12.1
+
+## Dependencies
+
+- Docker
+
+## Example
+
+See `example.html`
+
+## API
+
+### `int version()`
+
+Returns the version of libimagequant as a number. va.b.c is encoded as 0x0a0b0c
+
+### `RawImage quantize(std::string buffer, int image_width, int image_height, int numColors, float dithering)`
+
+Quantizes the given images, using at most `numColors`, a value between 2 and 256. `dithering` is a value between 0 and 1 controlling the amount of dithering. `RawImage` is a class with 3 fields: `buffer`, `width`, and `height`.
+
+### `RawImage zx_quantize(std::string buffer, int image_width, int image_height, float dithering)`
+
+???
+
+### `void free_result()`
+
+Frees the result created by `quantize()`.

codecs/imagequant/build.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+
+set -e
+
+export OPTIMIZE="-Os"
+export LDFLAGS="${OPTIMIZE}"
+export CFLAGS="${OPTIMIZE}"
+export CPPFLAGS="${OPTIMIZE}"
+
+echo "============================================="
+echo "Compiling libimagequant"
+echo "============================================="
+(
+  emcc \
+    --bind \
+    ${OPTIMIZE} \
+    -s ALLOW_MEMORY_GROWTH=1 \
+    -s MODULARIZE=1 \
+    -s 'EXPORT_NAME="imagequant"' \
+    -I node_modules/libimagequant \
+    --std=c99 \
+    -c \
+    node_modules/libimagequant/{libimagequant,pam,mediancut,blur,mempool,kmeans,nearest}.c
+)
+echo "============================================="
+echo "Compiling wasm module"
+echo "============================================="
+(
+  emcc \
+    --bind \
+    ${OPTIMIZE} \
+    -s ALLOW_MEMORY_GROWTH=1 \
+    -s MODULARIZE=1 \
+    -s 'EXPORT_NAME="imagequant"' \
+    -I node_modules/libimagequant \
+    -o ./imagequant.js \
+    --std=c++11 *.o \
+    -x c++ \
+    imagequant.cpp
+)
+echo "============================================="
+echo "Compiling wasm module done"
+echo "============================================="
+
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+echo "Did you update your docker image?"
+echo "Run \`docker pull trzeci/emscripten\`"
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"

codecs/imagequant/example.html

@@ -0,0 +1,41 @@
+<!doctype html>
+<style>
+  canvas {
+    image-rendering: pixelated;
+  }
+</style>
+<script src='imagequant.js'></script>
+<script>
+  const Module = imagequant();
+
+  async function loadImage(src) {
+    // Load image
+    const img = document.createElement('img');
+    img.src = src;
+    await new Promise(resolve => img.onload = resolve);
+    // Make canvas same size as image
+    const canvas = document.createElement('canvas');
+    [canvas.width, canvas.height] = [img.width, img.height];
+    // Draw image onto canvas
+    const ctx = canvas.getContext('2d');
+    ctx.drawImage(img, 0, 0);
+    return ctx.getImageData(0, 0, img.width, img.height);
+  }
+
+  Module.onRuntimeInitialized = async _ => {
+    console.log('Version:', Module.version().toString(16));
+    const image = await loadImage('../example.png');
+    // const rawImage = Module.quantize(image.data, image.width, image.height, 256, 1.0);
+    const rawImage = Module.zx_quantize(image.data, image.width, image.height, 1.0);
+    console.log('done');
+    Module.free_result();
+
+    const imageData = new ImageData(new Uint8ClampedArray(rawImage.buffer), rawImage.width, rawImage.height);
+    const canvas = document.createElement('canvas');
+    canvas.width = image.width;
+    canvas.height = image.height;
+    const ctx = canvas.getContext('2d');
+    ctx.putImageData(imageData, 0, 0);
+    document.body.appendChild(canvas);
+  };
+</script>

codecs/imagequant/imagequant.cpp

@@ -0,0 +1,245 @@
+#include "emscripten/bind.h"
+#include "emscripten/val.h"
+#include <stdlib.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <math.h>
+
+#include "libimagequant.h"
+
+using namespace emscripten;
+
+int version() {
+  return (((LIQ_VERSION/10000) % 100) << 16) |
+         (((LIQ_VERSION/100  ) % 100) << 8) |
+         (((LIQ_VERSION/1    ) % 100) << 0);
+}
+
+class RawImage {
+public:
+  val buffer;
+  int width;
+  int height;
+
+  RawImage(val b, int w, int h)
+    : buffer(b), width(w), height(h) {}
+};
+
+
+liq_attr *attr;
+liq_image *image;
+liq_result *res;
+uint8_t* result;
+RawImage quantize(std::string rawimage, int image_width, int image_height, int num_colors, float dithering) {
+  const uint8_t* image_buffer = (uint8_t*)rawimage.c_str();
+  int size = image_width * image_height;
+  attr = liq_attr_create();
+  image = liq_image_create_rgba(attr, image_buffer, image_width, image_height, 0);
+  liq_set_max_colors(attr, num_colors);
+  liq_image_quantize(image, attr, &res);
+  liq_set_dithering_level(res, dithering);
+  uint8_t* image8bit = (uint8_t*) malloc(size);
+  result = (uint8_t*) malloc(size * 4);
+  liq_write_remapped_image(res, image, image8bit, size);
+  const liq_palette *pal = liq_get_palette(res);
+  // Turn palletted image back into an RGBA image
+  for(int i = 0; i < size; i++) {
+    result[i * 4 + 0] = pal->entries[image8bit[i]].r;
+    result[i * 4 + 1] = pal->entries[image8bit[i]].g;
+    result[i * 4 + 2] = pal->entries[image8bit[i]].b;
+    result[i * 4 + 3] = pal->entries[image8bit[i]].a;
+  }
+  free(image8bit);
+  liq_result_destroy(res);
+  liq_image_destroy(image);
+  liq_attr_destroy(attr);
+  return {
+    val(typed_memory_view(image_width*image_height*4, result)),
+    image_width,
+    image_height
+  };
+}
+
+const liq_color zx_colors[] = {
+  {.a = 255, .r = 0, .g = 0, .b = 0},       // regular black
+  {.a = 255, .r = 0, .g = 0, .b = 215},     // regular blue
+  {.a = 255, .r = 215, .g = 0, .b = 0},     // regular red
+  {.a = 255, .r = 215, .g = 0, .b = 215},   // regular magenta
+  {.a = 255, .r = 0, .g = 215, .b = 0},     // regular green
+  {.a = 255, .r = 0, .g = 215, .b = 215},   // regular cyan
+  {.a = 255, .r = 215, .g = 215, .b = 0},   // regular yellow
+  {.a = 255, .r = 215, .g = 215, .b = 215}, // regular white
+  {.a = 255, .r = 0, .g = 0, .b = 255},     // bright blue
+  {.a = 255, .r = 255, .g = 0, .b = 0},     // bright red
+  {.a = 255, .r = 255, .g = 0, .b = 255},   // bright magenta
+  {.a = 255, .r = 0, .g = 255, .b = 0},     // bright green
+  {.a = 255, .r = 0, .g = 255, .b = 255},   // bright cyan
+  {.a = 255, .r = 255, .g = 255, .b = 0},   // bright yellow
+  {.a = 255, .r = 255, .g = 255, .b = 255}  // bright white
+};
+
+uint8_t block[8 * 8 * 4];
+
+/**
+ * The ZX has one bit per pixel, but can assign two colours to an 8x8 block. The two colours must
+ * both be 'regular' or 'bright'. Black exists as both regular and bright.
+ */
+RawImage zx_quantize(std::string rawimage, int image_width, int image_height, float dithering) {
+  const uint8_t* image_buffer = (uint8_t*) rawimage.c_str();
+  int size = image_width * image_height;
+  int bytes_per_pixel = 4;
+  result = (uint8_t*) malloc(size * bytes_per_pixel);
+  uint8_t* image8bit = (uint8_t*) malloc(8 * 8);
+
+  // For each 8x8 grid
+  for (int block_start_y = 0; block_start_y < image_height; block_start_y += 8) {
+    for (int block_start_x = 0; block_start_x < image_width; block_start_x += 8) {
+      int color_popularity[15] = {0};
+      int block_index = 0;
+      int block_width = 8;
+      int block_height = 8;
+
+      // If the block hangs off the right/bottom of the image dimensions, make it smaller to fit.
+      if (block_start_y + block_height > image_height) {
+        block_height = image_height - block_start_y;
+      }
+
+      if (block_start_x + block_width > image_width) {
+        block_width = image_width - block_start_x;
+      }
+
+      // For each pixel in that block:
+      for (int y = block_start_y; y < block_start_y + block_height; y++) {
+        for (int x = block_start_x; x < block_start_x + block_width; x++) {
+          int pixel_start = (y * image_width * bytes_per_pixel) + (x * bytes_per_pixel);
+          int smallest_distance = INT_MAX;
+          int winning_index = -1;
+
+          // Copy pixel data for quantizing later
+          block[block_index++] = image_buffer[pixel_start];
+          block[block_index++] = image_buffer[pixel_start + 1];
+          block[block_index++] = image_buffer[pixel_start + 2];
+          block[block_index++] = image_buffer[pixel_start + 3];
+
+          // Which zx color is this pixel closest to?
+          for (int color_index = 0; color_index < 15; color_index++) {
+            liq_color color = zx_colors[color_index];
+
+            // Using Euclidean distance. LibQuant has better methods, but it requires conversion to
+            // LAB, so I don't think it's worth it.
+            int distance =
+              pow(color.r - image_buffer[pixel_start + 0], 2) +
+              pow(color.g - image_buffer[pixel_start + 1], 2) +
+              pow(color.b - image_buffer[pixel_start + 2], 2);
+
+            if (distance < smallest_distance) {
+              winning_index = color_index;
+              smallest_distance = distance;
+            }
+          }
+          color_popularity[winning_index]++;
+        }
+      }
+
+      // Get the three most popular colours for the block.
+      int first_color_index = 0;
+      int second_color_index = 0;
+      int third_color_index = 0;
+      int highest_popularity = -1;
+      int second_highest_popularity = -1;
+      int third_highest_popularity = -1;
+
+      for (int color_index = 0; color_index < 15; color_index++) {
+        if (color_popularity[color_index] > highest_popularity) {
+          // Store this as the most popular pixel, and demote the current values:
+          third_color_index = second_color_index;
+          third_highest_popularity = second_highest_popularity;
+          second_color_index = first_color_index;
+          second_highest_popularity = highest_popularity;
+          first_color_index = color_index;
+          highest_popularity = color_popularity[color_index];
+        } else if (color_popularity[color_index] > second_highest_popularity) {
+          third_color_index = second_color_index;
+          third_highest_popularity = second_highest_popularity;
+          second_color_index = color_index;
+          second_highest_popularity = color_popularity[color_index];
+        } else if (color_popularity[color_index] > third_highest_popularity) {
+          third_color_index = color_index;
+          third_highest_popularity = color_popularity[color_index];
+        }
+      }
+
+      // ZX images can't mix bright and regular colours, except black which appears in both.
+      // Resolve any conflict:
+      while (1) {
+        // If either colour is black, there's no conflict to resolve.
+        if (first_color_index != 0 && second_color_index != 0) {
+          if (first_color_index >= 8 && second_color_index < 8) {
+            // Make the second color bright
+            second_color_index = second_color_index + 7;
+          } else if (first_color_index < 8 && second_color_index >= 8) {
+            // Make the second color regular
+            second_color_index = second_color_index - 7;
+          }
+        }
+
+        // If, during conflict resolving, we now have two of the same colour (because we initially
+        // selected the bright & regular version of the same colour), retry again with the third
+        // most popular colour.
+        if (first_color_index == second_color_index) {
+          second_color_index = third_color_index;
+        } else break;
+      }
+
+      // Quantize
+      attr = liq_attr_create();
+      image = liq_image_create_rgba(attr, block, block_width, block_height, 0);
+      liq_set_max_colors(attr, 2);
+      liq_image_add_fixed_color(image, zx_colors[first_color_index]);
+      liq_image_add_fixed_color(image, zx_colors[second_color_index]);
+      liq_image_quantize(image, attr, &res);
+      liq_set_dithering_level(res, dithering);
+      liq_write_remapped_image(res, image, image8bit, size);
+      const liq_palette *pal = liq_get_palette(res);
+
+      // Turn palletted image back into an RGBA image, and write it into the full size result image.
+      for(int y = 0; y < block_height; y++) {
+        for(int x = 0; x < block_width; x++) {
+          int image8BitPos = y * block_width + x;
+          int resultStartPos = ((block_start_y + y) * bytes_per_pixel * image_width) + ((block_start_x + x) * bytes_per_pixel);
+          result[resultStartPos + 0] = pal->entries[image8bit[image8BitPos]].r;
+          result[resultStartPos + 1] = pal->entries[image8bit[image8BitPos]].g;
+          result[resultStartPos + 2] = pal->entries[image8bit[image8BitPos]].b;
+          result[resultStartPos + 3] = pal->entries[image8bit[image8BitPos]].a;
+        }
+      }
+
+      liq_result_destroy(res);
+      liq_image_destroy(image);
+      liq_attr_destroy(attr);
+    }
+  }
+
+  free(image8bit);
+  return {
+    val(typed_memory_view(image_width*image_height*4, result)),
+    image_width,
+    image_height
+  };
+}
+
+void free_result() {
+  free(result);
+}
+
+EMSCRIPTEN_BINDINGS(my_module) {
+  class_<RawImage>("RawImage")
+    .property("buffer", &RawImage::buffer)
+    .property("width", &RawImage::width)
+    .property("height", &RawImage::height);
+
+  function("quantize", &quantize);
+  function("zx_quantize", &zx_quantize);
+  function("version", &version);
+  function("free_result", &free_result);
+}

codecs/imagequant/imagequant.d.ts

@@ -0,0 +1,15 @@
+interface RawImage {
+  buffer: Uint8Array;
+  width: number;
+  height: number;
+}
+
+interface QuantizerModule extends EmscriptenWasm.Module {
+  quantize(data: BufferSource, width: number, height: number, numColors: number, dither: number): RawImage;
+  zx_quantize(data: BufferSource, width: number, height: number, dither: number): RawImage;
+  free_result(): void;
+}
+
+export default function(opts: EmscriptenWasm.ModuleOpts): QuantizerModule;
+
+

codecs/imagequant/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "imagequant",
+  "scripts": {
+    "install": "napa",
+    "build": "docker run --rm -v $(pwd):/src trzeci/emscripten ./build.sh"
+  },
+  "napa": {
+    "libimagequant": "ImageOptim/libimagequant#2.12.1"
+  },
+  "devDependencies": {
+    "napa": "3.0.0"
+  }
+}

codecs/mozjpeg_enc/README.md

@@ -0,0 +1,47 @@
+# MozJPEG encoder
+
+- Source: <https://github.com/mozilla/mozjpeg>
+- Version: v3.3.1
+
+## Dependencies
+
+- Docker
+
+## Example
+
+See `example.html`
+
+## API
+
+### `int version()`
+
+Returns the version of MozJPEG as a number. va.b.c is encoded as 0x0a0b0c
+
+### `void free_result()`
+
+Frees the result created by `encode()`.
+
+### `Uint8Array encode(std::string image_in, int image_width, int image_height, MozJpegOptions opts)`
+
+Encodes the given image with given dimension to JPEG. Options looks like this:
+
+```c++
+struct MozJpegOptions {
+  int quality;
+  bool baseline;
+  bool arithmetic;
+  bool progressive;
+  bool optimize_coding;
+  int smoothing;
+  int color_space;
+  int quant_table;
+  bool trellis_multipass;
+  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/build.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+
+set -e
+
+export OPTIMIZE="-Os"
+export LDFLAGS="${OPTIMIZE}"
+export CFLAGS="${OPTIMIZE}"
+export CPPFLAGS="${OPTIMIZE}"
+
+apt-get update
+apt-get install -qqy autoconf libtool libpng-dev pkg-config
+
+echo "============================================="
+echo "Compiling mozjpeg"
+echo "============================================="
+(
+  cd node_modules/mozjpeg
+  autoreconf -fiv
+  emconfigure ./configure --without-simd
+  emmake make libjpeg.la
+)
+echo "============================================="
+echo "Compiling mozjpeg done"
+echo "============================================="
+
+echo "============================================="
+echo "Compiling wasm bindings"
+echo "============================================="
+(
+  emcc \
+    --bind \
+    ${OPTIMIZE} \
+    -s WASM=1 \
+    -s ALLOW_MEMORY_GROWTH=1 \
+    -s MODULARIZE=1 \
+    -s 'EXPORT_NAME="mozjpeg_enc"' \
+    -I node_modules/mozjpeg \
+    -o ./mozjpeg_enc.js \
+    -Wno-deprecated-register \
+    -Wno-writable-strings \
+    node_modules/mozjpeg/rdswitch.c \
+    -x c++ -std=c++11 \
+    mozjpeg_enc.cpp \
+    node_modules/mozjpeg/.libs/libjpeg.a
+)
+echo "============================================="
+echo "Compiling wasm bindings done"
+echo "============================================="
+
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+echo "Did you update your docker image?"
+echo "Run \`docker pull trzeci/emscripten\`"
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"

codecs/mozjpeg_enc/example.html

@@ -0,0 +1,48 @@
+<!doctype html>
+<script src='mozjpeg_enc.js'></script>
+<script>
+  const module = mozjpeg_enc();
+
+  async function loadImage(src) {
+    // Load image
+    const img = document.createElement('img');
+    img.src = src;
+    await new Promise(resolve => img.onload = resolve);
+    // Make canvas same size as image
+    const canvas = document.createElement('canvas');
+    [canvas.width, canvas.height] = [img.width, img.height];
+    // Draw image onto canvas
+    const ctx = canvas.getContext('2d');
+    ctx.drawImage(img, 0, 0);
+    return ctx.getImageData(0, 0, img.width, img.height);
+  }
+
+  module.onRuntimeInitialized = async _ => {
+    console.log('Version:', module.version().toString(16));
+    const image = await loadImage('../example.png');
+    const result = module.encode(image.data, image.width, image.height, {
+      quality: 75,
+      baseline: false,
+      arithmetic: false,
+      progressive: true,
+      optimize_coding: true,
+      smoothing: 0,
+      color_space: 3,
+      quant_table: 3,
+      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'});
+    const blobURL = URL.createObjectURL(blob);
+    const img = document.createElement('img');
+    img.src = blobURL;
+    document.body.appendChild(img);
+  };
+</script>

codecs/mozjpeg_enc/mozjpeg_enc.cpp

@@ -0,0 +1,234 @@
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <setjmp.h>
+#include <string.h>
+#include "config.h"
+#include "jpeglib.h"
+#include "cdjpeg.h"
+
+using namespace emscripten;
+
+// MozJPEG doesn’t expose a numeric version, so I have to do some fun C macro hackery to turn it
+// into a string. More details here: https://gcc.gnu.org/onlinedocs/cpp/Stringizing.html
+#define xstr(s) str(s)
+#define str(s) #s
+
+struct MozJpegOptions {
+  int quality;
+  bool baseline;
+  bool arithmetic;
+  bool progressive;
+  bool optimize_coding;
+  int smoothing;
+  int color_space;
+  int quant_table;
+  bool trellis_multipass;
+  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() {
+  char buffer[] = xstr(MOZJPEG_VERSION);
+  int version = 0;
+  int last_index = 0;
+  for(int i = 0; i < strlen(buffer); i++) {
+    if(buffer[i] == '.') {
+      buffer[i] = '\0';
+      version = version << 8 | atoi(&buffer[last_index]);
+      buffer[i] = '.';
+      last_index = i + 1;
+    }
+  }
+  version = version << 8 | atoi(&buffer[last_index]);
+  return version;
+}
+
+uint8_t* last_result;
+struct jpeg_compress_struct cinfo;
+
+val encode(std::string image_in, int image_width, int image_height, MozJpegOptions opts) {
+  uint8_t* image_buffer = (uint8_t*) image_in.c_str();
+
+  // The code below is basically the `write_JPEG_file` function from
+  // https://github.com/mozilla/mozjpeg/blob/master/example.c
+  // I just write to memory instead of a file.
+
+
+  /* This struct contains the JPEG compression parameters and pointers to
+   * working space (which is allocated as needed by the JPEG library).
+   * It is possible to have several such structures, representing multiple
+   * compression/decompression processes, in existence at once.  We refer
+   * to any one struct (and its associated working data) as a "JPEG object".
+   */
+  /* This struct represents a JPEG error handler.  It is declared separately
+   * because applications often want to supply a specialized error handler
+   * (see the second half of this file for an example).  But here we just
+   * take the easy way out and use the standard error handler, which will
+   * print a message on stderr and call exit() if compression fails.
+   * Note that this struct must live as long as the main JPEG parameter
+   * struct, to avoid dangling-pointer problems.
+   */
+  struct jpeg_error_mgr jerr;
+  /* More stuff */
+  JSAMPROW row_pointer[1];      /* pointer to JSAMPLE row[s] */
+  int row_stride;               /* physical row width in image buffer */
+  uint8_t* output;
+  unsigned long size;
+
+  /* Step 1: allocate and initialize JPEG compression object */
+
+  /* We have to set up the error handler first, in case the initialization
+   * step fails.  (Unlikely, but it could happen if you are out of memory.)
+   * This routine fills in the contents of struct jerr, and returns jerr's
+   * address which we place into the link field in cinfo.
+   */
+  cinfo.err = jpeg_std_error(&jerr);
+  /* Now we can initialize the JPEG compression object. */
+  jpeg_create_compress(&cinfo);
+
+  /* Step 2: specify data destination (eg, a file) */
+  /* Note: steps 2 and 3 can be done in either order. */
+
+  /* Here we use the library-supplied code to send compressed data to a
+   * stdio stream.  You can also write your own code to do something else.
+   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
+   * requires it in order to write binary files.
+   */
+  // if ((outfile = fopen(filename, "wb")) == NULL) {
+  //   fprintf(stderr, "can't open %s\n", filename);
+  //   exit(1);
+  // }
+  jpeg_mem_dest(&cinfo, &output, &size);
+
+  /* Step 3: set parameters for compression */
+
+  /* First we supply a description of the input image.
+   * Four fields of the cinfo struct must be filled in:
+   */
+  cinfo.image_width = image_width;      /* image width and height, in pixels */
+  cinfo.image_height = image_height;
+  cinfo.input_components = 4;           /* # of color components per pixel */
+  cinfo.in_color_space = JCS_EXT_RGBA;  /* colorspace of input image */
+  /* Now use the library's routine to set default compression parameters.
+   * (You must set at least cinfo.in_color_space before calling this,
+   * since the defaults depend on the source color space.)
+   */
+  jpeg_set_defaults(&cinfo);
+
+  jpeg_set_colorspace(&cinfo, (J_COLOR_SPACE) opts.color_space);
+
+  if (opts.quant_table != -1) {
+    jpeg_c_set_int_param(&cinfo, JINT_BASE_QUANT_TBL_IDX, opts.quant_table);
+  }
+
+  cinfo.optimize_coding = opts.optimize_coding;
+
+  if (opts.arithmetic) {
+    cinfo.arith_code = TRUE;
+    cinfo.optimize_coding = FALSE;
+  }
+
+  cinfo.smoothing_factor = opts.smoothing;
+
+  jpeg_c_set_bool_param(&cinfo, JBOOLEAN_USE_SCANS_IN_TRELLIS, opts.trellis_multipass);
+  jpeg_c_set_bool_param(&cinfo, JBOOLEAN_TRELLIS_EOB_OPT, opts.trellis_opt_zero);
+  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 {
+    cinfo.num_scans = 0;
+    cinfo.scan_info = NULL;
+  }
+  /* Step 4: Start compressor */
+
+  /* TRUE ensures that we will write a complete interchange-JPEG file.
+   * Pass TRUE unless you are very sure of what you're doing.
+   */
+  jpeg_start_compress(&cinfo, TRUE);
+
+  /* Step 5: while (scan lines remain to be written) */
+  /*           jpeg_write_scanlines(...); */
+
+  /* Here we use the library's state variable cinfo.next_scanline as the
+   * loop counter, so that we don't have to keep track ourselves.
+   * To keep things simple, we pass one scanline per call; you can pass
+   * more if you wish, though.
+   */
+  row_stride = image_width * 4; /* JSAMPLEs per row in image_buffer */
+
+  while (cinfo.next_scanline < cinfo.image_height) {
+    /* jpeg_write_scanlines expects an array of pointers to scanlines.
+     * Here the array is only one element long, but you could pass
+     * more than one scanline at a time if that's more convenient.
+     */
+    row_pointer[0] = & image_buffer[cinfo.next_scanline * row_stride];
+    (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
+  }
+
+  /* Step 6: Finish compression */
+
+  jpeg_finish_compress(&cinfo);
+  /* Step 7: release JPEG compression object */
+
+  last_result = output;
+
+  /* And we're done! */
+  return val(typed_memory_view(size, output));
+}
+
+void free_result() {
+  /* This is an important step since it will release a good deal of memory. */
+  jpeg_destroy_compress(&cinfo);
+}
+
+EMSCRIPTEN_BINDINGS(my_module) {
+  value_object<MozJpegOptions>("MozJpegOptions")
+    .field("quality", &MozJpegOptions::quality)
+    .field("baseline", &MozJpegOptions::baseline)
+    .field("arithmetic", &MozJpegOptions::arithmetic)
+    .field("progressive", &MozJpegOptions::progressive)
+    .field("optimize_coding", &MozJpegOptions::optimize_coding)
+    .field("smoothing", &MozJpegOptions::smoothing)
+    .field("color_space", &MozJpegOptions::color_space)
+    .field("quant_table", &MozJpegOptions::quant_table)
+    .field("trellis_multipass", &MozJpegOptions::trellis_multipass)
+    .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);
+  function("encode", &encode);
+  function("free_result", &free_result);
+}

codecs/mozjpeg_enc/mozjpeg_enc.d.ts

@@ -0,0 +1,8 @@
+import { EncodeOptions } from '../../src/codecs/mozjpeg/encoder-meta';
+
+interface MozJPEGModule extends EmscriptenWasm.Module {
+  encode(data: BufferSource, width: number, height: number, options: EncodeOptions): Uint8Array;
+  free_result(): void;
+}
+
+export default function(opts: EmscriptenWasm.ModuleOpts): MozJPEGModule;

codecs/mozjpeg_enc/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "mozjpeg_enc",
+  "scripts": {
+    "install": "napa",
+    "build": "docker run --rm -v $(pwd):/src trzeci/emscripten ./build.sh"
+  },
+  "napa": {
+    "mozjpeg": "mozilla/mozjpeg#v3.3.1"
+  },
+  "devDependencies": {
+    "napa": "3.0.0"
+  }
+}

codecs/optipng/.gitignore

@@ -0,0 +1,2 @@
+build/
+*.o

codecs/optipng/README.md

@@ -0,0 +1,26 @@
+# OptiPNG
+
+- Source: <http://optipng.sourceforge.net/>
+- Version: v0.7.7
+
+## Dependencies
+
+- Docker
+
+## Example
+
+See `example.html`
+
+## API
+
+### `int version()`
+
+Returns the version of optipng as a number. va.b.c is encoded as 0x0a0b0c
+
+### `ArrayBuffer compress(std::string buffer, {level})`;
+
+`compress` will re-compress the given PNG image via `buffer`. `level` is a number between 0 and 7.
+
+### `void free_result()`
+
+Frees the result created by `compress()`.

codecs/optipng/build.sh

@@ -0,0 +1,87 @@
+#!/bin/bash
+
+set -e
+
+export OPTIMIZE="-Os"
+export PREFIX="/src/build"
+export CFLAGS="${OPTIMIZE} -I${PREFIX}/include/"
+export CPPFLAGS="${OPTIMIZE} -I${PREFIX}/include/"
+export LDFLAGS="${OPTIMIZE} -L${PREFIX}/lib/"
+
+apt-get update
+apt-get install -qqy autoconf libtool
+
+echo "============================================="
+echo "Compiling zlib"
+echo "============================================="
+test -n "$SKIP_ZLIB" || (
+  cd node_modules/zlib
+  emconfigure ./configure --prefix=${PREFIX}/
+  emmake make
+  emmake make install
+)
+echo "============================================="
+echo "Compiling zlib done"
+echo "============================================="
+
+echo "============================================="
+echo "Compiling libpng"
+echo "============================================="
+test -n "$SKIP_LIBPNG" || (
+  cd node_modules/libpng
+  autoreconf -i
+  emconfigure ./configure --with-zlib-prefix=${PREFIX}/ --prefix=${PREFIX}/
+  emmake make
+  emmake make install
+)
+echo "============================================="
+echo "Compiling libpng done"
+echo "============================================="
+
+echo "============================================="
+echo "Compiling optipng"
+echo "============================================="
+(
+  emcc \
+    ${OPTIMIZE} \
+    -Wno-implicit-function-declaration \
+    -I ${PREFIX}/include \
+    -I node_modules/optipng/src/opngreduc \
+    -I node_modules/optipng/src/pngxtern \
+    -I node_modules/optipng/src/cexcept \
+    -I node_modules/optipng/src/gifread \
+    -I node_modules/optipng/src/pnmio \
+    -I node_modules/optipng/src/minitiff \
+    --std=c99 -c \
+    node_modules/optipng/src/opngreduc/*.c \
+    node_modules/optipng/src/pngxtern/*.c \
+    node_modules/optipng/src/gifread/*.c \
+    node_modules/optipng/src/minitiff/*.c \
+    node_modules/optipng/src/pnmio/*.c \
+    node_modules/optipng/src/optipng/*.c
+
+  emcc \
+    --bind \
+    ${OPTIMIZE} \
+    -s ALLOW_MEMORY_GROWTH=1 -s MODULARIZE=1 -s 'EXPORT_NAME="optipng"' \
+    -I ${PREFIX}/include \
+    -I node_modules/optipng/src/opngreduc \
+    -I node_modules/optipng/src/pngxtern \
+    -I node_modules/optipng/src/cexcept \
+    -I node_modules/optipng/src/gifread \
+    -I node_modules/optipng/src/pnmio \
+    -I node_modules/optipng/src/minitiff \
+    -o "optipng.js" \
+    --std=c++11 \
+    optipng.cpp \
+    *.o \
+    ${PREFIX}/lib/libz.so ${PREFIX}/lib/libpng.a
+)
+echo "============================================="
+echo "Compiling optipng done"
+echo "============================================="
+
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+echo "Did you update your docker image?"
+echo "Run \`docker pull trzeci/emscripten\`"
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"

codecs/optipng/example.html

@@ -0,0 +1,19 @@
+<!doctype html>
+<script src='optipng.js'></script>
+<script>
+  const Module = optipng();
+
+  Module.onRuntimeInitialized = async _ => {
+    console.log('Version:', Module.version().toString(16));
+    const image = await fetch('../example_palette.png').then(r => r.arrayBuffer());
+    const newImage = Module.compress(image, {level: 3});
+    console.log('done');
+    Module.free_result();
+
+    console.log(`Old size: ${image.byteLength}, new size: ${newImage.byteLength} (${newImage.byteLength/image.byteLength*100}%)`);
+    const blobURL = URL.createObjectURL(new Blob([newImage], {type: 'image/png'}));
+    const img = document.createElement('img');
+    img.src = blobURL;
+    document.body.appendChild(img);
+  };
+</script>

codecs/optipng/optipng.cpp

@@ -0,0 +1,53 @@
+#include "emscripten/bind.h"
+#include "emscripten/val.h"
+
+#include <stdio.h>
+
+using namespace emscripten;
+
+extern "C" int main(int argc, char *argv[]);
+
+int version() {
+  // FIXME (@surma): Haven’t found a version in optipng :(
+  return 0;
+}
+
+struct OptiPngOpts {
+  int level;
+};
+
+uint8_t* result;
+val compress(std::string png, OptiPngOpts opts) {
+  remove("input.png");
+  remove("output.png");
+  FILE* infile = fopen("input.png", "wb");
+  fwrite(png.c_str(), png.length(), 1, infile);
+  fflush(infile);
+  fclose(infile);
+
+  char optlevel[8];
+  sprintf(&optlevel[0], "-o%d", opts.level);
+  char* args[] = {"optipng", optlevel, "-out", "output.png", "input.png"};
+  main(5, args);
+
+  FILE *outfile = fopen("output.png", "rb");
+  fseek(outfile, 0, SEEK_END);
+  int fsize = ftell(outfile);
+  result = (uint8_t*) malloc(fsize);
+  fseek(outfile, 0, SEEK_SET);
+  fread(result, fsize, 1, outfile);
+  return val(typed_memory_view(fsize, result));
+}
+
+void free_result() {
+  free(result);
+}
+
+EMSCRIPTEN_BINDINGS(my_module) {
+  value_object<OptiPngOpts>("OptiPngOpts")
+    .field("level", &OptiPngOpts::level);
+
+  function("version", &version);
+  function("compress", &compress);
+  function("free_result", &free_result);
+}

codecs/optipng/optipng.d.ts

@@ -0,0 +1,10 @@
+import {EncodeOptions} from "src/codecs/optipng/encoder";
+
+export interface OptiPngModule extends EmscriptenWasm.Module {
+  compress(data: BufferSource, opts: EncodeOptions): Uint8Array;
+  free_result(): void;
+}
+
+export default function(opts: EmscriptenWasm.ModuleOpts): OptiPngModule;
+
+

codecs/optipng/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "optipng",
+  "scripts": {
+    "install": "tar-dependency install && napa",
+    "build": "npm run build:wasm",
+    "build:wasm": "docker run --rm -v $(pwd):/src -e SKIP_ZLIB=\"${SKIP_ZLIB}\" -e SKIP_LIBPNG=\"${SKIP_LIBPNG}\" trzeci/emscripten ./build.sh"
+  },
+  "tarDependencies": {
+    "node_modules/optipng": {
+      "url": "https://netcologne.dl.sourceforge.net/project/optipng/OptiPNG/optipng-0.7.7/optipng-0.7.7.tar.gz",
+      "strip": 1
+    }
+  },
+  "napa": {
+    "libpng": "emscripten-ports/libpng",
+    "zlib": "emscripten-ports/zlib"
+  },
+  "dependencies": {
+    "napa": "3.0.0",
+    "tar-dependency": "0.0.3"
+  }
+}

codecs/resize/.gitignore

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

codecs/resize/Cargo.toml

@@ -0,0 +1,37 @@
+[package]
+name = "squooshresize"
+version = "0.1.0"
+authors = ["Surma <surma@surma.link>"]
+
+[lib]
+#crate-type = ["cdylib", "rlib"]
+crate-type = ["cdylib"]
+
+[features]
+default = ["console_error_panic_hook", "wee_alloc"]
+
+[dependencies]
+cfg-if = "0.1.2"
+wasm-bindgen = "0.2.38"
+resize = "0.3.0"
+
+# The `console_error_panic_hook` crate provides better debugging of panics by
+# logging them with `console.error`. This is great for development, but requires
+# all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
+# code size when deploying.
+console_error_panic_hook = { version = "0.1.1", optional = true }
+
+# `wee_alloc` is a tiny allocator for wasm that is only ~1K in code size
+# compared to the default allocator's ~10K. It is slower than the default
+# allocator, however.
+#
+# Unfortunately, `wee_alloc` requires nightly Rust when targeting wasm for now.
+wee_alloc = { version = "0.4.2", optional = true }
+
+[dev-dependencies]
+wasm-bindgen-test = "0.2"
+
+[profile.release]
+# Tell `rustc` to optimize for small code size.
+opt-level = "s"
+lto = true

codecs/resize/Dockerfile

@@ -0,0 +1,18 @@
+FROM ubuntu
+RUN apt-get update && \
+  apt-get install -qqy git build-essential cmake python2.7
+RUN git clone --recursive https://github.com/WebAssembly/wabt /usr/src/wabt
+RUN mkdir -p /usr/src/wabt/build
+WORKDIR /usr/src/wabt/build
+RUN cmake .. -DCMAKE_INSTALL_PREFIX=/opt/wabt && \
+  make && \
+  make install
+
+FROM rust
+RUN rustup install nightly && \
+  rustup target add --toolchain nightly wasm32-unknown-unknown && \
+  cargo install wasm-pack
+
+COPY --from=0 /opt/wabt /opt/wabt
+ENV PATH="/opt/wabt/bin:${PATH}"
+WORKDIR /src

codecs/resize/benchmark.js

@@ -0,0 +1,53 @@
+// THIS IS NOT A NODE SCRIPT
+// This is a d8 script. Please install jsvu[1] and install v8.
+// Then run `npm run --silent benchmark`.
+// [1]: https://github.com/GoogleChromeLabs/jsvu
+
+self = global = this;
+load("./pkg/resize.js");
+
+async function init() {
+  //  Adjustable constants.
+  const inputDimensions = 2000;
+  const outputDimensions = 1500;
+  const algorithm = 3; // Lanczos
+  const iterations = new Array(100);
+
+  // Constants. Don’t change.
+  const imageByteSize = inputDimensions * inputDimensions * 4;
+  const imageBuffer = new Uint8ClampedArray(imageByteSize);
+
+  const module = await WebAssembly.compile(readbuffer("./pkg/resize_bg.wasm"));
+  await wasm_bindgen(module);
+  [[false, false], [true, false], [false, true], [true, true]].forEach(
+    opts => {
+      print(`\npremultiplication: ${opts[0]}`);
+      print(`color space conversion: ${opts[1]}`);
+      print(`==============================`);
+      for (let i = 0; i < 100; i++) {
+        const start = Date.now();
+        wasm_bindgen.resize(
+          imageBuffer,
+          inputDimensions,
+          inputDimensions,
+          outputDimensions,
+          outputDimensions,
+          algorithm,
+          ...opts
+        );
+        iterations[i] = Date.now() - start;
+      }
+      const average =
+        iterations.reduce((sum, c) => sum + c) / iterations.length;
+      const stddev = Math.sqrt(
+        iterations
+          .map(i => Math.pow(i - average, 2))
+          .reduce((sum, c) => sum + c) / iterations.length
+      );
+      print(`n = ${iterations.length}`);
+      print(`Average: ${average}`);
+      print(`StdDev: ${stddev}`);
+    }
+  );
+}
+init().catch(e => console.error(e, e.stack));

codecs/resize/build.rs

@@ -0,0 +1,23 @@
+include!("./src/srgb.rs");
+
+use std::io::Write;
+
+fn main() -> std::io::Result<()> {
+    let mut srgb_to_linear_lut = String::from("static SRGB_TO_LINEAR_LUT: [f32; 256] = [");
+    let mut linear_to_srgb_lut = String::from("static LINEAR_TO_SRGB_LUT: [f32; 256] = [");
+    for i in 0..256 {
+        srgb_to_linear_lut.push_str(&format!("{0:.7}", srgb_to_linear((i as f32) / 255.0)));
+        srgb_to_linear_lut.push_str(",");
+        linear_to_srgb_lut.push_str(&format!("{0:.7}", linear_to_srgb((i as f32) / 255.0)));
+        linear_to_srgb_lut.push_str(",");
+    }
+    srgb_to_linear_lut.pop().unwrap();
+    linear_to_srgb_lut.pop().unwrap();
+    srgb_to_linear_lut.push_str("];");
+    linear_to_srgb_lut.push_str("];");
+
+    let mut file = std::fs::File::create("src/lut.inc")?;
+    file.write_all(srgb_to_linear_lut.as_bytes())?;
+    file.write_all(linear_to_srgb_lut.as_bytes())?;
+    Ok(())
+}

codecs/resize/build.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+set -e
+
+echo "============================================="
+echo "Compiling wasm"
+echo "============================================="
+(
+  rustup run nightly \
+    wasm-pack build --target no-modules
+  wasm-strip pkg/resize_bg.wasm
+)
+echo "============================================="
+echo "Compiling wasm  done"
+echo "============================================="
+
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+echo "Did you update your docker image?"
+echo "Run \`docker pull ubuntu\`"
+echo "Run \`docker pull rust\`"
+echo "Run \`docker build -t squoosh-resize .\`"
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"

codecs/resize/package-lock.json

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

codecs/resize/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "resize",
+  "scripts": {
+    "build:image": "docker build -t squoosh-resize .",
+    "build": "docker run --rm -v $(pwd):/src squoosh-resize ./build.sh",
+    "benchmark": "v8 --no-liftoff --no-wasm-tier-up ./benchmark.js"
+  }
+}

codecs/resize/pkg/resize.d.ts

@@ -0,0 +1,13 @@
+/* tslint:disable */
+/**
+* @param {Uint8Array} arg0 
+* @param {number} arg1 
+* @param {number} arg2 
+* @param {number} arg3 
+* @param {number} arg4 
+* @param {number} arg5 
+* @param {boolean} arg6 
+* @param {boolean} arg7 
+* @returns {Uint8Array} 
+*/
+export function resize(arg0: Uint8Array, arg1: number, arg2: number, arg3: number, arg4: number, arg5: number, arg6: boolean, arg7: boolean): Uint8Array;

codecs/resize/pkg/resize.js

@@ -0,0 +1,114 @@
+(function() {
+    var wasm;
+    const __exports = {};
+
+
+    let cachegetUint8Memory = null;
+    function getUint8Memory() {
+        if (cachegetUint8Memory === null || cachegetUint8Memory.buffer !== wasm.memory.buffer) {
+            cachegetUint8Memory = new Uint8Array(wasm.memory.buffer);
+        }
+        return cachegetUint8Memory;
+    }
+
+    let WASM_VECTOR_LEN = 0;
+
+    function passArray8ToWasm(arg) {
+        const ptr = wasm.__wbindgen_malloc(arg.length * 1);
+        getUint8Memory().set(arg, ptr / 1);
+        WASM_VECTOR_LEN = arg.length;
+        return ptr;
+    }
+
+    function getArrayU8FromWasm(ptr, len) {
+        return getUint8Memory().subarray(ptr / 1, ptr / 1 + len);
+    }
+
+    let cachedGlobalArgumentPtr = null;
+    function globalArgumentPtr() {
+        if (cachedGlobalArgumentPtr === null) {
+            cachedGlobalArgumentPtr = wasm.__wbindgen_global_argument_ptr();
+        }
+        return cachedGlobalArgumentPtr;
+    }
+
+    let cachegetUint32Memory = null;
+    function getUint32Memory() {
+        if (cachegetUint32Memory === null || cachegetUint32Memory.buffer !== wasm.memory.buffer) {
+            cachegetUint32Memory = new Uint32Array(wasm.memory.buffer);
+        }
+        return cachegetUint32Memory;
+    }
+    /**
+    * @param {Uint8Array} arg0
+    * @param {number} arg1
+    * @param {number} arg2
+    * @param {number} arg3
+    * @param {number} arg4
+    * @param {number} arg5
+    * @param {boolean} arg6
+    * @param {boolean} arg7
+    * @returns {Uint8Array}
+    */
+    __exports.resize = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        const ptr0 = passArray8ToWasm(arg0);
+        const len0 = WASM_VECTOR_LEN;
+        const retptr = globalArgumentPtr();
+        wasm.resize(retptr, ptr0, len0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+        const mem = getUint32Memory();
+        const rustptr = mem[retptr / 4];
+        const rustlen = mem[retptr / 4 + 1];
+
+        const realRet = getArrayU8FromWasm(rustptr, rustlen).slice();
+        wasm.__wbindgen_free(rustptr, rustlen * 1);
+        return realRet;
+
+    };
+
+    const heap = new Array(32);
+
+    heap.fill(undefined);
+
+    heap.push(undefined, null, true, false);
+
+    let heap_next = heap.length;
+
+    function dropObject(idx) {
+        if (idx < 36) return;
+        heap[idx] = heap_next;
+        heap_next = idx;
+    }
+
+    __exports.__wbindgen_object_drop_ref = function(i) { dropObject(i); };
+
+    function init(path_or_module) {
+        let instantiation;
+        const imports = { './resize': __exports };
+        if (path_or_module instanceof WebAssembly.Module) {
+            instantiation = WebAssembly.instantiate(path_or_module, imports)
+            .then(instance => {
+            return { instance, module: path_or_module }
+        });
+    } else {
+        const data = fetch(path_or_module);
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            instantiation = WebAssembly.instantiateStreaming(data, imports)
+            .catch(e => {
+                console.warn("`WebAssembly.instantiateStreaming` failed. Assuming this is because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+                return data
+                .then(r => r.arrayBuffer())
+                .then(bytes => WebAssembly.instantiate(bytes, imports));
+            });
+        } else {
+            instantiation = data
+            .then(response => response.arrayBuffer())
+            .then(buffer => WebAssembly.instantiate(buffer, imports));
+        }
+    }
+    return instantiation.then(({instance}) => {
+        wasm = init.wasm = instance.exports;
+
+    });
+};
+self.wasm_bindgen = Object.assign(init, __exports);
+})();

codecs/resize/pkg/resize_bg.d.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+export const memory: WebAssembly.Memory;
+export function __wbindgen_global_argument_ptr(): number;
+export function __wbindgen_malloc(a: number): number;
+export function __wbindgen_free(a: number, b: number): void;
+export function resize(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number): void;

codecs/resize/src/lib.rs

@@ -0,0 +1,121 @@
+extern crate cfg_if;
+extern crate resize;
+extern crate wasm_bindgen;
+
+mod utils;
+
+use cfg_if::cfg_if;
+use resize::Pixel::RGBA;
+use resize::Type;
+use wasm_bindgen::prelude::*;
+
+mod srgb;
+use srgb::Clamp;
+
+cfg_if! {
+    // When the `wee_alloc` feature is enabled, use `wee_alloc` as the global
+    // allocator.
+    if #[cfg(feature = "wee_alloc")] {
+        extern crate wee_alloc;
+        #[global_allocator]
+        static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
+    }
+}
+
+include!("./lut.inc");
+
+// If `with_space_conversion` is true, this function returns 2 functions that
+// convert from sRGB to linear RGB and vice versa. If `with_space_conversion` is
+// false, the 2 functions returned do nothing.
+fn converter_funcs(with_space_conversion: bool) -> ((fn(u8) -> f32), (fn(f32) -> u8)) {
+    if with_space_conversion {
+        (
+            |v| SRGB_TO_LINEAR_LUT[v as usize] * 255.0,
+            |v| (LINEAR_TO_SRGB_LUT[v as usize] * 255.0) as u8,
+        )
+    } else {
+        (|v| v as f32, |v| v as u8)
+    }
+}
+
+// If `with_alpha_premultiplication` is true, this function returns a function
+// that premultiply the alpha channel with the given channel value and another
+// function that reverses that process. If `with_alpha_premultiplication` is
+// false, the functions just return the channel value.
+fn alpha_multiplier_funcs(
+    with_alpha_premultiplication: bool,
+) -> ((fn(f32, u8) -> u8), (fn(u8, u8) -> f32)) {
+    if with_alpha_premultiplication {
+        (
+            |v, a| (v * (a as f32) / 255.0) as u8,
+            |v, a| (v as f32) * 255.0 / (a as f32).clamp(0.0, 255.0),
+        )
+    } else {
+        (|v, _a| v as u8, |v, _a| v as f32)
+    }
+}
+
+#[wasm_bindgen]
+#[no_mangle]
+pub fn resize(
+    mut input_image: Vec<u8>,
+    input_width: usize,
+    input_height: usize,
+    output_width: usize,
+    output_height: usize,
+    typ_idx: usize,
+    premultiply: bool,
+    color_space_conversion: bool,
+) -> Vec<u8> {
+    let typ = match typ_idx {
+        0 => Type::Triangle,
+        1 => Type::Catrom,
+        2 => Type::Mitchell,
+        3 => Type::Lanczos3,
+        _ => panic!("Nope"),
+    };
+    let num_input_pixels = input_width * input_height;
+    let num_output_pixels = output_width * output_height;
+
+    let (to_linear, to_color_space) = converter_funcs(color_space_conversion);
+    let (premultiplier, demultiplier) = alpha_multiplier_funcs(premultiply);
+
+    // If both options are false, there is no preprocessing on the pixel valus
+    // and we can skip the loop.
+    if premultiply || color_space_conversion {
+        for i in 0..num_input_pixels {
+            for j in 0..3 {
+                input_image[4 * i + j] =
+                    premultiplier(to_linear(input_image[4 * i + j]), input_image[4 * i + 3]);
+            }
+        }
+    }
+
+    let mut resizer = resize::new(
+        input_width,
+        input_height,
+        output_width,
+        output_height,
+        RGBA,
+        typ,
+    );
+    let mut output_image = Vec::<u8>::with_capacity(num_output_pixels * 4);
+    output_image.resize(num_output_pixels * 4, 0);
+    resizer.resize(input_image.as_slice(), output_image.as_mut_slice());
+
+    if premultiply || color_space_conversion {
+        for i in 0..num_output_pixels {
+            for j in 0..3 {
+                // We don’t need to worry about division by zero, as division by zero
+                // is well-defined on floats to return ±Inf. ±Inf is converted to 0
+                // when casting to integers.
+                output_image[4 * i + j] = to_color_space(demultiplier(
+                    output_image[4 * i + j],
+                    output_image[4 * i + 3],
+                ));
+            }
+        }
+    }
+
+    return output_image;
+}

codecs/resize/src/srgb.rs

@@ -0,0 +1,29 @@
+pub trait Clamp: std::cmp::PartialOrd + Sized {
+    fn clamp(self, min: Self, max: Self) -> Self {
+        if self.lt(&min) {
+            min
+        } else if self.gt(&max) {
+            max
+        } else {
+            self
+        }
+    }
+}
+
+impl Clamp for f32 {}
+
+pub fn srgb_to_linear(v: f32) -> f32 {
+    if v < 0.04045 {
+        v / 12.92
+    } else {
+        ((v + 0.055) / 1.055).powf(2.4).clamp(0.0, 1.0)
+    }
+}
+
+pub fn linear_to_srgb(v: f32) -> f32 {
+    if v < 0.0031308 {
+        v * 12.92
+    } else {
+        (1.055 * v.powf(1.0 / 2.4) - 0.055).clamp(0.0, 1.0)
+    }
+}

codecs/resize/src/utils.rs

@@ -0,0 +1,17 @@
+use cfg_if::cfg_if;
+
+cfg_if! {
+    // When the `console_error_panic_hook` feature is enabled, we can call the
+    // `set_panic_hook` function at least once during initialization, and then
+    // we will get better error messages if our code ever panics.
+    //
+    // For more details see
+    // https://github.com/rustwasm/console_error_panic_hook#readme
+    if #[cfg(feature = "console_error_panic_hook")] {
+        extern crate console_error_panic_hook;
+        pub use self::console_error_panic_hook::set_once as set_panic_hook;
+    } else {
+        #[inline]
+        pub fn set_panic_hook() {}
+    }
+}

codecs/rotate/.gitignore

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

codecs/rotate/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "rotate"
+version = "0.1.0"
+authors = ["Surma <surma@google.com>"]
+edition = "2018"
+
+[lib]
+name = "rotate"
+path = "rotate.rs"
+crate-type = ["cdylib", "rlib"]
+
+[profile.release]
+lto = true
+opt-level = "s"

codecs/rotate/Dockerfile

@@ -0,0 +1,17 @@
+FROM ubuntu
+RUN apt-get update && \
+  apt-get install -qqy git build-essential cmake python2.7
+RUN git clone --recursive https://github.com/WebAssembly/wabt /usr/src/wabt
+RUN mkdir -p /usr/src/wabt/build
+WORKDIR /usr/src/wabt/build
+RUN cmake .. -DCMAKE_INSTALL_PREFIX=/opt/wabt && \
+  make && \
+  make install
+
+FROM rust
+RUN rustup install nightly && \
+  rustup target add --toolchain nightly wasm32-unknown-unknown
+
+COPY --from=0 /opt/wabt /opt/wabt
+ENV PATH="/opt/wabt/bin:${PATH}"
+WORKDIR /src

codecs/rotate/benchmark.js

@@ -0,0 +1,45 @@
+// THIS IS NOT A NODE SCRIPT
+// This is a d8 script. Please install jsvu[1] and install v8.
+// Then run `npm run --silent benchmark`.
+// [1]: https://github.com/GoogleChromeLabs/jsvu
+async function init() {
+  //  Adjustable constants.
+  const imageDimensions = 4096;
+  const iterations = new Array(100);
+
+  // Constants. Don’t change.
+  const imageByteSize = imageDimensions * imageDimensions * 4;
+  const wasmPageSize = 64 * 1024;
+
+  const buffer = readbuffer("rotate.wasm");
+  const { instance } = await WebAssembly.instantiate(buffer);
+
+  const pagesAvailable = Math.floor(
+    instance.exports.memory.buffer.byteLength / wasmPageSize
+  );
+  const pagesNeeded = Math.floor((imageByteSize * 2 + 4) / wasmPageSize) + 1;
+  const additionalPagesNeeded = pagesNeeded - pagesAvailable;
+  if (additionalPagesNeeded > 0) {
+    instance.exports.memory.grow(additionalPagesNeeded);
+  }
+
+  [0, 90, 180, 270].forEach(rotation => {
+    print(`\n${rotation} degrees`);
+    print(`==============================`);
+    for (let i = 0; i < 100; i++) {
+      const start = Date.now();
+      instance.exports.rotate(imageDimensions, imageDimensions, rotation);
+      iterations[i] = Date.now() - start;
+    }
+    const average = iterations.reduce((sum, c) => sum + c) / iterations.length;
+    const stddev = Math.sqrt(
+      iterations
+        .map(i => Math.pow(i - average, 2))
+        .reduce((sum, c) => sum + c) / iterations.length
+    );
+    print(`n = ${iterations.length}`);
+    print(`Average: ${average}`);
+    print(`StdDev: ${stddev}`);
+  });
+}
+init().catch(e => console.error(e.stack));

codecs/rotate/build.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+set -e
+
+echo "============================================="
+echo "Compiling wasm"
+echo "============================================="
+(
+  rustup run nightly \
+    cargo build \
+    --target wasm32-unknown-unknown \
+    --release
+  cp target/wasm32-unknown-unknown/release/rotate.wasm .
+  wasm-strip rotate.wasm
+)
+echo "============================================="
+echo "Compiling wasm  done"
+echo "============================================="
+
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+echo "Did you update your docker image?"
+echo "Run \`docker pull ubuntu\`"
+echo "Run \`docker pull rust\`"
+echo "Run \`docker build -t squoosh-rotate .\`"
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"

codecs/rotate/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "rotate",
+  "scripts": {
+    "build:image": "docker build -t squoosh-rotate .",
+    "build": "docker run --rm -v $(pwd):/src squoosh-rotate ./build.sh",
+    "benchmark": "echo File size after gzip && npm run benchmark:filesize && echo Optimizing && npm run -s benchmark:optimizing",
+    "benchmark:baseline": "v8 --liftoff --no-wasm-tier-up --no-opt ./benchmark.js",
+    "benchmark:optimizing": "v8 --no-liftoff --no-wasm-tier-up ./benchmark.js",
+    "benchmark:filesize": "cat rotate.wasm | gzip -c9n | wc -c"
+  }
+}

codecs/rotate/rotate.rs

@@ -0,0 +1,113 @@
+use std::slice::{from_raw_parts, from_raw_parts_mut};
+
+// This function is taken from Zachary Dremann
+// https://github.com/GoogleChromeLabs/squoosh/pull/462
+trait HardUnwrap<T> {
+    fn unwrap_hard(self) -> T;
+}
+
+impl<T> HardUnwrap<T> for Option<T> {
+    #[cfg(not(debug_assertions))]
+    #[inline]
+    fn unwrap_hard(self) -> T {
+        match self {
+            Some(t) => t,
+            None => std::process::abort(),
+        }
+    }
+
+    #[cfg(debug_assertions)]
+    fn unwrap_hard(self) -> T {
+        self.unwrap()
+    }
+}
+
+const TILE_SIZE: usize = 16;
+
+fn get_buffers<'a>(width: usize, height: usize) -> (&'a [u32], &'a mut [u32]) {
+    let num_pixels = width * height;
+    let in_b: &[u32];
+    let out_b: &mut [u32];
+    unsafe {
+        in_b = from_raw_parts::<u32>(8 as *const u32, num_pixels);
+        out_b = from_raw_parts_mut::<u32>((num_pixels * 4 + 8) as *mut u32, num_pixels);
+    }
+    return (in_b, out_b);
+}
+
+#[inline(never)]
+fn rotate_0(width: usize, height: usize) {
+    let (in_b, out_b) = get_buffers(width, height);
+    for (in_p, out_p) in in_b.iter().zip(out_b.iter_mut()) {
+        *out_p = *in_p;
+    }
+}
+
+#[inline(never)]
+fn rotate_90(width: usize, height: usize) {
+    let (in_b, out_b) = get_buffers(width, height);
+    let new_width = height;
+    let _new_height = width;
+    for y_start in (0..height).step_by(TILE_SIZE) {
+        for x_start in (0..width).step_by(TILE_SIZE) {
+            for y in y_start..(y_start + TILE_SIZE).min(height) {
+                let in_offset = y * width;
+                let in_bounds = if x_start + TILE_SIZE < width {
+                    (in_offset + x_start)..(in_offset + x_start + TILE_SIZE)
+                } else {
+                    (in_offset + x_start)..(in_offset + width)
+                };
+                let in_chunk = in_b.get(in_bounds).unwrap_hard();
+                for (x, in_p) in in_chunk.iter().enumerate() {
+                    let new_x = (new_width - 1) - y;
+                    let new_y = x + x_start;
+                    *out_b.get_mut(new_y * new_width + new_x).unwrap_hard() = *in_p;
+                }
+            }
+        }
+    }
+}
+
+#[inline(never)]
+fn rotate_180(width: usize, height: usize) {
+    let (in_b, out_b) = get_buffers(width, height);
+    for (in_p, out_p) in in_b.iter().zip(out_b.iter_mut().rev()) {
+        *out_p = *in_p;
+    }
+}
+
+#[inline(never)]
+fn rotate_270(width: usize, height: usize) {
+    let (in_b, out_b) = get_buffers(width, height);
+    let new_width = height;
+    let new_height = width;
+    for y_start in (0..height).step_by(TILE_SIZE) {
+        for x_start in (0..width).step_by(TILE_SIZE) {
+            for y in y_start..(y_start + TILE_SIZE).min(height) {
+                let in_offset = y * width;
+                let in_bounds = if x_start + TILE_SIZE < width {
+                    (in_offset + x_start)..(in_offset + x_start + TILE_SIZE)
+                } else {
+                    (in_offset + x_start)..(in_offset + width)
+                };
+                let in_chunk = in_b.get(in_bounds).unwrap_hard();
+                for (x, in_p) in in_chunk.iter().enumerate() {
+                    let new_x = y;
+                    let new_y = new_height - 1 - (x_start + x);
+                    *out_b.get_mut(new_y * new_width + new_x).unwrap_hard() = *in_p;
+                }
+            }
+        }
+    }
+}
+
+#[no_mangle]
+fn rotate(width: usize, height: usize, rotate: usize) {
+    match rotate {
+        0 => rotate_0(width, height),
+        90 => rotate_90(width, height),
+        180 => rotate_180(width, height),
+        270 => rotate_270(width, height),
+        _ => std::process::abort(),
+    }
+}

codecs/webp_dec/README.md

@@ -0,0 +1,22 @@
+# WebP decoder
+
+- Source: <https://github.com/webmproject/libwebp>
+- Version: v1.0.2
+
+## Example
+
+See `example.html`
+
+## API
+
+### `int version()`
+
+Returns the version of libwebp as a number. va.b.c is encoded as 0x0a0b0c
+
+### `RawImage decode(std::string buffer)`
+
+Decodes the given webp buffer into raw RGBA. `RawImage` is a class with 3 fields: `buffer`, `width`, and `height`.
+
+### `void free_result()`
+
+Frees the result created by `decode()`.

codecs/webp_dec/build.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+
+set -e
+
+export OPTIMIZE="-Os"
+export LDFLAGS="${OPTIMIZE}"
+export CFLAGS="${OPTIMIZE}"
+export CPPFLAGS="${OPTIMIZE}"
+apt-get update
+apt-get install -qqy autoconf libtool libpng-dev pkg-config
+
+echo "============================================="
+echo "Compiling libwebp"
+echo "============================================="
+test -n "$SKIP_LIBWEBP" || (
+  cd node_modules/libwebp
+  autoreconf -fiv
+  rm -rf build || true
+  mkdir -p build && cd build
+  emconfigure ../configure \
+    --disable-libwebpdemux \
+    --disable-wic \
+    --disable-gif \
+    --disable-tiff \
+    --disable-jpeg \
+    --disable-png \
+    --disable-sdl \
+    --disable-gl \
+    --disable-threading \
+    --disable-neon-rtcd \
+    --disable-neon \
+    --disable-sse2 \
+    --disable-sse4.1
+  emmake make
+)
+echo "============================================="
+echo "Compiling wasm bindings"
+echo "============================================="
+(
+  emcc \
+    ${OPTIMIZE} \
+    --bind \
+    -s ALLOW_MEMORY_GROWTH=1 \
+    -s MODULARIZE=1 \
+    -s 'EXPORT_NAME="webp_dec"' \
+    --std=c++11 \
+    -I node_modules/libwebp \
+    -o ./webp_dec.js \
+    -x c++ \
+    webp_dec.cpp \
+    node_modules/libwebp/build/src/.libs/libwebp.a
+)
+echo "============================================="
+echo "Compiling wasm bindings done"
+echo "============================================="
+
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+echo "Did you update your docker image?"
+echo "Run \`docker pull trzeci/emscripten\`"
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"

codecs/webp_dec/example.html

@@ -0,0 +1,24 @@
+<!doctype html>
+<script src='webp_dec.js'></script>
+<script>
+  const Module = webp_dec();
+
+  async function loadFile(src) {
+    const resp = await fetch(src);
+    return await resp.arrayBuffer();
+  }
+
+  Module.onRuntimeInitialized = async _ => {
+    console.log('Version:', Module.version().toString(16));
+    const image = await loadFile('../example.webp');
+    const result = Module.decode(image);
+    const imageData = new ImageData(new Uint8ClampedArray(result.buffer), result.width, result.height);
+    Module.free_result();
+    const canvas = document.createElement('canvas');
+    canvas.width = result.width;
+    canvas.height = result.height;
+    document.body.appendChild(canvas);
+    const ctx = canvas.getContext('2d');
+    ctx.putImageData(imageData, 0, 0);
+  };
+</script>

codecs/webp_dec/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "webp_dec",
+  "scripts": {
+    "install": "napa",
+    "build": "docker run --rm -v $(pwd):/src trzeci/emscripten ./build.sh"
+  },
+  "napa": {
+    "libwebp": "webmproject/libwebp#v1.0.2"
+  },
+  "devDependencies": {
+    "napa": "3.0.0"
+  }
+}

codecs/webp_dec/webp_dec.cpp

@@ -0,0 +1,47 @@
+#include "emscripten/bind.h"
+#include "emscripten/val.h"
+#include "src/webp/decode.h"
+#include "src/webp/demux.h"
+#include <string>
+
+using namespace emscripten;
+
+int version() {
+  return WebPGetDecoderVersion();
+}
+
+class RawImage {
+public:
+  val buffer;
+  int width;
+  int height;
+
+  RawImage(val b, int w, int h)
+    : buffer(b), width(w), height(h) {}
+};
+
+uint8_t* last_result;
+RawImage decode(std::string buffer) {
+  int width, height;
+  last_result = WebPDecodeRGBA((const uint8_t*)buffer.c_str(), buffer.size(), &width, &height);
+  return RawImage(
+    val(typed_memory_view(width*height*4, last_result)),
+    width,
+    height
+  );
+}
+
+void free_result() {
+  free(last_result);
+}
+
+EMSCRIPTEN_BINDINGS(my_module) {
+  class_<RawImage>("RawImage")
+    .property("buffer", &RawImage::buffer)
+    .property("width", &RawImage::width)
+    .property("height", &RawImage::height);
+
+  function("decode", &decode);
+  function("version", &version);
+  function("free_result", &free_result);
+}

codecs/webp_dec/webp_dec.d.ts

@@ -0,0 +1,13 @@
+interface RawImage {
+  buffer: Uint8Array;
+  width: number;
+  height: number;
+}
+
+interface WebPModule extends EmscriptenWasm.Module {
+  decode(data: BufferSource): RawImage;
+  free_result(): void;
+}
+
+export default function(opts: EmscriptenWasm.ModuleOpts): WebPModule;
+

codecs/webp_enc/README.md

@@ -0,0 +1,26 @@
+# WebP encoder
+
+- Source: <https://github.com/webmproject/libwebp>
+- Version: v1.0.2
+
+## Dependencies
+
+- Docker
+
+## Example
+
+See `example.html`
+
+## API
+
+### `int version()`
+
+Returns the version of libwebp as a number. va.b.c is encoded as 0x0a0b0c
+
+### `UInt8Array encode(uint8_t* image_buffer, int image_width, int image_height, WebPConfig config)`
+
+Encodes the given image with given dimension to WebP.
+
+### `void free_result()`
+
+Frees the last result created by `encode()`.

codecs/webp_enc/build.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+
+set -e
+
+export OPTIMIZE="-Os"
+export LDFLAGS="${OPTIMIZE}"
+export CFLAGS="${OPTIMIZE}"
+export CPPFLAGS="${OPTIMIZE}"
+
+apt-get update
+apt-get install -qqy autoconf libtool libpng-dev pkg-config
+
+echo "============================================="
+echo "Compiling libwebp"
+echo "============================================="
+test -n "$SKIP_LIBWEBP" || (
+  cd node_modules/libwebp
+  autoreconf -fiv
+  rm -rf build || true
+  mkdir -p build && cd build
+  emconfigure ../configure \
+    --disable-libwebpdemux \
+    --disable-wic \
+    --disable-gif \
+    --disable-tiff \
+    --disable-jpeg \
+    --disable-png \
+    --disable-sdl \
+    --disable-gl \
+    --disable-threading \
+    --disable-neon-rtcd \
+    --disable-neon \
+    --disable-sse2 \
+    --disable-sse4.1
+  emmake make
+)
+echo "============================================="
+echo "Compiling wasm bindings"
+echo "============================================="
+(
+  emcc \
+    ${OPTIMIZE} \
+    --bind \
+    -s ALLOW_MEMORY_GROWTH=1 \
+    -s MODULARIZE=1 \
+    -s 'EXPORT_NAME="webp_enc"' \
+    --std=c++11 \
+    -I node_modules/libwebp \
+    -o ./webp_enc.js \
+    -x c++ \
+    webp_enc.cpp \
+    node_modules/libwebp/build/src/.libs/libwebp.a
+)
+echo "============================================="
+echo "Compiling wasm bindings done"
+echo "============================================="
+
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+echo "Did you update your docker image?"
+echo "Run \`docker pull trzeci/emscripten\`"
+echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"

codecs/webp_enc/example.html

@@ -0,0 +1,62 @@
+<!doctype html>
+<script src='webp_enc.js'></script>
+<script>
+  const module = webp_enc();
+
+  async function loadImage(src) {
+    // Load image
+    const img = document.createElement('img');
+    img.src = src;
+    await new Promise(resolve => img.onload = resolve);
+    // Make canvas same size as image
+    const canvas = document.createElement('canvas');
+    [canvas.width, canvas.height] = [img.width, img.height];
+    // Draw image onto canvas
+    const ctx = canvas.getContext('2d');
+    ctx.drawImage(img, 0, 0);
+    return ctx.getImageData(0, 0, img.width, img.height);
+  }
+
+  module.onRuntimeInitialized = async _ => {
+    console.log('Version:', module.version().toString(16));
+    const image = await loadImage('../example.png');
+    const result = module.encode(image.data, image.width, image.height, {
+      quality: 75,
+      target_size: 0,
+      target_PSNR: 0,
+      method: 4,
+      sns_strength: 50,
+      filter_strength: 60,
+      filter_sharpness: 0,
+      filter_type: 1,
+      partitions: 0,
+      segments: 4,
+      pass: 1,
+      show_compressed: 0,
+      preprocessing: 0,
+      autofilter: 0,
+      partition_limit: 0,
+      alpha_compression: 1,
+      alpha_filtering: 1,
+      alpha_quality: 100,
+      lossless: 0,
+      exact: 0,
+      image_hint: 0,
+      emulate_jpeg_size: 0,
+      thread_level: 0,
+      low_memory: 0,
+      near_lossless: 100,
+      use_delta_palette: 0,
+      use_sharp_yuv: 0,
+    });
+    console.log('size', result.length);
+    const blob = new Blob([result], {type: 'image/webp'});
+
+    module.free_result();
+
+    const blobURL = URL.createObjectURL(blob);
+    const img = document.createElement('img');
+    img.src = blobURL;
+    document.body.appendChild(img);
+  };
+</script>

codecs/webp_enc/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "webp_enc",
+  "scripts": {
+    "install": "napa",
+    "build": "docker run --rm -v $(pwd):/src trzeci/emscripten ./build.sh"
+  },
+  "napa": {
+    "libwebp": "webmproject/libwebp#v1.0.2"
+  },
+  "devDependencies": {
+    "napa": "3.0.0"
+  }
+}

codecs/webp_enc/webp_enc.cpp

@@ -0,0 +1,96 @@
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+#include "src/webp/encode.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdexcept>
+
+using namespace emscripten;
+
+int version() {
+  return WebPGetEncoderVersion();
+}
+
+uint8_t* last_result;
+
+val encode(std::string img, int width, int height, WebPConfig config) {
+  uint8_t* img_in = (uint8_t*) img.c_str();
+
+  // A lot of this is duplicated from Encode in picture_enc.c
+  WebPPicture pic;
+  WebPMemoryWriter wrt;
+  int ok;
+
+  if (!WebPPictureInit(&pic)) {
+    // shouldn't happen, except if system installation is broken
+    throw std::runtime_error("Unexpected error");
+  }
+
+  // Only use use_argb if we really need it, as it's slower.
+  pic.use_argb = config.lossless || config.use_sharp_yuv || config.preprocessing > 0;
+  pic.width = width;
+  pic.height = height;
+  pic.writer = WebPMemoryWrite;
+  pic.custom_ptr = &wrt;
+
+  WebPMemoryWriterInit(&wrt);
+
+  ok = WebPPictureImportRGBA(&pic, (uint8_t*) img_in, width * 4) && WebPEncode(&config, &pic);
+  WebPPictureFree(&pic);
+  if (!ok) {
+    WebPMemoryWriterClear(&wrt);
+    throw std::runtime_error("Encode failed");
+  }
+
+  last_result = wrt.mem;
+
+  return val(typed_memory_view(wrt.size, wrt.mem));
+}
+
+void free_result() {
+  WebPFree(last_result);
+}
+
+
+EMSCRIPTEN_BINDINGS(my_module) {
+  enum_<WebPImageHint>("WebPImageHint")
+    .value("WEBP_HINT_DEFAULT", WebPImageHint::WEBP_HINT_DEFAULT)
+    .value("WEBP_HINT_PICTURE", WebPImageHint::WEBP_HINT_PICTURE)
+    .value("WEBP_HINT_PHOTO", WebPImageHint::WEBP_HINT_PHOTO)
+    .value("WEBP_HINT_GRAPH", WebPImageHint::WEBP_HINT_GRAPH)
+    ;
+
+  value_object<WebPConfig>("WebPConfig")
+    .field("lossless", &WebPConfig::lossless)
+    .field("quality", &WebPConfig::quality)
+    .field("method", &WebPConfig::method)
+    .field("image_hint", &WebPConfig::image_hint)
+    .field("target_size", &WebPConfig::target_size)
+    .field("target_PSNR", &WebPConfig::target_PSNR)
+    .field("segments", &WebPConfig::segments)
+    .field("sns_strength", &WebPConfig::sns_strength)
+    .field("filter_strength", &WebPConfig::filter_strength)
+    .field("filter_sharpness", &WebPConfig::filter_sharpness)
+    .field("filter_type", &WebPConfig::filter_type)
+    .field("autofilter", &WebPConfig::autofilter)
+    .field("alpha_compression", &WebPConfig::alpha_compression)
+    .field("alpha_filtering", &WebPConfig::alpha_filtering)
+    .field("alpha_quality", &WebPConfig::alpha_quality)
+    .field("pass", &WebPConfig::pass)
+    .field("show_compressed", &WebPConfig::show_compressed)
+    .field("preprocessing", &WebPConfig::preprocessing)
+    .field("partitions", &WebPConfig::partitions)
+    .field("partition_limit", &WebPConfig::partition_limit)
+    .field("emulate_jpeg_size", &WebPConfig::emulate_jpeg_size)
+    .field("thread_level", &WebPConfig::thread_level)
+    .field("low_memory", &WebPConfig::low_memory)
+    .field("near_lossless", &WebPConfig::near_lossless)
+    .field("exact", &WebPConfig::exact)
+    .field("use_delta_palette", &WebPConfig::use_delta_palette)
+    .field("use_sharp_yuv", &WebPConfig::use_sharp_yuv)
+    ;
+
+  function("version", &version);
+  function("encode", &encode);
+  function("free_result", &free_result);
+}

codecs/webp_enc/webp_enc.d.ts

@@ -0,0 +1,9 @@
+import { EncodeOptions } from '../../src/codecs/webp/encoder-meta';
+
+interface WebPModule extends EmscriptenWasm.Module {
+  encode(data: BufferSource, width: number, height: number, options: EncodeOptions): Uint8Array;
+  free_result(): void;
+}
+
+
+export default function(opts: EmscriptenWasm.ModuleOpts): WebPModule;

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

emscripten-wasm.d.ts

@@ -0,0 +1,107 @@
+// These types roughly model the object that the JS files generated by Emscripten define. Copied from https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/emscripten/index.d.ts and turned into a type definition rather than a global to support our way of using Emscripten.
+// TODO(@surma): Upstream this?
+declare namespace EmscriptenWasm {
+  type EnvironmentType = "WEB" | "NODE" | "SHELL" | "WORKER";
+
+  // Options object for modularized Emscripten files. Shoe-horned by @surma.
+  // FIXME: This an incomplete definition!
+  interface ModuleOpts {
+    noInitialRun?: boolean;
+    locateFile?: (url: string) => string;
+    onRuntimeInitialized?: () => void;
+  }
+
+  interface Module {
+    print(str: string): void;
+    printErr(str: string): void;
+    arguments: string[];
+    environment: EnvironmentType;
+    preInit: { ():  void }[];
+    preRun: { ():  void }[];
+    postRun: { ():  void }[];
+    preinitializedWebGLContext: WebGLRenderingContext;
+    noInitialRun: boolean;
+    noExitRuntime: boolean;
+    logReadFiles: boolean;
+    filePackagePrefixURL: string;
+    wasmBinary: ArrayBuffer;
+
+    destroy(object: object): void;
+    getPreloadedPackage(remotePackageName: string, remotePackageSize: number): ArrayBuffer;
+    instantiateWasm(
+        imports: WebAssembly.Imports,
+        successCallback: (module: WebAssembly.Module) => void
+    ): WebAssembly.Exports;
+    locateFile(url: string): string;
+    onCustomMessage(event: MessageEvent): void;
+
+    Runtime: any;
+
+    ccall(ident: string, returnType: string | null, argTypes: string[], args: any[]): any;
+    cwrap(ident: string, returnType: string | null, argTypes: string[]): any;
+
+    setValue(ptr: number, value: any, type: string, noSafe?: boolean): void;
+    getValue(ptr: number, type: string, noSafe?: boolean): number;
+
+    ALLOC_NORMAL: number;
+    ALLOC_STACK: number;
+    ALLOC_STATIC: number;
+    ALLOC_DYNAMIC: number;
+    ALLOC_NONE: number;
+
+    allocate(slab: any, types: string, allocator: number, ptr: number): number;
+    allocate(slab: any, types: string[], allocator: number, ptr: number): number;
+
+    Pointer_stringify(ptr: number, length?: number): string;
+    UTF16ToString(ptr: number): string;
+    stringToUTF16(str: string, outPtr: number): void;
+    UTF32ToString(ptr: number): string;
+    stringToUTF32(str: string, outPtr: number): void;
+
+    // USE_TYPED_ARRAYS == 1
+    HEAP: Int32Array;
+    IHEAP: Int32Array;
+    FHEAP: Float64Array;
+
+    // USE_TYPED_ARRAYS == 2
+    HEAP8: Int8Array;
+    HEAP16: Int16Array;
+    HEAP32: Int32Array;
+    HEAPU8:  Uint8Array;
+    HEAPU16: Uint16Array;
+    HEAPU32: Uint32Array;
+    HEAPF32: Float32Array;
+    HEAPF64: Float64Array;
+
+    TOTAL_STACK: number;
+    TOTAL_MEMORY: number;
+    FAST_MEMORY: number;
+
+    addOnPreRun(cb: () => any): void;
+    addOnInit(cb: () => any): void;
+    addOnPreMain(cb: () => any): void;
+    addOnExit(cb: () => any): void;
+    addOnPostRun(cb: () => any): void;
+
+    // Tools
+    intArrayFromString(stringy: string, dontAddNull?: boolean, length?: number): number[];
+    intArrayToString(array: number[]): string;
+    writeStringToMemory(str: string, buffer: number, dontAddNull: boolean): void;
+    writeArrayToMemory(array: number[], buffer: number): void;
+    writeAsciiToMemory(str: string, buffer: number, dontAddNull: boolean): void;
+
+    addRunDependency(id: any): void;
+    removeRunDependency(id: any): void;
+
+
+    preloadedImages: any;
+    preloadedAudios: any;
+
+    _malloc(size: number): number;
+    _free(ptr: number): void;
+
+    // Augmentations below by @surma.
+    onRuntimeInitialized: () => void | null;
+  }
+}
+

global.d.ts

@@ -1,22 +1,23 @@
 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 'preact-i18n';
-declare module 'preact-material-components-drawer';
-declare module 'material-radial-progress';
-
 declare module 'classnames' {
   export default function classnames(...args: any[]): string;
 }

package.json

@@ -1,91 +1,76 @@
 {
   "private": true,
   "name": "squoosh",
-  "version": "0.0.0",
+  "version": "1.7.0",
   "license": "apache-2.0",
   "scripts": {
-    "start": "webpack serve --hot",
+    "start": "webpack-dev-server --host 0.0.0.0 --hot",
     "build": "webpack -p",
-    "lint": "eslint src"
+    "lint": "tslint -c tslint.json  -p tsconfig.json -t verbose",
+    "lintfix": "tslint -c tslint.json -p tsconfig.json -t verbose --fix 'src/**/*.{ts,tsx,js,jsx}'",
+    "sizereport": "sizereport --config"
   },
-  "eslintConfig": {
-    "extends": [
-      "standard",
-      "standard-jsx"
-    ],
-    "rules": {
-      "indent": [
-        2,
-        2
-      ],
-      "semi": [
-        2,
-        "always"
-      ],
-      "prefer-const": 1
+  "husky": {
+    "hooks": {
+      "pre-commit": "npm run lint"
     }
   },
-  "eslintIgnore": [
-    "build/*"
-  ],
   "devDependencies": {
-    "@types/node": "^9.4.7",
-    "babel-loader": "^7.1.4",
-    "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.4",
-    "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.13",
-    "babel-preset-env": "^1.6.1",
-    "babel-register": "^6.26.0",
-    "clean-webpack-plugin": "^0.1.19",
-    "copy-webpack-plugin": "^4.5.1",
-    "css-loader": "^0.28.11",
-    "eslint": "^4.18.2",
-    "eslint-config-standard": "^11.0.0",
-    "eslint-config-standard-jsx": "^5.0.0",
-    "eslint-plugin-import": "^2.10.0",
-    "eslint-plugin-node": "^6.0.1",
-    "eslint-plugin-promise": "^3.7.0",
-    "eslint-plugin-react": "^7.7.0",
-    "eslint-plugin-standard": "^3.0.1",
-    "html-webpack-plugin": "^3.0.6",
-    "if-env": "^1.0.4",
-    "loader-utils": "^1.1.0",
-    "mini-css-extract-plugin": "^0.3.0",
-    "node-sass": "^4.7.2",
-    "optimize-css-assets-webpack-plugin": "^4.0.0",
-    "preload-webpack-plugin": "^3.0.0-alpha.3",
-    "progress-bar-webpack-plugin": "^1.11.0",
-    "raw-loader": "^0.5.1",
-    "sass-loader": "^6.0.7",
-    "script-ext-html-webpack-plugin": "^2.0.1",
-    "source-map-loader": "^0.2.3",
-    "style-loader": "^0.20.3",
-    "ts-loader": "^4.0.1",
-    "tslint": "^5.9.1",
-    "tslint-config-semistandard": "^7.0.0",
-    "tslint-react": "^3.5.1",
-    "typescript": "^2.7.2",
-    "typings-for-css-modules-loader": "^1.7.0",
-    "webpack": "^4.3.0",
-    "webpack-bundle-analyzer": "^2.11.1",
-    "webpack-cli": "^2.0.13",
-    "webpack-dev-server": "^3.1.1",
-    "webpack-plugin-replace": "^1.1.1",
-    "workbox-webpack-plugin": "^3.0.1"
-  },
-  "dependencies": {
-    "classnames": "^2.2.5",
-    "material-components-web": "^0.32.0",
-    "material-radial-progress": "git+https://gist.github.com/02134901c77c5309924bfcf8b4435ebe.git",
-    "preact": "^8.2.7",
-    "preact-i18n": "^1.2.0",
-    "preact-material-components": "^1.3.7",
-    "preact-material-components-drawer": "git+https://gist.github.com/a78fceed440b98e62582e4440b86bfab.git",
-    "preact-router": "^2.6.0"
+    "@types/node": "10.14.9",
+    "@types/pretty-bytes": "5.1.0",
+    "@types/webassembly-js-api": "0.0.3",
+    "@webcomponents/custom-elements": "1.2.4",
+    "@webpack-cli/serve": "0.1.8",
+    "assets-webpack-plugin": "3.9.10",
+    "chalk": "2.4.2",
+    "chokidar": "3.0.1",
+    "classnames": "2.2.6",
+    "clean-webpack-plugin": "1.0.1",
+    "comlink": "3.1.1",
+    "copy-webpack-plugin": "5.0.3",
+    "critters-webpack-plugin": "2.3.0",
+    "css-loader": "1.0.1",
+    "ejs": "2.6.2",
+    "escape-string-regexp": "2.0.0",
+    "exports-loader": "0.7.0",
+    "file-drop-element": "0.2.0",
+    "file-loader": "4.0.0",
+    "gzip-size": "5.1.1",
+    "html-webpack-plugin": "3.2.0",
+    "husky": "2.4.1",
+    "idb-keyval": "3.2.0",
+    "linkstate": "1.1.1",
+    "loader-utils": "1.2.3",
+    "mini-css-extract-plugin": "0.7.0",
+    "minimatch": "3.0.4",
+    "node-fetch": "2.6.0",
+    "node-sass": "4.12.0",
+    "optimize-css-assets-webpack-plugin": "5.0.1",
+    "pointer-tracker": "2.0.3",
+    "preact": "8.4.2",
+    "prerender-loader": "1.3.0",
+    "pretty-bytes": "5.2.0",
+    "progress-bar-webpack-plugin": "1.12.1",
+    "raw-loader": "3.0.0",
+    "readdirp": "3.0.2",
+    "sass-loader": "7.1.0",
+    "script-ext-html-webpack-plugin": "2.1.3",
+    "source-map-loader": "0.2.4",
+    "style-loader": "0.23.1",
+    "terser-webpack-plugin": "1.3.0",
+    "travis-size-report": "1.0.1",
+    "ts-loader": "6.0.2",
+    "tslint": "5.17.0",
+    "tslint-config-airbnb": "5.11.1",
+    "tslint-config-semistandard": "8.0.1",
+    "tslint-react": "4.0.0",
+    "typed-css-modules": "0.4.2",
+    "typescript": "3.5.2",
+    "url-loader": "2.0.0",
+    "webpack": "4.28.0",
+    "webpack-bundle-analyzer": "3.3.2",
+    "webpack-cli": "3.3.4",
+    "webpack-dev-server": "3.7.1",
+    "worker-plugin": "3.1.0"
   }
 }

renovate.json

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

sizereport.config.js

@@ -0,0 +1,14 @@
+const escapeRE = require("escape-string-regexp");
+
+module.exports = {
+  repo: "GoogleChromeLabs/squoosh",
+  path: "build/**/!(*.map)",
+  branch: "master",
+  findRenamed(path, newPaths) {
+    const nameParts = /^(.+\.)[a-f0-9]+(\..+)$/.exec(path);
+    if (!nameParts) return;
+
+    const matchRe = new RegExp(`^${escapeRE(nameParts[1])}[a-f0-9]+${escapeRE(nameParts[2])}$`);
+    return newPaths.find(newPath => matchRe.test(newPath));
+  }
+};

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

@@ -0,0 +1,11 @@
+import { canvasEncodeTest } from '../generic/util';
+
+export interface EncodeOptions { }
+export interface EncoderState { type: typeof type; options: EncodeOptions; }
+
+export const type = 'browser-bmp';
+export const label = 'Browser BMP';
+export const mimeType = 'image/bmp';
+export const extension = 'bmp';
+export const defaultOptions: EncodeOptions = {};
+export const featureTest = () => canvasEncodeTest(mimeType);

src/codecs/browser-bmp/encoder.ts

@@ -0,0 +1,6 @@
+import { mimeType } from './encoder-meta';
+import { canvasEncode } from '../../lib/util';
+
+export function encode(data: ImageData) {
+  return canvasEncode(data, mimeType);
+}

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

@@ -0,0 +1,11 @@
+import { canvasEncodeTest } from '../generic/util';
+
+export interface EncodeOptions {}
+export interface EncoderState { type: typeof type; options: EncodeOptions; }
+
+export const type = 'browser-gif';
+export const label = 'Browser GIF';
+export const mimeType = 'image/gif';
+export const extension = 'gif';
+export const defaultOptions: EncodeOptions = {};
+export const featureTest = () => canvasEncodeTest(mimeType);

src/codecs/browser-gif/encoder.ts

@@ -0,0 +1,6 @@
+import { mimeType } from './encoder-meta';
+import { canvasEncode } from '../../lib/util';
+
+export function encode(data: ImageData) {
+  return canvasEncode(data, mimeType);
+}

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

@@ -0,0 +1,11 @@
+import { canvasEncodeTest } from '../generic/util';
+
+export interface EncodeOptions { }
+export interface EncoderState { type: typeof type; options: EncodeOptions; }
+
+export const type = 'browser-jp2';
+export const label = 'Browser JPEG 2000';
+export const mimeType = 'image/jp2';
+export const extension = 'jp2';
+export const defaultOptions: EncodeOptions = {};
+export const featureTest = () => canvasEncodeTest(mimeType);