@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/chunk-C5BO7PMT.js

@@ -0,0 +1,282 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  PROXY_VARIANT_CONFIG,
+  ProxyCapacityError,
+  ProxyTranscodeError,
+  decideMediaProxyEligibility,
+  getMimeType,
+  injectMediaCodecMapIntoHtml,
+  isProxyVariantRequest,
+  probeAssetCodec,
+  recordProxyRequest,
+  resolveProxy,
+  resolveProxyVariantRequest
+} from "./chunk-THJALHFJ.js";
+import {
+  findStageProxyBox
+} from "./chunk-LEKZNRKI.js";
+import {
+  resolveAutoProxy
+} from "./chunk-4BNN5FGX.js";
+import {
+  PREVIEW_PROXY_BOX_PARAM,
+  parsePreviewProxyBox
+} from "./chunk-DLA44CMS.js";
+import {
+  decodeWellFormedEscapes
+} from "./chunk-BSQ7XANM.js";
+
+// src/utils/staticProjectServer.ts
+import { createServer, request as httpRequest } from "http";
+import { Duplex } from "stream";
+import { createReadStream, existsSync, statSync } from "fs";
+import { isAbsolute, relative, resolve } from "path";
+var REFUSED_LISTEN = /* @__PURE__ */ new Set(["EPERM", "EACCES"]);
+function socketPair() {
+  const sides = [];
+  const side = (other) => new Duplex({
+    read() {
+    },
+    write(chunk, _encoding, done) {
+      other().push(chunk);
+      done();
+    },
+    final(done) {
+      other().push(null);
+      done();
+    }
+  });
+  sides.push(
+    side(() => sides[1]),
+    side(() => sides[0])
+  );
+  return [sides[0], sides[1]];
+}
+function answerInProcess(server, request) {
+  const [client, served] = socketPair();
+  server.emit("connection", served);
+  return new Promise((resolveAnswer, rejectAnswer) => {
+    const req = httpRequest(
+      {
+        method: request.method,
+        path: request.path,
+        headers: { ...request.headers, connection: "close" },
+        // No `agent`: Node uses createConnection only when no agent is given.
+        createConnection: () => client
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("error", rejectAnswer);
+        res.on("end", () => {
+          const headers = {};
+          for (const [name, value] of Object.entries(res.headers)) {
+            if (value !== void 0 && name !== "connection" && name !== "transfer-encoding")
+              headers[name] = Array.isArray(value) ? value.join(", ") : value;
+          }
+          resolveAnswer({ status: res.statusCode ?? 500, headers, body: Buffer.concat(chunks) });
+        });
+      }
+    );
+    req.on("error", rejectAnswer);
+    req.end();
+  });
+}
+var inProcessServers = 0;
+var inProcessAnswers = /* @__PURE__ */ new Map();
+function inProcessAnswer(url) {
+  return inProcessAnswers.get(new URL(url).origin);
+}
+function serveFileWithRange(filePath, rangeHeader, res, contentType = getMimeType(filePath)) {
+  const size = statSync(filePath).size;
+  const headers = {
+    "Content-Type": contentType,
+    "Accept-Ranges": "bytes"
+  };
+  const last = size - 1;
+  let start = 0;
+  let end = last;
+  let status = 200;
+  const match = rangeHeader ? /^bytes=(\d*)-(\d*)$/.exec(rangeHeader.trim()) : null;
+  if (match) {
+    const hasStart = match[1] !== "";
+    start = hasStart ? Number(match[1]) : Math.max(0, size - Number(match[2]));
+    end = !hasStart ? last : match[2] !== "" ? Math.min(Number(match[2]), last) : last;
+    if (start > end || start > last) {
+      res.writeHead(416, { ...headers, "Content-Range": `bytes */${size}` });
+      res.end();
+      return;
+    }
+    status = 206;
+    headers["Content-Range"] = `bytes ${start}-${end}/${size}`;
+  }
+  headers["Content-Length"] = String(end - start + 1);
+  if (size === 0) {
+    res.writeHead(status, headers);
+    res.end();
+    return;
+  }
+  const stream = createReadStream(filePath, { start, end });
+  res.once("close", () => stream.destroy());
+  stream.on("open", () => {
+    res.writeHead(status, headers);
+    stream.pipe(res);
+  });
+  stream.on("error", () => {
+    if (!res.headersSent) res.writeHead(500);
+    res.end();
+    stream.destroy();
+  });
+}
+function writeProxyError(err, res) {
+  if (err instanceof ProxyCapacityError) {
+    res.writeHead(503, { "Content-Type": "text/plain", "Retry-After": "1" });
+    res.end(`Proxy transcode deferred: ${err.message}`);
+    return;
+  }
+  if (err instanceof ProxyTranscodeError) {
+    res.writeHead(502, { "Content-Type": "text/plain" });
+    res.end(`Proxy transcode failed: ${err.message}`);
+    return;
+  }
+  res.writeHead(500);
+  res.end();
+}
+async function serveProxyRequest(projectDir, filePath, request, box, autoProxy, rangeHeader, res, signal) {
+  const contentType = getMimeType(filePath);
+  if (!autoProxy || !contentType.startsWith("video/")) {
+    res.writeHead(404);
+    res.end();
+    return;
+  }
+  try {
+    const facts = await probeAssetCodec(filePath);
+    const eligibility = decideMediaProxyEligibility(facts);
+    if (!eligibility.eligible) {
+      res.writeHead(422, { "Content-Type": "text/plain" });
+      res.end(`media proxy unavailable: ${eligibility.reason}`);
+      return;
+    }
+    if (!facts) {
+      res.writeHead(422, { "Content-Type": "text/plain" });
+      res.end("media proxy unavailable: unknown_codec");
+      return;
+    }
+    const variant = resolveProxyVariantRequest(request, facts);
+    if (!variant) {
+      res.writeHead(422, { "Content-Type": "text/plain" });
+      res.end("media proxy variant does not match asset");
+      return;
+    }
+    recordProxyRequest();
+    const proxyPath = await resolveProxy(projectDir, filePath, variant, box, { signal });
+    if (res.writableEnded || res.destroyed) return;
+    serveFileWithRange(proxyPath, rangeHeader, res, PROXY_VARIANT_CONFIG[variant].contentType);
+  } catch (err) {
+    writeProxyError(err, res);
+  }
+}
+async function serveStaticProjectHtml(projectDir, html, bindErrorMessage = "Failed to bind local HTTP server", assetRoots = [], autoProxyOverride) {
+  const roots = [projectDir, ...assetRoots];
+  const autoProxy = resolveAutoProxy(projectDir, autoProxyOverride);
+  const copies = new AbortController();
+  const servedHtml = autoProxy ? await injectMediaCodecMapIntoHtml(
+    html,
+    projectDir,
+    [{ html }],
+    void 0,
+    true,
+    copies.signal,
+    findStageProxyBox(html)
+  ) : html;
+  const server = createServer((req, res) => {
+    const url = req.url ?? "/";
+    if (url === "/" || url === "/index.html") {
+      res.writeHead(200, { "Content-Type": getMimeType("index.html") });
+      res.end(servedHtml);
+      return;
+    }
+    const queryIndex = url.indexOf("?");
+    const pathOnly = queryIndex === -1 ? url : url.slice(0, queryIndex);
+    const query = new URLSearchParams(queryIndex === -1 ? "" : url.slice(queryIndex + 1));
+    const proxyParam = query.get("hf-proxy");
+    const proxyRequest = proxyParam !== null && isProxyVariantRequest(proxyParam) ? proxyParam : null;
+    const boxParam = query.get(PREVIEW_PROXY_BOX_PARAM);
+    const proxyBox = boxParam === null ? void 0 : parsePreviewProxyBox(boxParam);
+    if (proxyBox === null || proxyBox && !proxyRequest) {
+      res.writeHead(404);
+      res.end();
+      return;
+    }
+    const requestPath = decodeWellFormedEscapes(pathOnly).replace(/^\//, "");
+    for (const root of roots) {
+      const filePath = resolve(root, requestPath);
+      const rel = relative(root, filePath);
+      if (rel.startsWith("..") || isAbsolute(rel)) continue;
+      if (existsSync(filePath)) {
+        if (proxyRequest) {
+          void serveProxyRequest(
+            projectDir,
+            filePath,
+            proxyRequest,
+            proxyBox,
+            autoProxy,
+            req.headers.range,
+            res,
+            copies.signal
+          );
+        } else {
+          serveFileWithRange(filePath, req.headers.range, res);
+        }
+        return;
+      }
+    }
+    res.writeHead(404);
+    res.end();
+  });
+  const port = await new Promise((resolvePort, rejectPort) => {
+    server.on("error", rejectPort);
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      const resolvedPort = typeof addr === "object" && addr ? addr.port : 0;
+      if (!resolvedPort) rejectPort(new Error(bindErrorMessage));
+      else resolvePort(resolvedPort);
+    });
+  }).catch((error) => {
+    if (REFUSED_LISTEN.has(error.code ?? "")) return 0;
+    throw error;
+  });
+  if (port === 0) {
+    server.removeAllListeners("error");
+    const url = `http://hyperframes-${++inProcessServers}.localhost/`;
+    const answer = (request) => answerInProcess(server, request);
+    inProcessAnswers.set(new URL(url).origin, answer);
+    return {
+      url,
+      port: 0,
+      close: async () => {
+        copies.abort();
+        inProcessAnswers.delete(new URL(url).origin);
+      },
+      answer
+    };
+  }
+  return {
+    url: `http://127.0.0.1:${port}/`,
+    port,
+    close: () => new Promise((resolveClose) => {
+      copies.abort();
+      server.close(() => resolveClose());
+    })
+  };
+}
+
+export {
+  inProcessAnswer,
+  serveStaticProjectHtml
+};

