@theoremjs/agents 0.3.0 → 0.3.2

package/esm/src/kernel/engine/media-probe/audio.js

@@ -1,342 +0,0 @@
-import { ascii, id3v2End, uint64, view } from './bytes.js';
-import { MKV_AUDIO_TRACK, matroska, opusSamplesFromNs } from './matroska.js';
-import { MP4_SOUND, mp4Tracks } from './mp4.js';
-import { OPUS_RATE } from './opus.js';
-const RIFF_HEADER = 12;
-const CHUNK_HEADER = 8;
-const WAV_BYTE_RATE_OFFSET = 8;
-function positiveSeconds(seconds) {
-    return Number.isFinite(seconds) && seconds > 0 ? seconds : undefined;
-}
-function wavSeconds(bytes) {
-    if (bytes.length < RIFF_HEADER ||
-        ascii(bytes, 0, 4) !== 'RIFF' ||
-        ascii(bytes, 8, 4) !== 'WAVE') {
-        return undefined;
-    }
-    const v = view(bytes);
-    let byteRate;
-    let at = RIFF_HEADER;
-    while (at + CHUNK_HEADER <= bytes.length) {
-        const id = ascii(bytes, at, 4);
-        const size = v.getUint32(at + 4, true);
-        if (id === 'fmt ' && at + CHUNK_HEADER + WAV_BYTE_RATE_OFFSET + 4 <= bytes.length) {
-            byteRate = v.getUint32(at + CHUNK_HEADER + WAV_BYTE_RATE_OFFSET, true);
-        }
-        if (id === 'data') {
-            return byteRate ? positiveSeconds(size / byteRate) : undefined;
-        }
-        at += CHUNK_HEADER + size + (size % 2);
-    }
-    return undefined;
-}
-const AIFF_COMM_FRAMES = 2;
-const AIFF_COMM_RATE = 8;
-const AIFF_COMM_MIN = 18;
-const EXTENDED_BIAS = 16383;
-const EXTENDED_MANTISSA_BITS = 63;
-/** IEEE 754 80-bit extended float (AIFF sample rate). */
-function extended80(v, at) {
-    const exponent = v.getUint16(at) & 0x7fff;
-    const mantissa = v.getUint32(at + 2) * 2 ** 32 + v.getUint32(at + 6);
-    return mantissa * 2 ** (exponent - EXTENDED_BIAS - EXTENDED_MANTISSA_BITS);
-}
-function aiffSeconds(bytes) {
-    if (bytes.length < RIFF_HEADER || ascii(bytes, 0, 4) !== 'FORM')
-        return undefined;
-    const form = ascii(bytes, 8, 4);
-    if (form !== 'AIFF' && form !== 'AIFC')
-        return undefined;
-    const v = view(bytes);
-    let at = RIFF_HEADER;
-    while (at + CHUNK_HEADER <= bytes.length) {
-        const size = v.getUint32(at + 4);
-        if (ascii(bytes, at, 4) === 'COMM') {
-            if (size < AIFF_COMM_MIN || at + CHUNK_HEADER + AIFF_COMM_MIN > bytes.length) {
-                return undefined;
-            }
-            const body = at + CHUNK_HEADER;
-            const frames = v.getUint32(body + AIFF_COMM_FRAMES);
-            return positiveSeconds(frames / extended80(v, body + AIFF_COMM_RATE));
-        }
-        at += CHUNK_HEADER + size + (size % 2);
-    }
-    return undefined;
-}
-const FLAC_BLOCK_HEADER = 4;
-const FLAC_STREAMINFO = 0;
-const FLAC_STREAMINFO_LENGTH = 34;
-const FLAC_BLOCK_TYPE_MASK = 0x7f;
-/** Sample rate from a FLAC STREAMINFO body (20 bits at byte 10). */
-function streamInfoRate(bytes, at) {
-    if (at + FLAC_STREAMINFO_LENGTH > bytes.length)
-        return undefined;
-    return (bytes[at + 10] << 12) | (bytes[at + 11] << 4) | (bytes[at + 12] >> 4);
-}
-/** Seconds from a FLAC STREAMINFO body: sample rate and 36-bit total samples. */
-function streamInfoSeconds(bytes, at) {
-    const rate = streamInfoRate(bytes, at);
-    if (rate === undefined)
-        return undefined;
-    const samples = (bytes[at + 13] & 0x0f) * 2 ** 32 + view(bytes).getUint32(at + 14);
-    return positiveSeconds(samples / rate);
-}
-function flacSeconds(bytes) {
-    const at = id3v2End(bytes);
-    if (at + 4 + FLAC_BLOCK_HEADER > bytes.length || ascii(bytes, at, 4) !== 'fLaC') {
-        return undefined;
-    }
-    const header = at + 4;
-    if ((bytes[header] & FLAC_BLOCK_TYPE_MASK) !== FLAC_STREAMINFO)
-        return undefined;
-    return streamInfoSeconds(bytes, header + FLAC_BLOCK_HEADER);
-}
-const OGG_PAGE_HEADER = 27;
-const OGG_GRANULE = 6;
-const OGG_SERIAL = 14;
-const OGG_SEGMENTS = 26;
-const OPUS_PRE_SKIP = 10;
-const VORBIS_RATE = 12;
-/** Ogg FLAC mapping header (9 bytes) precedes `fLaC` and the STREAMINFO block header. */
-const OGG_FLAC_STREAMINFO = 9 + 4 + FLAC_BLOCK_HEADER;
-function oggPage(bytes, at) {
-    if (at + OGG_PAGE_HEADER > bytes.length ||
-        ascii(bytes, at, 4) !== 'OggS' ||
-        bytes[at + 4] !== 0) {
-        return undefined;
-    }
-    const v = view(bytes);
-    const noGranule = v.getUint32(at + OGG_GRANULE, true) === 0xffffffff &&
-        v.getUint32(at + OGG_GRANULE + 4, true) === 0xffffffff;
-    return {
-        granule: noGranule ? undefined : uint64(v, at + OGG_GRANULE, true),
-        serial: v.getUint32(at + OGG_SERIAL, true),
-        payload: at + OGG_PAGE_HEADER + bytes[at + OGG_SEGMENTS],
-    };
-}
-/** Granule position of the last page of `serial` that completes a packet. */
-function lastGranule(bytes, serial) {
-    for (let at = bytes.length - OGG_PAGE_HEADER; at >= 0; at--) {
-        if (bytes[at] !== 0x4f)
-            continue;
-        const page = oggPage(bytes, at);
-        if (page && page.serial === serial && page.granule !== undefined)
-            return page.granule;
-    }
-    return undefined;
-}
-function oggSeconds(bytes) {
-    const first = oggPage(bytes, 0);
-    if (!first)
-        return undefined;
-    const at = first.payload;
-    const v = view(bytes);
-    const has = (n) => at + n <= bytes.length;
-    let rate;
-    let preSkip = 0;
-    if (has(OPUS_PRE_SKIP + 2) && ascii(bytes, at, 8) === 'OpusHead') {
-        rate = OPUS_RATE;
-        preSkip = v.getUint16(at + OPUS_PRE_SKIP, true);
-    }
-    else if (has(VORBIS_RATE + 4) && bytes[at] === 1 && ascii(bytes, at + 1, 6) === 'vorbis') {
-        rate = v.getUint32(at + VORBIS_RATE, true);
-    }
-    else if (bytes[at] === 0x7f && has(5) && ascii(bytes, at + 1, 4) === 'FLAC') {
-        rate = streamInfoRate(bytes, at + OGG_FLAC_STREAMINFO);
-    }
-    else {
-        return undefined;
-    }
-    const granule = lastGranule(bytes, first.serial);
-    if (granule === undefined || !rate)
-        return undefined;
-    return positiveSeconds((granule - preSkip) / rate);
-}
-/**
- * Decoded length of a Matroska / WebM file's audio. Unlaced Opus blocks are
- * summed as a decoder outputs them — packet samples less the track's
- * `CodecDelay` and each group's `DiscardPadding`. Otherwise the segment's
- * stated `Duration` is used; without one the length is unknown.
- */
-function matroskaSeconds(bytes) {
-    const file = matroska(bytes);
-    if (!file)
-        return undefined;
-    const audio = file.tracks.filter((t) => t.type === MKV_AUDIO_TRACK);
-    const decoded = audio.map((t) => t.opusSamples === undefined ? undefined : t.opusSamples - opusSamplesFromNs(t.codecDelayNs));
-    if (file.complete && audio.length > 0 && decoded.every((n) => n !== undefined)) {
-        const samples = Math.max(...decoded);
-        if (samples > 0)
-            return positiveSeconds(samples / OPUS_RATE);
-    }
-    return file.durationSeconds === undefined ? undefined : positiveSeconds(file.durationSeconds);
-}
-function mp4Seconds(bytes) {
-    return mp4Tracks(bytes)?.find((t) => t.handler === MP4_SOUND)?.decodedSeconds;
-}
-const MPEG_VERSION_1 = 3;
-const MPEG_VERSION_2 = 2;
-const MPEG_VERSION_25 = 0;
-const MPEG_LAYER_1 = 3;
-const MPEG_LAYER_2 = 2;
-const MPEG_LAYER_3 = 1;
-const MPEG_MONO = 3;
-const MPEG_RATES = {
-    [MPEG_VERSION_1]: [44_100, 48_000, 32_000],
-    [MPEG_VERSION_2]: [22_050, 24_000, 16_000],
-    [MPEG_VERSION_25]: [11_025, 12_000, 8_000],
-};
-/** kbit/s by [version 1?][layer][index]. */
-const MPEG_BITRATES = {
-    v1: {
-        [MPEG_LAYER_1]: [0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448],
-        [MPEG_LAYER_2]: [0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384],
-        [MPEG_LAYER_3]: [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320],
-    },
-    v2: {
-        [MPEG_LAYER_1]: [0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256],
-        [MPEG_LAYER_2]: [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160],
-        [MPEG_LAYER_3]: [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160],
-    },
-};
-const MPEG_HEADER = 4;
-const LAYER_1_SLOT = 4;
-const XING_FRAMES_FLAG = 0x01;
-/** Optional Xing fields in order — frames, bytes, TOC, quality — as [flag, width]. */
-const XING_FIELDS = [
-    [0x01, 4],
-    [0x02, 4],
-    [0x04, 100],
-    [0x08, 4],
-];
-/** Encoder strings whose info tag carries encoder delay and padding (LAME and ffmpeg). */
-const LAME_ENCODERS = ['LAME', 'Lavf', 'Lavc'];
-/** 12-bit encoder delay and padding follow the 9-byte version, revision, lowpass, and gain fields. */
-const LAME_DELAY_PADDING = 21;
-const VBRI_OFFSET = 36;
-const VBRI_FRAMES = 14;
-/** Side-information length by [version 1?][mono?] — the Xing tag follows it. */
-const MPEG_SIDE_INFO = { v1: { mono: 17, stereo: 32 }, v2: { mono: 9, stereo: 17 } };
-const ADTS_RATES = [
-    96_000, 88_200, 64_000, 48_000, 44_100, 32_000, 24_000, 22_050, 16_000, 12_000, 11_025, 8_000,
-    7_350,
-];
-const ADTS_HEADER = 7;
-const AAC_FRAME_SAMPLES = 1024;
-/** Trailing tags that may follow the last frame. */
-const TRAILING_TAGS = ['TAG', 'APETAGEX', 'LYRICSBEGIN'];
-function mpegFrame(bytes, at) {
-    if (at + MPEG_HEADER > bytes.length || bytes[at] !== 0xff || (bytes[at + 1] & 0xe0) !== 0xe0) {
-        return undefined;
-    }
-    const version = (bytes[at + 1] >> 3) & 0x03;
-    const layer = (bytes[at + 1] >> 1) & 0x03;
-    const bitrateIndex = bytes[at + 2] >> 4;
-    const rateIndex = (bytes[at + 2] >> 2) & 0x03;
-    const padding = (bytes[at + 2] >> 1) & 0x01;
-    const mono = bytes[at + 3] >> 6 === MPEG_MONO;
-    const rate = MPEG_RATES[version]?.[rateIndex];
-    const family = version === MPEG_VERSION_1 ? 'v1' : 'v2';
-    const kbps = MPEG_BITRATES[family][layer]?.[bitrateIndex];
-    if (!rate || !kbps)
-        return undefined;
-    const samples = layer === MPEG_LAYER_1 ? 384 : layer === MPEG_LAYER_3 && family === 'v2' ? 576 : 1152;
-    const length = layer === MPEG_LAYER_1
-        ? (Math.floor((12 * kbps * 1000) / rate) + padding) * LAYER_1_SLOT
-        : Math.floor(((samples / 8) * kbps * 1000) / rate) + padding;
-    const sideInfo = MPEG_SIDE_INFO[family][mono ? 'mono' : 'stereo'];
-    return { length, samples, rate, sideInfo };
-}
-/**
- * Audio frame count from a Xing / Info or VBRI tag in the first frame, and the
- * encoder delay plus padding a LAME info tag declares (samples a decoder drops).
- */
-function vbrFrames(bytes, at, frame) {
-    const v = view(bytes);
-    const xing = at + MPEG_HEADER + frame.sideInfo;
-    const tag = xing + 8 <= bytes.length ? ascii(bytes, xing, 4) : '';
-    if ((tag === 'Xing' || tag === 'Info') && v.getUint32(xing + 4) & XING_FRAMES_FLAG) {
-        if (xing + 12 > bytes.length)
-            return undefined;
-        const flags = v.getUint32(xing + 4);
-        let lame = xing + 8;
-        for (const [flag, width] of XING_FIELDS)
-            if (flags & flag)
-                lame += width;
-        return { frames: v.getUint32(xing + 8), trimmed: lameTrimmed(bytes, lame) };
-    }
-    const vbri = at + VBRI_OFFSET;
-    if (vbri + VBRI_FRAMES + 4 <= bytes.length && ascii(bytes, vbri, 4) === 'VBRI') {
-        return { frames: v.getUint32(vbri + VBRI_FRAMES), trimmed: 0 };
-    }
-    return undefined;
-}
-/** Encoder delay plus padding from a LAME info tag at `at`; 0 when there is none. */
-function lameTrimmed(bytes, at) {
-    const fields = at + LAME_DELAY_PADDING;
-    if (fields + 3 > bytes.length || !LAME_ENCODERS.includes(ascii(bytes, at, 4)))
-        return 0;
-    const delay = (bytes[fields] << 4) | (bytes[fields + 1] >> 4);
-    const padding = ((bytes[fields + 1] & 0x0f) << 8) | bytes[fields + 2];
-    return delay + padding;
-}
-function adtsFrame(bytes, at) {
-    if (at + ADTS_HEADER > bytes.length || bytes[at] !== 0xff || (bytes[at + 1] & 0xf6) !== 0xf0) {
-        return undefined;
-    }
-    const rate = ADTS_RATES[(bytes[at + 2] >> 2) & 0x0f];
-    const length = ((bytes[at + 3] & 0x03) << 11) | (bytes[at + 4] << 3) | (bytes[at + 5] >> 5);
-    const blocks = (bytes[at + 6] & 0x03) + 1;
-    if (!rate || length < ADTS_HEADER)
-        return undefined;
-    return { length, samples: blocks * AAC_FRAME_SAMPLES, rate };
-}
-function atStreamEnd(bytes, at) {
-    if (at === bytes.length)
-        return true;
-    return TRAILING_TAGS.some((tag) => ascii(bytes, at, tag.length) === tag);
-}
-/** Walk frames from `start`; `undefined` unless every byte up to a trailing tag is a frame. */
-function walkFrames(bytes, start, read) {
-    let at = start;
-    let seconds = 0;
-    while (!atStreamEnd(bytes, at)) {
-        const frame = read(at);
-        if (!frame || at + frame.length > bytes.length)
-            return undefined;
-        seconds += frame.samples / frame.rate;
-        at += frame.length;
-    }
-    return positiveSeconds(seconds);
-}
-function mpegAudioSeconds(bytes) {
-    const start = id3v2End(bytes);
-    if (adtsFrame(bytes, start))
-        return walkFrames(bytes, start, (at) => adtsFrame(bytes, at));
-    const first = mpegFrame(bytes, start);
-    if (!first)
-        return undefined;
-    const tagged = vbrFrames(bytes, start, first);
-    if (tagged !== undefined) {
-        const samples = tagged.frames * first.samples;
-        if (tagged.trimmed >= samples)
-            return undefined;
-        return positiveSeconds((samples - tagged.trimmed) / first.rate);
-    }
-    return walkFrames(bytes, start, (at) => mpegFrame(bytes, at));
-}
-/**
- * Identified by the bytes, not the declared MIME type. Decoded means what a decoder outputs: declared
- * encoder delay and padding are dropped (Opus pre-skip, `CodecDelay`, `DiscardPadding`, LAME, the MP4
- * edit list's leading skip); ADTS declares no delay, so its priming samples count. `undefined` when
- * the duration cannot be read exactly.
- */
-export function audioSeconds(bytes) {
-    return (wavSeconds(bytes) ??
-        aiffSeconds(bytes) ??
-        flacSeconds(bytes) ??
-        oggSeconds(bytes) ??
-        matroskaSeconds(bytes) ??
-        mp4Seconds(bytes) ??
-        mpegAudioSeconds(bytes));
-}

