video-fps-probe 0.3.0 → 0.4.0-beta.2

package/dist/url/index.js

@@ -0,0 +1,335 @@
+export class RangeSourceError extends Error {
+    code;
+    status;
+    constructor(code, message, options = {}) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = 'RangeSourceError';
+        this.code = code;
+        this.status = typeof options.status === 'number' ? options.status : null;
+    }
+}
+const HEAD_BYTES = 65536;
+const CONTENT_RANGE = /^\s*bytes\s+(\d+)-(\d+)\/(\d+|\*)\s*$/i;
+const noop = () => { };
+const tag = (v) => Object.prototype.toString.call(v);
+function shown(value) {
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    if (typeof value === 'object' && value !== null)
+        return Array.isArray(value) ? 'an array' : 'an object';
+    return String(value);
+}
+function count(value, what, min = 0) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < min)
+        throw new TypeError(`${what} must be a non-negative safe integer${min > 0 ? ` of at least ${min}` : ''}, got ${shown(value)}`);
+    return value;
+}
+function signalOf(value, what) {
+    if (value === undefined || value === null)
+        return null;
+    const s = value;
+    if (typeof s !== 'object' || typeof s.aborted !== 'boolean' || typeof s.addEventListener !== 'function' || typeof s.removeEventListener !== 'function')
+        throw new TypeError(`${what} must be an AbortSignal, got ${shown(value)}`);
+    return value;
+}
+function objectOf(value, what) {
+    if (value === undefined)
+        return {};
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new TypeError(`${what} must be an object, got ${shown(value)}`);
+    return value;
+}
+function fetcherOf(value) {
+    if (typeof value !== 'function')
+        throw new TypeError(`fetcher must be a function, got ${shown(value)}`);
+    return value;
+}
+const reasonOf = (signal) => signal.reason ?? new DOMException('This operation was aborted', 'AbortError');
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw reasonOf(signal);
+}
+function linked(a, b) {
+    if (!a || !b || a === b || a.aborted || b.aborted)
+        return [a?.aborted || !b ? a : b, noop];
+    const c = new AbortController();
+    const fromA = () => c.abort(reasonOf(a));
+    const fromB = () => c.abort(reasonOf(b));
+    a.addEventListener('abort', fromA, { once: true });
+    b.addEventListener('abort', fromB, { once: true });
+    return [c.signal, () => (a.removeEventListener('abort', fromA), b.removeEventListener('abort', fromB))];
+}
+function untilAborted(pending, signal, late = noop) {
+    return new Promise((resolve, reject) => {
+        const stop = () => reject(reasonOf(signal));
+        if (signal?.aborted)
+            stop();
+        else
+            signal?.addEventListener('abort', stop, { once: true });
+        pending.then((value) => {
+            signal?.removeEventListener('abort', stop);
+            if (signal?.aborted)
+                late(value);
+            else
+                resolve(value);
+        }, (e) => {
+            signal?.removeEventListener('abort', stop);
+            reject(!signal?.aborted && e?.name === 'AbortError' ? Object.assign(new Error(String(e), { cause: e }), { name: '' }) : e);
+        });
+    });
+}
+function attempt(run) {
+    try {
+        return Promise.resolve(run());
+    }
+    catch (e) {
+        return Promise.reject(e);
+    }
+}
+function discard(reply) {
+    attempt(() => reply?.discard?.()).catch(noop);
+}
+function parseRange(value) {
+    const m = CONTENT_RANGE.exec(value);
+    if (!m)
+        return null;
+    const first = Number(m[1]);
+    const last = Number(m[2]);
+    const total = m[3] === '*' ? null : Number(m[3]);
+    if (!Number.isSafeInteger(first) || !Number.isSafeInteger(last) || first > last || (total !== null && !Number.isSafeInteger(total)))
+        return null;
+    return { first, last, total };
+}
+const present = (value) => value !== undefined && value !== null;
+const contentRangeOf = ({ contentRange: v }) => (typeof v === 'string' ? (v.trim() === '' ? null : v) : present(v) ? String(v) : null);
+function replyOf(value, range) {
+    if (typeof value !== 'object' || value === null)
+        throw new RangeSourceError('invalid-reply', `the reply to ${range} is ${shown(value)}, not an object`);
+    return value;
+}
+function refusal(reply, start, end, size, range) {
+    const status = present(reply.status) ? reply.status : null;
+    const contentRange = contentRangeOf(reply);
+    if (status === null && contentRange === null)
+        return new RangeSourceError('unverifiable-reply', `the reply to ${range} has neither a status nor a Content-Range, so it cannot be checked`);
+    if (status !== null && status !== 206 && !(status === 200 && start === 0 && end === size)) {
+        return new RangeSourceError('unexpected-status', `status ${shown(status)} to ${range} of an object of ${size} bytes, expected 206${start === 0 && end === size ? ' or 200' : ''}`, { status });
+    }
+    if (contentRange !== null) {
+        const r = parseRange(contentRange);
+        if (r && r.total !== null && r.total !== size)
+            return new RangeSourceError('size-changed', `Content-Range ${shown(contentRange)} gives an object of ${r.total} bytes, the source was opened at ${size} bytes`, { status });
+        if (!r || r.first !== start || r.last !== end - 1)
+            return new RangeSourceError('range-mismatch', `Content-Range ${shown(contentRange)} does not match ${range}`, { status });
+    }
+    if (present(reply.contentLength) && reply.contentLength !== end - start)
+        return new RangeSourceError('length-mismatch', `Content-Length ${shown(reply.contentLength)} does not match ${range} (${end - start} bytes)`, { status });
+    return null;
+}
+function exactly(value, length, what) {
+    let bytes;
+    if (ArrayBuffer.isView(value))
+        bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    else if (tag(value) === '[object ArrayBuffer]')
+        bytes = new Uint8Array(value);
+    else
+        throw new RangeSourceError('invalid-reply', `${what} is ${value === null ? 'null' : typeof value}, not bytes`);
+    if (bytes.byteLength > length)
+        throw new RangeSourceError('body-too-long', `${what} holds ${bytes.byteLength} bytes, more than the ${length} requested`);
+    if (bytes.byteLength < length)
+        throw new RangeSourceError('body-too-short', `${what} holds ${bytes.byteLength} of the ${length} bytes requested`);
+    return bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength && tag(bytes.buffer) === '[object ArrayBuffer]' ? bytes : bytes.slice();
+}
+async function bodyOf(reply, length, range, signal) {
+    const what = `the body of ${range}`;
+    try {
+        if (present(reply.bytes))
+            return exactly(reply.bytes, length, what);
+        const read = reply.body;
+        if (typeof read !== 'function')
+            throw new RangeSourceError('invalid-reply', `the reply to ${range} has neither bytes nor a body function`);
+        return exactly(await untilAborted(attempt(() => read.call(reply, length)), signal), length, what);
+    }
+    catch (e) {
+        discard(reply);
+        throw e;
+    }
+}
+function request(fetcher, start, end, signal) {
+    const range = `bytes=${start}-${end - 1}`;
+    return [range, untilAborted(attempt(() => fetcher({ start, end, range, signal })), signal, discard).then((value) => replyOf(value, range))];
+}
+function sourceOf(fetcher, size, own, head) {
+    const read = async (start, end, signal) => {
+        count(start, 'start');
+        count(end, 'end');
+        if (start > end || end > size)
+            throw new RangeError(`read needs start <= end <= size (${size}), got ${start} and ${end}`);
+        const [joined, release] = linked(own, signalOf(signal, 'signal'));
+        try {
+            throwIfAborted(joined);
+            if (start === end)
+                return new Uint8Array(0);
+            if (head && end <= head.byteLength)
+                return head.slice(start, end);
+            const [range, pending] = request(fetcher, start, end, joined);
+            const reply = await pending;
+            const refused = refusal(reply, start, end, size, range);
+            if (refused) {
+                discard(reply);
+                throw refused;
+            }
+            return await bodyOf(reply, end - start, range, joined);
+        }
+        finally {
+            release();
+        }
+    };
+    const clamp = (value, fallback) => {
+        if (value === undefined)
+            return fallback;
+        const n = Math.round(Number(value)) || 0;
+        return n < 0 ? Math.max(size + n, 0) : Math.min(n, size);
+    };
+    return {
+        size,
+        read,
+        slice(start, end) {
+            const from = clamp(start, 0);
+            const to = Math.max(from, clamp(end, size));
+            return { arrayBuffer: () => read(from, to, own).then((bytes) => bytes.buffer) };
+        },
+    };
+}
+export function rangeSource(fetcher, init) {
+    const f = fetcherOf(fetcher);
+    const o = objectOf(init, 'init');
+    return sourceOf(f, count(o.size, 'init.size'), signalOf(o.signal, 'init.signal'), null);
+}
+export async function openRangeSource(fetcher, init = {}) {
+    const f = fetcherOf(fetcher);
+    const o = objectOf(init, 'init');
+    const signal = signalOf(o.signal, 'init.signal');
+    if (o.size !== undefined)
+        return sourceOf(f, count(o.size, 'init.size'), signal, null);
+    const headBytes = o.headBytes === undefined ? HEAD_BYTES : count(o.headBytes, 'init.headBytes', 1);
+    throwIfAborted(signal);
+    const [range, pending] = request(f, 0, headBytes, signal);
+    const reply = await pending;
+    const status = present(reply.status) ? reply.status : null;
+    const contentRange = contentRangeOf(reply);
+    const r = contentRange === null ? null : parseRange(contentRange);
+    const length = present(reply.contentLength) ? reply.contentLength : null;
+    const refuse = (code, message) => {
+        discard(reply);
+        throw new RangeSourceError(code, message, { status });
+    };
+    if ((status === 416 || status === null) && contentRange !== null && /^\s*bytes\s+\*\/0\s*$/i.test(contentRange)) {
+        discard(reply);
+        return sourceOf(f, 0, signal, new Uint8Array(0));
+    }
+    let size;
+    if (status === 200) {
+        if (length === null || !Number.isSafeInteger(length) || length < 0 || length > headBytes)
+            refuse('unexpected-status', `status 200 to ${range} with ${length === null ? 'no Content-Length' : `Content-Length ${shown(length)}`}: the server sent the whole object instead of the range, and only an object of at most ${headBytes} bytes is accepted that way`);
+        if (contentRange !== null && (!r || r.first !== 0 || r.last !== length - 1 || r.total !== length))
+            refuse('range-mismatch', `Content-Range ${shown(contentRange)} does not match the whole object of ${length} bytes`);
+        size = length;
+    }
+    else if (status === 206 || (status === null && contentRange !== null)) {
+        if (contentRange === null)
+            refuse('unverifiable-reply', `the 206 reply to ${range} has no Content-Range, or does not expose it to a cross-origin page, so the object size is unknown: pass init.size`);
+        if (!r || r.total === null || r.first !== 0 || r.last !== Math.min(headBytes, r.total) - 1)
+            refuse('range-mismatch', `Content-Range ${shown(contentRange)} does not match ${range} of an object of known size`);
+        if (length !== null && length !== r.last + 1)
+            refuse('length-mismatch', `Content-Length ${shown(length)} does not match Content-Range ${shown(contentRange)}`);
+        size = r.total;
+    }
+    else if (status === null) {
+        return refuse('unverifiable-reply', `the reply to ${range} has neither a status nor a Content-Range, so it cannot be checked`);
+    }
+    else {
+        return refuse('unexpected-status', `status ${shown(status)} to ${range}, expected 206`);
+    }
+    return sourceOf(f, size, signal, await bodyOf(reply, Math.min(size, headBytes), range, signal));
+}
+function named(e, signal) {
+    const c = e?.cause;
+    const detail = c?.code ?? c?.message;
+    return signal?.aborted || e?.name !== 'TypeError' || typeof detail !== 'string' ? e : new TypeError(`${e.message}: ${detail}`, { cause: e });
+}
+export function httpRange(url, init = {}) {
+    const href = typeof url === 'string' ? url : typeof url?.href === 'string' ? url.href : null;
+    if (!href)
+        throw new TypeError(`url must be a non-empty string or a URL, got ${shown(url)}`);
+    const o = objectOf(init, 'init');
+    const headers = objectOf(o.headers, 'init.headers');
+    const run = o.fetch ?? globalThis.fetch;
+    if (typeof run !== 'function')
+        throw new TypeError('httpRange needs a fetch function: pass init.fetch where globalThis.fetch does not exist');
+    return async ({ range, signal }) => {
+        const h = new Headers(headers);
+        h.set('range', range);
+        h.set('accept-encoding', 'identity');
+        const fail = (e) => {
+            throw named(e, signal);
+        };
+        const res = await run(href, { headers: h, signal }).catch(fail);
+        const length = res.headers.get('content-length');
+        return {
+            status: res.status,
+            contentRange: res.headers.get('content-range'),
+            contentLength: length === null ? null : /^\s*\d+\s*$/.test(length) ? Number(length) : Number.NaN,
+            body: (expectedLength) => (res.body ? readCapped(res.body, expectedLength, signal).catch(fail) : Promise.resolve(new Uint8Array(0))),
+            discard: () => void res.body?.cancel().catch(noop),
+        };
+    };
+}
+export async function readCapped(body, expectedLength, signal = null) {
+    count(expectedLength, 'expectedLength');
+    const s = signalOf(signal, 'signal');
+    let next;
+    let stop;
+    const b = body;
+    if (typeof b?.getReader === 'function') {
+        const reader = body.getReader();
+        next = () => reader.read();
+        stop = () => void reader.cancel().catch(noop);
+    }
+    else if (typeof b?.[Symbol.asyncIterator] === 'function') {
+        const it = body[Symbol.asyncIterator]();
+        next = () => it.next();
+        stop = () => {
+            attempt(() => body.destroy?.()).catch(noop);
+            attempt(() => it.return?.()).catch(noop);
+        };
+    }
+    else {
+        throw new TypeError(`body must be a ReadableStream or an async iterable, got ${shown(body)}`);
+    }
+    const out = new Uint8Array(expectedLength);
+    let got = 0;
+    try {
+        for (;;) {
+            throwIfAborted(s);
+            const step = await untilAborted(attempt(next), s);
+            if (step.done)
+                break;
+            const chunk = step.value;
+            const view = ArrayBuffer.isView(chunk) ? new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength) : tag(chunk) === '[object ArrayBuffer]' ? new Uint8Array(chunk) : null;
+            if (!view)
+                throw new RangeSourceError('invalid-reply', `the body gave a ${chunk === null ? 'null' : typeof chunk} chunk, not bytes`);
+            if (got + view.byteLength > expectedLength)
+                throw new RangeSourceError('body-too-long', `the body passed the ${expectedLength} bytes requested`);
+            out.set(view, got);
+            got += view.byteLength;
+        }
+    }
+    catch (e) {
+        stop();
+        throw e;
+    }
+    if (got < expectedLength)
+        throw new RangeSourceError('body-too-short', `the body ended after ${got} of the ${expectedLength} bytes requested`);
+    return out;
+}

