imagescript 3.0.0 → 3.2.0

package/dist/render/svg.js

@@ -875,14 +875,25 @@ class Layer {
     width;
     height;
     data;
+    x0 = Infinity;
+    y0 = Infinity;
+    x1 = -Infinity;
+    y1 = -Infinity;
     constructor(width, height) {
         this.width = width;
         this.height = height;
         this.data = new Float32Array(width * height * 4);
     }
+    extend(x0, y0, x1, y1) {
+        this.x0 = Math.min(this.x0, x0);
+        this.y0 = Math.min(this.y0, y0);
+        this.x1 = Math.max(this.x1, x1);
+        this.y1 = Math.max(this.y1, y1);
+    }
     fill({ x0, y0, w, h, data }, paint) {
         const d = this.data;
         const solid = paint.solid;
+        this.extend(x0, y0, x0 + w, y0 + h);
         for (let y = 0; y < h; y++) {
             let i = ((y0 + y) * this.width + x0) * 4;
             for (let x = 0, o = y * w; x < w; x++, o++, i += 4) {
@@ -921,33 +932,40 @@ class Layer {
         }
     }
     composite(layer, opacity, mask) {
+        if (layer.x1 <= layer.x0)
+            return;
+        this.extend(layer.x0, layer.y0, layer.x1, layer.y1);
         const s = layer.data, d = this.data;
-        for (let p = 0, i = 0; p < this.width * this.height; p++, i += 4) {
-            if (s[i + 3] <= 0)
-                continue;
-            const f = mask ? opacity * mask[p] : opacity;
-            if (f <= 0)
-                continue;
-            const a = s[i + 3] * f;
-            const inv = 1 - a;
-            d[i] = s[i] * f + d[i] * inv;
-            d[i + 1] = s[i + 1] * f + d[i + 1] * inv;
-            d[i + 2] = s[i + 2] * f + d[i + 2] * inv;
-            d[i + 3] = a + d[i + 3] * inv;
+        for (let y = layer.y0; y < layer.y1; y++) {
+            for (let p = y * this.width + layer.x0, end = y * this.width + layer.x1, i = p * 4; p < end; p++, i += 4) {
+                if (s[i + 3] <= 0)
+                    continue;
+                const f = mask ? opacity * mask[p] : opacity;
+                if (f <= 0)
+                    continue;
+                const a = s[i + 3] * f;
+                const inv = 1 - a;
+                d[i] = s[i] * f + d[i] * inv;
+                d[i + 1] = s[i + 1] * f + d[i + 1] * inv;
+                d[i + 2] = s[i + 2] * f + d[i + 2] * inv;
+                d[i + 3] = a + d[i + 3] * inv;
+            }
         }
     }
     toRGBA() {
         const out = new Uint8ClampedArray(this.width * this.height * 4);
         const d = this.data;
-        for (let i = 0; i < d.length; i += 4) {
-            const a = d[i + 3];
-            if (a <= 0)
-                continue;
-            const f = a >= 1 ? 255 : 255 / a;
-            out[i] = d[i] * f;
-            out[i + 1] = d[i + 1] * f;
-            out[i + 2] = d[i + 2] * f;
-            out[i + 3] = a * 255;
+        for (let y = this.y0; y < this.y1; y++) {
+            for (let i = (y * this.width + this.x0) * 4, end = (y * this.width + this.x1) * 4; i < end; i += 4) {
+                const a = d[i + 3];
+                if (a <= 0)
+                    continue;
+                const f = a >= 1 ? 255 : 255 / a;
+                out[i] = d[i] * f;
+                out[i + 1] = d[i + 1] * f;
+                out[i + 2] = d[i + 2] * f;
+                out[i + 3] = a * 255;
+            }
         }
         return new Uint8Array(out.buffer);
     }

package/dist/render/text.js

@@ -3,8 +3,10 @@
  * Copyright 2015 Google Inc., Apache License 2.0 (see THIRD_PARTY_NOTICES.md and licenses/Apache-2.0.txt)
  */
 import { Font } from "./font.js";
+import { Hinter } from "./hinting.js";
 const SUBPIXELS = 4;
 const fonts = new WeakMap();
+const hinters = new WeakMap();
 function loadFont(data) {
     let regions = fonts.get(data.buffer);
     if (!regions)
@@ -15,9 +17,18 @@ function loadFont(data) {
         regions.set(key, font = new Font(data));
     return font;
 }
-export function render(data, size, text, layout) {
+export function render(data, size, text, layout, hinting = false) {
     const font = loadFont(data);
     const scale = size / font.unitsPerEm;
+    let hinter = null;
+    if (hinting && font.outlines === 'glyf') {
+        hinter = hinters.get(font) ?? null;
+        if (!hinter)
+            hinters.set(font, hinter = new Hinter(font));
+        if (!hinter.hasInstructions)
+            hinter = null;
+    }
+    hinting = hinter !== null;
     const ascent = Math.ceil(font.ascender * scale);
     const lineHeight = Math.ceil((font.ascender - font.descender + font.lineGap) * scale);
     const glyphs = new Map();
@@ -25,14 +36,23 @@ export function render(data, size, text, layout) {
         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: [] };
+            const hinted = hinter && hinter.glyph(index, size);
+            if (hinted)
+                g = { index, path: hinted.path, scale: 1, advance: hinted.advance, ink: inkExtent(hinted.path, 1), bitmaps: [] };
+            else {
+                const path = font.outline(index);
+                const advance = font.advance(index) * scale;
+                g = { index, path, scale, advance: hinting ? Math.round(advance) : advance, 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 kern = kerning ? (left, right) => {
+        const k = kerning(left.index, right.index) * scale;
+        return hinting ? Math.round(k) : k;
+    } : () => 0;
     const lines = wrap(text, layout, glyph, kern);
     let visible = lines;
     if (isFinite(layout.maxHeight)) {
@@ -47,8 +67,10 @@ export function render(data, size, text, layout) {
     const height = visible.length * lineHeight;
     const coverage = new Uint8Array(width * height);
     visible.forEach((line, n) => {
-        const offset = layout.horizontalAlign === 'right' ? width - line.extent
+        let offset = layout.horizontalAlign === 'right' ? width - line.extent
             : layout.horizontalAlign === 'center' ? (width - line.extent) / 2 : 0;
+        if (hinting)
+            offset = Math.round(offset);
         const baseline = ascent + n * lineHeight;
         for (const { x, glyph: g } of line.glyphs) {
             if (!g.ink)
@@ -57,7 +79,7 @@ export function render(data, size, text, layout) {
             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);
+                g.bitmaps[subpixel] = rasterizeGlyph(g.path, g.scale, subpixel / SUBPIXELS);
             const bitmap = g.bitmaps[subpixel];
             if (bitmap)
                 blit(coverage, width, height, bitmap, pixel + bitmap.left, baseline - bitmap.top);
@@ -217,6 +239,8 @@ export class Rasterizer {
     line(x0, y0, x1, y1) {
         if (y0 === y1)
             return;
+        x0 = x0 < 0 ? 0 : x0 > this.width ? this.width : x0;
+        x1 = x1 < 0 ? 0 : x1 > this.width ? this.width : x1;
         let dir = 1;
         if (y0 > y1) {
             dir = -1;
@@ -232,7 +256,8 @@ export class Rasterizer {
         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;
+            let xNext = x + dxdy * dy;
+            xNext = xNext < 0 ? 0 : xNext > w ? w : xNext;
             const d = dy * dir;
             const xa = x < xNext ? x : xNext, xb = x < xNext ? xNext : x;
             const xaFloor = Math.floor(xa);

package/dist/util/optimize.js

@@ -0,0 +1,264 @@
+const ALPHA = new Int32Array(new Uint8Array([0, 0, 0, 255]).buffer)[0];
+const ALPHA_COST = 4 / 3;
+export function optimize(frames, width, height, { replace, even, alpha, palette, cover }) {
+    const size = width * height * 4;
+    const canvas = new Uint8Array(size), canvas32 = new Int32Array(canvas.buffer);
+    const shown = new Uint8Array(size), shown32 = new Int32Array(shown.buffer);
+    const output = [];
+    const state = { canvas32, shown32, width, replace };
+    let opaque = true, denseTotal = 0, chosenTotal = 0;
+    const add = (duration) => {
+        let changed = bounds(state, { x: 0, y: 0, width, height });
+        if (!changed) {
+            if (output.length)
+                output[output.length - 1].duration += duration;
+            else {
+                output.push(empty(duration));
+                opaque = false;
+            }
+            return;
+        }
+        if (even)
+            changed = evenArea(changed);
+        let area = sparse(state, changed);
+        let blend = true;
+        if (area.unblendable && replace)
+            blend = false;
+        else if (area.unblendable) {
+            const last = output[output.length - 1];
+            grow(last, union(last, area.unblendable));
+            last.dispose = true;
+            clear(shown, width, last);
+            changed = bounds(state, { x: 0, y: 0, width, height });
+            if (!changed)
+                return void output.push(empty(duration));
+            if (even)
+                changed = evenArea(changed);
+            area = sparse(state, changed);
+        }
+        const { x, y, width: w, height: h } = changed;
+        const pixels = area.pixels;
+        if (!output.length && (w !== width || h !== height))
+            opaque = false;
+        if (!area.denseOpaque)
+            opaque = false;
+        const sparseCost = alpha === 'frame' && area.denseOpaque ? area.sparseChanges * ALPHA_COST : area.sparseChanges;
+        const dense = !blend || area.denseChanges < sparseCost
+            || (palette !== undefined && colors(new Int32Array(pixels.buffer), w, { x: 0, y: 0, width: w, height: h }, palette + 1) > palette
+                && colors(canvas32, width, changed, palette + 1) <= palette);
+        denseTotal += area.denseChanges;
+        chosenTotal += dense ? area.denseChanges : area.sparseChanges;
+        if (dense) {
+            for (let row = 0; row < h; row++)
+                pixels.set(canvas.subarray(((y + row) * width + x) * 4, ((y + row) * width + x + w) * 4), row * w * 4);
+            if (replace)
+                blend = false;
+        }
+        for (let row = 0; row < h; row++) {
+            const start = ((y + row) * width + x) * 4;
+            shown.set(canvas.subarray(start, start + w * 4), start);
+        }
+        output.push({ x, y, width: w, height: h, duration, dispose: false, blend, pixels });
+    };
+    let cleared = { x: 0, y: 0, width, height };
+    for (const f of frames) {
+        const saved = f.dispose === 2 ? canvas.slice() : null;
+        const area = clip(f, width, height);
+        if (cleared && contains(cleared, area))
+            copy(canvas, width, f, area);
+        else
+            draw(canvas, width, height, f);
+        cleared = null;
+        add(f.duration);
+        if (f.dispose === 1) {
+            clear(canvas, width, area);
+            cleared = area;
+        }
+        else if (saved)
+            canvas.set(saved);
+    }
+    if (typeof alpha === 'function' && opaque && output.some(f => f.blend) && denseTotal < chosenTotal * alpha(output)) {
+        shown.fill(0);
+        for (const f of output) {
+            const pixels32 = new Int32Array(f.pixels.buffer, f.pixels.byteOffset, f.width * f.height);
+            for (let row = 0, k = 0; row < f.height; row++, k += f.width) {
+                const start = (f.y + row) * width + f.x;
+                if (!f.blend)
+                    shown32.set(pixels32.subarray(k, k + f.width), start);
+                else
+                    for (let i = k, p = start, end = k + f.width; i < end; i++, p++) {
+                        if ((pixels32[i] & ALPHA) === 0)
+                            pixels32[i] = shown32[p];
+                        else
+                            shown32[p] = pixels32[i];
+                    }
+            }
+            f.blend = false;
+        }
+    }
+    if (cover && output.length)
+        grow(output[0], { x: 0, y: 0, width, height });
+    return output;
+}
+function colors(image32, width, { x, y, width: w, height: h }, limit) {
+    const seen = new Set();
+    for (let row = y; row < y + h; row++) {
+        let previous;
+        for (let p = row * width + x, end = p + w; p < end; p++) {
+            const value = image32[p];
+            if (value === previous)
+                continue;
+            previous = value;
+            seen.add(value);
+            if (seen.size >= limit)
+                return seen.size;
+        }
+    }
+    return seen.size;
+}
+const empty = (duration) => ({ x: 0, y: 0, width: 1, height: 1, duration, dispose: false, blend: true, pixels: new Uint8Array(4) });
+function clip(r, width, height) {
+    const x = Math.max(0, r.x), y = Math.max(0, r.y);
+    return { x, y, width: Math.max(0, Math.min(width, r.x + r.width) - x), height: Math.max(0, Math.min(height, r.y + r.height) - y) };
+}
+function contains(a, b) {
+    return b.x >= a.x && b.y >= a.y && b.x + b.width <= a.x + a.width && b.y + b.height <= a.y + a.height;
+}
+function union(a, b) {
+    const x = Math.min(a.x, b.x), y = Math.min(a.y, b.y);
+    return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
+}
+function evenArea({ x, y, width, height }) {
+    return { x: x & ~1, y: y & ~1, width: width + (x & 1), height: height + (y & 1) };
+}
+function sparse({ canvas32, shown32, width, replace }, { x, y, width: w, height: h }) {
+    const pixels = new Uint8Array(w * h * 4), pixels32 = new Int32Array(pixels.buffer);
+    let sparseChanges = 0, denseChanges = 0, lastSparse = -1, lastDense = -1;
+    let left = w, right = -1, top = h, bottom = -1, translucent = 0;
+    for (let row = 0, k = 0; row < h; row++) {
+        const start = (y + row) * width + x;
+        for (let i = 0, p = start; i < w; i++, p++, k++) {
+            const value = canvas32[p], before = shown32[p];
+            if (value === before || ((value | before) & ALPHA) === 0) {
+                if (lastSparse !== 0)
+                    sparseChanges++;
+                lastSparse = 0;
+            }
+            else {
+                pixels32[k] = value;
+                if (value !== lastSparse)
+                    sparseChanges++;
+                lastSparse = value;
+                if ((value & ALPHA) !== ALPHA && (replace || (before & ALPHA) !== 0)) {
+                    if (i < left)
+                        left = i;
+                    if (i > right)
+                        right = i;
+                    if (row < top)
+                        top = row;
+                    bottom = row;
+                }
+            }
+            if (value !== lastDense) {
+                denseChanges++;
+                translucent |= ~value & ALPHA;
+            }
+            lastDense = value;
+        }
+    }
+    const unblendable = right < 0 ? null : { x: x + left, y: y + top, width: right - left + 1, height: bottom - top + 1 };
+    return { pixels, sparseChanges, denseChanges, unblendable, denseOpaque: translucent === 0 };
+}
+function bounds({ canvas32, shown32, width }, area) {
+    const x0 = area.x, x1 = area.x + area.width, y0 = area.y, y1 = area.y + area.height;
+    const test = (p) => {
+        const c = canvas32[p], s = shown32[p];
+        return c !== s && ((c | s) & ALPHA) !== 0;
+    };
+    const rowHas = (y, from, to) => {
+        for (let x = from, p = y * width + from; x < to; x++, p++)
+            if (test(p))
+                return x;
+        return -1;
+    };
+    let top = y0, first = -1;
+    for (; top < y1; top++)
+        if ((first = rowHas(top, x0, x1)) >= 0)
+            break;
+    if (top === y1)
+        return null;
+    let bottom = y1 - 1;
+    while (bottom > top && rowHas(bottom, x0, x1) < 0)
+        bottom--;
+    let left = first, right = first;
+    for (let y = top; y <= bottom; y++) {
+        if (left > x0) {
+            const x = rowHas(y, x0, left);
+            if (x >= 0)
+                left = x;
+        }
+        for (let x = x1 - 1, p = y * width + x; x > right; x--, p--)
+            if (test(p)) {
+                right = x;
+                break;
+            }
+    }
+    return { x: left, y: top, width: right - left + 1, height: bottom - top + 1 };
+}
+function draw(canvas, width, height, f) {
+    const { x: x0, y: y0, width: w, height: h } = clip(f, width, height);
+    const pixels = f.pixels.byteOffset % 4 ? f.pixels.slice() : f.pixels;
+    const src = new Int32Array(pixels.buffer, pixels.byteOffset, f.width * f.height);
+    const dst = new Int32Array(canvas.buffer, canvas.byteOffset, width * height);
+    for (let y = y0; y < y0 + h; y++)
+        for (let x = x0, s = (y - f.y) * f.width + x - f.x, d = y * width + x; x < x0 + w; x++, s++, d++) {
+            let n = 0;
+            while (n < x0 + w - x && (src[s + n] & ALPHA) === ALPHA)
+                n++;
+            if (n) {
+                if (n >= 16)
+                    dst.set(src.subarray(s, s + n), d);
+                else
+                    for (let i = 0; i < n; i++)
+                        dst[d + i] = src[s + i];
+                x += n - 1;
+                s += n - 1;
+                d += n - 1;
+                continue;
+            }
+            const value = src[s], alpha = value & ALPHA;
+            if (alpha === 0)
+                continue;
+            if (alpha === ALPHA || (dst[d] & ALPHA) === 0)
+                dst[d] = value;
+            else {
+                const sa = pixels[s * 4 + 3], da = canvas[d * 4 + 3];
+                const u = sa * 255, v = (255 - sa) * da, al = u + v;
+                for (let c = 0; c < 3; c++)
+                    canvas[d * 4 + c] = (pixels[s * 4 + c] * u + canvas[d * 4 + c] * v) / al | 0;
+                canvas[d * 4 + 3] = al / 255 | 0;
+            }
+        }
+}
+function copy(canvas, width, f, { x, y, width: w, height: h }) {
+    const canvas32 = new Int32Array(canvas.buffer, canvas.byteOffset, width * (y + h));
+    for (let row = y; row < y + h; row++) {
+        const s = ((row - f.y) * f.width + x - f.x) * 4, d = row * width + x;
+        canvas.set(f.pixels.subarray(s, s + w * 4), d * 4);
+        for (let p = d; p < d + w; p++)
+            if ((canvas32[p] & ALPHA) === 0)
+                canvas32[p] = 0;
+    }
+}
+function clear(canvas, width, r) {
+    for (let y = r.y; y < r.y + r.height; y++)
+        canvas.fill(0, (y * width + r.x) * 4, (y * width + r.x + r.width) * 4);
+}
+function grow(frame, area) {
+    if (area.x === frame.x && area.y === frame.y && area.width === frame.width && area.height === frame.height)
+        return;
+    const pixels = new Uint8Array(area.width * area.height * 4);
+    for (let row = 0; row < frame.height; row++)
+        pixels.set(frame.pixels.subarray(row * frame.width * 4, (row + 1) * frame.width * 4), ((frame.y - area.y + row) * area.width + frame.x - area.x) * 4);
+    Object.assign(frame, area, { pixels });
+}

package/dist/util/options.js

@@ -0,0 +1,3 @@
+export function isOptions(value) {
+    return typeof value === 'object' && value !== null && !ArrayBuffer.isView(value);
+}

package/dist/util/resample.js

@@ -40,33 +40,33 @@ function coefficients(inSize, outSize, filter) {
 }
 export function resample(src, width, height, outWidth, outHeight, filter, out) {
     let plane = new Float32Array(outWidth * height * 4);
-    const horizontal = outWidth !== width ? coefficients(width, outWidth, filter) : null;
-    for (let y = 0; y < height; y++) {
-        const row = y * width * 4;
-        for (let x = 0; x < outWidth; x++) {
-            let r = 0, g = 0, b = 0, a = 0;
-            if (horizontal) {
-                const { start, count, weights, size } = horizontal;
-                for (let k = 0, s = row + start[x] * 4; k < count[x]; k++, s += 4) {
-                    const wa = weights[x * size + k] * src[s + 3];
+    if (outWidth !== width) {
+        const { start, count, weights, size } = coefficients(width, outWidth, filter);
+        for (let y = 0, o = 0; y < height; y++) {
+            const row = y * width * 4;
+            for (let x = 0; x < outWidth; x++, o += 4) {
+                let r = 0, g = 0, b = 0, a = 0;
+                for (let k = 0, s = row + start[x] * 4, w = x * size, n = count[x]; k < n; k++, s += 4) {
+                    const wa = weights[w + k] * src[s + 3];
                     r += src[s] * wa;
                     g += src[s + 1] * wa;
                     b += src[s + 2] * wa;
                     a += wa;
                 }
+                plane[o] = r / 255;
+                plane[o + 1] = g / 255;
+                plane[o + 2] = b / 255;
+                plane[o + 3] = a;
             }
-            else {
-                const s = row + x * 4;
-                a = src[s + 3];
-                r = src[s] * a;
-                g = src[s + 1] * a;
-                b = src[s + 2] * a;
-            }
-            const o = (y * outWidth + x) * 4;
-            plane[o] = r / 255;
-            plane[o + 1] = g / 255;
-            plane[o + 2] = b / 255;
-            plane[o + 3] = a;
+        }
+    }
+    else {
+        for (let s = 0; s < plane.length; s += 4) {
+            const a = src[s + 3];
+            plane[s] = src[s] * a / 255;
+            plane[s + 1] = src[s + 1] * a / 255;
+            plane[s + 2] = src[s + 2] * a / 255;
+            plane[s + 3] = a;
         }
     }
     if (outHeight !== height) {
@@ -74,12 +74,30 @@ export function resample(src, width, height, outWidth, outHeight, filter, out) {
         const next = new Float32Array(outWidth * outHeight * 4);
         const stride = outWidth * 4;
         for (let y = 0; y < outHeight; y++) {
-            const o = y * stride;
-            for (let k = 0; k < count[y]; k++) {
-                const w = weights[y * size + k];
-                const s = (start[y] + k) * stride;
+            const o = y * stride, n = count[y], w = y * size;
+            const s0 = start[y] * stride, s1 = s0 + stride, s2 = s1 + stride, s3 = s2 + stride;
+            const w0 = weights[w], w1 = weights[w + 1], w2 = weights[w + 2], w3 = weights[w + 3];
+            if (n === 1)
+                for (let x = 0; x < stride; x++)
+                    next[o + x] = 0 + plane[s0 + x] * w0;
+            else if (n === 2)
+                for (let x = 0; x < stride; x++)
+                    next[o + x] = Math.fround(0 + plane[s0 + x] * w0) + plane[s1 + x] * w1;
+            else if (n === 3) {
                 for (let x = 0; x < stride; x++)
-                    next[o + x] += plane[s + x] * w;
+                    next[o + x] = Math.fround(Math.fround(0 + plane[s0 + x] * w0) + plane[s1 + x] * w1) + plane[s2 + x] * w2;
+            }
+            else if (n === 4) {
+                for (let x = 0; x < stride; x++)
+                    next[o + x] = Math.fround(Math.fround(Math.fround(0 + plane[s0 + x] * w0) + plane[s1 + x] * w1) + plane[s2 + x] * w2) + plane[s3 + x] * w3;
+            }
+            else {
+                for (let x = 0; x < stride; x++) {
+                    let sum = 0;
+                    for (let k = 0, s = s0 + x; k < n; k++, s += stride)
+                        sum = Math.fround(sum + plane[s] * weights[w + k]);
+                    next[o + x] = sum;
+                }
             }
         }
         plane = next;

package/dist/util/utf8.js

@@ -1,55 +1,8 @@
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
 export function encode(text) {
-    const out = [];
-    for (const char of text) {
-        const c = char.codePointAt(0);
-        if (c < 0x80)
-            out.push(c);
-        else if (c < 0x800)
-            out.push(0xc0 | c >> 6, 0x80 | c & 63);
-        else if (c < 0x10000)
-            out.push(0xe0 | c >> 12, 0x80 | c >> 6 & 63, 0x80 | c & 63);
-        else
-            out.push(0xf0 | c >> 18, 0x80 | c >> 12 & 63, 0x80 | c >> 6 & 63, 0x80 | c & 63);
-    }
-    return Uint8Array.from(out);
+    return encoder.encode(text);
 }
 export function decode(bytes) {
-    let out = '';
-    let i = bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf ? 3 : 0;
-    while (i < bytes.length) {
-        const b = bytes[i++];
-        let c, extra;
-        if (b < 0x80) {
-            c = b;
-            extra = 0;
-        }
-        else if (b >= 0xc2 && b < 0xe0) {
-            c = b & 31;
-            extra = 1;
-        }
-        else if (b >= 0xe0 && b < 0xf0) {
-            c = b & 15;
-            extra = 2;
-        }
-        else if (b >= 0xf0 && b < 0xf5) {
-            c = b & 7;
-            extra = 3;
-        }
-        else {
-            out += '�';
-            continue;
-        }
-        let valid = true;
-        for (let k = 0; k < extra; k++) {
-            const next = bytes[i];
-            if (next === undefined || (next & 0xc0) !== 0x80) {
-                valid = false;
-                break;
-            }
-            c = c << 6 | next & 63;
-            i++;
-        }
-        out += valid && c <= 0x10ffff ? String.fromCodePoint(c) : '�';
-    }
-    return out;
+    return decoder.decode(bytes);
 }

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '3.0.0';
+export const VERSION = '3.2.0';