@peaceroad/markdown-it-figure-with-p-caption 0.16.1 → 0.18.0

package/README.md

@@ -15,10 +15,10 @@ Optionally, you can auto-number image and table caption paragraphs starting from
 - Pure image paragraphs (`![...](...)`) become `<figure class="f-img">` blocks as soon as a caption paragraph (previous or next) or an auto-detected caption exists.
 - Auto detection runs per image paragraph when `autoCaptionDetection` is `true` (default). The priority is:
     1. Caption paragraphs immediately before or after the image (standard syntax).
-    2. Image `alt` text that already matches p7d-markdown-it-p-captions label formats (`Figure. `, `Figure 1. `, `図　`,`図1　`, etc.).
+    2. Image `alt` text that `p7d-markdown-it-p-captions` recognizes as an image caption start (`Figure. `, `Figure 1. `, `図　`, `図1　`, etc.).
     3. Image `title` attribute that matches the same labels.
     4. Optional fallbacks (`autoAltCaption`, `autoTitleCaption`) that inject the label when the alt/title lacks one.
-        - `autoAltCaption`: `false` (default), `true`, or a string label. `true` inspects the first sentence of the caption text and picks `Figure` / `図` based on detected language; a string uses that label verbatim.
+        - `autoAltCaption`: `false` (default), `true`, or a string label. `true` uses locale-aware generated-label defaults from `p7d-markdown-it-p-captions`, so the label text and punctuation stay aligned with the upstream caption language data. A string is treated as a label stem that must be recognized by `p7d-markdown-it-p-captions`; setup throws if it cannot be parsed as an image caption label. This plugin appends the default joint/space unless the string already ends with punctuation such as `.` / `。` / `:`. Empty alt text does not generate a fallback caption.
         - `autoTitleCaption`: same behavior but sourced from the image `title`. It stays off by default so other plugins can keep using the `title` attribute for metadata.
 - Set `autoCaptionDetection: false` to disable the auto-caption workflow entirely.
 - Multi-image paragraphs are still wrapped as one figure when `multipleImages: true` (default). Layout-specific classes help with styling:
@@ -41,7 +41,7 @@ Optionally, you can auto-number image and table caption paragraphs starting from
 
 ### Blockquote
 
-- Captioned blockquotes (e.g., “Source. A paragraph. Ewritten immediately before or after `> ...`) become `<figure class="f-blockquote">` while keeping the original blockquote intact.
+- Captioned blockquotes (e.g., `Source. A paragraph.` written immediately before or after `> ...`) become `<figure class="f-blockquote">` while keeping the original blockquote intact.
 
 ### Video & Audio
 
@@ -50,9 +50,9 @@ Optionally, you can auto-number image and table caption paragraphs starting from
 
 ### Embedded content by iframe
 
-- Inline HTML `<iframe>` elements become `<figure class="f-video">` when they point to known video hosts (YouTube `youtube.com` / `youtube-nocookie.com`, Vimeo `player.vimeo.com`).
+- Inline HTML `<iframe>` elements become `<figure class="f-video">` when they point to known video hosts (YouTube `www.youtube.com`, `youtube.com`, `www.youtube-nocookie.com`, `youtube-nocookie.com`, Vimeo `player.vimeo.com`).
 - `<div>` wrappers are treated as iframe-type embeds only when the same HTML block contains an `<iframe ...>` tag (for example common video wrapper markup).
-- Blockquote-based social embeds (Twitter/X `twitter-tweet`, Mastodon `mastodon-embed`, Bluesky `bluesky-embed`, Instagram `instagram-media`, Tumblr `text-post-media`) are treated like iframe-type embeds when their `class` matches those providers. By default they become `<figure class="f-img">` so the caption label behaves like an image label (Labels can also use quote labels). You can override that figure class with `figureClassThatWrapsIframeTypeBlockquote` or the global `allIframeTypeFigureClassName`.
+- Blockquote-based social embeds (Twitter/X `twitter-tweet`, Mastodon `mastodon-embed`, Bluesky `bluesky-embed`, Instagram `instagram-media`, Tumblr `text-post-media`) are treated like iframe-type embeds when their class list contains one of those provider classes. Extra classes on the same blockquote do not block detection. By default they become `<figure class="f-img">` so the caption label behaves like an image label (Labels can also use quote labels). You can override that figure class with `figureClassThatWrapsIframeTypeBlockquote` or the global `allIframeTypeFigureClassName`.
 - `p7d-markdown-it-p-captions` ships with a `Slide.` label. When you use it (for example with Speaker Deck or SlideShare iframes), the `<figure>` wrapper automatically switches to `f-slide` (or whatever you set via `figureClassThatWrapsSlides`) so slides can get their own layout. If `allIframeTypeFigureClassName` is also configured, that class takes precedence even for slides, so you get a uniform embed wrapper without touching the slide option.
 - All other iframes fall back to `<figure class="f-iframe">` unless you override the class via `allIframeTypeFigureClassName`.
 