package/dist/worker/single.js

@@ -1,4 +1,5 @@
 import { analyzeWith } from "../core/dispatch.js";
+import { withErrorCode } from "../core/reader.js";
 const LABEL = { isobmff: 'ISO BMFF', matroska: 'Matroska' };
 export const wrongFamily = (served, found) => `the own ${LABEL[served]} worker does not read ${LABEL[found]}`;
 export function singleContainerEngine(kind, analyzer) {
@@ -6,7 +7,7 @@ export function singleContainerEngine(kind, analyzer) {
         containers: 'any',
         run: (blob, name, opts) => analyzeWith(blob, name, opts, (found) => {
             if (found !== kind)
-                throw new Error(wrongFamily(kind, found));
+                throw withErrorCode('unsupported-container', wrongFamily(kind, found));
             return analyzer;
         }),
     };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "video-fps-probe",
   "private": false,
-  "version": "0.3.0",
+  "version": "0.4.0-beta.2",
   "description": "Video frame rate, frame count and VFR detection from MP4/MOV/WebM/MKV container headers in a Web Worker. Matches ffprobe 8.1.1 on the test corpus (0 mismatches), no decoding.",
   "type": "module",
   "license": "MIT",
@@ -32,6 +32,7 @@
     "dist",
     "CHANGELOG.md"
   ],