package/esm/src/kernel/engine/media-probe/bytes.d.ts

@@ -1,6 +0,0 @@
-export declare function ascii(bytes: Uint8Array, offset: number, length: number): string;
-export declare function view(bytes: Uint8Array): DataView;
-/** Unsigned 64-bit read as a JS number; `undefined` above 2^53. */
-export declare function uint64(v: DataView, at: number, littleEndian?: boolean): number | undefined;
-/** Offset just past a leading ID3v2 tag, or 0 when there is none. */
-export declare function id3v2End(bytes: Uint8Array): number;

package/esm/src/kernel/engine/media-probe/bytes.js

@@ -1,26 +0,0 @@
-const ID3V2_HEADER = 10;
-const ID3V2_FOOTER_FLAG = 0x10;
-const SYNCSAFE_BITS = 7;
-export function ascii(bytes, offset, length) {
-    return String.fromCharCode(...bytes.subarray(offset, offset + length));
-}
-export function view(bytes) {
-    return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-}
-/** Unsigned 64-bit read as a JS number; `undefined` above 2^53. */
-export function uint64(v, at, littleEndian = false) {
-    const high = v.getUint32(littleEndian ? at + 4 : at, littleEndian);
-    const low = v.getUint32(littleEndian ? at : at + 4, littleEndian);
-    const n = high * 2 ** 32 + low;
-    return Number.isSafeInteger(n) ? n : undefined;
-}
-/** Offset just past a leading ID3v2 tag, or 0 when there is none. */
-export function id3v2End(bytes) {
-    if (bytes.length < ID3V2_HEADER || ascii(bytes, 0, 3) !== 'ID3')
-        return 0;
-    let size = 0;
-    for (let i = 6; i < ID3V2_HEADER; i++)
-        size = (size << SYNCSAFE_BITS) | (bytes[i] & 0x7f);
-    const footer = bytes[5] & ID3V2_FOOTER_FLAG ? ID3V2_HEADER : 0;
-    return ID3V2_HEADER + size + footer;
-}

