@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/format/font.js

@@ -0,0 +1,168 @@
+// DefineFont through DefineFont3: a font's glyphs, the outlines a field that
+// embeds it draws, and its layout, the advances, kerning, ascent and
+// descent a field's text is laid out by.
+import { readString, utf8 } from "./display.js";
+import { readRecords } from "./shape.js";
+import { SwfReader } from "./swf.js";
+import { DefineFont, DefineFont3, DefineFontInfo2 } from "./tags.js";
+import { readFontName } from "./text.js";
+/** DefineFont4 (91): a name, style, and optional OpenType CFF bytes. */
+export function readFont4(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    const id = r.u16();
+    const flags = r.u8();
+    const name = readString(r);
+    return {
+        id,
+        name,
+        bold: (flags & 1) !== 0,
+        italic: (flags & 2) !== 0,
+        data: flags & 4 ? bytes.subarray(r.pos, r.end) : null,
+    };
+}
+/** DefineFont (10), whose first offset gives the glyph count; its name and codes come separately. */
+function readFont1(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    const font = {
+        id: r.u16(),
+        name: "",
+        bold: false,
+        italic: false,
+        em: 1024,
+        glyphs: [],
+        layout: false,
+        ascent: 0,
+        descent: 0,
+        leading: 0,
+        kerning: new Map(),
+    };
+    const table = r.pos;
+    const first = r.u16();
+    if (r.overrun || first < 2 || first % 2 !== 0 || table + first > r.end) {
+        return font;
+    }
+    const offsets = [first];
+    for (let i = 1; i < first / 2; i++) {
+        const offset = r.u16();
+        if (offset < offsets[i - 1] || table + offset > r.end) {
+            return font;
+        }
+        offsets.push(offset);
+    }
+    offsets.push(r.end - table);
+    for (let i = 0; i < offsets.length - 1; i++) {
+        const start = offsets[i];
+        const end = offsets[i + 1];
+        const records = readRecords(new SwfReader(bytes, table + start, table + end), 1).records;
+        font.glyphs.push({ code: -1, records, advance: 0, bounds: null });
+    }
+    return font;
+}
+/** DefineFontInfo (13) or DefineFontInfo2 (62); the latter has a language byte before its codes. */
+export function readFontInfo(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    const id = r.u16();
+    const length = r.u8();
+    const name = utf8(bytes.subarray(r.pos, Math.min(r.pos + length, r.end))).replace(/\0+$/, "");
+    r.pos += length;
+    const flags = r.u8();
+    if (tag.code === DefineFontInfo2) {
+        r.u8();
+    }
+    const codes = [];
+    const size = flags & 1 ? 2 : 1;
+    while (r.pos + size <= r.end) {
+        codes.push(size === 2 ? r.u16() : r.u8());
+    }
+    return { id, name, bold: (flags & 2) !== 0, italic: (flags & 4) !== 0, codes };
+}
+/** DefineFont (10), DefineFont2 (48) or DefineFont3 (75), as far as the tag goes. */
+export function readFont(bytes, tag) {
+    if (tag.code === DefineFont) {
+        return readFont1(bytes, tag);
+    }
+    const named = readFontName(bytes, tag);
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    r.u16();
+    const flags = r.u8();
+    r.u8();
+    r.pos += 1 + r.u8();
+    const hasLayout = (flags & 0x80) !== 0;
+    const wideOffsets = (flags & 0x08) !== 0;
+    const wideCodes = (flags & 0x04) !== 0;
+    const count = r.u16();
+    const table = r.pos;
+    const offset = () => (wideOffsets ? r.u32() : r.u16());
+    const offsets = [];
+    for (let i = 0; i < count; i++) {
+        offsets.push(offset());
+    }
+    const codeTable = count > 0 ? offset() : 0;
+    const glyphs = [];
+    for (let i = 0; i < count; i++) {
+        const shape = new SwfReader(bytes, table + offsets[i], tag.offset + tag.length);
+        glyphs.push({ code: 0, records: readRecords(shape, 1).records, advance: 0, bounds: null });
+    }
+    const font = {
+        ...named,
+        em: tag.code === DefineFont3 ? 20480 : 1024,
+        glyphs,
+        layout: false,
+        ascent: 0,
+        descent: 0,
+        leading: 0,
+        kerning: new Map(),
+    };
+    if (count > 0) {
+        r.pos = table + codeTable;
+    }
+    const code = () => (wideCodes ? r.u16() : r.u8());
+    for (const glyph of glyphs) {
+        glyph.code = code();
+    }
+    if (!hasLayout || r.overrun) {
+        return font;
+    }
+    font.ascent = r.u16();
+    font.descent = r.u16();
+    font.leading = r.s16();
+    for (const glyph of glyphs) {
+        glyph.advance = r.s16();
+    }
+    for (const glyph of glyphs) {
+        glyph.bounds = r.rect();
+    }
+    const pairs = r.u16();
+    for (let i = 0; i < pairs && !r.overrun; i++) {
+        const first = code();
+        const second = code();
+        font.kerning.set((first << 16) | second, r.s16());
+    }
+    font.layout = !r.overrun;
+    return font;
+}
+/** The glyph for a character, by a binary search of the code table, as Flash finds it: null for one the font lacks. */
+export function glyphOf(font, code) {
+    let lo = 0;
+    let hi = font.glyphs.length - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const c = font.glyphs[mid].code;
+        if (c === code) {
+            return font.glyphs[mid];
+        }
+        if (c < code) {
+            lo = mid + 1;
+        }
+        else {
+            hi = mid - 1;
+        }
+    }
+    return null;
+}
+/** DefineFontAlignZones (73): the font it is for and its CSM hint; the zones themselves are not read. */
+export function readFontAlignZones(bytes, tag) {
+    const r = new SwfReader(bytes, tag.offset, tag.offset + tag.length);
+    const id = r.u16();
+    return { id, csmHint: r.u8() >> 6 };
+}

