Drop bimb dependency

README.md

@@ -210,10 +210,6 @@ You can find helpful code snippets in the `examples` folder.
 
 imgproxy supports only the most popular image formats of the moment: PNG, JPEG, GIF and WebP.
 
-## Special thanks
-
-Special thanks to [h2non](https://github.com/h2non) and all authors and contributors of [bimg](https://github.com/h2non/bimg).
-
 ## Author
 
 Sergey "DarthSim" Aleksandrovich

config.go

@@ -167,4 +167,6 @@ func init() {
 	} else if conf.GZipCompression > 9 {
 		log.Fatalf("GZip compression can't be greater than 9, now - %d\n", conf.GZipCompression)
 	}
+
+	initVips()
 }

download.go

@@ -57,41 +57,50 @@ func (r *netReader) GrowBuf(s int) {
 	r.buf.Grow(s)
 }
 
-func checkTypeAndDimensions(r io.Reader) error {
-	imgconf, _, err := image.DecodeConfig(r)
+func checkTypeAndDimensions(r io.Reader) (imageType, error) {
+	imgconf, imgtypeStr, err := image.DecodeConfig(r)
+	imgtype, imgtypeOk := imageTypes[imgtypeStr]
+
 	if err != nil {
-		return err
+		return UNKNOWN, err
 	}
 	if imgconf.Width > conf.MaxSrcDimension || imgconf.Height > conf.MaxSrcDimension {
-		return errors.New("File is too big")
+		return UNKNOWN, errors.New("File is too big")
+	}
+	if !imgtypeOk || !vipsTypeSupportedLoad(imgtype) {
+		return UNKNOWN, errors.New("Source image type not supported")
 	}
-	return nil
+
+	return imgtype, nil
 }
 
-func readAndCheckImage(res *http.Response) ([]byte, error) {
+func readAndCheckImage(res *http.Response) ([]byte, imageType, error) {
 	nr := newNetReader(res.Body)
 
-	if err := checkTypeAndDimensions(nr); err != nil {
-		return nil, err
+	imgtype, err := checkTypeAndDimensions(nr)
+	if err != nil {
+		return nil, UNKNOWN, err
 	}
 
 	if res.ContentLength > 0 {
 		nr.GrowBuf(int(res.ContentLength))
 	}
 
-	return nr.ReadAll()
+	b, err := nr.ReadAll()
+
+	return b, imgtype, err
 }
 
-func downloadImage(url string) ([]byte, error) {
+func downloadImage(url string) ([]byte, imageType, error) {
 	res, err := downloadClient.Get(url)
 	if err != nil {
-		return nil, err
+		return nil, UNKNOWN, err
 	}
 	defer res.Body.Close()
 
 	if res.StatusCode != 200 {
 		body, _ := ioutil.ReadAll(res.Body)
-		return nil, fmt.Errorf("Can't download image; Status: %d; %s", res.StatusCode, string(body))
+		return nil, UNKNOWN, fmt.Errorf("Can't download image; Status: %d; %s", res.StatusCode, string(body))
 	}
 
 	return readAndCheckImage(res)

glide.lock

@@ -1,19 +1,15 @@
-hash: 54db290c0c5bcd14e69e3faa4a1a23040d9117283134d96d6d8ed0df3544283e
-updated: 2017-09-15T13:31:21.075317146+03:00
+hash: 0ef57dd15f41e8f5181f43ff93b7c420e63c8bb2174a8c879ffd56dd98bed659
+updated: 2017-09-27T13:53:20.123821976+06:00
 imports:
-- name: github.com/h2non/bimg
-  version: 276e0541892a9c518de3cf332536cd30ebef25de
-- name: github.com/tj/go-debug
-  version: ff4a55a20a86994118644bbddc6a216da193cc13
 - name: golang.org/x/image
-  version: e20db36d77bd0cb36cea8fe49d5c37d82d21591f
+  version: 334384d9e19178a0488c9360d94d183c1ef0f711
   subpackages:
   - riff
   - vp8
   - vp8l
   - webp
 - name: golang.org/x/net
-  version: 859d1a86bb617c0c20d154590c3c5d3fcb670b07
+  version: 0a9397675ba34b2845f758fe3cd68828369c6517
   subpackages:
   - netutil
 - name: gopkg.in/yaml.v2

glide.yaml

@@ -1,7 +1,5 @@
 package: github.com/DarthSim/imgproxy
 import:
-- package: github.com/h2non/bimg
-  version: ~1.0.9
 - package: gopkg.in/yaml.v2
 - package: golang.org/x/net
   subpackages:

main.go

@@ -16,7 +16,7 @@ func main() {
 	}
 
 	s := &http.Server{
-		Handler:        newHttpHandler(),
+		Handler:        newHTTPHandler(),
 		ReadTimeout:    time.Duration(conf.ReadTimeout) * time.Second,
 		WriteTimeout:   time.Duration(conf.WriteTimeout) * time.Second,
 		MaxHeaderBytes: 1 << 20,

process.go

@@ -1,91 +1,269 @@
 package main
 
+/*
+#cgo pkg-config: vips
+#include "vips.h"
+*/
+import "C"
+
 import (
+	"errors"
+	"log"
 	"math"
+	"runtime"
+	"unsafe"
+)
+
+type imageType int
+
+const (
+	UNKNOWN imageType = iota
+	JPEG
+	PNG
+	WEBP
+	GIF
+)
+
+var imageTypes = map[string]imageType{
+	"jpeg": JPEG,
+	"jpg":  JPEG,
+	"png":  PNG,
+	"webp": WEBP,
+	"gif":  GIF,
+}
+
+type gravityType int
+
+const (
+	CENTER gravityType = iota
+	NORTH
+	EAST
+	SOUTH
+	WEST
+	SMART
+)
+
+var gravityTypes = map[string]gravityType{
+	"ce": CENTER,
+	"no": NORTH,
+	"ea": EAST,
+	"so": SOUTH,
+	"we": WEST,
+	"sm": SMART,
+}
 
-	"github.com/h2non/bimg"
+type resizeType int
+
+const (
+	FIT resizeType = iota
+	FILL
+	CROP
 )
 
+var resizeTypes = map[string]resizeType{
+	"fit":  FIT,
+	"fill": FILL,
+	"crop": CROP,
+}
+
 type processingOptions struct {
-	resize  string
+	resize  resizeType
 	width   int
 	height  int
-	gravity bimg.Gravity
+	gravity gravityType
 	enlarge bool
-	format  bimg.ImageType
+	format  imageType
+}
+
+func initVips() {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	if err := C.vips_initialize(); err != 0 {
+		C.vips_shutdown()
+		log.Fatalln("unable to start vips!")
+	}
+
+	C.vips_concurrency_set(1)
+	C.vips_cache_set_max_mem(100 * 1024 * 1024) // 100Mb
+	C.vips_cache_set_max(500)
 }
 
-var imageTypes = map[string]bimg.ImageType{
-	"jpeg": bimg.JPEG,
-	"jpg":  bimg.JPEG,
-	"png":  bimg.PNG,
-	"webp": bimg.WEBP,
+func vipsTypeSupportedLoad(imgtype imageType) bool {
+	switch imgtype {
+	case JPEG:
+		return int(C.vips_type_find_load_go(C.JPEG)) != 0
+	case PNG:
+		return int(C.vips_type_find_load_go(C.PNG)) != 0
+	case WEBP:
+		return int(C.vips_type_find_load_go(C.WEBP)) != 0
+	case GIF:
+		return int(C.vips_type_find_load_go(C.GIF)) != 0
+	}
+	return false
 }
 
-var gravityTypes = map[string]bimg.Gravity{
-	"ce": bimg.GravityCentre,
-	"no": bimg.GravityNorth,
-	"ea": bimg.GravityEast,
-	"so": bimg.GravitySouth,
-	"we": bimg.GravityWest,
-	"sm": bimg.GravitySmart,
+func vipsTypeSupportedSave(imgtype imageType) bool {
+	switch imgtype {
+	case JPEG:
+		return int(C.vips_type_find_save_go(C.JPEG)) != 0
+	case PNG:
+		return int(C.vips_type_find_save_go(C.PNG)) != 0
+	case WEBP:
+		return int(C.vips_type_find_save_go(C.WEBP)) != 0
+	}
+	return false
 }
 
 func round(f float64) int {
 	return int(f + .5)
 }
-func calcSize(size bimg.ImageSize, po processingOptions) (int, int) {
-	if (po.width == size.Width && po.height == size.Height) || (po.resize != "fill" && po.resize != "fit") {
-		return po.width, po.height
+
+func calcScale(width, height int, po processingOptions) float64 {
+	if (po.width == width && po.height == height) || (po.resize != FILL && po.resize != FIT) {
+		return 1
 	}
 
-	fsw, fsh, fow, foh := float64(size.Width), float64(size.Height), float64(po.width), float64(po.height)
+	fsw, fsh, fow, foh := float64(width), float64(height), float64(po.width), float64(po.height)
 
 	wr := fow / fsw
 	hr := foh / fsh
 
-	var rate float64
-	if po.resize == "fit" {
-		rate = math.Min(wr, hr)
-	} else {
-		rate = math.Max(wr, hr)
+	if po.resize == FIT {
+		return math.Min(wr, hr)
 	}
 
-	return round(math.Min(fsw*rate, fow)), round(math.Min(fsh*rate, foh))
+	return math.Max(wr, hr)
 }
 
-func processImage(p []byte, po processingOptions) ([]byte, error) {
-	var err error
+func calcCrop(width, height int, po processingOptions) (left, top int) {
+	left = (width - po.width + 1) / 2
+	top = (height - po.height + 1) / 2
 
-	img := bimg.NewImage(p)
+	if po.gravity == NORTH {
+		top = 0
+	}
 
-	size, err := img.Size()
-	if err != nil {
-		return nil, err
+	if po.gravity == EAST {
+		left = width - po.width
 	}
 
-	// Default options
-	opts := bimg.Options{
-		Interpolator: bimg.Bicubic,
-		Quality:      conf.Quality,
-		Gravity:      po.gravity,
-		Enlarge:      po.enlarge,
-		Type:         po.format,
+	if po.gravity == SOUTH {
+		top = height - po.height
 	}
 
-	opts.Width, opts.Height = calcSize(size, po)
+	if po.gravity == WEST {
+		left = 0
+	}
+
+	return
+}
+
+func processImage(data []byte, imgtype imageType, po processingOptions) ([]byte, error) {
+	defer runtime.KeepAlive(data)
+
+	err := C.int(0)
+
+	var img, tmpImg *C.struct__VipsImage
+
+	// Cleanup after all
+	defer func() {
+		C.vips_thread_shutdown()
+		C.vips_error_clear()
+	}()
+
+	// Load the image
+	switch imgtype {
+	case JPEG:
+		err = C.vips_jpegload_buffer_go(unsafe.Pointer(&data[0]), C.size_t(len(data)), &img)
+	case PNG:
+		err = C.vips_pngload_buffer_go(unsafe.Pointer(&data[0]), C.size_t(len(data)), &img)
+	case GIF:
+		err = C.vips_gifload_buffer_go(unsafe.Pointer(&data[0]), C.size_t(len(data)), &img)
+	case WEBP:
+		err = C.vips_webpload_buffer_go(unsafe.Pointer(&data[0]), C.size_t(len(data)), &img)
+	}
+	if err != 0 {
+		return nil, vipsError()
+	}
+
+	imgWidth := int(img.Xsize)
+	imgHeight := int(img.Ysize)
+
+	// Ensure we won't crop out of bounds
+	if !po.enlarge || po.resize == CROP {
+		if imgWidth < po.width {
+			po.width = imgWidth
+		}
 
-	switch po.resize {
-	case "fit":
-		opts.Embed = true
-	case "fill":
-		opts.Embed = true
-		opts.Crop = true
-	case "crop":
-		opts.Crop = true
-	default:
-		opts.Force = true
+		if imgHeight < po.height {
+			po.height = imgHeight
+		}
 	}
 
-	return img.Process(opts)
+	if po.width != imgWidth || po.height != imgHeight {
+		// Resize image for "fill" and "fit"
+		if po.resize == FILL || po.resize == FIT {
+			scale := calcScale(imgWidth, imgHeight, po)
+			err = C.vips_resize_go(img, &tmpImg, C.double(scale))
+			C.g_object_unref(C.gpointer(img))
+			img = tmpImg
+			if err != 0 {
+				return nil, vipsError()
+			}
+		}
+		// Crop image for "fill" and "crop"
+		if po.resize == FILL || po.resize == CROP {
+			if po.gravity == SMART && C.vips_support_smartcrop() == 1 {
+				err = C.vips_smartcrop_go(img, &tmpImg, C.int(po.width), C.int(po.height))
+				C.g_object_unref(C.gpointer(img))
+				img = tmpImg
+				if err != 0 {
+					return nil, vipsError()
+				}
+			} else {
+				left, top := calcCrop(int(img.Xsize), int(img.Ysize), po)
+				err = C.vips_extract_area_go(img, &tmpImg, C.int(left), C.int(top), C.int(po.width), C.int(po.height))
+				C.g_object_unref(C.gpointer(img))
+				img = tmpImg
+				if err != 0 {
+					return nil, vipsError()
+				}
+			}
+		}
+	}
+
+	// Convert to sRGB colour space
+	err = C.vips_colourspace_go(img, &tmpImg, C.VIPS_INTERPRETATION_sRGB)
+	C.g_object_unref(C.gpointer(img))
+	img = tmpImg
+	if err != 0 {
+		return nil, vipsError()
+	}
+
+	// Finally, save
+	imgsize := C.size_t(0)
+	var ptr unsafe.Pointer
+	switch po.format {
+	case JPEG:
+		err = C.vips_jpegsave_go(img, &ptr, &imgsize, 1, C.int(conf.Quality), 0)
+	case PNG:
+		err = C.vips_pngsave_go(img, &ptr, &imgsize)
+	case WEBP:
+		err = C.vips_webpsave_go(img, &ptr, &imgsize, 1, C.int(conf.Quality))
+	}
+	if err != 0 {
+		return nil, vipsError()
+	}
+
+	C.g_object_unref(C.gpointer(img))
+
+	buf := C.GoBytes(ptr, C.int(imgsize))
+	C.g_free(C.gpointer(ptr))
+
+	return buf, nil
+}
+
+func vipsError() error {
+	return errors.New(C.GoString(C.vips_error_buffer()))
 }

server.go

@@ -12,21 +12,19 @@ import (
 	"strconv"
 	"strings"
 	"time"
-
-	"github.com/h2non/bimg"
 )
 
-var mimes = map[bimg.ImageType]string{
-	bimg.JPEG: "image/jpeg",
-	bimg.PNG:  "image/png",
-	bimg.WEBP: "image/webp",
+var mimes = map[imageType]string{
+	JPEG: "image/jpeg",
+	PNG:  "image/png",
+	WEBP: "image/webp",
 }
 
 type httpHandler struct {
 	sem chan struct{}
 }
 
-func newHttpHandler() httpHandler {
+func newHTTPHandler() httpHandler {
 	return httpHandler{make(chan struct{}, conf.Concurrency)}
 }
 
@@ -47,7 +45,11 @@ func parsePath(r *http.Request) (string, processingOptions, error) {
 		return "", po, err
 	}
 
-	po.resize = parts[1]
+	if r, ok := resizeTypes[parts[1]]; ok {
+		po.resize = r
+	} else {
+		return "", po, fmt.Errorf("Invalid resize type: %s", parts[1])
+	}
 
 	if po.width, err = strconv.Atoi(parts[2]); err != nil {
 		return "", po, fmt.Errorf("Invalid width: %s", parts[2])
@@ -75,6 +77,10 @@ func parsePath(r *http.Request) (string, processingOptions, error) {
 		return "", po, fmt.Errorf("Invalid image format: %s", filenameParts[1])
 	}
 
+	if !vipsTypeSupportedSave(po.format) {
+		return "", po, errors.New("Resulting image type not supported")
+	}
+
 	filename, err := base64.RawURLEncoding.DecodeString(filenameParts[0])
 	if err != nil {
 		return "", po, errors.New("Invalid filename encoding")
@@ -173,13 +179,13 @@ func (h httpHandler) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	b, err := downloadImage(imgURL)
+	b, imgtype, err := downloadImage(imgURL)
 	if err != nil {
 		respondWithError(rw, 404, err, "Image is unreachable")
 		return
 	}
 
-	b, err = processImage(b, procOpt)
+	b, err = processImage(b, imgtype, procOpt)
 	if err != nil {
 		respondWithError(rw, 500, err, "Error occurred while processing image")
 		return

vendor/github.com/h2non/bimg/.editorconfig

@@ -1,12 +0,0 @@
-root = true
-
-[*]
-indent_style = tab
-indent_size = 2
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.md]
-trim_trailing_whitespace = false

vendor/github.com/h2non/bimg/.gitignore

@@ -1,9 +0,0 @@
-/bimg
-/bundle
-bin
-/*.jpg
-/*.png
-/*.webp
-/fixtures/*_out.*
-/.idea/
-fixtures/test_vertical_*.jpg

vendor/github.com/h2non/bimg/.travis.yml

@@ -1,101 +0,0 @@
-language: go
-
-dist: trusty
-sudo: false
-
-go:
-  - 1.6
-  - 1.7
-  - 1.8
-  - 1.9
-  - tip
-
-env:
-  - LIBVIPS=7.42.3
-  - LIBVIPS=8.2.3
-  - LIBVIPS=8.3.3
-  - LIBVIPS=8.4.6
-  - LIBVIPS=8.5.8
-  - LIBVIPS=8.6.0-alpha4
-  - LIBVIPS=master
-
-matrix:
-  allow_failures:
-    - env: LIBVIPS=7.42.3
-    - env: LIBVIPS=8.2.3
-    - env: LIBVIPS=8.3.3
-    - env: LIBVIPS=8.6.0-alpha4
-
-cache:
-  apt:
-  directories:
-    - $HOME/libvips
-
-addons:
-  apt:
-    packages:
-      - gobject-introspection
-      - gtk-doc-tools
-      - libcfitsio3-dev
-      - libfftw3-dev
-      - libgif-dev
-      - libgs-dev
-      - libgsf-1-dev
-      - libmatio-dev
-      - libopenslide-dev
-      - liborc-0.4-dev
-      - libpango1.0-dev
-      - libpoppler-glib-dev
-      - libwebp-dev
-
-# VIPS 8.3.3 requires Poppler 0.30 which is not released on Trusty.
-before_install:
-  - >
-    test "$LIBVIPS" != "master" -a "$LIBVIPS" \< "8.4" \
-        && wget http://www.vips.ecs.soton.ac.uk/supported/${LIBVIPS%.*}/vips-${LIBVIPS}.tar.gz -O vips.tgz \
-        || echo ":-)"
-  - >
-    test "$LIBVIPS" != "master" -a "$LIBVIPS" \> "8.4" \
-        && wget https://github.com/jcupitt/libvips/archive/v${LIBVIPS}.tar.gz -O vips.tgz \
-        || echo ":-)"
-  - >
-    test $LIBVIPS == "master" \
-        && wget https://github.com/jcupitt/libvips/archive/${LIBVIPS}.tar.gz -O vips.tgz \
-        || echo ":-)"
-  - mkdir libvips
-  - tar xf vips.tgz -C libvips --strip-components 1
-  - cd libvips
-  - test -f autogen.sh && ./autogen.sh || ./bootstrap.sh
-  - >
-    CXXFLAGS=-D_GLIBCXX_USE_CXX11_ABI=0
-    ./configure
-    --disable-debug
-    --disable-dependency-tracking
-    --disable-introspection
-    --disable-static
-    --enable-gtk-doc-html=no
-    --enable-gtk-doc=no
-    --enable-pyvips8=no
-    --without-orc
-    --without-python
-    --prefix=$HOME/libvips
-    $1
-  - make
-  - make install
-  - cd ..
-  - export PATH=$PATH:$HOME/libvips/bin
-  - export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:$HOME/libvips/lib/pkgconfig
-  - export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$HOME/libvips/lib
-  - vips --vips-version
-
-before_script:
-  - go get -u github.com/golang/lint/golint
-
-script:
-  - diff -u <(echo -n) <(gofmt -s -d ./)
-  - diff -u <(echo -n) <(go vet ./)
-  - diff -u <(echo -n) <(golint ./)
-  - go test -v -race -covermode=atomic -coverprofile=coverage.out
-
-after_success:
-  - goveralls -coverprofile=coverage.out -service=travis-ci

vendor/github.com/h2non/bimg/History.md

@@ -1,139 +0,0 @@
-
-## v1.0.14 / 2017-09-12
-
-  * Merge pull request #192 from greut/trim
-  * Adding trim operation.
-  * Merge pull request #191 from greut/alpha4
-  * Update 8.6 to alpha4.
-
-## v1.0.13 / 2017-09-11
-
-  * Merge pull request #190 from greut/typos
-  * Fix typo and small cleanup.
-
-## v1.0.12 / 2017-09-10
-
-  * Merge branch '99designs-vips-reduce'
-  * fix(reduce): resolve conflicts with master
-  * Use vips reduce when downscaling
-
-## v1.0.11 / 2017-09-10
-
-  * feat(#189): allow strip image metadata via bimg.Options.StripMetadata = bool
-  * fix(resize): code format issue
-  * refactor(resize): add Go version comment
-  * refactor(tests): fix minor code formatting issues
-  * fix(#162): garbage collection fix. split Resize() implementation for Go runtime specific
-  * feat(travis): add go 1.9
-  * Merge pull request #183 from greut/autorotate
-  * Proper handling of the EXIF cases.
-  * Merge pull request #184 from greut/libvips858
-  * Merge branch 'master' into libvips858
-  * Merge pull request #185 from greut/libvips860
-  * Add libvips 8.6 pre-release
-  * Update to libvips 8.5.8
-  * fix(resize): runtime.KeepAlive is only Go
-  * fix(#159): prevent buf to be freed by the GC before resize function exits
-  * Merge pull request #171 from greut/fix-170
-  * Check the length before jumping into buffer.
-  * Merge pull request #168 from Traum-Ferienwohnungen/icc_transform
-  * Add option to convert embedded ICC profiles
-  * Merge pull request #166 from danjou-a/patch-1
-  * Fix Resize verification value
-  * Merge pull request #165 from greut/libvips846
-  * Testing using libvips8.4.6 from Github.
-
-## v1.0.10 / 2017-06-25
-
-  * Merge pull request #164 from greut/length
-  * Add Image.Length()
-  * Merge pull request #163 from greut/libvips856
-  * Run libvips 8.5.6 on Travis.
-  * Merge pull request #161 from henry-blip/master
-  * Expose vips cache memory management functions.
-  * feat(docs): add watermark image note in features
-
-## v1.0.9 / 2017-05-25
-
-  * Merge pull request #156 from Dynom/SmartCropToGravity
-  * Adding a test, verifying both ways of enabling SmartCrop work
-  * Merge pull request #149 from waldophotos/master
-  * Replacing SmartCrop with a Gravity option
-  * refactor(docs): v8.4
-  * Change for older LIBVIPS versions. `vips_bandjoin_const1` is added in libvips 8.2.
-  * Second try, watermarking memory issue fix
-
-## v1.0.8 / 2017-05-18
-
-  * Merge pull request #145 from greut/smartcrop
-  * Merge pull request #155 from greut/libvips8.5.5
-  * Update libvips to 8.5.5.
-  * Adding basic smartcrop support.
-  * Merge pull request #153 from abracadaber/master
-  * Added Linux Mint 17.3+ distro names
-  * feat(docs): add new maintainer notice (thanks to @kirillDanshin)
-  * Merge pull request #152 from greut/libvips85
-  * Download latest version of libvips from github.
-  * Merge pull request #147 from h2non/revert-143-master
-  * Revert "Fix for memory issue when watermarking images"
-  * Merge pull request #146 from greut/minor-major
-  * Merge pull request #143 from waldophotos/master
-  * Merge pull request #144 from greut/go18
-  * Fix tests where minor/major were mixed up
-  * Enabled go 1.8 builds.
-  * Fix the unref of images, when image isn't transparent
-  * Fix for memory issue when watermarking images
-  * feat(docs): add maintainers sections
-  * Merge pull request #132 from jaume-pinyol/WATERMARK_SUPPORT
-  * Add support for image watermarks
-  * Merge pull request #131 from greut/versions
-  * Running tests on more specific versions.
-  * refactor(preinstall.sh): remove deprecation notice
-  * Update preinstall.sh
-  * fix(requirements): required libvips 7.42
-  * fix(History): typo
-  * chore(History): add breaking change note
-
-## v1.0.7 / 13-01-2017
-
-- fix(#128): crop image calculation for missing width or height axis.
-- feat: add TIFF save output format (**note**: this introduces a minor interface breaking change in `bimg.IsImageTypeSupportedByVips` auxiliary function).
-
-## v1.0.6 / 12-11-2016
-
-- feat(#118): handle 16-bit PNGs.
-- feat(#119): adds JPEG2000 file for the type tests.
-- feat(#121): test bimg against multiple libvips versions.
-
-## v1.0.5 / 01-10-2016
-
-- feat(#92): support Extend param with optional background.
-- fix(#106): allow image area extraction without explicit x/y axis.
-- feat(api): add Extend type with `libvips` enum alias.
-
-## v1.0.4 / 29-09-2016
-
-- fix(#111): safe check of magick image type support.
-
-## v1.0.3 / 28-09-2016
-
-- fix(#95): better image type inference and support check.
-- fix(background): pass proper background RGB color for PNG image conversion.
-- feat(types): validate supported image types by current `libvips` compilation.
-- feat(types): consistent SVG image checking.
-- feat(api): add public functions `VipsIsTypeSupported()`, `IsImageTypeSupportedByVips()` and `IsSVGImage()`.
-
-## v1.0.2 / 27-09-2016
-
-- feat(#95): support GIF, SVG and PDF formats.
-- fix(#108): auto-width and height calculations now round instead of floor.
-
-## v1.0.1 / 22-06-2016
-
-- fix(#90): Do not not dereference the original image a second time.
-
-## v1.0.0 / 21-04-2016
-
-- refactor(api): breaking changes: normalize public members to follow Go naming idioms.
-- feat(version): bump to major version. API contract won't be compromised in `v1`.
-- feat(docs): add missing inline godoc documentation.

vendor/github.com/h2non/bimg/LICENSE

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

vendor/github.com/h2non/bimg/README.md

@@ -1,348 +0,0 @@
-# bimg [![Build Status](https://travis-ci.org/h2non/bimg.svg)](https://travis-ci.org/h2non/bimg) [![GoDoc](https://godoc.org/github.com/h2non/bimg?status.svg)](https://godoc.org/github.com/h2non/bimg) [![Go Report Card](http://goreportcard.com/badge/h2non/bimg)](http://goreportcard.com/report/h2non/bimg) [![Coverage Status](https://coveralls.io/repos/github/h2non/bimg/badge.svg?branch=master)](https://coveralls.io/github/h2non/bimg?branch=master) ![License](https://img.shields.io/badge/license-MIT-blue.svg)
-
-Small [Go](http://golang.org) package for fast high-level image processing using [libvips](https://github.com/jcupitt/libvips) via C bindings, providing a simple, elegant and fluent [programmatic API](#examples).
-
-bimg was designed to be a small and efficient library supporting a common set of [image operations](#supported-image-operations) such as crop, resize, rotate, zoom or watermark. It can read JPEG, PNG, WEBP natively, and optionally TIFF, PDF, GIF and SVG formats if `libvips@8.3+` is compiled with proper library bindings.
-
-bimg is able to output images as JPEG, PNG and WEBP formats, including transparent conversion across them.
-
-bimg uses internally libvips, a powerful library written in C for image processing which requires a [low memory footprint](http://www.vips.ecs.soton.ac.uk/index.php?title=Speed_and_Memory_Use)
-and it's typically 4x faster than using the quickest ImageMagick and GraphicsMagick settings or Go native `image` package, and in some cases it's even 8x faster processing JPEG images.
-
-If you're looking for an HTTP based image processing solution, see [imaginary](https://github.com/h2non/imaginary).
-
-bimg was heavily inspired in [sharp](https://github.com/lovell/sharp), its homologous package built for [node.js](http://nodejs.org). bimg is used in production environments processing thousands of images per day.
-
-**v1 notice**: `bimg` introduces some minor breaking changes in `v1` release.
-If you're using `gopkg.in`, you can still rely in the `v0` without worrying about API breaking changes.
-
-`bimg` is currently maintained by [Kirill Danshin](https://github.com/kirillDanshin).
-
-## Contents
-
-- [Supported image operations](#supported-image-operations)
-- [Prerequisites](#prerequisites)
-- [Installation](#installation)
-- [Performance](#performance)
-- [Benchmark](#benchmark)
-- [Examples](#examples)
-- [Debugging](#debugging)
-- [API](#api)
-- [Authors](#authors)
-- [Credits](#credits)
-
-## Supported image operations
-
-- Resize
-- Enlarge
-- Crop (including smart crop support, libvips 8.5+)
-- Rotate (with auto-rotate based on EXIF orientation)
-- Flip (with auto-flip based on EXIF metadata)
-- Flop
-- Zoom
-- Thumbnail
-- Extract area
-- Watermark (using text or image)
-- Gaussian blur effect
-- Custom output color space (RGB, grayscale...)
-- Format conversion (with additional quality/compression settings)
-- EXIF metadata (size, alpha channel, profile, orientation...)
-- Trim (libvips 8.6+)
-
-## Prerequisites
-
-- [libvips](https://github.com/jcupitt/libvips) 7.42+ or 8+ (8.4+ recommended)
-- C compatible compiler such as gcc 4.6+ or clang 3.0+
-- Go 1.3+
-
-**Note**: `libvips` v8.3+ is required for GIF, PDF and SVG support.
-
-## Installation
-
-```bash
-go get -u gopkg.in/h2non/bimg.v1
-```
-
-### libvips
-
-Run the following script as `sudo` (supports OSX, Debian/Ubuntu, Redhat, Fedora, Amazon Linux):
-```bash
-curl -s https://raw.githubusercontent.com/h2non/bimg/master/preinstall.sh | sudo bash -
-```
-
-If you wanna take the advantage of [OpenSlide](http://openslide.org/), simply add `--with-openslide` to enable it:
-```bash
-curl -s https://raw.githubusercontent.com/h2non/bimg/master/preinstall.sh | sudo bash -s --with-openslide
-```
-
-The [install script](https://github.com/h2non/bimg/blob/master/preinstall.sh) requires `curl` and `pkg-config`.
-
-## Performance
-
-libvips is probably the faster open source solution for image processing.
-Here you can see some performance test comparisons for multiple scenarios:
-
-- [libvips speed and memory usage](http://www.vips.ecs.soton.ac.uk/index.php?title=Speed_and_Memory_Use)
-
-## Benchmark
-
-Tested using Go 1.5.1 and libvips-7.42.3 in OSX i7 2.7Ghz
-```
-BenchmarkRotateJpeg-8     	      20	  64686945 ns/op
-BenchmarkResizeLargeJpeg-8	      20	  63390416 ns/op
-BenchmarkResizePng-8      	     100	  18147294 ns/op
-BenchmarkResizeWebP-8     	     100	  20836741 ns/op
-BenchmarkConvertToJpeg-8  	     100	  12831812 ns/op
-BenchmarkConvertToPng-8   	      10	 128901422 ns/op
-BenchmarkConvertToWebp-8  	      10	 204027990 ns/op
-BenchmarkCropJpeg-8       	      30	  59068572 ns/op
-BenchmarkCropPng-8        	      10	 117303259 ns/op
-BenchmarkCropWebP-8       	      10	 107060659 ns/op
-BenchmarkExtractJpeg-8    	      50	  30708919 ns/op
-BenchmarkExtractPng-8     	    3000	    595546 ns/op
-BenchmarkExtractWebp-8    	    3000	    386379 ns/op
-BenchmarkZoomJpeg-8       	      10	 160005424 ns/op
-BenchmarkZoomPng-8        	      30	  44561047 ns/op
-BenchmarkZoomWebp-8       	      10	 126732678 ns/op
-BenchmarkWatermarkJpeg-8  	      20	  79006133 ns/op
-BenchmarkWatermarPng-8    	     200	   8197291 ns/op
-BenchmarkWatermarWebp-8   	      30	  49360369 ns/op
-```
-
-## Examples
-
-```go
-import (
-  "fmt"
-  "os"
-  "gopkg.in/h2non/bimg.v1"
-)
-```
-
-#### Resize
-
-```go
-buffer, err := bimg.Read("image.jpg")
-if err != nil {
-  fmt.Fprintln(os.Stderr, err)
-}
-
-newImage, err := bimg.NewImage(buffer).Resize(800, 600)
-if err != nil {
-  fmt.Fprintln(os.Stderr, err)
-}
-
-size, err := bimg.NewImage(newImage).Size()
-if size.Width == 800 && size.Height == 600 {
-  fmt.Println("The image size is valid")
-}
-
-bimg.Write("new.jpg", newImage)
-```
-
-#### Rotate
-
-```go
-buffer, err := bimg.Read("image.jpg")
-if err != nil {
-  fmt.Fprintln(os.Stderr, err)
-}
-
-newImage, err := bimg.NewImage(buffer).Rotate(90)
-if err != nil {
-  fmt.Fprintln(os.Stderr, err)
-}
-
-bimg.Write("new.jpg", newImage)
-```
-
-#### Convert
-
-```go
-buffer, err := bimg.Read("image.jpg")
-if err != nil {
-  fmt.Fprintln(os.Stderr, err)
-}
-
-newImage, err := bimg.NewImage(buffer).Convert(bimg.PNG)
-if err != nil {
-  fmt.Fprintln(os.Stderr, err)
-}
-
-if bimg.NewImage(newImage).Type() == "png" {
-  fmt.Fprintln(os.Stderr, "The image was converted into png")
-}
-```
-
-#### Force resize
-
-Force resize operation without perserving the aspect ratio:
-
-```go
-buffer, err := bimg.Read("image.jpg")
-if err != nil {
-  fmt.Fprintln(os.Stderr, err)
-}
-
-newImage, err := bimg.NewImage(buffer).ForceResize(1000, 500)
-if err != nil {
-  fmt.Fprintln(os.Stderr, err)
-}
-
-size := bimg.Size(newImage)
-if size.Width != 1000 || size.Height != 500 {
-  fmt.Fprintln(os.Stderr, "Incorrect image size")
-}
-```
-
-#### Custom colour space (black & white)
-
-```go
-buffer, err := bimg.Read("image.jpg")
-if err != nil {
-  fmt.Fprintln(os.Stderr, err)
-}
-
-newImage, err := bimg.NewImage(buffer).Colourspace(bimg.INTERPRETATION_B_W)
-if err != nil {
-  fmt.Fprintln(os.Stderr, err)
-}
-
-colourSpace, _ := bimg.ImageInterpretation(newImage)
-if colourSpace != bimg.INTERPRETATION_B_W {
-  fmt.Fprintln(os.Stderr, "Invalid colour space")
-}
-```
-
-#### Custom options
-
-See [Options](https://godoc.org/github.com/h2non/bimg#Options) struct to discover all the available fields
-
-```go
-options := bimg.Options{
-  Width:        800,
-  Height:       600,
-  Crop:         true,
-  Quality:      95,
-  Rotate:       180,
-  Interlace:    true,
-}
-
-buffer, err := bimg.Read("image.jpg")
-if err != nil {
-  fmt.Fprintln(os.Stderr, err)
-}
-
-newImage, err := bimg.NewImage(buffer).Process(options)
-if err != nil {
-  fmt.Fprintln(os.Stderr, err)
-}
-
-bimg.Write("new.jpg", newImage)
-```
-
-#### Watermark
-
-```go
-buffer, err := bimg.Read("image.jpg")
-if err != nil {
-  fmt.Fprintln(os.Stderr, err)
-}
-
-watermark := bimg.Watermark{
-  Text:       "Chuck Norris (c) 2315",
-  Opacity:    0.25,
-  Width:      200,
-  DPI:        100,
-  Margin:     150,
-  Font:       "sans bold 12",
-  Background: bimg.Color{255, 255, 255},
-}
-
-newImage, err := bimg.NewImage(buffer).Watermark(watermark)
-if err != nil {
-  fmt.Fprintln(os.Stderr, err)
-}
-
-bimg.Write("new.jpg", newImage)
-```
-
-#### Fluent interface
-
-```go
-buffer, err := bimg.Read("image.jpg")
-if err != nil {
-  fmt.Fprintln(os.Stderr, err)
-}
-
-image := bimg.NewImage(buffer)
-
-// first crop image
-_, err := image.CropByWidth(300)
-if err != nil {
-  fmt.Fprintln(os.Stderr, err)
-}
-
-// then flip it
-newImage, err := image.Flip()
-if err != nil {
-  fmt.Fprintln(os.Stderr, err)
-}
-
-// save the cropped and flipped image
-bimg.Write("new.jpg", newImage)
-```
-
-## Debugging
-
-Run the process passing the `DEBUG` environment variable
-```
-DEBUG=bimg ./app
-```
-
-Enable libvips traces (note that a lot of data will be written in stdout):
-```
-VIPS_TRACE=1 ./app
-```
-
-You can also dump a core on failure, as [John Cuppit](https://github.com/jcupitt) said:
-```c
-g_log_set_always_fatal(
-                G_LOG_FLAG_RECURSION |
-                G_LOG_FLAG_FATAL |
-                G_LOG_LEVEL_ERROR |
-                G_LOG_LEVEL_CRITICAL |
-                G_LOG_LEVEL_WARNING );
-```
-
-Or set the G_DEBUG environment variable:
-```
-export G_DEBUG=fatal-warnings,fatal-criticals
-```
-
-## API
-
-See [godoc reference](https://godoc.org/github.com/h2non/bimg) for detailed API documentation.
-
-## Authors
-
-- [Tomás Aparicio](https://github.com/h2non) - Original author and architect.
-- [Kirill Danshin](https://github.com/kirillDanshin) - Maintainer since April 2017.
-
-## Credits
-
-People who recurrently contributed to improve `bimg` in some way.
-
-- [John Cupitt](https://github.com/jcupitt)
-- [Yoan Blanc](https://github.com/greut)
-- [Christophe Eblé](https://github.com/chreble)
-- [Brant Fitzsimmons](https://github.com/bfitzsimmons)
-- [Thomas Meson](https://github.com/zllak)
-
-Thank you!
-
-## License
-
-MIT - Tomas Aparicio
-
-[![views](https://sourcegraph.com/api/repos/github.com/h2non/bimg/.counters/views.svg)](https://sourcegraph.com/github.com/h2non/bimg)

vendor/github.com/h2non/bimg/file.go

@@ -1,15 +0,0 @@
-package bimg
-
-import "io/ioutil"
-
-// Read reads all the content of the given file path
-// and returns it as byte buffer.
-func Read(path string) ([]byte, error) {
-	return ioutil.ReadFile(path)
-}
-
-// Write writes the given byte buffer into disk
-// to the given file path.
-func Write(path string, buf []byte) error {
-	return ioutil.WriteFile(path, buf, 0644)
-}

vendor/github.com/h2non/bimg/file_test.go

@@ -1,38 +0,0 @@
-package bimg
-
-import (
-	"testing"
-)
-
-func TestRead(t *testing.T) {
-	buf, err := Read("fixtures/test.jpg")
-
-	if err != nil {
-		t.Errorf("Cannot read the image: %#v", err)
-	}
-
-	if len(buf) == 0 {
-		t.Fatal("Empty buffer")
-	}
-
-	if DetermineImageType(buf) != JPEG {
-		t.Fatal("Image is not jpeg")
-	}
-}
-
-func TestWrite(t *testing.T) {
-	buf, err := Read("fixtures/test.jpg")
-
-	if err != nil {
-		t.Errorf("Cannot read the image: %#v", err)
-	}
-
-	if len(buf) == 0 {
-		t.Fatal("Empty buffer")
-	}
-
-	err = Write("fixtures/test_write_out.jpg", buf)
-	if err != nil {
-		t.Fatalf("Cannot write the file: %#v", err)
-	}
-}

vendor/github.com/h2non/bimg/image.go

@@ -1,235 +0,0 @@
-package bimg
-
-// Image provides a simple method DSL to transform a given image as byte buffer.
-type Image struct {
-	buffer []byte
-}
-
-// NewImage creates a new Image struct with method DSL.
-func NewImage(buf []byte) *Image {
-	return &Image{buf}
-}
-
-// Resize resizes the image to fixed width and height.
-func (i *Image) Resize(width, height int) ([]byte, error) {
-	options := Options{
-		Width:  width,
-		Height: height,
-		Embed:  true,
-	}
-	return i.Process(options)
-}
-
-// ForceResize resizes with custom size (aspect ratio won't be maintained).
-func (i *Image) ForceResize(width, height int) ([]byte, error) {
-	options := Options{
-		Width:  width,
-		Height: height,
-		Force:  true,
-	}
-	return i.Process(options)
-}
-
-// ResizeAndCrop resizes the image to fixed width and height with additional crop transformation.
-func (i *Image) ResizeAndCrop(width, height int) ([]byte, error) {
-	options := Options{
-		Width:  width,
-		Height: height,
-		Embed:  true,
-		Crop:   true,
-	}
-	return i.Process(options)
-}
-
-// SmartCrop produces a thumbnail aiming at focus on the interesting part.
-func (i *Image) SmartCrop(width, height int) ([]byte, error) {
-	options := Options{
-		Width:   width,
-		Height:  height,
-		Crop:    true,
-		Gravity: GravitySmart,
-	}
-	return i.Process(options)
-}
-
-// Extract area from the by X/Y axis in the current image.
-func (i *Image) Extract(top, left, width, height int) ([]byte, error) {
-	options := Options{
-		Top:        top,
-		Left:       left,
-		AreaWidth:  width,
-		AreaHeight: height,
-	}
-
-	if top == 0 && left == 0 {
-		options.Top = -1
-	}
-
-	return i.Process(options)
-}
-
-// Enlarge enlarges the image by width and height. Aspect ratio is maintained.
-func (i *Image) Enlarge(width, height int) ([]byte, error) {
-	options := Options{
-		Width:   width,
-		Height:  height,
-		Enlarge: true,
-	}
-	return i.Process(options)
-}
-
-// EnlargeAndCrop enlarges the image by width and height with additional crop transformation.
-func (i *Image) EnlargeAndCrop(width, height int) ([]byte, error) {
-	options := Options{
-		Width:   width,
-		Height:  height,
-		Enlarge: true,
-		Crop:    true,
-	}
-	return i.Process(options)
-}
-
-// Crop crops the image to the exact size specified.
-func (i *Image) Crop(width, height int, gravity Gravity) ([]byte, error) {
-	options := Options{
-		Width:   width,
-		Height:  height,
-		Gravity: gravity,
-		Crop:    true,
-	}
-	return i.Process(options)
-}
-
-// CropByWidth crops an image by width only param (auto height).
-func (i *Image) CropByWidth(width int) ([]byte, error) {
-	options := Options{
-		Width: width,
-		Crop:  true,
-	}
-	return i.Process(options)
-}
-
-// CropByHeight crops an image by height (auto width).
-func (i *Image) CropByHeight(height int) ([]byte, error) {
-	options := Options{
-		Height: height,
-		Crop:   true,
-	}
-	return i.Process(options)
-}
-
-// Thumbnail creates a thumbnail of the image by the a given width by aspect ratio 4:4.
-func (i *Image) Thumbnail(pixels int) ([]byte, error) {
-	options := Options{
-		Width:   pixels,
-		Height:  pixels,
-		Crop:    true,
-		Quality: 95,
-	}
-	return i.Process(options)
-}
-
-// Watermark adds text as watermark on the given image.
-func (i *Image) Watermark(w Watermark) ([]byte, error) {
-	options := Options{Watermark: w}
-	return i.Process(options)
-}
-
-// WatermarkImage adds image as watermark on the given image.
-func (i *Image) WatermarkImage(w WatermarkImage) ([]byte, error) {
-	options := Options{WatermarkImage: w}
-	return i.Process(options)
-}
-
-// Zoom zooms the image by the given factor.
-// You should probably call Extract() before.
-func (i *Image) Zoom(factor int) ([]byte, error) {
-	options := Options{Zoom: factor}
-	return i.Process(options)
-}
-
-// Rotate rotates the image by given angle degrees (0, 90, 180 or 270).
-func (i *Image) Rotate(a Angle) ([]byte, error) {
-	options := Options{Rotate: a}
-	return i.Process(options)
-}
-
-// Flip flips the image about the vertical Y axis.
-func (i *Image) Flip() ([]byte, error) {
-	options := Options{Flip: true}
-	return i.Process(options)
-}
-
-// Flop flops the image about the horizontal X axis.
-func (i *Image) Flop() ([]byte, error) {
-	options := Options{Flop: true}
-	return i.Process(options)
-}
-
-// Convert converts image to another format.
-func (i *Image) Convert(t ImageType) ([]byte, error) {
-	options := Options{Type: t}
-	return i.Process(options)
-}
-
-// Colourspace performs a color space conversion bsaed on the given interpretation.
-func (i *Image) Colourspace(c Interpretation) ([]byte, error) {
-	options := Options{Interpretation: c}
-	return i.Process(options)
-}
-
-// Trim removes the background from the picture. It can result in a 0x0 output
-// if the image is all background.
-func (i *Image) Trim() ([]byte, error) {
-	options := Options{Trim: true}
-	return i.Process(options)
-}
-
-// Process processes the image based on the given transformation options,
-// talking with libvips bindings accordingly and returning the resultant
-// image buffer.
-func (i *Image) Process(o Options) ([]byte, error) {
-	image, err := Resize(i.buffer, o)
-	if err != nil {
-		return nil, err
-	}
-	i.buffer = image
-	return image, nil
-}
-
-// Metadata returns the image metadata (size, alpha channel, profile, EXIF rotation).
-func (i *Image) Metadata() (ImageMetadata, error) {
-	return Metadata(i.buffer)
-}
-
-// Interpretation gets the image interpretation type.
-// See: http://www.vips.ecs.soton.ac.uk/supported/current/doc/html/libvips/VipsImage.html#VipsInterpretation
-func (i *Image) Interpretation() (Interpretation, error) {
-	return ImageInterpretation(i.buffer)
-}
-
-// ColourspaceIsSupported checks if the current image
-// color space is supported.
-func (i *Image) ColourspaceIsSupported() (bool, error) {
-	return ColourspaceIsSupported(i.buffer)
-}
-
-// Type returns the image type format (jpeg, png, webp, tiff).
-func (i *Image) Type() string {
-	return DetermineImageTypeName(i.buffer)
-}
-
-// Size returns the image size as form of width and height pixels.
-func (i *Image) Size() (ImageSize, error) {
-	return Size(i.buffer)
-}
-
-// Image returns the current resultant image buffer.
-func (i *Image) Image() []byte {
-	return i.buffer
-}
-
-// Length returns the size in bytes of the image buffer.
-func (i *Image) Length() int {
-	return len(i.buffer)
-}

vendor/github.com/h2non/bimg/image_test.go

@@ -1,527 +0,0 @@
-package bimg
-
-import (
-	"fmt"
-	"path"
-	"testing"
-)
-
-func TestImageResize(t *testing.T) {
-	buf, err := initImage("test.jpg").Resize(300, 240)
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-
-	err = assertSize(buf, 300, 240)
-	if err != nil {
-		t.Error(err)
-	}
-
-	Write("fixtures/test_resize_out.jpg", buf)
-}
-
-func TestImageGifResize(t *testing.T) {
-	_, err := initImage("test.gif").Resize(300, 240)
-	if err == nil {
-		t.Errorf("GIF shouldn't be saved within VIPS")
-	}
-}
-
-func TestImagePdfResize(t *testing.T) {
-	_, err := initImage("test.pdf").Resize(300, 240)
-	if err == nil {
-		t.Errorf("PDF cannot be saved within VIPS")
-	}
-}
-
-func TestImageSvgResize(t *testing.T) {
-	_, err := initImage("test.svg").Resize(300, 240)
-	if err == nil {
-		t.Errorf("SVG cannot be saved within VIPS")
-	}
-}
-
-func TestImageGifToJpeg(t *testing.T) {
-	if VipsMajorVersion >= 8 && VipsMinorVersion > 2 {
-		i := initImage("test.gif")
-		options := Options{
-			Type: JPEG,
-		}
-		buf, err := i.Process(options)
-		if err != nil {
-			t.Errorf("Cannot process the image: %#v", err)
-		}
-
-		Write("fixtures/test_gif.jpg", buf)
-	}
-}
-
-func TestImagePdfToJpeg(t *testing.T) {
-	if VipsMajorVersion >= 8 && VipsMinorVersion > 2 {
-		i := initImage("test.pdf")
-		options := Options{
-			Type: JPEG,
-		}
-		buf, err := i.Process(options)
-		if err != nil {
-			t.Errorf("Cannot process the image: %#v", err)
-		}
-
-		Write("fixtures/test_pdf.jpg", buf)
-	}
-}
-
-func TestImageSvgToJpeg(t *testing.T) {
-	if VipsMajorVersion >= 8 && VipsMinorVersion > 2 {
-		i := initImage("test.svg")
-		options := Options{
-			Type: JPEG,
-		}
-		buf, err := i.Process(options)
-		if err != nil {
-			t.Errorf("Cannot process the image: %#v", err)
-		}
-
-		Write("fixtures/test_svg.jpg", buf)
-	}
-}
-
-func TestImageResizeAndCrop(t *testing.T) {
-	buf, err := initImage("test.jpg").ResizeAndCrop(300, 200)
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-
-	err = assertSize(buf, 300, 200)
-	if err != nil {
-		t.Error(err)
-	}
-
-	Write("fixtures/test_resize_crop_out.jpg", buf)
-}
-
-func TestImageExtract(t *testing.T) {
-	buf, err := initImage("test.jpg").Extract(100, 100, 300, 200)
-	if err != nil {
-		t.Errorf("Cannot process the image: %s", err)
-	}
-
-	err = assertSize(buf, 300, 200)
-	if err != nil {
-		t.Error(err)
-	}
-
-	Write("fixtures/test_extract_out.jpg", buf)
-}
-
-func TestImageExtractZero(t *testing.T) {
-	buf, err := initImage("test.jpg").Extract(0, 0, 300, 200)
-	if err != nil {
-		t.Errorf("Cannot process the image: %s", err)
-	}
-
-	err = assertSize(buf, 300, 200)
-	if err != nil {
-		t.Error(err)
-	}
-
-	Write("fixtures/test_extract_zero_out.jpg", buf)
-}
-
-func TestImageEnlarge(t *testing.T) {
-	buf, err := initImage("test.png").Enlarge(500, 375)
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-
-	err = assertSize(buf, 500, 375)
-	if err != nil {
-		t.Error(err)
-	}
-
-	Write("fixtures/test_enlarge_out.jpg", buf)
-}
-
-func TestImageEnlargeAndCrop(t *testing.T) {
-	buf, err := initImage("test.png").EnlargeAndCrop(800, 480)
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-
-	err = assertSize(buf, 800, 480)
-	if err != nil {
-		t.Error(err)
-	}
-
-	Write("fixtures/test_enlarge_crop_out.jpg", buf)
-}
-
-func TestImageCrop(t *testing.T) {
-	buf, err := initImage("test.jpg").Crop(800, 600, GravityNorth)
-	if err != nil {
-		t.Errorf("Cannot process the image: %s", err)
-	}
-
-	err = assertSize(buf, 800, 600)
-	if err != nil {
-		t.Error(err)
-	}
-
-	Write("fixtures/test_crop_out.jpg", buf)
-}
-
-func TestImageCropByWidth(t *testing.T) {
-	buf, err := initImage("test.jpg").CropByWidth(600)
-	if err != nil {
-		t.Errorf("Cannot process the image: %s", err)
-	}
-
-	err = assertSize(buf, 600, 1050)
-	if err != nil {
-		t.Error(err)
-	}
-
-	Write("fixtures/test_crop_width_out.jpg", buf)
-}
-
-func TestImageCropByHeight(t *testing.T) {
-	buf, err := initImage("test.jpg").CropByHeight(300)
-	if err != nil {
-		t.Errorf("Cannot process the image: %s", err)
-	}
-
-	err = assertSize(buf, 1680, 300)
-	if err != nil {
-		t.Error(err)
-	}
-
-	Write("fixtures/test_crop_height_out.jpg", buf)
-}
-
-func TestImageThumbnail(t *testing.T) {
-	buf, err := initImage("test.jpg").Thumbnail(100)
-	if err != nil {
-		t.Errorf("Cannot process the image: %s", err)
-	}
-
-	err = assertSize(buf, 100, 100)
-	if err != nil {
-		t.Error(err)
-	}
-
-	Write("fixtures/test_thumbnail_out.jpg", buf)
-}
-
-func TestImageWatermark(t *testing.T) {
-	image := initImage("test.jpg")
-	_, err := image.Crop(800, 600, GravityNorth)
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-
-	buf, err := image.Watermark(Watermark{
-		Text:       "Copy me if you can",
-		Opacity:    0.5,
-		Width:      200,
-		DPI:        100,
-		Background: Color{255, 255, 255},
-	})
-	if err != nil {
-		t.Error(err)
-	}
-
-	err = assertSize(buf, 800, 600)
-	if err != nil {
-		t.Error(err)
-	}
-
-	if DetermineImageType(buf) != JPEG {
-		t.Fatal("Image is not jpeg")
-	}
-
-	Write("fixtures/test_watermark_text_out.jpg", buf)
-}
-
-func TestImageWatermarkWithImage(t *testing.T) {
-	image := initImage("test.jpg")
-	watermark, _ := imageBuf("transparent.png")
-
-	_, err := image.Crop(800, 600, GravityNorth)
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-
-	buf, err := image.WatermarkImage(WatermarkImage{Left: 100, Top: 100, Buf: watermark})
-
-	if err != nil {
-		t.Error(err)
-	}
-
-	err = assertSize(buf, 800, 600)
-	if err != nil {
-		t.Error(err)
-	}
-
-	if DetermineImageType(buf) != JPEG {
-		t.Fatal("Image is not jpeg")
-	}
-
-	Write("fixtures/test_watermark_image_out.jpg", buf)
-}
-
-func TestImageWatermarkNoReplicate(t *testing.T) {
-	image := initImage("test.jpg")
-	_, err := image.Crop(800, 600, GravityNorth)
-	if err != nil {
-		t.Errorf("Cannot process the image: %s", err)
-	}
-
-	buf, err := image.Watermark(Watermark{
-		Text:        "Copy me if you can",
-		Opacity:     0.5,
-		Width:       200,
-		DPI:         100,
-		NoReplicate: true,
-		Background:  Color{255, 255, 255},
-	})
-	if err != nil {
-		t.Error(err)
-	}
-
-	err = assertSize(buf, 800, 600)
-	if err != nil {
-		t.Error(err)
-	}
-
-	if DetermineImageType(buf) != JPEG {
-		t.Fatal("Image is not jpeg")
-	}
-
-	Write("fixtures/test_watermark_replicate_out.jpg", buf)
-}
-
-func TestImageZoom(t *testing.T) {
-	image := initImage("test.jpg")
-
-	_, err := image.Extract(100, 100, 400, 300)
-	if err != nil {
-		t.Errorf("Cannot extract the image: %s", err)
-	}
-
-	buf, err := image.Zoom(1)
-	if err != nil {
-		t.Errorf("Cannot process the image: %s", err)
-	}
-
-	err = assertSize(buf, 800, 600)
-	if err != nil {
-		t.Error(err)
-	}
-
-	Write("fixtures/test_zoom_out.jpg", buf)
-}
-
-func TestImageFlip(t *testing.T) {
-	buf, err := initImage("test.jpg").Flip()
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-	Write("fixtures/test_flip_out.jpg", buf)
-}
-
-func TestImageFlop(t *testing.T) {
-	buf, err := initImage("test.jpg").Flop()
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-	Write("fixtures/test_flop_out.jpg", buf)
-}
-
-func TestImageRotate(t *testing.T) {
-	buf, err := initImage("test_flip_out.jpg").Rotate(90)
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-	Write("fixtures/test_image_rotate_out.jpg", buf)
-}
-
-func TestImageConvert(t *testing.T) {
-	buf, err := initImage("test.jpg").Convert(PNG)
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-	Write("fixtures/test_image_convert_out.png", buf)
-}
-
-func TestTransparentImageConvert(t *testing.T) {
-	image := initImage("transparent.png")
-	options := Options{
-		Type:       JPEG,
-		Background: Color{255, 255, 255},
-	}
-	buf, err := image.Process(options)
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-	Write("fixtures/test_transparent_image_convert_out.jpg", buf)
-}
-
-func TestImageMetadata(t *testing.T) {
-	data, err := initImage("test.png").Metadata()
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-	if data.Alpha != true {
-		t.Fatal("Invalid alpha channel")
-	}
-	if data.Size.Width != 400 {
-		t.Fatal("Invalid width size")
-	}
-	if data.Type != "png" {
-		t.Fatal("Invalid image type")
-	}
-}
-
-func TestInterpretation(t *testing.T) {
-	interpretation, err := initImage("test.jpg").Interpretation()
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-	if interpretation != InterpretationSRGB {
-		t.Errorf("Invalid interpretation: %d", interpretation)
-	}
-}
-
-func TestImageColourspace(t *testing.T) {
-	tests := []struct {
-		file           string
-		interpretation Interpretation
-	}{
-		{"test.jpg", InterpretationSRGB},
-		{"test.jpg", InterpretationBW},
-	}
-
-	for _, test := range tests {
-		buf, err := initImage(test.file).Colourspace(test.interpretation)
-		if err != nil {
-			t.Errorf("Cannot process the image: %#v", err)
-		}
-
-		interpretation, err := ImageInterpretation(buf)
-		if interpretation != test.interpretation {
-			t.Errorf("Invalid colourspace")
-		}
-	}
-}
-
-func TestImageColourspaceIsSupported(t *testing.T) {
-	supported, err := initImage("test.jpg").ColourspaceIsSupported()
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-	if supported != true {
-		t.Errorf("Non-supported colourspace")
-	}
-}
-
-func TestFluentInterface(t *testing.T) {
-	image := initImage("test.jpg")
-	_, err := image.CropByWidth(300)
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-
-	_, err = image.Flip()
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-
-	_, err = image.Convert(PNG)
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-
-	data, _ := image.Metadata()
-	if data.Alpha != false {
-		t.Fatal("Invalid alpha channel")
-	}
-	if data.Size.Width != 300 {
-		t.Fatal("Invalid width size")
-	}
-	if data.Type != "png" {
-		t.Fatal("Invalid image type")
-	}
-
-	Write("fixtures/test_image_fluent_out.png", image.Image())
-}
-
-func TestImageSmartCrop(t *testing.T) {
-
-	if !(VipsMajorVersion >= 8 && VipsMinorVersion >= 5) {
-		t.Skipf("Skipping this test, libvips doesn't meet version requirement %s >= 8.5", VipsVersion)
-	}
-
-	i := initImage("northern_cardinal_bird.jpg")
-	buf, err := i.SmartCrop(300, 300)
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-
-	err = assertSize(buf, 300, 300)
-	if err != nil {
-		t.Error(err)
-	}
-
-	Write("fixtures/test_smart_crop.jpg", buf)
-}
-
-func TestImageTrim(t *testing.T) {
-
-	if !(VipsMajorVersion >= 8 && VipsMinorVersion >= 6) {
-		t.Skipf("Skipping this test, libvips doesn't meet version requirement %s >= 8.6", VipsVersion)
-	}
-
-	i := initImage("transparent.png")
-	buf, err := i.Trim()
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-
-	err = assertSize(buf, 250, 208)
-	if err != nil {
-		t.Errorf("The image wasn't trimmed.")
-	}
-
-	Write("fixtures/transparent_trim.png", buf)
-}
-
-func TestImageLength(t *testing.T) {
-	i := initImage("test.jpg")
-
-	actual := i.Length()
-	expected := 53653
-
-	if expected != actual {
-		t.Errorf("Size in Bytes of the image doesn't correspond. %d != %d", expected, actual)
-	}
-}
-
-func initImage(file string) *Image {
-	buf, _ := imageBuf(file)
-	return NewImage(buf)
-}
-
-func imageBuf(file string) ([]byte, error) {
-	return Read(path.Join("fixtures", file))
-}
-
-func assertSize(buf []byte, width, height int) error {
-	size, err := NewImage(buf).Size()
-	if err != nil {
-		return err
-	}
-	if size.Width != width || size.Height != height {
-		return fmt.Errorf("Invalid image size: %dx%d", size.Width, size.Height)
-	}
-	return nil
-}

vendor/github.com/h2non/bimg/metadata.go

@@ -1,77 +0,0 @@
-package bimg
-
-/*
-#cgo pkg-config: vips
-#include "vips/vips.h"
-*/
-import "C"
-
-// ImageSize represents the image width and height values
-type ImageSize struct {
-	Width  int
-	Height int
-}
-
-// ImageMetadata represents the basic metadata fields
-type ImageMetadata struct {
-	Orientation int
-	Channels    int
-	Alpha       bool
-	Profile     bool
-	Type        string
-	Space       string
-	Colourspace string
-	Size        ImageSize
-}
-
-// Size returns the image size by width and height pixels.
-func Size(buf []byte) (ImageSize, error) {
-	metadata, err := Metadata(buf)
-	if err != nil {
-		return ImageSize{}, err
-	}
-
-	return ImageSize{
-		Width:  int(metadata.Size.Width),
-		Height: int(metadata.Size.Height),
-	}, nil
-}
-
-// ColourspaceIsSupported checks if the image colourspace is supported by libvips.
-func ColourspaceIsSupported(buf []byte) (bool, error) {
-	return vipsColourspaceIsSupportedBuffer(buf)
-}
-
-// ImageInterpretation returns the image interpretation type.
-// See: http://www.vips.ecs.soton.ac.uk/supported/current/doc/html/libvips/VipsImage.html#VipsInterpretation
-func ImageInterpretation(buf []byte) (Interpretation, error) {
-	return vipsInterpretationBuffer(buf)
-}
-
-// Metadata returns the image metadata (size, type, alpha channel, profile, EXIF orientation...).
-func Metadata(buf []byte) (ImageMetadata, error) {
-	defer C.vips_thread_shutdown()
-
-	image, imageType, err := vipsRead(buf)
-	if err != nil {
-		return ImageMetadata{}, err
-	}
-	defer C.g_object_unref(C.gpointer(image))
-
-	size := ImageSize{
-		Width:  int(image.Xsize),
-		Height: int(image.Ysize),
-	}
-
-	metadata := ImageMetadata{
-		Size:        size,
-		Channels:    int(image.Bands),
-		Orientation: vipsExifOrientation(image),
-		Alpha:       vipsHasAlpha(image),
-		Profile:     vipsHasProfile(image),
-		Space:       vipsSpace(image),
-		Type:        ImageTypeName(imageType),
-	}
-
-	return metadata, nil
-}

vendor/github.com/h2non/bimg/metadata_test.go

@@ -1,124 +0,0 @@
-package bimg
-
-import (
-	"io/ioutil"
-	"os"
-	"path"
-	"testing"
-)
-
-func TestSize(t *testing.T) {
-	files := []struct {
-		name   string
-		width  int
-		height int
-	}{
-		{"test.jpg", 1680, 1050},
-		{"test.png", 400, 300},
-		{"test.webp", 550, 368},
-	}
-	for _, file := range files {
-		size, err := Size(readFile(file.name))
-		if err != nil {
-			t.Fatalf("Cannot read the image: %#v", err)
-		}
-
-		if size.Width != file.width || size.Height != file.height {
-			t.Fatalf("Unexpected image size: %dx%d", size.Width, size.Height)
-		}
-	}
-}
-
-func TestMetadata(t *testing.T) {
-	files := []struct {
-		name        string
-		format      string
-		orientation int
-		alpha       bool
-		profile     bool
-		space       string
-	}{
-		{"test.jpg", "jpeg", 0, false, false, "srgb"},
-		{"test_icc_prophoto.jpg", "jpeg", 0, false, true, "srgb"},
-		{"test.png", "png", 0, true, false, "srgb"},
-		{"test.webp", "webp", 0, false, false, "srgb"},
-	}
-
-	for _, file := range files {
-		metadata, err := Metadata(readFile(file.name))
-		if err != nil {
-			t.Fatalf("Cannot read the image: %s -> %s", file.name, err)
-		}
-
-		if metadata.Type != file.format {
-			t.Fatalf("Unexpected image format: %s", file.format)
-		}
-		if metadata.Orientation != file.orientation {
-			t.Fatalf("Unexpected image orientation: %d != %d", metadata.Orientation, file.orientation)
-		}
-		if metadata.Alpha != file.alpha {
-			t.Fatalf("Unexpected image alpha: %t != %t", metadata.Alpha, file.alpha)
-		}
-		if metadata.Profile != file.profile {
-			t.Fatalf("Unexpected image profile: %t != %t", metadata.Profile, file.profile)
-		}
-		if metadata.Space != file.space {
-			t.Fatalf("Unexpected image profile: %t != %t", metadata.Profile, file.profile)
-		}
-	}
-}
-
-func TestImageInterpretation(t *testing.T) {
-	files := []struct {
-		name           string
-		interpretation Interpretation
-	}{
-		{"test.jpg", InterpretationSRGB},
-		{"test.png", InterpretationSRGB},
-		{"test.webp", InterpretationSRGB},
-	}
-
-	for _, file := range files {
-		interpretation, err := ImageInterpretation(readFile(file.name))
-		if err != nil {
-			t.Fatalf("Cannot read the image: %s -> %s", file.name, err)
-		}
-		if interpretation != file.interpretation {
-			t.Fatalf("Unexpected image interpretation")
-		}
-	}
-}
-
-func TestColourspaceIsSupported(t *testing.T) {
-	files := []struct {
-		name string
-	}{
-		{"test.jpg"},
-		{"test.png"},
-		{"test.webp"},
-	}
-
-	for _, file := range files {
-		supported, err := ColourspaceIsSupported(readFile(file.name))
-		if err != nil {
-			t.Fatalf("Cannot read the image: %s -> %s", file.name, err)
-		}
-		if supported != true {
-			t.Fatalf("Unsupported image colourspace")
-		}
-	}
-
-	supported, err := initImage("test.jpg").ColourspaceIsSupported()
-	if err != nil {
-		t.Errorf("Cannot process the image: %#v", err)
-	}
-	if supported != true {
-		t.Errorf("Non-supported colourspace")
-	}
-}
-
-func readFile(file string) []byte {
-	data, _ := os.Open(path.Join("fixtures", file))
-	buf, _ := ioutil.ReadAll(data)
-	return buf
-}

vendor/github.com/h2non/bimg/options.go

@@ -1,221 +0,0 @@
-package bimg
-
-/*
-#cgo pkg-config: vips
-#include "vips/vips.h"
-*/
-import "C"
-
-const (
-	// Quality defines the default JPEG quality to be used.
-	Quality = 80
-	// MaxSize defines the maximum pixels width or height supported.
-	MaxSize = 16383
-)
-
-// Gravity represents the image gravity value.
-type Gravity int
-
-const (
-	// GravityCentre represents the centre value used for image gravity orientation.
-	GravityCentre Gravity = iota
-	// GravityNorth represents the north value used for image gravity orientation.
-	GravityNorth
-	// GravityEast represents the east value used for image gravity orientation.
-	GravityEast
-	// GravitySouth represents the south value used for image gravity orientation.
-	GravitySouth
-	// GravityWest represents the west value used for image gravity orientation.
-	GravityWest
-	// GravitySmart enables libvips Smart Crop algorithm for image gravity orientation.
-	GravitySmart
-)
-
-// Interpolator represents the image interpolation value.
-type Interpolator int
-
-const (
-	// Bicubic interpolation value.
-	Bicubic Interpolator = iota
-	// Bilinear interpolation value.
-	Bilinear
-	// Nohalo interpolation value.
-	Nohalo
-)
-
-var interpolations = map[Interpolator]string{
-	Bicubic:  "bicubic",
-	Bilinear: "bilinear",
-	Nohalo:   "nohalo",
-}
-
-func (i Interpolator) String() string {
-	return interpolations[i]
-}
-
-// Angle represents the image rotation angle value.
-type Angle int
-
-const (
-	// D0 represents the rotation angle 0 degrees.
-	D0 Angle = 0
-	// D45 represents the rotation angle 90 degrees.
-	D45 Angle = 45
-	// D90 represents the rotation angle 90 degrees.
-	D90 Angle = 90
-	// D135 represents the rotation angle 90 degrees.
-	D135 Angle = 135
-	// D180 represents the rotation angle 180 degrees.
-	D180 Angle = 180
-	// D235 represents the rotation angle 235 degrees.
-	D235 Angle = 235
-	// D270 represents the rotation angle 270 degrees.
-	D270 Angle = 270
-	// D315 represents the rotation angle 180 degrees.
-	D315 Angle = 315
-)
-
-// Direction represents the image direction value.
-type Direction int
-
-const (
-	// Horizontal represents the orizontal image direction value.
-	Horizontal Direction = C.VIPS_DIRECTION_HORIZONTAL
-	// Vertical represents the vertical image direction value.
-	Vertical Direction = C.VIPS_DIRECTION_VERTICAL
-)
-
-// Interpretation represents the image interpretation type.
-// See: http://www.vips.ecs.soton.ac.uk/supported/current/doc/html/libvips/VipsImage.html#VipsInterpretation
-type Interpretation int
-
-const (
-	// InterpretationError points to the libvips interpretation error type.
-	InterpretationError Interpretation = C.VIPS_INTERPRETATION_ERROR
-	// InterpretationMultiband points to its libvips interpretation equivalent type.
-	InterpretationMultiband Interpretation = C.VIPS_INTERPRETATION_MULTIBAND
-	// InterpretationBW points to its libvips interpretation equivalent type.
-	InterpretationBW Interpretation = C.VIPS_INTERPRETATION_B_W
-	// InterpretationCMYK points to its libvips interpretation equivalent type.
-	InterpretationCMYK Interpretation = C.VIPS_INTERPRETATION_CMYK
-	// InterpretationRGB points to its libvips interpretation equivalent type.
-	InterpretationRGB Interpretation = C.VIPS_INTERPRETATION_RGB
-	// InterpretationSRGB points to its libvips interpretation equivalent type.
-	InterpretationSRGB Interpretation = C.VIPS_INTERPRETATION_sRGB
-	// InterpretationRGB16 points to its libvips interpretation equivalent type.
-	InterpretationRGB16 Interpretation = C.VIPS_INTERPRETATION_RGB16
-	// InterpretationGREY16 points to its libvips interpretation equivalent type.
-	InterpretationGREY16 Interpretation = C.VIPS_INTERPRETATION_GREY16
-	// InterpretationScRGB points to its libvips interpretation equivalent type.
-	InterpretationScRGB Interpretation = C.VIPS_INTERPRETATION_scRGB
-	// InterpretationLAB points to its libvips interpretation equivalent type.
-	InterpretationLAB Interpretation = C.VIPS_INTERPRETATION_LAB
-	// InterpretationXYZ points to its libvips interpretation equivalent type.
-	InterpretationXYZ Interpretation = C.VIPS_INTERPRETATION_XYZ
-)
-
-// Extend represents the image extend mode, used when the edges
-// of an image are extended, you can specify how you want the extension done.
-// See: http://www.vips.ecs.soton.ac.uk/supported/8.4/doc/html/libvips/libvips-conversion.html#VIPS-EXTEND-BACKGROUND:CAPS
-type Extend int
-
-const (
-	// ExtendBlack extend with black (all 0) pixels mode.
-	ExtendBlack Extend = C.VIPS_EXTEND_BLACK
-	// ExtendCopy copy the image edges.
-	ExtendCopy Extend = C.VIPS_EXTEND_COPY
-	// ExtendRepeat repeat the whole image.
-	ExtendRepeat Extend = C.VIPS_EXTEND_REPEAT
-	// ExtendMirror mirror the whole image.
-	ExtendMirror Extend = C.VIPS_EXTEND_MIRROR
-	// ExtendWhite extend with white (all bits set) pixels.
-	ExtendWhite Extend = C.VIPS_EXTEND_WHITE
-	// ExtendBackground with colour from the background property.
-	ExtendBackground Extend = C.VIPS_EXTEND_BACKGROUND
-	// ExtendLast extend with last pixel.
-	ExtendLast Extend = C.VIPS_EXTEND_LAST
-)
-
-// WatermarkFont defines the default watermark font to be used.
-var WatermarkFont = "sans 10"
-
-// Color represents a traditional RGB color scheme.
-type Color struct {
-	R, G, B uint8
-}
-
-// ColorBlack is a shortcut to black RGB color representation.
-var ColorBlack = Color{0, 0, 0}
-
-// Watermark represents the text-based watermark supported options.
-type Watermark struct {
-	Width       int
-	DPI         int
-	Margin      int
-	Opacity     float32
-	NoReplicate bool
-	Text        string
-	Font        string
-	Background  Color
-}
-
-// WatermarkImage represents the image-based watermark supported options.
-type WatermarkImage struct {
-	Left    int
-	Top     int
-	Buf     []byte
-	Opacity float32
-}
-
-// GaussianBlur represents the gaussian image transformation values.
-type GaussianBlur struct {
-	Sigma   float64
-	MinAmpl float64
-}
-
-// Sharpen represents the image sharp transformation options.
-type Sharpen struct {
-	Radius int
-	X1     float64
-	Y2     float64
-	Y3     float64
-	M1     float64
-	M2     float64
-}
-
-// Options represents the supported image transformation options.
-type Options struct {
-	Height         int
-	Width          int
-	AreaHeight     int
-	AreaWidth      int
-	Top            int
-	Left           int
-	Quality        int
-	Compression    int
-	Zoom           int
-	Crop           bool
-	SmartCrop      bool // Deprecated
-	Enlarge        bool
-	Embed          bool
-	Flip           bool
-	Flop           bool
-	Force          bool
-	NoAutoRotate   bool
-	NoProfile      bool
-	Interlace      bool
-	StripMetadata  bool
-	Trim           bool
-	Extend         Extend
-	Rotate         Angle
-	Background     Color
-	Gravity        Gravity
-	Watermark      Watermark
-	WatermarkImage WatermarkImage
-	Type           ImageType
-	Interpolator   Interpolator
-	Interpretation Interpretation
-	GaussianBlur   GaussianBlur
-	Sharpen        Sharpen
-	OutputICC      string
-}

vendor/github.com/h2non/bimg/preinstall.sh

@@ -1,302 +0,0 @@
-#!/bin/bash
-
-vips_version_minimum=8.4.2
-vips_version_latest_major_minor=8.4
-vips_version_latest_patch=2
-
-openslide_version_minimum=3.4.0
-openslide_version_latest_major_minor=3.4
-openslide_version_latest_patch=1
-
-install_libvips_from_source() {
-  echo "Compiling libvips $vips_version_latest_major_minor.$vips_version_latest_patch from source"
-  curl -O http://www.vips.ecs.soton.ac.uk/supported/$vips_version_latest_major_minor/vips-$vips_version_latest_major_minor.$vips_version_latest_patch.tar.gz
-  tar zvxf vips-$vips_version_latest_major_minor.$vips_version_latest_patch.tar.gz
-  cd vips-$vips_version_latest_major_minor.$vips_version_latest_patch
-  CXXFLAGS="-D_GLIBCXX_USE_CXX11_ABI=0" ./configure --disable-debug --disable-docs --disable-static --disable-introspection --disable-dependency-tracking --enable-cxx=yes --without-python --without-orc --without-fftw $1
-  make
-  make install
-  cd ..
-  rm -rf vips-$vips_version_latest_major_minor.$vips_version_latest_patch
-  rm vips-$vips_version_latest_major_minor.$vips_version_latest_patch.tar.gz
-  ldconfig
-  echo "Installed libvips $(PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig:/usr/lib/pkgconfig pkg-config --modversion vips)"
-}
-
-install_libopenslide_from_source() {
-  echo "Compiling openslide $openslide_version_latest_major_minor.$openslide_version_latest_patch from source"
-  curl -O -L https://github.com/openslide/openslide/releases/download/v$openslide_version_latest_major_minor.$openslide_version_latest_patch/openslide-$openslide_version_latest_major_minor.$openslide_version_latest_patch.tar.gz
-  tar xzvf openslide-$openslide_version_latest_major_minor.$openslide_version_latest_patch.tar.gz
-  cd openslide-$openslide_version_latest_major_minor.$openslide_version_latest_patch
-  PKG_CONFIG_PATH=$pkg_config_path ./configure $1
-  make
-  make install
-  cd ..
-  rm -rf openslide-$openslide_version_latest_major_minor.$openslide_version_latest_patch
-  rm openslide-$openslide_version_latest_major_minor.$openslide_version_latest_patch.tar.gz
-  ldconfig
-  echo "Installed libopenslide $openslide_version_latest_major_minor.$openslide_version_latest_patch"
-}
-
-sorry() {
-  echo "Sorry, I don't yet know how to install lib$1 on $2"
-  exit 1
-}
-
-pkg_config_path="$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig:/usr/lib/pkgconfig"
-
-check_if_library_exists() {
-  PKG_CONFIG_PATH=$pkg_config_path pkg-config --exists $1
-  if [ $? -eq 0 ]; then
-    version_found=$(PKG_CONFIG_PATH=$pkg_config_path pkg-config --modversion $1)
-    PKG_CONFIG_PATH=$pkg_config_path pkg-config --atleast-version=$2 $1
-    if [ $? -eq 0 ]; then
-      # Found suitable version of libvips
-      echo "Found lib$1 $version_found"
-      return 1
-    fi
-    echo "Found lib$1 $version_found but require $2"
-  else
-    echo "Could not find lib$1 using a PKG_CONFIG_PATH of '$pkg_config_path'"
-  fi
-  return 0
-}
-
-enable_openslide=0
-# Is libvips already installed, and is it at least the minimum required version?
-if [ $# -eq 1 ]; then
-  if [ "$1" = "--with-openslide" ]; then
-    echo "Installing vips with openslide support"
-    enable_openslide=1
-  else
-    echo "Sorry, $1 is not supported. Did you mean --with-openslide?"
-    exit 1
-  fi
-fi
-
-if ! type pkg-config >/dev/null; then
-  sorry "vips" "a system without pkg-config"
-fi
-
-openslide_exists=0
-if [ $enable_openslide -eq 1 ]; then
-  check_if_library_exists "openslide" "$openslide_version_minimum"
-  openslide_exists=$?
-fi
-
-check_if_library_exists "vips" "$vips_version_minimum"
-vips_exists=$?
-if [ $vips_exists -eq 1 ] && [ $enable_openslide -eq 1 ]; then
-  if [ $openslide_exists -eq 1 ]; then
-    # Check if vips compiled with openslide support
-    vips_with_openslide=`vips list classes | grep -i opensli`
-    if [ -z $vips_with_openslide ]; then
-      echo "Vips compiled without openslide support."
-    else
-      exit 0
-    fi
-  fi
-elif [ $vips_exists -eq 1 ] && [ $enable_openslide -eq 0 ]; then
-  exit 0
-fi
-
-# Verify root/sudo access
-if [ "$(id -u)" -ne "0" ]; then
-  echo "Sorry, I need root/sudo access to continue"
-  exit 1
-fi
-
-# Deprecation warning
-if [ "$(arch)" == "x86_64" ]; then
-  echo "This script is no longer required on most 64-bit Linux systems when using sharp v0.12.0+"
-fi
-
-# OS-specific installations of libopenslide follows
-# Either openslide does not exist, or vips is installed without openslide support
-if [ $enable_openslide -eq 1 ] && [ -z $vips_with_openslide ] && [ $openslide_exists -eq 0 ]; then
-  if [ -f /etc/debian_version ]; then
-    # Debian Linux
-    DISTRO=$(lsb_release -c -s)
-    echo "Detected Debian Linux '$DISTRO'"
-    case "$DISTRO" in
-      jessie|vivid|wily|xenial)
-        # Debian 8, Ubuntu 15
-        echo "Installing libopenslide via apt-get"
-        apt-get install -y libopenslide-dev
-        ;;
-      trusty|utopic|qiana|rebecca|rafaela|freya|rosa|sarah|serena)
-        # Ubuntu 14, Mint 17+
-        echo "Installing libopenslide dependencies via apt-get"
-        apt-get install -y automake build-essential curl zlib1g-dev libopenjpeg-dev libpng12-dev libjpeg-dev libtiff5-dev libgdk-pixbuf2.0-dev libxml2-dev libsqlite3-dev libcairo2-dev libglib2.0-dev sqlite3 libsqlite3-dev
-        install_libopenslide_from_source
-        ;;
-      precise|wheezy|maya)
-        # Debian 7, Ubuntu 12.04, Mint 13
-        echo "Installing libopenslide dependencies via apt-get"
-        apt-get install -y automake build-essential curl zlib1g-dev libopenjpeg-dev libpng12-dev libjpeg-dev libtiff5-dev libgdk-pixbuf2.0-dev libxml2-dev libsqlite3-dev libcairo2-dev libglib2.0-dev sqlite3 libsqlite3-dev
-        install_libopenslide_from_source
-        ;;
-      *)
-        # Unsupported Debian-based OS
-        sorry "openslide" "Debian-based $DISTRO"
-        ;;
-    esac
-  elif [ -f /etc/redhat-release ]; then
-    # Red Hat Linux
-    RELEASE=$(cat /etc/redhat-release)
-    echo "Detected Red Hat Linux '$RELEASE'"
-    case $RELEASE in
-      "Red Hat Enterprise Linux release 7."*|"CentOS Linux release 7."*|"Scientific Linux release 7."*)
-        # RHEL/CentOS 7
-        echo "Installing libopenslide dependencies via yum"
-        yum groupinstall -y "Development Tools"
-        yum install -y tar curl libpng-devel libjpeg-devel libxml2-devel zlib-devel openjpeg-devel libtiff-devel gdk-pixbuf2-devel sqlite-devel cairo-devel glib2-devel
-        install_libopenslide_from_source "--prefix=/usr"
-        ;;
-      "Red Hat Enterprise Linux release 6."*|"CentOS release 6."*|"Scientific Linux release 6."*)
-        # RHEL/CentOS 6
-        echo "Installing libopenslide dependencies via yum"
-        yum groupinstall -y "Development Tools"
-        yum install -y tar curl libpng-devel libjpeg-devel libxml2-devel zlib-devel openjpeg-devel libtiff-devel gdk-pixbuf2-devel sqlite-devel cairo-devel glib2-devel
-        install_libopenslide_from_source "--prefix=/usr"
-        ;;
-      "Fedora release 21 "*|"Fedora release 22 "*)
-        # Fedora 21, 22
-        echo "Installing libopenslide via yum"
-        yum install -y openslide-devel
-        ;;
-      *)
-        # Unsupported RHEL-based OS
-        sorry "openslide" "$RELEASE"
-        ;;
-    esac
-  elif [ -f /etc/os-release ]; then
-    RELEASE=$(cat /etc/os-release | grep VERSION)
-    echo "Detected OpenSuse Linux '$RELEASE'"
-    case $RELEASE in
-      *"13.2"*)
-      echo "Installing libopenslide via zypper"
-      zypper --gpg-auto-import-keys install -y libopenslide-devel
-      ;;
-    esac
-  elif [ -f /etc/SuSE-brand ]; then
-    RELEASE=$(cat /etc/SuSE-brand | grep VERSION)
-    echo "Detected OpenSuse Linux '$RELEASE'"
-    case $RELEASE in
-      *"13.1")
-      echo "Installing libopenslide dependencies via zypper"
-      zypper --gpg-auto-import-keys install -y --type pattern devel_basis
-      zypper --gpg-auto-import-keys install -y tar curl libpng16-devel libjpeg-turbo libjpeg8-devel libxml2-devel zlib-devel openjpeg-devel libtiff-devel libgdk_pixbuf-2_0-0 sqlite3-devel cairo-devel glib2-devel
-      install_libopenslide_from_source
-      ;;
-    esac
-  else
-    # Unsupported OS
-    sorry "openslide" "$(uname -a)"
-  fi
-fi
-
-# OS-specific installations of libvips follows
-
-if [ -f /etc/debian_version ]; then
-  # Debian Linux
-  DISTRO=$(lsb_release -c -s)
-  echo "Detected Debian Linux '$DISTRO'"
-  case "$DISTRO" in
-    jessie|trusty|utopic|vivid|wily|xenial|qiana|rebecca|rafaela|freya|rosa|sarah|serena)
-      # Debian 8, Ubuntu 14.04+, Mint 17+
-      echo "Installing libvips dependencies via apt-get"
-      apt-get install -y automake build-essential gobject-introspection gtk-doc-tools libglib2.0-dev libjpeg-dev libpng12-dev libwebp-dev libtiff5-dev libexif-dev libgsf-1-dev liblcms2-dev libxml2-dev swig libmagickcore-dev curl
-      install_libvips_from_source
-      ;;
-    precise|wheezy|maya)
-      # Debian 7, Ubuntu 12.04, Mint 13
-      echo "Installing libvips dependencies via apt-get"
-      add-apt-repository -y ppa:lyrasis/precise-backports
-      apt-get update
-      apt-get install -y automake build-essential gobject-introspection gtk-doc-tools libglib2.0-dev libjpeg-dev libpng12-dev libwebp-dev libtiff4-dev libexif-dev libgsf-1-dev liblcms2-dev libxml2-dev swig libmagickcore-dev curl
-      install_libvips_from_source
-      ;;
-    *)
-      # Unsupported Debian-based OS
-      sorry "vips" "Debian-based $DISTRO"
-      ;;
-  esac
-elif [ -f /etc/redhat-release ]; then
-  # Red Hat Linux
-  RELEASE=$(cat /etc/redhat-release)
-  echo "Detected Red Hat Linux '$RELEASE'"
-  case $RELEASE in
-    "Red Hat Enterprise Linux release 7."*|"CentOS Linux release 7."*|"Scientific Linux release 7."*)
-      # RHEL/CentOS 7
-      echo "Installing libvips dependencies via yum"
-      yum groupinstall -y "Development Tools"
-      yum install -y tar curl gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel libgsf-devel lcms2-devel ImageMagick-devel gobject-introspection-devel libwebp-devel
-      install_libvips_from_source "--prefix=/usr"
-      ;;
-    "Red Hat Enterprise Linux release 6."*|"CentOS release 6."*|"Scientific Linux release 6."*)
-      # RHEL/CentOS 6
-      echo "Installing libvips dependencies via yum"
-      yum groupinstall -y "Development Tools"
-      yum install -y tar curl gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel libgsf-devel lcms-devel ImageMagick-devel
-      yum install -y http://li.nux.ro/download/nux/dextop/el6/x86_64/nux-dextop-release-0-2.el6.nux.noarch.rpm
-      yum install -y --enablerepo=nux-dextop gobject-introspection-devel
-      yum install -y http://rpms.famillecollet.com/enterprise/remi-release-6.rpm
-      yum install -y --enablerepo=remi libwebp-devel
-      install_libvips_from_source "--prefix=/usr"
-      ;;
-    "Fedora"*)
-      # Fedora 21, 22, 23
-      echo "Installing libvips dependencies via yum"
-      yum groupinstall -y "Development Tools"
-      yum install -y gcc-c++ gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel lcms-devel ImageMagick-devel gobject-introspection-devel libwebp-devel curl
-      install_libvips_from_source "--prefix=/usr"
-      ;;
-    *)
-      # Unsupported RHEL-based OS
-      sorry "vips" "$RELEASE"
-      ;;
-  esac
-elif [ -f /etc/system-release ]; then
-  # Probably Amazon Linux
-  RELEASE=$(cat /etc/system-release)
-  case $RELEASE in
-    "Amazon Linux AMI release 2015.03"|"Amazon Linux AMI release 2015.09")
-      # Amazon Linux
-      echo "Detected '$RELEASE'"
-      echo "Installing libvips dependencies via yum"
-      yum groupinstall -y "Development Tools"
-      yum install -y gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel libgsf-devel lcms2-devel ImageMagick-devel gobject-introspection-devel libwebp-devel curl
-      install_libvips_from_source "--prefix=/usr"
-      ;;
-    *)
-      # Unsupported Amazon Linux version
-      sorry "vips" "$RELEASE"
-      ;;
-  esac
-elif [ -f /etc/os-release ]; then
-  RELEASE=$(cat /etc/os-release | grep VERSION)
-  echo "Detected OpenSuse Linux '$RELEASE'"
-  case $RELEASE in
-    *"13.2"*)
-    echo "Installing libvips dependencies via zypper"
-    zypper --gpg-auto-import-keys install -y --type pattern devel_basis
-    zypper --gpg-auto-import-keys install -y tar curl gtk-doc libxml2-devel libjpeg-turbo libjpeg8-devel libpng16-devel libtiff-devel libexif-devel liblcms2-devel ImageMagick-devel gobject-introspection-devel libwebp-devel
-    install_libvips_from_source
-    ;;
-  esac
-elif [ -f /etc/SuSE-brand ]; then
-  RELEASE=$(cat /etc/SuSE-brand | grep VERSION)
-  echo "Detected OpenSuse Linux '$RELEASE'"
-  case $RELEASE in
-    *"13.1")
-    echo "Installing libvips dependencies via zypper"
-    zypper --gpg-auto-import-keys install -y --type pattern devel_basis
-    zypper --gpg-auto-import-keys install -y tar curl gtk-doc libxml2-devel libjpeg-turbo libjpeg8-devel libpng16-devel libtiff-devel libexif-devel liblcms2-devel ImageMagick-devel gobject-introspection-devel libwebp-devel
-    install_libvips_from_source
-    ;;
-  esac
-else
-  # Unsupported OS
-  sorry "vips" "$(uname -a)"
-fi