package/esm/src/kernel/engine/media-probe/image.d.ts

@@ -1,5 +0,0 @@
-export interface ImageSize {
-    width: number;
-    height: number;
-}
-export declare function imageSize(bytes: Uint8Array): ImageSize | undefined;

package/esm/src/kernel/engine/media-probe/image.js

@@ -1,171 +0,0 @@
-import { ascii, view } from './bytes.js';
-import { boxes, FULL_BOX_HEADER, hasBrand } from './iso-bmff.js';
-const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
-const PNG_WIDTH_OFFSET = 16;
-const PNG_HEIGHT_OFFSET = 20;
-const GIF_WIDTH_OFFSET = 6;
-const GIF_HEIGHT_OFFSET = 8;
-const JPEG_SOI = 0xd8;
-const JPEG_MARKER = 0xff;
-const JPEG_SOF_FIRST = 0xc0;
-const JPEG_SOF_LAST = 0xcf;
-/** DHT, JPG extension, DAC — in the SOF range but not frame headers. */
-const JPEG_NOT_SOF = new Set([0xc4, 0xc8, 0xcc]);
-const JPEG_STANDALONE = new Set([0x01, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7]);
-const WEBP_CHUNK_OFFSET = 12;
-const WEBP_VP8_SIZE_OFFSET = 26;
-const WEBP_VP8L_SIZE_OFFSET = 21;
-const WEBP_VP8X_SIZE_OFFSET = 24;
-const FOURTEEN_BITS = 0x3fff;
-const CHUNK_HEADER = 8;
-function positive(size) {
-    return size.width > 0 && size.height > 0 ? size : undefined;
-}
-function pngSize(bytes) {
-    if (bytes.length < PNG_HEIGHT_OFFSET + 4)
-        return undefined;
-    if (!PNG_SIGNATURE.every((b, i) => bytes[i] === b))
-        return undefined;
-    const v = view(bytes);
-    return positive({
-        width: v.getUint32(PNG_WIDTH_OFFSET),
-        height: v.getUint32(PNG_HEIGHT_OFFSET),
-    });
-}
-function gifSize(bytes) {
-    if (bytes.length < GIF_HEIGHT_OFFSET + 2 || ascii(bytes, 0, 3) !== 'GIF')
-        return undefined;
-    const v = view(bytes);
-    return positive({
-        width: v.getUint16(GIF_WIDTH_OFFSET, true),
-        height: v.getUint16(GIF_HEIGHT_OFFSET, true),
-    });
-}
-function jpegSize(bytes) {
-    if (bytes[0] !== JPEG_MARKER || bytes[1] !== JPEG_SOI)
-        return undefined;
-    const v = view(bytes);
-    let at = 2;
-    while (at + 4 <= bytes.length) {
-        if (bytes[at] !== JPEG_MARKER)
-            return undefined;
-        const marker = bytes[at + 1];
-        if (marker === JPEG_MARKER) {
-            at += 1;
-            continue;
-        }
-        if (JPEG_STANDALONE.has(marker)) {
-            at += 2;
-            continue;
-        }
-        const length = v.getUint16(at + 2);
-        if (marker >= JPEG_SOF_FIRST && marker <= JPEG_SOF_LAST && !JPEG_NOT_SOF.has(marker)) {
-            if (at + 9 > bytes.length)
-                return undefined;
-            return positive({ height: v.getUint16(at + 5), width: v.getUint16(at + 7) });
-        }
-        at += 2 + length;
-    }
-    return undefined;
-}
-function webpSize(bytes) {
-    if (bytes.length < WEBP_CHUNK_OFFSET + CHUNK_HEADER)
-        return undefined;
-    if (ascii(bytes, 0, 4) !== 'RIFF' || ascii(bytes, 8, 4) !== 'WEBP')
-        return undefined;
-    const v = view(bytes);
-    const chunk = ascii(bytes, WEBP_CHUNK_OFFSET, 4);
-    if (chunk === 'VP8 ' && bytes.length >= WEBP_VP8_SIZE_OFFSET + 4) {
-        return positive({
-            width: v.getUint16(WEBP_VP8_SIZE_OFFSET, true) & FOURTEEN_BITS,
-            height: v.getUint16(WEBP_VP8_SIZE_OFFSET + 2, true) & FOURTEEN_BITS,
-        });
-    }
-    if (chunk === 'VP8L' && bytes.length >= WEBP_VP8L_SIZE_OFFSET + 4) {
-        const bits = v.getUint32(WEBP_VP8L_SIZE_OFFSET, true);
-        return positive({
-            width: (bits & FOURTEEN_BITS) + 1,
-            height: ((bits >>> 14) & FOURTEEN_BITS) + 1,
-        });
-    }
-    if (chunk === 'VP8X' && bytes.length >= WEBP_VP8X_SIZE_OFFSET + 6) {
-        const u24 = (at) => bytes[at] | (bytes[at + 1] << 8) | (bytes[at + 2] << 16);
-        return positive({
-            width: u24(WEBP_VP8X_SIZE_OFFSET) + 1,
-            height: u24(WEBP_VP8X_SIZE_OFFSET + 3) + 1,
-        });
-    }
-    return undefined;
-}
-/** HEIF brands (ISO/IEC 23008-12): image, image sequence, and HEVC variants. */
-const HEIF_BRANDS = new Set(['mif1', 'msf1', 'heic', 'heix', 'heim', 'heis', 'hevc', 'hevx']);
-const IPMA_WIDE_INDEX = 0x01;
-const IPMA_INDEX_MASK_WIDE = 0x7fff;
-const IPMA_INDEX_MASK = 0x7f;
-/** Property indices (1-based into `ipco`) associated with `itemId` in an `ipma` box. */
-function itemProperties(bytes, ipma, itemId) {
-    const v = view(bytes);
-    const version = bytes[ipma.start];
-    const wide = v.getUint32(ipma.start) & IPMA_WIDE_INDEX;
-    let at = ipma.start + FULL_BOX_HEADER;
-    if (at + 4 > ipma.end)
-        return undefined;
-    const entries = v.getUint32(at);
-    at += 4;
-    for (let e = 0; e < entries; e++) {
-        const idSize = version < 1 ? 2 : 4;
-        if (at + idSize + 1 > ipma.end)
-            return undefined;
-        const id = idSize === 2 ? v.getUint16(at) : v.getUint32(at);
-        const count = bytes[at + idSize];
-        at += idSize + 1;
-        const indexSize = wide ? 2 : 1;
-        if (at + count * indexSize > ipma.end)
-            return undefined;
-        if (id === itemId) {
-            return Array.from({ length: count }, (_, i) => wide ? v.getUint16(at + i * 2) & IPMA_INDEX_MASK_WIDE : bytes[at + i] & IPMA_INDEX_MASK);
-        }
-        at += count * indexSize;
-    }
-    return undefined;
-}
-/**
- * HEIF / HEIC size: the `ispe` property of the primary item (`pitm`), which
- * for a tiled photo is the grid's full size. `undefined` when the primary item
- * also carries a clean-aperture crop (`clap`) — the delivered size differs.
- */
-function heifSize(bytes) {
-    if (!hasBrand(bytes, (brand) => HEIF_BRANDS.has(brand)))
-        return undefined;
-    const meta = boxes(bytes).list.find((b) => b.type === 'meta');
-    if (!meta)
-        return undefined;
-    const inner = boxes(bytes, meta.start + FULL_BOX_HEADER, meta.end).list;
-    const pitm = inner.find((b) => b.type === 'pitm');
-    const iprp = inner.find((b) => b.type === 'iprp');
-    if (!pitm || !iprp || pitm.start + FULL_BOX_HEADER + 2 > pitm.end)
-        return undefined;
-    const v = view(bytes);
-    const primary = bytes[pitm.start] === 0
-        ? v.getUint16(pitm.start + FULL_BOX_HEADER)
-        : v.getUint32(pitm.start + FULL_BOX_HEADER);
-    const props = boxes(bytes, iprp.start, iprp.end).list;
-    const ipco = props.find((b) => b.type === 'ipco');
-    const ipma = props.find((b) => b.type === 'ipma');
-    if (!ipco || !ipma)
-        return undefined;
-    const list = boxes(bytes, ipco.start, ipco.end).list;
-    const associated = itemProperties(bytes, ipma, primary)?.map((i) => list[i - 1]);
-    if (!associated || associated.some((b) => b?.type === 'clap'))
-        return undefined;
-    const ispe = associated.find((b) => b?.type === 'ispe');
-    if (!ispe || ispe.start + FULL_BOX_HEADER + 8 > ispe.end)
-        return undefined;
-    return positive({
-        width: v.getUint32(ispe.start + FULL_BOX_HEADER),
-        height: v.getUint32(ispe.start + FULL_BOX_HEADER + 4),
-    });
-}
-export function imageSize(bytes) {
-    return pngSize(bytes) ?? jpegSize(bytes) ?? gifSize(bytes) ?? webpSize(bytes) ?? heifSize(bytes);
-}