package/dist/thread/format/index.js

@@ -0,0 +1,26 @@
+/**
+ * Parsers for the SWF container and its tags: shapes, fonts, text, bitmaps,
+ * sounds, buttons and filters, a DoABC's bytes, which codegen parses, and
+ * the AVM1 action blocks, which it compiles; and Pixel Bender's bytecode,
+ * which a script hands flash.display.Shader. Also an AIR application's
+ * descriptor, and the ZIP archives AIR packages are.
+ * The compiler and the player both use this package, so it must stay free of
+ * DOM and node APIs.
+ */
+export { abcReferences } from "./abc-names.js";
+export { ButtonCondition, ClipEvent, readActions, } from "./actions.js";
+export { readAirDescriptor } from "./air-descriptor.js";
+export { AIR_API_VERSION, API_VERSION, checkApiVersion } from "./api-versions.js";
+export { isBitmapTag, readBitmap } from "./bitmap.js";
+export { BUTTON_DOWN, BUTTON_HIT_TEST, BUTTON_OVER, BUTTON_UP, readButton, } from "./button.js";
+export { CompressedDataError, CompressedDataTooLargeError, decompressSwf, decompressSwfPrefix, deflateCompress, LZMA_HEADER, lzmaByteArrayCompress, lzmaByteArrayUncompress, zlibCompress, zlibUncompress, } from "./compression.js";
+export { readBinaryData, readDoAbc, readExports, readFrameLabel, readPlace, readRemove, readScalingGrid, readSceneData, readSprite, readString, readSymbolClass, } from "./display.js";
+export { readFilters } from "./filters.js";
+export { glyphOf, readFont, readFont4, readFontAlignZones, readFontInfo, } from "./font.js";
+export { PBJ_RULES, PBJ_STRING, PBJ_TYPE_SIZES, PBJ_TYPES, PbjError, PbjOp, pbjFloatType, readPbj, } from "./pbj.js";
+export { IDENTITY, readColorTransform, readMatrix, readMorphShape, readShape, } from "./shape.js";
+export { readButtonSound, readSound, readSoundInfo, readSoundStreamBlock, readSoundStreamHead, readStartSound, } from "./sound.js";
+export { backgroundColor, fileAttributes, isAs3, readSwf, readSwfHeader, readTags, SwfReader, } from "./swf.js";
+export * as tags from "./tags.js";
+export { readCsmTextSettings, readEditText, readFontName, readStaticText, } from "./text.js";
+export { readZip, ZipError } from "./zip.js";

package/dist/thread/format/pbj.js

