@theoremjs/agents 0.3.0 → 0.3.1

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

@@ -1,226 +0,0 @@
-import { ascii, view } from './bytes.js';
-import { OPUS_RATE, opusPacketSamples } from './opus.js';
-const EBML_HEADER = 0x1a45dfa3;
-const MKV_SEGMENT = 0x18538067;
-const MKV_INFO = 0x1549a966;
-const MKV_TIMECODE_SCALE = 0x2ad7b1;
-const MKV_DURATION = 0x4489;
-const MKV_TRACKS = 0x1654ae6b;
-const MKV_TRACK_ENTRY = 0xae;
-const MKV_TRACK_NUMBER = 0xd7;
-const MKV_TRACK_TYPE = 0x83;
-const MKV_CODEC_ID = 0x86;
-const MKV_CODEC_DELAY = 0x56aa;
-const MKV_DEFAULT_DURATION = 0x23e383;
-const MKV_VIDEO = 0xe0;
-const MKV_PIXEL_WIDTH = 0xb0;
-const MKV_PIXEL_HEIGHT = 0xba;
-const MKV_CLUSTER = 0x1f43b675;
-const MKV_CLUSTER_TIMECODE = 0xe7;
-const MKV_SIMPLE_BLOCK = 0xa3;
-const MKV_BLOCK_GROUP = 0xa0;
-const MKV_BLOCK = 0xa1;
-const MKV_DISCARD_PADDING = 0x75a2;
-const MKV_DEFAULT_TIMECODE_SCALE = 1_000_000;
-const MKV_LACING = 0x06;
-/** Track number (vint), relative timestamp (int16), and flags open every block. */
-const MKV_BLOCK_FIXED = 3;
-const NS_PER_SECOND = 1e9;
-/**
- * Masters are walked into whatever their size says, since live recordings (MediaRecorder,
- * streaming muxers) leave Segment and Cluster sizes unknown; every other element is skipped by size.
- */
-const MKV_DESCEND = new Set([
-    MKV_SEGMENT,
-    MKV_INFO,
-    MKV_TRACKS,
-    MKV_TRACK_ENTRY,
-    MKV_VIDEO,
-    MKV_CLUSTER,
-]);
-/** Matroska `TrackType` values. */
-export const MKV_VIDEO_TRACK = 1;
-export const MKV_AUDIO_TRACK = 2;
-/** Variable-length integer: `value` with the length marker removed, `unknown` when all ones. */
-function vint(bytes, at, keepMarker) {
-    const first = bytes[at];
-    if (first === undefined || first === 0)
-        return undefined;
-    const length = Math.clz32(first) - 23;
-    if (at + length > bytes.length)
-        return undefined;
-    let value = keepMarker ? first : first & (0xff >> length);
-    let allOnes = value === 0xff >> length;
-    for (let i = 1; i < length; i++) {
-        value = value * 256 + bytes[at + i];
-        allOnes &&= bytes[at + i] === 0xff;
-    }
-    return { value, length, unknown: !keepMarker && allOnes };
-}
-function ebmlElement(bytes, at) {
-    const id = vint(bytes, at, true);
-    if (!id)
-        return undefined;
-    const size = vint(bytes, at + id.length, false);
-    if (!size)
-        return undefined;
-    return {
-        id: id.value,
-        body: at + id.length + size.length,
-        size: size.value,
-        unknown: size.unknown,
-    };
-}
-function mkvUint(bytes, at, size) {
-    let n = 0;
-    for (let i = 0; i < size; i++)
-        n = n * 256 + bytes[at + i];
-    return n;
-}
-function mkvInt(bytes, at, size) {
-    const n = mkvUint(bytes, at, size);
-    return size > 0 && bytes[at] & 0x80 ? n - 2 ** (8 * size) : n;
-}
-/** Nanoseconds as a whole count of 48 kHz Opus samples. */
-export function opusSamplesFromNs(ns) {
-    return Math.round((ns * OPUS_RATE) / NS_PER_SECOND);
-}
-/**
- * `undefined` without an EBML header. A truncated or unknown-sized leaf element, or an unreadable
- * block header, stops the walk with `complete: false`.
- */
-export function matroska(bytes) {
-    const head = vint(bytes, 0, true);
-    if (head?.value !== EBML_HEADER)
-        return undefined;
-    const walk = { tracks: [], scale: MKV_DEFAULT_TIMECODE_SCALE, clusterTimecode: 0 };
-    let at = 0;
-    while (at < bytes.length) {
-        const el = ebmlElement(bytes, at);
-        if (!el)
-            return undefined;
-        if (MKV_DESCEND.has(el.id)) {
-            if (el.id === MKV_TRACK_ENTRY)
-                walk.tracks.push({ codecDelayNs: 0, opusSamples: 0 });
-            at = el.body;
-            continue;
-        }
-        const incomplete = el.unknown || el.body + el.size > bytes.length;
-        if (incomplete || !readLeaf(bytes, el, walk)) {
-            // Past here nothing can be walked; only a stated duration still holds.
-            return {
-                tracks: walk.tracks,
-                durationSeconds: seconds(walk.duration, walk.scale),
-                complete: false,
-            };
-        }
-        at = el.body + el.size;
-    }
-    return {
-        tracks: walk.tracks,
-        durationSeconds: seconds(walk.duration, walk.scale),
-        complete: true,
-    };
-}
-/** Record one leaf element; `false` when a block in it cannot be read. */
-function readLeaf(bytes, el, walk) {
-    const track = walk.tracks.at(-1);
-    const v = view(bytes);
-    switch (el.id) {
-        case MKV_TIMECODE_SCALE:
-            walk.scale = mkvUint(bytes, el.body, el.size);
-            break;
-        case MKV_DURATION:
-            walk.duration =
-                el.size === 4 ? v.getFloat32(el.body) : el.size === 8 ? v.getFloat64(el.body) : undefined;
-            break;
-        case MKV_TRACK_NUMBER:
-            if (track)
-                track.number = mkvUint(bytes, el.body, el.size);
-            break;
-        case MKV_TRACK_TYPE:
-            if (track)
-                track.type = mkvUint(bytes, el.body, el.size);
-            break;
-        case MKV_CODEC_ID:
-            if (track)
-                track.codec = ascii(bytes, el.body, el.size).replace(/\0+$/, '');
-            break;
-        case MKV_CODEC_DELAY:
-            if (track)
-                track.codecDelayNs = mkvUint(bytes, el.body, el.size);
-            break;
-        case MKV_DEFAULT_DURATION:
-            if (track)
-                track.defaultDurationNs = mkvUint(bytes, el.body, el.size);
-            break;
-        case MKV_PIXEL_WIDTH:
-            if (track)
-                track.pixelWidth = mkvUint(bytes, el.body, el.size);
-            break;
-        case MKV_PIXEL_HEIGHT:
-            if (track)
-                track.pixelHeight = mkvUint(bytes, el.body, el.size);
-            break;
-        case MKV_CLUSTER_TIMECODE:
-            walk.clusterTimecode = mkvUint(bytes, el.body, el.size);
-            break;
-        case MKV_SIMPLE_BLOCK:
-            return addBlock(bytes, el.body, el.body + el.size, walk, 0);
-        case MKV_BLOCK_GROUP:
-            return addBlockGroup(bytes, el, walk);
-    }
-    return true;
-}
-function seconds(duration, scale) {
-    return duration === undefined ? undefined : (duration * scale) / NS_PER_SECOND;
-}
-/** One `BlockGroup`: its `Block`, less any `DiscardPadding` declared beside it. */
-function addBlockGroup(bytes, group, walk) {
-    const end = group.body + group.size;
-    let block;
-    let discardNs = 0;
-    for (let at = group.body; at < end;) {
-        const el = ebmlElement(bytes, at);
-        if (!el || el.unknown || el.body + el.size > end)
-            return false;
-        if (el.id === MKV_BLOCK)
-            block = el;
-        if (el.id === MKV_DISCARD_PADDING)
-            discardNs = mkvInt(bytes, el.body, el.size);
-        at = el.body + el.size;
-    }
-    return (block !== undefined && addBlock(bytes, block.body, block.body + block.size, walk, discardNs));
-}
-/**
- * Credit one block to its track: its timestamp, and — for an Opus track — its
- * decoded samples. `false` when the block header itself cannot be read.
- */
-function addBlock(bytes, at, end, walk, discardNs) {
-    const trackNumber = vint(bytes, at, false);
-    if (!trackNumber)
-        return false;
-    const header = at + trackNumber.length;
-    if (header + MKV_BLOCK_FIXED > end)
-        return false;
-    const track = walk.tracks.find((t) => t.number === trackNumber.value);
-    if (!track)
-        return true;
-    const relative = view(bytes).getInt16(header);
-    const ns = (walk.clusterTimecode + relative) * walk.scale;
-    if (track.lastNs === undefined || ns > track.lastNs) {
-        track.previousNs = track.lastNs;
-        track.lastNs = ns;
-    }
-    else if (ns < track.lastNs && (track.previousNs === undefined || ns > track.previousNs)) {
-        track.previousNs = ns;
-    }
-    if (track.opusSamples === undefined)
-        return true;
-    const samples = track.codec === 'A_OPUS' && !(bytes[header + 2] & MKV_LACING)
-        ? opusPacketSamples(bytes, header + MKV_BLOCK_FIXED, end)
-        : undefined;
-    track.opusSamples =
-        samples === undefined ? undefined : track.opusSamples + samples - opusSamplesFromNs(discardNs);
-    return true;
-}

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