+  "main": "./dist/cjs/index.cjs",
   "types": "./dist/index.d.ts",
   "module": "./dist/index.js",
   "typesVersions": {
@@ -51,6 +52,18 @@
       "check": [
         "dist/check/index.d.ts"
       ],
+      "header": [
+        "dist/header/index.d.ts"
+      ],
+      "url": [
+        "dist/url/index.d.ts"
+      ],
+      "color": [
+        "dist/color/index.d.ts"
+      ],
+      "aspect": [
+        "dist/aspect/index.d.ts"
+      ],
       "presets": [
         "dist/presets/index.d.ts"
       ],
@@ -79,6 +92,18 @@
   },
   "exports": {
     ".": {
+      "module-sync": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "module": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
+      },
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
@@ -99,10 +124,98 @@
       "default": "./dist/react/index.js"
     },
     "./check": {
+      "module-sync": {
+        "types": "./dist/check/index.d.ts",
+        "default": "./dist/check/index.js"
+      },
+      "module": {
+        "types": "./dist/check/index.d.ts",
+        "default": "./dist/check/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/check/index.d.cts",
+        "default": "./dist/cjs/check.cjs"
+      },
       "types": "./dist/check/index.d.ts",
       "default": "./dist/check/index.js"
     },
+    "./header": {
+      "module-sync": {
+        "types": "./dist/header/index.d.ts",
+        "default": "./dist/header/index.js"
+      },
+      "module": {
+        "types": "./dist/header/index.d.ts",
+        "default": "./dist/header/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/header/index.d.cts",
+        "default": "./dist/cjs/header.cjs"
+      },
+      "types": "./dist/header/index.d.ts",
+      "default": "./dist/header/index.js"
+    },
+    "./url": {
+      "module-sync": {
+        "types": "./dist/url/index.d.ts",
+        "default": "./dist/url/index.js"
+      },
+      "module": {
+        "types": "./dist/url/index.d.ts",
+        "default": "./dist/url/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/url/index.d.cts",
+        "default": "./dist/cjs/url.cjs"
+      },
+      "types": "./dist/url/index.d.ts",
+      "default": "./dist/url/index.js"
+    },
+    "./color": {
+      "module-sync": {
+        "types": "./dist/color/index.d.ts",
+        "default": "./dist/color/index.js"
+      },
+      "module": {
+        "types": "./dist/color/index.d.ts",
+        "default": "./dist/color/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/color/index.d.cts",
+        "default": "./dist/cjs/color.cjs"
+      },
+      "types": "./dist/color/index.d.ts",
+      "default": "./dist/color/index.js"
+    },
+    "./aspect": {
+      "module-sync": {
+        "types": "./dist/aspect/index.d.ts",
+        "default": "./dist/aspect/index.js"
+      },
+      "module": {
+        "types": "./dist/aspect/index.d.ts",
+        "default": "./dist/aspect/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/aspect/index.d.cts",
+        "default": "./dist/cjs/aspect.cjs"
+      },
+      "types": "./dist/aspect/index.d.ts",
+      "default": "./dist/aspect/index.js"
+    },
     "./presets": {
+      "module-sync": {
+        "types": "./dist/presets/index.d.ts",
+        "default": "./dist/presets/index.js"
+      },
+      "module": {
+        "types": "./dist/presets/index.d.ts",
+        "default": "./dist/presets/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/presets/index.d.cts",
+        "default": "./dist/cjs/presets.cjs"
+      },
       "types": "./dist/presets/index.d.ts",
       "default": "./dist/presets/index.js"
     },
