@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/format/compression.js

@@ -0,0 +1,200 @@
+/**
+ * Compression as SWF files and ByteArray use it, synchronously and with no
+ * platform API, through @swf2es/native/compress: zlib itself for zlib and raw
+ * deflate, the LZMA SDK's encoder for LZMA, and an LZMA decoder after the
+ * SDK's specification.
+ */
+import { CORRUPT, DICTIONARY, DONE, deflate, FULL, inflate, lzmaDecode, lzmaEncode, TRUNCATED, } from "../native/compress/index.js";
+/** Data a decompressor cannot read: corrupt, truncated, or not what it says. */
+export class CompressedDataError extends Error {
+}
+/**
+ * Data whose output does not fit: more than the decompressor's memory, or
+ * the page's, can hold. avmplus' ByteArray fails such an uncompress with
+ * MemoryError 1000, where it fails corrupt data with IOError 2058.
+ */
+export class CompressedDataTooLargeError extends CompressedDataError {
+}
+/** `data` as a zlib stream, as zlib's deflate writes it at `level`, 9 by default, as avmplus' ByteArray. */
+export function zlibCompress(data, level = 9) {
+    return deflate(data, level, false);
+}
+/** `data` as a raw deflate stream, with no zlib header or checksum. */
+export function deflateCompress(data) {
+    return deflate(data, 9, true);
+}
+/** The most an inflate may write: as much as a wasm32 memory holds. */
+const NO_LIMIT = 2 ** 32 - 1;
+/** A failed decode's status as a CompressedDataError. */
+function failure(result) {
+    switch (result.status) {
+        case TRUNCATED:
+            return new CompressedDataError("truncated");
+        case CORRUPT:
+            return new CompressedDataError(result.message ?? "corrupt");
+        case DICTIONARY:
+            return new CompressedDataError("needs a preset dictionary");
+        default:
+            return new CompressedDataTooLargeError("out of memory");
+    }
+}
+/**
+ * The bytes of a zlib stream (or, `raw`, of a raw deflate stream), up to its
+ * end: anything after is left, as zlib's inflate leaves it. The header is
+ * checked here, so that every way it can be wrong reads as avmplus' does.
+ */
+export function zlibUncompress(data, raw = false) {
+    if (!raw) {
+        if (data.length < 2) {
+            throw new CompressedDataError("truncated");
+        }
+        const cmf = data[0];
+        const flg = data[1];
+        if ((cmf & 0x0f) !== 8 || cmf >> 4 > 7 || ((cmf << 8) | flg) % 31 !== 0) {
+            throw new CompressedDataError("incorrect header check");
+        }
+        if (flg & 0x20) {
+            throw new CompressedDataError("needs a preset dictionary");
+        }
+    }
+    const result = inflate(data, raw, NO_LIMIT);
+    if (result.status !== DONE) {
+        throw failure(result);
+    }
+    return result.bytes;
+}
+/** The size of an LZMA header: its 5 property bytes and the 8-byte length of what it holds. */
+export const LZMA_HEADER = 13;
+/** `data` as ByteArray's LZMA: the 5 property bytes, its length in 8 bytes, little-endian, and the stream. */
+export function lzmaByteArrayCompress(data) {
+    return lzmaEncode(data);
+}
+/**
+ * ByteArray's LZMA, as avmplus reads it: the length its header gives must
+ * be what the stream holds. A length past 32 bits is not read here; the
+ * caller checks it first, as avmplus fails it before trying.
+ */
+export function lzmaByteArrayUncompress(data) {
+    const length = (data[5] | (data[6] << 8) | (data[7] << 16) | (data[8] << 24)) >>> 0;
+    if (length > MAX_LZMA_RATIO * (data.length - LZMA_HEADER) + 4096) {
+        throw new CompressedDataError(`${length} bytes in a stream of ${data.length}`);
+    }
+    const result = lzmaDecode(data, 0, LZMA_HEADER, length);
+    if (result.status !== DONE) {
+        throw failure(result);
+    }
+    if (result.bytes.length !== length) {
+        throw new CompressedDataError("length mismatch");
+    }
+    return result.bytes;
+}
+/**
+ * More than LZMA can expand a byte to. Its best case, a long run of one
+ * byte, is matches of 273 bytes that each cost 14 decisions, each at least
+ * the 0.022 bits of LZMA's likeliest probability (2017/2048): 7090:1,
+ * which an encoder nears on 32 MB of zeros (6959:1). A header naming more
+ * than this of its stream is refused before decoding; one naming less is
+ * decoded, and a decoder that would read past the stream's end fails.
+ */
+const MAX_LZMA_RATIO = 8192;
+/**
+ * The first `length` bytes of a SWF as an uncompressed one, or fewer if it
+ * has fewer, decompressing only as far as they need: the header and the
+ * first tags, without trusting the header's file length, which a SWF of
+ * 30 bytes may give as 4 GB. Whatever cannot be read ends it early.
+ */
+export function decompressSwfPrefix(swf, length) {
+    const signature = String.fromCharCode(swf[0], swf[1], swf[2]);
+    if (swf.length < 8 || signature === "FWS") {
+        return swf.subarray(0, length);
+    }
+    const fileLength = new DataView(swf.buffer, swf.byteOffset, swf.byteLength).getUint32(4, true);
+    // No further than the header's length, where decompressSwf stops too.
+    const want = Math.max(0, Math.min(length, fileLength) - 8);
+    const options = { offset: 8, partial: true };
+    let out = new Uint8Array(8);
+    // A kilobyte of the body first, as a header and the first tags need, and
+    // more only while the input runs out before the output: a large SWF is
+    // not copied whole for its first bytes. What decoded before any failure
+    // is kept, so a SWF cut short still has its start.
+    for (let input = 1024;; input *= 16) {
+        const end = Math.min(swf.length, (signature === "ZWS" ? 17 : 8) + input);
+        let result = null;
+        if (signature === "CWS") {
+            result = inflate(swf.subarray(8, end), false, want, options);
+        }
+        else if (signature === "ZWS" && swf.length >= 17) {
+            const size = Math.min(want, Math.max(0, fileLength - 8));
+            result = lzmaDecode(swf.subarray(0, end), 12, 17, size, options);
+        }
+        if (result === null) {
+            break;
+        }
+        out = result.bytes;
+        if (result.status !== TRUNCATED || end === swf.length) {
+            break;
+        }
+    }
+    out.set(swf.subarray(0, 8), 0);
+    out[0] = 0x46; // F
+    return out;
+}
+/**
+ * A SWF's bytes as an uncompressed one: the header as FWS, then the body,
+ * inflated for CWS, and for ZWS decoded from LZMA, whose header SWF writes
+ * differently (after the 8 bytes of the SWF header, a 4-byte compressed
+ * length and the 5 property bytes, and no 8-byte size).
+ */
+export function decompressSwf(swf) {
+    const signature = String.fromCharCode(swf[0], swf[1], swf[2]);
+    if (signature === "FWS") {
+        return swf;
+    }
+    const fileLength = new DataView(swf.buffer, swf.byteOffset, swf.byteLength).getUint32(4, true);
+    if (fileLength < 8 && (signature === "CWS" || signature === "ZWS")) {
+        throw new CompressedDataError(`a file length of ${fileLength}, shorter than its header`);
+    }
+    let result;
+    if (signature === "CWS") {
+        // A byte past the header's length tells a longer body from one that
+        // fits, which then ends with its checksum checked.
+        result = inflate(swf.subarray(8), false, fileLength - 8 + 1, { offset: 8 });
+        if (result.status === TRUNCATED) {
+            // Some SWFs omit the Adler-32 trailer despite holding a complete deflate stream.
+            const raw = inflate(swf.subarray(10), true, fileLength - 8 + 1, { offset: 8 });
+            if ((raw.status === DONE || raw.status === FULL) && 10 + raw.used + 4 > swf.length) {
+                result = raw;
+            }
+        }
+        // A longer body, as a packer may leave bytes after the End tag inside
+        // the stream, is read as far as the header's length and no further, as
+        // Flash Player plays it, and as a ZWS's decoding stops.
+        if (result.status === FULL) {
+            result = { ...result, status: DONE, bytes: result.bytes.subarray(0, fileLength) };
+        }
+    }
+    else if (signature === "ZWS") {
+        if (swf.length < 17) {
+            throw new CompressedDataError("truncated");
+        }
+        // A length no stream that short can hold is refused before decoding;
+        // within it, the decoder stops where the stream does.
+        if (fileLength - 8 > MAX_LZMA_RATIO * (swf.length - 17) + 4096) {
+            throw new CompressedDataError(`a body of ${fileLength - 8} bytes in ${swf.length} of SWF`);
+        }
+        result = lzmaDecode(swf, 12, 17, fileLength - 8, { offset: 8 });
+    }
+    else {
+        throw new TypeError(`Not a SWF file (signature ${JSON.stringify(signature)})`);
+    }
+    if (result.status !== DONE) {
+        throw failure(result);
+    }
+    const file = result.bytes;
+    if (file.length !== fileLength) {
+        throw new CompressedDataError(`body of ${file.length - 8} bytes where the header says ${fileLength - 8}`);
+    }
+    file.set(swf.subarray(0, 8), 0);
+    file[0] = 0x46; // F
+    return file;
+}