@@ -1,22 +0,0 @@
-export declare const MP4_SOUND = "soun";
-export declare const MP4_VIDEO = "vide";
-export interface Mp4Track {
-    /** `hdlr` handler type — `soun`, `vide`, … */
-    handler: string;
-    /**
-     * Presented length: the `tkhd` duration (edit-list aware), else the sum of
-     * the track's sample durations. `undefined` when neither can be read.
-     */
-    seconds?: number;
-    /**
-     * From the edit list's leading skip (encoder priming, reorder delay) to the end of the sample the
-     * edit ends in, which a decoder keeps whole. `undefined` when the samples cannot be summed, or the
-     * edit list holds more than one non-empty edit or ends before the last sample.
-     */
-    decodedSeconds?: number;
-    /** Coded frame size from the first visual sample entry (video tracks). */
-    width?: number;
-    height?: number;
-}
-/** `undefined` when the bytes do not open with `ftyp` and hold a `moov`. */
-export declare function mp4Tracks(bytes: Uint8Array): Mp4Track[] | undefined;

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

@@ -1,279 +0,0 @@
-import { ascii, uint64, view } from './bytes.js';
-import { boxes, FULL_BOX_HEADER } from './iso-bmff.js';
-const TIMED_V0_SCALE = 12;
-const TIMED_V1_SCALE = 20;
-const TKHD_V0_TRACK_ID = 12;
-const TKHD_V1_TRACK_ID = 20;
-const TKHD_V0_DURATION = 20;
-const TKHD_V1_DURATION = 28;
-const STTS_ENTRIES = FULL_BOX_HEADER + 4;
-const STTS_ENTRY = 8;
-const HDLR_TYPE = FULL_BOX_HEADER + 4;
-/** Visual sample entry: 8-byte box header, 6 reserved, data reference, 16 pre-defined/reserved. */
-const VISUAL_ENTRY_WIDTH = 8 + 6 + 2 + 16;
-const STSD_ENTRIES = FULL_BOX_HEADER + 4;
-const TFHD_DEFAULT_DURATION = 0x08;
-const TFHD_OPTIONAL = [
-    [0x01, 8],
-    [0x02, 4],
-];
-const TRUN_DATA_OFFSET = 0x01;
-const TRUN_FIRST_FLAGS = 0x04;
-const TRUN_DURATION = 0x100;
-const TRUN_FIELDS = [0x100, 0x200, 0x400, 0x800];
-const U32_UNKNOWN = 0xffffffff;
-/** `elst` media time of an empty edit — a gap that plays no samples. */
-const EMPTY_EDIT = -1;
-const ELST_ENTRIES = FULL_BOX_HEADER + 4;
-const ELST_V0_ENTRY = 12;
-const ELST_V1_ENTRY = 20;
-export const MP4_SOUND = 'soun';
-export const MP4_VIDEO = 'vide';
-const MPEG4_AUDIO = 'mp4a';
-/** Timescale and duration from an `mvhd` or `mdhd` payload. */
-function timedHeader(bytes, box) {
-    const v = view(bytes);
-    const version = bytes[box.start];
-    const scaleAt = box.start + (version === 1 ? TIMED_V1_SCALE : TIMED_V0_SCALE);
-    if (scaleAt + (version === 1 ? 12 : 8) > box.end)
-        return undefined;
-    const scale = v.getUint32(scaleAt);
-    const duration = version === 1 ? uint64(v, scaleAt + 4) : knownU32(v.getUint32(scaleAt + 4));
-    return scale > 0 ? { scale, duration } : undefined;
-}
-function knownU32(n) {
-    return n === U32_UNKNOWN ? undefined : n;
-}
-function childList(bytes, box) {
-    return boxes(bytes, box.start, box.end).list;
-}
-function descend(bytes, box, path) {
-    let at = box;
-    for (const type of path) {
-        at = at ? childList(bytes, at).find((b) => b.type === type) : undefined;
-    }
-    return at;
-}
-/** Track id and presented duration (movie timescale) from `tkhd`. */
-function trackHeader(bytes, tkhd) {
-    const v = view(bytes);
-    const wide = bytes[tkhd.start] === 1;
-    const idAt = tkhd.start + (wide ? TKHD_V1_TRACK_ID : TKHD_V0_TRACK_ID);
-    const durationAt = tkhd.start + (wide ? TKHD_V1_DURATION : TKHD_V0_DURATION);
-    if (durationAt + (wide ? 8 : 4) > tkhd.end)
-        return undefined;
-    const duration = wide ? uint64(v, durationAt) : knownU32(v.getUint32(durationAt));
-    return { id: v.getUint32(idAt), duration };
-}
-/**
- * The track's non-empty edit — `{ mediaTime: 0, duration: 0 }` without an edit
- * list; `undefined` when the list cannot be read or holds more than one.
- */
-function soleEdit(bytes, elst) {
-    if (!elst)
-        return { mediaTime: 0, duration: 0 };
-    const v = view(bytes);
-    const wide = bytes[elst.start] === 1;
-    const size = wide ? ELST_V1_ENTRY : ELST_V0_ENTRY;
-    if (elst.start + ELST_ENTRIES > elst.end)
-        return undefined;
-    const count = v.getUint32(elst.start + FULL_BOX_HEADER);
-    let edit;
-    for (let i = 0, at = elst.start + ELST_ENTRIES; i < count; i++, at += size) {
-        if (at + size > elst.end)
-            return undefined;
-        const duration = wide ? uint64(v, at) : v.getUint32(at);
-        const mediaTime = wide ? int64(v, at + 8) : v.getInt32(at + 4);
-        if (duration === undefined || mediaTime === undefined)
-            return undefined;
-        if (mediaTime === EMPTY_EDIT)
-            continue;
-        if (edit)
-            return undefined;
-        edit = { mediaTime, duration };
-    }
-    return edit ?? { mediaTime: 0, duration: 0 };
-}
-function int64(v, at) {
-    const n = v.getBigInt64(at);
-    return n >= BigInt(Number.MIN_SAFE_INTEGER) && n <= BigInt(Number.MAX_SAFE_INTEGER)
-        ? Number(n)
-        : undefined;
-}
-/** Four-character type of the first sample entry in `stsd`. */
-function sampleEntry(bytes, stsd) {
-    const at = stsd.start + STSD_ENTRIES;
-    return at + 8 <= stsd.end ? ascii(bytes, at + 4, 4) : undefined;
-}
-function visualSize(bytes, stsd) {
-    const entry = stsd.start + STSD_ENTRIES;
-    const at = entry + VISUAL_ENTRY_WIDTH;
-    if (at + 4 > stsd.end)
-        return undefined;
-    const v = view(bytes);
-    const width = v.getUint16(at);
-    const height = v.getUint16(at + 2);
-    return width > 0 && height > 0 ? { width, height } : undefined;
-}
-/** Default sample duration for `trackId` from `moov/mvex/trex`. */
-function trexDuration(bytes, moov, trackId) {
-    const mvex = descend(bytes, moov, ['mvex']);
-    if (!mvex)
-        return undefined;
-    const v = view(bytes);
-    for (const trex of childList(bytes, mvex).filter((b) => b.type === 'trex')) {
-        const at = trex.start + FULL_BOX_HEADER;
-        if (at + 12 <= trex.end && v.getUint32(at) === trackId)
-            return v.getUint32(at + 8);
-    }
-    return undefined;
-}
-function addSamples(sum, count, delta) {
-    if (count === 0)
-        return sum ?? { ticks: 0, last: 0 };
-    return {
-        ticks: (sum?.ticks ?? 0) + count * delta,
-        last: delta,
-        previous: count > 1 ? delta : sum?.last,
-    };
-}
-function sttsSamples(bytes, stts) {
-    if (!stts || stts.start + STTS_ENTRIES > stts.end)
-        return undefined;
-    const v = view(bytes);
-    const count = v.getUint32(stts.start + FULL_BOX_HEADER);
-    let sum;
-    for (let i = 0, at = stts.start + STTS_ENTRIES; i < count; i++, at += STTS_ENTRY) {
-        if (at + STTS_ENTRY > stts.end)
-            return undefined;
-        sum = addSamples(sum, v.getUint32(at), v.getUint32(at + 4));
-    }
-    return sum;
-}
-function fragmentSamples(bytes, top, trackId, trex) {
-    const v = view(bytes);
-    let sum;
-    for (const moof of top.filter((b) => b.type === 'moof')) {
-        for (const traf of childList(bytes, moof).filter((b) => b.type === 'traf')) {
-            const inner = childList(bytes, traf);
-            const tfhd = inner.find((b) => b.type === 'tfhd');
-            if (!tfhd || tfhd.start + 8 > tfhd.end)
-                return undefined;
-            const tfhdFlags = v.getUint32(tfhd.start) & 0xffffff;
-            if (v.getUint32(tfhd.start + FULL_BOX_HEADER) !== trackId)
-                continue;
-            let at = tfhd.start + 8;
-            for (const [flag, width] of TFHD_OPTIONAL)
-                if (tfhdFlags & flag)
-                    at += width;
-            const fallback = tfhdFlags & TFHD_DEFAULT_DURATION && at + 4 <= tfhd.end ? v.getUint32(at) : trex;
-            for (const trun of inner.filter((b) => b.type === 'trun')) {
-                const next = runSamples(v, trun, fallback, sum);
-                if (next === undefined)
-                    return undefined;
-                sum = next;
-            }
-        }
-    }
-    return sum;
-}
-function runSamples(v, trun, fallback, sum) {
-    const flags = v.getUint32(trun.start) & 0xffffff;
-    const count = v.getUint32(trun.start + FULL_BOX_HEADER);
-    let at = trun.start + 8;
-    if (flags & TRUN_DATA_OFFSET)
-        at += 4;
-    if (flags & TRUN_FIRST_FLAGS)
-        at += 4;
-    if (!(flags & TRUN_DURATION)) {
-        return fallback === undefined ? undefined : addSamples(sum, count, fallback);
-    }
-    const stride = TRUN_FIELDS.filter((f) => flags & f).length * 4;
-    if (at + stride * count > trun.end)
-        return undefined;
-    let next = addSamples(sum, 0, 0);
-    for (let i = 0; i < count; i++)
-        next = addSamples(next, 1, v.getUint32(at + i * stride));
-    return next;
-}
-/**
- * Decoded ticks: from the edit's start to the end of the sample it ends in.
- * `undefined` when the edit ends before the last sample begins.
- *
- * MPEG-4 audio (`mp4a`) decodes whole frames: a final sample whose `stts`
- * duration is shortened (how ffmpeg marks encoder padding) still decodes as
- * long as the frame before it.
- */
-function decodedTicks(samples, edit, mediaScale, movieScale, wholeFrames) {
-    const lastStart = samples.ticks - samples.last;
-    if (edit.duration > 0) {
-        if (!movieScale)
-            return undefined;
-        const editEnd = edit.mediaTime + (edit.duration * mediaScale) / movieScale;
-        if (editEnd <= lastStart)
-            return undefined;
-    }
-    const frame = wholeFrames && samples.previous !== undefined
-        ? Math.max(samples.last, samples.previous)
-        : samples.last;
-    return lastStart + frame - edit.mediaTime;
-}
-function positive(seconds) {
-    return Number.isFinite(seconds) && seconds > 0 ? seconds : undefined;
-}
-function trackSamples(bytes, movie, stbl, trackId) {
-    const table = sttsSamples(bytes, stbl && descend(bytes, stbl, ['stts']));
-    const fragments = trackId === undefined
-        ? undefined
-        : fragmentSamples(bytes, movie.top, trackId, trexDuration(bytes, movie.moov, trackId));
-    if (!table || !fragments)
-        return fragments ?? table;
-    // Fragments follow the samples `moov` lists; the last sample is theirs.
-    return {
-        ticks: table.ticks + fragments.ticks,
-        last: fragments.last,
-        previous: fragments.previous ?? table.last,
-    };
-}
-function presentedSeconds(duration, movie, samples, mediaScale) {
-    if (duration && movie.scale)
-        return positive(duration / movie.scale);
-    return samples && mediaScale ? positive(samples.ticks / mediaScale) : undefined;
-}
-function readTrack(bytes, movie, trak) {
-    const tkhd = descend(bytes, trak, ['tkhd']);
-    const hdlr = descend(bytes, trak, ['mdia', 'hdlr']);
-    const mdhd = descend(bytes, trak, ['mdia', 'mdhd']);
-    if (!tkhd || !hdlr || !mdhd || hdlr.start + HDLR_TYPE + 4 > hdlr.end)
-        return undefined;
-    const handler = ascii(bytes, hdlr.start + HDLR_TYPE, 4);
-    const header = trackHeader(bytes, tkhd);
-    const media = timedHeader(bytes, mdhd);
-    const stbl = descend(bytes, trak, ['mdia', 'minf', 'stbl']);
-    const stsd = stbl && descend(bytes, stbl, ['stsd']);
-    const samples = trackSamples(bytes, movie, stbl, header?.id);
-    const edit = soleEdit(bytes, descend(bytes, trak, ['edts', 'elst']));
-    const wholeFrames = stsd !== undefined && sampleEntry(bytes, stsd) === MPEG4_AUDIO;
-    const decoded = samples && media && edit
-        ? decodedTicks(samples, edit, media.scale, movie.scale, wholeFrames)
-        : undefined;
-    return {
-        handler,
-        seconds: presentedSeconds(header?.duration, movie, samples, media?.scale),
-        decodedSeconds: decoded === undefined || !media ? undefined : positive(decoded / media.scale),
-        ...(handler === MP4_VIDEO && stsd ? visualSize(bytes, stsd) : undefined),
-    };
-}
-/** `undefined` when the bytes do not open with `ftyp` and hold a `moov`. */
-export function mp4Tracks(bytes) {
-    const top = boxes(bytes).list;
-    const moov = top.find((b) => b.type === 'moov');
-    if (top[0]?.type !== 'ftyp' || !moov)
-        return undefined;
-    const mvhd = descend(bytes, moov, ['mvhd']);
-    const movie = { top, moov, scale: mvhd ? timedHeader(bytes, mvhd)?.scale : undefined };
-    return childList(bytes, moov)
-        .filter((b) => b.type === 'trak')
-        .map((trak) => readTrack(bytes, movie, trak))
-        .filter((track) => track !== undefined);
-}

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