@@ -166,7 +279,9 @@
     "build:demo": "tsc -b && vite build --config demo/vite.config.ts",
     "preview": "vite preview --config demo/vite.config.ts",
     "check:package": "publint --strict && node scripts/check-dist.mjs",
-    "check:types": "npx --yes @arethetypeswrong/cli@0.18.5 --pack . --ignore-rules cjs-resolves-to-esm --exclude-entrypoints ./standalone/own.worker.js ./standalone/own-isobmff.worker.js ./standalone/own-matroska.worker.js",
+    "check:types": "npm run check:types:server && npm run check:types:browser",
+    "check:types:server": "npx --yes @arethetypeswrong/cli@0.18.5 --pack . --entrypoints . ./header ./url ./color ./aspect ./check ./presets",
+    "check:types:browser": "npx --yes @arethetypeswrong/cli@0.18.5 --pack . --ignore-rules cjs-resolves-to-esm --exclude-entrypoints . ./header ./url ./color ./aspect ./check ./presets ./standalone/own.worker.js ./standalone/own-isobmff.worker.js ./standalone/own-matroska.worker.js",
     "prepack": "npm run build:lib && node scripts/check-dist.mjs",
     "check:aliases": "node scripts/src-aliases.mjs --check",
     "check:stable-chunks": "node scripts/check-stable-chunks.mjs",