@@ -60,7 +60,8 @@ Optionally, you can auto-number image and table caption paragraphs starting from
 
 - The label inside the figcaption (the `span` element used for the label) is generated by `p7d-markdown-it-p-captions`, not by this plugin. By default the class name is formed by combining `classPrefix` with the mark name, producing names such as `f-img-label`, `f-video-label`, `f-blockquote-label`, and `f-slide-label`. 
 - With `markdown-it-attrs`, attributes attached to image-only paragraphs (for example `![...](...) {.foo #bar}`) are forwarded to the generated `<figure>`.
-- `styleProcess` controls parsing of a trailing `{...}` block from the last text token of an image-only paragraph in this plugin's own scanner. It is a narrow fallback parser, not full `markdown-it-attrs` parity, and attributes already attached to paragraph tokens by `markdown-it-attrs` are still forwarded.
+- `styleProcess` controls parsing of a trailing `{...}` block from the last text token of an image-only paragraph in this plugin's own scanner. It supports simple `.class`, `#id`, bare attributes, and quoted `key="value with spaces"` / `key='value with spaces'` pairs. It is still a narrow fallback parser, not full `markdown-it-attrs` parity, and attributes already attached to paragraph tokens by `markdown-it-attrs` are still forwarded.
+- Attribute forwarding is not sanitization. If you render untrusted Markdown, keep using an HTML sanitizer or a trusted-host policy appropriate for your application; this plugin only decides which already-parsed or narrowly parsed attributes move onto `<figure>`.
 - Attributes attached to caption paragraphs stay on the converted `<figcaption>` token after paragraph-to-figcaption conversion.
 
 ## Behavior Customization
@@ -75,7 +76,8 @@ Optionally, you can auto-number image and table caption paragraphs starting from
 
 ### Wrapping without captions
 
-- `oneImageWithoutCaption`: turn single-image paragraphs into `<figure>` elements even when no caption paragraph/auto caption is present. This is independent of automatic detection.
+- `imageOnlyParagraphWithoutCaption`: turn valid image-only paragraphs into `<figure>` elements even when no caption paragraph/auto caption is present. This includes single-image paragraphs and, when `multipleImages` is enabled, multi-image paragraphs that receive classes such as `f-img-horizontal`, `f-img-vertical`, or `f-img-multiple`. This is independent of automatic detection.
+- `oneImageWithoutCaption`: legacy alias for `imageOnlyParagraphWithoutCaption`. When both are provided, `imageOnlyParagraphWithoutCaption` wins.
 - `videoWithoutCaption`, `audioWithoutCaption`, `iframeWithoutCaption`, `iframeTypeBlockquoteWithoutCaption`: wrap the respective media blocks without caption.
 
 ### Caption text helpers (delegated to `p7d-markdown-it-p-captions`)
@@ -85,20 +87,23 @@ Every option below is forwarded verbatim to `p7d-markdown-it-p-captions`, which
 - `strongFilename` / `dquoteFilename`: pull out filenames from captions using `**filename**` or `"filename"` syntax and wrap them in `<strong class="f-*-filename">`.
 - `jointSpaceUseHalfWidth`: replace full-width space between Japanese labels and caption body with half-width space.
 - `bLabel` / `strongLabel`: emphasize the label span itself.