@@ -1,4 +0,0 @@
-/** Opus always decodes at 48 kHz. */
-export declare const OPUS_RATE = 48000;
-/** Opus packet duration in 48 kHz samples from its TOC byte (RFC 6716 §3.1). */
-export declare function opusPacketSamples(bytes: Uint8Array, at: number, end: number): number | undefined;

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

@@ -1,23 +0,0 @@
-/** Opus always decodes at 48 kHz. */
-export const OPUS_RATE = 48_000;
-const MS_PER_SECOND = 1000;
-const TOC_CONFIG_SHIFT = 3;
-const TOC_FRAME_CODE = 0x03;
-const FRAME_COUNT_MASK = 0x3f;
-const SILK_CONFIGS = 12;
-const HYBRID_CONFIGS = 16;
-/** Opus packet duration in 48 kHz samples from its TOC byte (RFC 6716 §3.1). */
-export function opusPacketSamples(bytes, at, end) {
-    if (at >= end)
-        return undefined;
-    const toc = bytes[at];
-    const config = toc >> TOC_CONFIG_SHIFT;
-    const frameMs = config < SILK_CONFIGS
-        ? [10, 20, 40, 60][config % 4]
-        : config < HYBRID_CONFIGS
-            ? [10, 20][config % 2]
-            : [2.5, 5, 10, 20][config % 4];
-    const code = toc & TOC_FRAME_CODE;
-    const frames = code === 0 ? 1 : code < 3 ? 2 : at + 1 < end ? bytes[at + 1] & FRAME_COUNT_MASK : undefined;
-    return frames === undefined ? undefined : (frameMs * frames * OPUS_RATE) / MS_PER_SECOND;
-}

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

