easycaptionkit 0.0.0-stage → 0.1.0

package/skills/easycaptionkit/scripts/lib/files.js

@@ -0,0 +1,249 @@
+"use strict";
+
+// Reading the files other tools wrote: never more than such a file can
+// hold, whatever the file is (a pipe or a device says it holds nothing and
+// can go on forever), in UTF-8 or UTF-16, and saying where a JSON file
+// stops being JSON.
+
+const fs = require("node:fs");
+
+// The order of the bytes of a text in UTF-16 with no byte order mark. UTF-8
+// text has no NUL, and in UTF-16 each digit, space and Latin letter (an
+// SRT's times, a JSON's keys) has one in its high byte, so NULs on one
+// side of the pairs of bytes and next to none on the other tell UTF-16.
+// "le", "be", or "" for any other text.
+function utf16Order(buf) {
+  const n = Math.min(buf.length, 512) & ~1;
+  if (n < 4) return "";
+  let even = 0;
+  let odd = 0;
+  for (let i = 0; i < n; i += 2) {
+    if (buf[i] === 0) even++;
+    if (buf[i + 1] === 0) odd++;
+  }
+  const many = (n / 2) * 0.3;
+  if (odd >= many && even <= odd / 8) return "le";
+  if (even >= many && odd <= even / 8) return "be";
+  return "";
+}
+
+// A file's bytes as text: UTF-16 when it starts with UTF-16's byte order
+// mark, as Notepad's Unicode and some Windows subtitle tools save it, or
+// reads as UTF-16 without one; else UTF-8. The mark is kept, as UTF-8's
+// is, for the reader to take off.
+function decodeText(buf) {
+  const swapped = () => Buffer.from(buf.subarray(0, buf.length - (buf.length % 2))).swap16();
+  if (buf[0] === 0xff && buf[1] === 0xfe) return buf.toString("utf16le");
+  if (buf[0] === 0xfe && buf[1] === 0xff) return swapped().toString("utf16le");
+  const order = utf16Order(buf);
+  if (order === "le") return buf.toString("utf16le");
+  if (order === "be") return swapped().toString("utf16le");
+  return buf.toString("utf8");
+}
+
+// The file as text, or an error with code EFBIG and the size, when known,
+// once it holds more than `most` bytes.
+function readAtMost(file, most) {
+  const fd = fs.openSync(file, "r");
+  try {
+    const stat = fs.fstatSync(fd);
+    if (stat.isDirectory()) throw Object.assign(new Error(`${file} is a folder`), { code: "EISDIR" });
+    const big = (size) => Object.assign(new Error(`${file} holds more than ${most} bytes`), { code: "EFBIG", size });
+    if (stat.isFile() && stat.size > most) throw big(stat.size);
+    const chunks = [];
+    const chunk = Buffer.allocUnsafe(1 << 16);
+    let total = 0;
+    for (;;) {
+      const n = fs.readSync(fd, chunk, 0, chunk.length, null);
+      if (n === 0) break;
+      total += n;
+      if (total > most) throw big(stat.isFile() ? stat.size : null);
+      chunks.push(Buffer.from(chunk.subarray(0, n)));
+    }
+    return decodeText(Buffer.concat(chunks));
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+// The same, read without holding up the process, for a pipe or a device:
+// one that nothing writes to yet waits in the background, so a signal
+// still stops the run while it waits.
+async function readAtMostLater(file, most) {
+  const handle = await fs.promises.open(file, "r");
+  try {
+    const stat = await handle.stat();
+    if (stat.isDirectory()) throw Object.assign(new Error(`${file} is a folder`), { code: "EISDIR" });
+    const big = (size) => Object.assign(new Error(`${file} holds more than ${most} bytes`), { code: "EFBIG", size });
+    if (stat.isFile() && stat.size > most) throw big(stat.size);
+    const chunks = [];
+    let total = 0;
+    for (;;) {
+      const chunk = Buffer.allocUnsafe(1 << 16);
+      const { bytesRead } = await handle.read(chunk, 0, chunk.length, null);
+      if (bytesRead === 0) break;
+      total += bytesRead;
+      if (total > most) throw big(stat.isFile() ? stat.size : null);
+      chunks.push(chunk.subarray(0, bytesRead));
+    }
+    return decodeText(Buffer.concat(chunks));
+  } finally {
+    await handle.close();
+  }
+}
+
+// How many lists and objects a JSON text opens, and how deep they nest,
+// found in one pass that steps over its strings and makes nothing of it,
+// so that a text of millions of them, or of thousands opened one inside
+// another, is told before JSON.parse makes them all, or badAt keeps a
+// stack of them: 64 MB of either took gigabytes and half a minute. The
+// pass stops once either passes `most` or `deepest`. { opened, deepest,
+// over }.
+function jsonShape(text, { most = Infinity, deepest = Infinity } = {}) {
+  let opened = 0;
+  let depth = 0;
+  let deep = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c === 0x22) {
+      // To the quote that ends the string, one no backslash escapes.
+      for (i++; i < text.length; i++) {
+        const d = text.charCodeAt(i);
+        if (d === 0x5c) i++;
+        else if (d === 0x22) break;
+      }
+    } else if (c === 0x7b || c === 0x5b) {
+      opened++;
+      if (++depth > deep) deep = depth;
+      if (opened > most || deep > deepest) return { opened, deepest: deep, over: true };
+    } else if ((c === 0x7d || c === 0x5d) && depth > 0) depth--;
+  }
+  return { opened, deepest: deep, over: false };
+}
+
+// Where JSON text stops being JSON: the position of the first character
+// a JSON reader cannot take there, or the end of the text when it stops
+// short. -1 when it is all JSON. Walked with a stack rather than by
+// recursion, so a deep nesting cannot overflow.
+function badAt(text) {
+  let i = 0;
+  const n = text.length;
+  const skip = () => {
+    while (i < n && (text[i] === " " || text[i] === "\t" || text[i] === "\n" || text[i] === "\r")) i++;
+  };
+  // A string from its opening quote; false at the character that breaks it.
+  const string = () => {
+    i++;
+    while (i < n) {
+      const c = text.charCodeAt(i);
+      if (c === 0x22) {
+        i++;
+        return true;
+      }
+      if (c < 0x20) return false;
+      if (c === 0x5c) {
+        const e = text[i + 1];
+        if (e === "u") {
+          if (!/^[0-9a-fA-F]{4}$/.test(text.slice(i + 2, i + 6))) {
+            i += 2;
+            while (i < n && /[0-9a-fA-F]/.test(text[i])) i++;
+            return false;
+          }
+          i += 6;
+        } else if (e !== undefined && '"\\/bfnrt'.includes(e)) i += 2;
+        else {
+          i++;
+          return false;
+        }
+      } else i++;
+    }
+    return false;
+  };
+  const value = () => {
+    const c = text[i];
+    if (c === '"') return string();
+    for (const word of ["true", "false", "null"]) {
+      if (c !== word[0]) continue;
+      for (const letter of word) {
+        if (text[i] !== letter) return false;
+        i++;
+      }
+      return true;
+    }
+    const m = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/.exec(text.slice(i, i + 400));
+    if (!m) return false;
+    // A number cut short, like 1. or -, breaks where it stops.
+    i += m[0].length;
+    return !/^[.eE\d]/.test(text[i] || "");
+  };
+  const stack = [];
+  for (;;) {
+    skip();
+    if (i >= n) return n;
+    if (text[i] === "{" || text[i] === "[") {
+      stack.push(text[i]);
+      i++;
+      skip();
+      if (text[i] === (stack[stack.length - 1] === "{" ? "}" : "]")) {
+        stack.pop();
+        i++;
+      } else {
+        if (stack[stack.length - 1] === "{") {
+          if (text[i] !== '"') return i < n ? i : n;
+          if (!string()) return Math.min(i, n);
+          skip();
+          if (text[i] !== ":") return i < n ? i : n;
+          i++;
+        }
+        continue;
+      }
+    } else if (!value()) return Math.min(i, n);
+    // After a value: a comma and the next one, the end of what holds it, or
+    // the end of the text.
+    for (;;) {
+      skip();
+      if (!stack.length) return i < n ? i : -1;
+      const open = stack[stack.length - 1];
+      if (text[i] === ",") {
+        i++;
+        if (open === "{") {
+          skip();
+          if (text[i] !== '"') return i < n ? i : n;
+          if (!string()) return Math.min(i, n);
+          skip();
+          if (text[i] !== ":") return i < n ? i : n;
+          i++;
+        }
+        break;
+      }
+      if (text[i] === (open === "{" ? "}" : "]")) {
+        stack.pop();
+        i++;
+        continue;
+      }
+      return i < n ? i : n;
+    }
+  }
+}
+
+// "at line 7, column 17: Expected ',' or '}' after property value", from
+// JSON.parse's error and the text it read. Where the error gives no
+// position, as for a word typed without quotes, it is found in the text.
+// What the error quotes of the text is left out: it can hold a line break
+// or any other character the file has.
+function jsonProblem(err, text) {
+  const message = String((err && err.message) || err);
+  const m = /^(.*?(?: after JSON)?)(?: in JSON)? at position (\d+)/.exec(message);
+  const at = m ? Number(m[2]) : badAt(text);
+  const why = (m ? m[1] : message.replace(/, (?:\.\.\.)?".*$/s, "").replace(/^(Unexpected end of JSON input).*$/s, "$1")).replace(/[\u0000-\u001f\u007f]+/g, " ");
+  if (at < 0) return `: ${why}`;
+  const before = text.slice(0, at);
+  const line = before.split("\n").length;
+  const column = Array.from(before.slice(before.lastIndexOf("\n") + 1)).length + 1;
+  return ` at line ${line}, column ${column}: ${why}`;
+}
+
+// The size of a file in words: "65 MB", or "more than 64 MB" for a pipe.
+const sizeText = (err, most) => (err.size ? `${Math.round(err.size / 1048576)} MB` : `more than ${Math.round(most / 1048576)} MB`);
+
+module.exports = { readAtMost, readAtMostLater, decodeText, jsonShape, jsonProblem, badAt, sizeText };

package/skills/easycaptionkit/scripts/lib/fontfile.js

@@ -0,0 +1,355 @@
+"use strict";
+
+// The few things of a font file captions.ass needs: the name libass finds
+// it by, how tall libass makes the font for a size, and how wide each
+// letter is. Read from TrueType and
+// OpenType files, collections of them, and WOFF and WOFF2, the files
+// easyfontkit saves. A file that is not one of them, or is cut short, gives
+// null: the caller then takes Arial's numbers.
+
+const fs = require("node:fs");
+const zlib = require("node:zlib");
+
+// No font file the captions use is this big, nor do its tables unpack to
+// more; a file made to unpack to gigabytes is not unpacked.
+const MOST = 64 * 1024 * 1024;
+
+// What a file's tables would unpack to is more than the room left for it.
+const TOO_BIG = "too big";
+
+// WOFF2 names its tables by a number into this list.
+const KNOWN = "cmap head hhea hmtx maxp name OS/2 post cvt  fpgm glyf loca prep CFF  VORG EBDT EBLC gasp hdmx kern LTSH PCLT VDMX vhea vmtx BASE GDEF GPOS GSUB EBSC JSTF MATH CBDT CBLC COLR CPAL SVG  sbix acnt avar bdat bloc bsln cvar fdsc feat fmtx fvar gvar hsty just lcar mort morx opbd prop trak Zapf Silf Glat Gloc Feat Sill"
+  .match(/.{4}\s?/g)
+  .map((t) => t.slice(0, 4));
+
+const tag = (buf, at) => buf.toString("latin1", at, at + 4);
+
+// The tables of a font, { tag: Buffer }, for the ones asked for.
+function sfntTables(buf, at, wanted) {
+  const count = buf.readUInt16BE(at + 4);
+  const tables = {};
+  for (let i = 0; i < count; i++) {
+    const rec = at + 12 + i * 16;
+    const name = tag(buf, rec);
+    if (!wanted.includes(name)) continue;
+    const offset = buf.readUInt32BE(rec + 8);
+    const length = buf.readUInt32BE(rec + 12);
+    if (offset + length > buf.length) throw new Error("cut short");
+    tables[name] = buf.subarray(offset, offset + length);
+  }
+  return tables;
+}
+
+// The tables of a WOFF, each packed on its own. What the tables asked for
+// unpack to, as the table directory gives it, is checked against `room`
+// and passed to `charge` before any of them is unpacked, and none unpacks
+// past its own length.
+function woffTables(buf, wanted, room, charge) {
+  const count = buf.readUInt16BE(12);
+  const records = [];
+  for (let i = 0; i < count; i++) {
+    const rec = 44 + i * 20;
+    const name = tag(buf, rec);
+    if (!wanted.includes(name)) continue;
+    const offset = buf.readUInt32BE(rec + 4);
+    const compressed = buf.readUInt32BE(rec + 8);
+    const length = buf.readUInt32BE(rec + 12);
+    if (offset + compressed > buf.length) throw new Error("cut short");
+    records.push({ name, data: buf.subarray(offset, offset + compressed), length, packed: compressed < length });
+  }
+  const unpacked = records.filter((r) => r.packed).reduce((sum, r) => sum + r.length, 0);
+  if (unpacked > room) throw new Error(TOO_BIG);
+  charge(unpacked);
+  const tables = {};
+  for (const r of records) tables[r.name] = r.packed ? zlib.inflateSync(r.data, { maxOutputLength: Math.max(1, r.length) }) : r.data;
+  return tables;
+}
+
+// A number of WOFF2's table directory: seven bits a byte, at most five.
+function base128(buf, state) {
+  let value = 0;
+  for (let i = 0; i < 5; i++) {
+    const byte = buf[state.at++];
+    if (byte === undefined || (i === 0 && byte === 0x80)) throw new Error("bad number");
+    value = value * 128 + (byte & 0x7f);
+    if (!(byte & 0x80)) return value;
+  }
+  throw new Error("bad number");
+}
+
+// The tables of a WOFF2, all packed in one stream. The stream's length, the
+// sum of its tables' as the table directory gives them, is checked against
+// `room` and passed to `charge` before the stream is unpacked, and the
+// stream does not unpack past it.
+function woff2Tables(buf, wanted, room, charge) {
+  if (tag(buf, 4) === "ttcf") return null;
+  const count = buf.readUInt16BE(12);
+  const compressed = buf.readUInt32BE(20);
+  const state = { at: 48 };
+  const entries = [];
+  for (let i = 0; i < count; i++) {
+    const flags = buf[state.at++];
+    let name = KNOWN[flags & 0x3f];
+    if ((flags & 0x3f) === 63) {
+      name = tag(buf, state.at);
+      state.at += 4;
+    }
+    const version = flags >> 6;
+    const length = base128(buf, state);
+    // glyf and loca are transformed unless the version is 3, the others
+    // only when it is not 0.
+    const transformed = name === "glyf" || name === "loca" ? version !== 3 : version !== 0;
+    entries.push({ name, length: transformed ? base128(buf, state) : length, transformed });
+  }
+  if (state.at + compressed > buf.length) throw new Error("cut short");
+  const unpacked = entries.reduce((sum, e) => sum + e.length, 0);
+  if (unpacked > room) throw new Error(TOO_BIG);
+  charge(unpacked);
+  const data = zlib.brotliDecompressSync(buf.subarray(state.at, state.at + compressed), { maxOutputLength: Math.max(1, unpacked) });
+  const tables = {};
+  let at = 0;
+  for (const e of entries) {
+    if (wanted.includes(e.name)) {
+      if (at + e.length > data.length) throw new Error("cut short");
+      tables[e.name] = Object.assign(data.subarray(at, at + e.length), { transformed: e.transformed });
+    }
+    at += e.length;
+  }
+  return tables;
+}
+
+// The glyph of each character a cmap maps, in its format 4 or 12 table.
+// A table that says it holds more than it does is cut short: it is
+// checked here, while the file is read, so that no lookup later reads
+// past its end.
+function cmapOf(table) {
+  const short = (end) => {
+    if (end > table.length) throw new Error("cut short");
+  };
+  short(4);
+  const count = table.readUInt16BE(2);
+  short(4 + count * 8);
+  let best = null;
+  for (let i = 0; i < count; i++) {
+    const platform = table.readUInt16BE(4 + i * 8);
+    const encoding = table.readUInt16BE(6 + i * 8);
+    const offset = table.readUInt32BE(8 + i * 8);
+    short(offset + 2);
+    const format = table.readUInt16BE(offset);
+    const rank = format === 12 && (platform === 3 || platform === 0) ? 2 : format === 4 && ((platform === 3 && encoding === 1) || platform === 0) ? 1 : 0;
+    if (rank && (!best || rank > best.rank)) best = { rank, offset, format };
+  }
+  if (!best) return null;
+  const at = best.offset;
+  // The first of `n` entries whose end is at or past code, found by halves
+  // where the ends come in order, as the format asks, else by going
+  // through them: a CJK font has thousands, and every letter of every
+  // caption is looked up. `ordered` says which.
+  const firstEnding = (n, endOf) => {
+    let ordered = true;
+    for (let i = 1; i < n && ordered; i++) ordered = endOf(i) >= endOf(i - 1);
+    const find = (code) => {
+      if (!ordered) {
+        for (let i = 0; i < n; i++) if (code <= endOf(i)) return i;
+        return n;
+      }
+      let lo = 0;
+      let hi = n;
+      while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (endOf(mid) >= code) hi = mid;
+        else lo = mid + 1;
+      }
+      return lo;
+    };
+    return Object.assign(find, { ordered });
+  };
+  if (best.format === 12) {
+    short(at + 16);
+    const groups = table.readUInt32BE(at + 12);
+    short(at + 16 + groups * 12);
+    const list = [];
+    for (let g = 0; g < groups; g++) list.push([table.readUInt32BE(at + 16 + g * 12), table.readUInt32BE(at + 20 + g * 12), table.readUInt32BE(at + 24 + g * 12)]);
+    const find = firstEnding(list.length, (i) => list[i][1]);
+    // Groups in order, each after the one before: the group a code is in
+    // is the first that ends at or past it.
+    const apart = find.ordered && list.every((g, i) => i === 0 || g[0] > list[i - 1][1]);
+    return (code) => {
+      if (apart) {
+        const group = list[find(code)];
+        return group && code >= group[0] ? group[2] + code - group[0] : 0;
+      }
+      for (const [from, to, glyph] of list) if (code >= from && code <= to) return glyph + code - from;
+      return 0;
+    };
+  }
+  short(at + 14);
+  const segments = Math.floor(table.readUInt16BE(at + 6) / 2);
+  const ends = at + 14;
+  const starts = ends + segments * 2 + 2;
+  const deltas = starts + segments * 2;
+  const ranges = deltas + segments * 2;
+  short(ranges + segments * 2);
+  const find = firstEnding(segments, (s) => table.readUInt16BE(ends + s * 2));
+  return (code) => {
+    if (code > 0xffff) return 0;
+    for (let s = find(code); s < segments; s++) {
+      if (code > table.readUInt16BE(ends + s * 2)) continue;
+      const start = table.readUInt16BE(starts + s * 2);
+      if (code < start) return 0;
+      const delta = table.readInt16BE(deltas + s * 2);
+      const range = table.readUInt16BE(ranges + s * 2);
+      if (!range) return (code + delta) & 0xffff;
+      // A glyph looked up past the end of the table is none.
+      const where = ranges + s * 2 + range + (code - start) * 2;
+      if (where + 2 > table.length) return 0;
+      const glyph = table.readUInt16BE(where);
+      return glyph ? (glyph + delta) & 0xffff : 0;
+    }
+    return 0;
+  };
+}
+
+// UTF-16 as the name table keeps it, high byte first.
+function utf16be(bytes) {
+  let text = "";
+  for (let i = 0; i + 1 < bytes.length; i += 2) text += String.fromCharCode(bytes.readUInt16BE(i));
+  return text;
+}
+
+// The family name a font file gives itself, the one libass finds a file of
+// its fonts folder by (and Windows a font by): name 1 of its Windows
+// names, in English where it has one. A file with no Windows names gives
+// its Unicode or its Mac one. libass does not look at the typographic
+// family (name 16), so neither does this. Empty when there is none.
+function familyOf(name) {
+  if (!name || name.length < 6) return "";
+  const count = name.readUInt16BE(2);
+  const strings = name.readUInt16BE(4);
+  const found = [];
+  for (let i = 0; i < count && 6 + i * 12 + 12 <= name.length; i++) {
+    const rec = 6 + i * 12;
+    const [platform, encoding, language, id, length, offset] = [0, 2, 4, 6, 8, 10].map((k) => name.readUInt16BE(rec + k));
+    const at = strings + offset;
+    if (id !== 1 || at + length > name.length || (platform === 1 && encoding !== 0) || ![0, 1, 3].includes(platform)) continue;
+    const bytes = name.subarray(at, at + length);
+    const text = (platform === 1 ? bytes.toString("latin1") : utf16be(bytes)).replace(/\u0000/g, "").trim();
+    if (text) found.push({ platform, language, text });
+  }
+  const pick = found.find((n) => n.platform === 3 && n.language === 0x409) || found.find((n) => n.platform === 3) || found.find((n) => n.platform === 0) || found[0];
+  return pick ? pick.text : "";
+}
+
+// The advance of each glyph, from hmtx as it is or as WOFF2 keeps it,
+// with its side bearings left out.
+function advancesOf(hmtx, count) {
+  const at = hmtx.transformed ? 1 : 0;
+  const step = hmtx.transformed ? 2 : 4;
+  if (at + count * step > hmtx.length) throw new Error("cut short");
+  const widths = new Uint16Array(count);
+  for (let i = 0; i < count; i++) widths[i] = hmtx.readUInt16BE(at + i * step);
+  return widths;
+}
+
+// { family, unitsPerEm, winAscent, winDescent, ascender, descender,
+// advance }: family is the name libass finds the file by (empty when it
+// gives none), advance(character) a letter's width in ems, or NaN when the
+// font has no glyph for it. `index` picks a font of a collection.
+const readFont = (file, index = 0) => loadFont(file, index).font;
+
+// { font, size }: the font as readFont gives it, or null, and the bytes
+// reading it took: the file's, and what its tables unpacked to. A file
+// that would take more than `budget` is not unpacked, and its font is
+// null. The font keeps a copy of the cmap and the widths it reads, and
+// nothing else of the file, so a font kept for a whole run takes little
+// memory however much its file unpacked to.
+function loadFont(file, index = 0, budget = Infinity) {
+  let size = 0;
+  try {
+    const stat = fs.statSync(file);
+    if (!stat.isFile() || stat.size > MOST || stat.size > budget) return { font: null, size: 0 };
+    const buf = fs.readFileSync(file);
+    size = buf.length;
+    const room = Math.min(MOST, budget - size);
+    const wanted = ["head", "hhea", "OS/2", "cmap", "hmtx", "name"];
+    const kind = tag(buf, 0);
+    let tables;
+    const charge = (n) => (size += n);
+    if (kind === "wOF2") tables = woff2Tables(buf, wanted, room, charge);
+    else if (kind === "wOFF") tables = woffTables(buf, wanted, room, charge);
+    else if (kind === "ttcf") {
+      const fonts = buf.readUInt32BE(8);
+      if (index >= fonts) return { font: null, size };
+      tables = sfntTables(buf, buf.readUInt32BE(12 + index * 4), wanted);
+    } else if (kind === "\u0000\u0001\u0000\u0000" || kind === "OTTO" || kind === "true") tables = sfntTables(buf, 0, wanted);
+    if (!tables || !tables.head || !tables.hhea || tables.head.readUInt32BE(12) !== 0x5f0f3cf5) return { font: null, size };
+    const unitsPerEm = tables.head.readUInt16BE(18);
+    if (!(unitsPerEm >= 16 && unitsPerEm <= 16384)) return { font: null, size };
+    const os2 = tables["OS/2"] && tables["OS/2"].length >= 78 ? tables["OS/2"] : null;
+    let family = "";
+    try {
+      family = familyOf(tables.name);
+    } catch {
+      // A name table cut short names nothing.
+    }
+    const font = {
+      family,
+      unitsPerEm,
+      ascender: tables.hhea.readInt16BE(4),
+      descender: tables.hhea.readInt16BE(6),
+      winAscent: os2 ? os2.readUInt16BE(74) : 0,
+      winDescent: os2 ? os2.readUInt16BE(76) : 0,
+      advance: () => NaN,
+    };
+    if (tables.cmap && tables.hmtx) {
+      // A copy: the lookup keeps the cmap, and a view would keep the whole
+      // file, or all it unpacked to, with it.
+      const glyphOf = cmapOf(Buffer.from(tables.cmap));
+      const widths = advancesOf(tables.hmtx, tables.hhea.readUInt16BE(34));
+      if (glyphOf && widths.length) {
+        font.advance = (c) => {
+          const glyph = glyphOf(c.codePointAt(0));
+          return glyph ? widths[Math.min(glyph, widths.length - 1)] / unitsPerEm : NaN;
+        };
+      }
+    }
+    return { font, size };
+  } catch {
+    return { font: null, size };
+  }
+}
+
+// What a font file loadFont reads starts with: WOFF2, WOFF, a collection,
+// TrueType or OpenType.
+const KINDS = new Set(["wOF2", "wOFF", "ttcf", "\u0000\u0001\u0000\u0000", "OTTO", "true"]);
+
+// Whether a file is one loadFont would read: a file of no more than MOST
+// bytes that starts as a font file does. Only its first four bytes are
+// read, so a video named as a font is not.
+function fontLike(file) {
+  let fd;
+  try {
+    const stat = fs.statSync(file);
+    if (!stat.isFile() || stat.size > MOST) return false;
+    fd = fs.openSync(file, "r");
+    const head = Buffer.alloc(4);
+    return fs.readSync(fd, head, 0, 4, 0) === 4 && KINDS.has(tag(head, 0));
+  } catch {
+    return false;
+  } finally {
+    if (fd !== undefined) fs.closeSync(fd);
+  }
+}
+
+// The ASS font size for a font whose em is one pixel. libass, as VSFilter
+// does, makes the font as tall as its OS/2 winAscent and winDescent: an
+// em is the size times unitsPerEm over their sum, where the font has
+// both those and its hhea ascender and descender.
+function assScale(font) {
+  const win = font.winAscent + font.winDescent;
+  const hhea = font.ascender - font.descender;
+  const height = win > 0 && hhea > 0 ? win : hhea > 0 ? hhea : win;
+  return height > 0 ? height / font.unitsPerEm : 0;
+}
+
+module.exports = { readFont, loadFont, assScale, fontLike };