package/dist/thread/format/display.js

@@ -0,0 +1,305 @@
+import { readColorTransform, readMatrix } from "./shape.js";
+import { readTags, SwfReader } from "./swf.js";
+import { DoABC, PlaceObject, PlaceObject3, PlaceObject4, RemoveObject, RemoveObject2, } from "./tags.js";
+export function readString(r) {
+    const start = r.pos;
+    while (r.pos < r.end && r.bytes[r.pos] !== 0) {
+        r.pos++;
+    }
+    const s = utf8(r.bytes.subarray(start, r.pos));
+    r.pos++;
+    return s;
+}
+/**
+ * UTF-8 as SWF 6 and later write strings, read as avmplus' Utf8ToUtf16 does
+ * (fromUtf8 in the runtime): a malformed or overlong sequence is no
+ * sequence, and its first byte stands for itself.
+ */
+export function utf8(bytes) {
+    let s = "";
+    const length = bytes.length;
+    for (let i = 0; i < length;) {
+        const b = bytes[i++];
+        // ASCII, and a continuation byte on its own, stand for themselves.
+        if (b < 0xc0) {
+            s += String.fromCharCode(b);
+            continue;
+        }
+        const n = b < 0xe0 ? 1 : b < 0xf0 ? 2 : 3;
+        const minimum = n === 1 ? 0x80 : n === 2 ? 0x800 : 0x10000;
+        let c = b & (n === 1 ? 0x1f : n === 2 ? 0x0f : 0x07);
+        let ok = i + n <= length;
+        for (let k = 0; ok && k < n; k++) {
+            const next = bytes[i + k];
+            ok = (next & 0xc0) === 0x80;
+            c = (c << 6) | (next & 0x3f);
+        }
+        if (!ok || c < minimum) {
+            s += String.fromCharCode(b);
+            continue;
+        }
+        i += n;
+        if (n === 3) {
+            // A surrogate pair however large the value, as avmplus makes one;
+            // fromCodePoint would refuse one past U+10FFFF.
+            const u = c - 0x10000;
+            s += String.fromCharCode(0xd800 + ((u >> 10) & 0x3ff), 0xdc00 + (u & 0x3ff));
+        }
+        else {
+            s += String.fromCharCode(c);
+        }
+    }
+    return s;
+}
+/**
+ * A PlaceObject 1 to 4 tag's body; given the SWF's
+ * action list, with the indices of its clip actions.
+ */
+export function readPlace(bytes, tag, actions) {
+    const { place } = parsePlace(bytes, tag);
+    place.actions = actions?.byTag.get(tag.offset) ?? null;
+    place.corrupt = actions?.corruptEvents.get(tag.offset) ?? 0;
+    return place;
+}
+/** Where a PlaceObject 2 to 4's clip actions start, -1 without them, and its depth. */
+export function clipActionsOffset(bytes, tag) {
+    const { place, clipActions } = parsePlace(bytes, tag);
+    return { depth: place.depth, offset: clipActions };
+}
+function parsePlace(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    const place = {
+        depth: 0,
+        move: false,
+        character: null,
+        matrix: null,
+        colorTransform: null,
+        ratio: null,
+        name: null,
+        clipDepth: null,
+        className: null,
+        hasImage: false,
+        blendMode: null,
+        cacheAsBitmap: null,
+        visible: null,
+        opaqueBackground: null,
+        filters: null,
+        metaData: null,
+        actions: null,
+        corrupt: 0,
+    };
+    if (tag.code === PlaceObject) {
+        place.character = r.u16();
+        place.depth = r.u16();
+        place.matrix = readMatrix(r);
+        if (r.pos < r.end) {
+            place.colorTransform = readColorTransform(r, false);
+        }
+        return { place, clipActions: -1 };
+    }
+    const flags = r.u8();
+    const flags2 = tag.code === PlaceObject3 || tag.code === PlaceObject4 ? r.u8() : 0;
+    place.depth = r.u16();
+    place.move = (flags & 0x01) !== 0;
+    // SWF19 has a class name follow HasImage with a character; Flash reads
+    // one with HasImage only without a character, as Ruffle's reader notes.
+    const hasImage = (flags2 & 0x10) !== 0;
+    place.hasImage = hasImage;
+    if (flags2 & 0x08 || (hasImage && !(flags & 0x02))) {
+        place.className = readString(r);
+    }
+    if (flags & 0x02) {
+        place.character = r.u16();
+    }
+    if (flags & 0x04) {
+        place.matrix = readMatrix(r);
+    }
+    if (flags & 0x08) {
+        place.colorTransform = readColorTransform(r, true);
+    }
+    if (flags & 0x10) {
+        place.ratio = r.u16();
+    }
+    if (flags & 0x20) {
+        place.name = readString(r);
+    }
+    if (flags & 0x40) {
+        place.clipDepth = r.u16();
+    }
+    if (flags2 & 0x01) {
+        place.filters = readFilterBytes(r);
+    }
+    if (flags2 & 0x02) {
+        place.blendMode = r.u8();
+    }
+    if (flags2 & 0x04) {
+        place.cacheAsBitmap = r.u8() !== 0;
+    }
+    if (flags2 & 0x20) {
+        place.visible = r.u8() !== 0;
+    }
+    // The background follows its own flag, not HasVisible as SWF19 lays it out.
+    if (flags2 & 0x40) {
+        const a = r.u8();
+        const rgb = (r.u8() << 16) | (r.u8() << 8) | r.u8();
+        place.opaqueBackground = ((a << 24) | rgb) >>> 0;
+    }
+    const clipActions = flags & 0x80 && r.pos < r.end ? r.pos : -1;
+    if (tag.code === PlaceObject4) {
+        if (clipActions >= 0) {
+            // PlaceObject4 postdates SWF 6: its clip event flags are always 32 bits.
+            r.u16();
+            r.u32();
+            while (r.pos < r.end) {
+                const events = r.u32();
+                if (events === 0) {
+                    break;
+                }
+                const length = r.u32();
+                // Flash still consumes keyPress's key code when its record says length 0.
+                r.pos += events & (1 << 17) ? Math.max(1, length) : length;
+            }
+        }
+        if (r.pos < r.end) {
+            place.metaData = bytes.subarray(r.pos, r.end);
+        }
+    }
+    return { place, clipActions };
+}
+/** Filter sizes by id, as FILTER's variants lay them out (6 and 7 have variable length). */
+export function readFilterBytes(r) {
+    const start = r.pos;
+    const count = r.u8();
+    for (let i = 0; i < count && !r.overrun; i++) {
+        const id = r.u8();
+        switch (id) {
+            case 0:
+                r.pos += 23; // DropShadow
+                break;
+            case 1:
+                r.pos += 9; // Blur
+                break;
+            case 2:
+                r.pos += 15; // Glow
+                break;
+            case 3:
+                r.pos += 27; // Bevel
+                break;
+            case 4:
+            case 7: {
+                const stops = r.u8(); // GradientGlow, GradientBevel
+                r.pos += stops * 5 + 19;
+                break;
+            }
+            case 5: {
+                const x = r.u8(); // Convolution
+                const y = r.u8();
+                r.pos += 8 + x * y * 4 + 5;
+                break;
+            }
+            case 6:
+                r.pos += 80; // ColorMatrix
+                break;
+        }
+    }
+    return r.bytes.subarray(start, Math.min(r.pos, r.end));
+}
+/** A RemoveObject's or RemoveObject2's depth. */
+export function readRemove(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    if (tag.code === RemoveObject) {
+        r.u16();
+    }
+    else if (tag.code !== RemoveObject2) {
+        throw new Error(`tag ${tag.code} is not a remove`);
+    }
+    return r.u16();
+}
+export function readFrameLabel(bytes, tag) {
+    return readString(new SwfReader(bytes, tag.offset, tag.offset + tag.length));
+}
+/** An EncodedU32: seven bits a byte, low first, while the top bit is set. */
+function encodedU32(r) {
+    let value = 0;
+    for (let shift = 0; shift < 35; shift += 7) {
+        const b = r.u8();
+        value += (b & 0x7f) * 2 ** shift;
+        if (!(b & 0x80)) {
+            break;
+        }
+    }
+    return value >>> 0;
+}
+/** DefineSceneAndFrameLabelData; a count past the tag's end stops where its bytes do. */
+export function readSceneData(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    const list = () => {
+        const out = [];
+        const count = encodedU32(r);
+        for (let i = 0; i < count && !r.overrun; i++) {
+            const frame = encodedU32(r);
+            const name = readString(r);
+            if (!r.overrun) {
+                out.push({ frame, name });
+            }
+        }
+        return out;
+    };
+    const scenes = list();
+    return { scenes, labels: list() };
+}
+/** A DefineSprite's id, frame count and its own tags. */
+export function readSprite(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    const id = r.u16();
+    const frameCount = r.u16();
+    return { id, frameCount, tags: readTags(bytes, r.pos, tag.offset + tag.length).tags };
+}
+/** DefineScalingGrid: the sprite or button it is for, and its grid, in twips, in the character's space. */
+export function readScalingGrid(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    const id = r.u16();
+    return { id, grid: r.rect() };
+}
+/** DefineBinaryData: a character's bytes, after its id and 4 reserved bytes, which a ByteArray subclass SymbolClass binds to it holds. */
+export function readBinaryData(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    const id = r.u16();
+    r.u32();
+    return {
+        id,
+        data: bytes.subarray(Math.min(r.pos, tag.offset + tag.length), tag.offset + tag.length),
+    };
+}
+/** SymbolClass's links, including multiple classes of one character; id 0 is the document class. */
+export function readSymbolClass(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    const count = r.u16();
+    const symbols = [];
+    for (let i = 0; i < count && !r.overrun; i++) {
+        const id = r.u16();
+        symbols.push([id, readString(r)]);
+    }
+    return symbols;
+}
+/** A DoABC's or DoABC2's ABC bytes, its name, and whether it is to be run lazily (kDoAbcLazyInitializeFlag). */
+export function readDoAbc(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    if (tag.code === DoABC) {
+        return { name: "", lazy: false, abc: bytes.subarray(tag.offset, tag.offset + tag.length) };
+    }
+    const flags = r.u32();
+    const name = readString(r);
+    return { name, lazy: (flags & 1) !== 0, abc: bytes.subarray(r.pos, tag.offset + tag.length) };
+}
+/** ExportAssets: the characters it names, each id with its name, in tag order. */
+export function readExports(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    const exports = [];
+    const n = r.end - r.pos >= 2 ? r.u16() : 0;
+    for (let i = 0; i < n && r.end - r.pos >= 2; i++) {
+        const id = r.u16();
+        exports.push({ id, name: readString(r) });
+    }
+    return exports;
+}