@@ -1,5 +0,0 @@
-/**
- * The last page-tree root in file order wins, so an incremental update that rewrites the page tree
- * beats the original. `undefined` when no root can be read (encrypted object streams, damage).
- */
-export declare function pdfPageCount(bytes: Uint8Array): Promise<number | undefined>;

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

@@ -1,117 +0,0 @@
-const PDF_PAGES_TYPE = /\/Type\s*\/Pages(?![A-Za-z])/g;
-const PDF_COUNT = /\/Count\s+(\d+)/;
-const PDF_PARENT = /\/Parent(?![A-Za-z])/;
-const PDF_OBJSTM = /\/Type\s*\/ObjStm(?![A-Za-z])/g;
-const PDF_STREAM_START = /stream\r?\n/g;
-/** Direct `/Length n` — not an indirect `/Length n 0 R`. */
-const PDF_DIRECT_LENGTH = /\/Length\s+(\d+)(?!\d)(?!\s+\d+\s+R)/;
-/** End-of-line before `endstream`; not part of the stream data. */
-const PDF_TRAILING_EOL = /\r?\n$|\r$/;
-const PDF_HEADER = '%PDF-';
-function latin1(bytes) {
-    return new TextDecoder('latin1').decode(bytes);
-}
-/** Innermost `<< … >>` dictionary that contains `at`, with its end offset. */
-function enclosingDict(text, at) {
-    let depth = 0;
-    let start = -1;
-    for (let i = at; i > 0; i--) {
-        if (text[i] === '>' && text[i - 1] === '>') {
-            depth++;
-            i--;
-        }
-        else if (text[i] === '<' && text[i - 1] === '<') {
-            if (depth === 0) {
-                start = i - 1;
-                break;
-            }
-            depth--;
-            i--;
-        }
-    }
-    if (start < 0)
-        return undefined;
-    depth = 0;
-    for (let i = start; i < text.length - 1; i++) {
-        if (text[i] === '<' && text[i + 1] === '<') {
-            depth++;
-            i++;
-        }
-        else if (text[i] === '>' && text[i + 1] === '>') {
-            depth--;
-            i++;
-            if (depth === 0)
-                return { dict: text.slice(start, i + 1), end: i + 1 };
-        }
-    }
-    return undefined;
-}
-/** Page-tree roots in `text`, each placed at `at` (or at its own offset when `at` is omitted). */
-function pageTreeRoots(text, at) {
-    const roots = [];
-    for (const match of text.matchAll(PDF_PAGES_TYPE)) {
-        const dict = enclosingDict(text, match.index)?.dict;
-        if (!dict || PDF_PARENT.test(dict))
-            continue;
-        const count = PDF_COUNT.exec(dict)?.[1];
-        if (count !== undefined)
-            roots.push({ at: at ?? match.index, count: Number(count) });
-    }
-    return roots;
-}
-async function inflate(bytes) {
-    try {
-        const stream = new Blob([bytes.slice()])
-            .stream()
-            .pipeThrough(new DecompressionStream('deflate'));
-        return new Uint8Array(await new Response(stream).arrayBuffer());
-    }
-    catch {
-        return undefined;
-    }
-}
-/** End offset of stream data: the direct `/Length`, else up to `endstream` less its EOL. */
-function streamEnd(text, bodyStart, dict) {
-    const length = PDF_DIRECT_LENGTH.exec(dict)?.[1];
-    if (length !== undefined && bodyStart + Number(length) <= text.length) {
-        return bodyStart + Number(length);
-    }
-    const keyword = text.indexOf('endstream', bodyStart);
-    if (keyword < 0)
-        return undefined;
-    const eol = PDF_TRAILING_EOL.exec(text.slice(bodyStart, keyword));
-    return keyword - (eol?.[0].length ?? 0);
-}
-/** Page-tree roots inside FlateDecode object streams (`/Type /ObjStm`), placed at the stream. */
-async function objectStreamRoots(text, bytes) {
-    const roots = [];
-    for (const match of text.matchAll(PDF_OBJSTM)) {
-        const found = enclosingDict(text, match.index);
-        if (!found?.dict.includes('/FlateDecode'))
-            continue;
-        PDF_STREAM_START.lastIndex = found.end;
-        const start = PDF_STREAM_START.exec(text);
-        if (!start || text.slice(found.end, start.index).trim() !== '')
-            continue;
-        const bodyStart = start.index + start[0].length;
-        const bodyEnd = streamEnd(text, bodyStart, found.dict);
-        if (bodyEnd === undefined)
-            continue;
-        const inflated = await inflate(bytes.subarray(bodyStart, bodyEnd));
-        if (inflated)
-            roots.push(...pageTreeRoots(latin1(inflated), match.index));
-    }
-    return roots;
-}
-/**
- * The last page-tree root in file order wins, so an incremental update that rewrites the page tree
- * beats the original. `undefined` when no root can be read (encrypted object streams, damage).
- */
-export async function pdfPageCount(bytes) {
-    const text = latin1(bytes);
-    if (!text.startsWith(PDF_HEADER))
-        return undefined;
-    const roots = [...pageTreeRoots(text), ...(await objectStreamRoots(text, bytes))];
-    const last = roots.sort((a, b) => a.at - b.at).at(-1);
-    return last && last.count > 0 ? last.count : undefined;
-}