-- `removeUnnumberedLabel`: drop the leading “Figure. Etext entirely when no label number is present. Use `removeUnnumberedLabelExceptMarks` to keep specific labels (e.g., `['blockquote']` keeps `Quote. `).
+- `removeUnnumberedLabel`: drop the leading label entirely when no label number is present. Use `removeUnnumberedLabelExceptMarks` to keep specific labels (e.g., `['blockquote']` keeps `Quote. `).
 - `removeMarkNameInCaptionClass`: replace `.f-img-label` / `.f-table-label` with the generic `.f-label`.
 - `wrapCaptionBody`: wrap the non-label caption text in a span element.
 - `hasNumClass`: add a class attribute to label span element if it has a label number.
 - `labelClassFollowsFigure`: mirror the resolved `<figure>` class onto the `figcaption` spans (`f-embed-label`, `f-embed-label-joint`, `f-embed-body`, etc.) when you want captions styled alongside the wrapper.
 - `figureToLabelClassMap`: extend `labelClassFollowsFigure` by mapping specific figure classes (e.g., `f-embed`) to custom caption label classes such as `caption-embed caption-social` for fine-grained control. When this map is provided and `labelClassFollowsFigure` is not set explicitly, figure-following mode is enabled automatically.
 - `labelPrefixMarker`: allow a leading marker before labels (string or array, e.g., `*Figure. ...`). Arrays are limited to two markers; extras are ignored.
+- `languages`: optional available caption-recognition catalogs delegated to `p7d-markdown-it-p-captions` (default: `['en', 'ja']`). Most users can leave this unset. Set it only when you want to restrict or extend which labels can be recognized (for example English `Figure.` and Japanese `図　`) and which catalogs are available for generated fallback labels. It is separate from the active locale used to choose among those available catalogs.
+- Automatic image-label fallback text and punctuation (`Figure. `, `図　`, etc.) are generated from `p7d-markdown-it-p-captions` locale metadata, not from a local hardcoded map in this plugin.
+- Generated fallback label tie-break is resolved once per render. Prefer passing the active locale through `env.locale` or `env.preferredLocales`. Compatibility fallbacks are `preferredLanguages`, `env.preferredLanguages`, `env.lang`, and `env.language`. If none of those selects an available catalog, this plugin finally uses a cheap document-script heuristic that skips a leading hyphen-fenced frontmatter block (`---` or longer, spaces allowed before newline), then falls back to the raw `languages` order. This tie-break only affects generated fallback labels; it does not change the caption-recognition dictionaries selected by `languages`. Compatibility note: for generated fallback labels, `env.locale` / `env.preferredLocales` intentionally take precedence over the legacy `preferredLanguages` option so a shared `md` instance can render different documents with different active locales.
 
 ### Automatic numbering
 
 - `autoLabelNumberSets`: enable numbering per media type. Pass an array such as `['img']`, `['table']`, or `['img', 'table']`.
 - `autoLabelNumber`: shorthand for turning numbering on for both images and tables without passing the array yourself. Provide `autoLabelNumberSets` explicitly (e.g., `['img']`) when you need finer control—the explicit array always wins.
 - Counters start at `1` near the top of the document and increment sequentially per media type. Figures and tables keep independent counters even when mixed together.
-- The counter only advances when a real caption exists (paragraph, auto-detected alt/title, or fallback text). Figures emitted solely because of `oneImageWithoutCaption` stay unnumbered.
+- The counter only advances when a real caption exists (paragraph, auto-detected alt/title, or fallback text). Figures emitted solely because of `imageOnlyParagraphWithoutCaption` / `oneImageWithoutCaption` stay unnumbered.
 - Manual numbers inside the caption text (e.g., `Figure 5.`) always win. The plugin updates its internal counter so the next automatic number becomes `6`. This applies to captions sourced from paragraphs, auto detection, and fallback captions.
 
 ## Basic Usage