package/esm/src/kernel/engine/media-probe/iso-bmff.d.ts

@@ -1,19 +0,0 @@
-/** Version and flags that open every full box. */
-export declare const FULL_BOX_HEADER = 4;
-export interface Box {
-    type: string;
-    /** First payload byte (past size, type, and any large size). */
-    start: number;
-    /** One past the last payload byte. */
-    end: number;
-}
-/**
- * Boxes laid end to end in `[start, end)`. Stops at the first box whose size
- * does not fit; `complete` says whether the walk reached `end` exactly.
- */
-export declare function boxes(bytes: Uint8Array, start?: number, end?: number): {
-    list: Box[];
-    complete: boolean;
-};
-/** True when the file opens with an `ftyp` box whose major or compatible brands meet `accept`. */
-export declare function hasBrand(bytes: Uint8Array, accept: (brand: string) => boolean): boolean;

package/esm/src/kernel/engine/media-probe/iso-bmff.js

@@ -1,48 +0,0 @@
-import { ascii, uint64, view } from './bytes.js';
-const BOX_HEADER = 8;
-const LARGE_SIZE = 1;
-const TO_END = 0;
-/** Major brand and minor version precede the compatible brands. */
-const FTYP_COMPATIBLE = 8;
-/** Version and flags that open every full box. */
-export const FULL_BOX_HEADER = 4;
-/**
- * Boxes laid end to end in `[start, end)`. Stops at the first box whose size
- * does not fit; `complete` says whether the walk reached `end` exactly.
- */
-export function boxes(bytes, start = 0, end = bytes.length) {
-    const v = view(bytes);
-    const list = [];
-    let at = start;
-    while (at + BOX_HEADER <= end) {
-        const size32 = v.getUint32(at);
-        const type = ascii(bytes, at + 4, 4);
-        let header = BOX_HEADER;
-        let size = size32;
-        if (size32 === LARGE_SIZE) {
-            if (at + BOX_HEADER * 2 > end)
-                break;
-            size = uint64(v, at + BOX_HEADER);
-            header = BOX_HEADER * 2;
-        }
-        else if (size32 === TO_END) {
-            size = end - at;
-        }
-        if (size === undefined || size < header || at + size > end)
-            break;
-        list.push({ type, start: at + header, end: at + size });
-        at += size;
-    }
-    return { list, complete: at === end };
-}
-/** True when the file opens with an `ftyp` box whose major or compatible brands meet `accept`. */
-export function hasBrand(bytes, accept) {
-    const ftyp = boxes(bytes).list[0];
-    return ftyp?.type === 'ftyp' && brands(bytes, ftyp).some(accept);
-}
-function brands(bytes, ftyp) {
-    const list = [ascii(bytes, ftyp.start, 4)];
-    for (let at = ftyp.start + FTYP_COMPATIBLE; at + 4 <= ftyp.end; at += 4)
-        list.push(ascii(bytes, at, 4));
-    return list;
-}

