@bendyline/squisq 2.11.16 → 2.11.17

package/dist/{chunk-ANH2OZ2M.js → chunk-LJZHC6GN.js}

@@ -2,14 +2,14 @@ import {
   assertMarkdownDocumentWithinLimits,
   parseMarkdown,
   toMdast
-} from "./chunk-GDHXT5Q7.js";
+} from "./chunk-PGWYC3S2.js";
 import {
   formatFrontmatterYaml,
   getChildren,
   splitFrontmatterBlock,
   stringifyHtmlNodes,
   walkMarkdownTree
-} from "./chunk-X7BNDUNI.js";
+} from "./chunk-Q6ELOAOQ.js";
 
 // src/markdown/stringify.ts
 import { unified } from "unified";
@@ -21,17 +21,41 @@ var defaultProcessor;
 var DQ_RUN = `"(?:[^"\\\\]|\\\\.)*"`;
 var SQ_RUN = `'(?:[^'\\\\]|\\\\.)*'`;
 var ESCAPED_TEMPLATE_SPAN_RE = new RegExp(
-  `\\{\\\\\\[((?:${DQ_RUN}|${SQ_RUN}|\\\\.|[^\\]\\\\])*)\\]\\}`,
+  `\\{\\\\\\[((?:${DQ_RUN}|${SQ_RUN}|\\\\.|[^\\]\\\\"'])*)\\]\\}`,
   "g"
 );
 var HEADING_LINE_RE = /^#{1,6} .*$/gm;
 var TRAILING_ESCAPED_PANDOC_SPAN_RE = new RegExp(
-  `\\{(?!\\\\?\\[)((?:${DQ_RUN}|${SQ_RUN}|\\\\.|[^}\\\\])*)\\}(?=\\s*(?:\\{\\[.*)?$)`
+  `\\{(?!\\\\?\\[)((?:${DQ_RUN}|${SQ_RUN}|\\\\.|[^}\\\\"'])*)\\}(?=\\s*(?:\\{\\[.*)?$)`
 );
 var UNESCAPE_PUNCT_RE = /\\([\\[\]:#.,+=/?;@%$(){}'"-])/g;
 function unescapeMarkdownPunct(text) {
   return text.replace(UNESCAPE_PUNCT_RE, "$1");
 }
+function literalTextUnsafe(options) {
+  return [
+    // GFM's writer only guards lowercase protocol endings, while its parser
+    // recognizes uppercase ones. Escape the colon before the domain dot can
+    // become a literal backslash inside an automatically recognized URL.
+    ...options?.gfm === false ? [] : [
+      {
+        character: ":",
+        before: "[PS]",
+        after: "\\/",
+        inConstruct: "phrasing",
+        notInConstruct: [
+          "autolink",
+          "link",
+          "image",
+          "label"
+        ]
+      }
+    ],
+    { character: "\\", after: "[ 	]", inConstruct: "phrasing" },
+    ...options?.math === false ? [] : [{ character: "$", inConstruct: "phrasing" }],
+    ...options?.directive === false ? [] : [{ character: ":", after: "[A-Za-z]", inConstruct: "phrasing" }]
+  ];
+}
 var PREFERRED_MASK_SENTINEL = "\0";
 function pickMaskSentinel(text) {
   const present = new Set(text);
@@ -154,7 +178,8 @@ function stringifyMarkdown(doc, options) {
         strong: "*",
         rule: "-",
         fence: "`",
-        setext: false
+        setext: false,
+        unsafe: literalTextUnsafe()
       });
     }
     processor = defaultProcessor;
@@ -176,7 +201,8 @@ function stringifyMarkdown(doc, options) {
       strong: options?.strong ?? "*",
       rule: options?.rule ?? "-",
       fence: options?.fence ?? "`",
-      setext: options?.setext ?? false
+      setext: options?.setext ?? false,
+      unsafe: literalTextUnsafe(options)
     });
   }
   const result = processor.stringify(mdastTree);