@@ -126,12 +131,12 @@ Auto label numbering for images and tables.
 ```js
 const figureOption = {
   // Opinionated defaults
-  oneImageWithoutCaption: true,
+  imageOnlyParagraphWithoutCaption: true,
   videoWithoutCaption: true,
   audioWithoutCaption: true,
   iframeWithoutCaption: true,
   iframeTypeBlockquoteWithoutCaption: true,
-  removeUnnumberedLabelExceptMarks: ['blockquote'], // keep “Quote. Elabels even when unnumbered
+  removeUnnumberedLabelExceptMarks: ['blockquote'], // keep `Quote.` labels even when unnumbered
   allIframeTypeFigureClassName: 'f-embed', // apply a uniform class to every iframe-style embed
   autoLabelNumber: true,
 
@@ -145,7 +150,7 @@ If there is no label number, the label will also be deleted.
 
 ```js
 const figureOption = {
-  oneImageWithoutCaption: true,
+  imageOnlyParagraphWithoutCaption: true,
   videoWithoutCaption: true,
   audioWithoutCaption: true,
   iframeWithoutCaption: true,
@@ -173,7 +178,7 @@ const md = mdit({ html: true }).use(mditFigureWithPCaption, figureOption)
 [HTML]
 <p><img src="figure.jpg" alt="A single cat"></p>
 
-<!-- Above: If oneImageWithoutCaption is true, this img element has wrapped into figure element without caption. -->
+<!-- Above: If imageOnlyParagraphWithoutCaption (or its legacy alias oneImageWithoutCaption) is true, this img element has wrapped into figure element without caption. -->
 
 
 [Markdown]
@@ -438,7 +443,7 @@ A paragraph.
 
 ### Styles
 
-This example uses `classPrefix: 'custom'` and leaves `styleProcess: true` so a trailing `{.notice}` block moves onto the `<figure>` wrapper. This fallback only handles the final trailing attrs block on an image-only paragraph; for broader attrs syntax support, keep using `markdown-it-attrs`.
+This example uses `classPrefix: 'custom'` and leaves `styleProcess: true` so a trailing `{.notice}` block moves onto the `<figure>` wrapper. This fallback only handles the final trailing attrs block on an image-only paragraph; it supports quoted values with spaces, but for broader attrs syntax support, keep using `markdown-it-attrs`.
 
 ```
 [Markdown]
@@ -454,7 +459,7 @@ Figure. Highlighted cat.
 
 ### Automatic detection fallbacks
 
-`autoCaptionDetection` combined with `autoAltCaption` / `autoTitleCaption` can still generate caption text even when the original alt/title lacks labels. The corresponding attributes are cleared after conversion so the figcaption becomes the canonical source.
+`autoCaptionDetection` combined with `autoAltCaption` / `autoTitleCaption` can still generate caption text even when the original alt/title lacks labels, as long as the alt/title body is non-empty. The corresponding attributes are cleared after conversion so the figcaption becomes the canonical source. When these fallbacks are `true`, the generated label text and punctuation come from `p7d-markdown-it-p-captions` locale metadata rather than a local hardcoded map. When these fallbacks are strings, the string must be a label stem recognized as an image caption label by `p7d-markdown-it-p-captions`; invalid strings fail during plugin setup instead of producing a stray paragraph.
 
 ```
 [Markdown]
@@ -496,7 +501,7 @@ $ pwd
 
 ### Captionless conversion toggles
 
-If `oneImageWithoutCaption` is enabled, a single image paragraph will be wrapped with `<figure class="f-img">` even without a caption.
+If `imageOnlyParagraphWithoutCaption` (or the legacy alias `oneImageWithoutCaption`) is enabled, a single image paragraph will be wrapped with `<figure class="f-img">` even without a caption. Multi-image image-only paragraphs can also be wrapped, in which case the normal layout classes such as `f-img-horizontal`, `f-img-vertical`, or `f-img-multiple` are used.
 
 ```
 [Markdown]
@@ -508,7 +513,7 @@ If `oneImageWithoutCaption` is enabled, a single image paragraph will be wrapped
 </figure>
 ```
 
-If `videoWithoutCaption` is enabled, an `iframe` pointing to a known video host (such as YouTube or video elements) will be wrapped with `<figure class="f-video">`.
+If `videoWithoutCaption` is enabled, `<video>` elements and iframes pointing to known video hosts (such as `www.youtube.com`, `youtube.com`, `www.youtube-nocookie.com`, or Vimeo) will be wrapped with `<figure class="f-video">`.
 
 ```
 [Markdown]

package/embeds/detect.js

@@ -0,0 +1,182 @@
+import {
+  BLOCKQUOTE_EMBED_CLASS_NAMES,
+  HTML_EMBED_CANDIDATES,
+  VIDEO_IFRAME_HOSTS,
+} from './providers.js'
+
+const htmlRegCache = new Map()
+const openingClassAttrReg = /^<[^>]*?\bclass=(?:"([^"]*)"|'([^']*)')/i
+const openingSrcAttrReg = /^<[^>]*?\bsrc=(?:"([^"]*)"|'([^']*)')/i
+const endBlockquoteScriptReg = /<\/blockquote> *<script[^>]*?><\/script>$/i
+const targetHtmlHintReg = /<(?:video|audio|iframe|blockquote|div)\b/i
+const blueskyEmbedHintReg = /bluesky-embed/i
+const videoTagHintReg = /<video\b/i
+const audioTagHintReg = /<audio\b/i
+const iframeTagHintReg = /<iframe\b/i
+const blockquoteTagHintReg = /<blockquote\b/i
+const divTagHintReg = /<div\b/i
+const iframeTagReg = /<iframe(?=[\s>])/i
+
+const getHtmlReg = (tag) => {
+  const cached = htmlRegCache.get(tag)
+  if (cached) return cached
+  const regexStr = `^<${tag} ?[^>]*?>[\\s\\S]*?<\\/${tag}>(\\n| *?)(<script [^>]*?>(?:<\\/script>)?)? *(\\n|$)`
+  const reg = new RegExp(regexStr, 'i')
+  htmlRegCache.set(tag, reg)
+  return reg
+}
+
+const getHtmlDetectionHints = (content) => {
+  const source = typeof content === 'string' ? content : ''
+  const hasTargetHtmlHint = targetHtmlHintReg.test(source)
+  const hasBlueskyHint = blueskyEmbedHintReg.test(source)
+  if (!hasTargetHtmlHint && !hasBlueskyHint) {
+    return null
+  }
+  const hasVideoHint = videoTagHintReg.test(source)
+  const hasAudioHint = audioTagHintReg.test(source)
+  const hasIframeHint = iframeTagHintReg.test(source)
+  const hasBlockquoteHint = blockquoteTagHintReg.test(source)
+  const hasDivHint = divTagHintReg.test(source)
+  return {
+    hasBlueskyHint,
+    hasVideoHint,
+    hasAudioHint,
+    hasIframeHint,
+    hasBlockquoteHint,
+    hasDivHint,
+    hasIframeTag: hasIframeHint || (hasDivHint && iframeTagReg.test(source)),
+  }
+}
+
+const appendHtmlBlockNewlineIfNeeded = (token, hasTag) => {
+  if ((hasTag[2] && hasTag[3] !== '\n') || (hasTag[1] !== '\n' && hasTag[2] === undefined)) {
+    token.content += '\n'
+  }
+}
+
+const consumeBlockquoteEmbedScript = (tokens, token, startIndex) => {
+  let addedContent = ''
+  let i = startIndex + 1
+  while (i < tokens.length) {
+    const nextToken = tokens[i]
+    if (nextToken.type === 'inline' && endBlockquoteScriptReg.test(nextToken.content)) {
+      addedContent += nextToken.content + '\n'
+      if (tokens[i + 1] && tokens[i + 1].type === 'paragraph_close') {
+        tokens.splice(i + 1, 1)
+      }
+      nextToken.content = ''
+      if (nextToken.children) {
+        for (let j = 0; j < nextToken.children.length; j++) {
+          nextToken.children[j].content = ''
+        }
+      }
+      break
+    }
+    if (nextToken.type === 'paragraph_open') {
+      addedContent += '\n'
+      tokens.splice(i, 1)
+      continue
+    }
+    i++
+  }
+  token.content += addedContent
+}
+
+const getOpeningAttrValue = (content, reg) => {
+  if (typeof content !== 'string' || content.charCodeAt(0) !== 0x3c) return ''
+  const match = content.match(reg)
+  if (!match) return ''
+  return match[1] || match[2] || ''
+}
+
+const hasKnownBlockquoteEmbedClass = (content) => {
+  const classAttr = getOpeningAttrValue(content, openingClassAttrReg)
+  if (!classAttr) return false
+  let start = 0
+  while (start < classAttr.length) {
+    while (start < classAttr.length && classAttr.charCodeAt(start) <= 0x20) start++
+    if (start >= classAttr.length) break
+    let end = start + 1
+    while (end < classAttr.length && classAttr.charCodeAt(end) > 0x20) end++
+    if (BLOCKQUOTE_EMBED_CLASS_NAMES.has(classAttr.slice(start, end))) return true
+    start = end + 1
+  }
+  return false
+}
+
+const isKnownVideoIframe = (content) => {
+  const src = getOpeningAttrValue(content, openingSrcAttrReg)
+  if (!src || src.slice(0, 8).toLowerCase() !== 'https://') return false
+  const slashIndex = src.indexOf('/', 8)
+  const host = (slashIndex === -1 ? src.slice(8) : src.slice(8, slashIndex)).toLowerCase()
+  return VIDEO_IFRAME_HOSTS.has(host)
+}
+
+const detectHtmlTagCandidate = (tokens, token, startIndex, detector, hints, result) => {
+  if (detector.requiresIframeTag && !hints.hasIframeTag) return ''
+  const hasTagHint = !!(detector.hintKey && hints[detector.hintKey])
+  const allowBlueskyFallback = detector.candidate === 'blockquote' && hints.hasBlueskyHint
+  if (!hasTagHint && !allowBlueskyFallback) return ''
+  const hasTag = hasTagHint ? token.content.match(getHtmlReg(detector.lookupTag)) : null
+  const isBlueskyFallback = detector.candidate === 'blockquote' && !hasTag && hints.hasBlueskyHint
+  if (!hasTag && !isBlueskyFallback) return ''
+  if (hasTag) {
+    appendHtmlBlockNewlineIfNeeded(token, hasTag)
+    if (detector.treatAsVideoIframe) {
+      result.isVideoIframe = true
+    }
+    return detector.matchedTag || detector.candidate
+  }
+  consumeBlockquoteEmbedScript(tokens, token, startIndex)
+  return 'blockquote'
+}
+
+const resolveHtmlWrapWithoutCaption = (matchedTag, result, htmlWrapWithoutCaption) => {
+  if (!htmlWrapWithoutCaption) return false
+  if (matchedTag === 'blockquote') {
+    return !!(result.isIframeTypeBlockquote && htmlWrapWithoutCaption.iframeTypeBlockquote)
+  }
+  if (matchedTag === 'iframe' && result.isVideoIframe) {
+    return !!(htmlWrapWithoutCaption.video || htmlWrapWithoutCaption.iframe)
+  }
+  return !!htmlWrapWithoutCaption[matchedTag]
+}
+
+export const detectHtmlFigureCandidate = (tokens, token, startIndex, htmlWrapWithoutCaption) => {
+  if (!token || token.type !== 'html_block') return null
+  const hints = getHtmlDetectionHints(token.content)
+  if (!hints) return null
+
+  const result = {
+    isVideoIframe: false,
+    isIframeTypeBlockquote: false,
+  }
+
+  let matchedTag = ''
+  for (let i = 0; i < HTML_EMBED_CANDIDATES.length; i++) {
+    matchedTag = detectHtmlTagCandidate(tokens, token, startIndex, HTML_EMBED_CANDIDATES[i], hints, result)
+    if (matchedTag) break
+  }
+  if (!matchedTag) return null
+
+  if (matchedTag === 'blockquote') {
+    if (!hasKnownBlockquoteEmbedClass(token.content)) return null
+    result.isIframeTypeBlockquote = true
+  }
+
+  if (matchedTag === 'iframe' && isKnownVideoIframe(token.content)) {
+    result.isVideoIframe = true
+  }
+
+  return {
+    type: 'html',
+    tagName: matchedTag,
+    en: startIndex,
+    replaceInsteadOfWrap: false,
+    wrapWithoutCaption: resolveHtmlWrapWithoutCaption(matchedTag, result, htmlWrapWithoutCaption),
+    canWrap: true,
+    isVideoIframe: result.isVideoIframe,
+    isIframeTypeBlockquote: result.isIframeTypeBlockquote,
+  }
+}

package/embeds/providers.js

@@ -0,0 +1,30 @@
+export const HTML_EMBED_CANDIDATES = Object.freeze([
+  { candidate: 'video', lookupTag: 'video', hintKey: 'hasVideoHint' },
+  { candidate: 'audio', lookupTag: 'audio', hintKey: 'hasAudioHint' },
+  { candidate: 'iframe', lookupTag: 'iframe', hintKey: 'hasIframeHint' },
+  { candidate: 'blockquote', lookupTag: 'blockquote', hintKey: 'hasBlockquoteHint' },
+  {
+    candidate: 'div',
+    lookupTag: 'div',
+    hintKey: 'hasDivHint',
+    requiresIframeTag: true,
+    matchedTag: 'iframe',
+    treatAsVideoIframe: true,
+  },
+])
+
+export const BLOCKQUOTE_EMBED_CLASS_NAMES = new Set([
+  'twitter-tweet',
+  'instagram-media',
+  'text-post-media',
+  'bluesky-embed',
+  'mastodon-embed',
+])
+
+export const VIDEO_IFRAME_HOSTS = new Set([
+  'www.youtube.com',
+  'youtube.com',
+  'www.youtube-nocookie.com',
+  'youtube-nocookie.com',
+  'player.vimeo.com',
+])