@@ -0,0 +1,484 @@
+// Pixel Bender bytecode (PBJ), as flash.display.Shader takes it: the
+// kernel's metadata, parameters and image inputs, then its operations. The
+// layout is Ruffle's (https://github.com/ruffle-rs/ruffle)
+// render/pixel_bender/src/parser.rs, itself after pbjas and Haxe's
+// format.pbj: MIT OR Apache-2.0, Copyright (c) 2018-2022 Ruffle LLC and
+// Ruffle contributors. What Flash refuses, and with which error, is
+// adl's: bytes that end inside an opcode are EOFError 2030, and anything
+// else it will not run, ArgumentError 2004, kernels Ruffle accepts among
+// them (each operation's register kinds and sizes, PBJ_RULES).
+import { utf8 } from "./display.js";
+/** The parameter and metadata types, by their PBJ code, as ShaderParameterType names them. */
+export const PBJ_TYPES = [
+    null,
+    "float",
+    "float2",
+    "float3",
+    "float4",
+    "matrix2x2",
+    "matrix3x3",
+    "matrix4x4",
+    "int",
+    "int2",
+    "int3",
+    "int4",
+    "string",
+    "bool",
+    "bool2",
+    "bool3",
+    "bool4",
+];
+export const PBJ_STRING = 0xc;
+/** How many numbers a value of each type holds, by code; 0 for a string. */
+export const PBJ_TYPE_SIZES = [0, 1, 2, 3, 4, 4, 9, 16, 1, 2, 3, 4, 0, 1, 2, 3, 4];
+/** Whether a type's numbers are floats, by code. */
+export function pbjFloatType(type) {
+    return type >= 0x1 && type <= 0x7;
+}
+export const PbjOp = {
+    nop: 0x00,
+    add: 0x01,
+    sub: 0x02,
+    mul: 0x03,
+    rcp: 0x04,
+    div: 0x05,
+    atan2: 0x06,
+    pow: 0x07,
+    mod: 0x08,
+    min: 0x09,
+    max: 0x0a,
+    step: 0x0b,
+    sin: 0x0c,
+    cos: 0x0d,
+    tan: 0x0e,
+    asin: 0x0f,
+    acos: 0x10,
+    atan: 0x11,
+    exp: 0x12,
+    exp2: 0x13,
+    log: 0x14,
+    log2: 0x15,
+    sqrt: 0x16,
+    rsqrt: 0x17,
+    abs: 0x18,
+    sign: 0x19,
+    floor: 0x1a,
+    ceil: 0x1b,
+    fract: 0x1c,
+    mov: 0x1d,
+    floatToInt: 0x1e,
+    intToFloat: 0x1f,
+    matMatMul: 0x20,
+    vecMatMul: 0x21,
+    matVecMul: 0x22,
+    normalize: 0x23,
+    length: 0x24,
+    distance: 0x25,
+    dot: 0x26,
+    cross: 0x27,
+    equal: 0x28,
+    notEqual: 0x29,
+    lessThan: 0x2a,
+    lessThanEqual: 0x2b,
+    logicalNot: 0x2c,
+    logicalAnd: 0x2d,
+    logicalOr: 0x2e,
+    logicalXor: 0x2f,
+    sampleNearest: 0x30,
+    sampleLinear: 0x31,
+    load: 0x32,
+    select: 0x33,
+    if: 0x34,
+    else: 0x35,
+    endIf: 0x36,
+    floatToBool: 0x37,
+    boolToFloat: 0x38,
+    intToBool: 0x39,
+    boolToInt: 0x3a,
+    vectorEqual: 0x3b,
+    vectorNotEqual: 0x3c,
+    any: 0x3d,
+    all: 0x3e,
+    kernelMetadata: 0xa0,
+    parameter: 0xa1,
+    parameterMetadata: 0xa2,
+    texture: 0xa3,
+    name: 0xa4,
+    version: 0xa5,
+};
+/** Why Flash refuses a kernel: EOFError 2030 for bytes that end too soon, ArgumentError 2004 for anything else. */
+export class PbjError extends Error {
+    errorID;
+    constructor(errorID) {
+        super(errorID === 2030 ? "End of file was encountered." : "One of the parameters is invalid.");
+        this.errorID = errorID;
+    }
+}
+const F = 1;
+const I = 2;
+const FF = [F, F];
+const FF_II = [F, F, I, I];
+const SAME_FLOAT = { kinds: FF, sizes: "same" };
+const SAME_EITHER = { kinds: FF_II, sizes: "same" };
+export const PBJ_RULES = new Map([
+    [PbjOp.add, SAME_EITHER],
+    [PbjOp.sub, SAME_EITHER],
+    [PbjOp.mul, SAME_EITHER],
+    [PbjOp.div, SAME_EITHER],
+    [PbjOp.mov, SAME_EITHER],
+    [PbjOp.equal, SAME_EITHER],
+    [PbjOp.notEqual, SAME_EITHER],
+    [PbjOp.lessThan, SAME_EITHER],
+    [PbjOp.lessThanEqual, SAME_EITHER],
+    [PbjOp.matMatMul, SAME_FLOAT],
+    [PbjOp.vecMatMul, { kinds: [F, F, F, I, I, F, I, I], sizes: "scalar" }],
+    [PbjOp.matVecMul, { kinds: [F, F, F, I, I, F, I, I], sizes: "scalar" }],
+    [PbjOp.normalize, { kinds: FF, sizes: "vector" }],
+    [PbjOp.length, { kinds: FF, sizes: "length" }],
+    [PbjOp.distance, { kinds: FF, sizes: "vector" }],
+    [PbjOp.cross, { kinds: FF, sizes: "cross" }],
+    [PbjOp.floatToInt, { kinds: [I, F], sizes: "same" }],
+    [PbjOp.intToFloat, { kinds: [F, I], sizes: "same" }],
+    [PbjOp.logicalNot, { kinds: [I, I], sizes: "scalar" }],
+    [PbjOp.logicalAnd, { kinds: [I, I], sizes: "scalar" }],
+    [PbjOp.logicalOr, { kinds: [I, I], sizes: "scalar" }],
+    [PbjOp.logicalXor, { kinds: [I, I], sizes: "scalar" }],
+    [PbjOp.floatToBool, { kinds: [I, F], sizes: "any" }],
+    [PbjOp.boolToFloat, { kinds: [F, I], sizes: "any" }],
+    [PbjOp.intToBool, { kinds: [I, I], sizes: "any" }],
+    [PbjOp.boolToInt, { kinds: [F, I], sizes: "any" }],
+    [PbjOp.vectorEqual, { kinds: FF_II, sizes: "any" }],
+    [PbjOp.vectorNotEqual, { kinds: FF_II, sizes: "any" }],
+    [PbjOp.any, { kinds: [I, I], sizes: "any" }],
+    [PbjOp.all, { kinds: [I, I], sizes: "any" }],
+]);
+for (let op = PbjOp.rcp; op <= PbjOp.fract; op++) {
+    if (op !== PbjOp.div) {
+        PBJ_RULES.set(op, SAME_FLOAT);
+    }
+}
+PBJ_RULES.set(PbjOp.dot, SAME_FLOAT);
+/** The operations adl takes on matrices, each column as its registers hold it. */
+const MATRIX_OPS = [
+    PbjOp.add,
+    PbjOp.sub,
+    PbjOp.mul,
+    PbjOp.mov,
+    PbjOp.matMatMul,
+    PbjOp.matVecMul,
+    PbjOp.vecMatMul,
+];
+function sizesFit(rule, dst, src) {
+    switch (rule.sizes) {
+        case "same":
+            return dst === src;
+        case "any":
+            return true;
+        case "scalar":
+            return dst === 1 && src === 1;
+        case "vector":
+            return dst === src && src >= 2;
+        case "length":
+            return dst === 1 && src >= 2;
+        case "cross":
+            return dst === 3 && src === 3;
+    }
+}
+function kindsFit(rule, dst, src) {
+    const d = dst.int ? I : F;
+    const s = src.int ? I : F;
+    for (let i = 0; i < rule.kinds.length; i += 2) {
+        if (rule.kinds[i] === d && rule.kinds[i + 1] === s) {
+            return true;
+        }
+    }
+    return false;
+}
+class Reader {
+    bytes;
+    at = 0;
+    view;
+    constructor(bytes) {
+        this.bytes = bytes;
+        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    }
+    get done() {
+        return this.at >= this.bytes.length;
+    }
+    need(n) {
+        const at = this.at;
+        if (at + n > this.bytes.length) {
+            throw new PbjError(2030);
+        }
+        this.at += n;
+        return at;
+    }
+    u8() {
+        return this.bytes[this.need(1)];
+    }
+    u16() {
+        return this.view.getUint16(this.need(2), true);
+    }
+    u24() {
+        const at = this.need(3);
+        return this.bytes[at] | (this.bytes[at + 1] << 8) | (this.bytes[at + 2] << 16);
+    }
+    i32() {
+        return this.view.getInt32(this.need(4), true);
+    }
+    /** A float, big-endian, unlike every other number in PBJ. */
+    f32() {
+        return this.view.getFloat32(this.need(4), false);
+    }
+    skip(n) {
+        this.need(n);
+    }
+    /** A string to its terminating zero, in UTF-8. */
+    cstring() {
+        const start = this.at;
+        while (this.u8() !== 0) {
+            // Up to the zero.
+        }
+        return utf8(this.bytes.subarray(start, this.at - 1));
+    }
+    string(length) {
+        return utf8(this.bytes.subarray(this.need(length), this.at));
+    }
+}
+/** A destination: a register of the channels its 4-bit mask writes, r first. */
+function destination(value, mask) {
+    const channels = [];
+    for (let c = 0; c < 4; c++) {
+        if (mask & (8 >> c)) {
+            channels.push(c);
+        }
+    }
+    return {
+        index: value & 0x7fff,
+        int: (value & 0x8000) !== 0,
+        channels,
+        size: channels.length,
+        matrix: 0,
+    };
+}
+/** A source: its register in the low 16 bits, the swizzle's four channels in the high 8. */
+function source(value, size) {
+    const swizzle = value >>> 16;
+    const channels = [];
+    for (let i = 0; i < 4; i++) {
+        channels.push((swizzle >> (6 - i * 2)) & 3);
+    }
+    return { index: value & 0x7fff, int: (value & 0x8000) !== 0, channels, size, matrix: 0 };
+}
+function matrix(value, size) {
+    return {
+        index: value & 0x7fff,
+        int: (value & 0x8000) !== 0,
+        channels: [],
+        size: 1,
+        matrix: size,
+    };
+}
+function metadataValue(r, type) {
+    if (type === PBJ_STRING) {
+        return r.cstring();
+    }
+    const values = [];
+    for (let i = 0; i < PBJ_TYPE_SIZES[type]; i++) {
+        values.push(pbjFloatType(type) ? r.f32() : r.u16());
+    }
+    return values;
+}
+/**
+ * The kernel `bytes` hold, or PbjError with the error Flash refuses it
+ * with. Every byte is read: PBJ has no length, so it ends with the bytes.
+ */
+export function readPbj(bytes) {
+    const r = new Reader(bytes);
+    const kernel = {
+        name: null,
+        metadata: [],
+        parameters: [],
+        inputs: [],
+        operations: [],
+    };
+    /** The parameter the second metadata opcode adds to: the last one, but for an input after it. */
+    let owner = null;
+    let depth = 0;
+    const elses = [];
+    const refuse = () => {
+        throw new PbjError(2004);
+    };
+    while (!r.done) {
+        const op = r.u8();
+        switch (op) {
+            case PbjOp.version: {
+                if (r.i32() !== 1) {
+                    refuse();
+                }
+                break;
+            }
+            case PbjOp.name: {
+                kernel.name = r.string(r.u16());
+                break;
+            }
+            case PbjOp.kernelMetadata:
+            case PbjOp.parameterMetadata: {
+                const type = r.u8();
+                const key = r.cstring();
+                if (type === 0 || type >= PBJ_TYPES.length) {
+                    // adl reads on past what it cannot size, to the end.
+                    throw new PbjError(2030);
+                }
+                const value = metadataValue(r, type);
+                if (op === PbjOp.kernelMetadata) {
+                    if (type !== PBJ_STRING && type !== 0x8) {
+                        refuse();
+                    }
+                    kernel.metadata.push({ key, type, value });
+                }
+                else {
+                    owner?.metadata.push({ key, type, value });
+                }
+                break;
+            }
+            case PbjOp.parameter: {
+                const qualifier = r.u8();
+                const type = r.u8();
+                const reg = r.u16();
+                const mask = r.u8();
+                const name = r.cstring();
+                const output = qualifier === 2;
+                if (type === PBJ_STRING || name === "name" || (output && !pbjFloatType(type))) {
+                    refuse();
+                }
+                const size = type - 0x5 + 2;
+                const register = size >= 2 && size <= 4 ? matrix(reg, size) : destination(reg, mask & 0xf);
+                const parameter = { name, type, output, register, metadata: [] };
+                if (output && register.matrix) {
+                    refuse();
+                }
+                kernel.parameters.push(parameter);
+                owner = parameter;
+                break;
+            }
+            case PbjOp.texture: {
+                const index = r.u8();
+                const channels = r.u8();
+                kernel.inputs.push({ name: r.cstring(), index, channels });
+                owner = null;
+                break;
+            }
+            case PbjOp.nop: {
+                // Both words read first: a nop cut short is EOFError 2030, whatever its bytes.
+                const first = r.u24();
+                const second = r.u24();
+                if (first !== 0 || second !== 0) {
+                    refuse();
+                }
+                break;
+            }
+            case PbjOp.load: {
+                const dst = destination(r.u16(), r.u8() >> 4);
+                const value = dst.int ? r.i32() & 0xffff : r.f32();
+                if (dst.size === 0) {
+                    refuse();
+                }
+                kernel.operations.push({ op, dst, value });
+                break;
+            }
+            case PbjOp.sampleNearest:
+            case PbjOp.sampleLinear: {
+                const reg = r.u16();
+                const mask = r.u8();
+                const src = source(r.u24(), (mask & 3) + 1);
+                const texture = r.u8();
+                const dst = destination(reg, mask >> 4);
+                // adl takes an int coordinate, and a texture never declared, which then has no input.
+                if (dst.int || dst.size === 0) {
+                    refuse();
+                }
+                kernel.operations.push({ op, dst, src, texture });
+                break;
+            }
+            case PbjOp.if: {
+                r.skip(3);
+                const src = source(r.u24(), 1);
+                r.skip(1);
+                if (!src.int) {
+                    refuse();
+                }
+                depth++;
+                elses.push(false);
+                kernel.operations.push({ op, src });
+                break;
+            }
+            case PbjOp.else:
+            case PbjOp.endIf: {
+                r.skip(7);
+                if (depth === 0 || (op === PbjOp.else && elses[elses.length - 1])) {
+                    refuse();
+                }
+                if (op === PbjOp.else) {
+                    elses[elses.length - 1] = true;
+                }
+                else {
+                    depth--;
+                    elses.pop();
+                }
+                kernel.operations.push({ op });
+                break;
+            }
+            case PbjOp.select: {
+                const dst = destination(r.u16(), r.u8() >> 4);
+                const condition = source(r.u24(), 1);
+                r.skip(1);
+                const a = source(r.u24(), dst.size);
+                r.skip(1);
+                const b = source(r.u24(), dst.size);
+                r.skip(1);
+                if (!condition.int || dst.int !== a.int || a.int !== b.int || dst.size === 0) {
+                    refuse();
+                }
+                kernel.operations.push({ op, dst, condition, a, b });
+                break;
+            }
+            default: {
+                const reg = r.u16();
+                const mask = r.u8();
+                const value = r.u24();
+                r.skip(1);
+                const rule = PBJ_RULES.get(op) ?? refuse();
+                const size = (mask & 3) + 1;
+                const bits = (mask >> 2) & 3;
+                if (bits === 0) {
+                    const dst = destination(reg, mask >> 4);
+                    const src = source(value, size);
+                    if (dst.size === 0 || !kindsFit(rule, dst, src) || !sizesFit(rule, dst.size, src.size)) {
+                        refuse();
+                    }
+                    kernel.operations.push({ op, dst, src });
+                    break;
+                }
+                // A matrix: its size in the mask, and no swizzle.
+                const n = bits + 1;
+                const src = matrix(value, n);
+                const vector = op === PbjOp.matVecMul || op === PbjOp.vecMatMul;
+                const dst = vector ? destination(reg, mask >> 4) : matrix(reg, n);
+                if (!MATRIX_OPS.includes(op) ||
+                    value >>> 16 !== 0 ||
+                    size !== 1 ||
+                    src.int ||
+                    dst.int ||
+                    (vector ? dst.size !== n : mask >> 4 !== 0)) {
+                    refuse();
+                }
+                kernel.operations.push({ op, dst, src });
+            }
+        }
+    }
+    if (depth !== 0 || !kernel.parameters.some((p) => p.output)) {
+        refuse();
+    }
+    return kernel;
+}