package/dist/thread/format/filters.js

@@ -0,0 +1,136 @@
+// The filters a PlaceObject3 gives a display object, as the SWF stores
+// them: FILTERLIST's records, with their fixed-point and float fields.
+import { SwfReader } from "./swf.js";
+function color(r) {
+    const red = r.u8();
+    const green = r.u8();
+    const blue = r.u8();
+    return { rgb: (red << 16) | (green << 8) | blue, alpha: r.u8() };
+}
+const fixed = (r) => (r.u32() | 0) / 65536;
+const fixed8 = (r) => ((r.u16() << 16) >> 16) / 256;
+function float(r) {
+    const v = new DataView(new ArrayBuffer(4));
+    v.setUint32(0, r.u32());
+    return v.getFloat32(0);
+}
+/** A FILTERLIST's filters, as far as the bytes go. */
+export function readFilters(bytes) {
+    const r = new SwfReader(bytes, 0, bytes.length);
+    const count = r.u8();
+    const filters = [];
+    for (let i = 0; i < count && !r.overrun; i++) {
+        const id = r.u8();
+        let filter = null;
+        switch (id) {
+            case 0: {
+                const c = color(r);
+                const [blurX, blurY, angle, distance] = [fixed(r), fixed(r), fixed(r), fixed(r)];
+                const strength = fixed8(r);
+                const flags = r.u8();
+                filter = {
+                    type: "dropShadow",
+                    color: c,
+                    blurX,
+                    blurY,
+                    angle,
+                    distance,
+                    strength,
+                    inner: (flags & 0x80) !== 0,
+                    knockout: (flags & 0x40) !== 0,
+                    composite: (flags & 0x20) !== 0,
+                    passes: flags & 0x1f,
+                };
+                break;
+            }
+            case 1: {
+                const [blurX, blurY] = [fixed(r), fixed(r)];
+                filter = { type: "blur", blurX, blurY, passes: r.u8() >> 3 };
+                break;
+            }
+            case 2: {
+                const c = color(r);
+                const [blurX, blurY] = [fixed(r), fixed(r)];
+                const strength = fixed8(r);
+                const flags = r.u8();
+                filter = {
+                    type: "glow",
+                    color: c,
+                    blurX,
+                    blurY,
+                    strength,
+                    inner: (flags & 0x80) !== 0,
+                    knockout: (flags & 0x40) !== 0,
+                    composite: (flags & 0x20) !== 0,
+                    passes: flags & 0x1f,
+                };
+                break;
+            }
+            case 3:
+            case 4:
+            case 7: {
+                let colors;
+                let ratios;
+                if (id === 3) {
+                    // The highlight, then the shadow: the SWF spec has them the other way, adl this.
+                    const highlight = color(r);
+                    colors = [color(r), highlight];
+                    ratios = [];
+                }
+                else {
+                    const n = r.u8();
+                    colors = Array.from({ length: n }, () => color(r));
+                    ratios = Array.from({ length: n }, () => r.u8());
+                }
+                const [blurX, blurY, angle, distance] = [fixed(r), fixed(r), fixed(r), fixed(r)];
+                const strength = fixed8(r);
+                const flags = r.u8();
+                filter = {
+                    type: id === 3 ? "bevel" : id === 4 ? "gradientGlow" : "gradientBevel",
+                    colors,
+                    ratios,
+                    blurX,
+                    blurY,
+                    angle,
+                    distance,
+                    strength,
+                    inner: (flags & 0x80) !== 0,
+                    knockout: (flags & 0x40) !== 0,
+                    composite: (flags & 0x20) !== 0,
+                    onTop: (flags & 0x10) !== 0,
+                    passes: flags & 0x0f,
+                };
+                break;
+            }
+            case 5: {
+                const matrixX = r.u8();
+                const matrixY = r.u8();
+                const divisor = float(r);
+                const bias = float(r);
+                const matrix = Array.from({ length: matrixX * matrixY }, () => float(r));
+                const c = color(r);
+                const flags = r.u8();
+                filter = {
+                    type: "convolution",
+                    matrixX,
+                    matrixY,
+                    divisor,
+                    bias,
+                    matrix,
+                    color: c,
+                    clamp: (flags & 0x02) !== 0,
+                    preserveAlpha: (flags & 0x01) !== 0,
+                };
+                break;
+            }
+            case 6:
+                filter = { type: "colorMatrix", matrix: Array.from({ length: 20 }, () => float(r)) };
+                break;
+        }
+        if (!filter || r.overrun) {
+            break;
+        }
+        filters.push(filter);
+    }
+    return filters;
+}