imagescript 1.3.0 → 3.0.0

package/dist/render/text.d.ts

@@ -0,0 +1,61 @@
+/*!
+ * The Rasterizer class is translated from font-rs (https://github.com/raphlinus/font-rs)
+ * Copyright 2015 Google Inc., Apache License 2.0 (see THIRD_PARTY_NOTICES.md and licenses/Apache-2.0.txt)
+ */
+import { PathCommand } from './font.js';
+export interface Layout {
+    maxWidth: number;
+    maxHeight: number;
+    wrapStyle: 'word' | 'char';
+    horizontalAlign: 'left' | 'center' | 'right';
+    verticalAlign: 'top' | 'middle' | 'bottom';
+    wrapHardBreaks: boolean;
+}
+export interface GlyphBitmap {
+    data: Uint8Array;
+    width: number;
+    height: number;
+    /** offset from the pen position */
+    left: number;
+    /** offset above the baseline */
+    top: number;
+}
+/**
+ * Lays out and rasterizes text
+ * Lines start at ceil(ascender) and advance by ceil(ascender - descender + lineGap); glyphs are placed with
+ * subpixel precision using their advance widths and the font's kerning; the canvas spans from the origin to the
+ * furthest glyph edge
+ * @param {Uint8Array} data TrueType/OpenType font
+ * @param {number} size font size in pixels per em
+ * @param {string} text
+ * @param {Layout} layout
+ * @return {{width: number, height: number, coverage: Uint8Array}}
+ */
+export declare function render(data: Uint8Array, size: number, text: string, layout: Layout): {
+    width: number;
+    height: number;
+    coverage: Uint8Array;
+};
+/**
+ * Rasterizes a glyph outline into an 8-bit coverage bitmap
+ * @param {Array} path outline in font units (y up)
+ * @param {number} scale pixels per font unit
+ * @param {number} [offset=0] horizontal subpixel offset
+ * @return {{data: Uint8Array, width: number, height: number, left: number, top: number}|null}
+ *     left/top position the bitmap relative to the pen position on the baseline (top is measured upwards)
+ */
+export declare function rasterizeGlyph(path: PathCommand[], scale: number, offset?: number): GlyphBitmap | null;
+/**
+ * Signed area coverage rasterizer: every line segment adds its area to an accumulation buffer,
+ * a prefix sum over each row yields the coverage
+ */
+export declare class Rasterizer {
+    width: number;
+    height: number;
+    accumulation: Float32Array;
+    constructor(width: number, height: number);
+    line(x0: number, y0: number, x1: number, y1: number): void;
+    quad(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number): void;
+    cubic(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void;
+    coverage(): Uint8Array;
+}

package/dist/render/text.js

@@ -0,0 +1,317 @@
+/*!
+ * The Rasterizer class is translated from font-rs (https://github.com/raphlinus/font-rs)
+ * Copyright 2015 Google Inc., Apache License 2.0 (see THIRD_PARTY_NOTICES.md and licenses/Apache-2.0.txt)
+ */
+import { Font } from "./font.js";
+const SUBPIXELS = 4;
+const fonts = new WeakMap();
+function loadFont(data) {
+    let regions = fonts.get(data.buffer);
+    if (!regions)
+        fonts.set(data.buffer, regions = new Map());
+    const key = `${data.byteOffset}:${data.byteLength}`;
+    let font = regions.get(key);
+    if (!font)
+        regions.set(key, font = new Font(data));
+    return font;
+}
+export function render(data, size, text, layout) {
+    const font = loadFont(data);
+    const scale = size / font.unitsPerEm;
+    const ascent = Math.ceil(font.ascender * scale);
+    const lineHeight = Math.ceil((font.ascender - font.descender + font.lineGap) * scale);
+    const glyphs = new Map();
+    const glyph = (codepoint) => {
+        let g = glyphs.get(codepoint);
+        if (!g) {
+            const index = font.glyphIndex(codepoint);
+            const path = font.outline(index);
+            g = { index, advance: font.advance(index) * scale, ink: inkExtent(path, scale), bitmaps: [] };
+            glyphs.set(codepoint, g);
+        }
+        return g;
+    };
+    const kerning = font.kerning;
+    const kern = kerning ? (left, right) => kerning(left.index, right.index) * scale : () => 0;
+    const lines = wrap(text, layout, glyph, kern);
+    let visible = lines;
+    if (isFinite(layout.maxHeight)) {
+        const count = Math.max(1, Math.floor(layout.maxHeight / lineHeight));
+        if (count < lines.length) {
+            const start = layout.verticalAlign === 'bottom' ? lines.length - count
+                : layout.verticalAlign === 'middle' ? lines.length - count >> 1 : 0;
+            visible = lines.slice(start, start + count);
+        }
+    }
+    const width = Math.ceil(Math.max(0, ...visible.map(line => line.extent)));
+    const height = visible.length * lineHeight;
+    const coverage = new Uint8Array(width * height);
+    visible.forEach((line, n) => {
+        const offset = layout.horizontalAlign === 'right' ? width - line.extent
+            : layout.horizontalAlign === 'center' ? (width - line.extent) / 2 : 0;
+        const baseline = ascent + n * lineHeight;
+        for (const { x, glyph: g } of line.glyphs) {
+            if (!g.ink)
+                continue;
+            const position = Math.round((offset + x) * SUBPIXELS) / SUBPIXELS;
+            const pixel = Math.floor(position);
+            const subpixel = Math.round((position - pixel) * SUBPIXELS);
+            if (g.bitmaps[subpixel] === undefined)
+                g.bitmaps[subpixel] = rasterizeGlyph(font.outline(g.index), scale, subpixel / SUBPIXELS);
+            const bitmap = g.bitmaps[subpixel];
+            if (bitmap)
+                blit(coverage, width, height, bitmap, pixel + bitmap.left, baseline - bitmap.top);
+        }
+    });
+    return { width, height, coverage };
+}
+function inkExtent(path, scale) {
+    let left = Infinity, right = -Infinity;
+    for (const command of path)
+        for (let i = 1; i < command.length; i += 2) {
+            left = Math.min(left, command[i] * scale);
+            right = Math.max(right, command[i] * scale);
+        }
+    return right > left ? { left, right } : null;
+}
+function wrap(text, layout, glyph, kern) {
+    const lines = [];
+    const paragraphs = layout.wrapHardBreaks ? text.split(/\r\n|\r|\n/) : [text.replace(/\r\n|\r|\n/g, '')];
+    const edge = (x, g) => g.ink ? x + g.ink.right : 0;
+    for (const paragraph of paragraphs) {
+        let line = { glyphs: [], extent: 0, soft: false };
+        let x = 0;
+        let breakAt = -1;
+        const next = (g) => line.glyphs.length ? x + kern(line.glyphs[line.glyphs.length - 1].glyph, g) : x;
+        const add = (g) => {
+            const position = next(g);
+            line.glyphs.push({ x: position, glyph: g });
+            line.extent = Math.max(line.extent, edge(position, g));
+            x = position + g.advance;
+        };
+        const newLine = () => {
+            lines.push(line);
+            line = { glyphs: [], extent: 0, soft: true };
+            x = 0;
+            breakAt = -1;
+        };
+        for (const char of paragraph) {
+            const codepoint = char.codePointAt(0);
+            const g = glyph(codepoint);
+            const space = codepoint === 0x20 || codepoint === 0x09;
+            if (!space && line.glyphs.length && edge(next(g), g) > layout.maxWidth) {
+                if (layout.wrapStyle === 'word' && breakAt > 0) {
+                    const word = line.glyphs.splice(breakAt);
+                    line.extent = measure(line.glyphs, edge);
+                    newLine();
+                    for (const item of word)
+                        add(item.glyph);
+                }
+                else
+                    newLine();
+            }
+            if (space && line.soft && !line.glyphs.length)
+                continue;
+            add(g);
+            if (space)
+                breakAt = line.glyphs.length;
+        }
+        lines.push(line);
+    }
+    return lines;
+}
+function measure(glyphs, edge) {
+    let extent = 0;
+    for (const { x, glyph } of glyphs)
+        extent = Math.max(extent, edge(x, glyph));
+    return extent;
+}
+function blit(target, width, height, bitmap, x0, y0) {
+    for (let y = 0; y < bitmap.height; y++) {
+        const ty = y0 + y;
+        if (ty < 0 || ty >= height)
+            continue;
+        for (let x = 0; x < bitmap.width; x++) {
+            const tx = x0 + x;
+            if (tx < 0 || tx >= width)
+                continue;
+            const v = bitmap.data[y * bitmap.width + x];
+            if (v) {
+                const o = ty * width + tx;
+                target[o] = Math.min(255, target[o] + v);
+            }
+        }
+    }
+}
+export function rasterizeGlyph(path, scale, offset = 0) {
+    if (!path.length)
+        return null;
+    let xmin = Infinity, ymin = Infinity, xmax = -Infinity, ymax = -Infinity;
+    for (const command of path)
+        for (let i = 1; i < command.length; i += 2) {
+            const x = command[i] * scale + offset, y = command[i + 1] * scale;
+            if (x < xmin)
+                xmin = x;
+            if (x > xmax)
+                xmax = x;
+            if (y < ymin)
+                ymin = y;
+            if (y > ymax)
+                ymax = y;
+        }
+    const left = Math.floor(xmin), right = Math.ceil(xmax);
+    const bottom = Math.floor(ymin), top = Math.ceil(ymax);
+    const width = right - left, height = top - bottom;
+    if (width <= 0 || height <= 0)
+        return null;
+    const raster = new Rasterizer(width, height);
+    const tx = (x) => x * scale + offset - left;
+    const ty = (y) => top - y * scale;
+    let sx = 0, sy = 0, cx = 0, cy = 0;
+    for (const command of path) {
+        switch (command[0]) {
+            case 'M':
+                sx = cx = tx(command[1]);
+                sy = cy = ty(command[2]);
+                break;
+            case 'L': {
+                const x = tx(command[1]), y = ty(command[2]);
+                raster.line(cx, cy, x, y);
+                cx = x;
+                cy = y;
+                break;
+            }
+            case 'Q': {
+                const x = tx(command[3]), y = ty(command[4]);
+                raster.quad(cx, cy, tx(command[1]), ty(command[2]), x, y);
+                cx = x;
+                cy = y;
+                break;
+            }
+            case 'C': {
+                const x = tx(command[5]), y = ty(command[6]);
+                raster.cubic(cx, cy, tx(command[1]), ty(command[2]), tx(command[3]), ty(command[4]), x, y);
+                cx = x;
+                cy = y;
+                break;
+            }
+            case 'Z':
+                if (cx !== sx || cy !== sy)
+                    raster.line(cx, cy, sx, sy);
+                cx = sx;
+                cy = sy;
+                break;
+        }
+    }
+    return { data: raster.coverage(), width, height, left, top };
+}
+export class Rasterizer {
+    width;
+    height;
+    accumulation;
+    constructor(width, height) {
+        this.width = width;
+        this.height = height;
+        this.accumulation = new Float32Array(width * height + 4);
+    }
+    line(x0, y0, x1, y1) {
+        if (y0 === y1)
+            return;
+        let dir = 1;
+        if (y0 > y1) {
+            dir = -1;
+            [x0, y0, x1, y1] = [x1, y1, x0, y0];
+        }
+        const a = this.accumulation;
+        const w = this.width;
+        const dxdy = (x1 - x0) / (y1 - y0);
+        let x = x0;
+        if (y0 < 0)
+            x -= y0 * dxdy;
+        const yEnd = Math.min(this.height, Math.ceil(y1));
+        for (let y = Math.max(0, y0 | 0); y < yEnd; y++) {
+            const lineStart = y * w;
+            const dy = Math.min(y + 1, y1) - Math.max(y, y0);
+            const xNext = x + dxdy * dy;
+            const d = dy * dir;
+            const xa = x < xNext ? x : xNext, xb = x < xNext ? xNext : x;
+            const xaFloor = Math.floor(xa);
+            const xai = xaFloor;
+            const xbCeil = Math.ceil(xb);
+            const xbi = xbCeil;
+            const index = lineStart + xai;
+            if (index >= 0) {
+                if (xbi <= xai + 1) {
+                    const xmf = 0.5 * (x + xNext) - xaFloor;
+                    a[index] += d - d * xmf;
+                    a[index + 1] += d * xmf;
+                }
+                else {
+                    const s = 1 / (xb - xa);
+                    const xaf = xa - xaFloor;
+                    const a0 = 0.5 * s * (1 - xaf) * (1 - xaf);
+                    const xbf = xb - xbCeil + 1;
+                    const am = 0.5 * s * xbf * xbf;
+                    a[index] += d * a0;
+                    if (xbi === xai + 2)
+                        a[index + 1] += d * (1 - a0 - am);
+                    else {
+                        const a1 = s * (1.5 - xaf);
+                        a[index + 1] += d * (a1 - a0);
+                        for (let xi = xai + 2; xi < xbi - 1; xi++)
+                            a[lineStart + xi] += d * s;
+                        const a2 = a1 + (xbi - xai - 3) * s;
+                        a[lineStart + xbi - 1] += d * (1 - a2 - am);
+                    }
+                    a[lineStart + xbi] += d * am;
+                }
+            }
+            x = xNext;
+        }
+    }
+    quad(x0, y0, x1, y1, x2, y2) {
+        const devx = x0 - 2 * x1 + x2;
+        const devy = y0 - 2 * y1 + y2;
+        const devsq = devx * devx + devy * devy;
+        if (devsq < 0.333)
+            return this.line(x0, y0, x2, y2);
+        const n = 1 + Math.floor(Math.sqrt(Math.sqrt(3 * devsq)));
+        let px = x0, py = y0;
+        for (let i = 1; i <= n; i++) {
+            const t = i / n, mt = 1 - t;
+            const x = mt * mt * x0 + 2 * mt * t * x1 + t * t * x2;
+            const y = mt * mt * y0 + 2 * mt * t * y1 + t * t * y2;
+            this.line(px, py, x, y);
+            px = x;
+            py = y;
+        }
+    }
+    cubic(x0, y0, x1, y1, x2, y2, x3, y3) {
+        const dx = Math.max(Math.abs(x0 - 2 * x1 + x2), Math.abs(x1 - 2 * x2 + x3));
+        const dy = Math.max(Math.abs(y0 - 2 * y1 + y2), Math.abs(y1 - 2 * y2 + y3));
+        const devsq = dx * dx + dy * dy;
+        if (devsq < 0.333)
+            return this.line(x0, y0, x3, y3);
+        const n = 1 + Math.floor(Math.sqrt(Math.sqrt(6 * devsq)));
+        let px = x0, py = y0;
+        for (let i = 1; i <= n; i++) {
+            const t = i / n, mt = 1 - t;
+            const x = mt * mt * mt * x0 + 3 * mt * mt * t * x1 + 3 * mt * t * t * x2 + t * t * t * x3;
+            const y = mt * mt * mt * y0 + 3 * mt * mt * t * y1 + 3 * mt * t * t * y2 + t * t * t * y3;
+            this.line(px, py, x, y);
+            px = x;
+            py = y;
+        }
+    }
+    coverage() {
+        const length = this.width * this.height;
+        const out = new Uint8Array(length);
+        let acc = 0;
+        for (let i = 0; i < length; i++) {
+            acc += this.accumulation[i];
+            const v = acc < 0 ? -acc : acc;
+            out[i] = v >= 1 ? 255 : v * 255 + 0.5 | 0;
+        }
+        return out;
+    }
+}

package/dist/text-layout.d.ts

@@ -0,0 +1,46 @@
+/** Where lines are wrapped: between words or at any character */
+export type WrapStyle = 'word' | 'char';
+/** Alignment of the lines relative to the widest line */
+export type HorizontalAlign = 'left' | 'center' | 'right';
+/** Which lines to keep when the text is cut off at `maxHeight` */
+export type VerticalAlign = 'top' | 'middle' | 'bottom';
+/** Options of {@link TextLayout} */
+export interface TextLayoutOptions {
+    /** Longer lines are wrapped. Default: `Infinity` */
+    maxWidth?: number;
+    /** Lines that don't fit are cut off. Default: `Infinity` */
+    maxHeight?: number;
+    /** Whether to wrap between words or at any character. Default: `'word'` */
+    wrapStyle?: WrapStyle;
+    /**
+     * Alignment of the lines relative to the widest line. Default: `'left'`
+     * (before 3.0 this was called verticalAlign, values are accepted under either name)
+     */
+    horizontalAlign?: HorizontalAlign | VerticalAlign;
+    /**
+     * Which lines to keep when cutting off at `maxHeight`. Default: `'top'`
+     * (before 3.0 this was called horizontalAlign, values are accepted under either name)
+     */
+    verticalAlign?: VerticalAlign | HorizontalAlign;
+    /** Whether to break lines at newline characters. Default: `true` */
+    wrapHardBreaks?: boolean;
+}
+/**
+ * Layout options for {@link Image.renderText}
+ */
+export declare class TextLayout {
+    /** Longer lines are wrapped */
+    maxWidth: number;
+    /** Lines that don't fit are cut off */
+    maxHeight: number;
+    /** Whether to wrap between words or at any character */
+    wrapStyle: WrapStyle;
+    /** Alignment of the lines relative to the widest line */
+    horizontalAlign: HorizontalAlign;
+    /** Which lines to keep when cutting off at `maxHeight` */
+    verticalAlign: VerticalAlign;
+    /** Whether to break lines at newline characters */
+    wrapHardBreaks: boolean;
+    /** @param options See {@link TextLayoutOptions} */
+    constructor(options?: TextLayoutOptions);
+}

package/dist/text-layout.js

@@ -0,0 +1,35 @@
+const HORIZONTAL = ['left', 'center', 'right'];
+const VERTICAL = ['top', 'middle', 'bottom'];
+export class TextLayout {
+    maxWidth;
+    maxHeight;
+    wrapStyle;
+    horizontalAlign = 'left';
+    verticalAlign = 'top';
+    wrapHardBreaks;
+    constructor(options = {}) {
+        const { maxWidth, maxHeight, wrapStyle, verticalAlign, horizontalAlign, wrapHardBreaks } = options;
+        this.maxWidth = maxWidth || Infinity;
+        if (isNaN(this.maxWidth) || this.maxWidth < 1)
+            throw new RangeError('Invalid maxWidth');
+        this.maxHeight = maxHeight || Infinity;
+        if (isNaN(this.maxHeight) || this.maxHeight < 1)
+            throw new RangeError('Invalid maxHeight');
+        this.wrapStyle = wrapStyle || 'word';
+        if (!['word', 'char'].includes(this.wrapStyle))
+            throw new RangeError('Invalid wrapStyle');
+        for (const value of [horizontalAlign, verticalAlign]) {
+            if (value === undefined)
+                continue;
+            if (HORIZONTAL.includes(value))
+                this.horizontalAlign = value;
+            else if (VERTICAL.includes(value))
+                this.verticalAlign = value;
+            else
+                throw new RangeError(`Invalid alignment: ${value}`);
+        }
+        this.wrapHardBreaks = typeof wrapHardBreaks === 'undefined' ? true : wrapHardBreaks;
+        if (typeof this.wrapHardBreaks !== 'boolean')
+            throw new TypeError('Invalid wrapHardBreaks');
+    }
+}

package/dist/util/blur.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Blurs premultiplied RGBA float pixels in place
+ * @param sigma standard deviation of the gaussian in pixels
+ */
+export declare function gaussianBlur(pixels: Float32Array, width: number, height: number, sigma: number): void;
+/**
+ * Converts 8-bit RGBA to premultiplied floats
+ */
+export declare function premultiply(rgba: Uint8ClampedArray): Float32Array;
+/**
+ * Converts premultiplied floats back to 8-bit RGBA (the clamped output rounds)
+ */
+export declare function unpremultiply(pixels: Float32Array, out: Uint8ClampedArray): void;

package/dist/util/blur.js

@@ -0,0 +1,146 @@
+function boxSizes(sigma) {
+    const n = 3;
+    let lower = Math.floor(Math.sqrt(12 * sigma * sigma / n + 1));
+    if (lower % 2 === 0)
+        lower--;
+    const upper = lower + 2;
+    const m = Math.round((12 * sigma * sigma - n * lower * lower - 4 * n * lower - 3 * n) / (-4 * lower - 4));
+    return Array.from({ length: n }, (_, i) => i < m ? lower : upper);
+}
+function boxPass(src, dst, count, length, lineStride, step, radius) {
+    const scale = 1 / (2 * radius + 1);
+    const last = (length - 1) * step;
+    for (let line = 0; line < count; line++) {
+        const base = line * lineStride;
+        const first = base, end = base + last;
+        let r = 0, g = 0, b = 0, a = 0;
+        for (let k = -radius; k <= radius; k++) {
+            const o = k < 0 ? first : Math.min(end, base + k * step);
+            r += src[o];
+            g += src[o + 1];
+            b += src[o + 2];
+            a += src[o + 3];
+        }
+        for (let i = 0, o = base; i < length; i++, o += step) {
+            dst[o] = r * scale;
+            dst[o + 1] = g * scale;
+            dst[o + 2] = b * scale;
+            dst[o + 3] = a * scale;
+            const add = Math.min(end, o + (radius + 1) * step), remove = Math.max(first, o - radius * step);
+            r += src[add] - src[remove];
+            g += src[add + 1] - src[remove + 1];
+            b += src[add + 2] - src[remove + 2];
+            a += src[add + 3] - src[remove + 3];
+        }
+    }
+}
+function boxPassRows(src, dst, width, height, radius) {
+    const stride = width * 4;
+    const scale = 1 / (2 * radius + 1);
+    const sum = new Float64Array(stride);
+    const row = (y) => (y < 0 ? 0 : y >= height ? height - 1 : y) * stride;
+    for (let k = -radius; k <= radius; k++) {
+        const o = row(k);
+        for (let x = 0; x < stride; x++)
+            sum[x] += src[o + x];
+    }
+    for (let y = 0; y < height; y++) {
+        const o = y * stride, add = row(y + radius + 1), remove = row(y - radius);
+        for (let x = 0; x < stride; x++) {
+            dst[o + x] = sum[x] * scale;
+            sum[x] += src[add + x] - src[remove + x];
+        }
+    }
+}
+function gaussianKernel(sigma) {
+    const radius = Math.ceil(3 * sigma);
+    const kernel = new Float64Array(2 * radius + 1);
+    let total = 0;
+    for (let i = -radius; i <= radius; i++)
+        total += kernel[i + radius] = Math.exp(-i * i / (2 * sigma * sigma));
+    for (let i = 0; i < kernel.length; i++)
+        kernel[i] /= total;
+    return kernel;
+}
+function kernelPass(src, dst, count, length, lineStride, step, kernel) {
+    const radius = (kernel.length - 1) / 2;
+    const last = length - 1;
+    for (let line = 0; line < count; line++) {
+        const base = line * lineStride;
+        for (let i = 0; i < length; i++) {
+            let r = 0, g = 0, b = 0, a = 0;
+            for (let k = -radius; k <= radius; k++) {
+                const j = i + k;
+                const o = base + (j < 0 ? 0 : j > last ? last : j) * step;
+                const w = kernel[k + radius];
+                r += src[o] * w;
+                g += src[o + 1] * w;
+                b += src[o + 2] * w;
+                a += src[o + 3] * w;
+            }
+            const o = base + i * step;
+            dst[o] = r;
+            dst[o + 1] = g;
+            dst[o + 2] = b;
+            dst[o + 3] = a;
+        }
+    }
+}
+function kernelPassRows(src, dst, width, height, kernel) {
+    const stride = width * 4;
+    const radius = (kernel.length - 1) / 2;
+    for (let y = 0; y < height; y++) {
+        const o = y * stride;
+        for (let k = -radius; k <= radius; k++) {
+            const j = y + k;
+            const s = (j < 0 ? 0 : j >= height ? height - 1 : j) * stride;
+            const w = kernel[k + radius];
+            for (let x = 0; x < stride; x++)
+                dst[o + x] += src[s + x] * w;
+        }
+    }
+}
+export function gaussianBlur(pixels, width, height, sigma) {
+    if (!(sigma > 0))
+        return;
+    const tmp = new Float32Array(pixels.length);
+    if (sigma < 2) {
+        const kernel = gaussianKernel(sigma);
+        kernelPass(pixels, tmp, height, width, width * 4, 4, kernel);
+        pixels.fill(0);
+        kernelPassRows(tmp, pixels, width, height, kernel);
+        return;
+    }
+    for (const size of boxSizes(sigma)) {
+        const radius = (size - 1) / 2;
+        if (radius < 1)
+            continue;
+        boxPass(pixels, tmp, height, width, width * 4, 4, radius);
+        boxPassRows(tmp, pixels, width, height, radius);
+    }
+}
+export function premultiply(rgba) {
+    const out = new Float32Array(rgba.length);
+    for (let i = 0; i < rgba.length; i += 4) {
+        const a = rgba[i + 3];
+        out[i] = rgba[i] * a / 255;
+        out[i + 1] = rgba[i + 1] * a / 255;
+        out[i + 2] = rgba[i + 2] * a / 255;
+        out[i + 3] = a;
+    }
+    return out;
+}
+export function unpremultiply(pixels, out) {
+    for (let i = 0; i < pixels.length; i += 4) {
+        const a = pixels[i + 3];
+        if (a < 0.5) {
+            out[i] = out[i + 1] = out[i + 2] = out[i + 3] = 0;
+            continue;
+        }
+        const f = 255 / a;
+        out[i] = pixels[i] * f;
+        out[i + 1] = pixels[i + 1] * f;
+        out[i + 2] = pixels[i + 2] * f;
+        out[i + 3] = a;
+    }
+}

package/dist/util/mem.d.ts

@@ -0,0 +1,10 @@
+/** Data accepted wherever binary input is expected */
+export type BinaryData = ArrayBuffer | ArrayBufferView;
+/**
+ * Returns a Uint8Array view of the given buffer without copying
+ */
+export declare function view(buffer: BinaryData): Uint8Array;
+/**
+ * Concatenates byte arrays
+ */
+export declare function concat(parts: ArrayLike<number>[]): Uint8Array;

package/dist/util/mem.js

@@ -0,0 +1,23 @@
+export function view(buffer) {
+    if (buffer instanceof Uint8Array && buffer.constructor === Uint8Array)
+        return buffer;
+    if (buffer instanceof ArrayBuffer)
+        return new Uint8Array(buffer);
+    if (ArrayBuffer.isView(buffer))
+        return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    if (typeof SharedArrayBuffer !== 'undefined' && buffer instanceof SharedArrayBuffer)
+        return new Uint8Array(buffer);
+    throw new TypeError('The provided value is not of type \'(ArrayBuffer or ArrayBufferView)\'');
+}
+export function concat(parts) {
+    let length = 0;
+    for (const part of parts)
+        length += part.length;
+    const out = new Uint8Array(length);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}

package/dist/util/resample.d.ts

@@ -0,0 +1,12 @@
+export interface Filter {
+    /** radius of the filter at scale 1 */
+    support: number;
+    weight: (x: number) => number;
+}
+export declare const BOX: Filter;
+export declare const TRIANGLE: Filter;
+export declare const CUBIC: Filter;
+/**
+ * Resamples RGBA pixels with the given filter, in premultiplied alpha so transparent pixels don't bleed their color
+ */
+export declare function resample(src: Uint8ClampedArray, width: number, height: number, outWidth: number, outHeight: number, filter: Filter, out: Uint8ClampedArray): void;