vendor/github.com/h2non/bimg/resize.go

@@ -1,16 +0,0 @@
-// +build go17
-
-package bimg
-
-import (
-	"runtime"
-)
-
-// Resize is used to transform a given image as byte buffer
-// with the passed options.
-func Resize(buf []byte, o Options) ([]byte, error) {
-	// Required in order to prevent premature garbage collection. See:
-	// https://github.com/h2non/bimg/pull/162
-	defer runtime.KeepAlive(buf)
-	return resizer(buf, o)
-}

vendor/github.com/h2non/bimg/resize_legacy.go

@@ -1,10 +0,0 @@
-// +build !go17
-
-package bimg
-
-// Resize is used to transform a given image as byte buffer
-// with the passed options.
-// Used as proxy to resizer() only in Go <= 1.6 versions
-func Resize(buf []byte, o Options) ([]byte, error) {
-	return resizer(buf, o)
-}

vendor/github.com/h2non/bimg/resizer.go

@@ -1,572 +0,0 @@
-package bimg
-
-/*
-#cgo pkg-config: vips
-#include "vips/vips.h"
-*/
-import "C"
-
-import (
-	"errors"
-	"math"
-)
-
-// resizer is used to transform a given image as byte buffer
-// with the passed options.
-func resizer(buf []byte, o Options) ([]byte, error) {
-	defer C.vips_thread_shutdown()
-
-	image, imageType, err := loadImage(buf)
-	if err != nil {
-		return nil, err
-	}
-
-	// Clone and define default options
-	o = applyDefaults(o, imageType)
-
-	if !IsTypeSupported(o.Type) {
-		return nil, errors.New("Unsupported image output type")
-	}
-
-	debug("Options: %#v", o)
-
-	// Auto rotate image based on EXIF orientation header
-	image, rotated, err := rotateAndFlipImage(image, o)
-	if err != nil {
-		return nil, err
-	}
-
-	// If JPEG image, retrieve the buffer
-	if rotated && imageType == JPEG && !o.NoAutoRotate {
-		buf, err = getImageBuffer(image)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	inWidth := int(image.Xsize)
-	inHeight := int(image.Ysize)
-
-	// Infer the required operation based on the in/out image sizes for a coherent transformation
-	normalizeOperation(&o, inWidth, inHeight)
-
-	// image calculations
-	factor := imageCalculations(&o, inWidth, inHeight)
-	shrink := calculateShrink(factor, o.Interpolator)
-	residual := calculateResidual(factor, shrink)
-
-	// Do not enlarge the output if the input width or height
-	// are already less than the required dimensions
-	if !o.Enlarge && !o.Force {
-		if inWidth < o.Width && inHeight < o.Height {
-			factor = 1.0
-			shrink = 1
-			residual = 0
-			o.Width = inWidth
-			o.Height = inHeight
-		}
-	}
-
-	// Try to use libjpeg shrink-on-load
-	if imageType == JPEG && shrink >= 2 {
-		tmpImage, factor, err := shrinkJpegImage(buf, image, factor, shrink)
-		if err != nil {
-			return nil, err
-		}
-
-		image = tmpImage
-		factor = math.Max(factor, 1.0)
-		shrink = int(math.Floor(factor))
-		residual = float64(shrink) / factor
-	}
-
-	// Zoom image, if necessary
-	image, err = zoomImage(image, o.Zoom)
-	if err != nil {
-		return nil, err
-	}
-
-	// Transform image, if necessary
-	if shouldTransformImage(o, inWidth, inHeight) {
-		image, err = transformImage(image, o, shrink, residual)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	// Apply effects, if necessary
-	if shouldApplyEffects(o) {
-		image, err = applyEffects(image, o)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	// Add watermark, if necessary
-	image, err = watermarkImageWithText(image, o.Watermark)
-	if err != nil {
-		return nil, err
-	}
-
-	// Add watermark, if necessary
-	image, err = watermarkImageWithAnotherImage(image, o.WatermarkImage)
-	if err != nil {
-		return nil, err
-	}
-
-	// Flatten image on a background, if necessary
-	image, err = imageFlatten(image, imageType, o)
-	if err != nil {
-		return nil, err
-	}
-
-	return saveImage(image, o)
-}
-
-func loadImage(buf []byte) (*C.VipsImage, ImageType, error) {
-	if len(buf) == 0 {
-		return nil, JPEG, errors.New("Image buffer is empty")
-	}
-
-	image, imageType, err := vipsRead(buf)
-	if err != nil {
-		return nil, JPEG, err
-	}
-
-	return image, imageType, nil
-}
-
-func applyDefaults(o Options, imageType ImageType) Options {
-	if o.Quality == 0 {
-		o.Quality = Quality
-	}
-	if o.Compression == 0 {
-		o.Compression = 6
-	}
-	if o.Type == 0 {
-		o.Type = imageType
-	}
-	if o.Interpretation == 0 {
-		o.Interpretation = InterpretationSRGB
-	}
-	return o
-}
-
-func saveImage(image *C.VipsImage, o Options) ([]byte, error) {
-	saveOptions := vipsSaveOptions{
-		Quality:        o.Quality,
-		Type:           o.Type,
-		Compression:    o.Compression,
-		Interlace:      o.Interlace,
-		NoProfile:      o.NoProfile,
-		Interpretation: o.Interpretation,
-		OutputICC:      o.OutputICC,
-		StripMetadata:  o.StripMetadata,
-	}
-	// Finally get the resultant buffer
-	return vipsSave(image, saveOptions)
-}
-
-func normalizeOperation(o *Options, inWidth, inHeight int) {
-	if !o.Force && !o.Crop && !o.Embed && !o.Enlarge && o.Rotate == 0 && (o.Width > 0 || o.Height > 0) {
-		o.Force = true
-	}
-}
-
-func shouldTransformImage(o Options, inWidth, inHeight int) bool {
-	return o.Force || (o.Width > 0 && o.Width != inWidth) ||
-		(o.Height > 0 && o.Height != inHeight) || o.AreaWidth > 0 || o.AreaHeight > 0 ||
-		o.Trim
-}
-
-func shouldApplyEffects(o Options) bool {
-	return o.GaussianBlur.Sigma > 0 || o.GaussianBlur.MinAmpl > 0 || o.Sharpen.Radius > 0 && o.Sharpen.Y2 > 0 || o.Sharpen.Y3 > 0
-}
-
-func transformImage(image *C.VipsImage, o Options, shrink int, residual float64) (*C.VipsImage, error) {
-	var err error
-	// Use vips_shrink with the integral reduction
-	if shrink > 1 {
-		image, residual, err = shrinkImage(image, o, residual, shrink)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	residualx, residualy := residual, residual
-	if o.Force {
-		residualx = float64(o.Width) / float64(image.Xsize)
-		residualy = float64(o.Height) / float64(image.Ysize)
-	}
-
-	if o.Force || residual != 0 {
-		if residualx < 1 && residualy < 1 {
-			image, err = vipsReduce(image, 1/residualx, 1/residualy)
-		} else {
-			image, err = vipsAffine(image, residualx, residualy, o.Interpolator)
-		}
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	if o.Force {
-		o.Crop = false
-		o.Embed = false
-	}
-
-	image, err = extractOrEmbedImage(image, o)
-	if err != nil {
-		return nil, err
-	}
-
-	debug("Transform: shrink=%v, residual=%v, interpolator=%v",
-		shrink, residual, o.Interpolator.String())
-
-	return image, nil
-}
-
-func applyEffects(image *C.VipsImage, o Options) (*C.VipsImage, error) {
-	var err error
-
-	if o.GaussianBlur.Sigma > 0 || o.GaussianBlur.MinAmpl > 0 {
-		image, err = vipsGaussianBlur(image, o.GaussianBlur)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	if o.Sharpen.Radius > 0 && o.Sharpen.Y2 > 0 || o.Sharpen.Y3 > 0 {
-		image, err = vipsSharpen(image, o.Sharpen)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	debug("Effects: gaussSigma=%v, gaussMinAmpl=%v, sharpenRadius=%v",
-		o.GaussianBlur.Sigma, o.GaussianBlur.MinAmpl, o.Sharpen.Radius)
-
-	return image, nil
-}
-
-func extractOrEmbedImage(image *C.VipsImage, o Options) (*C.VipsImage, error) {
-	var err error
-	inWidth := int(image.Xsize)
-	inHeight := int(image.Ysize)
-
-	switch {
-	case o.Gravity == GravitySmart, o.SmartCrop:
-		image, err = vipsSmartCrop(image, o.Width, o.Height)
-		break
-	case o.Crop:
-		width := int(math.Min(float64(inWidth), float64(o.Width)))
-		height := int(math.Min(float64(inHeight), float64(o.Height)))
-		left, top := calculateCrop(inWidth, inHeight, o.Width, o.Height, o.Gravity)
-		left, top = int(math.Max(float64(left), 0)), int(math.Max(float64(top), 0))
-		image, err = vipsExtract(image, left, top, width, height)
-		break
-	case o.Embed:
-		left, top := (o.Width-inWidth)/2, (o.Height-inHeight)/2
-		image, err = vipsEmbed(image, left, top, o.Width, o.Height, o.Extend, o.Background)
-		break
-	case o.Trim:
-		left, top, width, height, err := vipsTrim(image)
-		if err == nil {
-			image, err = vipsExtract(image, left, top, width, height)
-		}
-		break
-	case o.Top != 0 || o.Left != 0 || o.AreaWidth != 0 || o.AreaHeight != 0:
-		if o.AreaWidth == 0 {
-			o.AreaHeight = o.Width
-		}
-		if o.AreaHeight == 0 {
-			o.AreaHeight = o.Height
-		}
-		if o.AreaWidth == 0 || o.AreaHeight == 0 {
-			return nil, errors.New("Extract area width/height params are required")
-		}
-		image, err = vipsExtract(image, o.Left, o.Top, o.AreaWidth, o.AreaHeight)
-		break
-	}
-
-	return image, err
-}
-
-func rotateAndFlipImage(image *C.VipsImage, o Options) (*C.VipsImage, bool, error) {
-	var err error
-	var rotated bool
-	var direction Direction = -1
-
-	if o.NoAutoRotate == false {
-		rotation, flip := calculateRotationAndFlip(image, o.Rotate)
-		if flip {
-			o.Flip = flip
-		}
-		if rotation > 0 && o.Rotate == 0 {
-			o.Rotate = rotation
-		}
-	}
-
-	if o.Rotate > 0 {
-		rotated = true
-		image, err = vipsRotate(image, getAngle(o.Rotate))
-	}
-
-	if o.Flip {
-		direction = Horizontal
-	} else if o.Flop {
-		direction = Vertical
-	}
-
-	if direction != -1 {
-		rotated = true
-		image, err = vipsFlip(image, direction)
-	}
-
-	return image, rotated, err
-}
-
-func watermarkImageWithText(image *C.VipsImage, w Watermark) (*C.VipsImage, error) {
-	if w.Text == "" {
-		return image, nil
-	}
-
-	// Defaults
-	if w.Font == "" {
-		w.Font = WatermarkFont
-	}
-	if w.Width == 0 {
-		w.Width = int(math.Floor(float64(image.Xsize / 6)))
-	}
-	if w.DPI == 0 {
-		w.DPI = 150
-	}
-	if w.Margin == 0 {
-		w.Margin = w.Width
-	}
-	if w.Opacity == 0 {
-		w.Opacity = 0.25
-	} else if w.Opacity > 1 {
-		w.Opacity = 1
-	}
-
-	image, err := vipsWatermark(image, w)
-	if err != nil {
-		return nil, err
-	}
-
-	return image, nil
-}
-
-func watermarkImageWithAnotherImage(image *C.VipsImage, w WatermarkImage) (*C.VipsImage, error) {
-
-	if len(w.Buf) == 0 {
-		return image, nil
-	}
-
-	if w.Opacity == 0.0 {
-		w.Opacity = 1.0
-	}
-
-	image, err := vipsDrawWatermark(image, w)
-
-	if err != nil {
-		return nil, err
-	}
-
-	return image, nil
-}
-
-func imageFlatten(image *C.VipsImage, imageType ImageType, o Options) (*C.VipsImage, error) {
-	// Only PNG images are supported for now
-	if imageType != PNG || o.Background == ColorBlack {
-		return image, nil
-	}
-	return vipsFlattenBackground(image, o.Background)
-}
-
-func zoomImage(image *C.VipsImage, zoom int) (*C.VipsImage, error) {
-	if zoom == 0 {
-		return image, nil
-	}
-	return vipsZoom(image, zoom+1)
-}
-
-func shrinkImage(image *C.VipsImage, o Options, residual float64, shrink int) (*C.VipsImage, float64, error) {
-	// Use vips_shrink with the integral reduction
-	image, err := vipsShrink(image, shrink)
-	if err != nil {
-		return nil, 0, err
-	}
-
-	// Recalculate residual float based on dimensions of required vs shrunk images
-	residualx := float64(o.Width) / float64(image.Xsize)
-	residualy := float64(o.Height) / float64(image.Ysize)
-
-	if o.Crop {
-		residual = math.Max(residualx, residualy)
-	} else {
-		residual = math.Min(residualx, residualy)
-	}
-
-	return image, residual, nil
-}
-
-func shrinkJpegImage(buf []byte, input *C.VipsImage, factor float64, shrink int) (*C.VipsImage, float64, error) {
-	var image *C.VipsImage
-	var err error
-	shrinkOnLoad := 1
-
-	// Recalculate integral shrink and double residual
-	switch {
-	case shrink >= 8:
-		factor = factor / 8
-		shrinkOnLoad = 8
-	case shrink >= 4:
-		factor = factor / 4
-		shrinkOnLoad = 4
-	case shrink >= 2:
-		factor = factor / 2
-		shrinkOnLoad = 2
-	}
-
-	// Reload input using shrink-on-load
-	if shrinkOnLoad > 1 {
-		image, err = vipsShrinkJpeg(buf, input, shrinkOnLoad)
-	}
-
-	return image, factor, err
-}
-
-func imageCalculations(o *Options, inWidth, inHeight int) float64 {
-	factor := 1.0
-	xfactor := float64(inWidth) / float64(o.Width)
-	yfactor := float64(inHeight) / float64(o.Height)
-
-	switch {
-	// Fixed width and height
-	case o.Width > 0 && o.Height > 0:
-		if o.Crop {
-			factor = math.Min(xfactor, yfactor)
-		} else {
-			factor = math.Max(xfactor, yfactor)
-		}
-	// Fixed width, auto height
-	case o.Width > 0:
-		if o.Crop {
-			o.Height = inHeight
-		} else {
-			factor = xfactor
-			o.Height = roundFloat(float64(inHeight) / factor)
-		}
-	// Fixed height, auto width
-	case o.Height > 0:
-		if o.Crop {
-			o.Width = inWidth
-		} else {
-			factor = yfactor
-			o.Width = roundFloat(float64(inWidth) / factor)
-		}
-	// Identity transform
-	default:
-		o.Width = inWidth
-		o.Height = inHeight
-		break
-	}
-
-	return factor
-}
-
-func roundFloat(f float64) int {
-	if f < 0 {
-		return int(math.Ceil(f - 0.5))
-	}
-	return int(math.Floor(f + 0.5))
-}
-
-func calculateCrop(inWidth, inHeight, outWidth, outHeight int, gravity Gravity) (int, int) {
-	left, top := 0, 0
-
-	switch gravity {
-	case GravityNorth:
-		left = (inWidth - outWidth + 1) / 2
-	case GravityEast:
-		left = inWidth - outWidth
-		top = (inHeight - outHeight + 1) / 2
-	case GravitySouth:
-		left = (inWidth - outWidth + 1) / 2
-		top = inHeight - outHeight
-	case GravityWest:
-		top = (inHeight - outHeight + 1) / 2
-	default:
-		left = (inWidth - outWidth + 1) / 2
-		top = (inHeight - outHeight + 1) / 2
-	}
-
-	return left, top
-}
-
-func calculateRotationAndFlip(image *C.VipsImage, angle Angle) (Angle, bool) {
-	rotate := D0
-	flip := false
-
-	if angle > 0 {
-		return rotate, flip
-	}
-
-	switch vipsExifOrientation(image) {
-	case 6:
-		rotate = D90
-		break
-	case 3:
-		rotate = D180
-		break
-	case 8:
-		rotate = D270
-		break
-	case 2:
-		flip = true
-		break // flip 1
-	case 7:
-		flip = true
-		rotate = D270
-		break // flip 6
-	case 4:
-		flip = true
-		rotate = D180
-		break // flip 3
-	case 5:
-		flip = true
-		rotate = D90
-		break // flip 8
-	}
-
-	return rotate, flip
-}
-
-func calculateShrink(factor float64, i Interpolator) int {
-	var shrink float64
-
-	// Calculate integral box shrink
-	windowSize := vipsWindowSize(i.String())
-	if factor >= 2 && windowSize > 3 {
-		// Shrink less, affine more with interpolators that use at least 4x4 pixel window, e.g. bicubic
-		shrink = float64(math.Floor(factor * 3.0 / windowSize))
-	} else {
-		shrink = math.Floor(factor)
-	}
-
-	return int(math.Max(shrink, 1))
-}
-
-func calculateResidual(factor float64, shrink int) float64 {
-	return float64(shrink) / factor
-}
-
-func getAngle(angle Angle) Angle {
-	divisor := angle % 90
-	if divisor != 0 {
-		angle = angle - divisor
-	}
-	return Angle(math.Min(float64(angle), 270))
-}

vendor/github.com/h2non/bimg/resizer_test.go

@@ -1,704 +0,0 @@
-package bimg
-
-import (
-	"bytes"
-	"crypto/md5"
-	"fmt"
-	"image"
-	"image/jpeg"
-	"io/ioutil"
-	"os"
-	"path"
-	"strconv"
-	"testing"
-)
-
-func TestResize(t *testing.T) {
-	options := Options{Width: 800, Height: 600}
-	buf, _ := Read("fixtures/test.jpg")
-
-	newImg, err := Resize(buf, options)
-	if err != nil {
-		t.Errorf("Resize(imgData, %#v) error: %#v", options, err)
-	}
-
-	if DetermineImageType(newImg) != JPEG {
-		t.Fatal("Image is not jpeg")
-	}
-
-	size, _ := Size(newImg)
-	if size.Height != options.Height || size.Width != options.Width {
-		t.Fatalf("Invalid image size: %dx%d", size.Width, size.Height)
-	}
-
-	Write("fixtures/test_out.jpg", newImg)
-}
-
-func TestResizeVerticalImage(t *testing.T) {
-	tests := []struct {
-		format  ImageType
-		options Options
-	}{
-		{JPEG, Options{Width: 800, Height: 600}},
-		{JPEG, Options{Width: 1000, Height: 1000}},
-		{JPEG, Options{Width: 1000, Height: 1500}},
-		{JPEG, Options{Width: 1000}},
-		{JPEG, Options{Height: 1500}},
-		{JPEG, Options{Width: 100, Height: 50}},
-		{JPEG, Options{Width: 2000, Height: 2000}},
-		{JPEG, Options{Width: 500, Height: 1000}},
-		{JPEG, Options{Width: 500}},
-		{JPEG, Options{Height: 500}},
-		{JPEG, Options{Crop: true, Width: 500, Height: 1000}},
-		{JPEG, Options{Crop: true, Enlarge: true, Width: 2000, Height: 1400}},
-		{JPEG, Options{Enlarge: true, Force: true, Width: 2000, Height: 2000}},
-		{JPEG, Options{Force: true, Width: 2000, Height: 2000}},
-	}
-
-	buf, _ := Read("fixtures/vertical.jpg")
-	for _, test := range tests {
-		image, err := Resize(buf, test.options)
-		if err != nil {
-			t.Errorf("Resize(imgData, %#v) error: %#v", test.options, err)
-		}
-
-		if DetermineImageType(image) != test.format {
-			t.Fatalf("Image format is invalid. Expected: %#v", test.format)
-		}
-
-		size, _ := Size(image)
-		if test.options.Height > 0 && size.Height != test.options.Height {
-			t.Fatalf("Invalid height: %d", size.Height)
-		}
-		if test.options.Width > 0 && size.Width != test.options.Width {
-			t.Fatalf("Invalid width: %d", size.Width)
-		}
-
-		Write("fixtures/test_vertical_"+strconv.Itoa(test.options.Width)+"x"+strconv.Itoa(test.options.Height)+"_out.jpg", image)
-	}
-}
-
-func TestResizeCustomSizes(t *testing.T) {
-	tests := []struct {
-		format  ImageType
-		options Options
-	}{
-		{JPEG, Options{Width: 800, Height: 600}},
-		{JPEG, Options{Width: 1000, Height: 1000}},
-		{JPEG, Options{Width: 100, Height: 50}},
-		{JPEG, Options{Width: 2000, Height: 2000}},
-		{JPEG, Options{Width: 500, Height: 1000}},
-		{JPEG, Options{Width: 500}},
-		{JPEG, Options{Height: 500}},
-		{JPEG, Options{Crop: true, Width: 500, Height: 1000}},
-		{JPEG, Options{Crop: true, Enlarge: true, Width: 2000, Height: 1400}},
-		{JPEG, Options{Enlarge: true, Force: true, Width: 2000, Height: 2000}},
-		{JPEG, Options{Force: true, Width: 2000, Height: 2000}},
-	}
-
-	buf, _ := Read("fixtures/test.jpg")
-	for _, test := range tests {
-		image, err := Resize(buf, test.options)
-		if err != nil {
-			t.Errorf("Resize(imgData, %#v) error: %#v", test.options, err)
-		}
-
-		if DetermineImageType(image) != test.format {
-			t.Fatalf("Image format is invalid. Expected: %#v", test.format)
-		}
-
-		size, _ := Size(image)
-		if test.options.Height > 0 && size.Height != test.options.Height {
-			t.Fatalf("Invalid height: %d", size.Height)
-		}
-		if test.options.Width > 0 && size.Width != test.options.Width {
-			t.Fatalf("Invalid width: %d", size.Width)
-		}
-	}
-}
-
-func TestResizePrecision(t *testing.T) {
-	// see https://github.com/h2non/bimg/issues/99
-	img := image.NewGray16(image.Rect(0, 0, 1920, 1080))
-	input := &bytes.Buffer{}
-	jpeg.Encode(input, img, nil)
-
-	opts := Options{Width: 300}
-	newImg, err := Resize(input.Bytes(), opts)
-	if err != nil {
-		t.Fatalf("Resize(imgData, %#v) error: %#v", opts, err)
-	}
-
-	size, _ := Size(newImg)
-	if size.Width != opts.Width {
-		t.Fatalf("Invalid width: %d", size.Width)
-	}
-}
-
-func TestRotate(t *testing.T) {
-	options := Options{Width: 800, Height: 600, Rotate: 270, Crop: true}
-	buf, _ := Read("fixtures/test.jpg")
-
-	newImg, err := Resize(buf, options)
-	if err != nil {
-		t.Errorf("Resize(imgData, %#v) error: %#v", options, err)
-	}
-
-	if DetermineImageType(newImg) != JPEG {
-		t.Error("Image is not jpeg")
-	}
-
-	size, _ := Size(newImg)
-	if size.Width != options.Width || size.Height != options.Height {
-		t.Errorf("Invalid image size: %dx%d", size.Width, size.Height)
-	}
-
-	Write("fixtures/test_rotate_out.jpg", newImg)
-}
-
-func TestInvalidRotateDegrees(t *testing.T) {
-	options := Options{Width: 800, Height: 600, Rotate: 111, Crop: true}
-	buf, _ := Read("fixtures/test.jpg")
-
-	newImg, err := Resize(buf, options)
-	if err != nil {
-		t.Errorf("Resize(imgData, %#v) error: %#v", options, err)
-	}
-
-	if DetermineImageType(newImg) != JPEG {
-		t.Errorf("Image is not jpeg")
-	}
-
-	size, _ := Size(newImg)
-	if size.Width != options.Width || size.Height != options.Height {
-		t.Errorf("Invalid image size: %dx%d", size.Width, size.Height)
-	}
-
-	Write("fixtures/test_rotate_invalid_out.jpg", newImg)
-}
-
-func TestCorruptedImage(t *testing.T) {
-	options := Options{Width: 800, Height: 600}
-	buf, _ := Read("fixtures/corrupt.jpg")
-
-	newImg, err := Resize(buf, options)
-	if err != nil {
-		t.Errorf("Resize(imgData, %#v) error: %#v", options, err)
-	}
-
-	if DetermineImageType(newImg) != JPEG {
-		t.Fatal("Image is not jpeg")
-	}
-
-	size, _ := Size(newImg)
-	if size.Height != options.Height || size.Width != options.Width {
-		t.Fatalf("Invalid image size: %dx%d", size.Width, size.Height)
-	}
-
-	Write("fixtures/test_corrupt_out.jpg", newImg)
-}
-
-func TestNoColorProfile(t *testing.T) {
-	options := Options{Width: 800, Height: 600, NoProfile: true}
-	buf, _ := Read("fixtures/test.jpg")
-
-	newImg, err := Resize(buf, options)
-	if err != nil {
-		t.Errorf("Resize(imgData, %#v) error: %#v", options, err)
-	}
-
-	metadata, err := Metadata(newImg)
-	if metadata.Profile == true {
-		t.Fatal("Invalid profile data")
-	}
-
-	size, _ := Size(newImg)
-	if size.Height != options.Height || size.Width != options.Width {
-		t.Fatalf("Invalid image size: %dx%d", size.Width, size.Height)
-	}
-}
-
-func TestEmbedExtendColor(t *testing.T) {
-	options := Options{Width: 400, Height: 600, Crop: false, Embed: true, Extend: ExtendWhite, Background: Color{255, 20, 10}}
-	buf, _ := Read("fixtures/test_issue.jpg")
-
-	newImg, err := Resize(buf, options)
-	if err != nil {
-		t.Errorf("Resize(imgData, %#v) error: %#v", options, err)
-	}
-
-	size, _ := Size(newImg)
-	if size.Height != options.Height || size.Width != options.Width {
-		t.Fatalf("Invalid image size: %dx%d", size.Width, size.Height)
-	}
-
-	Write("fixtures/test_extend_white_out.jpg", newImg)
-}
-
-func TestEmbedExtendWithCustomColor(t *testing.T) {
-	options := Options{Width: 400, Height: 600, Crop: false, Embed: true, Extend: 5, Background: Color{255, 20, 10}}
-	buf, _ := Read("fixtures/test_issue.jpg")
-
-	newImg, err := Resize(buf, options)
-	if err != nil {
-		t.Errorf("Resize(imgData, %#v) error: %#v", options, err)
-	}
-
-	size, _ := Size(newImg)
-	if size.Height != options.Height || size.Width != options.Width {
-		t.Fatalf("Invalid image size: %dx%d", size.Width, size.Height)
-	}
-
-	Write("fixtures/test_extend_background_out.jpg", newImg)
-}
-
-func TestGaussianBlur(t *testing.T) {
-	options := Options{Width: 800, Height: 600, GaussianBlur: GaussianBlur{Sigma: 5}}
-	buf, _ := Read("fixtures/test.jpg")
-
-	newImg, err := Resize(buf, options)
-	if err != nil {
-		t.Errorf("Resize(imgData, %#v) error: %#v", options, err)
-	}
-
-	size, _ := Size(newImg)
-	if size.Height != options.Height || size.Width != options.Width {
-		t.Fatalf("Invalid image size: %dx%d", size.Width, size.Height)
-	}
-
-	Write("fixtures/test_gaussian_out.jpg", newImg)
-}
-
-func TestSharpen(t *testing.T) {
-	options := Options{Width: 800, Height: 600, Sharpen: Sharpen{Radius: 1, X1: 1.5, Y2: 20, Y3: 50, M1: 1, M2: 2}}
-	buf, _ := Read("fixtures/test.jpg")
-
-	newImg, err := Resize(buf, options)
-	if err != nil {
-		t.Errorf("Resize(imgData, %#v) error: %#v", options, err)
-	}
-
-	size, _ := Size(newImg)
-	if size.Height != options.Height || size.Width != options.Width {
-		t.Fatalf("Invalid image size: %dx%d", size.Width, size.Height)
-	}
-
-	Write("fixtures/test_sharpen_out.jpg", newImg)
-}
-
-func TestExtractWithDefaultAxis(t *testing.T) {
-	options := Options{AreaWidth: 200, AreaHeight: 200}
-	buf, _ := Read("fixtures/test.jpg")
-
-	newImg, err := Resize(buf, options)
-	if err != nil {
-		t.Errorf("Resize(imgData, %#v) error: %#v", options, err)
-	}
-
-	size, _ := Size(newImg)
-	if size.Height != options.AreaHeight || size.Width != options.AreaWidth {
-		t.Fatalf("Invalid image size: %dx%d", size.Width, size.Height)
-	}
-
-	Write("fixtures/test_extract_defaults_out.jpg", newImg)
-}
-
-func TestExtractCustomAxis(t *testing.T) {
-	options := Options{Top: 100, Left: 100, AreaWidth: 200, AreaHeight: 200}
-	buf, _ := Read("fixtures/test.jpg")
-
-	newImg, err := Resize(buf, options)
-	if err != nil {
-		t.Errorf("Resize(imgData, %#v) error: %#v", options, err)
-	}
-
-	size, _ := Size(newImg)
-	if size.Height != options.AreaHeight || size.Width != options.AreaWidth {
-		t.Fatalf("Invalid image size: %dx%d", size.Width, size.Height)
-	}
-
-	Write("fixtures/test_extract_custom_axis_out.jpg", newImg)
-}
-
-func TestConvert(t *testing.T) {
-	width, height := 300, 240
-	formats := [3]ImageType{PNG, WEBP, JPEG}
-
-	files := []string{
-		"test.jpg",
-		"test.png",
-		"test.webp",
-	}
-
-	for _, file := range files {
-		img, err := os.Open("fixtures/" + file)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		buf, err := ioutil.ReadAll(img)
-		if err != nil {
-			t.Fatal(err)
-		}
-		img.Close()
-
-		for _, format := range formats {
-			options := Options{Width: width, Height: height, Crop: true, Type: format}
-
-			newImg, err := Resize(buf, options)
-			if err != nil {
-				t.Errorf("Resize(imgData, %#v) error: %#v", options, err)
-			}
-
-			if DetermineImageType(newImg) != format {
-				t.Fatal("Image is not png")
-			}
-
-			size, _ := Size(newImg)
-			if size.Height != height || size.Width != width {
-				t.Fatalf("Invalid image size: %dx%d", size.Width, size.Height)
-			}
-		}
-	}
-}
-
-func TestResizePngWithTransparency(t *testing.T) {
-	width, height := 300, 240
-
-	options := Options{Width: width, Height: height, Crop: true}
-	img, err := os.Open("fixtures/transparent.png")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer img.Close()
-
-	buf, err := ioutil.ReadAll(img)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	newImg, err := Resize(buf, options)
-	if err != nil {
-		t.Errorf("Resize(imgData, %#v) error: %#v", options, err)
-	}
-
-	if DetermineImageType(newImg) != PNG {
-		t.Fatal("Image is not png")
-	}
-
-	size, _ := Size(newImg)
-	if size.Height != height || size.Width != width {
-		t.Fatal("Invalid image size")
-	}
-
-	Write("fixtures/transparent_out.png", newImg)
-}
-
-func TestRotationAndFlip(t *testing.T) {
-	files := []struct {
-		Name  string
-		Angle Angle
-		Flip  bool
-	}{
-		{"Landscape_1", 0, false},
-		{"Landscape_2", 0, true},
-		{"Landscape_3", D180, false},
-		{"Landscape_4", D180, true},
-		{"Landscape_5", D90, true},
-		{"Landscape_6", D90, false},
-		{"Landscape_7", D270, true},
-		{"Landscape_8", D270, false},
-		{"Portrait_1", 0, false},
-		{"Portrait_2", 0, true},
-		{"Portrait_3", D180, false},
-		{"Portrait_4", D180, true},
-		{"Portrait_5", D90, true},
-		{"Portrait_6", D90, false},
-		{"Portrait_7", D270, true},
-		{"Portrait_8", D270, false},
-	}
-
-	for _, file := range files {
-		img, err := os.Open(fmt.Sprintf("fixtures/exif/%s.jpg", file.Name))
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		buf, err := ioutil.ReadAll(img)
-		if err != nil {
-			t.Fatal(err)
-		}
-		img.Close()
-
-		image, _, err := loadImage(buf)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		angle, flip := calculateRotationAndFlip(image, D0)
-		if angle != file.Angle {
-			t.Errorf("Rotation for %v expected to be %v. got %v", file.Name, file.Angle, angle)
-		}
-		if flip != file.Flip {
-			t.Errorf("Flip for %v expected to be %v. got %v", file.Name, file.Flip, flip)
-		}
-
-		// Visual debugging.
-		newImg, err := Resize(buf, Options{})
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		Write(fmt.Sprintf("fixtures/exif/%s_out.jpg", file.Name), newImg)
-	}
-}
-
-func TestIfBothSmartCropOptionsAreIdentical(t *testing.T) {
-	if !(VipsMajorVersion >= 8 && VipsMinorVersion > 4) {
-		t.Skipf("Skipping this test, libvips doesn't meet version requirement %s > 8.4", VipsVersion)
-	}
-
-	benchmarkOptions := Options{Width: 100, Height: 100, Crop: true}
-	smartCropOptions := Options{Width: 100, Height: 100, Crop: true, SmartCrop: true}
-	gravityOptions := Options{Width: 100, Height: 100, Crop: true, Gravity: GravitySmart}
-
-	testImg, err := os.Open("fixtures/northern_cardinal_bird.jpg")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer testImg.Close()
-
-	testImgByte, err := ioutil.ReadAll(testImg)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	scImg, err := Resize(testImgByte, smartCropOptions)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	gImg, err := Resize(testImgByte, gravityOptions)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	benchmarkImg, err := Resize(testImgByte, benchmarkOptions)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	sch, gh, bh := md5.Sum(scImg), md5.Sum(gImg), md5.Sum(benchmarkImg)
-	if gh == bh || sch == bh {
-		t.Error("Expected both options produce a different result from a standard crop.")
-	}
-
-	if sch != gh {
-		t.Errorf("Expected both options to result in the same output, %x != %x", sch, gh)
-	}
-}
-
-func runBenchmarkResize(file string, o Options, b *testing.B) {
-	buf, _ := Read(path.Join("fixtures", file))
-
-	for n := 0; n < b.N; n++ {
-		Resize(buf, o)
-	}
-}
-
-func BenchmarkRotateJpeg(b *testing.B) {
-	options := Options{Rotate: 180}
-	runBenchmarkResize("test.jpg", options, b)
-}
-
-func BenchmarkResizeLargeJpeg(b *testing.B) {
-	options := Options{
-		Width:  800,
-		Height: 600,
-	}
-	runBenchmarkResize("test.jpg", options, b)
-}
-
-func BenchmarkResizePng(b *testing.B) {
-	options := Options{
-		Width:  200,
-		Height: 200,
-	}
-	runBenchmarkResize("test.png", options, b)
-}
-
-func BenchmarkResizeWebP(b *testing.B) {
-	options := Options{
-		Width:  200,
-		Height: 200,
-	}
-	runBenchmarkResize("test.webp", options, b)
-}
-
-func BenchmarkConvertToJpeg(b *testing.B) {
-	options := Options{Type: JPEG}
-	runBenchmarkResize("test.png", options, b)
-}
-
-func BenchmarkConvertToPng(b *testing.B) {
-	options := Options{Type: PNG}
-	runBenchmarkResize("test.jpg", options, b)
-}
-
-func BenchmarkConvertToWebp(b *testing.B) {
-	options := Options{Type: WEBP}
-	runBenchmarkResize("test.jpg", options, b)
-}
-
-func BenchmarkCropJpeg(b *testing.B) {
-	options := Options{
-		Width:  800,
-		Height: 600,
-	}
-	runBenchmarkResize("test.jpg", options, b)
-}
-
-func BenchmarkCropPng(b *testing.B) {
-	options := Options{
-		Width:  800,
-		Height: 600,
-	}
-	runBenchmarkResize("test.png", options, b)
-}
-
-func BenchmarkCropWebP(b *testing.B) {
-	options := Options{
-		Width:  800,
-		Height: 600,
-	}
-	runBenchmarkResize("test.webp", options, b)
-}
-
-func BenchmarkExtractJpeg(b *testing.B) {
-	options := Options{
-		Top:        100,
-		Left:       50,
-		AreaWidth:  600,
-		AreaHeight: 480,
-	}
-	runBenchmarkResize("test.jpg", options, b)
-}
-
-func BenchmarkExtractPng(b *testing.B) {
-	options := Options{
-		Top:        100,
-		Left:       50,
-		AreaWidth:  600,
-		AreaHeight: 480,
-	}
-	runBenchmarkResize("test.png", options, b)
-}
-
-func BenchmarkExtractWebp(b *testing.B) {
-	options := Options{
-		Top:        100,
-		Left:       50,
-		AreaWidth:  600,
-		AreaHeight: 480,
-	}
-	runBenchmarkResize("test.webp", options, b)
-}
-
-func BenchmarkZoomJpeg(b *testing.B) {
-	options := Options{Zoom: 1}
-	runBenchmarkResize("test.jpg", options, b)
-}
-
-func BenchmarkZoomPng(b *testing.B) {
-	options := Options{Zoom: 1}
-	runBenchmarkResize("test.png", options, b)
-}
-
-func BenchmarkZoomWebp(b *testing.B) {
-	options := Options{Zoom: 1}
-	runBenchmarkResize("test.webp", options, b)
-}
-
-func BenchmarkWatermarkJpeg(b *testing.B) {
-	options := Options{
-		Watermark: Watermark{
-			Text:       "Chuck Norris (c) 2315",
-			Opacity:    0.25,
-			Width:      200,
-			DPI:        100,
-			Margin:     150,
-			Font:       "sans bold 12",
-			Background: Color{255, 255, 255},
-		},
-	}
-	runBenchmarkResize("test.jpg", options, b)
-}
-
-func BenchmarkWatermarPng(b *testing.B) {
-	options := Options{
-		Watermark: Watermark{
-			Text:       "Chuck Norris (c) 2315",
-			Opacity:    0.25,
-			Width:      200,
-			DPI:        100,
-			Margin:     150,
-			Font:       "sans bold 12",
-			Background: Color{255, 255, 255},
-		},
-	}
-	runBenchmarkResize("test.png", options, b)
-}
-
-func BenchmarkWatermarWebp(b *testing.B) {
-	options := Options{
-		Watermark: Watermark{
-			Text:       "Chuck Norris (c) 2315",
-			Opacity:    0.25,
-			Width:      200,
-			DPI:        100,
-			Margin:     150,
-			Font:       "sans bold 12",
-			Background: Color{255, 255, 255},
-		},
-	}
-	runBenchmarkResize("test.webp", options, b)
-}
-
-func BenchmarkWatermarkImageJpeg(b *testing.B) {
-	watermark := readFile("transparent.png")
-	options := Options{
-		WatermarkImage: WatermarkImage{
-			Buf:     watermark,
-			Opacity: 0.25,
-			Left:    100,
-			Top:     100,
-		},
-	}
-	runBenchmarkResize("test.jpg", options, b)
-}
-
-func BenchmarkWatermarImagePng(b *testing.B) {
-	watermark := readFile("transparent.png")
-	options := Options{
-		WatermarkImage: WatermarkImage{
-			Buf:     watermark,
-			Opacity: 0.25,
-			Left:    100,
-			Top:     100,
-		},
-	}
-	runBenchmarkResize("test.png", options, b)
-}
-
-func BenchmarkWatermarImageWebp(b *testing.B) {
-	watermark := readFile("transparent.png")
-	options := Options{
-		WatermarkImage: WatermarkImage{
-			Buf:     watermark,
-			Opacity: 0.25,
-			Left:    100,
-			Top:     100,
-		},
-	}
-	runBenchmarkResize("test.webp", options, b)
-}

vendor/github.com/h2non/bimg/type.go

@@ -1,172 +0,0 @@
-package bimg
-
-import (
-	"regexp"
-	"sync"
-	"unicode/utf8"
-)
-
-const (
-	// UNKNOWN represents an unknow image type value.
-	UNKNOWN ImageType = iota
-	// JPEG represents the JPEG image type.
-	JPEG
-	// WEBP represents the WEBP image type.
-	WEBP
-	// PNG represents the PNG image type.
-	PNG
-	// TIFF represents the TIFF image type.
-	TIFF
-	// GIF represents the GIF image type.
-	GIF
-	// PDF represents the PDF type.
-	PDF
-	// SVG represents the SVG image type.
-	SVG
-	// MAGICK represents the libmagick compatible genetic image type.
-	MAGICK
-)
-
-// ImageType represents an image type value.
-type ImageType int
-
-var (
-	htmlCommentRegex = regexp.MustCompile("(?i)<!--([\\s\\S]*?)-->")
-	svgRegex         = regexp.MustCompile(`(?i)^\s*(?:<\?xml[^>]*>\s*)?(?:<!doctype svg[^>]*>\s*)?<svg[^>]*>[^*]*<\/svg>\s*$`)
-)
-
-// ImageTypes stores as pairs of image types supported and its alias names.
-var ImageTypes = map[ImageType]string{
-	JPEG:   "jpeg",
-	PNG:    "png",
-	WEBP:   "webp",
-	TIFF:   "tiff",
-	GIF:    "gif",
-	PDF:    "pdf",
-	SVG:    "svg",
-	MAGICK: "magick",
-}
-
-// imageMutex is used to provide thread-safe synchronization
-// for SupportedImageTypes map.
-var imageMutex = &sync.RWMutex{}
-
-// SupportedImageType represents whether a type can be loaded and/or saved by
-// the current libvips compilation.
-type SupportedImageType struct {
-	Load bool
-	Save bool
-}
-
-// SupportedImageTypes stores the optional image type supported
-// by the current libvips compilation.
-// Note: lazy evaluation as demand is required due
-// to bootstrap runtime limitation with C/libvips world.
-var SupportedImageTypes = map[ImageType]SupportedImageType{}
-
-// discoverSupportedImageTypes is used to fill SupportedImageTypes map.
-func discoverSupportedImageTypes() {
-	imageMutex.Lock()
-	for imageType := range ImageTypes {
-		SupportedImageTypes[imageType] = SupportedImageType{
-			Load: VipsIsTypeSupported(imageType),
-			Save: VipsIsTypeSupportedSave(imageType),
-		}
-	}
-	imageMutex.Unlock()
-}
-
-// isBinary checks if the given buffer is a binary file.
-func isBinary(buf []byte) bool {
-	if len(buf) < 24 {
-		return false
-	}
-	for i := 0; i < 24; i++ {
-		charCode, _ := utf8.DecodeRuneInString(string(buf[i]))
-		if charCode == 65533 || charCode <= 8 {
-			return true
-		}
-	}
-	return false
-}
-
-// IsSVGImage returns true if the given buffer is a valid SVG image.
-func IsSVGImage(buf []byte) bool {
-	return !isBinary(buf) && svgRegex.Match(htmlCommentRegex.ReplaceAll(buf, []byte{}))
-}
-
-// DetermineImageType determines the image type format (jpeg, png, webp or tiff)
-func DetermineImageType(buf []byte) ImageType {
-	return vipsImageType(buf)
-}
-
-// DetermineImageTypeName determines the image type format by name (jpeg, png, webp or tiff)
-func DetermineImageTypeName(buf []byte) string {
-	return ImageTypeName(vipsImageType(buf))
-}
-
-// IsImageTypeSupportedByVips returns true if the given image type
-// is supported by current libvips compilation.
-func IsImageTypeSupportedByVips(t ImageType) SupportedImageType {
-	imageMutex.RLock()
-
-	// Discover supported image types and cache the result
-	itShouldDiscover := len(SupportedImageTypes) == 0
-	if itShouldDiscover {
-		imageMutex.RUnlock()
-		discoverSupportedImageTypes()
-	}
-
-	// Check if image type is actually supported
-	supported, ok := SupportedImageTypes[t]
-	if !itShouldDiscover {
-		imageMutex.RUnlock()
-	}
-
-	if ok {
-		return supported
-	}
-	return SupportedImageType{Load: false, Save: false}
-}
-
-// IsTypeSupported checks if a given image type is supported
-func IsTypeSupported(t ImageType) bool {
-	_, ok := ImageTypes[t]
-	return ok && IsImageTypeSupportedByVips(t).Load
-}
-
-// IsTypeNameSupported checks if a given image type name is supported
-func IsTypeNameSupported(t string) bool {
-	for imageType, name := range ImageTypes {
-		if name == t {
-			return IsImageTypeSupportedByVips(imageType).Load
-		}
-	}
-	return false
-}
-
-// IsTypeSupportedSave checks if a given image type is support for saving
-func IsTypeSupportedSave(t ImageType) bool {
-	_, ok := ImageTypes[t]
-	return ok && IsImageTypeSupportedByVips(t).Save
-}
-
-// IsTypeNameSupportedSave checks if a given image type name is supported for
-// saving
-func IsTypeNameSupportedSave(t string) bool {
-	for imageType, name := range ImageTypes {
-		if name == t {
-			return IsImageTypeSupportedByVips(imageType).Save
-		}
-	}
-	return false
-}
-
-// ImageTypeName is used to get the human friendly name of an image format.
-func ImageTypeName(t ImageType) string {
-	imageType := ImageTypes[t]
-	if imageType == "" {
-		return "unknown"
-	}
-	return imageType
-}

vendor/github.com/h2non/bimg/type_test.go

@@ -1,130 +0,0 @@
-package bimg
-
-import (
-	"io/ioutil"
-	"os"
-	"path"
-	"testing"
-)
-
-func TestDeterminateImageType(t *testing.T) {
-	files := []struct {
-		name     string
-		expected ImageType
-	}{
-		{"test.jpg", JPEG},
-		{"test.png", PNG},
-		{"test.webp", WEBP},
-		{"test.gif", GIF},
-		{"test.pdf", PDF},
-		{"test.svg", SVG},
-		{"test.jp2", MAGICK},
-	}
-
-	for _, file := range files {
-		img, _ := os.Open(path.Join("fixtures", file.name))
-		buf, _ := ioutil.ReadAll(img)
-		defer img.Close()
-
-		if VipsIsTypeSupported(file.expected) {
-			if DetermineImageType(buf) != file.expected {
-				t.Fatalf("Image type is not valid: %s != %s", file.name, ImageTypes[file.expected])
-			}
-		}
-	}
-}
-
-func TestDeterminateImageTypeName(t *testing.T) {
-	files := []struct {
-		name     string
-		expected string
-	}{
-		{"test.jpg", "jpeg"},
-		{"test.png", "png"},
-		{"test.webp", "webp"},
-		{"test.gif", "gif"},
-		{"test.pdf", "pdf"},
-		{"test.svg", "svg"},
-		{"test.jp2", "magick"},
-	}
-
-	for _, file := range files {
-		img, _ := os.Open(path.Join("fixtures", file.name))
-		buf, _ := ioutil.ReadAll(img)
-		defer img.Close()
-
-		if DetermineImageTypeName(buf) != file.expected {
-			t.Fatalf("Image type is not valid: %s != %s", file.name, file.expected)
-		}
-	}
-}
-
-func TestIsTypeSupported(t *testing.T) {
-	types := []struct {
-		name ImageType
-	}{
-		{JPEG}, {PNG}, {WEBP}, {GIF}, {PDF},
-	}
-
-	for _, n := range types {
-		if IsTypeSupported(n.name) == false {
-			t.Fatalf("Image type %#v is not valid", ImageTypes[n.name])
-		}
-	}
-}
-
-func TestIsTypeNameSupported(t *testing.T) {
-	types := []struct {
-		name     string
-		expected bool
-	}{
-		{"jpeg", true},
-		{"png", true},
-		{"webp", true},
-		{"gif", true},
-		{"pdf", true},
-	}
-
-	for _, n := range types {
-		if IsTypeNameSupported(n.name) != n.expected {
-			t.Fatalf("Image type %#v is not valid", n.name)
-		}
-	}
-}
-
-func TestIsTypeSupportedSave(t *testing.T) {
-	types := []struct {
-		name ImageType
-	}{
-		{JPEG}, {PNG}, {WEBP},
-	}
-	if VipsVersion >= "8.5.0" {
-		types = append(types, struct{ name ImageType }{TIFF})
-	}
-
-	for _, n := range types {
-		if IsTypeSupportedSave(n.name) == false {
-			t.Fatalf("Image type %#v is not valid", ImageTypes[n.name])
-		}
-	}
-}
-
-func TestIsTypeNameSupportedSave(t *testing.T) {
-	types := []struct {
-		name     string
-		expected bool
-	}{
-		{"jpeg", true},
-		{"png", true},
-		{"webp", true},
-		{"gif", false},
-		{"pdf", false},
-		{"tiff", VipsVersion >= "8.5.0"},
-	}
-
-	for _, n := range types {
-		if IsTypeNameSupportedSave(n.name) != n.expected {
-			t.Fatalf("Image type %#v is not valid", n.name)
-		}
-	}
-}

vendor/github.com/h2non/bimg/version.go

@@ -1,4 +0,0 @@
-package bimg
-
-// Version represents the current package semantic version.
-const Version = "1.0.14"

vendor/github.com/h2non/bimg/vips.go

@@ -1,692 +0,0 @@
-package bimg
-
-/*
-#cgo pkg-config: vips
-#include "vips.h"
-*/
-import "C"
-
-import (
-	"errors"
-	"fmt"
-	"math"
-	"os"
-	"runtime"
-	"strings"
-	"sync"
-	"unsafe"
-
-	d "github.com/tj/go-debug"
-)
-
-// debug is internally used to
-var debug = d.Debug("bimg")
-
-// VipsVersion exposes the current libvips semantic version
-const VipsVersion = string(C.VIPS_VERSION)
-
-// VipsMajorVersion exposes the current libvips major version number
-const VipsMajorVersion = int(C.VIPS_MAJOR_VERSION)
-
-// VipsMinorVersion exposes the current libvips minor version number
-const VipsMinorVersion = int(C.VIPS_MINOR_VERSION)
-
-const (
-	maxCacheMem  = 100 * 1024 * 1024
-	maxCacheSize = 500
-)
-
-var (
-	m           sync.Mutex
-	initialized bool
-)
-
-// VipsMemoryInfo represents the memory stats provided by libvips.
-type VipsMemoryInfo struct {
-	Memory          int64
-	MemoryHighwater int64
-	Allocations     int64
-}
-
-// vipsSaveOptions represents the internal option used to talk with libvips.
-type vipsSaveOptions struct {
-	Quality        int
-	Compression    int
-	Type           ImageType
-	Interlace      bool
-	NoProfile      bool
-	StripMetadata  bool
-	OutputICC      string // Absolute path to the output ICC profile
-	Interpretation Interpretation
-}
-
-type vipsWatermarkOptions struct {
-	Width       C.int
-	DPI         C.int
-	Margin      C.int
-	NoReplicate C.int
-	Opacity     C.float
-	Background  [3]C.double
-}
-
-type vipsWatermarkImageOptions struct {
-	Left    C.int
-	Top     C.int
-	Opacity C.float
-}
-
-type vipsWatermarkTextOptions struct {
-	Text *C.char
-	Font *C.char
-}
-
-func init() {
-	Initialize()
-}
-
-// Initialize is used to explicitly start libvips in thread-safe way.
-// Only call this function if you have previously turned off libvips.
-func Initialize() {
-	if C.VIPS_MAJOR_VERSION <= 7 && C.VIPS_MINOR_VERSION < 40 {
-		panic("unsupported libvips version!")
-	}
-
-	m.Lock()
-	runtime.LockOSThread()
-	defer m.Unlock()
-	defer runtime.UnlockOSThread()
-
-	err := C.vips_init(C.CString("bimg"))
-	if err != 0 {
-		panic("unable to start vips!")
-	}
-
-	// Set libvips cache params
-	C.vips_cache_set_max_mem(maxCacheMem)
-	C.vips_cache_set_max(maxCacheSize)
-
-	// Define a custom thread concurrency limit in libvips (this may generate thread-unsafe issues)
-	// See: https://github.com/jcupitt/libvips/issues/261#issuecomment-92850414
-	if os.Getenv("VIPS_CONCURRENCY") == "" {
-		C.vips_concurrency_set(1)
-	}
-
-	// Enable libvips cache tracing
-	if os.Getenv("VIPS_TRACE") != "" {
-		C.vips_enable_cache_set_trace()
-	}
-
-	initialized = true
-}
-
-// Shutdown is used to shutdown libvips in a thread-safe way.
-// You can call this to drop caches as well.
-// If libvips was already initialized, the function is no-op
-func Shutdown() {
-	m.Lock()
-	defer m.Unlock()
-
-	if initialized {
-		C.vips_shutdown()
-		initialized = false
-	}
-}
-
-// VipsCacheSetMaxMem Sets the maximum amount of tracked memory allowed before the vips operation cache
-// begins to drop entries.
-func VipsCacheSetMaxMem(maxCacheMem int) {
-	C.vips_cache_set_max_mem(C.size_t(maxCacheMem))
-}
-
-// VipsCacheSetMax sets the maximum number of operations to keep in the vips operation cache.
-func VipsCacheSetMax(maxCacheSize int) {
-	C.vips_cache_set_max(C.int(maxCacheSize))
-}
-
-// VipsCacheDropAll drops the vips operation cache, freeing the allocated memory.
-func VipsCacheDropAll() {
-	C.vips_cache_drop_all()
-}
-
-// VipsDebugInfo outputs to stdout libvips collected data. Useful for debugging.
-func VipsDebugInfo() {
-	C.im__print_all()
-}
-
-// VipsMemory gets memory info stats from libvips (cache size, memory allocs...)
-func VipsMemory() VipsMemoryInfo {
-	return VipsMemoryInfo{
-		Memory:          int64(C.vips_tracked_get_mem()),
-		MemoryHighwater: int64(C.vips_tracked_get_mem_highwater()),
-		Allocations:     int64(C.vips_tracked_get_allocs()),
-	}
-}
-
-// VipsIsTypeSupported returns true if the given image type
-// is supported by the current libvips compilation.
-func VipsIsTypeSupported(t ImageType) bool {
-	if t == JPEG {
-		return int(C.vips_type_find_bridge(C.JPEG)) != 0
-	}
-	if t == WEBP {
-		return int(C.vips_type_find_bridge(C.WEBP)) != 0
-	}
-	if t == PNG {
-		return int(C.vips_type_find_bridge(C.PNG)) != 0
-	}
-	if t == GIF {
-		return int(C.vips_type_find_bridge(C.GIF)) != 0
-	}
-	if t == PDF {
-		return int(C.vips_type_find_bridge(C.PDF)) != 0
-	}
-	if t == SVG {
-		return int(C.vips_type_find_bridge(C.SVG)) != 0
-	}
-	if t == TIFF {
-		return int(C.vips_type_find_bridge(C.TIFF)) != 0
-	}
-	if t == MAGICK {
-		return int(C.vips_type_find_bridge(C.MAGICK)) != 0
-	}
-	return false
-}
-
-// VipsIsTypeSupportedSave returns true if the given image type
-// is supported by the current libvips compilation for the
-// save operation.
-func VipsIsTypeSupportedSave(t ImageType) bool {
-	if t == JPEG {
-		return int(C.vips_type_find_save_bridge(C.JPEG)) != 0
-	}
-	if t == WEBP {
-		return int(C.vips_type_find_save_bridge(C.WEBP)) != 0
-	}
-	if t == PNG {
-		return int(C.vips_type_find_save_bridge(C.PNG)) != 0
-	}
-	if t == TIFF {
-		return int(C.vips_type_find_save_bridge(C.TIFF)) != 0
-	}
-	return false
-}
-
-func vipsExifOrientation(image *C.VipsImage) int {
-	return int(C.vips_exif_orientation(image))
-}
-
-func vipsHasAlpha(image *C.VipsImage) bool {
-	return int(C.has_alpha_channel(image)) > 0
-}
-
-func vipsHasProfile(image *C.VipsImage) bool {
-	return int(C.has_profile_embed(image)) > 0
-}
-
-func vipsWindowSize(name string) float64 {
-	cname := C.CString(name)
-	defer C.free(unsafe.Pointer(cname))
-	return float64(C.interpolator_window_size(cname))
-}
-
-func vipsSpace(image *C.VipsImage) string {
-	return C.GoString(C.vips_enum_nick_bridge(image))
-}
-
-func vipsRotate(image *C.VipsImage, angle Angle) (*C.VipsImage, error) {
-	var out *C.VipsImage
-	defer C.g_object_unref(C.gpointer(image))
-
-	err := C.vips_rotate(image, &out, C.int(angle))
-	if err != 0 {
-		return nil, catchVipsError()
-	}
-
-	return out, nil
-}
-
-func vipsFlip(image *C.VipsImage, direction Direction) (*C.VipsImage, error) {
-	var out *C.VipsImage
-	defer C.g_object_unref(C.gpointer(image))
-
-	err := C.vips_flip_bridge(image, &out, C.int(direction))
-	if err != 0 {
-		return nil, catchVipsError()
-	}
-
-	return out, nil
-}
-
-func vipsZoom(image *C.VipsImage, zoom int) (*C.VipsImage, error) {
-	var out *C.VipsImage
-	defer C.g_object_unref(C.gpointer(image))
-
-	err := C.vips_zoom_bridge(image, &out, C.int(zoom), C.int(zoom))
-	if err != 0 {
-		return nil, catchVipsError()
-	}
-
-	return out, nil
-}
-
-func vipsWatermark(image *C.VipsImage, w Watermark) (*C.VipsImage, error) {
-	var out *C.VipsImage
-
-	// Defaults
-	noReplicate := 0
-	if w.NoReplicate {
-		noReplicate = 1
-	}
-
-	text := C.CString(w.Text)
-	font := C.CString(w.Font)
-	background := [3]C.double{C.double(w.Background.R), C.double(w.Background.G), C.double(w.Background.B)}
-
-	textOpts := vipsWatermarkTextOptions{text, font}
-	opts := vipsWatermarkOptions{C.int(w.Width), C.int(w.DPI), C.int(w.Margin), C.int(noReplicate), C.float(w.Opacity), background}
-
-	defer C.free(unsafe.Pointer(text))
-	defer C.free(unsafe.Pointer(font))
-
-	err := C.vips_watermark(image, &out, (*C.WatermarkTextOptions)(unsafe.Pointer(&textOpts)), (*C.WatermarkOptions)(unsafe.Pointer(&opts)))
-	if err != 0 {
-		return nil, catchVipsError()
-	}
-
-	return out, nil
-}
-
-func vipsRead(buf []byte) (*C.VipsImage, ImageType, error) {
-	var image *C.VipsImage
-	imageType := vipsImageType(buf)
-
-	if imageType == UNKNOWN {
-		return nil, UNKNOWN, errors.New("Unsupported image format")
-	}
-
-	length := C.size_t(len(buf))
-	imageBuf := unsafe.Pointer(&buf[0])
-
-	err := C.vips_init_image(imageBuf, length, C.int(imageType), &image)
-	if err != 0 {
-		return nil, UNKNOWN, catchVipsError()
-	}
-
-	return image, imageType, nil
-}
-
-func vipsColourspaceIsSupportedBuffer(buf []byte) (bool, error) {
-	image, _, err := vipsRead(buf)
-	if err != nil {
-		return false, err
-	}
-	C.g_object_unref(C.gpointer(image))
-	return vipsColourspaceIsSupported(image), nil
-}
-
-func vipsColourspaceIsSupported(image *C.VipsImage) bool {
-	return int(C.vips_colourspace_issupported_bridge(image)) == 1
-}
-
-func vipsInterpretationBuffer(buf []byte) (Interpretation, error) {
-	image, _, err := vipsRead(buf)
-	if err != nil {
-		return InterpretationError, err
-	}
-	C.g_object_unref(C.gpointer(image))
-	return vipsInterpretation(image), nil
-}
-
-func vipsInterpretation(image *C.VipsImage) Interpretation {
-	return Interpretation(C.vips_image_guess_interpretation_bridge(image))
-}
-
-func vipsFlattenBackground(image *C.VipsImage, background Color) (*C.VipsImage, error) {
-	var outImage *C.VipsImage
-
-	backgroundC := [3]C.double{
-		C.double(background.R),
-		C.double(background.G),
-		C.double(background.B),
-	}
-
-	if vipsHasAlpha(image) {
-		err := C.vips_flatten_background_brigde(image, &outImage,
-			backgroundC[0], backgroundC[1], backgroundC[2])
-		if int(err) != 0 {
-			return nil, catchVipsError()
-		}
-		C.g_object_unref(C.gpointer(image))
-		image = outImage
-	}
-
-	return image, nil
-}
-
-func vipsPreSave(image *C.VipsImage, o *vipsSaveOptions) (*C.VipsImage, error) {
-	var outImage *C.VipsImage
-	// Remove ICC profile metadata
-	if o.NoProfile {
-		C.remove_profile(image)
-	}
-
-	// Use a default interpretation and cast it to C type
-	if o.Interpretation == 0 {
-		o.Interpretation = InterpretationSRGB
-	}
-	interpretation := C.VipsInterpretation(o.Interpretation)
-
-	// Apply the proper colour space
-	if vipsColourspaceIsSupported(image) {
-		err := C.vips_colourspace_bridge(image, &outImage, interpretation)
-		if int(err) != 0 {
-			return nil, catchVipsError()
-		}
-		image = outImage
-	}
-
-	if o.OutputICC != "" && vipsHasProfile(image) {
-		debug("Embedded ICC profile found, trying to convert to %s", o.OutputICC)
-		outputIccPath := C.CString(o.OutputICC)
-		defer C.free(unsafe.Pointer(outputIccPath))
-
-		err := C.vips_icc_transform_bridge(image, &outImage, outputIccPath)
-		if int(err) != 0 {
-			return nil, catchVipsError()
-		}
-		image = outImage
-	}
-
-	return image, nil
-}
-
-func vipsSave(image *C.VipsImage, o vipsSaveOptions) ([]byte, error) {
-	defer C.g_object_unref(C.gpointer(image))
-
-	tmpImage, err := vipsPreSave(image, &o)
-	if err != nil {
-		return nil, err
-	}
-
-	// When an image has an unsupported color space, vipsPreSave
-	// returns the pointer of the image passed to it unmodified.
-	// When this occurs, we must take care to not dereference the
-	// original image a second time; we may otherwise erroneously
-	// free the object twice.
-	if tmpImage != image {
-		defer C.g_object_unref(C.gpointer(tmpImage))
-	}
-
-	length := C.size_t(0)
-	saveErr := C.int(0)
-	interlace := C.int(boolToInt(o.Interlace))
-	quality := C.int(o.Quality)
-	strip := C.int(boolToInt(o.StripMetadata))
-
-	if o.Type != 0 && !IsTypeSupportedSave(o.Type) {
-		return nil, fmt.Errorf("VIPS cannot save to %#v", ImageTypes[o.Type])
-	}
-	var ptr unsafe.Pointer
-	switch o.Type {
-	case WEBP:
-		saveErr = C.vips_webpsave_bridge(tmpImage, &ptr, &length, strip, quality)
-	case PNG:
-		saveErr = C.vips_pngsave_bridge(tmpImage, &ptr, &length, strip, C.int(o.Compression), quality, interlace)
-	case TIFF:
-		saveErr = C.vips_tiffsave_bridge(tmpImage, &ptr, &length)
-	default:
-		saveErr = C.vips_jpegsave_bridge(tmpImage, &ptr, &length, strip, quality, interlace)
-	}
-
-	if int(saveErr) != 0 {
-		return nil, catchVipsError()
-	}
-
-	buf := C.GoBytes(ptr, C.int(length))
-
-	// Clean up
-	C.g_free(C.gpointer(ptr))
-	C.vips_error_clear()
-
-	return buf, nil
-}
-
-func getImageBuffer(image *C.VipsImage) ([]byte, error) {
-	var ptr unsafe.Pointer
-
-	length := C.size_t(0)
-	interlace := C.int(0)
-	quality := C.int(100)
-
-	err := C.int(0)
-	err = C.vips_jpegsave_bridge(image, &ptr, &length, 1, quality, interlace)
-	if int(err) != 0 {
-		return nil, catchVipsError()
-	}
-
-	defer C.g_free(C.gpointer(ptr))
-	defer C.vips_error_clear()
-
-	return C.GoBytes(ptr, C.int(length)), nil
-}
-
-func vipsExtract(image *C.VipsImage, left, top, width, height int) (*C.VipsImage, error) {
-	var buf *C.VipsImage
-	defer C.g_object_unref(C.gpointer(image))
-
-	if width > MaxSize || height > MaxSize {
-		return nil, errors.New("Maximum image size exceeded")
-	}
-
-	top, left = max(top), max(left)
-	err := C.vips_extract_area_bridge(image, &buf, C.int(left), C.int(top), C.int(width), C.int(height))
-	if err != 0 {
-		return nil, catchVipsError()
-	}
-
-	return buf, nil
-}
-
-func vipsSmartCrop(image *C.VipsImage, width, height int) (*C.VipsImage, error) {
-	var buf *C.VipsImage
-	defer C.g_object_unref(C.gpointer(image))
-
-	if width > MaxSize || height > MaxSize {
-		return nil, errors.New("Maximum image size exceeded")
-	}
-
-	err := C.vips_smartcrop_bridge(image, &buf, C.int(width), C.int(height))
-	if err != 0 {
-		return nil, catchVipsError()
-	}
-
-	return buf, nil
-}
-
-func vipsTrim(image *C.VipsImage) (int, int, int, int, error) {
-	defer C.g_object_unref(C.gpointer(image))
-
-	top := C.int(0)
-	left := C.int(0)
-	width := C.int(0)
-	height := C.int(0)
-
-	err := C.vips_find_trim_bridge(image, &top, &left, &width, &height)
-	if err != 0 {
-		return 0, 0, 0, 0, catchVipsError()
-	}
-
-	return int(top), int(left), int(width), int(height), nil
-}
-
-func vipsShrinkJpeg(buf []byte, input *C.VipsImage, shrink int) (*C.VipsImage, error) {
-	var image *C.VipsImage
-	var ptr = unsafe.Pointer(&buf[0])
-	defer C.g_object_unref(C.gpointer(input))
-
-	err := C.vips_jpegload_buffer_shrink(ptr, C.size_t(len(buf)), &image, C.int(shrink))
-	if err != 0 {
-		return nil, catchVipsError()
-	}
-
-	return image, nil
-}
-
-func vipsShrink(input *C.VipsImage, shrink int) (*C.VipsImage, error) {
-	var image *C.VipsImage
-	defer C.g_object_unref(C.gpointer(input))
-
-	err := C.vips_shrink_bridge(input, &image, C.double(float64(shrink)), C.double(float64(shrink)))
-	if err != 0 {
-		return nil, catchVipsError()
-	}
-
-	return image, nil
-}
-
-func vipsReduce(input *C.VipsImage, xshrink float64, yshrink float64) (*C.VipsImage, error) {
-	var image *C.VipsImage
-	defer C.g_object_unref(C.gpointer(input))
-
-	err := C.vips_reduce_bridge(input, &image, C.double(xshrink), C.double(yshrink))
-	if err != 0 {
-		return nil, catchVipsError()
-	}
-
-	return image, nil
-}
-
-func vipsEmbed(input *C.VipsImage, left, top, width, height int, extend Extend, background Color) (*C.VipsImage, error) {
-	var image *C.VipsImage
-
-	// Max extend value, see: http://www.vips.ecs.soton.ac.uk/supported/8.4/doc/html/libvips/libvips-conversion.html#VipsExtend
-	if extend > 5 {
-		extend = ExtendBackground
-	}
-
-	defer C.g_object_unref(C.gpointer(input))
-	err := C.vips_embed_bridge(input, &image, C.int(left), C.int(top), C.int(width),
-		C.int(height), C.int(extend), C.double(background.R), C.double(background.G), C.double(background.B))
-	if err != 0 {
-		return nil, catchVipsError()
-	}
-
-	return image, nil
-}
-
-func vipsAffine(input *C.VipsImage, residualx, residualy float64, i Interpolator) (*C.VipsImage, error) {
-	var image *C.VipsImage
-	cstring := C.CString(i.String())
-	interpolator := C.vips_interpolate_new(cstring)
-
-	defer C.free(unsafe.Pointer(cstring))
-	defer C.g_object_unref(C.gpointer(input))
-	defer C.g_object_unref(C.gpointer(interpolator))
-
-	err := C.vips_affine_interpolator(input, &image, C.double(residualx), 0, 0, C.double(residualy), interpolator)
-	if err != 0 {
-		return nil, catchVipsError()
-	}
-
-	return image, nil
-}
-
-func vipsImageType(buf []byte) ImageType {
-	if len(buf) < 12 {
-		return UNKNOWN
-	}
-	if buf[0] == 0xFF && buf[1] == 0xD8 && buf[2] == 0xFF {
-		return JPEG
-	}
-	if IsTypeSupported(GIF) && buf[0] == 0x47 && buf[1] == 0x49 && buf[2] == 0x46 {
-		return GIF
-	}
-	if buf[0] == 0x89 && buf[1] == 0x50 && buf[2] == 0x4E && buf[3] == 0x47 {
-		return PNG
-	}
-	if IsTypeSupported(TIFF) &&
-		((buf[0] == 0x49 && buf[1] == 0x49 && buf[2] == 0x2A && buf[3] == 0x0) ||
-			(buf[0] == 0x4D && buf[1] == 0x4D && buf[2] == 0x0 && buf[3] == 0x2A)) {
-		return TIFF
-	}
-	if IsTypeSupported(PDF) && buf[0] == 0x25 && buf[1] == 0x50 && buf[2] == 0x44 && buf[3] == 0x46 {
-		return PDF
-	}
-	if IsTypeSupported(WEBP) && buf[8] == 0x57 && buf[9] == 0x45 && buf[10] == 0x42 && buf[11] == 0x50 {
-		return WEBP
-	}
-	if IsTypeSupported(SVG) && IsSVGImage(buf) {
-		return SVG
-	}
-	if IsTypeSupported(MAGICK) && strings.HasSuffix(readImageType(buf), "MagickBuffer") {
-		return MAGICK
-	}
-
-	return UNKNOWN
-}
-
-func readImageType(buf []byte) string {
-	length := C.size_t(len(buf))
-	imageBuf := unsafe.Pointer(&buf[0])
-	load := C.vips_foreign_find_load_buffer(imageBuf, length)
-	return C.GoString(load)
-}
-
-func catchVipsError() error {
-	s := C.GoString(C.vips_error_buffer())
-	C.vips_error_clear()
-	C.vips_thread_shutdown()
-	return errors.New(s)
-}
-
-func boolToInt(b bool) int {
-	if b {
-		return 1
-	}
-	return 0
-}
-
-func vipsGaussianBlur(image *C.VipsImage, o GaussianBlur) (*C.VipsImage, error) {
-	var out *C.VipsImage
-	defer C.g_object_unref(C.gpointer(image))
-
-	err := C.vips_gaussblur_bridge(image, &out, C.double(o.Sigma), C.double(o.MinAmpl))
-	if err != 0 {
-		return nil, catchVipsError()
-	}
-	return out, nil
-}
-
-func vipsSharpen(image *C.VipsImage, o Sharpen) (*C.VipsImage, error) {
-	var out *C.VipsImage
-	defer C.g_object_unref(C.gpointer(image))
-
-	err := C.vips_sharpen_bridge(image, &out, C.int(o.Radius), C.double(o.X1), C.double(o.Y2), C.double(o.Y3), C.double(o.M1), C.double(o.M2))
-	if err != 0 {
-		return nil, catchVipsError()
-	}
-	return out, nil
-}
-
-func max(x int) int {
-	return int(math.Max(float64(x), 0))
-}
-
-func vipsDrawWatermark(image *C.VipsImage, o WatermarkImage) (*C.VipsImage, error) {
-	var out *C.VipsImage
-
-	watermark, _, e := vipsRead(o.Buf)
-	if e != nil {
-		return nil, e
-	}
-
-	opts := vipsWatermarkImageOptions{C.int(o.Left), C.int(o.Top), C.float(o.Opacity)}
-
-	err := C.vips_watermark_image(image, watermark, &out, (*C.WatermarkImageOptions)(unsafe.Pointer(&opts)))
-
-	if err != 0 {
-		return nil, catchVipsError()
-	}
-
-	return out, nil
-}

vendor/github.com/h2non/bimg/vips.h

@@ -1,549 +0,0 @@
-#include <stdlib.h>
-#include <string.h>
-#include <vips/vips.h>
-#include <vips/foreign.h>
-#include <vips/vips7compat.h>
-
-/**
- * Starting libvips 7.41, VIPS_ANGLE_x has been renamed to VIPS_ANGLE_Dx
- * "to help python". So we provide the macro to correctly build for versions
- * before 7.41.x.
- * https://github.com/jcupitt/libvips/blob/master/ChangeLog#L128
- */
-
-#if (VIPS_MAJOR_VERSION == 7 && VIPS_MINOR_VERSION < 41)
-#define VIPS_ANGLE_D0 VIPS_ANGLE_0
-#define VIPS_ANGLE_D90 VIPS_ANGLE_90
-#define VIPS_ANGLE_D180 VIPS_ANGLE_180
-#define VIPS_ANGLE_D270 VIPS_ANGLE_270
-#endif
-
-#define EXIF_IFD0_ORIENTATION "exif-ifd0-Orientation"
-
-#define INT_TO_GBOOLEAN(bool) (bool > 0 ? TRUE : FALSE)
-
-
-enum types {
-	UNKNOWN = 0,
-	JPEG,
-	WEBP,
-	PNG,
-	TIFF,
-	GIF,
-	PDF,
-	SVG,
-	MAGICK
-};
-
-typedef struct {
-	const char *Text;
-	const char *Font;
-} WatermarkTextOptions;
-
-typedef struct {
-	int    Width;
-	int    DPI;
-	int    Margin;
-	int    NoReplicate;
-	float  Opacity;
-	double Background[3];
-} WatermarkOptions;
-
-typedef struct {
-	int    Left;
-	int    Top;
-	float    Opacity;
-} WatermarkImageOptions;
-
-static unsigned long
-has_profile_embed(VipsImage *image) {
-	return vips_image_get_typeof(image, VIPS_META_ICC_NAME);
-}
-
-static void
-remove_profile(VipsImage *image) {
-	vips_image_remove(image, VIPS_META_ICC_NAME);
-}
-
-static int
-has_alpha_channel(VipsImage *image) {
-	return (
-		(image->Bands == 2 && image->Type == VIPS_INTERPRETATION_B_W) ||
-		(image->Bands == 4 && image->Type != VIPS_INTERPRETATION_CMYK) ||
-		(image->Bands == 5 && image->Type == VIPS_INTERPRETATION_CMYK)
-	) ? 1 : 0;
-}
-
-/**
- * This method is here to handle the weird initialization of the vips lib.
- * libvips use a macro VIPS_INIT() that call vips__init() in version < 7.41,
- * or calls vips_init() in version >= 7.41.
- *
- * Anyway, it's not possible to build bimg on Debian Jessie with libvips 7.40.x,
- * as vips_init() is a macro to VIPS_INIT(), which is also a macro, hence, cgo
- * is unable to determine the return type of vips_init(), making the build impossible.
- * In order to correctly build bimg, for version < 7.41, we should undef vips_init and
- * creates a vips_init() method that calls VIPS_INIT().
- */
-
-#if (VIPS_MAJOR_VERSION == 7 && VIPS_MINOR_VERSION < 41)
-#undef vips_init
-int
-vips_init(const char *argv0)
-{
-	return VIPS_INIT(argv0);
-}
-#endif
-
-void
-vips_enable_cache_set_trace() {
-	vips_cache_set_trace(TRUE);
-}
-
-int
-vips_affine_interpolator(VipsImage *in, VipsImage **out, double a, double b, double c, double d, VipsInterpolate *interpolator) {
-	return vips_affine(in, out, a, b, c, d, "interpolate", interpolator, NULL);
-}
-
-int
-vips_jpegload_buffer_shrink(void *buf, size_t len, VipsImage **out, int shrink) {
-	return vips_jpegload_buffer(buf, len, out, "shrink", shrink, NULL);
-}
-
-int
-vips_flip_bridge(VipsImage *in, VipsImage **out, int direction) {
-	return vips_flip(in, out, direction, NULL);
-}
-
-int
-vips_shrink_bridge(VipsImage *in, VipsImage **out, double xshrink, double yshrink) {
-	return vips_shrink(in, out, xshrink, yshrink, NULL);
-}
-
-int
-vips_reduce_bridge(VipsImage *in, VipsImage **out, double xshrink, double yshrink) {
-	return vips_reduce(in, out, xshrink, yshrink, NULL);
-}
-
-int
-vips_type_find_bridge(int t) {
-	if (t == GIF) {
-		return vips_type_find("VipsOperation", "gifload");
-	}
-	if (t == PDF) {
-		return vips_type_find("VipsOperation", "pdfload");
-	}
-	if (t == TIFF) {
-		return vips_type_find("VipsOperation", "tiffload");
-	}
-	if (t == SVG) {
-		return vips_type_find("VipsOperation", "svgload");
-	}
-	if (t == WEBP) {
-		return vips_type_find("VipsOperation", "webpload");
-	}
-	if (t == PNG) {
-		return vips_type_find("VipsOperation", "pngload");
-	}
-	if (t == JPEG) {
-		return vips_type_find("VipsOperation", "jpegload");
-	}
-	if (t == MAGICK) {
-		return vips_type_find("VipsOperation", "magickload");
-	}
-	return 0;
-}
-
-int
-vips_type_find_save_bridge(int t) {
-	if (t == TIFF) {
-		return vips_type_find("VipsOperation", "tiffsave_buffer");
-	}
-	if (t == WEBP) {
-		return vips_type_find("VipsOperation", "webpsave_buffer");
-	}
-	if (t == PNG) {
-		return vips_type_find("VipsOperation", "pngsave_buffer");
-	}
-	if (t == JPEG) {
-		return vips_type_find("VipsOperation", "jpegsave_buffer");
-	}
-	return 0;
-}
-
-int
-vips_rotate(VipsImage *in, VipsImage **out, int angle) {
-	int rotate = VIPS_ANGLE_D0;
-
-	angle %= 360;
-
-	if (angle == 45) {
-		rotate = VIPS_ANGLE45_D45;
-	} else if (angle == 90) {
-		rotate = VIPS_ANGLE_D90;
-	} else if (angle == 135) {
-		rotate = VIPS_ANGLE45_D135;
-	} else if (angle == 180) {
-		rotate = VIPS_ANGLE_D180;
-	} else if (angle == 225) {
-		rotate = VIPS_ANGLE45_D225;
-	} else if (angle == 270) {
-		rotate = VIPS_ANGLE_D270;
-	} else if (angle == 315) {
-		rotate = VIPS_ANGLE45_D315;
-	} else {
-		angle = 0;
-	}
-
-	if (angle > 0 && angle % 90 != 0) {
-		return vips_rot45(in, out, "angle", rotate, NULL);
-	} else {
-		return vips_rot(in, out, rotate, NULL);
-	}
-}
-
-int
-vips_exif_orientation(VipsImage *image) {
-	int orientation = 0;
-	const char *exif;
-	if (
-		vips_image_get_typeof(image, EXIF_IFD0_ORIENTATION) != 0 &&
-		!vips_image_get_string(image, EXIF_IFD0_ORIENTATION, &exif)
-	) {
-		orientation = atoi(&exif[0]);
-	}
-	return orientation;
-}
-
-int
-interpolator_window_size(char const *name) {
-	VipsInterpolate *interpolator = vips_interpolate_new(name);
-	int window_size = vips_interpolate_get_window_size(interpolator);
-	g_object_unref(interpolator);
-	return window_size;
-}
-
-const char *
-vips_enum_nick_bridge(VipsImage *image) {
-	return vips_enum_nick(VIPS_TYPE_INTERPRETATION, image->Type);
-}
-
-int
-vips_zoom_bridge(VipsImage *in, VipsImage **out, int xfac, int yfac) {
-	return vips_zoom(in, out, xfac, yfac, NULL);
-}
-
-int
-vips_embed_bridge(VipsImage *in, VipsImage **out, int left, int top, int width, int height, int extend, double r, double g, double b) {
-	if (extend == VIPS_EXTEND_BACKGROUND) {
-		double background[3] = {r, g, b};
-		VipsArrayDouble *vipsBackground = vips_array_double_new(background, 3);
-		return vips_embed(in, out, left, top, width, height, "extend", extend, "background", vipsBackground, NULL);
-	}
-	return vips_embed(in, out, left, top, width, height, "extend", extend, NULL);
-}
-
-int
-vips_extract_area_bridge(VipsImage *in, VipsImage **out, int left, int top, int width, int height) {
-	return vips_extract_area(in, out, left, top, width, height, NULL);
-}
-
-int
-vips_colourspace_issupported_bridge(VipsImage *in) {
-	return vips_colourspace_issupported(in) ? 1 : 0;
-}
-
-VipsInterpretation
-vips_image_guess_interpretation_bridge(VipsImage *in) {
-	return vips_image_guess_interpretation(in);
-}
-
-int
-vips_colourspace_bridge(VipsImage *in, VipsImage **out, VipsInterpretation space) {
-	return vips_colourspace(in, out, space, NULL);
-}
-
-int
-vips_icc_transform_bridge (VipsImage *in, VipsImage **out, const char *output_icc_profile) {
-	// `output_icc_profile` represents the absolute path to the output ICC profile file
-	return vips_icc_transform(in, out, output_icc_profile, "embedded", TRUE, NULL);
-}
-
-int
-vips_jpegsave_bridge(VipsImage *in, void **buf, size_t *len, int strip, int quality, int interlace) {
-	return vips_jpegsave_buffer(in, buf, len,
-		"strip", INT_TO_GBOOLEAN(strip),
-		"Q", quality,
-		"optimize_coding", TRUE,
-		"interlace", INT_TO_GBOOLEAN(interlace),
-		NULL
-	);
-}
-
-int
-vips_pngsave_bridge(VipsImage *in, void **buf, size_t *len, int strip, int compression, int quality, int interlace) {
-#if (VIPS_MAJOR_VERSION >= 8 || (VIPS_MAJOR_VERSION >= 7 && VIPS_MINOR_VERSION >= 42))
-	return vips_pngsave_buffer(in, buf, len,
-		"strip", INT_TO_GBOOLEAN(strip),
-		"compression", compression,
-		"interlace", INT_TO_GBOOLEAN(interlace),
-		"filter", VIPS_FOREIGN_PNG_FILTER_NONE,
-		NULL
-	);
-#else
-	return vips_pngsave_buffer(in, buf, len,
-		"strip", INT_TO_GBOOLEAN(strip),
-		"compression", compression,
-		"interlace", INT_TO_GBOOLEAN(interlace),
-		NULL
-	);
-#endif
-}
-
-int
-vips_webpsave_bridge(VipsImage *in, void **buf, size_t *len, int strip, int quality) {
-	return vips_webpsave_buffer(in, buf, len,
-		"strip", INT_TO_GBOOLEAN(strip),
-		"Q", quality,
-		NULL
-	);
-}
-
-int
-vips_tiffsave_bridge(VipsImage *in, void **buf, size_t *len) {
-#if (VIPS_MAJOR_VERSION >= 8 && VIPS_MINOR_VERSION >= 5)
-	return vips_tiffsave_buffer(in, buf, len, NULL);
-#else
-	return 0;
-#endif
-}
-
-int
-vips_is_16bit (VipsInterpretation interpretation) {
-	return interpretation == VIPS_INTERPRETATION_RGB16 || interpretation == VIPS_INTERPRETATION_GREY16;
-}
-
-int
-vips_flatten_background_brigde(VipsImage *in, VipsImage **out, double r, double g, double b) {
-	if (vips_is_16bit(in->Type)) {
-		r = 65535 * r / 255;
-		g = 65535 * g / 255;
-		b = 65535 * b / 255;
-	}
-
-	double background[3] = {r, g, b};
-	VipsArrayDouble *vipsBackground = vips_array_double_new(background, 3);
-
-	return vips_flatten(in, out,
-		"background", vipsBackground,
-		"max_alpha", vips_is_16bit(in->Type) ? 65535.0 : 255.0,
-		NULL
-	);
-}
-
-int
-vips_init_image (void *buf, size_t len, int imageType, VipsImage **out) {
-	int code = 1;
-
-	if (imageType == JPEG) {
-		code = vips_jpegload_buffer(buf, len, out, "access", VIPS_ACCESS_RANDOM, NULL);
-	} else if (imageType == PNG) {
-		code = vips_pngload_buffer(buf, len, out, "access", VIPS_ACCESS_RANDOM, NULL);
-	} else if (imageType == WEBP) {
-		code = vips_webpload_buffer(buf, len, out, "access", VIPS_ACCESS_RANDOM, NULL);
-	} else if (imageType == TIFF) {
-		code = vips_tiffload_buffer(buf, len, out, "access", VIPS_ACCESS_RANDOM, NULL);
-#if (VIPS_MAJOR_VERSION >= 8)
-#if (VIPS_MINOR_VERSION >= 3)
-	} else if (imageType == GIF) {
-		code = vips_gifload_buffer(buf, len, out, "access", VIPS_ACCESS_RANDOM, NULL);
-	} else if (imageType == PDF) {
-		code = vips_pdfload_buffer(buf, len, out, "access", VIPS_ACCESS_RANDOM, NULL);
-	} else if (imageType == SVG) {
-		code = vips_svgload_buffer(buf, len, out, "access", VIPS_ACCESS_RANDOM, NULL);
-#endif
-	} else if (imageType == MAGICK) {
-		code = vips_magickload_buffer(buf, len, out, "access", VIPS_ACCESS_RANDOM, NULL);
-#endif
-	}
-
-	return code;
-}
-
-int
-vips_watermark_replicate (VipsImage *orig, VipsImage *in, VipsImage **out) {
-	VipsImage *cache = vips_image_new();
-
-	if (
-		vips_replicate(in, &cache,
-			1 + orig->Xsize / in->Xsize,
-			1 + orig->Ysize / in->Ysize, NULL) ||
-		vips_crop(cache, out, 0, 0, orig->Xsize, orig->Ysize, NULL)
-	) {
-		g_object_unref(cache);
-		return 1;
-	}
-
-	g_object_unref(cache);
-	return 0;
-}
-
-int
-vips_watermark(VipsImage *in, VipsImage **out, WatermarkTextOptions *to, WatermarkOptions *o) {
-	double ones[3] = { 1, 1, 1 };
-
-	VipsImage *base = vips_image_new();
-	VipsImage **t = (VipsImage **) vips_object_local_array(VIPS_OBJECT(base), 10);
-	t[0] = in;
-
-	// Make the mask.
-	if (
-		vips_text(&t[1], to->Text,
-			"width", o->Width,
-			"dpi", o->DPI,
-			"font", to->Font,
-			NULL) ||
-		vips_linear1(t[1], &t[2], o->Opacity, 0.0, NULL) ||
-		vips_cast(t[2], &t[3], VIPS_FORMAT_UCHAR, NULL) ||
-		vips_embed(t[3], &t[4], 100, 100, t[3]->Xsize + o->Margin, t[3]->Ysize + o->Margin, NULL)
-		) {
-		g_object_unref(base);
-		return 1;
-	}
-
-	// Replicate if necessary
-	if (o->NoReplicate != 1) {
-		VipsImage *cache = vips_image_new();
-		if (vips_watermark_replicate(t[0], t[4], &cache)) {
-			g_object_unref(cache);
-			g_object_unref(base);
-			return 1;
-		}
-		g_object_unref(t[4]);
-		t[4] = cache;
-	}
-
-	// Make the constant image to paint the text with.
-	if (
-		vips_black(&t[5], 1, 1, NULL) ||
-		vips_linear(t[5], &t[6], ones, o->Background, 3, NULL) ||
-		vips_cast(t[6], &t[7], VIPS_FORMAT_UCHAR, NULL) ||
-		vips_copy(t[7], &t[8], "interpretation", t[0]->Type, NULL) ||
-		vips_embed(t[8], &t[9], 0, 0, t[0]->Xsize, t[0]->Ysize, "extend", VIPS_EXTEND_COPY, NULL)
-		) {
-		g_object_unref(base);
-		return 1;
-	}
-
-	// Blend the mask and text and write to output.
-	if (vips_ifthenelse(t[4], t[9], t[0], out, "blend", TRUE, NULL)) {
-		g_object_unref(base);
-		return 1;
-	}
-
-	g_object_unref(base);
-	return 0;
-}
-
-int
-vips_gaussblur_bridge(VipsImage *in, VipsImage **out, double sigma, double min_ampl) {
-#if (VIPS_MAJOR_VERSION == 7 && VIPS_MINOR_VERSION < 41)
-	return vips_gaussblur(in, out, (int) sigma, NULL);
-#else
-	return vips_gaussblur(in, out, sigma, NULL, "min_ampl", min_ampl, NULL);
-#endif
-}
-
-int
-vips_sharpen_bridge(VipsImage *in, VipsImage **out, int radius, double x1, double y2, double y3, double m1, double m2) {
-#if (VIPS_MAJOR_VERSION == 7 && VIPS_MINOR_VERSION < 41)
-	return vips_sharpen(in, out, radius, x1, y2, y3, m1, m2, NULL);
-#else
-	return vips_sharpen(in, out, "radius", radius, "x1", x1, "y2", y2, "y3", y3, "m1", m1, "m2", m2, NULL);
-#endif
-}
-
-int
-vips_add_band(VipsImage *in, VipsImage **out, double c) {
-#if (VIPS_MAJOR_VERSION > 8 || (VIPS_MAJOR_VERSION >= 8 && VIPS_MINOR_VERSION >= 2))
-	return vips_bandjoin_const1(in, out, c, NULL);
-#else
-	VipsImage *base = vips_image_new();
-	if (
-		vips_black(&base, in->Xsize, in->Ysize, NULL) ||
-		vips_linear1(base, &base, 1, c, NULL)) {
-			g_object_unref(base);
-			return 1;
-		}
-	g_object_unref(base);
-	return vips_bandjoin2(in, base, out, c, NULL);
-#endif
-}
-
-int
-vips_watermark_image(VipsImage *in, VipsImage *sub, VipsImage **out, WatermarkImageOptions *o) {
-	VipsImage *base = vips_image_new();
-	VipsImage **t = (VipsImage **) vips_object_local_array(VIPS_OBJECT(base), 10);
-
-  // add in and sub for unreffing and later use
-	t[0] = in;
-	t[1] = sub;
-
-  if (has_alpha_channel(in) == 0) {
-		vips_add_band(in, &t[0], 255.0);
-		// in is no longer in the array and won't be unreffed, so add it at the end
-		t[8] = in;
-	}
-
-	if (has_alpha_channel(sub) == 0) {
-		vips_add_band(sub, &t[1], 255.0);
-		// sub is no longer in the array and won't be unreffed, so add it at the end
-		t[9] = sub;
-	}
-
-	// Place watermark image in the right place and size it to the size of the
-	// image that should be watermarked
-	if (
-		vips_embed(t[1], &t[2], o->Left, o->Top, t[0]->Xsize, t[0]->Ysize, NULL)) {
-			g_object_unref(base);
-		return 1;
-	}
-
-	// Create a mask image based on the alpha band from the watermark image
-	// and place it in the right position
-	if (
-		vips_extract_band(t[1], &t[3], t[1]->Bands - 1, "n", 1, NULL) ||
-		vips_linear1(t[3], &t[4], o->Opacity, 0.0, NULL) ||
-		vips_cast(t[4], &t[5], VIPS_FORMAT_UCHAR, NULL) ||
-		vips_copy(t[5], &t[6], "interpretation", t[0]->Type, NULL) ||
-		vips_embed(t[6], &t[7], o->Left, o->Top, t[0]->Xsize, t[0]->Ysize, NULL))	{
-			g_object_unref(base);
-		return 1;
-	}
-
-	// Blend the mask and watermark image and write to output.
-	if (vips_ifthenelse(t[7], t[2], t[0], out, "blend", TRUE, NULL)) {
-		g_object_unref(base);
-		return 1;
-	}
-
-	g_object_unref(base);
-	return 0;
-}
-
-int
-vips_smartcrop_bridge(VipsImage *in, VipsImage **out, int width, int height) {
-#if (VIPS_MAJOR_VERSION >= 8 && VIPS_MINOR_VERSION >= 5)
-	return vips_smartcrop(in, out, width, height, NULL);
-#else
-	return 0;
-#endif
-}
-
-int vips_find_trim_bridge(VipsImage *in, int *top, int *left, int *width, int *height) {
-#if (VIPS_MAJOR_VERSION >= 8 && VIPS_MINOR_VERSION >= 6)
-	return vips_find_trim(in, top, left, width, height, NULL);
-#else
-	return 0;
-#endif
-}

vendor/github.com/h2non/bimg/vips_test.go

@@ -1,170 +0,0 @@
-package bimg
-
-import (
-	"io/ioutil"
-	"os"
-	"path"
-	"testing"
-)
-
-func TestVipsRead(t *testing.T) {
-	files := []struct {
-		name     string
-		expected ImageType
-	}{
-		{"test.jpg", JPEG},
-		{"test.png", PNG},
-		{"test.webp", WEBP},
-	}
-
-	for _, file := range files {
-		image, imageType, _ := vipsRead(readImage(file.name))
-		if image == nil {
-			t.Fatal("Empty image")
-		}
-		if imageType != file.expected {
-			t.Fatal("Invalid image type")
-		}
-	}
-}
-
-func TestVipsSave(t *testing.T) {
-	types := [...]ImageType{JPEG, PNG, WEBP}
-
-	for _, typ := range types {
-		image, _, _ := vipsRead(readImage("test.jpg"))
-		options := vipsSaveOptions{Quality: 95, Type: typ, StripMetadata: true}
-
-		buf, err := vipsSave(image, options)
-		if err != nil {
-			t.Fatalf("Cannot save the image as '%v'", ImageTypes[typ])
-		}
-		if len(buf) == 0 {
-			t.Fatalf("Empty saved '%v' image", ImageTypes[typ])
-		}
-	}
-}
-
-func TestVipsSaveTiff(t *testing.T) {
-	if !IsTypeSupportedSave(TIFF) {
-		t.Skipf("Format %#v is not supported", ImageTypes[TIFF])
-	}
-	image, _, _ := vipsRead(readImage("test.jpg"))
-	options := vipsSaveOptions{Quality: 95, Type: TIFF}
-	buf, _ := vipsSave(image, options)
-
-	if len(buf) == 0 {
-		t.Fatalf("Empty saved '%v' image", ImageTypes[TIFF])
-	}
-}
-
-func TestVipsRotate(t *testing.T) {
-	files := []struct {
-		name   string
-		rotate Angle
-	}{
-		{"test.jpg", D90},
-		{"test_square.jpg", D45},
-	}
-
-	for _, file := range files {
-		image, _, _ := vipsRead(readImage(file.name))
-
-		newImg, err := vipsRotate(image, file.rotate)
-		if err != nil {
-			t.Fatal("Cannot rotate the image")
-		}
-
-		buf, _ := vipsSave(newImg, vipsSaveOptions{Quality: 95})
-		if len(buf) == 0 {
-			t.Fatal("Empty image")
-		}
-	}
-}
-
-func TestVipsZoom(t *testing.T) {
-	image, _, _ := vipsRead(readImage("test.jpg"))
-
-	newImg, err := vipsZoom(image, 1)
-	if err != nil {
-		t.Fatal("Cannot save the image")
-	}
-
-	buf, _ := vipsSave(newImg, vipsSaveOptions{Quality: 95})
-	if len(buf) == 0 {
-		t.Fatal("Empty image")
-	}
-}
-
-func TestVipsWatermark(t *testing.T) {
-	image, _, _ := vipsRead(readImage("test.jpg"))
-
-	watermark := Watermark{
-		Text:       "Copy me if you can",
-		Font:       "sans bold 12",
-		Opacity:    0.5,
-		Width:      200,
-		DPI:        100,
-		Margin:     100,
-		Background: Color{255, 255, 255},
-	}
-
-	newImg, err := vipsWatermark(image, watermark)
-	if err != nil {
-		t.Errorf("Cannot add watermark: %s", err)
-	}
-
-	buf, _ := vipsSave(newImg, vipsSaveOptions{Quality: 95})
-	if len(buf) == 0 {
-		t.Fatal("Empty image")
-	}
-}
-
-func TestVipsWatermarkWithImage(t *testing.T) {
-	image, _, _ := vipsRead(readImage("test.jpg"))
-
-	watermark := readImage("transparent.png")
-
-	options := WatermarkImage{Left: 100, Top: 100, Opacity: 1.0, Buf: watermark}
-	newImg, err := vipsDrawWatermark(image, options)
-	if err != nil {
-		t.Errorf("Cannot add watermark: %s", err)
-	}
-
-	buf, _ := vipsSave(newImg, vipsSaveOptions{Quality: 95})
-	if len(buf) == 0 {
-		t.Fatal("Empty image")
-	}
-}
-
-func TestVipsImageType(t *testing.T) {
-	imgType := vipsImageType(readImage("test.jpg"))
-	if imgType != JPEG {
-		t.Fatal("Invalid image type")
-	}
-}
-
-func TestVipsImageTypeInvalid(t *testing.T) {
-	imgType := vipsImageType([]byte("vip"))
-	if imgType != UNKNOWN {
-		t.Fatal("Invalid image type")
-	}
-}
-
-func TestVipsMemory(t *testing.T) {
-	mem := VipsMemory()
-
-	if mem.Memory < 1024 {
-		t.Fatal("Invalid memory")
-	}
-	if mem.Allocations == 0 {
-		t.Fatal("Invalid memory allocations")
-	}
-}
-
-func readImage(file string) []byte {
-	img, _ := os.Open(path.Join("fixtures", file))
-	buf, _ := ioutil.ReadAll(img)
-	defer img.Close()
-	return buf
-}

vendor/github.com/tj/go-debug/History.md

@@ -1,21 +0,0 @@
-
-v2.0.0 / 2014-10-22
-==================
-
- * remove live toggling feature. Closes #10
-
-1.1.1 / 2014-07-07
-==================
-
- * fix: dispose socket. Closes #1
-
-1.1.0 / 2014-06-29
-==================
-
- * add unix domain socket live debugging support
- * add support for enabling/disabling at runtime
-
-0.1.0 / 2014-05-24
-==================
-
- * add global and debug relative deltas

vendor/github.com/tj/go-debug/Makefile

@@ -1,8 +0,0 @@
-
-test:
-	@go test
-
-bench:
-	@go test -bench=.
-
-.PHONY: bench test

vendor/github.com/tj/go-debug/Readme.md

@@ -1,75 +0,0 @@
-
-# go-debug
-
- Conditional debug logging for Go libraries.
-
- View the [docs](http://godoc.org/github.com/tj/go-debug).
-
-## Installation
-
-```
-$ go get github.com/tj/go-debug
-```
-
-## Example
-
-```go
-package main
-
-import . "github.com/tj/go-debug"
-import "time"
-
-var debug = Debug("single")
-
-func main() {
-  for {
-    debug("sending mail")
-    debug("send email to %s", "tobi@segment.io")
-    debug("send email to %s", "loki@segment.io")
-    debug("send email to %s", "jane@segment.io")
-    time.Sleep(500 * time.Millisecond)
-  }
-}
-```
-
-If you run the program with the `DEBUG=*` environment variable you will see:
-
-```
-15:58:15.115 34us   33us   single - sending mail
-15:58:15.116 3us    3us    single - send email to tobi@segment.io
-15:58:15.116 1us    1us    single - send email to loki@segment.io
-15:58:15.116 1us    1us    single - send email to jane@segment.io
-15:58:15.620 504ms  504ms  single - sending mail
-15:58:15.620 6us    6us    single - send email to tobi@segment.io
-15:58:15.620 4us    4us    single - send email to loki@segment.io
-15:58:15.620 4us    4us    single - send email to jane@segment.io
-15:58:16.123 503ms  503ms  single - sending mail
-15:58:16.123 7us    7us    single - send email to tobi@segment.io
-15:58:16.123 4us    4us    single - send email to loki@segment.io
-15:58:16.123 4us    4us    single - send email to jane@segment.io
-15:58:16.625 501ms  501ms  single - sending mail
-15:58:16.625 4us    4us    single - send email to tobi@segment.io
-15:58:16.625 4us    4us    single - send email to loki@segment.io
-15:58:16.625 5us    5us    single - send email to jane@segment.io
-```
-
-A timestamp and two deltas are displayed. The timestamp consists of hour, minute, second and microseconds. The left-most delta is relative to the previous debug call of any name, followed by a delta specific to that debug function. These may be useful to identify timing issues and potential bottlenecks.
-
-## The DEBUG environment variable
-
- Executables often support `--verbose` flags for conditional logging, however
- libraries typically either require altering your code to enable logging,
- or simply omit logging all together. go-debug allows conditional logging
- to be enabled via the __DEBUG__ environment variable, where one or more
- patterns may be specified.
-
- For example suppose your application has several models and you want
- to output logs for users only, you might use `DEBUG=models:user`. In contrast
- if you wanted to see what all database activity was you might use `DEBUG=models:*`,
- or if you're love being swamped with logs: `DEBUG=*`. You may also specify a list of names delimited by a comma, for example `DEBUG=mongo,redis:*`.
-
- The name given _should_ be the package name, however you can use whatever you like.
-
-# License
-
-MIT

vendor/github.com/tj/go-debug/debug.go

@@ -1,128 +0,0 @@
-package debug
-
-import (
-	"fmt"
-	"io"
-	"math/rand"
-	"os"
-	"regexp"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-)
-
-var (
-	writer  io.Writer = os.Stderr
-	reg     *regexp.Regexp
-	m       sync.Mutex
-	enabled = false
-)
-
-// Debugger function.
-type DebugFunction func(string, ...interface{})
-
-// Terminal colors used at random.
-var colors []string = []string{
-	"31",
-	"32",
-	"33",
-	"34",
-	"35",
-	"36",
-}
-
-// Initialize with DEBUG environment variable.
-func init() {
-	env := os.Getenv("DEBUG")
-
-	if "" != env {
-		Enable(env)
-	}
-}
-
-// SetWriter replaces the default of os.Stderr with `w`.
-func SetWriter(w io.Writer) {
-	m.Lock()
-	defer m.Unlock()
-	writer = w
-}
-
-// Disable all pattern matching. This function is thread-safe.
-func Disable() {
-	m.Lock()
-	defer m.Unlock()
-	enabled = false
-}
-
-// Enable the given debug `pattern`. Patterns take a glob-like form,
-// for example if you wanted to enable everything, just use "*", or
-// if you had a library named mongodb you could use "mongodb:connection",
-// or "mongodb:*". Multiple matches can be made with a comma, for
-// example "mongo*,redis*".
-//
-// This function is thread-safe.
-func Enable(pattern string) {
-	m.Lock()
-	defer m.Unlock()
-	pattern = regexp.QuoteMeta(pattern)
-	pattern = strings.Replace(pattern, "\\*", ".*?", -1)
-	pattern = strings.Replace(pattern, ",", "|", -1)
-	pattern = "^(" + pattern + ")$"
-	reg = regexp.MustCompile(pattern)
-	enabled = true
-}
-
-// Debug creates a debug function for `name` which you call
-// with printf-style arguments in your application or library.
-func Debug(name string) DebugFunction {
-	prevGlobal := time.Now()
-	color := colors[rand.Intn(len(colors))]
-	prev := time.Now()
-
-	return func(format string, args ...interface{}) {
-		if !enabled {
-			return
-		}
-
-		if !reg.MatchString(name) {
-			return
-		}
-
-		d := deltas(prevGlobal, prev, color)
-		fmt.Fprintf(writer, d+" \033["+color+"m"+name+"\033[0m - "+format+"\n", args...)
-		prevGlobal = time.Now()
-		prev = time.Now()
-	}
-}
-
-// Return formatting for deltas.
-func deltas(prevGlobal, prev time.Time, color string) string {
-	now := time.Now()
-	global := now.Sub(prevGlobal).Nanoseconds()
-	delta := now.Sub(prev).Nanoseconds()
-	ts := now.UTC().Format("15:04:05.000")
-	deltas := fmt.Sprintf("%s %-6s \033["+color+"m%-6s", ts, humanizeNano(global), humanizeNano(delta))
-	return deltas
-}
-
-// Humanize nanoseconds to a string.
-func humanizeNano(n int64) string {
-	var suffix string
-
-	switch {
-	case n > 1e9:
-		n /= 1e9
-		suffix = "s"
-	case n > 1e6:
-		n /= 1e6
-		suffix = "ms"
-	case n > 1e3:
-		n /= 1e3
-		suffix = "us"
-	default:
-		suffix = "ns"
-	}
-
-	return strconv.Itoa(int(n)) + suffix
-}

vendor/github.com/tj/go-debug/debug_test.go

@@ -1,152 +0,0 @@
-package debug
-
-import "testing"
-import "strings"
-import "bytes"
-import "time"
-
-func assertContains(t *testing.T, str, substr string) {
-	if !strings.Contains(str, substr) {
-		t.Fatalf("expected %q to contain %q", str, substr)
-	}
-}
-
-func assertNotContains(t *testing.T, str, substr string) {
-	if strings.Contains(str, substr) {
-		t.Fatalf("expected %q to not contain %q", str, substr)
-	}
-}
-
-func TestDefault(t *testing.T) {
-	var b []byte
-	buf := bytes.NewBuffer(b)
-	SetWriter(buf)
-
-	debug := Debug("foo")
-	debug("something")
-	debug("here")
-	debug("whoop")
-
-	if buf.Len() != 0 {
-		t.Fatalf("buffer should be empty")
-	}
-}
-
-func TestEnable(t *testing.T) {
-	var b []byte
-	buf := bytes.NewBuffer(b)
-	SetWriter(buf)
-
-	Enable("foo")
-
-	debug := Debug("foo")
-	debug("something")
-	debug("here")
-	debug("whoop")
-
-	if buf.Len() == 0 {
-		t.Fatalf("buffer should have output")
-	}
-
-	str := string(buf.Bytes())
-	assertContains(t, str, "something")
-	assertContains(t, str, "here")
-	assertContains(t, str, "whoop")
-}
-
-func TestMultipleOneEnabled(t *testing.T) {
-	var b []byte
-	buf := bytes.NewBuffer(b)
-	SetWriter(buf)
-
-	Enable("foo")
-
-	foo := Debug("foo")
-	foo("foo")
-
-	bar := Debug("bar")
-	bar("bar")
-
-	if buf.Len() == 0 {
-		t.Fatalf("buffer should have output")
-	}
-
-	str := string(buf.Bytes())
-	assertContains(t, str, "foo")
-	assertNotContains(t, str, "bar")
-}
-
-func TestMultipleEnabled(t *testing.T) {
-	var b []byte
-	buf := bytes.NewBuffer(b)
-	SetWriter(buf)
-
-	Enable("foo,bar")
-
-	foo := Debug("foo")
-	foo("foo")
-
-	bar := Debug("bar")
-	bar("bar")
-
-	if buf.Len() == 0 {
-		t.Fatalf("buffer should have output")
-	}
-
-	str := string(buf.Bytes())
-	assertContains(t, str, "foo")
-	assertContains(t, str, "bar")
-}
-
-func TestEnableDisable(t *testing.T) {
-	var b []byte
-	buf := bytes.NewBuffer(b)
-	SetWriter(buf)
-
-	Enable("foo,bar")
-	Disable()
-
-	foo := Debug("foo")
-	foo("foo")
-
-	bar := Debug("bar")
-	bar("bar")
-
-	if buf.Len() != 0 {
-		t.Fatalf("buffer should not have output")
-	}
-}
-
-func ExampleEnable() {
-	Enable("mongo:connection")
-	Enable("mongo:*")
-	Enable("foo,bar,baz")
-	Enable("*")
-}
-
-func ExampleDebug() {
-	var debug = Debug("single")
-
-	for {
-		debug("sending mail")
-		debug("send email to %s", "tobi@segment.io")
-		debug("send email to %s", "loki@segment.io")
-		debug("send email to %s", "jane@segment.io")
-		time.Sleep(500 * time.Millisecond)
-	}
-}
-
-func BenchmarkDisabled(b *testing.B) {
-	debug := Debug("something")
-	for i := 0; i < b.N; i++ {
-		debug("stuff")
-	}
-}
-
-func BenchmarkNonMatch(b *testing.B) {
-	debug := Debug("something")
-	Enable("nonmatch")
-	for i := 0; i < b.N; i++ {
-		debug("stuff")
-	}
-}

vendor/github.com/tj/go-debug/example/multiple.go

@@ -1,25 +0,0 @@
-package main
-
-import . "github.com/visionmedia/go-debug"
-import "time"
-
-var a = Debug("multiple:a")
-var b = Debug("multiple:b")
-var c = Debug("multiple:c")
-
-func work(debug DebugFunction, delay time.Duration) {
-	for {
-		debug("doing stuff")
-		time.Sleep(delay)
-	}
-}
-
-func main() {
-	q := make(chan bool)
-
-	go work(a, 1000*time.Millisecond)
-	go work(b, 250*time.Millisecond)
-	go work(c, 100*time.Millisecond)
-
-	<-q
-}

vendor/github.com/tj/go-debug/example/single.go

@@ -1,16 +0,0 @@
-package main
-
-import . "github.com/visionmedia/go-debug"
-import "time"
-
-var debug = Debug("single")
-
-func main() {
-	for {
-		debug("sending mail")
-		debug("send email to %s", "tobi@segment.io")
-		debug("send email to %s", "loki@segment.io")
-		debug("send email to %s", "jane@segment.io")
-		time.Sleep(500 * time.Millisecond)
-	}
-}

vendor/golang.org/x/image/README

@@ -1,3 +0,0 @@
-This repository holds supplementary Go image libraries.
-
-To submit changes to this repository, see http://golang.org/doc/contribute.html.

vendor/golang.org/x/image/README.md

@@ -0,0 +1,17 @@
+# Go Images
+
+This repository holds supplementary Go image libraries.
+
+## Download/Install
+
+The easiest way to install is to run `go get -u golang.org/x/image`. You can
+also manually git clone the repository to `$GOPATH/src/golang.org/x/image`.
+
+## Report Issues / Send Patches
+
+This repository uses Gerrit for code changes. To learn how to submit changes to
+this repository, see https://golang.org/doc/contribute.html.
+
+The main issue tracker for the image repository is located at
+https://github.com/golang/go/issues. Prefix your issue with "x/image:" in the
+subject line, so it is easy to find.

vendor/golang.org/x/net/README

@@ -1,3 +0,0 @@
-This repository holds supplementary Go networking libraries.
-
-To submit changes to this repository, see http://golang.org/doc/contribute.html.

vendor/golang.org/x/net/README.md

@@ -0,0 +1,16 @@
+# Go Networking
+
+This repository holds supplementary Go networking libraries.
+
+## Download/Install
+
+The easiest way to install is to run `go get -u golang.org/x/net`. You can
+also manually git clone the repository to `$GOPATH/src/golang.org/x/net`.
+
+## Report Issues / Send Patches
+
+This repository uses Gerrit for code changes. To learn how to submit
+changes to this repository, see https://golang.org/doc/contribute.html.
+The main issue tracker for the net repository is located at
+https://github.com/golang/go/issues. Prefix your issue with "x/net:" in the
+subject line, so it is easy to find.

vendor/golang.org/x/net/html/atom/gen.go

@@ -4,17 +4,17 @@
 
 // +build ignore
 
-package main
+//go:generate go run gen.go
+//go:generate go run gen.go -test
 
-// This program generates table.go and table_test.go.
-// Invoke as
-//
-//	go run gen.go |gofmt >table.go
-//	go run gen.go -test |gofmt >table_test.go
+package main
 
 import (
+	"bytes"
 	"flag"
 	"fmt"
+	"go/format"
+	"io/ioutil"
 	"math/rand"
 	"os"
 	"sort"
@@ -42,6 +42,18 @@ func identifier(s string) string {
 
 var test = flag.Bool("test", false, "generate table_test.go")
 
+func genFile(name string, buf *bytes.Buffer) {
+	b, err := format.Source(buf.Bytes())
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+	if err := ioutil.WriteFile(name, b, 0644); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
 func main() {
 	flag.Parse()
 
@@ -52,32 +64,31 @@ func main() {
 	all = append(all, extra...)
 	sort.Strings(all)
 
-	if *test {
-		fmt.Printf("// generated by go run gen.go -test; DO NOT EDIT\n\n")
-		fmt.Printf("package atom\n\n")
-		fmt.Printf("var testAtomList = []string{\n")
-		for _, s := range all {
-			fmt.Printf("\t%q,\n", s)
-		}
-		fmt.Printf("}\n")
-		return
-	}
-
 	// uniq - lists have dups
-	// compute max len too
-	maxLen := 0
 	w := 0
 	for _, s := range all {
 		if w == 0 || all[w-1] != s {
-			if maxLen < len(s) {
-				maxLen = len(s)
-			}
 			all[w] = s
 			w++
 		}
 	}
 	all = all[:w]
 
+	if *test {
+		var buf bytes.Buffer
+		fmt.Fprintln(&buf, "// Code generated by go generate gen.go; DO NOT EDIT.\n")
+		fmt.Fprintln(&buf, "//go:generate go run gen.go -test\n")
+		fmt.Fprintln(&buf, "package atom\n")
+		fmt.Fprintln(&buf, "var testAtomList = []string{")
+		for _, s := range all {
+			fmt.Fprintf(&buf, "\t%q,\n", s)
+		}
+		fmt.Fprintln(&buf, "}")
+
+		genFile("table_test.go", &buf)
+		return
+	}
+
 	// Find hash that minimizes table size.
 	var best *table
 	for i := 0; i < 1000000; i++ {
@@ -163,36 +174,46 @@ func main() {
 		atom[s] = uint32(off<<8 | len(s))
 	}
 
+	var buf bytes.Buffer
 	// Generate the Go code.
-	fmt.Printf("// generated by go run gen.go; DO NOT EDIT\n\n")
-	fmt.Printf("package atom\n\nconst (\n")
+	fmt.Fprintln(&buf, "// Code generated by go generate gen.go; DO NOT EDIT.\n")
+	fmt.Fprintln(&buf, "//go:generate go run gen.go\n")
+	fmt.Fprintln(&buf, "package atom\n\nconst (")
+
+	// compute max len
+	maxLen := 0
 	for _, s := range all {
-		fmt.Printf("\t%s Atom = %#x\n", identifier(s), atom[s])
+		if maxLen < len(s) {
+			maxLen = len(s)
+		}
+		fmt.Fprintf(&buf, "\t%s Atom = %#x\n", identifier(s), atom[s])
 	}
-	fmt.Printf(")\n\n")
+	fmt.Fprintln(&buf, ")\n")
 
-	fmt.Printf("const hash0 = %#x\n\n", best.h0)
-	fmt.Printf("const maxAtomLen = %d\n\n", maxLen)
+	fmt.Fprintf(&buf, "const hash0 = %#x\n\n", best.h0)
+	fmt.Fprintf(&buf, "const maxAtomLen = %d\n\n", maxLen)
 
-	fmt.Printf("var table = [1<<%d]Atom{\n", best.k)
+	fmt.Fprintf(&buf, "var table = [1<<%d]Atom{\n", best.k)
 	for i, s := range best.tab {
 		if s == "" {
 			continue
 		}
-		fmt.Printf("\t%#x: %#x, // %s\n", i, atom[s], s)
+		fmt.Fprintf(&buf, "\t%#x: %#x, // %s\n", i, atom[s], s)
 	}
-	fmt.Printf("}\n")
+	fmt.Fprintf(&buf, "}\n")
 	datasize := (1 << best.k) * 4
 
-	fmt.Printf("const atomText =\n")
+	fmt.Fprintln(&buf, "const atomText =")
 	textsize := len(text)
 	for len(text) > 60 {
-		fmt.Printf("\t%q +\n", text[:60])
+		fmt.Fprintf(&buf, "\t%q +\n", text[:60])
 		text = text[60:]
 	}
-	fmt.Printf("\t%q\n\n", text)
+	fmt.Fprintf(&buf, "\t%q\n\n", text)
+
+	genFile("table.go", &buf)
 
-	fmt.Fprintf(os.Stderr, "%d atoms; %d string bytes + %d tables = %d total data\n", len(all), textsize, datasize, textsize+datasize)
+	fmt.Fprintf(os.Stdout, "%d atoms; %d string bytes + %d tables = %d total data\n", len(all), textsize, datasize, textsize+datasize)
 }
 
 type byLen []string
@@ -285,8 +306,10 @@ func (t *table) push(i uint32, depth int) bool {
 
 // The lists of element names and attribute keys were taken from
 // https://html.spec.whatwg.org/multipage/indices.html#index
-// as of the "HTML Living Standard - Last Updated 21 February 2015" version.
+// as of the "HTML Living Standard - Last Updated 18 September 2017" version.
 
+// "command", "keygen" and "menuitem" have been removed from the spec,
+// but are kept here for backwards compatibility.
 var elements = []string{
 	"a",
 	"abbr",
@@ -349,6 +372,7 @@ var elements = []string{
 	"legend",
 	"li",
 	"link",
+	"main",
 	"map",
 	"mark",
 	"menu",
@@ -364,6 +388,7 @@ var elements = []string{
 	"output",
 	"p",
 	"param",
+	"picture",
 	"pre",
 	"progress",
 	"q",
@@ -375,6 +400,7 @@ var elements = []string{
 	"script",
 	"section",
 	"select",
+	"slot",
 	"small",
 	"source",
 	"span",
@@ -403,14 +429,21 @@ var elements = []string{
 }
 
 // https://html.spec.whatwg.org/multipage/indices.html#attributes-3
-
+//
+// "challenge", "command", "contextmenu", "dropzone", "icon", "keytype", "mediagroup",
+// "radiogroup", "spellcheck", "scoped", "seamless", "sortable" and "sorted" have been removed from the spec,
+// but are kept here for backwards compatibility.
 var attributes = []string{
 	"abbr",
 	"accept",
 	"accept-charset",
 	"accesskey",
 	"action",
+	"allowfullscreen",
+	"allowpaymentrequest",
+	"allowusermedia",
 	"alt",
+	"as",
 	"async",
 	"autocomplete",
 	"autofocus",
@@ -420,6 +453,7 @@ var attributes = []string{
 	"checked",
 	"cite",
 	"class",
+	"color",
 	"cols",
 	"colspan",
 	"command",
@@ -457,6 +491,8 @@ var attributes = []string{
 	"icon",
 	"id",
 	"inputmode",
+	"integrity",
+	"is",
 	"ismap",
 	"itemid",
 	"itemprop",
@@ -481,16 +517,20 @@ var attributes = []string{
 	"multiple",
 	"muted",
 	"name",
+	"nomodule",
+	"nonce",
 	"novalidate",
 	"open",
 	"optimum",
 	"pattern",
 	"ping",
 	"placeholder",
+	"playsinline",
 	"poster",
 	"preload",
 	"radiogroup",
 	"readonly",
+	"referrerpolicy",
 	"rel",
 	"required",
 	"reversed",
@@ -507,10 +547,13 @@ var attributes = []string{
 	"sizes",
 	"sortable",
 	"sorted",
+	"slot",
 	"span",
+	"spellcheck",
 	"src",
 	"srcdoc",
 	"srclang",
+	"srcset",
 	"start",
 	"step",
 	"style",
@@ -520,16 +563,22 @@ var attributes = []string{
 	"translate",
 	"type",
 	"typemustmatch",
+	"updateviacache",
 	"usemap",
 	"value",
 	"width",
+	"workertype",
 	"wrap",
 }
 
+// "onautocomplete", "onautocompleteerror", "onmousewheel",
+// "onshow" and "onsort" have been removed from the spec,
+// but are kept here for backwards compatibility.
 var eventHandlers = []string{
 	"onabort",
 	"onautocomplete",
 	"onautocompleteerror",
+	"onauxclick",
 	"onafterprint",
 	"onbeforeprint",
 	"onbeforeunload",
@@ -541,11 +590,14 @@ var eventHandlers = []string{
 	"onclick",
 	"onclose",
 	"oncontextmenu",
+	"oncopy",
 	"oncuechange",
+	"oncut",
 	"ondblclick",
 	"ondrag",
 	"ondragend",
 	"ondragenter",
+	"ondragexit",
 	"ondragleave",
 	"ondragover",
 	"ondragstart",
@@ -565,18 +617,24 @@ var eventHandlers = []string{
 	"onload",
 	"onloadeddata",
 	"onloadedmetadata",
+	"onloadend",
 	"onloadstart",
 	"onmessage",
+	"onmessageerror",
 	"onmousedown",
+	"onmouseenter",
+	"onmouseleave",
 	"onmousemove",
 	"onmouseout",
 	"onmouseover",
 	"onmouseup",
 	"onmousewheel",
+	"onwheel",
 	"onoffline",
 	"ononline",
 	"onpagehide",
 	"onpageshow",
+	"onpaste",
 	"onpause",
 	"onplay",
 	"onplaying",
@@ -585,7 +643,9 @@ var eventHandlers = []string{
 	"onratechange",
 	"onreset",
 	"onresize",
+	"onrejectionhandled",
 	"onscroll",
+	"onsecuritypolicyviolation",
 	"onseeked",
 	"onseeking",
 	"onselect",
@@ -597,6 +657,7 @@ var eventHandlers = []string{
 	"onsuspend",
 	"ontimeupdate",
 	"ontoggle",
+	"onunhandledrejection",
 	"onunload",
 	"onvolumechange",
 	"onwaiting",

vendor/golang.org/x/net/html/atom/table.go

@@ -1,713 +1,777 @@
-// generated by go run gen.go; DO NOT EDIT
+// Code generated by go generate gen.go; DO NOT EDIT.
+
+//go:generate go run gen.go
 
 package atom
 
 const (
-	A                   Atom = 0x1
-	Abbr                Atom = 0x4
-	Accept              Atom = 0x2106
-	AcceptCharset       Atom = 0x210e
-	Accesskey           Atom = 0x3309
-	Action              Atom = 0x1f606
-	Address             Atom = 0x4f307
-	Align               Atom = 0x1105
-	Alt                 Atom = 0x4503
-	Annotation          Atom = 0x1670a
-	AnnotationXml       Atom = 0x1670e
-	Applet              Atom = 0x2b306
-	Area                Atom = 0x2fa04
-	Article             Atom = 0x38807
-	Aside               Atom = 0x8305
-	Async               Atom = 0x7b05
-	Audio               Atom = 0xa605
-	Autocomplete        Atom = 0x1fc0c
-	Autofocus           Atom = 0xb309
-	Autoplay            Atom = 0xce08
-	B                   Atom = 0x101
-	Base                Atom = 0xd604
-	Basefont            Atom = 0xd608
-	Bdi                 Atom = 0x1a03
-	Bdo                 Atom = 0xe703
-	Bgsound             Atom = 0x11807
-	Big                 Atom = 0x12403
-	Blink               Atom = 0x12705
-	Blockquote          Atom = 0x12c0a
-	Body                Atom = 0x2f04
-	Br                  Atom = 0x202
-	Button              Atom = 0x13606
-	Canvas              Atom = 0x7f06
-	Caption             Atom = 0x1bb07
-	Center              Atom = 0x5b506
-	Challenge           Atom = 0x21f09
-	Charset             Atom = 0x2807
-	Checked             Atom = 0x32807
-	Cite                Atom = 0x3c804
-	Class               Atom = 0x4de05
-	Code                Atom = 0x14904
-	Col                 Atom = 0x15003
-	Colgroup            Atom = 0x15008
-	Color               Atom = 0x15d05
-	Cols                Atom = 0x16204
-	Colspan             Atom = 0x16207
-	Command             Atom = 0x17507
-	Content             Atom = 0x42307
-	Contenteditable     Atom = 0x4230f
-	Contextmenu         Atom = 0x3310b
-	Controls            Atom = 0x18808
-	Coords              Atom = 0x19406
-	Crossorigin         Atom = 0x19f0b
-	Data                Atom = 0x44a04
-	Datalist            Atom = 0x44a08
-	Datetime            Atom = 0x23c08
-	Dd                  Atom = 0x26702
-	Default             Atom = 0x8607
-	Defer               Atom = 0x14b05
-	Del                 Atom = 0x3ef03
-	Desc                Atom = 0x4db04
-	Details             Atom = 0x4807
-	Dfn                 Atom = 0x6103
-	Dialog              Atom = 0x1b06
-	Dir                 Atom = 0x6903
-	Dirname             Atom = 0x6907
-	Disabled            Atom = 0x10c08
-	Div                 Atom = 0x11303
-	Dl                  Atom = 0x11e02
-	Download            Atom = 0x40008
-	Draggable           Atom = 0x17b09
-	Dropzone            Atom = 0x39108
-	Dt                  Atom = 0x50902
-	Em                  Atom = 0x6502
-	Embed               Atom = 0x6505
-	Enctype             Atom = 0x21107
-	Face                Atom = 0x5b304
-	Fieldset            Atom = 0x1b008
-	Figcaption          Atom = 0x1b80a
-	Figure              Atom = 0x1cc06
-	Font                Atom = 0xda04
-	Footer              Atom = 0x8d06
-	For                 Atom = 0x1d803
-	ForeignObject       Atom = 0x1d80d
-	Foreignobject       Atom = 0x1e50d
-	Form                Atom = 0x1f204
-	Formaction          Atom = 0x1f20a
-	Formenctype         Atom = 0x20d0b
-	Formmethod          Atom = 0x2280a
-	Formnovalidate      Atom = 0x2320e
-	Formtarget          Atom = 0x2470a
-	Frame               Atom = 0x9a05
-	Frameset            Atom = 0x9a08
-	H1                  Atom = 0x26e02
-	H2                  Atom = 0x29402
-	H3                  Atom = 0x2a702
-	H4                  Atom = 0x2e902
-	H5                  Atom = 0x2f302
-	H6                  Atom = 0x50b02
-	Head                Atom = 0x2d504
-	Header              Atom = 0x2d506
-	Headers             Atom = 0x2d507
-	Height              Atom = 0x25106
-	Hgroup              Atom = 0x25906
-	Hidden              Atom = 0x26506
-	High                Atom = 0x26b04
-	Hr                  Atom = 0x27002
-	Href                Atom = 0x27004
-	Hreflang            Atom = 0x27008
-	Html                Atom = 0x25504
-	HttpEquiv           Atom = 0x2780a
-	I                   Atom = 0x601
-	Icon                Atom = 0x42204
-	Id                  Atom = 0x8502
-	Iframe              Atom = 0x29606
-	Image               Atom = 0x29c05
-	Img                 Atom = 0x2a103
-	Input               Atom = 0x3e805
-	Inputmode           Atom = 0x3e809
-	Ins                 Atom = 0x1a803
-	Isindex             Atom = 0x2a907
-	Ismap               Atom = 0x2b005
-	Itemid              Atom = 0x33c06
-	Itemprop            Atom = 0x3c908
-	Itemref             Atom = 0x5ad07
-	Itemscope           Atom = 0x2b909
-	Itemtype            Atom = 0x2c308
-	Kbd                 Atom = 0x1903
-	Keygen              Atom = 0x3906
-	Keytype             Atom = 0x53707
-	Kind                Atom = 0x10904
-	Label               Atom = 0xf005
-	Lang                Atom = 0x27404
-	Legend              Atom = 0x18206
-	Li                  Atom = 0x1202
-	Link                Atom = 0x12804
-	List                Atom = 0x44e04
-	Listing             Atom = 0x44e07
-	Loop                Atom = 0xf404
-	Low                 Atom = 0x11f03
-	Malignmark          Atom = 0x100a
-	Manifest            Atom = 0x5f108
-	Map                 Atom = 0x2b203
-	Mark                Atom = 0x1604
-	Marquee             Atom = 0x2cb07
-	Math                Atom = 0x2d204
-	Max                 Atom = 0x2e103
-	Maxlength           Atom = 0x2e109
-	Media               Atom = 0x6e05
-	Mediagroup          Atom = 0x6e0a
-	Menu                Atom = 0x33804
-	Menuitem            Atom = 0x33808
-	Meta                Atom = 0x45d04
-	Meter               Atom = 0x24205
-	Method              Atom = 0x22c06
-	Mglyph              Atom = 0x2a206
-	Mi                  Atom = 0x2eb02
-	Min                 Atom = 0x2eb03
-	Minlength           Atom = 0x2eb09
-	Mn                  Atom = 0x23502
-	Mo                  Atom = 0x3ed02
-	Ms                  Atom = 0x2bc02
-	Mtext               Atom = 0x2f505
-	Multiple            Atom = 0x30308
-	Muted               Atom = 0x30b05
-	Name                Atom = 0x6c04
-	Nav                 Atom = 0x3e03
-	Nobr                Atom = 0x5704
-	Noembed             Atom = 0x6307
-	Noframes            Atom = 0x9808
-	Noscript            Atom = 0x3d208
-	Novalidate          Atom = 0x2360a
-	Object              Atom = 0x1ec06
-	Ol                  Atom = 0xc902
-	Onabort             Atom = 0x13a07
-	Onafterprint        Atom = 0x1c00c
-	Onautocomplete      Atom = 0x1fa0e
-	Onautocompleteerror Atom = 0x1fa13
-	Onbeforeprint       Atom = 0x6040d
-	Onbeforeunload      Atom = 0x4e70e
-	Onblur              Atom = 0xaa06
-	Oncancel            Atom = 0xe908
-	Oncanplay           Atom = 0x28509
-	Oncanplaythrough    Atom = 0x28510
-	Onchange            Atom = 0x3a708
-	Onclick             Atom = 0x31007
-	Onclose             Atom = 0x31707
-	Oncontextmenu       Atom = 0x32f0d
-	Oncuechange         Atom = 0x3420b
-	Ondblclick          Atom = 0x34d0a
-	Ondrag              Atom = 0x35706
-	Ondragend           Atom = 0x35709
-	Ondragenter         Atom = 0x3600b
-	Ondragleave         Atom = 0x36b0b
-	Ondragover          Atom = 0x3760a
-	Ondragstart         Atom = 0x3800b
-	Ondrop              Atom = 0x38f06
-	Ondurationchange    Atom = 0x39f10
-	Onemptied           Atom = 0x39609
-	Onended             Atom = 0x3af07
-	Onerror             Atom = 0x3b607
-	Onfocus             Atom = 0x3bd07
-	Onhashchange        Atom = 0x3da0c
-	Oninput             Atom = 0x3e607
-	Oninvalid           Atom = 0x3f209
-	Onkeydown           Atom = 0x3fb09
-	Onkeypress          Atom = 0x4080a
-	Onkeyup             Atom = 0x41807
-	Onlanguagechange    Atom = 0x43210
-	Onload              Atom = 0x44206
-	Onloadeddata        Atom = 0x4420c
-	Onloadedmetadata    Atom = 0x45510
-	Onloadstart         Atom = 0x46b0b
-	Onmessage           Atom = 0x47609
-	Onmousedown         Atom = 0x47f0b
-	Onmousemove         Atom = 0x48a0b
-	Onmouseout          Atom = 0x4950a
-	Onmouseover         Atom = 0x4a20b
-	Onmouseup           Atom = 0x4ad09
-	Onmousewheel        Atom = 0x4b60c
-	Onoffline           Atom = 0x4c209
-	Ononline            Atom = 0x4cb08
-	Onpagehide          Atom = 0x4d30a
-	Onpageshow          Atom = 0x4fe0a
-	Onpause             Atom = 0x50d07
-	Onplay              Atom = 0x51706
-	Onplaying           Atom = 0x51709
-	Onpopstate          Atom = 0x5200a
-	Onprogress          Atom = 0x52a0a
-	Onratechange        Atom = 0x53e0c
-	Onreset             Atom = 0x54a07
-	Onresize            Atom = 0x55108
-	Onscroll            Atom = 0x55f08
-	Onseeked            Atom = 0x56708
-	Onseeking           Atom = 0x56f09
-	Onselect            Atom = 0x57808
-	Onshow              Atom = 0x58206
-	Onsort              Atom = 0x58b06
-	Onstalled           Atom = 0x59509
-	Onstorage           Atom = 0x59e09
-	Onsubmit            Atom = 0x5a708
-	Onsuspend           Atom = 0x5bb09
-	Ontimeupdate        Atom = 0xdb0c
-	Ontoggle            Atom = 0x5c408
-	Onunload            Atom = 0x5cc08
-	Onvolumechange      Atom = 0x5d40e
-	Onwaiting           Atom = 0x5e209
-	Open                Atom = 0x3cf04
-	Optgroup            Atom = 0xf608
-	Optimum             Atom = 0x5eb07
-	Option              Atom = 0x60006
-	Output              Atom = 0x49c06
-	P                   Atom = 0xc01
-	Param               Atom = 0xc05
-	Pattern             Atom = 0x5107
-	Ping                Atom = 0x7704
-	Placeholder         Atom = 0xc30b
-	Plaintext           Atom = 0xfd09
-	Poster              Atom = 0x15706
-	Pre                 Atom = 0x25e03
-	Preload             Atom = 0x25e07
-	Progress            Atom = 0x52c08
-	Prompt              Atom = 0x5fa06
-	Public              Atom = 0x41e06
-	Q                   Atom = 0x13101
-	Radiogroup          Atom = 0x30a
-	Readonly            Atom = 0x2fb08
-	Rel                 Atom = 0x25f03
-	Required            Atom = 0x1d008
-	Reversed            Atom = 0x5a08
-	Rows                Atom = 0x9204
-	Rowspan             Atom = 0x9207
-	Rp                  Atom = 0x1c602
-	Rt                  Atom = 0x13f02
-	Ruby                Atom = 0xaf04
-	S                   Atom = 0x2c01
-	Samp                Atom = 0x4e04
-	Sandbox             Atom = 0xbb07
-	Scope               Atom = 0x2bd05
-	Scoped              Atom = 0x2bd06
-	Script              Atom = 0x3d406
-	Seamless            Atom = 0x31c08
-	Section             Atom = 0x4e207
-	Select              Atom = 0x57a06
-	Selected            Atom = 0x57a08
-	Shape               Atom = 0x4f905
-	Size                Atom = 0x55504
-	Sizes               Atom = 0x55505
-	Small               Atom = 0x18f05
-	Sortable            Atom = 0x58d08
-	Sorted              Atom = 0x19906
-	Source              Atom = 0x1aa06
-	Spacer              Atom = 0x2db06
-	Span                Atom = 0x9504
-	Spellcheck          Atom = 0x3230a
-	Src                 Atom = 0x3c303
-	Srcdoc              Atom = 0x3c306
-	Srclang             Atom = 0x41107
-	Start               Atom = 0x38605
-	Step                Atom = 0x5f704
-	Strike              Atom = 0x53306
-	Strong              Atom = 0x55906
-	Style               Atom = 0x61105
-	Sub                 Atom = 0x5a903
-	Summary             Atom = 0x61607
-	Sup                 Atom = 0x61d03
-	Svg                 Atom = 0x62003
-	System              Atom = 0x62306
-	Tabindex            Atom = 0x46308
-	Table               Atom = 0x42d05
-	Target              Atom = 0x24b06
-	Tbody               Atom = 0x2e05
-	Td                  Atom = 0x4702
-	Template            Atom = 0x62608
-	Textarea            Atom = 0x2f608
-	Tfoot               Atom = 0x8c05
-	Th                  Atom = 0x22e02
-	Thead               Atom = 0x2d405
-	Time                Atom = 0xdd04
-	Title               Atom = 0xa105
-	Tr                  Atom = 0x10502
-	Track               Atom = 0x10505
-	Translate           Atom = 0x14009
-	Tt                  Atom = 0x5302
-	Type                Atom = 0x21404
-	Typemustmatch       Atom = 0x2140d
-	U                   Atom = 0xb01
-	Ul                  Atom = 0x8a02
-	Usemap              Atom = 0x51106
-	Value               Atom = 0x4005
-	Var                 Atom = 0x11503
-	Video               Atom = 0x28105
-	Wbr                 Atom = 0x12103
-	Width               Atom = 0x50705
-	Wrap                Atom = 0x58704
-	Xmp                 Atom = 0xc103
+	A                         Atom = 0x1
+	Abbr                      Atom = 0x4
+	Accept                    Atom = 0x1a06
+	AcceptCharset             Atom = 0x1a0e
+	Accesskey                 Atom = 0x2c09
+	Action                    Atom = 0x25a06
+	Address                   Atom = 0x6ed07
+	Align                     Atom = 0x6d405
+	Allowfullscreen           Atom = 0x1f00f
+	Allowpaymentrequest       Atom = 0x6913
+	Allowusermedia            Atom = 0x850e
+	Alt                       Atom = 0xb003
+	Annotation                Atom = 0x1b90a
+	AnnotationXml             Atom = 0x1b90e
+	Applet                    Atom = 0x30106
+	Area                      Atom = 0x34a04
+	Article                   Atom = 0x3f007
+	As                        Atom = 0xb902
+	Aside                     Atom = 0xc105
+	Async                     Atom = 0xb905
+	Audio                     Atom = 0xcf05
+	Autocomplete              Atom = 0x2600c
+	Autofocus                 Atom = 0xeb09
+	Autoplay                  Atom = 0x10608
+	B                         Atom = 0x101
+	Base                      Atom = 0x11504
+	Basefont                  Atom = 0x11508
+	Bdi                       Atom = 0x16103
+	Bdo                       Atom = 0x13403
+	Bgsound                   Atom = 0x14707
+	Big                       Atom = 0x15903
+	Blink                     Atom = 0x15c05
+	Blockquote                Atom = 0x1680a
+	Body                      Atom = 0x2804
+	Br                        Atom = 0x202
+	Button                    Atom = 0x17206
+	Canvas                    Atom = 0xbd06
+	Caption                   Atom = 0x21907
+	Center                    Atom = 0x20806
+	Challenge                 Atom = 0x28309
+	Charset                   Atom = 0x2107
+	Checked                   Atom = 0x46d07
+	Cite                      Atom = 0x55804
+	Class                     Atom = 0x5b905
+	Code                      Atom = 0x19004
+	Col                       Atom = 0x19703
+	Colgroup                  Atom = 0x19708
+	Color                     Atom = 0x1af05
+	Cols                      Atom = 0x1b404
+	Colspan                   Atom = 0x1b407
+	Command                   Atom = 0x1c707
+	Content                   Atom = 0x57f07
+	Contenteditable           Atom = 0x57f0f
+	Contextmenu               Atom = 0x3740b
+	Controls                  Atom = 0x1ce08
+	Coords                    Atom = 0x1da06
+	Crossorigin               Atom = 0x1e30b
+	Data                      Atom = 0x49904
+	Datalist                  Atom = 0x49908
+	Datetime                  Atom = 0x2a008
+	Dd                        Atom = 0x2bf02
+	Default                   Atom = 0xc407
+	Defer                     Atom = 0x19205
+	Del                       Atom = 0x44603
+	Desc                      Atom = 0x55504
+	Details                   Atom = 0x4607
+	Dfn                       Atom = 0x5f03
+	Dialog                    Atom = 0x16206
+	Dir                       Atom = 0xa303
+	Dirname                   Atom = 0xa307
+	Disabled                  Atom = 0x14d08
+	Div                       Atom = 0x15403
+	Dl                        Atom = 0x5e202
+	Download                  Atom = 0x45708
+	Draggable                 Atom = 0x18309
+	Dropzone                  Atom = 0x3f908
+	Dt                        Atom = 0x64702
+	Em                        Atom = 0x4202
+	Embed                     Atom = 0x4205
+	Enctype                   Atom = 0x27507
+	Face                      Atom = 0x20604
+	Fieldset                  Atom = 0x20e08
+	Figcaption                Atom = 0x2160a
+	Figure                    Atom = 0x23006
+	Font                      Atom = 0x11904
+	Footer                    Atom = 0xb306
+	For                       Atom = 0x23c03
+	ForeignObject             Atom = 0x23c0d
+	Foreignobject             Atom = 0x2490d
+	Form                      Atom = 0x25604
+	Formaction                Atom = 0x2560a
+	Formenctype               Atom = 0x2710b
+	Formmethod                Atom = 0x28c0a
+	Formnovalidate            Atom = 0x2960e
+	Formtarget                Atom = 0x2a80a
+	Frame                     Atom = 0x5705
+	Frameset                  Atom = 0x5708
+	H1                        Atom = 0x14502
+	H2                        Atom = 0x2c602
+	H3                        Atom = 0x2f502
+	H4                        Atom = 0x33902
+	H5                        Atom = 0x34302
+	H6                        Atom = 0x64902
+	Head                      Atom = 0x32504
+	Header                    Atom = 0x32506
+	Headers                   Atom = 0x32507
+	Height                    Atom = 0x12c06
+	Hgroup                    Atom = 0x2b206
+	Hidden                    Atom = 0x2bd06
+	High                      Atom = 0x2c304
+	Hr                        Atom = 0x14002
+	Href                      Atom = 0x2c804
+	Hreflang                  Atom = 0x2c808
+	Html                      Atom = 0x13004
+	HttpEquiv                 Atom = 0x2d00a
+	I                         Atom = 0x601
+	Icon                      Atom = 0x57e04
+	Id                        Atom = 0xc302
+	Iframe                    Atom = 0x2e406
+	Image                     Atom = 0x2ea05
+	Img                       Atom = 0x2ef03
+	Input                     Atom = 0x43f05
+	Inputmode                 Atom = 0x43f09
+	Ins                       Atom = 0x1ec03
+	Integrity                 Atom = 0x22709
+	Is                        Atom = 0x14e02
+	Isindex                   Atom = 0x2f707
+	Ismap                     Atom = 0x2fe05
+	Itemid                    Atom = 0x37f06
+	Itemprop                  Atom = 0x55908
+	Itemref                   Atom = 0x3c107
+	Itemscope                 Atom = 0x66d09
+	Itemtype                  Atom = 0x30708
+	Kbd                       Atom = 0x16003
+	Keygen                    Atom = 0x3206
+	Keytype                   Atom = 0x7e07
+	Kind                      Atom = 0x18004
+	Label                     Atom = 0xda05
+	Lang                      Atom = 0x2cc04
+	Legend                    Atom = 0x18a06
+	Li                        Atom = 0x11102
+	Link                      Atom = 0x15d04
+	List                      Atom = 0x49d04
+	Listing                   Atom = 0x49d07
+	Loop                      Atom = 0xde04
+	Low                       Atom = 0x6b03
+	Main                      Atom = 0x1004
+	Malignmark                Atom = 0x6d30a
+	Manifest                  Atom = 0x30f08
+	Map                       Atom = 0x30003
+	Mark                      Atom = 0x6d904
+	Marquee                   Atom = 0x31b07
+	Math                      Atom = 0x32204
+	Max                       Atom = 0x33103
+	Maxlength                 Atom = 0x33109
+	Media                     Atom = 0x8e05
+	Mediagroup                Atom = 0x8e0a
+	Menu                      Atom = 0x37b04
+	Menuitem                  Atom = 0x37b08
+	Meta                      Atom = 0x4ac04
+	Meter                     Atom = 0xa805
+	Method                    Atom = 0x29006
+	Mglyph                    Atom = 0x2f006
+	Mi                        Atom = 0x33b02
+	Min                       Atom = 0x33b03
+	Minlength                 Atom = 0x33b09
+	Mn                        Atom = 0x29902
+	Mo                        Atom = 0x6302
+	Ms                        Atom = 0x67002
+	Mtext                     Atom = 0x34505
+	Multiple                  Atom = 0x35308
+	Muted                     Atom = 0x35b05
+	Name                      Atom = 0xa604
+	Nav                       Atom = 0x1303
+	Nobr                      Atom = 0x3704
+	Noembed                   Atom = 0x4007
+	Noframes                  Atom = 0x5508
+	Nomodule                  Atom = 0x6108
+	Nonce                     Atom = 0x56205
+	Noscript                  Atom = 0x1fe08
+	Novalidate                Atom = 0x29a0a
+	Object                    Atom = 0x25006
+	Ol                        Atom = 0x10102
+	Onabort                   Atom = 0x17607
+	Onafterprint              Atom = 0x21e0c
+	Onautocomplete            Atom = 0x25e0e
+	Onautocompleteerror       Atom = 0x25e13
+	Onauxclick                Atom = 0x61b0a
+	Onbeforeprint             Atom = 0x69a0d
+	Onbeforeunload            Atom = 0x6e10e
+	Onblur                    Atom = 0x5c206
+	Oncancel                  Atom = 0xd308
+	Oncanplay                 Atom = 0x13609
+	Oncanplaythrough          Atom = 0x13610
+	Onchange                  Atom = 0x40f08
+	Onclick                   Atom = 0x2dd07
+	Onclose                   Atom = 0x36007
+	Oncontextmenu             Atom = 0x3720d
+	Oncopy                    Atom = 0x38506
+	Oncuechange               Atom = 0x38b0b
+	Oncut                     Atom = 0x39605
+	Ondblclick                Atom = 0x39b0a
+	Ondrag                    Atom = 0x3a506
+	Ondragend                 Atom = 0x3a509
+	Ondragenter               Atom = 0x3ae0b
+	Ondragexit                Atom = 0x3b90a
+	Ondragleave               Atom = 0x3d30b
+	Ondragover                Atom = 0x3de0a
+	Ondragstart               Atom = 0x3e80b
+	Ondrop                    Atom = 0x3f706
+	Ondurationchange          Atom = 0x40710
+	Onemptied                 Atom = 0x3fe09
+	Onended                   Atom = 0x41707
+	Onerror                   Atom = 0x41e07
+	Onfocus                   Atom = 0x42507
+	Onhashchange              Atom = 0x4310c
+	Oninput                   Atom = 0x43d07
+	Oninvalid                 Atom = 0x44909
+	Onkeydown                 Atom = 0x45209
+	Onkeypress                Atom = 0x45f0a
+	Onkeyup                   Atom = 0x47407
+	Onlanguagechange          Atom = 0x48110
+	Onload                    Atom = 0x49106
+	Onloadeddata              Atom = 0x4910c
+	Onloadedmetadata          Atom = 0x4a410
+	Onloadend                 Atom = 0x4ba09
+	Onloadstart               Atom = 0x4c30b
+	Onmessage                 Atom = 0x4ce09
+	Onmessageerror            Atom = 0x4ce0e
+	Onmousedown               Atom = 0x4dc0b
+	Onmouseenter              Atom = 0x4e70c
+	Onmouseleave              Atom = 0x4f30c
+	Onmousemove               Atom = 0x4ff0b
+	Onmouseout                Atom = 0x50a0a
+	Onmouseover               Atom = 0x5170b
+	Onmouseup                 Atom = 0x52209
+	Onmousewheel              Atom = 0x5300c
+	Onoffline                 Atom = 0x53c09
+	Ononline                  Atom = 0x54508
+	Onpagehide                Atom = 0x54d0a
+	Onpageshow                Atom = 0x5670a
+	Onpaste                   Atom = 0x57307
+	Onpause                   Atom = 0x58e07
+	Onplay                    Atom = 0x59806
+	Onplaying                 Atom = 0x59809
+	Onpopstate                Atom = 0x5a10a
+	Onprogress                Atom = 0x5ab0a
+	Onratechange              Atom = 0x5c80c
+	Onrejectionhandled        Atom = 0x5d412
+	Onreset                   Atom = 0x5e607
+	Onresize                  Atom = 0x5ed08
+	Onscroll                  Atom = 0x5fc08
+	Onsecuritypolicyviolation Atom = 0x60419
+	Onseeked                  Atom = 0x62508
+	Onseeking                 Atom = 0x62d09
+	Onselect                  Atom = 0x63608
+	Onshow                    Atom = 0x64006
+	Onsort                    Atom = 0x64b06
+	Onstalled                 Atom = 0x65509
+	Onstorage                 Atom = 0x65e09
+	Onsubmit                  Atom = 0x66708
+	Onsuspend                 Atom = 0x67709
+	Ontimeupdate              Atom = 0x11a0c
+	Ontoggle                  Atom = 0x68008
+	Onunhandledrejection      Atom = 0x68814
+	Onunload                  Atom = 0x6a708
+	Onvolumechange            Atom = 0x6af0e
+	Onwaiting                 Atom = 0x6bd09
+	Onwheel                   Atom = 0x6c607
+	Open                      Atom = 0x55f04
+	Optgroup                  Atom = 0xe008
+	Optimum                   Atom = 0x6cd07
+	Option                    Atom = 0x6dd06
+	Output                    Atom = 0x51106
+	P                         Atom = 0xc01
+	Param                     Atom = 0xc05
+	Pattern                   Atom = 0x4f07
+	Picture                   Atom = 0x9707
+	Ping                      Atom = 0xe704
+	Placeholder               Atom = 0xfb0b
+	Plaintext                 Atom = 0x19e09
+	Playsinline               Atom = 0x10a0b
+	Poster                    Atom = 0x2b706
+	Pre                       Atom = 0x46403
+	Preload                   Atom = 0x47a07
+	Progress                  Atom = 0x5ad08
+	Prompt                    Atom = 0x52a06
+	Public                    Atom = 0x57a06
+	Q                         Atom = 0x7701
+	Radiogroup                Atom = 0x30a
+	Readonly                  Atom = 0x34b08
+	Referrerpolicy            Atom = 0x3c50e
+	Rel                       Atom = 0x47b03
+	Required                  Atom = 0x23408
+	Reversed                  Atom = 0x9c08
+	Rows                      Atom = 0x3a04
+	Rowspan                   Atom = 0x3a07
+	Rp                        Atom = 0x22402
+	Rt                        Atom = 0x17b02
+	Ruby                      Atom = 0xac04
+	S                         Atom = 0x2501
+	Samp                      Atom = 0x4c04
+	Sandbox                   Atom = 0xf307
+	Scope                     Atom = 0x67105
+	Scoped                    Atom = 0x67106
+	Script                    Atom = 0x20006
+	Seamless                  Atom = 0x36508
+	Section                   Atom = 0x5bd07
+	Select                    Atom = 0x63806
+	Selected                  Atom = 0x63808
+	Shape                     Atom = 0x1d505
+	Size                      Atom = 0x5f104
+	Sizes                     Atom = 0x5f105
+	Slot                      Atom = 0x1df04
+	Small                     Atom = 0x1ee05
+	Sortable                  Atom = 0x64d08
+	Sorted                    Atom = 0x32b06
+	Source                    Atom = 0x36c06
+	Spacer                    Atom = 0x42b06
+	Span                      Atom = 0x3d04
+	Spellcheck                Atom = 0x4680a
+	Src                       Atom = 0x5b403
+	Srcdoc                    Atom = 0x5b406
+	Srclang                   Atom = 0x5f507
+	Srcset                    Atom = 0x6f306
+	Start                     Atom = 0x3ee05
+	Step                      Atom = 0x57704
+	Strike                    Atom = 0x7a06
+	Strong                    Atom = 0x31506
+	Style                     Atom = 0x6f905
+	Sub                       Atom = 0x66903
+	Summary                   Atom = 0x6fe07
+	Sup                       Atom = 0x70503
+	Svg                       Atom = 0x70803
+	System                    Atom = 0x70b06
+	Tabindex                  Atom = 0x4b208
+	Table                     Atom = 0x58905
+	Target                    Atom = 0x2ac06
+	Tbody                     Atom = 0x2705
+	Td                        Atom = 0x5e02
+	Template                  Atom = 0x70e08
+	Textarea                  Atom = 0x34608
+	Tfoot                     Atom = 0xb205
+	Th                        Atom = 0x13f02
+	Thead                     Atom = 0x32405
+	Time                      Atom = 0x11c04
+	Title                     Atom = 0xca05
+	Tr                        Atom = 0x7402
+	Track                     Atom = 0x17c05
+	Translate                 Atom = 0x1a609
+	Tt                        Atom = 0x5102
+	Type                      Atom = 0x8104
+	Typemustmatch             Atom = 0x2780d
+	U                         Atom = 0xb01
+	Ul                        Atom = 0x6602
+	Updateviacache            Atom = 0x1200e
+	Usemap                    Atom = 0x59206
+	Value                     Atom = 0x1505
+	Var                       Atom = 0x15603
+	Video                     Atom = 0x2d905
+	Wbr                       Atom = 0x57003
+	Width                     Atom = 0x64505
+	Workertype                Atom = 0x7160a
+	Wrap                      Atom = 0x72004
+	Xmp                       Atom = 0xf903
 )
 
-const hash0 = 0xc17da63e
+const hash0 = 0x81cdf10e
 
-const maxAtomLen = 19
+const maxAtomLen = 25
 
 var table = [1 << 9]Atom{
-	0x1:   0x48a0b, // onmousemove
-	0x2:   0x5e209, // onwaiting
-	0x3:   0x1fa13, // onautocompleteerror
-	0x4:   0x5fa06, // prompt
-	0x7:   0x5eb07, // optimum
-	0x8:   0x1604,  // mark
-	0xa:   0x5ad07, // itemref
-	0xb:   0x4fe0a, // onpageshow
-	0xc:   0x57a06, // select
-	0xd:   0x17b09, // draggable
-	0xe:   0x3e03,  // nav
-	0xf:   0x17507, // command
-	0x11:  0xb01,   // u
-	0x14:  0x2d507, // headers
-	0x15:  0x44a08, // datalist
-	0x17:  0x4e04,  // samp
-	0x1a:  0x3fb09, // onkeydown
-	0x1b:  0x55f08, // onscroll
-	0x1c:  0x15003, // col
-	0x20:  0x3c908, // itemprop
-	0x21:  0x2780a, // http-equiv
-	0x22:  0x61d03, // sup
-	0x24:  0x1d008, // required
-	0x2b:  0x25e07, // preload
-	0x2c:  0x6040d, // onbeforeprint
-	0x2d:  0x3600b, // ondragenter
-	0x2e:  0x50902, // dt
-	0x2f:  0x5a708, // onsubmit
-	0x30:  0x27002, // hr
-	0x31:  0x32f0d, // oncontextmenu
-	0x33:  0x29c05, // image
-	0x34:  0x50d07, // onpause
-	0x35:  0x25906, // hgroup
-	0x36:  0x7704,  // ping
-	0x37:  0x57808, // onselect
-	0x3a:  0x11303, // div
-	0x3b:  0x1fa0e, // onautocomplete
-	0x40:  0x2eb02, // mi
-	0x41:  0x31c08, // seamless
-	0x42:  0x2807,  // charset
-	0x43:  0x8502,  // id
-	0x44:  0x5200a, // onpopstate
-	0x45:  0x3ef03, // del
-	0x46:  0x2cb07, // marquee
-	0x47:  0x3309,  // accesskey
-	0x49:  0x8d06,  // footer
-	0x4a:  0x44e04, // list
-	0x4b:  0x2b005, // ismap
-	0x51:  0x33804, // menu
-	0x52:  0x2f04,  // body
-	0x55:  0x9a08,  // frameset
-	0x56:  0x54a07, // onreset
-	0x57:  0x12705, // blink
-	0x58:  0xa105,  // title
-	0x59:  0x38807, // article
-	0x5b:  0x22e02, // th
-	0x5d:  0x13101, // q
-	0x5e:  0x3cf04, // open
-	0x5f:  0x2fa04, // area
-	0x61:  0x44206, // onload
-	0x62:  0xda04,  // font
-	0x63:  0xd604,  // base
-	0x64:  0x16207, // colspan
-	0x65:  0x53707, // keytype
-	0x66:  0x11e02, // dl
-	0x68:  0x1b008, // fieldset
-	0x6a:  0x2eb03, // min
-	0x6b:  0x11503, // var
-	0x6f:  0x2d506, // header
-	0x70:  0x13f02, // rt
-	0x71:  0x15008, // colgroup
-	0x72:  0x23502, // mn
-	0x74:  0x13a07, // onabort
-	0x75:  0x3906,  // keygen
-	0x76:  0x4c209, // onoffline
-	0x77:  0x21f09, // challenge
-	0x78:  0x2b203, // map
-	0x7a:  0x2e902, // h4
-	0x7b:  0x3b607, // onerror
-	0x7c:  0x2e109, // maxlength
-	0x7d:  0x2f505, // mtext
-	0x7e:  0xbb07,  // sandbox
-	0x7f:  0x58b06, // onsort
-	0x80:  0x100a,  // malignmark
-	0x81:  0x45d04, // meta
-	0x82:  0x7b05,  // async
-	0x83:  0x2a702, // h3
-	0x84:  0x26702, // dd
-	0x85:  0x27004, // href
-	0x86:  0x6e0a,  // mediagroup
-	0x87:  0x19406, // coords
-	0x88:  0x41107, // srclang
-	0x89:  0x34d0a, // ondblclick
-	0x8a:  0x4005,  // value
-	0x8c:  0xe908,  // oncancel
-	0x8e:  0x3230a, // spellcheck
-	0x8f:  0x9a05,  // frame
-	0x91:  0x12403, // big
-	0x94:  0x1f606, // action
-	0x95:  0x6903,  // dir
-	0x97:  0x2fb08, // readonly
-	0x99:  0x42d05, // table
-	0x9a:  0x61607, // summary
-	0x9b:  0x12103, // wbr
-	0x9c:  0x30a,   // radiogroup
-	0x9d:  0x6c04,  // name
-	0x9f:  0x62306, // system
-	0xa1:  0x15d05, // color
-	0xa2:  0x7f06,  // canvas
-	0xa3:  0x25504, // html
-	0xa5:  0x56f09, // onseeking
-	0xac:  0x4f905, // shape
-	0xad:  0x25f03, // rel
-	0xae:  0x28510, // oncanplaythrough
-	0xaf:  0x3760a, // ondragover
-	0xb0:  0x62608, // template
-	0xb1:  0x1d80d, // foreignObject
-	0xb3:  0x9204,  // rows
-	0xb6:  0x44e07, // listing
-	0xb7:  0x49c06, // output
-	0xb9:  0x3310b, // contextmenu
-	0xbb:  0x11f03, // low
-	0xbc:  0x1c602, // rp
-	0xbd:  0x5bb09, // onsuspend
-	0xbe:  0x13606, // button
-	0xbf:  0x4db04, // desc
-	0xc1:  0x4e207, // section
-	0xc2:  0x52a0a, // onprogress
-	0xc3:  0x59e09, // onstorage
-	0xc4:  0x2d204, // math
-	0xc5:  0x4503,  // alt
-	0xc7:  0x8a02,  // ul
-	0xc8:  0x5107,  // pattern
-	0xc9:  0x4b60c, // onmousewheel
-	0xca:  0x35709, // ondragend
-	0xcb:  0xaf04,  // ruby
-	0xcc:  0xc01,   // p
-	0xcd:  0x31707, // onclose
-	0xce:  0x24205, // meter
-	0xcf:  0x11807, // bgsound
-	0xd2:  0x25106, // height
-	0xd4:  0x101,   // b
-	0xd5:  0x2c308, // itemtype
-	0xd8:  0x1bb07, // caption
-	0xd9:  0x10c08, // disabled
-	0xdb:  0x33808, // menuitem
-	0xdc:  0x62003, // svg
-	0xdd:  0x18f05, // small
-	0xde:  0x44a04, // data
-	0xe0:  0x4cb08, // ononline
-	0xe1:  0x2a206, // mglyph
-	0xe3:  0x6505,  // embed
-	0xe4:  0x10502, // tr
-	0xe5:  0x46b0b, // onloadstart
-	0xe7:  0x3c306, // srcdoc
-	0xeb:  0x5c408, // ontoggle
-	0xed:  0xe703,  // bdo
-	0xee:  0x4702,  // td
-	0xef:  0x8305,  // aside
-	0xf0:  0x29402, // h2
-	0xf1:  0x52c08, // progress
-	0xf2:  0x12c0a, // blockquote
-	0xf4:  0xf005,  // label
-	0xf5:  0x601,   // i
-	0xf7:  0x9207,  // rowspan
-	0xfb:  0x51709, // onplaying
-	0xfd:  0x2a103, // img
-	0xfe:  0xf608,  // optgroup
-	0xff:  0x42307, // content
-	0x101: 0x53e0c, // onratechange
-	0x103: 0x3da0c, // onhashchange
-	0x104: 0x4807,  // details
-	0x106: 0x40008, // download
-	0x109: 0x14009, // translate
-	0x10b: 0x4230f, // contenteditable
-	0x10d: 0x36b0b, // ondragleave
-	0x10e: 0x2106,  // accept
-	0x10f: 0x57a08, // selected
-	0x112: 0x1f20a, // formaction
-	0x113: 0x5b506, // center
-	0x115: 0x45510, // onloadedmetadata
-	0x116: 0x12804, // link
-	0x117: 0xdd04,  // time
-	0x118: 0x19f0b, // crossorigin
-	0x119: 0x3bd07, // onfocus
-	0x11a: 0x58704, // wrap
-	0x11b: 0x42204, // icon
-	0x11d: 0x28105, // video
-	0x11e: 0x4de05, // class
-	0x121: 0x5d40e, // onvolumechange
-	0x122: 0xaa06,  // onblur
-	0x123: 0x2b909, // itemscope
-	0x124: 0x61105, // style
-	0x127: 0x41e06, // public
-	0x129: 0x2320e, // formnovalidate
-	0x12a: 0x58206, // onshow
-	0x12c: 0x51706, // onplay
-	0x12d: 0x3c804, // cite
-	0x12e: 0x2bc02, // ms
-	0x12f: 0xdb0c,  // ontimeupdate
-	0x130: 0x10904, // kind
-	0x131: 0x2470a, // formtarget
-	0x135: 0x3af07, // onended
-	0x136: 0x26506, // hidden
-	0x137: 0x2c01,  // s
-	0x139: 0x2280a, // formmethod
-	0x13a: 0x3e805, // input
-	0x13c: 0x50b02, // h6
-	0x13d: 0xc902,  // ol
-	0x13e: 0x3420b, // oncuechange
-	0x13f: 0x1e50d, // foreignobject
-	0x143: 0x4e70e, // onbeforeunload
-	0x144: 0x2bd05, // scope
-	0x145: 0x39609, // onemptied
-	0x146: 0x14b05, // defer
-	0x147: 0xc103,  // xmp
-	0x148: 0x39f10, // ondurationchange
-	0x149: 0x1903,  // kbd
-	0x14c: 0x47609, // onmessage
-	0x14d: 0x60006, // option
-	0x14e: 0x2eb09, // minlength
-	0x14f: 0x32807, // checked
-	0x150: 0xce08,  // autoplay
-	0x152: 0x202,   // br
-	0x153: 0x2360a, // novalidate
-	0x156: 0x6307,  // noembed
-	0x159: 0x31007, // onclick
-	0x15a: 0x47f0b, // onmousedown
-	0x15b: 0x3a708, // onchange
-	0x15e: 0x3f209, // oninvalid
-	0x15f: 0x2bd06, // scoped
-	0x160: 0x18808, // controls
-	0x161: 0x30b05, // muted
-	0x162: 0x58d08, // sortable
-	0x163: 0x51106, // usemap
-	0x164: 0x1b80a, // figcaption
-	0x165: 0x35706, // ondrag
-	0x166: 0x26b04, // high
-	0x168: 0x3c303, // src
-	0x169: 0x15706, // poster
-	0x16b: 0x1670e, // annotation-xml
-	0x16c: 0x5f704, // step
-	0x16d: 0x4,     // abbr
-	0x16e: 0x1b06,  // dialog
-	0x170: 0x1202,  // li
-	0x172: 0x3ed02, // mo
-	0x175: 0x1d803, // for
-	0x176: 0x1a803, // ins
-	0x178: 0x55504, // size
-	0x179: 0x43210, // onlanguagechange
-	0x17a: 0x8607,  // default
-	0x17b: 0x1a03,  // bdi
-	0x17c: 0x4d30a, // onpagehide
-	0x17d: 0x6907,  // dirname
-	0x17e: 0x21404, // type
-	0x17f: 0x1f204, // form
-	0x181: 0x28509, // oncanplay
-	0x182: 0x6103,  // dfn
-	0x183: 0x46308, // tabindex
-	0x186: 0x6502,  // em
-	0x187: 0x27404, // lang
-	0x189: 0x39108, // dropzone
-	0x18a: 0x4080a, // onkeypress
-	0x18b: 0x23c08, // datetime
-	0x18c: 0x16204, // cols
-	0x18d: 0x1,     // a
-	0x18e: 0x4420c, // onloadeddata
-	0x190: 0xa605,  // audio
-	0x192: 0x2e05,  // tbody
-	0x193: 0x22c06, // method
-	0x195: 0xf404,  // loop
-	0x196: 0x29606, // iframe
-	0x198: 0x2d504, // head
-	0x19e: 0x5f108, // manifest
-	0x19f: 0xb309,  // autofocus
-	0x1a0: 0x14904, // code
-	0x1a1: 0x55906, // strong
-	0x1a2: 0x30308, // multiple
-	0x1a3: 0xc05,   // param
-	0x1a6: 0x21107, // enctype
-	0x1a7: 0x5b304, // face
-	0x1a8: 0xfd09,  // plaintext
-	0x1a9: 0x26e02, // h1
-	0x1aa: 0x59509, // onstalled
-	0x1ad: 0x3d406, // script
-	0x1ae: 0x2db06, // spacer
-	0x1af: 0x55108, // onresize
-	0x1b0: 0x4a20b, // onmouseover
-	0x1b1: 0x5cc08, // onunload
-	0x1b2: 0x56708, // onseeked
-	0x1b4: 0x2140d, // typemustmatch
-	0x1b5: 0x1cc06, // figure
-	0x1b6: 0x4950a, // onmouseout
-	0x1b7: 0x25e03, // pre
-	0x1b8: 0x50705, // width
-	0x1b9: 0x19906, // sorted
-	0x1bb: 0x5704,  // nobr
-	0x1be: 0x5302,  // tt
-	0x1bf: 0x1105,  // align
-	0x1c0: 0x3e607, // oninput
-	0x1c3: 0x41807, // onkeyup
-	0x1c6: 0x1c00c, // onafterprint
-	0x1c7: 0x210e,  // accept-charset
-	0x1c8: 0x33c06, // itemid
-	0x1c9: 0x3e809, // inputmode
-	0x1cb: 0x53306, // strike
-	0x1cc: 0x5a903, // sub
-	0x1cd: 0x10505, // track
-	0x1ce: 0x38605, // start
-	0x1d0: 0xd608,  // basefont
-	0x1d6: 0x1aa06, // source
-	0x1d7: 0x18206, // legend
-	0x1d8: 0x2d405, // thead
-	0x1da: 0x8c05,  // tfoot
-	0x1dd: 0x1ec06, // object
-	0x1de: 0x6e05,  // media
-	0x1df: 0x1670a, // annotation
-	0x1e0: 0x20d0b, // formenctype
-	0x1e2: 0x3d208, // noscript
-	0x1e4: 0x55505, // sizes
-	0x1e5: 0x1fc0c, // autocomplete
-	0x1e6: 0x9504,  // span
-	0x1e7: 0x9808,  // noframes
-	0x1e8: 0x24b06, // target
-	0x1e9: 0x38f06, // ondrop
-	0x1ea: 0x2b306, // applet
-	0x1ec: 0x5a08,  // reversed
-	0x1f0: 0x2a907, // isindex
-	0x1f3: 0x27008, // hreflang
-	0x1f5: 0x2f302, // h5
-	0x1f6: 0x4f307, // address
-	0x1fa: 0x2e103, // max
-	0x1fb: 0xc30b,  // placeholder
-	0x1fc: 0x2f608, // textarea
-	0x1fe: 0x4ad09, // onmouseup
-	0x1ff: 0x3800b, // ondragstart
+	0x1:   0x8e0a,  // mediagroup
+	0x2:   0x2cc04, // lang
+	0x4:   0x2c09,  // accesskey
+	0x5:   0x5708,  // frameset
+	0x7:   0x63608, // onselect
+	0x8:   0x70b06, // system
+	0xa:   0x64505, // width
+	0xc:   0x2710b, // formenctype
+	0xd:   0x10102, // ol
+	0xe:   0x38b0b, // oncuechange
+	0x10:  0x13403, // bdo
+	0x11:  0xcf05,  // audio
+	0x12:  0x18309, // draggable
+	0x14:  0x2d905, // video
+	0x15:  0x29902, // mn
+	0x16:  0x37b04, // menu
+	0x17:  0x2b706, // poster
+	0x19:  0xb306,  // footer
+	0x1a:  0x29006, // method
+	0x1b:  0x2a008, // datetime
+	0x1c:  0x17607, // onabort
+	0x1d:  0x1200e, // updateviacache
+	0x1e:  0xb905,  // async
+	0x1f:  0x49106, // onload
+	0x21:  0xd308,  // oncancel
+	0x22:  0x62508, // onseeked
+	0x23:  0x2ea05, // image
+	0x24:  0x5d412, // onrejectionhandled
+	0x26:  0x15d04, // link
+	0x27:  0x51106, // output
+	0x28:  0x32504, // head
+	0x29:  0x4f30c, // onmouseleave
+	0x2a:  0x57307, // onpaste
+	0x2b:  0x59809, // onplaying
+	0x2c:  0x1b407, // colspan
+	0x2f:  0x1af05, // color
+	0x30:  0x5f104, // size
+	0x31:  0x2d00a, // http-equiv
+	0x33:  0x601,   // i
+	0x34:  0x54d0a, // onpagehide
+	0x35:  0x68814, // onunhandledrejection
+	0x37:  0x41e07, // onerror
+	0x3a:  0x11508, // basefont
+	0x3f:  0x1303,  // nav
+	0x40:  0x18004, // kind
+	0x41:  0x34b08, // readonly
+	0x42:  0x2f006, // mglyph
+	0x44:  0x11102, // li
+	0x46:  0x2bd06, // hidden
+	0x47:  0x70803, // svg
+	0x48:  0x57704, // step
+	0x49:  0x22709, // integrity
+	0x4a:  0x57a06, // public
+	0x4c:  0x19703, // col
+	0x4d:  0x1680a, // blockquote
+	0x4e:  0x34302, // h5
+	0x50:  0x5ad08, // progress
+	0x51:  0x5f105, // sizes
+	0x52:  0x33902, // h4
+	0x56:  0x32405, // thead
+	0x57:  0x7e07,  // keytype
+	0x58:  0x5ab0a, // onprogress
+	0x59:  0x43f09, // inputmode
+	0x5a:  0x3a509, // ondragend
+	0x5d:  0x39605, // oncut
+	0x5e:  0x42b06, // spacer
+	0x5f:  0x19708, // colgroup
+	0x62:  0x14e02, // is
+	0x65:  0xb902,  // as
+	0x66:  0x53c09, // onoffline
+	0x67:  0x32b06, // sorted
+	0x69:  0x48110, // onlanguagechange
+	0x6c:  0x4310c, // onhashchange
+	0x6d:  0xa604,  // name
+	0x6e:  0xb205,  // tfoot
+	0x6f:  0x55504, // desc
+	0x70:  0x33103, // max
+	0x72:  0x1da06, // coords
+	0x73:  0x2f502, // h3
+	0x74:  0x6e10e, // onbeforeunload
+	0x75:  0x3a04,  // rows
+	0x76:  0x63806, // select
+	0x77:  0xa805,  // meter
+	0x78:  0x37f06, // itemid
+	0x79:  0x5300c, // onmousewheel
+	0x7a:  0x5b406, // srcdoc
+	0x7d:  0x17c05, // track
+	0x7f:  0x30708, // itemtype
+	0x82:  0x6302,  // mo
+	0x83:  0x40f08, // onchange
+	0x84:  0x32507, // headers
+	0x85:  0x5c80c, // onratechange
+	0x86:  0x60419, // onsecuritypolicyviolation
+	0x88:  0x49908, // datalist
+	0x89:  0x4dc0b, // onmousedown
+	0x8a:  0x1df04, // slot
+	0x8b:  0x4a410, // onloadedmetadata
+	0x8c:  0x1a06,  // accept
+	0x8d:  0x25006, // object
+	0x91:  0x6af0e, // onvolumechange
+	0x92:  0x2107,  // charset
+	0x93:  0x25e13, // onautocompleteerror
+	0x94:  0x6913,  // allowpaymentrequest
+	0x95:  0x2804,  // body
+	0x96:  0xc407,  // default
+	0x97:  0x63808, // selected
+	0x98:  0x20604, // face
+	0x99:  0x1d505, // shape
+	0x9b:  0x68008, // ontoggle
+	0x9e:  0x64702, // dt
+	0x9f:  0x6d904, // mark
+	0xa1:  0xb01,   // u
+	0xa4:  0x6a708, // onunload
+	0xa5:  0xde04,  // loop
+	0xa6:  0x14d08, // disabled
+	0xaa:  0x41707, // onended
+	0xab:  0x6d30a, // malignmark
+	0xad:  0x67709, // onsuspend
+	0xae:  0x34505, // mtext
+	0xaf:  0x64b06, // onsort
+	0xb0:  0x55908, // itemprop
+	0xb3:  0x66d09, // itemscope
+	0xb4:  0x15c05, // blink
+	0xb6:  0x3a506, // ondrag
+	0xb7:  0x6602,  // ul
+	0xb8:  0x25604, // form
+	0xb9:  0xf307,  // sandbox
+	0xba:  0x5705,  // frame
+	0xbb:  0x1505,  // value
+	0xbc:  0x65e09, // onstorage
+	0xc0:  0x17b02, // rt
+	0xc2:  0x202,   // br
+	0xc3:  0x20e08, // fieldset
+	0xc4:  0x2780d, // typemustmatch
+	0xc5:  0x6108,  // nomodule
+	0xc6:  0x4007,  // noembed
+	0xc7:  0x69a0d, // onbeforeprint
+	0xc8:  0x17206, // button
+	0xc9:  0x2dd07, // onclick
+	0xca:  0x6fe07, // summary
+	0xcd:  0xac04,  // ruby
+	0xce:  0x5b905, // class
+	0xcf:  0x3e80b, // ondragstart
+	0xd0:  0x21907, // caption
+	0xd4:  0x850e,  // allowusermedia
+	0xd5:  0x4c30b, // onloadstart
+	0xd9:  0x15403, // div
+	0xda:  0x49d04, // list
+	0xdb:  0x32204, // math
+	0xdc:  0x43f05, // input
+	0xdf:  0x3de0a, // ondragover
+	0xe0:  0x2c602, // h2
+	0xe2:  0x19e09, // plaintext
+	0xe4:  0x4e70c, // onmouseenter
+	0xe7:  0x46d07, // checked
+	0xe8:  0x46403, // pre
+	0xea:  0x35308, // multiple
+	0xeb:  0x16103, // bdi
+	0xec:  0x33109, // maxlength
+	0xed:  0x7701,  // q
+	0xee:  0x61b0a, // onauxclick
+	0xf0:  0x57003, // wbr
+	0xf2:  0x11504, // base
+	0xf3:  0x6dd06, // option
+	0xf5:  0x40710, // ondurationchange
+	0xf7:  0x5508,  // noframes
+	0xf9:  0x3f908, // dropzone
+	0xfb:  0x67105, // scope
+	0xfc:  0x9c08,  // reversed
+	0xfd:  0x3ae0b, // ondragenter
+	0xfe:  0x3ee05, // start
+	0xff:  0xf903,  // xmp
+	0x100: 0x5f507, // srclang
+	0x101: 0x2ef03, // img
+	0x104: 0x101,   // b
+	0x105: 0x23c03, // for
+	0x106: 0xc105,  // aside
+	0x107: 0x43d07, // oninput
+	0x108: 0x34a04, // area
+	0x109: 0x28c0a, // formmethod
+	0x10a: 0x72004, // wrap
+	0x10c: 0x22402, // rp
+	0x10d: 0x45f0a, // onkeypress
+	0x10e: 0x5102,  // tt
+	0x110: 0x33b02, // mi
+	0x111: 0x35b05, // muted
+	0x112: 0xb003,  // alt
+	0x113: 0x19004, // code
+	0x114: 0x4202,  // em
+	0x115: 0x3b90a, // ondragexit
+	0x117: 0x3d04,  // span
+	0x119: 0x30f08, // manifest
+	0x11a: 0x37b08, // menuitem
+	0x11b: 0x57f07, // content
+	0x11d: 0x6bd09, // onwaiting
+	0x11f: 0x4ba09, // onloadend
+	0x121: 0x3720d, // oncontextmenu
+	0x123: 0x5c206, // onblur
+	0x124: 0x3f007, // article
+	0x125: 0xa303,  // dir
+	0x126: 0xe704,  // ping
+	0x127: 0x23408, // required
+	0x128: 0x44909, // oninvalid
+	0x129: 0x6d405, // align
+	0x12b: 0x57e04, // icon
+	0x12c: 0x64902, // h6
+	0x12d: 0x1b404, // cols
+	0x12e: 0x2160a, // figcaption
+	0x12f: 0x45209, // onkeydown
+	0x130: 0x66708, // onsubmit
+	0x131: 0x13609, // oncanplay
+	0x132: 0x70503, // sup
+	0x133: 0xc01,   // p
+	0x135: 0x3fe09, // onemptied
+	0x136: 0x38506, // oncopy
+	0x137: 0x55804, // cite
+	0x138: 0x39b0a, // ondblclick
+	0x13a: 0x4ff0b, // onmousemove
+	0x13c: 0x66903, // sub
+	0x13d: 0x47b03, // rel
+	0x13e: 0xe008,  // optgroup
+	0x142: 0x3a07,  // rowspan
+	0x143: 0x36c06, // source
+	0x144: 0x1fe08, // noscript
+	0x145: 0x55f04, // open
+	0x146: 0x1ec03, // ins
+	0x147: 0x23c0d, // foreignObject
+	0x148: 0x5a10a, // onpopstate
+	0x14a: 0x27507, // enctype
+	0x14b: 0x25e0e, // onautocomplete
+	0x14c: 0x34608, // textarea
+	0x14e: 0x2600c, // autocomplete
+	0x14f: 0x14002, // hr
+	0x150: 0x1ce08, // controls
+	0x151: 0xc302,  // id
+	0x153: 0x21e0c, // onafterprint
+	0x155: 0x2490d, // foreignobject
+	0x156: 0x31b07, // marquee
+	0x157: 0x58e07, // onpause
+	0x158: 0x5e202, // dl
+	0x159: 0x12c06, // height
+	0x15a: 0x33b03, // min
+	0x15b: 0xa307,  // dirname
+	0x15c: 0x1a609, // translate
+	0x15d: 0x13004, // html
+	0x15e: 0x33b09, // minlength
+	0x15f: 0x47a07, // preload
+	0x160: 0x70e08, // template
+	0x161: 0x3d30b, // ondragleave
+	0x164: 0x5b403, // src
+	0x165: 0x31506, // strong
+	0x167: 0x4c04,  // samp
+	0x168: 0x6ed07, // address
+	0x169: 0x54508, // ononline
+	0x16b: 0xfb0b,  // placeholder
+	0x16c: 0x2ac06, // target
+	0x16d: 0x1ee05, // small
+	0x16e: 0x6c607, // onwheel
+	0x16f: 0x1b90a, // annotation
+	0x170: 0x4680a, // spellcheck
+	0x171: 0x4607,  // details
+	0x172: 0xbd06,  // canvas
+	0x173: 0xeb09,  // autofocus
+	0x174: 0xc05,   // param
+	0x176: 0x45708, // download
+	0x177: 0x44603, // del
+	0x178: 0x36007, // onclose
+	0x179: 0x16003, // kbd
+	0x17a: 0x30106, // applet
+	0x17b: 0x2c804, // href
+	0x17c: 0x5ed08, // onresize
+	0x17e: 0x4910c, // onloadeddata
+	0x180: 0x7402,  // tr
+	0x181: 0x2a80a, // formtarget
+	0x182: 0xca05,  // title
+	0x183: 0x6f905, // style
+	0x184: 0x7a06,  // strike
+	0x185: 0x59206, // usemap
+	0x186: 0x2e406, // iframe
+	0x187: 0x1004,  // main
+	0x189: 0x9707,  // picture
+	0x18c: 0x2fe05, // ismap
+	0x18e: 0x49904, // data
+	0x18f: 0xda05,  // label
+	0x191: 0x3c50e, // referrerpolicy
+	0x192: 0x13f02, // th
+	0x194: 0x52a06, // prompt
+	0x195: 0x5bd07, // section
+	0x197: 0x6cd07, // optimum
+	0x198: 0x2c304, // high
+	0x199: 0x14502, // h1
+	0x19a: 0x65509, // onstalled
+	0x19b: 0x15603, // var
+	0x19c: 0x11c04, // time
+	0x19e: 0x67002, // ms
+	0x19f: 0x32506, // header
+	0x1a0: 0x4ce09, // onmessage
+	0x1a1: 0x56205, // nonce
+	0x1a2: 0x2560a, // formaction
+	0x1a3: 0x20806, // center
+	0x1a4: 0x3704,  // nobr
+	0x1a5: 0x58905, // table
+	0x1a6: 0x49d07, // listing
+	0x1a7: 0x18a06, // legend
+	0x1a9: 0x28309, // challenge
+	0x1aa: 0x23006, // figure
+	0x1ab: 0x8e05,  // media
+	0x1ae: 0x8104,  // type
+	0x1af: 0x11904, // font
+	0x1b0: 0x4ce0e, // onmessageerror
+	0x1b1: 0x36508, // seamless
+	0x1b2: 0x5f03,  // dfn
+	0x1b3: 0x19205, // defer
+	0x1b4: 0x6b03,  // low
+	0x1b5: 0x62d09, // onseeking
+	0x1b6: 0x5170b, // onmouseover
+	0x1b7: 0x29a0a, // novalidate
+	0x1b8: 0x7160a, // workertype
+	0x1ba: 0x3c107, // itemref
+	0x1bd: 0x1,     // a
+	0x1be: 0x30003, // map
+	0x1bf: 0x11a0c, // ontimeupdate
+	0x1c0: 0x14707, // bgsound
+	0x1c1: 0x3206,  // keygen
+	0x1c2: 0x2705,  // tbody
+	0x1c5: 0x64006, // onshow
+	0x1c7: 0x2501,  // s
+	0x1c8: 0x4f07,  // pattern
+	0x1cc: 0x13610, // oncanplaythrough
+	0x1ce: 0x2bf02, // dd
+	0x1cf: 0x6f306, // srcset
+	0x1d0: 0x15903, // big
+	0x1d2: 0x64d08, // sortable
+	0x1d3: 0x47407, // onkeyup
+	0x1d5: 0x59806, // onplay
+	0x1d7: 0x4ac04, // meta
+	0x1d8: 0x3f706, // ondrop
+	0x1da: 0x5fc08, // onscroll
+	0x1db: 0x1e30b, // crossorigin
+	0x1dc: 0x5670a, // onpageshow
+	0x1dd: 0x4,     // abbr
+	0x1de: 0x5e02,  // td
+	0x1df: 0x57f0f, // contenteditable
+	0x1e0: 0x25a06, // action
+	0x1e1: 0x10a0b, // playsinline
+	0x1e2: 0x42507, // onfocus
+	0x1e3: 0x2c808, // hreflang
+	0x1e5: 0x50a0a, // onmouseout
+	0x1e6: 0x5e607, // onreset
+	0x1e7: 0x10608, // autoplay
+	0x1ea: 0x67106, // scoped
+	0x1ec: 0x30a,   // radiogroup
+	0x1ee: 0x3740b, // contextmenu
+	0x1ef: 0x52209, // onmouseup
+	0x1f1: 0x2b206, // hgroup
+	0x1f2: 0x1f00f, // allowfullscreen
+	0x1f3: 0x4b208, // tabindex
+	0x1f6: 0x2f707, // isindex
+	0x1f7: 0x1a0e,  // accept-charset
+	0x1f8: 0x2960e, // formnovalidate
+	0x1fb: 0x1b90e, // annotation-xml
+	0x1fc: 0x4205,  // embed
+	0x1fd: 0x20006, // script
+	0x1fe: 0x16206, // dialog
+	0x1ff: 0x1c707, // command
 }
 
-const atomText = "abbradiogrouparamalignmarkbdialogaccept-charsetbodyaccesskey" +
-	"genavaluealtdetailsampatternobreversedfnoembedirnamediagroup" +
-	"ingasyncanvasidefaultfooterowspanoframesetitleaudionblurubya" +
-	"utofocusandboxmplaceholderautoplaybasefontimeupdatebdoncance" +
-	"labelooptgrouplaintextrackindisabledivarbgsoundlowbrbigblink" +
-	"blockquotebuttonabortranslatecodefercolgroupostercolorcolspa" +
-	"nnotation-xmlcommandraggablegendcontrolsmallcoordsortedcross" +
-	"originsourcefieldsetfigcaptionafterprintfigurequiredforeignO" +
-	"bjectforeignobjectformactionautocompleteerrorformenctypemust" +
-	"matchallengeformmethodformnovalidatetimeterformtargetheightm" +
-	"lhgroupreloadhiddenhigh1hreflanghttp-equivideoncanplaythroug" +
-	"h2iframeimageimglyph3isindexismappletitemscopeditemtypemarqu" +
-	"eematheaderspacermaxlength4minlength5mtextareadonlymultiplem" +
-	"utedonclickoncloseamlesspellcheckedoncontextmenuitemidoncuec" +
-	"hangeondblclickondragendondragenterondragleaveondragoverondr" +
-	"agstarticleondropzonemptiedondurationchangeonendedonerroronf" +
-	"ocusrcdocitempropenoscriptonhashchangeoninputmodeloninvalido" +
-	"nkeydownloadonkeypressrclangonkeyupublicontenteditableonlang" +
-	"uagechangeonloadeddatalistingonloadedmetadatabindexonloadsta" +
-	"rtonmessageonmousedownonmousemoveonmouseoutputonmouseoveronm" +
-	"ouseuponmousewheelonofflineononlineonpagehidesclassectionbef" +
-	"oreunloaddresshapeonpageshowidth6onpausemaponplayingonpopsta" +
-	"teonprogresstrikeytypeonratechangeonresetonresizestrongonscr" +
-	"ollonseekedonseekingonselectedonshowraponsortableonstalledon" +
-	"storageonsubmitemrefacenteronsuspendontoggleonunloadonvolume" +
-	"changeonwaitingoptimumanifestepromptoptionbeforeprintstylesu" +
-	"mmarysupsvgsystemplate"
+const atomText = "abbradiogrouparamainavalueaccept-charsetbodyaccesskeygenobro" +
+	"wspanoembedetailsampatternoframesetdfnomoduleallowpaymentreq" +
+	"uestrikeytypeallowusermediagroupictureversedirnameterubyaltf" +
+	"ooterasyncanvasidefaultitleaudioncancelabelooptgroupingautof" +
+	"ocusandboxmplaceholderautoplaysinlinebasefontimeupdateviacac" +
+	"heightmlbdoncanplaythrough1bgsoundisabledivarbigblinkbdialog" +
+	"blockquotebuttonabortrackindraggablegendcodefercolgrouplaint" +
+	"extranslatecolorcolspannotation-xmlcommandcontrolshapecoords" +
+	"lotcrossoriginsmallowfullscreenoscriptfacenterfieldsetfigcap" +
+	"tionafterprintegrityfigurequiredforeignObjectforeignobjectfo" +
+	"rmactionautocompleteerrorformenctypemustmatchallengeformmeth" +
+	"odformnovalidatetimeformtargethgrouposterhiddenhigh2hreflang" +
+	"http-equivideonclickiframeimageimglyph3isindexismappletitemt" +
+	"ypemanifestrongmarqueematheadersortedmaxlength4minlength5mte" +
+	"xtareadonlymultiplemutedoncloseamlessourceoncontextmenuitemi" +
+	"doncopyoncuechangeoncutondblclickondragendondragenterondrage" +
+	"xitemreferrerpolicyondragleaveondragoverondragstarticleondro" +
+	"pzonemptiedondurationchangeonendedonerroronfocuspaceronhashc" +
+	"hangeoninputmodeloninvalidonkeydownloadonkeypresspellchecked" +
+	"onkeyupreloadonlanguagechangeonloadeddatalistingonloadedmeta" +
+	"databindexonloadendonloadstartonmessageerroronmousedownonmou" +
+	"seenteronmouseleaveonmousemoveonmouseoutputonmouseoveronmous" +
+	"eupromptonmousewheelonofflineononlineonpagehidescitempropeno" +
+	"nceonpageshowbronpastepublicontenteditableonpausemaponplayin" +
+	"gonpopstateonprogressrcdoclassectionbluronratechangeonreject" +
+	"ionhandledonresetonresizesrclangonscrollonsecuritypolicyviol" +
+	"ationauxclickonseekedonseekingonselectedonshowidth6onsortabl" +
+	"eonstalledonstorageonsubmitemscopedonsuspendontoggleonunhand" +
+	"ledrejectionbeforeprintonunloadonvolumechangeonwaitingonwhee" +
+	"loptimumalignmarkoptionbeforeunloaddressrcsetstylesummarysup" +
+	"svgsystemplateworkertypewrap"

vendor/golang.org/x/net/html/atom/table_test.go

@@ -1,23 +1,28 @@
-// generated by go run gen.go -test; DO NOT EDIT
+// Code generated by go generate gen.go; DO NOT EDIT.
+
+//go:generate go run gen.go -test
 
 package atom
 
 var testAtomList = []string{
 	"a",
 	"abbr",
-	"abbr",
 	"accept",
 	"accept-charset",
 	"accesskey",
 	"action",
 	"address",
 	"align",
+	"allowfullscreen",
+	"allowpaymentrequest",
+	"allowusermedia",
 	"alt",
 	"annotation",
 	"annotation-xml",
 	"applet",
 	"area",
 	"article",
+	"as",
 	"aside",
 	"async",
 	"audio",
@@ -43,7 +48,6 @@ var testAtomList = []string{
 	"charset",
 	"checked",
 	"cite",
-	"cite",
 	"class",
 	"code",
 	"col",
@@ -52,7 +56,6 @@ var testAtomList = []string{
 	"cols",
 	"colspan",
 	"command",
-	"command",
 	"content",
 	"contenteditable",
 	"contextmenu",
@@ -60,7 +63,6 @@ var testAtomList = []string{
 	"coords",
 	"crossorigin",
 	"data",
-	"data",
 	"datalist",
 	"datetime",
 	"dd",
@@ -93,7 +95,6 @@ var testAtomList = []string{
 	"foreignObject",
 	"foreignobject",
 	"form",
-	"form",
 	"formaction",
 	"formenctype",
 	"formmethod",
@@ -128,6 +129,8 @@ var testAtomList = []string{
 	"input",
 	"inputmode",
 	"ins",
+	"integrity",
+	"is",
 	"isindex",
 	"ismap",
 	"itemid",
@@ -140,7 +143,6 @@ var testAtomList = []string{
 	"keytype",
 	"kind",
 	"label",
-	"label",
 	"lang",
 	"legend",
 	"li",
@@ -149,6 +151,7 @@ var testAtomList = []string{
 	"listing",
 	"loop",
 	"low",
+	"main",
 	"malignmark",
 	"manifest",
 	"map",
@@ -179,6 +182,8 @@ var testAtomList = []string{
 	"nobr",
 	"noembed",
 	"noframes",
+	"nomodule",
+	"nonce",
 	"noscript",
 	"novalidate",
 	"object",
@@ -187,6 +192,7 @@ var testAtomList = []string{
 	"onafterprint",
 	"onautocomplete",
 	"onautocompleteerror",
+	"onauxclick",
 	"onbeforeprint",
 	"onbeforeunload",
 	"onblur",
@@ -197,11 +203,14 @@ var testAtomList = []string{
 	"onclick",
 	"onclose",
 	"oncontextmenu",
+	"oncopy",
 	"oncuechange",
+	"oncut",
 	"ondblclick",
 	"ondrag",
 	"ondragend",
 	"ondragenter",
+	"ondragexit",
 	"ondragleave",
 	"ondragover",
 	"ondragstart",
@@ -221,9 +230,13 @@ var testAtomList = []string{
 	"onload",
 	"onloadeddata",
 	"onloadedmetadata",
+	"onloadend",
 	"onloadstart",
 	"onmessage",
+	"onmessageerror",
 	"onmousedown",
+	"onmouseenter",
+	"onmouseleave",
 	"onmousemove",
 	"onmouseout",
 	"onmouseover",
@@ -233,15 +246,18 @@ var testAtomList = []string{
 	"ononline",
 	"onpagehide",
 	"onpageshow",
+	"onpaste",
 	"onpause",
 	"onplay",
 	"onplaying",
 	"onpopstate",
 	"onprogress",
 	"onratechange",
+	"onrejectionhandled",
 	"onreset",
 	"onresize",
 	"onscroll",
+	"onsecuritypolicyviolation",
 	"onseeked",
 	"onseeking",
 	"onselect",
@@ -253,9 +269,11 @@ var testAtomList = []string{
 	"onsuspend",
 	"ontimeupdate",
 	"ontoggle",
+	"onunhandledrejection",
 	"onunload",
 	"onvolumechange",
 	"onwaiting",
+	"onwheel",
 	"open",
 	"optgroup",
 	"optimum",
@@ -264,9 +282,11 @@ var testAtomList = []string{
 	"p",
 	"param",
 	"pattern",
+	"picture",
 	"ping",
 	"placeholder",
 	"plaintext",
+	"playsinline",
 	"poster",
 	"pre",
 	"preload",
@@ -276,6 +296,7 @@ var testAtomList = []string{
 	"q",
 	"radiogroup",
 	"readonly",
+	"referrerpolicy",
 	"rel",
 	"required",
 	"reversed",
@@ -297,23 +318,23 @@ var testAtomList = []string{
 	"shape",
 	"size",
 	"sizes",
+	"slot",
 	"small",
 	"sortable",
 	"sorted",
 	"source",
 	"spacer",
 	"span",
-	"span",
 	"spellcheck",
 	"src",
 	"srcdoc",
 	"srclang",
+	"srcset",
 	"start",
 	"step",
 	"strike",
 	"strong",
 	"style",
-	"style",
 	"sub",
 	"summary",
 	"sup",
@@ -331,7 +352,6 @@ var testAtomList = []string{
 	"thead",
 	"time",
 	"title",
-	"title",
 	"tr",
 	"track",
 	"translate",
@@ -340,12 +360,14 @@ var testAtomList = []string{
 	"typemustmatch",
 	"u",
 	"ul",
+	"updateviacache",
 	"usemap",
 	"value",
 	"var",
 	"video",
 	"wbr",
 	"width",
+	"workertype",
 	"wrap",
 	"xmp",
 }

vendor/golang.org/x/net/html/const.go

@@ -52,10 +52,12 @@ var isSpecialElementMap = map[string]bool{
 	"iframe":     true,
 	"img":        true,
 	"input":      true,
-	"isindex":    true,
+	"isindex":    true, // The 'isindex' element has been removed, but keep it for backwards compatibility.
+	"keygen":     true,
 	"li":         true,
 	"link":       true,
 	"listing":    true,
+	"main":       true,
 	"marquee":    true,
 	"menu":       true,
 	"meta":       true,

vendor/golang.org/x/net/idna/idna.go

@@ -167,7 +167,7 @@ type options struct {
 	bidirule func(s string) bool
 }
 
-// A Profile defines the configuration of a IDNA mapper.
+// A Profile defines the configuration of an IDNA mapper.
 type Profile struct {
 	options
 }

vendor/golang.org/x/net/proxy/socks5.go

@@ -12,7 +12,7 @@ import (
 )
 
 // SOCKS5 returns a Dialer that makes SOCKSv5 connections to the given address
-// with an optional username and password. See RFC 1928.
+// with an optional username and password. See RFC 1928 and 1929.
 func SOCKS5(network, addr string, auth *Auth, forward Dialer) (Dialer, error) {
 	s := &socks5{
 		network: network,
@@ -120,6 +120,7 @@ func (s *socks5) connect(conn net.Conn, target string) error {
 		return errors.New("proxy: SOCKS5 proxy at " + s.addr + " requires authentication")
 	}
 
+	// See RFC 1929
 	if buf[1] == socks5AuthPassword {
 		buf = buf[:0]
 		buf = append(buf, 1 /* password protocol version */)

vendor/golang.org/x/net/publicsuffix/gen.go

@@ -37,7 +37,7 @@ import (
 
 const (
 	// These sum of these four values must be no greater than 32.
-	nodesBitsChildren   = 9
+	nodesBitsChildren   = 10
 	nodesBitsICANN      = 1
 	nodesBitsTextOffset = 15
 	nodesBitsTextLength = 6