@@ -1204,11 +1230,22 @@ function rewriteMarkdownReferences(source, options = {}) {
 
 // src/markdown/docfxMarkdown.ts
 function normalizeDocfxMarkdown(source, options = {}) {
-  const { frontmatter, body } = splitFrontmatterBlock(source);
+  let output = normalizeDocfxMarkdownPass(source, options);
+  if (options.unknownDirectives === "preserve") {
+    for (let pass = 0; pass < 2 && output !== source && /:::/u.test(output); pass++) {
+      source = output;
+      output = normalizeDocfxMarkdownPass(source, options);
+    }
+  }
+  return output;
+}
+function normalizeDocfxMarkdownPass(source, options = {}) {
+  const { frontmatter, body: originalBody } = splitFrontmatterBlock(source);
+  const body = flattenDocfxLayout(originalBody);
   const protectedSpans = [];
-  for (const comment of body.matchAll(/<!--[\s\S]*?-->/g))
+  for (const comment of body.matchAll(/<!--[\s\S]*?(?:-->|$)/g))
     protectedSpans.push([comment.index, comment.index + comment[0].length]);
-  walkMarkdownTree(parseMarkdown(body, { frontmatter: false }), (node) => {
+  walkMarkdownTree(parseMarkdown(body, { frontmatter: false, directive: false }), (node) => {
     if ((node.type === "code" || node.type === "inlineCode") && node.position?.start.offset !== void 0 && node.position.end.offset !== void 0)
       protectedSpans.push([node.position.start.offset, node.position.end.offset]);
   });
@@ -1216,8 +1253,8 @@ function normalizeDocfxMarkdown(source, options = {}) {
     type: "document",
     children: [{ type: "paragraph", children: [{ type: "text", value: text }] }]
   }).trimEnd();
-  const output = body.replace(
-    /(^[^\S\n]*(?:>\s*)?):::\s*([\w-]+)([^\n]*?)(?=\r?$)|(^[^\S\n]*>\s*)\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION|div)\b([^\]]*)\]|:::\s*(image)\b([^\n]*?):::/gim,
+  let output = body.replace(
+    /(^[^\S\n]*(?:>\s*)?):::\s*([\w-]+)([^\n]*?)(?=\r?$)|(^[^\S\n]*>\s*)\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION|div)\b([^\]]*)\]|:::\s*(image|no-loc)\b([^\n]*?):::/gim,
     (match, prefix, name, raw, quote, admonition, _extra, inlineName, inlineRaw, offset) => {
       if (protectedSpans.some(([start, end]) => offset >= start && offset < end)) return match;
       if (admonition)
@@ -1239,6 +1276,16 @@ function normalizeDocfxMarkdown(source, options = {}) {
           }).trimEnd();
           return `${prefix ?? ""}${image}`;
         }
+        case "code":
+          if (options.reference && attributes.has("source"))
+            return (prefix ?? "") + options.reference("code", attributes.get("source"), raw?.trim() ?? "Code example");
+          throw new Error("Unsupported DocFX code without a source reference resolver");
+        case "no-loc":
+          return (prefix ?? "") + escape(attributes.get("text") ?? "");
+        case "moniker":
+          return (prefix ?? "") + "**Applies to: " + escape(attributes.get("range") ?? raw?.trim() ?? "") + "**";
+        case "moniker-end":
+          return "";
         case "zone":
           return attributes.has("pivot") ? `${prefix ?? ""}**Applies to: ${escape(attributes.get("pivot"))}**
 ` : "";
