emf-converter 4.23.1 → 4.24.0

package/README.md

@@ -4,7 +4,7 @@
 [![CI](https://github.com/ChristopherVR/emf-converter/actions/workflows/ci.yml/badge.svg)](https://github.com/ChristopherVR/emf-converter/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/emf-converter.svg)](LICENSE)
 
-A zero-dependency TypeScript library that converts **EMF** (Enhanced Metafile, including embedded **EMF+** / GDI+ records) and **WMF** (Windows Metafile) files into **PNG**, **JPEG** or **SVG** (markup, a base64 data URL, React elements, or a generated JSX/TSX component).
+A zero-dependency TypeScript library that converts **EMF** (Enhanced Metafile, including embedded **EMF+** / GDI+ records) and **WMF** (Windows Metafile) files into **PNG**, **JPEG**, **WebP**, **SVG** (markup, a base64 data URL, React elements, or a generated JSX/TSX component) or **PDF**. The input can be an `ArrayBuffer`, a typed array or Node.js `Buffer`, or a `Blob`, plain or gzip-compressed (`.emz`, `.wmz`).
 
 Windows metafiles are recorded GDI and GDI+ drawing calls, commonly embedded in Office documents and on the Windows clipboard. This library replays those calls the way Windows does: the PNG output is checked pixel for pixel against images painted by Windows itself (hundreds of ground-truth fixtures under `src/__fixtures__/gdi`, generated by `scripts/gdi-fixtures`), and the SVG output keeps vectors, text and gradients resolution-independent.
 
@@ -32,14 +32,14 @@ npm install emf-converter
 
 No required dependencies:
 
-- **Browser / Web Worker**: `OffscreenCanvas` or `HTMLCanvasElement` is used automatically for PNG and JPEG. Bundlers select the dedicated browser entry through conditional exports; it contains no native canvas or Node filesystem imports. Installing `@napi-rs/canvas` is only needed for the optional Node backend.
-- **Node.js**: SVG output, and PNG/JPEG output for drawings without text, work out of the box through the built-in rasteriser. For PNG/JPEG output of drawings with text, either pass `fonts` (see [Exact text](#exact-text)) or install the optional [`@napi-rs/canvas`](https://www.npmjs.com/package/@napi-rs/canvas) (prebuilt, no `node-gyp`):
+- **Browser / Web Worker**: `OffscreenCanvas` or `HTMLCanvasElement` is used automatically for PNG, JPEG and WebP. Bundlers select the dedicated browser entry through conditional exports; it contains no native canvas or Node filesystem imports. Installing `@napi-rs/canvas` is only needed for the optional Node backend.
+- **Node.js**: SVG and PDF output, and PNG/JPEG/WebP output for drawings without text, work out of the box through the built-in rasteriser. For PNG/JPEG/WebP output of drawings with text, either pass `fonts` (see [Exact text](#exact-text)) or install the optional [`@napi-rs/canvas`](https://www.npmjs.com/package/@napi-rs/canvas) (prebuilt, no `node-gyp`):
 
   ```bash
   npm install @napi-rs/canvas
   ```
 
-  Without either, PNG/JPEG conversion of a drawing that contains text returns `null` rather than an image missing its text.
+  Without either, PNG/JPEG/WebP conversion of a drawing that contains text returns `null` rather than an image missing its text.
 
 ## Quick start
 
@@ -60,6 +60,20 @@ const smooth = await convertMetafileToDataUrl(buffer, { gdiAntialias: true });
 
 Returns `Promise<string | null>`; `null` when the buffer is not a valid metafile (or, in plain Node.js, when it has text and neither `fonts` nor `@napi-rs/canvas` is available).
 
+For the bytes themselves, use `convertMetafile`. It takes a `format` (`'png'` by default, `'jpeg'`, `'webp'` or `'svg'`) and returns the encoded file, which is what you write to disk in Node.js:
+
+```typescript
+import { readFile, writeFile } from 'node:fs/promises';
+import { convertMetafile } from 'emf-converter';
+
+const image = await convertMetafile(await readFile('drawing.emf'), { format: 'webp' });
+if (image) {
+	await writeFile('drawing.webp', image.data); // image.data is a Uint8Array
+}
+```
+
+The data-URL functions are wrappers around `convertMetafile`, so both give the same image.
+
 ### JPEG output
 
 ```typescript
@@ -75,6 +89,20 @@ const preview = await convertMetafileToJpegDataUrl(buffer, { quality: 0.7, backg
 
 The same rendering as the PNG, encoded by the bundled baseline JPEG encoder, so the output is identical in browsers and Node.js. JPEG has no transparency: the metafile's transparent background is filled with `background`. Colour is kept at full resolution (4:4:4) so coloured lines and text stay crisp; `chromaSubsampling: true` halves it (4:2:0) for a smaller file.
 
+### WebP output
+
+```typescript
+import { convertMetafileToWebpDataUrl } from 'emf-converter';
+
+const webp = await convertMetafileToWebpDataUrl(buffer);
+// => "data:image/webp;base64,UklGR..."
+
+// Lossy WebP at quality 0-1 (default 0.8), plus every PNG option (maxWidth, dpiScale, fonts, ...).
+const small = await convertMetafileToWebpDataUrl(buffer, { lossless: false, quality: 0.8, maxWidth: 800 });
+```
+
+The same rendering as the PNG, encoded by the bundled WebP encoder, so the output is identical in browsers and Node.js. The default is lossless: the pixels and the transparent background are kept exactly, and the file is usually smaller than the PNG. Lossy WebP (`lossless: false`) comes from a simple encoder. For line art and text it is usually much larger than lossless, so use it only for smooth, photo-like content. Images larger than 16383 pixels on a side return `null`.
+
 ### SVG output
 
 ```typescript
@@ -147,13 +175,151 @@ const png = await convertMetafileToDataUrl(buffer, { fonts });
 
 Without `fonts`, text is drawn by the host's canvas font engine (supply `fontFamilyMap` to remap Windows face names). SVG output always keeps text as `<text>`; with `fonts` it carries GDI's exact per-glyph positions.
 
+### PDF output
+
+```typescript
+import { convertMetafileToPdf, loadSystemFonts } from 'emf-converter';
+
+const fonts = await loadSystemFonts(); // Node.js only
+const pdf = await convertMetafileToPdf(buffer, { fonts, title: 'Drawing' });
+// => Uint8Array holding a PDF file, or null
+```
+
+The output is a one-page vector PDF 1.7. It uses the same replay as the SVG output, so paths, clipping, gradients, patterns, opacity, blend modes and images are kept as vectors or embedded (JPEG bytes are copied unchanged). The page is the drawing itself by default (1 pixel = 0.75 pt); `pageSize: { width, height }` in points fits it to a page instead.
+
+Text is real text. With `fonts`, the matching TrueType face is embedded as a subset, so the text is selectable and searchable. Without `fonts`, text uses the standard PDF fonts (Helvetica, Times or Courier) and looks different from the original font. The output does not include PDF/A or tagged PDF. It has been checked with pdf.js.
+
+### Raw RGBA pixels
+
+```typescript
+import { convertMetafileToImageData } from 'emf-converter';
+
+const image = await convertMetafileToImageData(buffer);
+if (image) {
+	const { data, width, height } = image; // straight (non-premultiplied) RGBA, row-major, top-down
+	// e.g. sharp(data, { raw: { width, height, channels: 4 } }).png().toFile('drawing.png');
+}
+```
+
+This is the same rendering the PNG output encodes, without the encoding step, for code that needs the pixels themselves.
+
+### Inspecting a file
+
+`getMetafileInfo` reads the header and records without rendering anything, so you can see what a file contains before converting it:
+
+```typescript
+import { getMetafileInfo } from 'emf-converter';
+
+const info = await getMetafileInfo(buffer);
+// info.format: 'emf' | 'emf+' | 'emf+dual' | 'wmf'
+// info.width, info.height: the PNG size at default options
+// info.fonts: [{ name: 'Segoe UI', gdi: true, emfPlus: false }, ...]
+```
+
+The main use is finding out which font files to pass as `fonts`: `info.fonts` lists the face names the file declares, so you know which fonts to supply for exact text. The list is of declared fonts, and not every one is necessarily drawn with. Fonts inside nested WMFs are not collected. The `width` and `height` ignore `maxWidth` and `dpiScale`. See the [API reference](docs/api.md) for every field.
+
+### Cancellation
+
+Every conversion function accepts `signal` (an `AbortSignal`) and `timeoutMs`:
+
+```typescript
+const controller = new AbortController();
+const timer = setTimeout(() => controller.abort(), 5000);
+try {
+	const png = await convertMetafileToDataUrl(buffer, { signal: controller.signal });
+} finally {
+	clearTimeout(timer);
+}
+
+// Or reject after a time limit, with a DOMException named TimeoutError.
+const quick = await convertMetafileToDataUrl(buffer, { timeoutMs: 5000 });
+```
+
+When the signal aborts, the promise rejects with `signal.reason` (an `AbortError` when there is none). A `null` result still means the buffer is not a valid metafile. Conversion checks the signal at every record, so it stops within about one record's work. One very large record, such as a single giant blit, can overrun the limit. With a `signal`, conversion yields to the event loop about every 16 ms.
+
+### Command line
+
+The package installs an `emf-converter` command, which `npx emf-converter` runs:
+
+```text
+Usage: emf-converter <files...> [options]
+
+Convert EMF, EMF+, WMF and gzip-compressed (.emz, .wmz) metafiles to PNG,
+JPEG, WebP, SVG or PDF.
+
+Inputs:
+  <files...>            Files to convert. "-" reads one file from stdin.
+                        Wildcards (* and ?) are expanded by the CLI itself.
+
+Options:
+  -f, --format <fmt>    Output format: png, jpeg, webp, svg or pdf. Default:
+                        from the --out extension, else png.
+  -o, --out <path>      Output file for one input, or a directory (created if
+                        missing) for several. Default: next to each input,
+                        with the new extension. "-" writes to stdout.
+                        Stdin input without --out also writes to stdout.
+      --width <px>      Maximum output width in pixels.
+      --height <px>     Maximum output height in pixels.
+      --scale <n>       DPI scale factor (default 1; the library clamps to 4).
+      --quality <0-1>   JPEG quality (default 0.92), or lossy WebP quality
+                        (default 0.8).
+      --lossy           Lossy WebP instead of the default lossless WebP.
+      --background <c>  JPEG colour under transparent areas, #rgb or #rrggbb
+                        (default #ffffff). JPEG only.
+      --antialias       Smooth shape edges instead of reproducing Windows'
+                        own rasterisation.
+      --fonts <value>   "system" (default): the installed fonts, so text
+                        matches Windows; "none": no font files; or a
+                        directory of .ttf, .ttc, .fon or .fnt files.
+  -q, --quiet           Print only errors.
+  -h, --help            Show this help.
+  -v, --version         Print the version.
+
+Exit codes: 0 all files converted, 1 one or more files failed (the rest are
+still converted), 2 usage error.
+
+Examples:
+  emf-converter drawing.emf
+  emf-converter drawing.emf --width 1200 -o drawing.jpg
+  emf-converter "charts/*.wmf" -f svg -o out/
+  cat drawing.emz | emf-converter - -f png > drawing.png
+```
+
+The `--fonts system` default loads the installed fonts, so text matches Windows. Wildcards are expanded by the CLI itself (Node.js 22 or later), and a file named explicitly is converted whatever its extension.
+
 ## API
 
+### `MetafileInput`
+
+```ts
+type MetafileInput = ArrayBuffer | ArrayBufferView | Blob;
+```
+
+Every conversion function accepts this. Typed arrays, `DataView`s and Node.js `Buffer`s are read from their viewed bytes only, so pass the `Buffer` itself. Gzip-compressed `.emz` and `.wmz` files are inflated automatically (needs `DecompressionStream`: browsers and Node.js 18+; inflated size is capped at 256 MiB).
+
+### `convertMetafile(input, options?)`
+
+| Parameter   | Type                           | Description                                                       |
+| ----------- | ------------------------------ | ----------------------------------------------------------------- |
+| `input`     | `MetafileInput`                | Raw EMF or WMF file (format is auto-detected)                     |
+| `options`   | `ConvertOptions` (optional)    | `format` (`'png'` default, `'jpeg'`, `'webp'`, `'svg'`) plus that format's options |
+| **Returns** | `Promise<ConvertedImage \| null>` | The encoded file, or `null` on failure                          |
+
+#### `ConvertedImage`
+
+| Field      | Type         | Description |
+| ---------- | ------------ | ----------- |
+| `format`   | `'png' \| 'jpeg' \| 'webp' \| 'svg'` | The output format |
+| `mimeType` | `string`     | `image/png`, `image/jpeg`, `image/webp` or `image/svg+xml` |
+| `data`     | `Uint8Array` | The file bytes |
+| `width`    | `number`     | Pixel width, or the SVG's `width` |
+| `height`   | `number`     | Pixel height, or the SVG's `height` |
+
 ### `convertMetafileToDataUrl(buffer, options?)`
 
 | Parameter   | Type                           | Description                                         |
 | ----------- | ------------------------------ | --------------------------------------------------- |
-| `buffer`    | `ArrayBuffer`                  | Raw EMF or WMF file bytes (format is auto-detected) |
+| `buffer`    | `MetafileInput`                | Raw EMF or WMF file (format is auto-detected)       |
 | `options`   | `EmfConvertOptions` (optional) | See below                                           |
 | **Returns** | `Promise<string \| null>`      | PNG data URL, or `null` on failure                  |
 
@@ -180,6 +346,8 @@ page. The defaults are `1252` and `437`; explicit text charsets are unchanged.
 | `fonts`              | `Array<ArrayBuffer \| ArrayBufferView>` | None            | TrueType (`.ttf`/`.ttc`) and raster (`.fon`/`.fnt`) font files for exact GDI text |
 | `fontSmoothing`      | `'cleartype' \| 'gray' \| 'mono'`     | `'cleartype'`     | What `DEFAULT_QUALITY` / `DRAFT_QUALITY` / `PROOF_QUALITY` fonts render as (Windows' system setting) |
 | `fontFamilyMap`      | `Record<string, string>`              | None              | Without `fonts`: maps Windows face names (case-insensitive) to locally available fonts, e.g. `{ calibri: 'Carlito' }` |
+| `signal`             | `AbortSignal`                         | None              | Cancels the conversion: the promise rejects with `signal.reason` when it aborts (see [Cancellation](#cancellation)) |
+| `timeoutMs`          | `number`                              | None              | Rejects with a `DOMException` named `TimeoutError` after this many milliseconds |
 
 ### `convertMetafileToJpegDataUrl(buffer, options?)`
 
@@ -214,13 +382,85 @@ Returns `Promise<string | null>`, a `data:image/jpeg;base64,...` URL (`null` in
 | `includeSize` | `boolean` | `true` | Emit `width`/`height` on the root `<svg>` (`viewBox` is always emitted); `false` gives a fluid SVG |
 | `idPrefix` | `string` | `emf1-`, `emf2-`, ... | Prefix for generated element ids; keep it unique per inlined SVG |
 
+### `convertMetafileToWebpDataUrl(buffer, options?)`
+
+Returns `Promise<string | null>`, a `data:image/webp;base64,...` URL (`null` in the same cases as the PNG function, and for images larger than 16383 pixels on a side).
+
+#### `WebpConvertOptions` (extends `EmfConvertOptions`)
+
+| Field | Type | Default | Description |
+| --- | --- | --- | --- |
+| `lossless` | `boolean` | `true` | `true` writes lossless WebP: exact pixels, transparency kept. `false` writes lossy WebP at `quality` (transparency is still kept). |
+| `quality` | `number` | `0.8` | Lossy quality from `0` to `1`. Ignored when `lossless` is `true`. |
+
+### `convertMetafileToPdf(buffer, options?)`
+
+```ts
+function convertMetafileToPdf(buffer: MetafileInput, options?: PdfConvertOptions): Promise<Uint8Array | null>;
+```
+
+Returns the bytes of a one-page vector PDF, or `null` for an invalid or empty metafile. `svgTreeToPdf(tree, options?)` makes the same PDF from an `SvgNode` tree.
+
+#### `PdfConvertOptions` (extends `SvgConvertOptions`, plus `PdfOptions`)
+
+| Field | Type | Default | Description |
+| --- | --- | --- | --- |
+| `pageSize` | `'drawing' \| { width: number; height: number }` | `'drawing'` | `'drawing'` makes the page the drawing itself (1 pixel = 0.75 pt). `{ width, height }` in points fits the drawing to a page of that size, centred. |
+| `fonts` | `Array<ArrayBuffer \| ArrayBufferView>` | None | TrueType (`.ttf`, `.ttc`) files. Text in a matching font is embedded as a subset of that face. Other text uses the standard PDF fonts. |
+| `compress` | `boolean` | `true` | Deflate the content streams and image data. |
+| `title` | `string` | None | Document title in the PDF information dictionary. |
+| `decodeImage` | `(bytes: Uint8Array, mime: string) => PdfDecodedImage \| null` (may be async) | None | Decodes an embedded image format that is neither JPEG nor handled by the bundled decoders (PNG, BMP, GIF, TIFF, WebP). Returns straight RGBA, or `null` to skip the image. |
+
+### `convertMetafileToImageData(buffer, options?)`
+
+```ts
+function convertMetafileToImageData(buffer: MetafileInput, options?: EmfConvertOptions): Promise<RgbaImage | null>;
+```
+
+Returns `{ data: Uint8ClampedArray, width, height }`: straight (non-premultiplied) RGBA, row-major and top-down, like `ImageData`. It is the rendering the PNG output encodes, without the encoding step.
+
+### `getMetafileInfo(buffer, options?)`
+
+```ts
+function getMetafileInfo(buffer: MetafileInput, options?: MetafileInfoOptions): Promise<MetafileInfo | null>;
+```
+
+Reads the header and records without rendering, and returns `null` for an invalid metafile.
+
+#### `MetafileInfoOptions`
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `maxRecords` | `number` | As for the converters | Record limit per stream. |
+| `ansiCodePage` | `number` | `1252` | ANSI code page for WMF face names, as for the converters. |
+
+#### `MetafileInfo`
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `format` | `'emf' \| 'emf+' \| 'emf+dual' \| 'wmf'` | `'emf+'` is EMF+ only (the GDI records are a stub); `'emf+dual'` has a GDI fallback. |
+| `bounds` | `MetafileRect` | EMF: the header's device-pixel bounds (inclusive). WMF: the bounding box in logical units. |
+| `frame` | `MetafileRect \| null` | EMF: the picture frame in .01 mm. Placeable WMF: the bounding box in .01 mm. |
+| `device` | `{ width, height } \| null` | EMF: the reference device size in pixels. |
+| `dpi` | `{ x, y }` | Reference device resolution (96 when unknown). |
+| `width` / `height` | `number` | Pixel size `convertMetafileToDataUrl` produces at default options. |
+| `recordCount` | `number` | Records read from the stream. |
+| `emfPlusRecordCount` | `number` | Records read from the EMF+ streams inside `EMR_COMMENT` records. |
+| `recordTypes` | `Record<string, number>` | Count by record name (`EMR_*`, `META_*`, `EMFPLUS_*`). |
+| `fonts` | `MetafileFont[]` | Declared font faces: `{ name, gdi, emfPlus }`. Not every one is necessarily drawn with. |
+| `hasText` | `boolean` | `true` when any text-drawing record is present. |
+| `images` | `{ count, mimeTypes }` | Embedded images, including DIBs, EMF+ images and nested metafiles. |
+| `embeddedMetafiles` | `number` | Nested metafiles among `images`. |
+| `description` | `string \| null` | The EMF header's application and document names. |
+| `truncated` | `boolean` | `true` when the record limit was hit or the stream ends in a damaged record. |
+
 ### `loadSystemFonts(options?)`
 
 Node.js only (returns `[]` elsewhere; the package stays browser-safe). Reads the installed `.ttf`, `.ttc`, `.fon` and `.fnt` files from the platform font folders (Windows, Linux, macOS, and per-user folders) for the `fonts` option. Options: `dirs` (scan these instead), `filter(path, name)`, `maxDepth`.
 
 ## How it works
 
-A three-phase pipeline: **parse → replay → export**. Records are replayed by the GDI, EMF+ or WMF handlers onto a Canvas (or the built-in pure-JavaScript rasteriser) for PNG and JPEG, or onto a recording context for SVG. GDI and GDI+ shapes, raster operations, brushes, clipping, text and WMF playback are all fitted to output painted by Windows itself.
+A three-phase pipeline: **parse → replay → export**. Records are replayed by the GDI, EMF+ or WMF handlers onto a Canvas (or the built-in pure-JavaScript rasteriser) for PNG, JPEG and WebP, or onto a recording context for SVG and PDF. GDI and GDI+ shapes, raster operations, brushes, clipping, text and WMF playback are all fitted to output painted by Windows itself.
 
 See [How it works](docs/how-it-works.md) for the pipeline, the Windows-parity details and the full list of supported records.
 

package/THIRD_PARTY_NOTICES

@@ -131,6 +131,54 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 
 
+===== libwebp (src/webp-decoder.ts, src/webp-vp8.ts, src/webp-vp8l.ts, src/webp-tables.ts) =====
+
+The WebP decoder is a TypeScript port of the decoding paths of libwebp
+(https://chromium.googlesource.com/webm/libwebp): the VP8 key-frame decoder
+(prediction, transforms, loop filter, fancy upsampling and YUV conversion with
+libwebp's fixed-point arithmetic), the VP8L lossless decoder and the ALPH
+unfiltering. The constant tables in src/webp-tables.ts are copied from
+libwebp's src/dec/tree_dec.c and src/dec/quant_dec.c.
+
+Copyright (c) 2010, Google Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.
+
+  * Neither the name of Google nor the names of its contributors may
+    be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+===== WebP test images (src/__fixtures__/webp, repository only) =====
+
+The .webp files were encoded from synthetic pictures drawn by a script (no
+third-party image content) with libwebp 1.6.0 through Pillow, and each .png is
+the same file decoded by libwebp, used as the expected output. Nothing from
+them is shipped in the package.
+
+
 ===== Independent JPEG Group software (src/jpeg-arith.ts, src/jpeg-turbo.ts) =====
 
 src/jpeg-arith.ts decodes arithmetic-coded JPEG and is a port of the entropy
@@ -233,6 +281,46 @@ identification and copyright information removed and shall not be
 misrepresented as the original profile.
 
 
+===== libwebp / RFC 6386 (src/webp-vp8-tables.ts, src/webp-vp8-encoder.ts) =====
+
+The WebP lossy encoder (src/webp-vp8-encoder.ts) follows the VP8 specification
+(RFC 6386) and libwebp for the 4x4 transforms, the quantiser mapping, the frame
+edge conventions and the token coding. src/webp-vp8-tables.ts holds the VP8
+constant tables (default token probabilities, token probability update
+probabilities, DC and AC quantiser steps), which are normative parts of the
+format and are identical in the RFC and in libwebp. The lossless encoder
+(src/webp-lossless.ts) is written from the public WebP Lossless Bitstream
+Specification, and uses its 120-entry distance-neighbourhood table.
+
+libwebp is distributed under the following licence:
+
+Copyright (c) 2010, Google Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the name of Google nor the names of its contributors may be used to
+    endorse or promote products derived from this software without specific
+    prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
 ===== Measured Windows data and cited references (no third-party code) =====
 
 src/jpeg-cmyk-data.ts, src/emf-gdi-illuminant-data.ts, src/emf-plus-image-curves.ts,