package/esm/src/kernel/engine/media-probe/matroska.d.ts

@@ -1,35 +0,0 @@
-/** Matroska `TrackType` values. */
-export declare const MKV_VIDEO_TRACK = 1;
-export declare const MKV_AUDIO_TRACK = 2;
-export interface MatroskaTrack {
-    number?: number;
-    type?: number;
-    codec?: string;
-    codecDelayNs: number;
-    defaultDurationNs?: number;
-    pixelWidth?: number;
-    pixelHeight?: number;
-    /**
-     * Decoded 48 kHz Opus samples — packet samples less each group's
-     * `DiscardPadding`, before `CodecDelay`. `undefined` for a track that is not
-     * Opus or has a block that cannot be read exactly (laced).
-     */
-    opusSamples?: number;
-    /** Latest block timestamp, and the latest before it (ns). */
-    lastNs?: number;
-    previousNs?: number;
-}
-export interface Matroska {
-    tracks: MatroskaTrack[];
-    /** `Duration` from the segment info, in seconds. */
-    durationSeconds?: number;
-    /** Every element was walked to the end of the file; block sums are whole. */
-    complete: boolean;
-}
-/** Nanoseconds as a whole count of 48 kHz Opus samples. */
-export declare function opusSamplesFromNs(ns: number): number;
-/**
- * `undefined` without an EBML header. A truncated or unknown-sized leaf element, or an unreadable
- * block header, stops the walk with `complete: false`.
- */
-export declare function matroska(bytes: Uint8Array): Matroska | undefined;