package/vendor/framey/dist/chunk-CFUCHO4T.js

@@ -0,0 +1,358 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  parseHTML
+} from "./chunk-SDYDNHEE.js";
+
+// src/whisper/normalize.ts
+import { readFileSync, readdirSync, writeFileSync } from "fs";
+import { extname, join } from "path";
+import { parseExpressionAt, tokenizer } from "acorn";
+function detectFormat(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  if (ext === ".srt") return "srt";
+  if (ext === ".vtt") return "vtt";
+  if (ext === ".json") return detectJsonFormat(JSON.parse(readFileSync(filePath, "utf-8")));
+  throw new Error(`Unsupported transcript file extension: ${ext}. Use .json, .srt, or .vtt`);
+}
+function detectJsonFormat(raw) {
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    const obj = raw;
+    if (obj.transcription && Array.isArray(obj.transcription)) return "whisper-cpp";
+    if (obj.words && Array.isArray(obj.words)) return "openai";
+  }
+  if (Array.isArray(raw) && raw.slice(0, 1).every((w) => w?.text !== void 0 && w?.start !== void 0)) {
+    return "words-json";
+  }
+  throw new Error(
+    "Unrecognized JSON transcript format. Expected whisper.cpp (transcription[].tokens), OpenAI API (words[]), or normalized ([{text, start, end}])."
+  );
+}
+function mergeFragments(words) {
+  for (let i = 0; i < words.length - 1; i++) {
+    const curr = words[i];
+    const next = words[i + 1];
+    if (!curr || !next) continue;
+    const isSingleLetterFragment = curr.text.length === 1 && /^[A-Z]$/.test(curr.text) && !/^[IAO]$/.test(curr.text) && /^[a-z]/.test(next.text);
+    const shouldMerge = isSingleLetterFragment || /[a-z]$/.test(curr.text) && /^in'$/i.test(next.text);
+    if (shouldMerge) {
+      curr.text += next.text;
+      curr.end = next.end;
+      words.splice(i + 1, 1);
+      i--;
+    }
+  }
+}
+function interpolateZeroDuration(words) {
+  for (let i = 0; i < words.length; i++) {
+    const wi = words[i];
+    if (!wi || wi.start < wi.end) continue;
+    let j = i;
+    while (j < words.length) {
+      const wj = words[j];
+      if (!wj || wj.start < wj.end) break;
+      j++;
+    }
+    const clusterLen = j - i;
+    const prev = i > 0 ? words[i - 1] : void 0;
+    const prevEnd = prev ? prev.end : wi.start;
+    const nextWord = j < words.length ? words[j] : void 0;
+    const nextStart = nextWord ? nextWord.start : prevEnd + clusterLen * 0.3;
+    const span = nextStart - prevEnd;
+    const perWord = span / clusterLen;
+    for (let k = i; k < j; k++) {
+      const wk = words[k];
+      if (!wk) continue;
+      wk.start = round3(prevEnd + (k - i) * perWord);
+      wk.end = round3(prevEnd + (k - i + 1) * perWord);
+    }
+    i = j - 1;
+  }
+}
+var TRAILING_PUNCTUATION = /^[.,!?;:'")\]}>…–—¡¿\-，。！？、；：」』）】》〉]+$/;
+function crossesCjkBoundary(left, right) {
+  return CJK_CHAR.test(left.at(-1) ?? "") || CJK_CHAR.test(right[0] ?? "");
+}
+function continuesWord(previous, rawText, text) {
+  return TRAILING_PUNCTUATION.test(text) || /^'(t|m|s|ve|re|ll|d)$/i.test(text) || !rawText.startsWith(" ") && !crossesCjkBoundary(previous, text);
+}
+function parseWhisperCpp(data) {
+  const words = [];
+  const transcription = data.transcription;
+  for (const seg of transcription ?? []) {
+    for (const token of seg.tokens ?? []) {
+      const rawText = token.text ?? "";
+      const text = rawText.trim();
+      if (!text || text.startsWith("[_") || text.startsWith("[BLANK")) continue;
+      const lastWord = words[words.length - 1];
+      if (lastWord && continuesWord(lastWord.text, rawText, text)) {
+        lastWord.text += text;
+        lastWord.end = round3((token.offsets?.to ?? 0) / 1e3);
+        continue;
+      }
+      words.push({
+        text,
+        start: round3((token.offsets?.from ?? 0) / 1e3),
+        end: round3((token.offsets?.to ?? 0) / 1e3)
+      });
+    }
+  }
+  mergeFragments(words);
+  interpolateZeroDuration(words);
+  return words;
+}
+function parseOpenAI(data) {
+  const words = data.words ?? [];
+  return words.map((w) => ({
+    text: (w.word ?? w.text ?? "").trim(),
+    start: round3(w.start ?? 0),
+    end: round3(w.end ?? 0)
+  })).filter((w) => w.text.length > 0);
+}
+function parseSrt(content) {
+  const blocks = content.replace(/\r\n?/g, "\n").trim().split(/\n\n+/);
+  const words = [];
+  for (const block of blocks) {
+    const lines = block.trim().split("\n");
+    const timeLine = lines.find((l) => l.includes("-->"));
+    if (!timeLine) continue;
+    const [startStr, endStr] = timeLine.split("-->").map((s) => s.trim());
+    if (!startStr || !endStr) continue;
+    const text = lines.slice(lines.indexOf(timeLine) + 1).join(" ").replace(/<[^>]+>/g, "").trim();
+    if (!text) continue;
+    words.push({
+      text,
+      start: parseSrtTimestamp(startStr),
+      end: parseSrtTimestamp(endStr)
+    });
+  }
+  return words;
+}
+function decodeVttText(text) {
+  if (!text.includes("&")) return text;
+  const { document } = parseHTML("<html><body></body></html>");
+  const element = document.createElement("span");
+  element.innerHTML = text.replace(/</g, "&lt;");
+  return element.textContent ?? "";
+}
+function parseVtt(content) {
+  const body = content.replace(/\r\n?/g, "\n").replace(/^WEBVTT[^\n]*\n/, "");
+  const blocks = body.trim().split(/\n\n+/);
+  const words = [];
+  for (const block of blocks) {
+    const lines = block.trim().split("\n");
+    const timeLine = lines.find((l) => l.includes("-->"));
+    if (!timeLine) continue;
+    const [startStr, endStr] = timeLine.split("-->").map((s) => s.trim());
+    if (!startStr || !endStr) continue;
+    const text = lines.slice(lines.indexOf(timeLine) + 1).join(" ").replace(/<[^>]+>/g, "").trim();
+    if (!text) continue;
+    words.push({
+      text: decodeVttText(text),
+      start: parseVttTimestamp(startStr),
+      end: parseVttTimestamp(endStr)
+    });
+  }
+  return words;
+}
+function parseSrtTimestamp(ts) {
+  const m = ts.match(/(\d+):(\d+):(\d+)[,.](\d+)/);
+  if (!m) return 0;
+  return parseInt(m[1], 10) * 3600 + parseInt(m[2], 10) * 60 + parseInt(m[3], 10) + parseInt(m[4].padEnd(3, "0"), 10) / 1e3;
+}
+function parseVttTimestamp(ts) {
+  const timestamp = ts.split(/[ \t]+/, 1)[0] ?? "";
+  const parts = timestamp.split(":");
+  if (parts.length === 3) return parseSrtTimestamp(timestamp);
+  if (parts.length === 2) {
+    const [min, secMs] = parts;
+    const [sec, ms] = (secMs ?? "0.0").split(".");
+    return parseInt(min, 10) * 60 + parseInt(sec, 10) + parseInt((ms ?? "0").padEnd(3, "0"), 10) / 1e3;
+  }
+  return 0;
+}
+function formatSrtTimestamp(seconds) {
+  const { hours, minutes, wholeSeconds, milliseconds } = timestampParts(seconds);
+  return `${pad2(hours)}:${pad2(minutes)}:${pad2(wholeSeconds)},${pad3(milliseconds)}`;
+}
+function formatVttTimestamp(seconds) {
+  const { hours, minutes, wholeSeconds, milliseconds } = timestampParts(seconds);
+  return `${pad2(hours)}:${pad2(minutes)}:${pad2(wholeSeconds)}.${pad3(milliseconds)}`;
+}
+function round3(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+function timestampParts(seconds) {
+  const safeSeconds = Number.isFinite(seconds) ? seconds : 0;
+  const totalMs = Math.max(0, Math.round(safeSeconds * 1e3));
+  const milliseconds = totalMs % 1e3;
+  const totalSeconds = (totalMs - milliseconds) / 1e3;
+  const wholeSeconds = totalSeconds % 60;
+  const totalMinutes = (totalSeconds - wholeSeconds) / 60;
+  const minutes = totalMinutes % 60;
+  const hours = (totalMinutes - minutes) / 60;
+  return { hours, minutes, wholeSeconds, milliseconds };
+}
+function pad2(n) {
+  return n.toString().padStart(2, "0");
+}
+function pad3(n) {
+  return n.toString().padStart(3, "0");
+}
+function endsSentence(text) {
+  return /[.!?。！？][)"'\]}」』）]*$/.test(text);
+}
+function pushCue(cues, cue) {
+  if (!cue) return;
+  const text = cue.text.trim();
+  if (!text) return;
+  cues.push({ text, start: round3(cue.start), end: round3(cue.end) });
+}
+function breaksCue(current, word, text, maxChars, maxGap) {
+  const nextLength = current.text.length + 1 + text.length;
+  const gap = word.start - current.end;
+  return nextLength > maxChars || gap > maxGap;
+}
+function entriesToCues(words) {
+  const cues = [];
+  for (const word of words) {
+    pushCue(cues, { text: word.text, start: word.start, end: word.end });
+  }
+  return cues;
+}
+var CJK_CHAR = /[　-〿぀-ヿ㐀-䶿一-鿿豈-﫿＀-￯]/;
+var SPACELESS_SCRIPT_CHAR = /[฀-๿຀-໿က-႟ក-៿　-〿぀-ヿ㐀-䶿一-鿿豈-﫿＀-￯]/;
+var SPACELESS_PHRASE_MIN_CHARS = 4;
+function median(values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  if (sorted.length === 0) return 0;
+  if (sorted.length % 2 === 1) return sorted[mid] ?? 0;
+  return ((sorted[mid - 1] ?? 0) + (sorted[mid] ?? 0)) / 2;
+}
+function inferPreGrouped(words) {
+  if (words.some((w) => /\s/.test(w.text.trim()))) return true;
+  const spaceless = words.filter((w) => SPACELESS_SCRIPT_CHAR.test(w.text));
+  if (spaceless.length === 0) return false;
+  return median(spaceless.map((w) => w.text.trim().length)) >= SPACELESS_PHRASE_MIN_CHARS;
+}
+function joinTokens(left, right) {
+  return `${left}${crossesCjkBoundary(left, right) ? "" : " "}${right}`;
+}
+function wordsToCues(words, opts = {}) {
+  const preGrouped = opts.preGrouped ?? inferPreGrouped(words);
+  if (preGrouped) return entriesToCues(words);
+  const maxChars = opts.maxChars ?? 42;
+  const maxGap = opts.maxGap ?? 0.8;
+  const cues = [];
+  let current;
+  const flush = () => {
+    pushCue(cues, current);
+    current = void 0;
+  };
+  for (const word of words) {
+    const text = word.text.trim();
+    if (!text) continue;
+    if (current && !breaksCue(current, word, text, maxChars, maxGap)) {
+      current.text = joinTokens(current.text, text);
+      current.end = word.end;
+    } else {
+      flush();
+      current = { text, start: word.start, end: word.end };
+    }
+    if (endsSentence(text)) flush();
+  }
+  flush();
+  return cues;
+}
+function formatSrt(words, opts) {
+  const cues = wordsToCues(words, opts);
+  if (cues.length === 0) return "";
+  return cues.map(
+    (cue, i) => `${i + 1}
+${formatSrtTimestamp(cue.start)} --> ${formatSrtTimestamp(cue.end)}
+${cue.text}`
+  ).join("\n\n") + "\n";
+}
+function formatVtt(words, opts) {
+  const cues = wordsToCues(words, opts);
+  if (cues.length === 0) return "WEBVTT\n\n";
+  return "WEBVTT\n\n" + cues.map(
+    (cue) => `${formatVttTimestamp(cue.start)} --> ${formatVttTimestamp(cue.end)}
+${cue.text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}`
+  ).join("\n\n") + "\n";
+}
+function loadTranscript(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  const content = readFileSync(filePath, "utf-8");
+  if (ext === ".srt") {
+    const words2 = parseSrt(content).map((w, i) => ({ ...w, id: w.id ?? `w${i}` }));
+    return { words: words2, format: "srt" };
+  }
+  if (ext === ".vtt") {
+    const words2 = parseVtt(content).map((w, i) => ({ ...w, id: w.id ?? `w${i}` }));
+    return { words: words2, format: "vtt" };
+  }
+  const parsed = JSON.parse(content);
+  const format = detectJsonFormat(parsed);
+  const words = (format === "whisper-cpp" ? parseWhisperCpp(parsed) : format === "openai" ? parseOpenAI(parsed) : parsed.map((w) => ({
+    id: w.id,
+    text: w.text.trim(),
+    start: round3(w.start),
+    end: round3(w.end)
+  }))).map((w, i) => ({ ...w, id: w.id || `w${i}` }));
+  return { words, format };
+}
+function findCaptionArray(source, name) {
+  const prefix = `const ${name} = `;
+  const start = source.indexOf(`${prefix}[`);
+  if (start < 0) return void 0;
+  try {
+    const array = parseExpressionAt(source, start + prefix.length, { ecmaVersion: "latest" });
+    if (array.type !== "ArrayExpression") return void 0;
+    const terminator = tokenizer(source.slice(array.end), { ecmaVersion: "latest" }).getToken();
+    if (terminator.type.label !== ";") return void 0;
+    return source.slice(start, array.end + terminator.end);
+  } catch {
+    return void 0;
+  }
+}
+function patchCaptionHtml(dir, words) {
+  if (words.length === 0) return;
+  const wordsJson = JSON.stringify(words, null, 2).replace(/</g, "\\u003c").replace(/\n/g, "\n          ");
+  let htmlFiles;
+  try {
+    htmlFiles = readdirSync(dir, { withFileTypes: true, recursive: true }).filter((e) => e.isFile() && e.name.endsWith(".html")).map((e) => join(e.parentPath, e.name));
+  } catch {
+    return;
+  }
+  for (const file of htmlFiles) {
+    let content = readFileSync(file, "utf-8");
+    const scriptBlocks = content.match(/<script>[\s\S]*?<\/script>/g) ?? [];
+    let scriptMatch;
+    let transcriptMatch;
+    for (const block of scriptBlocks) {
+      scriptMatch = scriptMatch ?? findCaptionArray(block, "script");
+      transcriptMatch = transcriptMatch ?? findCaptionArray(block, "TRANSCRIPT");
+    }
+    const match = scriptMatch ?? transcriptMatch;
+    if (match) {
+      const varName = scriptMatch ? "script" : "TRANSCRIPT";
+      content = content.replace(match, () => `const ${varName} = ${wordsJson};`);
+      writeFileSync(file, content, "utf-8");
+    }
+  }
+}
+
+export {
+  detectFormat,
+  wordsToCues,
+  formatSrt,
+  formatVtt,
+  loadTranscript,
+  patchCaptionHtml
+};

package/vendor/framey/dist/chunk-CZGHFATT.js

@@ -0,0 +1,31 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+
+// ../parsers/dist/compositionDuration.js
+var TIMING_TOLERANCE_SECONDS = 0.05;
+var isPositiveFinite = (value) => value !== null && Number.isFinite(value) && value > 0;
+function resolveCompositionDuration(input) {
+  const pendingClips = input.clipEndsSeconds.filter((end) => end === null).length;
+  if (isPositiveFinite(input.authoredDurationSeconds)) {
+    return { seconds: input.authoredDurationSeconds, source: "authored", pendingClips };
+  }
+  const known = input.clipEndsSeconds.filter(isPositiveFinite);
+  if (known.length > 0) {
+    return { seconds: Math.max(...known), source: "derived", pendingClips };
+  }
+  return {
+    seconds: null,
+    source: "unresolved",
+    pendingClips,
+    reason: pendingClips > 0 ? "every clip's length is still pending" : "no authored duration and no clip with a length"
+  };
+}
+
+export {
+  TIMING_TOLERANCE_SECONDS,
+  resolveCompositionDuration
+};