imagescript 3.0.0 → 3.2.0

package/dist/image.js

@@ -1,15 +1,19 @@
 import * as png from "./codecs/png.js";
 import * as jpeg from "./codecs/jpeg.js";
 import * as tiff from "./codecs/tiff.js";
+import * as webp from "./codecs/webp.js";
+import * as tga from "./codecs/tga.js";
 import * as quantize from "./codecs/quantize.js";
 import * as textRenderer from "./render/text.js";
 import * as svgRenderer from "./render/svg.js";
 import { view } from "./util/mem.js";
 import { ImageType } from "./image-type.js";
 import { TextLayout } from "./text-layout.js";
-import { VERSION } from "./version.js";
+import { resolveMetadata, pngText, exifData } from "./metadata.js";
+import { encode as utf8 } from "./util/utf8.js";
 import { resample, BOX, TRIANGLE, CUBIC } from "./util/resample.js";
 import { gaussianBlur, premultiply, unpremultiply } from "./util/blur.js";
+import { isOptions } from "./util/options.js";
 export class Image {
     __width__;
     __height__;
@@ -204,8 +208,8 @@ export class Image {
     static get RESIZE_AUTO() {
         return -1;
     }
-    scale(factor, mode = Image.RESIZE_BILINEAR) {
-        const image = this.__scale__(factor, mode);
+    scale(factor, modeOrOptions) {
+        const image = this.__scale__(factor, resizeMode(modeOrOptions));
         return this.__apply__(image);
     }
     __scale__(factor, mode = Image.RESIZE_BILINEAR) {
@@ -213,23 +217,27 @@ export class Image {
             return this;
         return this.__resize__(this.width * factor, this.height * factor, mode);
     }
-    resize(width, height, mode = Image.RESIZE_BILINEAR) {
+    resize(width, height, modeOrOptions) {
+        const mode = resizeMode(modeOrOptions);
         const image = this.__resize__(width, height, mode);
         return this.__apply__(image);
     }
-    contain(width, height, mode = Image.RESIZE_BILINEAR) {
+    contain(width, height, modeOrOptions) {
+        const mode = resizeMode(modeOrOptions);
         width = Math.floor(width);
         height = Math.floor(height);
         const scale = Math.min(width / this.width, height / this.height);
         return this.resize(Math.max(1, Math.min(width, Math.round(this.width * scale))), Math.max(1, Math.min(height, Math.round(this.height * scale))), mode);
     }
-    fit(width, height, mode = Image.RESIZE_BILINEAR) {
+    fit(width, height, modeOrOptions) {
+        const mode = resizeMode(modeOrOptions);
         const result = new Image(width, height);
         this.contain(width, height, mode);
         result.composite(this, (width - this.width) / 2, (height - this.height) / 2);
         return this.__apply__(result);
     }
-    cover(width, height, mode = Image.RESIZE_BILINEAR) {
+    cover(width, height, modeOrOptions) {
+        const mode = resizeMode(modeOrOptions);
         width = Math.floor(width);
         height = Math.floor(height);
         const scale = Math.max(width / this.width, height / this.height);
@@ -280,6 +288,51 @@ export class Image {
             throw new RangeError('Crop region does not overlap the image');
         return this.__apply__(this.__crop__(left, top, right - left, bottom - top));
     }
+    trim(color, options = {}) {
+        const bounds = this.__trim_bounds__(color, options);
+        return bounds ? this.__apply__(this.__crop__(...bounds)) : this;
+    }
+    __trim_bounds__(color, { tolerance = 0 }) {
+        if (!(tolerance >= 0 && tolerance <= 1))
+            throw new RangeError('Invalid tolerance, it has to be between 0 and 1');
+        const bitmap = this.bitmap;
+        const { width, height } = this;
+        const c = color === undefined ? [bitmap[0], bitmap[1], bitmap[2], bitmap[3]] : [color >>> 24, color >> 16 & 255, color >> 8 & 255, color & 255];
+        const limit = tolerance * 255;
+        const matches = (x, y) => {
+            const i = (y * width + x) * 4;
+            if (Math.abs(bitmap[i + 3] - c[3]) > limit)
+                return false;
+            if (bitmap[i + 3] === 0 && c[3] === 0)
+                return true;
+            return Math.abs(bitmap[i] - c[0]) <= limit && Math.abs(bitmap[i + 1] - c[1]) <= limit && Math.abs(bitmap[i + 2] - c[2]) <= limit;
+        };
+        const rowMatches = (y) => {
+            for (let x = 0; x < width; x++)
+                if (!matches(x, y))
+                    return false;
+            return true;
+        };
+        const columnMatches = (x, top, bottom) => {
+            for (let y = top; y < bottom; y++)
+                if (!matches(x, y))
+                    return false;
+            return true;
+        };
+        let top = 0, bottom = height;
+        while (top < height && rowMatches(top))
+            top++;
+        if (top === height)
+            return null;
+        while (rowMatches(bottom - 1))
+            bottom--;
+        let left = 0, right = width;
+        while (columnMatches(left, top, bottom))
+            left++;
+        while (columnMatches(right - 1, top, bottom))
+            right--;
+        return [left, top, right - left, bottom - top];
+    }
     __crop__(x, y, width, height) {
         x = ~~x;
         y = ~~y;
@@ -367,25 +420,29 @@ export class Image {
         }
         return this;
     }
-    opacity(opacity, absolute = false) {
+    opacity(opacity, absoluteOrOptions = false) {
+        const absolute = isOptions(absoluteOrOptions) ? absoluteOrOptions.absolute ?? false : absoluteOrOptions;
         if (isNaN(opacity) || opacity < 0)
             throw new RangeError('Invalid opacity value');
         this.__set_channel_value__(opacity, absolute, 3);
         return this;
     }
-    red(factor, absolute = false) {
+    red(factor, absoluteOrOptions = false) {
+        const absolute = isOptions(absoluteOrOptions) ? absoluteOrOptions.absolute ?? false : absoluteOrOptions;
         if (isNaN(factor) || factor < 0)
             throw new RangeError('Invalid red factor');
         this.__set_channel_value__(factor, absolute, 0);
         return this;
     }
-    green(factor, absolute = false) {
+    green(factor, absoluteOrOptions = false) {
+        const absolute = isOptions(absoluteOrOptions) ? absoluteOrOptions.absolute ?? false : absoluteOrOptions;
         if (isNaN(factor) || factor < 0)
             throw new RangeError('Invalid green factor');
         this.__set_channel_value__(factor, absolute, 1);
         return this;
     }
-    blue(factor, absolute = false) {
+    blue(factor, absoluteOrOptions = false) {
+        const absolute = isOptions(absoluteOrOptions) ? absoluteOrOptions.absolute ?? false : absoluteOrOptions;
         if (isNaN(factor) || factor < 0)
             throw new RangeError('Invalid blue factor');
         this.__set_channel_value__(factor, absolute, 2);
@@ -395,18 +452,22 @@ export class Image {
         for (let i = offset; i < this.bitmap.length; i += 4)
             this.bitmap[i] = value * (absolute ? 255 : this.bitmap[i]);
     }
-    lightness(value, absolute = false) {
+    lightness(value, absoluteOrOptions = false) {
+        const absolute = isOptions(absoluteOrOptions) ? absoluteOrOptions.absolute ?? false : absoluteOrOptions;
         if (isNaN(value) || value < 0)
             throw new RangeError('Invalid lightness value');
         return this.__map_hsla__(c => { c.l = value * (absolute ? 1 : c.l); });
     }
-    saturation(value, absolute = false) {
+    saturation(value, absoluteOrOptions = false) {
+        const absolute = isOptions(absoluteOrOptions) ? absoluteOrOptions.absolute ?? false : absoluteOrOptions;
         if (isNaN(value) || value < 0)
             throw new RangeError('Invalid saturation value');
         return this.__map_hsla__(c => { c.s = value * (absolute ? 1 : c.s); });
     }
-    composite(source, x = 0, y = 0, options = {}) {
+    composite(source, xOrOptions = 0, yArgument = 0, optionsArgument = {}) {
+        const options = isOptions(xOrOptions) ? xOrOptions : optionsArgument;
         const { opacity = 1, mode = 'normal' } = options;
+        let x = isOptions(xOrOptions) ? xOrOptions.x ?? 0 : xOrOptions, y = isOptions(xOrOptions) ? xOrOptions.y ?? 0 : yArgument;
         x |= 0;
         y |= 0;
         if (isNaN(opacity) || opacity < 0 || opacity > 1)
@@ -556,7 +617,8 @@ export class Image {
         unpremultiply(pixels, this.bitmap);
         return this;
     }
-    sharpen(amount = 1, radius = 1) {
+    sharpen(amountOrOptions = 1, radiusArgument = 1) {
+        const { amount = 1, radius = 1 } = isOptions(amountOrOptions) ? amountOrOptions : { amount: amountOrOptions, radius: radiusArgument };
         if (isNaN(amount) || amount < 0)
             throw new RangeError('Invalid sharpen amount');
         if (isNaN(radius) || radius <= 0)
@@ -606,6 +668,29 @@ export class Image {
         }
         return this;
     }
+    colorToAlpha(color, options = {}) {
+        const { transparencyThreshold = 0, opacityThreshold = 1 } = options;
+        if (!(transparencyThreshold >= 0 && opacityThreshold <= 1 && transparencyThreshold < opacityThreshold))
+            throw new RangeError('Invalid thresholds, they have to satisfy 0 <= transparencyThreshold < opacityThreshold <= 1');
+        const bitmap = this.bitmap;
+        const c = color === undefined ? [bitmap[0], bitmap[1], bitmap[2]] : [color >>> 24, color >> 16 & 255, color >> 8 & 255];
+        for (let i = 0; i < bitmap.length; i += 4) {
+            let distance = 0;
+            for (let k = 0; k < 3; k++) {
+                const d = bitmap[i + k] - c[k];
+                const a = d > 0 ? d / (255 - c[k]) : d < 0 ? -d / c[k] : 0;
+                if (a > distance)
+                    distance = a;
+            }
+            const alpha = distance <= transparencyThreshold ? 0 : distance >= opacityThreshold ? 1
+                : (distance - transparencyThreshold) / (opacityThreshold - transparencyThreshold);
+            if (alpha > 0)
+                for (let k = 0; k < 3; k++)
+                    bitmap[i + k] = Math.round((bitmap[i + k] - c[k]) / alpha + c[k]);
+            bitmap[i + 3] = Math.round(bitmap[i + 3] * alpha);
+        }
+        return this;
+    }
     __map_channels__(map) {
         const lut = new Uint8ClampedArray(256);
         for (let v = 0; v < 256; v++)
@@ -795,7 +880,8 @@ export class Image {
             throw new RangeError(`Invalid gradient position: ${position}`);
         };
     }
-    roundCorners(radius = Math.min(this.width, this.height) / 4) {
+    roundCorners(radiusOrOptions) {
+        let radius = (isOptions(radiusOrOptions) ? radiusOrOptions.radius : radiusOrOptions) ?? Math.min(this.width, this.height) / 4;
         radius = Math.max(0, Math.min(radius, this.width / 2, this.height / 2));
         const size = Math.ceil(radius);
         for (let y = 0; y < size; y++) {
@@ -827,7 +913,8 @@ export class Image {
             return (((r & 0xff) << 24) | ((g & 0xff) << 16) | ((b & 0xff) << 8) | (a & 0xff)) >>> 0;
         };
     }
-    fisheye(strength = 2) {
+    fisheye(strengthOrOptions) {
+        const strength = (isOptions(strengthOrOptions) ? strengthOrOptions.strength : strengthOrOptions) ?? 2;
         const r = new Image(this.width, this.height);
         const w = this.width;
         const h = this.height;
@@ -852,31 +939,31 @@ export class Image {
         }
         return this.__apply__(r);
     }
-    async encode(compression = 1, metadata = {}) {
-        if (typeof compression === 'object' && compression !== null) {
-            metadata = compression;
-            compression = 1;
-        }
+    async encode(compressionOrOptions = 1, metadataArgument = {}) {
+        let compression = 1, metadata = metadataArgument;
+        if (!isOptions(compressionOrOptions))
+            compression = compressionOrOptions;
+        else if ('compression' in compressionOrOptions || 'metadata' in compressionOrOptions)
+            ({ compression = 1, metadata = {} } = compressionOrOptions);
+        else
+            metadata = compressionOrOptions;
         const level = Math.min(9, Math.max(0, ~~compression));
-        const { title, author, description, copyright, creationTime, software, disclaimer, warning, source, comment } = metadata || {};
-        return png.encodeRGBA(this.__bytes__(), this.width, this.height, level, {
-            Title: title,
-            Author: author,
-            Description: description,
-            Copyright: copyright,
-            'Creation Time': new Date(creationTime === undefined ? Date.now() : creationTime).toUTCString(),
-            Software: software === undefined ? `github.com/matmen/ImageScript v${VERSION}` : software,
-            Disclaimer: disclaimer,
-            Warning: warning,
-            Source: source,
-            Comment: comment
-        });
-    }
-    encodePNG(compression, metadata) {
-        return this.encode(compression, metadata);
-    }
-    async encodeJPEG(quality = 90) {
-        return jpeg.encode(this.__bytes__(), this.width, this.height, quality);
+        return png.encodeRGBA(this.__bytes__(), this.width, this.height, level, pngText(resolveMetadata(metadata)));
+    }
+    encodePNG(compressionOrOptions, metadata) {
+        return this.encode(compressionOrOptions, metadata);
+    }
+    async encodeJPEG(qualityOrOptions = 90) {
+        const { quality = 90, metadata = {} } = isOptions(qualityOrOptions) ? qualityOrOptions : { quality: qualityOrOptions };
+        const m = resolveMetadata(metadata);
+        return jpeg.encode(this.__bytes__(), this.width, this.height, quality, { exif: exifData(m), comment: m.comment ? utf8(m.comment) : undefined });
+    }
+    async encodeWebP({ metadata = {} } = {}) {
+        return webp.encode(this.__bytes__(), this.width, this.height, exifData(resolveMetadata(metadata)));
+    }
+    async encodeTGA({ metadata = {} } = {}) {
+        const { author, comment, creationTime: time, software } = resolveMetadata(metadata);
+        return tga.encode(this.__bytes__(), this.width, this.height, { author, comment, time, software });
     }
     static async decode(input, options = {}) {
         const { applyOrientation = true } = options;
@@ -889,6 +976,13 @@ export class Image {
             decoded = jpeg.decode(data);
         else if (ImageType.isTIFF(dataView))
             decoded = await tiff.decode(data);
+        else if (ImageType.isWebP(dataView)) {
+            if (webp.isAnimated(data))
+                throw new Error('Animated WebPs have to be decoded with Animation.decode()');
+            decoded = webp.decode(data);
+        }
+        else if (ImageType.isTGA(dataView))
+            decoded = tga.decode(data);
         else
             throw new Error('Unsupported image type');
         const image = new Image(decoded.width, decoded.height);
@@ -950,7 +1044,8 @@ export class Image {
     static get SVG_MODE_HEIGHT() {
         return 3;
     }
-    static async renderSVG(svg, size = 1, mode = Image.SVG_MODE_SCALE) {
+    static async renderSVG(svg, sizeOrOptions = 1, modeArgument = Image.SVG_MODE_SCALE) {
+        const { size = 1, mode = Image.SVG_MODE_SCALE } = isOptions(sizeOrOptions) ? sizeOrOptions : { size: sizeOrOptions, mode: modeArgument };
         if (![1, 2, 3].includes(mode))
             throw new Error('Invalid SVG scaling mode');
         if (mode === Image.SVG_MODE_SCALE && size <= 0)
@@ -962,11 +1057,12 @@ export class Image {
         image.bitmap.set(pixels);
         return image;
     }
-    static async renderText(font, size, text, color = 0xffffffff, layout = new TextLayout(), style = {}) {
-        const { strokeWidth = 0, strokeColor = 0x000000ff } = style;
+    static async renderText(font, size, text, colorOrOptions = 0xffffffff, layoutArgument, styleArgument = {}) {
+        const options = isOptions(colorOrOptions) ? colorOrOptions : { ...styleArgument, color: colorOrOptions, layout: layoutArgument };
+        const { color = 0xffffffff, layout = new TextLayout(), strokeWidth = 0, strokeColor = 0x000000ff, hinting = true } = options;
         if (isNaN(strokeWidth) || strokeWidth < 0)
             throw new RangeError('Invalid stroke width');
-        const rendered = textRenderer.render(view(font), size, text, layout);
+        const rendered = textRenderer.render(view(font), size, text, layout, hinting);
         const [r, g, b, a] = Image.colorToRGBA(color);
         const pad = Math.ceil(strokeWidth);
         const width = rendered.width + 2 * pad, height = rendered.height + 2 * pad;
@@ -1038,6 +1134,9 @@ function hue2rgb(p, q, t) {
         return p + (q - p) * (2 / 3 - t) * 6;
     return p;
 }
+function resizeMode(modeOrOptions) {
+    return (isOptions(modeOrOptions) ? modeOrOptions.mode : modeOrOptions) ?? Image.RESIZE_BILINEAR;
+}
 const hardLight = (b, s) => s <= 0.5 ? b * 2 * s : 1 - (1 - b) * (1 - (2 * s - 1));
 const BLEND_MODES = {
     'normal': (_b, s) => s,

package/dist/index.d.ts

@@ -1,19 +1,33 @@
 import { BinaryData } from './util/mem.js';
-import { Image } from './image.js';
+import { Image, DecodeOptions } from './image.js';
 import { GIF } from './gif.js';
+import { Animation, AnimationDecodeOptions } from './animation.js';
 export { Image } from './image.js';
-export type { Color, ColorFunction, ResizeMode, SVGScaleMode, PNGMetadata, TextStyle, DecodeOptions, CompositeOptions, BlendMode, CropCircleOptions, DominantColorOptions, RotateOptions } from './image.js';
+export type { Color, ColorFunction, ResizeMode, SVGScaleMode, PNGMetadata, TextStyle, DecodeOptions, CompositeOptions, BlendMode, CropCircleOptions, DominantColorOptions, RotateOptions, ColorToAlphaOptions, ResizeOptions, AdjustOptions, SharpenOptions, PNGEncodeOptions, JPEGEncodeOptions, EncodeOptions, SVGOptions, TextOptions, RoundCornersOptions, FisheyeOptions, TrimOptions } from './image.js';
 export { Frame } from './frame.js';
-export type { FrameDisposalModeName, FrameDisposalModeId } from './frame.js';
+export type { FrameDisposalModeName, FrameDisposalModeId, FrameOptions } from './frame.js';
 export { GIF } from './gif.js';
+export { Animation } from './animation.js';
+export type { AnimationOptions, AnimationDecodeOptions, AnimationEncodeOptions, GIFEncodeOptions, APNGEncodeOptions } from './animation.js';
 export { TextLayout } from './text-layout.js';
 export type { TextLayoutOptions, WrapStyle, HorizontalAlign, VerticalAlign } from './text-layout.js';
 export { ImageType } from './image-type.js';
 export type { ImageTypeName } from './image-type.js';
 export type { BinaryData } from './util/mem.js';
+export type { Metadata } from './metadata.js';
 /**
- * Decodes any supported image, GIFs are returned as {@link GIF}
+ * Decodes any supported image: GIFs are returned as {@link GIF} (an {@link Animation}), animated WebPs as
+ * {@link Animation}, everything else (including APNGs, as their default image) as {@link Image}.
+ * {@link Animation.decode} decodes the frames of GIFs, APNGs and WebPs
  * @param data The image data
- * @param onlyExtractFirstFrame Whether to end GIF decoding after the first frame
+ * @param options See {@link AnimationDecodeOptions} (for animations) and {@link DecodeOptions} (for images)
  */
-export declare function decode(data: BinaryData, onlyExtractFirstFrame?: boolean): Promise<GIF | Image>;
+export declare function decode(data: BinaryData, options?: AnimationDecodeOptions & DecodeOptions): Promise<GIF | Animation | Image>;
+/**
+ * Decodes any supported image: GIFs are returned as {@link GIF} (an {@link Animation}), animated WebPs as
+ * {@link Animation}, everything else (including APNGs, as their default image) as {@link Image}.
+ * {@link Animation.decode} decodes the frames of GIFs, APNGs and WebPs
+ * @param data The image data
+ * @param onlyExtractFirstFrame Whether to end animation decoding after the first frame
+ */
+export declare function decode(data: BinaryData, onlyExtractFirstFrame?: boolean): Promise<GIF | Animation | Image>;

package/dist/index.js

@@ -1,13 +1,22 @@
 import { Image } from "./image.js";
 import { GIF } from "./gif.js";
+import { Animation } from "./animation.js";
+import { isOptions } from "./util/options.js";
+import * as webp from "./codecs/webp.js";
+import { view } from "./util/mem.js";
 import { ImageType } from "./image-type.js";
 export { Image } from "./image.js";
 export { Frame } from "./frame.js";
 export { GIF } from "./gif.js";
+export { Animation } from "./animation.js";
 export { TextLayout } from "./text-layout.js";
 export { ImageType } from "./image-type.js";
-export function decode(data, onlyExtractFirstFrame = false) {
-    if (ImageType.getType(data) === 'gif')
-        return GIF.decode(data, onlyExtractFirstFrame);
-    return Image.decode(data);
+export function decode(data, onlyFirstFrameOrOptions = false) {
+    const { onlyFirstFrame = false, applyOrientation } = isOptions(onlyFirstFrameOrOptions) ? onlyFirstFrameOrOptions : { onlyFirstFrame: onlyFirstFrameOrOptions };
+    const type = ImageType.getType(data);
+    if (type === 'gif')
+        return GIF.decode(data, { onlyFirstFrame });
+    if (type === 'webp' && webp.isAnimated(view(data)))
+        return Animation.decode(data, { onlyFirstFrame });
+    return Image.decode(data, { applyOrientation });
 }

package/dist/metadata.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Metadata written by the encoders. Each format stores the fields it has a place for:
+ *
+ * | Format | Fields |
+ * |---|---|
+ * | PNG, APNG | all (as text chunks) |
+ * | JPEG | author, description, copyright, creation time, software (Exif); comment (comment marker) |
+ * | WebP | author, description, copyright, creation time, software (Exif) |
+ * | GIF | software, comment (comment extensions) |
+ * | TGA | author, comment, creation time, software (extension area) |
+ *
+ * Empty fields are left out
+ */
+export interface Metadata {
+    /** The image's title */
+    title?: string;
+    /** The image's author */
+    author?: string;
+    /** The image's description */
+    description?: string;
+    /** The image's copyright info */
+    copyright?: string;
+    /** The image's creation time. Default: now */
+    creationTime?: string | number | Date;
+    /** The software used to create the image. Default: `'github.com/matmen/ImageScript vX.X.X'`, `''` leaves it out */
+    software?: string;
+    /** A disclaimer for the image */
+    disclaimer?: string;
+    /** A warning for the image */
+    warning?: string;
+    /** The image's source */
+    source?: string;
+    /** A comment for the image */
+    comment?: string;
+}

package/dist/metadata.js

@@ -0,0 +1,43 @@
+import { VERSION } from "./version.js";
+import { encode as utf8 } from "./util/utf8.js";
+import * as exif from "./codecs/exif.js";
+const TEXT_FIELDS = ['title', 'author', 'description', 'copyright', 'software', 'disclaimer', 'warning', 'source', 'comment'];
+export function resolveMetadata(metadata = {}) {
+    const { creationTime, software } = metadata || {};
+    const time = new Date(creationTime === undefined ? Date.now() : creationTime);
+    if (isNaN(time.getTime()))
+        throw new RangeError('Invalid creation time');
+    const resolved = { creationTime: time };
+    for (const key of TEXT_FIELDS) {
+        const value = key === 'software' && software === undefined ? `github.com/matmen/ImageScript v${VERSION}` : metadata?.[key];
+        if (value)
+            resolved[key] = String(value);
+    }
+    return resolved;
+}
+export function pngText(m) {
+    return {
+        Title: m.title,
+        Author: m.author,
+        Description: m.description,
+        Copyright: m.copyright,
+        'Creation Time': m.creationTime.toUTCString(),
+        Software: m.software,
+        Disclaimer: m.disclaimer,
+        Warning: m.warning,
+        Source: m.source,
+        Comment: m.comment
+    };
+}
+export function exifData(m) {
+    return exif.encode({
+        description: m.description,
+        software: m.software,
+        dateTime: m.creationTime,
+        artist: m.author,
+        copyright: m.copyright
+    });
+}
+export function gifComments(m) {
+    return [m.software, m.comment].filter((c) => !!c).map(utf8);
+}

package/dist/render/font.js

@@ -73,6 +73,103 @@ export class Font {
         const index = Math.min(glyph, this.numberOfHMetrics - 1);
         return this.u16(hmtx + index * 4);
     }
+    leftSideBearing(glyph) {
+        const hmtx = this.tables.hmtx.offset;
+        if (glyph < this.numberOfHMetrics)
+            return this.i16(hmtx + glyph * 4 + 2);
+        return this.i16(hmtx + this.numberOfHMetrics * 4 + (glyph - this.numberOfHMetrics) * 2);
+    }
+    glyfPoints(glyph) {
+        if (this.outlines !== 'glyf' || glyph >= this.numGlyphs)
+            return null;
+        const loca = this.tables.loca.offset;
+        const start = this.indexToLocFormat ? this.u32(loca + glyph * 4) : this.u16(loca + glyph * 2) * 2;
+        const end = this.indexToLocFormat ? this.u32(loca + glyph * 4 + 4) : this.u16(loca + glyph * 2 + 2) * 2;
+        if (end <= start)
+            return null;
+        const offset = this.tables.glyf.offset + start;
+        const contourCount = this.i16(offset);
+        const xMin = this.i16(offset + 2);
+        if (contourCount < 0) {
+            const components = [];
+            let p = offset + 10, flags = 0;
+            do {
+                flags = this.u16(p);
+                const component = this.u16(p + 2);
+                p += 4;
+                let arg1, arg2;
+                if (flags & 1) {
+                    arg1 = flags & 2 ? this.i16(p) : this.u16(p);
+                    arg2 = flags & 2 ? this.i16(p + 2) : this.u16(p + 2);
+                    p += 4;
+                }
+                else {
+                    arg1 = flags & 2 ? this.i8(p) : this.u8(p);
+                    arg2 = flags & 2 ? this.i8(p + 1) : this.u8(p + 1);
+                    p += 2;
+                }
+                let matrix = [1, 0, 0, 1];
+                const f2dot14 = (o) => this.i16(o) / 16384;
+                if (flags & 8) {
+                    const s = f2dot14(p);
+                    matrix = [s, 0, 0, s];
+                    p += 2;
+                }
+                else if (flags & 0x40) {
+                    matrix = [f2dot14(p), 0, 0, f2dot14(p + 2)];
+                    p += 4;
+                }
+                else if (flags & 0x80) {
+                    matrix = [f2dot14(p), f2dot14(p + 2), f2dot14(p + 4), f2dot14(p + 6)];
+                    p += 8;
+                }
+                components.push({
+                    glyph: component,
+                    dx: flags & 2 ? arg1 : 0,
+                    dy: flags & 2 ? arg2 : 0,
+                    matrix,
+                    round: (flags & 4) !== 0,
+                    match: flags & 2 ? null : [arg1, arg2],
+                    useMetrics: (flags & 0x200) !== 0
+                });
+            } while (flags & 0x20);
+            const instructions = flags & 0x100 ? this.data.subarray(p + 2, p + 2 + this.u16(p)) : new Uint8Array(0);
+            return { xs: [], ys: [], on: [], ends: [], instructions, xMin, components };
+        }
+        const ends = [];
+        for (let i = 0; i < contourCount; i++)
+            ends.push(this.u16(offset + 10 + i * 2));
+        const pointCount = contourCount ? ends[contourCount - 1] + 1 : 0;
+        let p = offset + 10 + contourCount * 2;
+        const instructionLength = this.u16(p);
+        const instructions = this.data.subarray(p + 2, p + 2 + instructionLength);
+        p += 2 + instructionLength;
+        const flags = new Uint8Array(pointCount);
+        for (let i = 0; i < pointCount;) {
+            const flag = this.u8(p++);
+            flags[i++] = flag;
+            if (flag & 8)
+                for (let repeat = this.u8(p++); repeat > 0 && i < pointCount; repeat--)
+                    flags[i++] = flag;
+        }
+        const xs = [], ys = [];
+        for (const [coords, short, same] of [[xs, 2, 16], [ys, 4, 32]]) {
+            let value = 0;
+            for (let i = 0; i < pointCount; i++) {
+                const flag = flags[i];
+                if (flag & short) {
+                    const delta = this.u8(p++);
+                    value += flag & same ? delta : -delta;
+                }
+                else if (!(flag & same)) {
+                    value += this.i16(p);
+                    p += 2;
+                }
+                coords.push(value);
+            }
+        }
+        return { xs, ys, on: Array.from(flags, f => (f & 1) === 1), ends, instructions, xMin, components: null };
+    }
     outline(glyph) {
         if (glyph >= this.numGlyphs)
             glyph = 0;
@@ -190,11 +287,11 @@ export class Font {
         return cffCharString(this.cff, glyph);
     }
 }
-function contourToPath(path, xs, ys, flags, first, last) {
+export function contourToPath(path, xs, ys, flags, first, last) {
     if (last < first)
         return;
     const count = last - first + 1;
-    const on = (i) => flags[first + (i % count)] & 1;
+    const on = (i) => flags[first + (i % count)] === true || (flags[first + (i % count)] & 1) === 1;
     const x = (i) => xs[first + (i % count)];
     const y = (i) => ys[first + (i % count)];
     let start = -1;