@@ -1250,12 +1297,100 @@ function normalizeDocfxMarkdown(source, options = {}) {
         case "column-end":
           return "";
         default:
+          if (options.unknownDirectives === "preserve") {
+            const fence = "`".repeat(
+              Math.max(1, ...Array.from(match.matchAll(/`+/g), (m) => m[0].length + 1))
+            );
+            return `${prefix ?? ""}${fence}${match.trim()}${fence}`;
+          }
           throw new Error(`Unsupported DocFX directive: ${name}`);
       }
     }
   );
+  if (options.reference) {
+    const spans = [];
+    for (const comment of output.matchAll(/<!--[\s\S]*?(?:-->|$)/g))
+      spans.push([comment.index, comment.index + comment[0].length]);
+    walkMarkdownTree(parseMarkdown(output, { frontmatter: false, directive: false }), (node) => {
+      if ((node.type === "code" || node.type === "inlineCode") && node.position)
+        spans.push([node.position.start.offset, node.position.end.offset]);
+    });
+    output = output.replace(
+      /\[!code-[\w-]+\s*\[([^\]]*)\]\(([^)\n]+)\)\]|<xref:([^>\n]+)>/gi,
+      (match, label, target, uid, offset) => {
+        if (spans.some(([start, end]) => offset >= start && offset < end)) return match;
+        return uid ? options.reference("xref", uid, uid.split("?")[0]) : options.reference("code", target, label || "Code example");
+      }
+    );
+  }
+  if (options.unknownDirectives === "preserve" && /\[!code-|\[!INCLUDE\b|<xref:/i.test(output)) {
+    const spans = [];
+    for (const comment of output.matchAll(/<!--[\s\S]*?(?:-->|$)/g))
+      spans.push([comment.index, comment.index + comment[0].length]);
+    walkMarkdownTree(parseMarkdown(output, { frontmatter: false, directive: false }), (node) => {
+      if ((node.type === "code" || node.type === "inlineCode") && node.position)
+        spans.push([node.position.start.offset, node.position.end.offset]);
+    });
+    output = output.replace(
+      /\[!code-[^\n]*|\[!INCLUDE[^\n]*|<xref:[^\n]*/gi,
+      (match, offset) => {
+        if (spans.some(([start, end]) => offset >= start && offset < end)) return match;
+        options.onPreservedReference?.(match);
+        const fence = String.fromCharCode(96).repeat(
+          Math.max(1, ...Array.from(match.matchAll(/\x60+/g), (m) => m[0].length + 1))
+        );
+        return fence + " " + match + " " + fence;
+      }
+    );
+  }
+  if (options.frontmatterAsCode && frontmatter) {
+    const fence = "`".repeat(
+      Math.max(3, ...Array.from(frontmatter.matchAll(/`+/g), (m) => m[0].length + 1))
+    );
+    return output + "\n\n## Original source metadata\n\n" + fence + "text\n" + frontmatter.trimEnd() + "\n" + fence + "\n";
+  }
   return (frontmatter ?? "") + output;
 }
+function flattenDocfxLayout(source) {
+  const stack = [];
+  let fence;
+  let comment = false;
+  return source.split("\n").map((line) => {
+    const column = [...stack].reverse().find((entry) => entry.kind === "column");
+    const margin = column ? column.indent + 4 : 0;
+    const indent = /^ */.exec(line)[0].length;
+    const content = line.slice(Math.min(indent, margin));
+    const boundary = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(content);
+    if (fence) {
+      if (boundary && boundary[1][0] === fence.character && boundary[1].length >= fence.length && !boundary[2].trim())
+        fence = void 0;
+      return content;
+    }
+    const commented = comment || line.includes("<!--");
+    const opening = line.lastIndexOf("<!--");
+    const closing = line.lastIndexOf("-->");
+    if (opening > closing) comment = true;
+    else if (closing >= 0) comment = false;
+    if (commented) return content;
+    if (boundary) {
+      fence = { character: boundary[1][0], length: boundary[1].length };
+      return content;
+    }
+    const marker = /^ *:::(row|column)(-end)?(?=\s|:|$)[^\n]*$/i.exec(line);
+    if (!marker || !stack.length && indent > 3) return content;
+    const kind = marker[1].toLowerCase();
+    if (marker[2]) {
+      const index = stack.map((entry) => entry.kind).lastIndexOf(kind);
+      if (index < 0) return content;
+      stack.splice(index);
+    } else {
+      if (stack.length >= 128)
+        throw new Error("DocFX layout exceeds the 128-level nesting safety limit");
+      stack.push({ kind, indent });
+    }
+    return "";
+  }).join("\n");
+}
 
 export {
   stringifyMarkdown,

package/dist/{chunk-IRVXZUVU.js → chunk-MY46W5O5.js}

@@ -7,10 +7,10 @@ import {
   buildNarrationScript,
   expectedSyllablesAt,
   wordPosAtExpectedSyllables
-} from "./chunk-5W7F46OO.js";
+} from "./chunk-PNXBDMNS.js";
 import {
   flattenRenderableBlocks
-} from "./chunk-WMXQDP2C.js";
+} from "./chunk-L7IIFWWW.js";
 
 // src/narration/types.ts
 var DEFAULT_FEATURE_CONFIG = Object.freeze({

package/dist/{chunk-GDHXT5Q7.js → chunk-PGWYC3S2.js}

@@ -6,11 +6,11 @@ import {
   quoteAttrValue,
   splitKeyValueToken,
   tokenizeAttrTokens
-} from "./chunk-TMOHAFYE.js";
+} from "./chunk-WSFXV5BT.js";
 import {
   parseFrontmatter,
   parseHtmlToNodes
-} from "./chunk-X7BNDUNI.js";
+} from "./chunk-Q6ELOAOQ.js";
 import {
   resolveIcon
 } from "./chunk-7N4G32LG.js";

package/dist/{chunk-5W7F46OO.js → chunk-PNXBDMNS.js}

@@ -1,7 +1,7 @@
 import {
   flattenRenderableBlocks,
   getBlockBodyText
-} from "./chunk-WMXQDP2C.js";
+} from "./chunk-L7IIFWWW.js";
 import {
   estimateSpokenWordCount
 } from "./chunk-GHOPHGOK.js";

package/dist/{chunk-X7BNDUNI.js → chunk-Q6ELOAOQ.js}

@@ -685,6 +685,378 @@ function plainTextFromInlineHtml(html) {
   return walk(parseHtmlToNodes(html)).replace(/\u00A0/g, " ").replace(/\n{3,}/g, "\n\n").trim();
 }
 
+// src/markdown/mediaReference.ts
+var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set(["mp4", "m4v", "mov", "webm", "ogv"]);
+var AUDIO_EXTENSIONS = /* @__PURE__ */ new Set(["mp3", "m4a", "aac", "wav", "ogg", "oga", "opus", "flac"]);
+var CONTAINER_EXTENSIONS = /* @__PURE__ */ new Set(["webm", "mp4"]);
+function mediaKindForUrl(url) {
+  const path = url.split(/[?#]/, 1)[0] ?? "";
+  const name = path.slice(path.lastIndexOf("/") + 1);
+  const dot = name.lastIndexOf(".");
+  if (dot <= 0) return null;
+  const ext = name.slice(dot + 1).toLowerCase();
+  if (AUDIO_EXTENSIONS.has(ext)) return "audio";
+  if (CONTAINER_EXTENSIONS.has(ext) && /^(?:\.\/)?audio\//i.test(path)) return "audio";
+  if (VIDEO_EXTENSIONS.has(ext)) return "video";
+  return null;
+}
+
+// src/markdown/videoEmbed.ts
+var VIDEO_EMBED_PROVIDERS = [
+  { id: "youtube", name: "YouTube", example: "https://www.youtube.com/watch?v=dQw4w9WgXcQ" },
+  { id: "vimeo", name: "Vimeo", example: "https://vimeo.com/76979871" },
+  {
+    id: "loom",
+    name: "Loom",
+    example: "https://www.loom.com/share/0281766fa2d04bb788eaf19e65135184"
+  },
+  { id: "dailymotion", name: "Dailymotion", example: "https://www.dailymotion.com/video/x7tgad0" },
+  { id: "wistia", name: "Wistia", example: "https://home.wistia.com/medias/e4a27b971d" }
+];
+var PROVIDER_NAMES = Object.fromEntries(
+  VIDEO_EMBED_PROVIDERS.map((p) => [p.id, p.name])
+);
+var LANDSCAPE = 16 / 9;
+var PORTRAIT = 9 / 16;
+function unescapeMarkdown(value) {
+  return value.replace(/\\([!-/:-@[-`{-~])/g, "$1");
+}
+function toUrl(input) {
+  let text = unescapeMarkdown(input.trim());
+  if (text.startsWith("<") && text.endsWith(">")) text = text.slice(1, -1).trim();
+  if (!text || /\s/.test(text)) return null;
+  if (text.startsWith("//")) text = `https:${text}`;
+  else if (!/^[a-z][a-z0-9+.-]*:/i.test(text)) text = `https://${text}`;
+  let url;
+  try {
+    url = new URL(text);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") return null;
+  if (url.username || url.password || url.port) return null;
+  return url;
+}
+function baseHost(url) {
+  return url.hostname.toLowerCase().replace(/^(?:www|m)\./, "");
+}
+function pathSegments(url) {
+  return url.pathname.split("/").filter(Boolean).map((segment) => {
+    try {
+      return decodeURIComponent(segment);
+    } catch {
+      return segment;
+    }
+  });
+}
+function fragmentParam(url, key) {
+  const hash = url.hash.replace(/^#/, "");
+  if (!hash) return null;
+  return new URLSearchParams(hash).get(key);
+}
+var HMS_RE = /^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s?)?$/;
+var CLOCK_RE = /^(?:(\d+):)?(\d{1,2}):(\d{2})$/;
+function parseVideoStartTime(raw) {
+  if (!raw) return void 0;
+  const value = raw.trim().toLowerCase();
+  if (!value) return void 0;
+  let total = null;
+  const hms = HMS_RE.exec(value);
+  if (hms && (hms[1] || hms[2] || hms[3])) {
+    total = Number(hms[1] ?? 0) * 3600 + Number(hms[2] ?? 0) * 60 + Number(hms[3] ?? 0);
+  } else {
+    const clock = CLOCK_RE.exec(value);
+    const minutes = Number(clock?.[2]);
+    const seconds = Number(clock?.[3]);
+    if (clock && seconds < 60 && (clock[1] === void 0 || minutes < 60)) {
+      total = Number(clock[1] ?? 0) * 3600 + minutes * 60 + seconds;
+    }
+  }
+  if (total === null || !Number.isFinite(total) || total <= 0) return void 0;
+  return Math.floor(total);
+}
+function withQuery(base, params) {
+  const query = params.filter((entry) => entry[1] !== void 0).map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join("&");
+  return query ? `${base}?${query}` : base;
+}
+function build(provider, fields) {
+  const embed = {
+    provider,
+    providerName: PROVIDER_NAMES[provider],
+    id: fields.id,
+    embedUrl: fields.embedUrl,
+    watchUrl: fields.watchUrl,
+    aspectRatio: fields.aspectRatio ?? LANDSCAPE
+  };
+  if (fields.playlistId) embed.playlistId = fields.playlistId;
+  if (fields.startSeconds) embed.startSeconds = fields.startSeconds;
+  if (fields.thumbnailUrl) embed.thumbnailUrl = fields.thumbnailUrl;
+  return embed;
+}
+var YOUTUBE_HOSTS = /* @__PURE__ */ new Set(["youtube.com", "music.youtube.com", "youtube-nocookie.com"]);
+var YOUTUBE_ID_RE = /^[A-Za-z0-9_-]{11}$/;
+var YOUTUBE_LIST_RE = /^[A-Za-z0-9_-]{2,80}$/;
+var YOUTUBE_ID_PATHS = /* @__PURE__ */ new Set(["embed", "v", "e", "live", "shorts"]);
+var YOUTUBE_EMBED_ORIGIN = "https://www.youtube-nocookie.com";
+function parseYouTube(url) {
+  const host = baseHost(url);
+  const segments = pathSegments(url);
+  const params = url.searchParams;
+  let id = null;
+  let shorts = false;
+  if (host === "youtu.be") {
+    id = segments[0] ?? null;
+  } else if (YOUTUBE_HOSTS.has(host)) {
+    const [head, second] = segments;
+    if (head === "watch") id = params.get("v");
+    else if (head && YOUTUBE_ID_PATHS.has(head) && second !== "videoseries") {
+      id = second ?? null;
+      shorts = head === "shorts";
+    } else if (head !== "playlist" && !(head === "embed" && second === "videoseries")) {
+      return null;
+    }
+  } else {
+    return null;
+  }
+  if (id !== null && !YOUTUBE_ID_RE.test(id)) return null;
+  const list = params.get("list");
+  const playlistId = list && YOUTUBE_LIST_RE.test(list) ? list : void 0;
+  if (!id && !playlistId) return null;
+  const startSeconds = parseVideoStartTime(
+    params.get("t") ?? params.get("start") ?? fragmentParam(url, "t")
+  );
+  const start = startSeconds ? String(startSeconds) : void 0;
+  if (!id) {
+    return build("youtube", {
+      id: playlistId,
+      playlistId,
+      embedUrl: withQuery(`${YOUTUBE_EMBED_ORIGIN}/embed/videoseries`, [["list", playlistId]]),
+      watchUrl: withQuery("https://www.youtube.com/playlist", [["list", playlistId]])
+    });
+  }
+  return build("youtube", {
+    id,
+    playlistId,
+    startSeconds,
+    embedUrl: withQuery(`${YOUTUBE_EMBED_ORIGIN}/embed/${id}`, [
+      ["list", playlistId],
+      ["start", start]
+    ]),
+    watchUrl: shorts ? `https://www.youtube.com/shorts/${id}` : withQuery("https://www.youtube.com/watch", [
+      ["v", id],
+      ["list", playlistId],
+      ["t", start && `${start}s`]
+    ]),
+    thumbnailUrl: `https://i.ytimg.com/vi/${id}/hqdefault.jpg`,
+    aspectRatio: shorts ? PORTRAIT : LANDSCAPE
+  });
+}
+var VIMEO_ID_RE = /^\d{1,12}$/;
+var VIMEO_HASH_RE = /^[0-9a-f]{6,24}$/i;
+function vimeoIdFromSegments(segments) {
+  const [a, b, c, d] = segments;
+  if (a && VIMEO_ID_RE.test(a)) {
+    return { id: a, ...b && VIMEO_HASH_RE.test(b) ? { hash: b } : {} };
+  }
+  if (a === "video" && b && VIMEO_ID_RE.test(b)) return { id: b };
+  if (a === "channels" && c && VIMEO_ID_RE.test(c)) return { id: c };
+  if (a === "groups" && c === "videos" && d && VIMEO_ID_RE.test(d)) return { id: d };
+  if ((a === "album" || a === "showcase") && c === "video" && d && VIMEO_ID_RE.test(d)) {
+    return { id: d };
+  }
+  return null;
+}
+function parseVimeo(url) {
+  const host = baseHost(url);
+  if (host !== "vimeo.com" && host !== "player.vimeo.com") return null;
+  const found = vimeoIdFromSegments(pathSegments(url));
+  if (!found) return null;
+  const queryHash = url.searchParams.get("h");
+  const hash = found.hash ?? (queryHash && VIMEO_HASH_RE.test(queryHash) ? queryHash : void 0);
+  const startSeconds = parseVideoStartTime(
+    fragmentParam(url, "t") ?? url.searchParams.get("t") ?? url.searchParams.get("start")
+  );
+  const timeFragment = startSeconds ? `#t=${startSeconds}s` : "";
+  return build("vimeo", {
+    id: found.id,
+    startSeconds,
+    embedUrl: withQuery(`https://player.vimeo.com/video/${found.id}`, [["h", hash]]) + timeFragment,
+    watchUrl: `https://vimeo.com/${found.id}${hash ? `/${hash}` : ""}${timeFragment}`
+  });
+}
+var LOOM_ID_RE = /(?:^|-)([0-9a-f]{32})$/i;
+function parseLoom(url) {
+  if (baseHost(url) !== "loom.com") return null;
+  const [head, second] = pathSegments(url);
+  if (head !== "share" && head !== "embed" || !second) return null;
+  const match = LOOM_ID_RE.exec(second);
+  if (!match) return null;
+  const id = match[1].toLowerCase();
+  return build("loom", {
+    id,
+    embedUrl: `https://www.loom.com/embed/${id}`,
+    watchUrl: `https://www.loom.com/share/${id}`
+  });
+}
+var DAILYMOTION_ID_RE = /^[A-Za-z0-9]{5,20}$/;
+function parseDailymotion(url) {
+  const host = baseHost(url);
+  const segments = pathSegments(url);
+  let raw = null;
+  if (host === "dai.ly") raw = segments[0] ?? null;
+  else if (host === "dailymotion.com") {
+    if (segments[0] === "video") raw = segments[1] ?? null;
+    else if (segments[0] === "embed" && segments[1] === "video") raw = segments[2] ?? null;
+    else return null;
+  } else if (host === "geo.dailymotion.com") {
+    raw = url.searchParams.get("video");
+  } else {
+    return null;
+  }
+  const id = raw?.split("_")[0];
+  if (!id || !DAILYMOTION_ID_RE.test(id)) return null;
+  const startSeconds = parseVideoStartTime(url.searchParams.get("start"));
+  const start = startSeconds ? String(startSeconds) : void 0;
+  return build("dailymotion", {
+    id,
+    startSeconds,
+    embedUrl: withQuery(`https://www.dailymotion.com/embed/video/${id}`, [["start", start]]),
+    watchUrl: withQuery(`https://www.dailymotion.com/video/${id}`, [["start", start]]),
+    thumbnailUrl: `https://www.dailymotion.com/thumbnail/video/${id}`
+  });
+}
+var WISTIA_ID_RE = /^[a-z0-9]{10}$/;
+var WISTIA_ACCOUNT_HOST_RE = /^[a-z0-9-]{1,63}\.wistia\.com$/;
+function parseWistia(url) {
+  const host = url.hostname.toLowerCase();
+  const fastHost = host === "fast.wistia.net" || host === "fast.wistia.com";
+  if (!fastHost && !WISTIA_ACCOUNT_HOST_RE.test(host)) return null;
+  const segments = pathSegments(url);
+  let raw;
+  if (segments[0] === "medias") raw = segments[1];
+  else if (segments[0] === "embed" && (segments[1] === "iframe" || segments[1] === "medias")) {
+    raw = segments[2];
+  }
+  const id = raw?.replace(/\.jsonp$/, "");
+  if (!id || !WISTIA_ID_RE.test(id)) return null;
+  const embedUrl = `https://fast.wistia.net/embed/iframe/${id}`;
+  return build("wistia", {
+    id,
+    embedUrl,
+    // A media page lives on the account's own subdomain; the fast host only
+    // serves the player, which doubles as a viewable page.
+    watchUrl: fastHost ? embedUrl : `https://${host}/medias/${id}`
+  });
+}
+var PARSERS = [
+  parseYouTube,
+  parseVimeo,
+  parseLoom,
+  parseDailymotion,
+  parseWistia
+];
+function parseVideoEmbedUrl(input) {
+  if (typeof input !== "string") return null;
+  const url = toUrl(input);
+  if (!url) return null;
+  for (const parse of PARSERS) {
+    const embed = parse(url);
+    if (embed) return embed;
+  }
+  return null;
+}
+function isVideoEmbedUrl(input) {
+  return parseVideoEmbedUrl(input) !== null;
+}
+var VIDEO_EMBED_IFRAME_ALLOW = "accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share; fullscreen";
+function videoEmbedIframeAttributes(embed, title) {
+  return {
+    src: embed.embedUrl,
+    title: title?.trim() || `${embed.providerName} video`,
+    allow: VIDEO_EMBED_IFRAME_ALLOW,
+    allowfullscreen: "",
+    referrerpolicy: "strict-origin-when-cross-origin",
+    loading: "lazy"
+  };
+}
+var GENERIC_PLAYER_TITLE_RE = /^(?:[\w .-]+[ -])?(?:video[ -])?player$/i;
+function attributeOf(element, name) {
+  for (const [key, value] of Object.entries(element.attributes)) {
+    if (key.toLowerCase() === name) return value;
+  }
+  return void 0;
+}
+function soleIframe(nodes) {
+  let found = null;
+  let disqualified = false;
+  const visit = (list) => {
+    for (const node of list) {
+      if (disqualified) return;
+      if (node.type === "htmlText") {
+        if (node.value.trim()) disqualified = true;
+        continue;
+      }
+      if (node.type !== "htmlElement") continue;
+      const tag = node.tagName.toLowerCase();
+      if (tag === "iframe") {
+        if (found) disqualified = true;
+        found = node;
+        continue;
+      }
+      if (tag === "script" || tag === "style" || tag === "noscript") continue;
+      visit(node.children);
+    }
+  };
+  visit(nodes);
+  return disqualified ? null : found;
+}
+function iframeEmbed(element) {
+  const embed = parseVideoEmbedUrl(attributeOf(element, "src"));
+  if (!embed) return null;
+  const title = attributeOf(element, "title")?.trim() ?? "";
+  const generic = GENERIC_PLAYER_TITLE_RE.test(title) || title.toLowerCase() === `${embed.providerName} video`.toLowerCase();
+  return { embed, title: title && !generic ? title : null };
+}
+function videoEmbedFromIframe(element) {
+  return element.tagName.toLowerCase() === "iframe" ? iframeEmbed(element) : null;
+}
+function parseVideoEmbedInput(input) {
+  if (typeof input !== "string") return null;
+  const text = input.trim();
+  if (!text) return null;
+  if (/^<(?!https?:)/i.test(text)) {
+    if (!/<iframe\b/i.test(text)) return null;
+    const iframe = soleIframe(parseHtmlToNodes(text));
+    return iframe ? iframeEmbed(iframe) : null;
+  }
+  const embed = parseVideoEmbedUrl(text);
+  return embed ? { embed, title: null } : null;
+}
+function isBlankInline(node) {
+  return node.type === "text" && !node.value.trim() || node.type === "htmlInline" && node.htmlChildren.length === 0;
+}
+function findBlockVideoEmbed(node) {
+  if (node.type === "htmlBlock") {
+    const iframe = soleIframe(node.htmlChildren);
+    const found = iframe ? iframeEmbed(iframe) : null;
+    return found ? { ...found, form: "iframe" } : null;
+  }
+  if (node.type !== "paragraph") return null;
+  const text = extractPlainText(node).trim();
+  if (text && !/\s/.test(text)) {
+    const bare = parseVideoEmbedUrl(text);
+    if (bare) return { embed: bare, title: null, form: "url" };
+  }
+  const significant = node.children.filter((child) => !isBlankInline(child));
+  if (significant.length !== 1 || significant[0].type !== "link") return null;
+  const link = significant[0];
+  const embed = parseVideoEmbedUrl(link.url);
+  if (!embed) return null;
+  const label = extractPlainText(link).trim();
+  const title = label && !isVideoEmbedUrl(label) && label !== link.url ? label : null;
+  return { embed, title, form: title ? "link" : "url" };
+}
+
 export {
   parseHtmlToNodes,
   stringifyHtmlNodes,
@@ -702,5 +1074,15 @@ export {
   createDocument,
   inferDocumentTitle,
   readFrontmatterThemeId,
-  plainTextFromInlineHtml
+  plainTextFromInlineHtml,
+  mediaKindForUrl,
+  VIDEO_EMBED_PROVIDERS,
+  parseVideoStartTime,
+  parseVideoEmbedUrl,
+  isVideoEmbedUrl,
+  VIDEO_EMBED_IFRAME_ALLOW,
+  videoEmbedIframeAttributes,
+  videoEmbedFromIframe,
+  parseVideoEmbedInput,
+  findBlockVideoEmbed
 };