@peaceroad/markdown-it-figure-with-p-caption 0.13.0 → 0.14.0

package/index.js

@@ -1,7 +1,7 @@
-import { setCaptionParagraph } from 'p7d-markdown-it-p-captions'
-import { imgAttrToPCaption, setAltToLabel, setTitleToLabel } from './imgAttrToPCaption.js'
+import { setCaptionParagraph, markReg } from 'p7d-markdown-it-p-captions'
 
 const htmlRegCache = new Map()
+const cleanCaptionRegCache = new Map()
 const classReg = /^f-(.+)$/
 const blueskyEmbedReg = /^<blockquote class="bluesky-embed"[^]*?>[\s\S]*?$/
 const videoIframeReg = /^<[^>]*? src="https:\/\/(?:www.youtube-nocookie.com|player.vimeo.com)\//i
@@ -10,9 +10,301 @@ const imageAttrsReg = /^ *\{(.*?)\} *$/
 const classAttrReg = /^\./
 const idAttrReg = /^#/
 const attrParseReg = /^(.*?)="?(.*)"?$/
-const whitespaceReg = /^ *$/
 const sampLangReg = /^ *(?:samp|shell|console)(?:(?= )|$)/
 const endBlockquoteScriptReg = /<\/blockquote> *<script[^>]*?><\/script>$/
+const imgCaptionMarkReg = markReg && markReg.img ? markReg.img : null
+const asciiLabelReg = /^[A-Za-z]/
+const trailingDigitsReg = /(\d+)\s*$/
+const CHECK_TYPE_TOKEN_MAP = {
+  table_open: 'table',
+  pre_open: 'pre',
+  blockquote_open: 'blockquote',
+}
+const HTML_TAG_CANDIDATES = ['video', 'audio', 'iframe', 'blockquote', 'div']
+const fallbackLabelDefaults = {
+  img: { en: 'Figure', ja: '図' },
+  table: { en: 'Table', ja: '表' },
+}
+
+const normalizeSetLabelNumbers = (value) => {
+  const normalized = { img: false, table: false }
+  if (!value) return normalized
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      if (normalized.hasOwnProperty(entry)) normalized[entry] = true
+    }
+    return normalized
+  }
+  return normalized
+}
+
+const buildLabelClassLookup = (opt) => {
+  const classPrefix = opt.classPrefix ? opt.classPrefix + '-' : ''
+  const defaultClasses = [classPrefix + 'label']
+  const withType = (type) => {
+    if (opt.removeMarkNameInCaptionClass) return defaultClasses
+    return [classPrefix + type + '-label', ...defaultClasses]
+  }
+  return {
+    img: withType('img'),
+    table: withType('table'),
+    default: defaultClasses,
+  }
+}
+
+const shouldApplyLabelNumbering = (captionType, opt) => {
+  const setting = opt.setLabelNumbers
+  if (!setting) return false
+  return !!setting[captionType]
+}
+
+const isOnlySpacesText = (token) => {
+  if (!token || token.type !== 'text') return false
+  const content = token.content
+  if (typeof content !== 'string') return false
+  for (let i = 0; i < content.length; i++) {
+    if (content.charCodeAt(i) !== 0x20) return false
+  }
+  return true
+}
+
+const getTokenAttr = (token, attrName) => {
+  if (!token || !token.attrs) return ''
+  for (let i = 0; i < token.attrs.length; i++) {
+    if (token.attrs[i][0] === attrName) return token.attrs[i][1] || ''
+  }
+  return ''
+}
+
+const setTokenAttr = (token, attrName, value) => {
+  if (!token) return
+  if (!token.attrs) token.attrs = []
+  for (let i = 0; i < token.attrs.length; i++) {
+    if (token.attrs[i][0] === attrName) {
+      token.attrs[i][1] = value
+      return
+    }
+  }
+  token.attrs.push([attrName, value])
+}
+
+const removeTokenAttr = (token, attrName) => {
+  if (!token || !token.attrs) return
+  for (let i = token.attrs.length - 1; i >= 0; i--) {
+    if (token.attrs[i][0] === attrName) {
+      token.attrs.splice(i, 1)
+    }
+  }
+}
+
+const clearImageAltAttr = (token) => {
+  if (!token) return
+  setTokenAttr(token, 'alt', '')
+  token.content = ''
+  if (token.children) {
+    for (let i = 0; i < token.children.length; i++) {
+      token.children[i].content = ''
+    }
+  }
+}
+
+const clearImageTitleAttr = (token) => {
+  removeTokenAttr(token, 'title')
+}
+
+const getImageAltText = (token) => {
+  let alt = getTokenAttr(token, 'alt')
+  if (alt) return alt
+  if (typeof token.content === 'string' && token.content !== '') return token.content
+  if (token.children && token.children.length > 0) {
+    return token.children.map(child => child.content || '').join('')
+  }
+  return ''
+}
+
+const getImageTitleText = (token) => getTokenAttr(token, 'title')
+
+const detectCaptionLanguage = (text) => {
+  const target = (text || '').trim()
+  if (!target) return 'en'
+  for (let i = 0; i < target.length; i++) {
+    const char = target[i]
+    const code = target.charCodeAt(i)
+    if (isJapaneseCharCode(code)) return 'ja'
+    if (isSentenceBoundaryChar(char) || char === '\n') break
+  }
+  return 'en'
+}
+
+const isJapaneseCharCode = (code) => {
+  return (
+    (code >= 0x3040 && code <= 0x30ff) || // Hiragana + Katakana
+    (code >= 0x31f0 && code <= 0x31ff) || // Katakana extensions
+    (code >= 0x4e00 && code <= 0x9fff) || // CJK Unified Ideographs
+    (code >= 0xff66 && code <= 0xff9f)    // Half-width Katakana
+  )
+}
+
+const isSentenceBoundaryChar = (char) => {
+  return char === '.' || char === '!' || char === '?' || char === '。' || char === '！' || char === '？'
+}
+
+const getAutoFallbackLabel = (text, captionType) => {
+  const type = captionType === 'table' ? 'table' : 'img'
+  const lang = detectCaptionLanguage(text)
+  const defaults = fallbackLabelDefaults[type] || fallbackLabelDefaults.img
+  if (lang === 'ja') return defaults.ja || defaults.en || ''
+  return defaults.en || defaults.ja || ''
+}
+
+const getPersistedFallbackLabel = (text, captionType, fallbackState) => {
+  const type = captionType === 'table' ? 'table' : 'img'
+  if (!fallbackState) return getAutoFallbackLabel(text, type)
+  if (fallbackState[type]) return fallbackState[type]
+  const resolved = getAutoFallbackLabel(text, type)
+  fallbackState[type] = resolved
+  return resolved
+}
+
+const buildCaptionWithFallback = (text, fallbackOption, captionType = 'img', fallbackState) => {
+  const trimmedText = (text || '').trim()
+  if (!fallbackOption) return ''
+  let label = ''
+  if (typeof fallbackOption === 'string') {
+    label = fallbackOption.trim()
+  } else if (fallbackOption === true) {
+    label = getPersistedFallbackLabel(trimmedText, captionType, fallbackState)
+  }
+  if (!label) return trimmedText
+  const isAsciiLabel = asciiLabelReg.test(label)
+  if (!trimmedText) {
+    return isAsciiLabel ? label + '.' : label
+  }
+  return label + (isAsciiLabel ? '. ' : '　') + trimmedText
+}
+
+const createAutoCaptionParagraph = (captionText, TokenConstructor) => {
+  const paragraphOpen = new TokenConstructor('paragraph_open', 'p', 1)
+  paragraphOpen.block = true
+  const inlineToken = new TokenConstructor('inline', '', 0)
+  inlineToken.block = true
+  inlineToken.content = captionText
+  const textToken = new TokenConstructor('text', '', 0)
+  textToken.content = captionText
+  inlineToken.children = [textToken]
+  const paragraphClose = new TokenConstructor('paragraph_close', 'p', -1)
+  paragraphClose.block = true
+  return [paragraphOpen, inlineToken, paragraphClose]
+}
+
+const getCaptionInlineToken = (tokens, range, caption) => {
+  if (caption.isPrev) {
+    const inlineIndex = range.start - 2
+    if (inlineIndex >= 0) return tokens[inlineIndex]
+  } else if (caption.isNext) {
+    return tokens[range.end + 2]
+  }
+  return null
+}
+
+const getInlineLabelTextToken = (inlineToken, type, opt) => {
+  if (!inlineToken || !inlineToken.children) return null
+  const children = inlineToken.children
+  const classNames = opt.labelClassLookup[type] || opt.labelClassLookup.default
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i]
+    if (!child || !child.attrs) continue
+    const classAttr = getTokenAttr(child, 'class')
+    if (!classAttr) continue
+    const classes = classAttr.split(/\s+/)
+    const matched = classNames.some(className => classes.includes(className))
+    if (!matched) continue
+    const textToken = children[i + 1]
+    if (textToken && textToken.type === 'text') {
+      return textToken
+    }
+  }
+  return null
+}
+
+const updateInlineTokenContent = (inlineToken, originalText, newText) => {
+  if (!inlineToken || typeof inlineToken.content !== 'string') return
+  if (!originalText) return
+  const index = inlineToken.content.indexOf(originalText)
+  if (index === -1) return
+  inlineToken.content =
+    inlineToken.content.slice(0, index) +
+    newText +
+    inlineToken.content.slice(index + originalText.length)
+}
+
+const ensureAutoFigureNumbering = (tokens, range, caption, figureNumberState, opt) => {
+  const captionType = caption.name === 'img' ? 'img' : (caption.name === 'table' ? 'table' : '')
+  if (!captionType) return
+  if (!shouldApplyLabelNumbering(captionType, opt)) return
+  const inlineToken = getCaptionInlineToken(tokens, range, caption)
+  if (!inlineToken) return
+  const labelTextToken = getInlineLabelTextToken(inlineToken, captionType, opt)
+  if (!labelTextToken || typeof labelTextToken.content !== 'string') return
+  const existingMatch = labelTextToken.content.match(trailingDigitsReg)
+  if (existingMatch && existingMatch[1]) {
+    const explicitValue = parseInt(existingMatch[1], 10)
+    if (!Number.isNaN(explicitValue) && explicitValue > (figureNumberState[captionType] || 0)) {
+      figureNumberState[captionType] = explicitValue
+    }
+    return
+  }
+  figureNumberState[captionType] = (figureNumberState[captionType] || 0) + 1
+  const baseLabel = labelTextToken.content.replace(/\s*\d+$/, '').trim() || labelTextToken.content.trim()
+  if (!baseLabel) return
+  const joint = asciiLabelReg.test(baseLabel) ? ' ' : ''
+  const newLabelText = baseLabel + joint + figureNumberState[captionType]
+  const originalText = labelTextToken.content
+  labelTextToken.content = newLabelText
+  updateInlineTokenContent(inlineToken, originalText, newLabelText)
+}
+
+const getAutoCaptionFromImage = (imageToken, opt, fallbackLabelState) => {
+  if (!opt.autoCaptionDetection) return ''
+  const tryMatch = (text) => {
+    if (!text) return ''
+    const trimmed = text.trim()
+    if (trimmed && imgCaptionMarkReg && trimmed.match(imgCaptionMarkReg)) {
+      return trimmed
+    }
+    return ''
+  }
+
+  const altText = getImageAltText(imageToken)
+  let caption = tryMatch(altText)
+  if (caption) {
+    clearImageAltAttr(imageToken)
+    return caption
+  }
+  if (!caption && opt.autoAltCaption) {
+    const altForFallback = altText || ''
+    caption = buildCaptionWithFallback(altForFallback, opt.autoAltCaption, 'img', fallbackLabelState)
+    if (imageToken) {
+      clearImageAltAttr(imageToken)
+    }
+  }
+  if (caption) return caption
+
+  const titleText = getImageTitleText(imageToken)
+  caption = tryMatch(titleText)
+  if (caption) {
+    clearImageTitleAttr(imageToken)
+    return caption
+  }
+  if (!caption && opt.autoTitleCaption) {
+    const titleForFallback = titleText || ''
+    caption = buildCaptionWithFallback(titleForFallback, opt.autoTitleCaption, 'img', fallbackLabelState)
+    if (imageToken) {
+      clearImageTitleAttr(imageToken)
+    }
+  }
+  return caption
+}
 
 const getHtmlReg = (tag) => {
   if (htmlRegCache.has(tag)) return htmlRegCache.get(tag)
@@ -40,7 +332,7 @@ const checkPrevCaption = (tokens, n, caption, fNum, sp, opt, TokenConstructor) =
   const captionStartToken = tokens[n-3]
   const captionEndToken = tokens[n-1]
   if (captionStartToken === undefined || captionEndToken === undefined) return
-  if (captionStartToken.type !== 'paragraph_open' && captionEndToken.type !== 'paragraph_close') return
+  if (captionStartToken.type !== 'paragraph_open' || captionEndToken.type !== 'paragraph_close') return
   setCaptionParagraph(n-3, { tokens, Token: TokenConstructor }, caption, fNum, sp, opt)
   const captionName = getCaptionName(captionStartToken)
   if(!captionName) return
@@ -54,7 +346,7 @@ const checkNextCaption = (tokens, en, caption, fNum, sp, opt, TokenConstructor)
   const captionStartToken = tokens[en+1]
   const captionEndToken = tokens[en+3]
   if (captionStartToken === undefined || captionEndToken === undefined) return
-  if (captionStartToken.type !== 'paragraph_open' && captionEndToken.type !== 'paragraph_close') return
+  if (captionStartToken.type !== 'paragraph_open' || captionEndToken.type !== 'paragraph_close') return
   setCaptionParagraph(en+1, { tokens, Token: TokenConstructor }, caption, fNum, sp, opt)
   const captionName = getCaptionName(captionStartToken)
   if(!captionName) return
@@ -63,8 +355,6 @@ const checkNextCaption = (tokens, en, caption, fNum, sp, opt, TokenConstructor)
   return
 }
 
-const cleanCaptionRegCache = new Map()
-
 const cleanCaptionTokenAttrs = (token, captionName) => {
   if (!token.attrs) return
   let reg = cleanCaptionRegCache.get(captionName)
@@ -80,28 +370,44 @@ const cleanCaptionTokenAttrs = (token, captionName) => {
   }
 }
 
-const changePrevCaptionPosition = (tokens, n, caption, opt) => {
-  const captionStartToken = tokens[n-3]
-  const captionInlineToken = tokens[n-2]
-  const captionEndToken = tokens[n-1]
-
-  if (opt.imgAltCaption || opt.imgTitleCaption) {
-    let isNoCaption = false
-    if (captionInlineToken.attrs) {
-      const attrs = captionInlineToken.attrs, len = attrs.length
-      for (let i = 0; i < len; i++) {
-        const attr = attrs[i]
-        if (attr[0] === 'class' && attr[1] === 'nocaption') {
-          isNoCaption = true
-          break
-        }
+const resolveFigureClassName = (checkTokenTagName, caption, sp, opt) => {
+  let className = 'f-' + checkTokenTagName
+  if (opt.allIframeTypeFigureClassName === '') {
+    if (sp.isVideoIframe) {
+      className = 'f-video'
+    }
+    if (sp.isIframeTypeBlockquote) {
+      let figureClassThatWrapsIframeTypeBlockquote = opt.figureClassThatWrapsIframeTypeBlockquote
+      if ((caption.isPrev || caption.isNext) &&
+        figureClassThatWrapsIframeTypeBlockquote === 'f-img' &&
+        (caption.name === 'blockquote' || caption.name === 'img')) {
+        figureClassThatWrapsIframeTypeBlockquote = 'f-img'
       }
+      className = figureClassThatWrapsIframeTypeBlockquote
     }
-    if (isNoCaption) {
-      tokens.splice(n-3, 3)
-      return false
+  } else {
+    if (checkTokenTagName === 'iframe' || sp.isIframeTypeBlockquote) {
+      className = opt.allIframeTypeFigureClassName
     }
   }
+  return className
+}
+
+const applyCaptionDrivenFigureClass = (caption, sp, opt) => {
+  if (!sp) return
+  const figureClassForSlides = opt.figureClassThatWrapsSlides
+  if (!figureClassForSlides) return
+  const detectedMark = (sp.captionDecision && sp.captionDecision.mark) || (caption && caption.name) || ''
+  if (detectedMark !== 'slide') return
+  if (opt.allIframeTypeFigureClassName && sp.figureClassName === opt.allIframeTypeFigureClassName) return
+  sp.figureClassName = figureClassForSlides
+}
+
+
+const changePrevCaptionPosition = (tokens, n, caption, opt) => {
+  const captionStartToken = tokens[n-3]
+  const captionInlineToken = tokens[n-2]
+  const captionEndToken = tokens[n-1]
 
   cleanCaptionTokenAttrs(captionStartToken, caption.name)
   captionStartToken.type = 'figcaption_open'
@@ -113,7 +419,7 @@ const changePrevCaptionPosition = (tokens, n, caption, opt) => {
   return true
 }
 
-const changeNextCaptionPosition = (tokens, en, caption) => {
+const changeNextCaptionPosition = (tokens, en, caption, opt) => {
   const captionStartToken = tokens[en+2] // +1: text node for figure.
   const captionInlineToken = tokens[en+3]
   const captionEndToken = tokens[en+4]
@@ -131,29 +437,8 @@ const wrapWithFigure = (tokens, range, checkTokenTagName, caption, replaceInstea
   let n = range.start
   let en = range.end
   const figureStartToken = new TokenConstructor('figure_open', 'figure', 1)
-  figureStartToken.attrSet('class', 'f-' + checkTokenTagName)
-
-  if (opt.allIframeTypeFigureClassName === '') {
-    if (sp.isVideoIframe) {
-      figureStartToken.attrSet('class', 'f-video')
-    }
-    if (sp.isIframeTypeBlockquote) {
-      let figureClassThatWrapsIframeTypeBlockquote = 'i-frame'
-      if (caption.isPrev || caption.isNext) {
-        if (caption.name === 'blockquote' || caption.name === 'img') {
-          figureClassThatWrapsIframeTypeBlockquote = 'f-img'
-        }
-        figureStartToken.attrSet('class', figureClassThatWrapsIframeTypeBlockquote)
-      } else {
-        figureClassThatWrapsIframeTypeBlockquote = opt.figureClassThatWrapsIframeTypeBlockquote
-        figureStartToken.attrSet('class', figureClassThatWrapsIframeTypeBlockquote)
-      }
-    }
-  } else {
-    if (checkTokenTagName === 'iframe' || sp.isIframeTypeBlockquote) {
-      figureStartToken.attrSet('class', opt.allIframeTypeFigureClassName)
-    }
-  }
+  const figureClassName = sp.figureClassName || resolveFigureClassName(checkTokenTagName, caption, sp, opt)
+  figureStartToken.attrSet('class', figureClassName)
 
   if(/pre-(?:code|samp)/.test(checkTokenTagName) && opt.roleDocExample) {
     figureStartToken.attrSet('role', 'doc-example')
@@ -193,51 +478,256 @@ const checkCaption = (tokens, n, en, caption, fNum, sp, opt, TokenConstructor) =
   return
 }
 
-const processTokensRecursively = (tokens, opt, fNum, TokenConstructor, parentType) => {
-  const nestedContainers = ['blockquote', 'list_item', 'dd']
+const nestedContainers = ['blockquote', 'list_item', 'dd']
+
+const getNestedContainerType = (token) => {
+  if (!token || token.type.indexOf('_open') === -1) return null
+  const typeName = token.type.replace('_open', '')
+  if (nestedContainers.includes(typeName)) {
+    return typeName
+  }
+  return null
+}
+
+const resetRangeState = (range, start) => {
+  range.start = start
+  range.end = start
+}
+
+const resetCaptionState = (caption) => {
+  caption.mark = ''
+  caption.name = ''
+  caption.nameSuffix = ''
+  caption.isPrev = false
+  caption.isNext = false
+}
 
-  figureWithCaptionCore(tokens, opt, fNum, TokenConstructor, parentType)
+const resetSpecialState = (sp) => {
+  sp.attrs.length = 0
+  sp.isVideoIframe = false
+  sp.isIframeTypeBlockquote = false
+  sp.hasImgCaption = false
+  sp.figureClassName = ''
+  sp.captionDecision = null
+}
 
-  const nestedRanges = []
-  let i = 0
+const findClosingTokenIndex = (tokens, startIndex, tag) => {
+  let depth = 1
+  let i = startIndex + 1
   while (i < tokens.length) {
     const token = tokens[i]
-    let containerType = null
-    for (const container of nestedContainers) {
-      if (token.type === `${container}_open`) {
-        containerType = container
-        break
-      }
+    if (token.type === `${tag}_open`) depth++
+    if (token.type === `${tag}_close`) {
+      depth--
+      if (depth === 0) return i
     }
-    if (containerType) {
-      let depth = 1
-      let endIndex = i + 1
-      while (endIndex < tokens.length && depth > 0) {
-        if (tokens[endIndex].type === `${containerType}_open`) depth++
-        if (tokens[endIndex].type === `${containerType}_close`) depth--
-        endIndex++
+    i++
+  }
+  return startIndex
+}
+
+const detectCheckTypeOpen = (tokens, token, n, caption) => {
+  if (!token) return null
+  const baseType = CHECK_TYPE_TOKEN_MAP[token.type]
+  if (!baseType) return null
+  if (n > 1 && tokens[n - 2] && tokens[n - 2].type === 'figure_open') return null
+  let tagName = token.tag
+  caption.name = baseType
+  if (baseType === 'pre') {
+    if (tokens[n + 1] && tokens[n + 1].tag === 'code') caption.mark = 'pre-code'
+    if (tokens[n + 1] && tokens[n + 1].tag === 'samp') caption.mark = 'pre-samp'
+    caption.name = caption.mark
+  }
+  const en = findClosingTokenIndex(tokens, n, tagName)
+  return {
+    type: 'block',
+    tagName,
+    en,
+    replaceInsteadOfWrap: false,
+    wrapWithoutCaption: false,
+    canWrap: true,
+  }
+}
+
+const detectFenceToken = (token, n, caption) => {
+  if (!token || token.type !== 'fence' || token.tag !== 'code' || !token.block) return null
+  let tagName = 'pre-code'
+  if (sampLangReg.test(token.info)) {
+    token.tag = 'samp'
+    tagName = 'pre-samp'
+  }
+  caption.name = tagName
+  return {
+    type: 'fence',
+    tagName,
+    en: n,
+    replaceInsteadOfWrap: false,
+    wrapWithoutCaption: false,
+    canWrap: true,
+  }
+}
+
+const detectHtmlBlockToken = (tokens, token, n, caption, sp, opt) => {
+  if (!token || token.type !== 'html_block') return null
+  const blueskyContMatch = token.content.match(blueskyEmbedReg)
+  let matchedTag = ''
+  for (let i = 0; i < HTML_TAG_CANDIDATES.length; i++) {
+    const candidate = HTML_TAG_CANDIDATES[i]
+    const treatDivAsIframe = candidate === 'div'
+    const lookupTag = treatDivAsIframe ? 'div' : candidate
+    const hasTag = token.content.match(getHtmlReg(lookupTag))
+    const isBlueskyBlockquote = !hasTag && blueskyContMatch && candidate === 'blockquote'
+    if (!(hasTag || isBlueskyBlockquote)) continue
+    if (hasTag) {
+      if ((hasTag[2] && hasTag[3] !== '\n') || (hasTag[1] !== '\n' && hasTag[2] === undefined)) {
+        token.content += '\n'
       }
-      if (depth === 0 && endIndex - i > 2) {
-        nestedRanges.push({
-          start: i + 1,
-          end: endIndex - 1,
-          type: containerType
-        })
+      matchedTag = treatDivAsIframe ? 'iframe' : candidate
+      if (treatDivAsIframe) {
+        sp.isVideoIframe = true
       }
-      i = endIndex
     } else {
-      i++
+      let addedCont = ''
+      const tokensLength = tokens.length
+      let j = n + 1
+      while (j < tokensLength) {
+        const nextToken = tokens[j]
+        if (nextToken.type === 'inline' && endBlockquoteScriptReg.test(nextToken.content)) {
+          addedCont += nextToken.content + '\n'
+          if (tokens[j + 1] && tokens[j + 1].type === 'paragraph_close') {
+            tokens.splice(j + 1, 1)
+          }
+          nextToken.content = ''
+          nextToken.children.forEach((child) => {
+            child.content = ''
+          })
+          break
+        }
+        if (nextToken.type === 'paragraph_open') {
+          addedCont += '\n'
+          tokens.splice(j, 1)
+          continue
+        }
+        j++
+      }
+      token.content += addedCont
+      matchedTag = 'blockquote'
+    }
+    break
+  }
+  if (!matchedTag) return null
+  if (matchedTag === 'blockquote') {
+    const isIframeTypeBlockquote = token.content.match(classNameReg)
+    if (isIframeTypeBlockquote) {
+      sp.isIframeTypeBlockquote = true
+    } else {
+      return null
     }
   }
+  if (matchedTag === 'iframe' && videoIframeReg.test(token.content)) {
+    sp.isVideoIframe = true
+  }
+  caption.name = matchedTag
+  let wrapWithoutCaption = false
+  if (matchedTag === 'iframe' && opt.iframeWithoutCaption) {
+    wrapWithoutCaption = true
+  } else if (matchedTag === 'video' && opt.videoWithoutCaption) {
+    wrapWithoutCaption = true
+  } else if (matchedTag === 'audio' && opt.audioWithoutCaption) {
+    wrapWithoutCaption = true
+  } else if (matchedTag === 'blockquote' && sp.isIframeTypeBlockquote && opt.iframeTypeBlockquoteWithoutCaption) {
+    wrapWithoutCaption = true
+  }
+  return {
+    type: 'html',
+    tagName: matchedTag,
+    en: n,
+    replaceInsteadOfWrap: false,
+    wrapWithoutCaption,
+    canWrap: true,
+  }
+}
 
-  for (let j = nestedRanges.length - 1; j >= 0; j--) {
-    const range = nestedRanges[j]
-    const innerTokens = tokens.slice(range.start, range.end)
-    if (innerTokens.length > 0) {
-      processTokensRecursively(innerTokens, opt, fNum, TokenConstructor, range.type)
-      tokens.splice(range.start, range.end - range.start, ...innerTokens)
+const detectImageParagraph = (tokens, token, nextToken, n, caption, sp, opt) => {
+  if (!token || token.type !== 'paragraph_open') return null
+  if (!nextToken || nextToken.type !== 'inline' || !nextToken.children || nextToken.children.length === 0) return null
+  if (nextToken.children[0].type !== 'image') return null
+
+  let imageNum = 1
+  let isMultipleImagesHorizontal = true
+  let isMultipleImagesVertical = true
+  let isValid = true
+  caption.name = 'img'
+  const children = nextToken.children
+  const childrenLength = children.length
+  for (let childIndex = 1; childIndex < childrenLength; childIndex++) {
+    const child = children[childIndex]
+    if (childIndex === childrenLength - 1 && child.type === 'text') {
+      let imageAttrs = child.content && child.content.match(imageAttrsReg)
+      if (imageAttrs) {
+        imageAttrs = imageAttrs[1].split(/ +/)
+        for (let i = 0; i < imageAttrs.length; i++) {
+          if (classAttrReg.test(imageAttrs[i])) {
+            imageAttrs[i] = imageAttrs[i].replace(classAttrReg, 'class=')
+          }
+          if (idAttrReg.test(imageAttrs[i])) {
+            imageAttrs[i] = imageAttrs[i].replace(idAttrReg, 'id=')
+          }
+          const imageAttr = imageAttrs[i].match(attrParseReg)
+          if (!imageAttr || !imageAttr[1]) continue
+          sp.attrs.push([imageAttr[1], imageAttr[2]])
+        }
+        break
+      }
+    }
+
+    if (!opt.multipleImages) {
+      isValid = false
+      break
+    }
+    if (child.type === 'image') {
+      imageNum++
+      continue
+    }
+    if (isOnlySpacesText(child)) {
+      isMultipleImagesVertical = false
+      continue
+    }
+    if (child.type === 'softbreak') {
+      isMultipleImagesHorizontal = false
+      continue
+    }
+    isValid = false
+    break
+  }
+  if (isValid && imageNum > 1 && opt.multipleImages) {
+    if (isMultipleImagesHorizontal) {
+      caption.nameSuffix = '-horizontal'
+    } else if (isMultipleImagesVertical) {
+      caption.nameSuffix = '-vertical'
+    } else {
+      caption.nameSuffix = '-multiple'
+    }
+    for (let i = 0; i < childrenLength; i++) {
+      const child = children[i]
+      if (isOnlySpacesText(child)) {
+        child.content = ''
+      }
     }
   }
+  nextToken.children[0].type = 'image'
+  const en = n + 2
+  let tagName = 'img'
+  if (caption.nameSuffix) tagName += caption.nameSuffix
+  return {
+    type: 'image',
+    tagName,
+    en,
+    replaceInsteadOfWrap: true,
+    wrapWithoutCaption: isValid && !!opt.oneImageWithoutCaption,
+    canWrap: isValid,
+    imageToken: children[0]
+  }
 }
 
 const figureWithCaption = (state, opt) => {
@@ -246,302 +736,147 @@ const figureWithCaption = (state, opt) => {
     table: 0,
   }
 
-  processTokensRecursively(state.tokens, opt, fNum, state.Token, null)
-}
+  const figureNumberState = {
+    img: 0,
+    table: 0,
+  }
+
+  const fallbackLabelState = {
+    img: null,
+    table: null,
+  }
 
-const figureWithCaptionCore = (tokens, opt, fNum, TokenConstructor, parentType) => {
-  const checkTypes = ['table', 'pre', 'blockquote']
-  const htmlTags = ['video', 'audio', 'iframe', 'blockquote', 'div']
+  figureWithCaptionCore(state.tokens, opt, fNum, figureNumberState, fallbackLabelState, state.Token, null, 0)
+}
 
-  const rRange = { start: 0, end: 0 }
+const figureWithCaptionCore = (tokens, opt, fNum, figureNumberState, fallbackLabelState, TokenConstructor, parentType = null, startIndex = 0) => {
+  const rRange = { start: startIndex, end: startIndex }
   const rCaption = {
     mark: '', name: '', nameSuffix: '', isPrev: false, isNext: false
   }
   const rSp = {
-    attrs: [], isVideoIframe: false, isIframeTypeBlockquote: false, hasImgCaption: false
+    attrs: [], isVideoIframe: false, isIframeTypeBlockquote: false, hasImgCaption: false, captionDecision: null
   }
 
-  let n = 0
+  let n = startIndex
   while (n < tokens.length) {
     const token = tokens[n]
-    const nextToken = tokens[n+1]
-    let en = n
-
-    rRange.start = n
-    rRange.end = en
-    let checkToken = false
-    let checkTokenTagName = ''
-    rCaption.mark = ''
-    rCaption.name = ''
-    rCaption.nameSuffix = ''
-    rCaption.isPrev = false
-    rCaption.isNext = false
-
-    rSp.attrs.length = 0
-    rSp.isVideoIframe = false
-    rSp.isIframeTypeBlockquote = false
-    rSp.hasImgCaption = false
-
-    let cti = 0
-    while (cti < checkTypes.length) {
-      if (token.type === checkTypes[cti] + '_open') {
-        // for n-1 token is line-break
-        if (n > 1 && tokens[n-2].type === 'figure_open') {
-          cti++; continue
-        }
-        checkToken = true
-        checkTokenTagName = token.tag
-        rCaption.name = checkTypes[cti]
-        if (checkTypes[cti] === 'pre') {
-          if (tokens[n+1].tag === 'code') rCaption.mark = 'pre-code'
-          if (tokens[n+1].tag === 'samp') rCaption.mark = 'pre-samp'
-          rCaption.name = rCaption.mark
-        }
-        while (en < tokens.length) {
-          if(tokens[en].type === checkTokenTagName + '_close') {
-            break
-          }
-          en++
-        }
-        rRange.end = en
-        checkCaption(tokens, n, en, rCaption, fNum, rSp, opt, TokenConstructor)
-        if (rCaption.isPrev || rCaption.isNext) {
-          wrapWithFigure(tokens, rRange, checkTokenTagName, rCaption, false, rSp, opt, TokenConstructor)
-        }
-        break
-      }
+    const containerType = getNestedContainerType(token)
 
-      if (token.type === 'fence') {
-        if (token.tag === 'code' && token.block) {
-          checkToken = true
-          let isSamp = false
-          if (sampLangReg.test(token.info)) {
-            token.tag = 'samp'
-            isSamp = true
-          }
-          if (isSamp) {
-            checkTokenTagName = 'pre-samp'
-            rCaption.name = 'pre-samp'
-          } else {
-            checkTokenTagName = 'pre-code'
-            rCaption.name = 'pre-code'
-          }
-          checkCaption(tokens, n, en, rCaption, fNum, rSp, opt, TokenConstructor)
-          if (rCaption.isPrev || rCaption.isNext) {
-            wrapWithFigure(tokens, rRange, checkTokenTagName, rCaption, false, rSp, opt, TokenConstructor)
-            break
-          }
-        }
-        break
-      }
-      cti++
-    }
-
-    if (token.type === 'html_block') {
-      let ctj = 0
-      let hasTag
-      while (ctj < htmlTags.length) {
-        if (htmlTags[ctj] === 'div') {
-          // for vimeo
-          hasTag = token.content.match(getHtmlReg('div'))
-          htmlTags[ctj] = 'iframe'
-          rSp.isVideoIframe = true
-        } else {
-          hasTag = token.content.match(getHtmlReg(htmlTags[ctj]))
-        }
-        const blueskyContMatch = token.content.match(blueskyEmbedReg)
-        if (!(hasTag || (blueskyContMatch && htmlTags[ctj] === 'blockquote'))) {
-          ctj++
-          continue
-        }
-        if (hasTag) {
-          if ((hasTag[2] && hasTag[3] !== '\n') || (hasTag[1] !== '\n' && hasTag[2] === undefined)) {
-            token.content += '\n'
-          }
-        } else if (blueskyContMatch) {
-          let addedCont = ''
-          const tokensChildren = tokens
-          const tokensLength = tokensChildren.length
-          let j = n + 1
-          let hasEndBlockquote = true
-          while (j < tokensLength) {
-            const nextToken = tokens[j]
-            if (nextToken.type === 'inline' && endBlockquoteScriptReg.test(nextToken.content)) {
-              addedCont += nextToken.content + '\n'
-              if (tokens[j + 1] && tokens[j + 1].type === 'paragraph_close') {
-                tokens.splice(j + 1, 1)
-              }
-              nextToken.content = ''
-              nextToken.children.forEach((child) => {
-                child.content = ''
-              })
-              break
-            }
-            if (nextToken.type === 'paragraph_open') {
-              addedCont += '\n'
-              tokens.splice(j, 1)
-              continue
-            }
-            j++
-          }
-          token.content += addedCont
-          if (!hasEndBlockquote) {
-            ctj++
-            continue
-          }
-        }
+    if (containerType && containerType !== 'blockquote') {
+      const closeIndex = figureWithCaptionCore(tokens, opt, fNum, figureNumberState, fallbackLabelState, TokenConstructor, containerType, n + 1)
+      n = (typeof closeIndex === 'number' ? closeIndex : n) + 1
+      continue
+    }
 
-        checkTokenTagName = htmlTags[ctj]
-        rCaption.name = htmlTags[ctj]
-        checkToken = true
-        if (checkTokenTagName === 'blockquote') {
-          const isIframeTypeBlockquote = token.content.match(classNameReg)
-          if(isIframeTypeBlockquote) {
-            rSp.isIframeTypeBlockquote = true
-          } else {
-            ctj++
-            continue
-          }
-        }
-        break
-      }
-      if (!checkToken) {n++; continue;}
-      if (checkTokenTagName === 'iframe') {
-        if(videoIframeReg.test(token.content)) {
-          rSp.isVideoIframe = true
-        }
-      }
 
-      checkCaption(tokens, n, en, rCaption, fNum, rSp, opt, TokenConstructor)
-      if (rCaption.isPrev || rCaption.isNext) {
-        wrapWithFigure(tokens, rRange, checkTokenTagName, rCaption, false, rSp, opt, TokenConstructor)
-        n = en + 2
-      } else if ((opt.iframeWithoutCaption && (checkTokenTagName === 'iframe')) ||
-        (opt.videoWithoutCaption && (checkTokenTagName === 'video')) ||
-        (opt.iframeTypeBlockquoteWithoutCaption && (checkTokenTagName === 'blockquote'))) {
-        wrapWithFigure(tokens, rRange, checkTokenTagName, rCaption, false, rSp, opt, TokenConstructor)
-        n = en + 2
+    if (parentType && token.type === `${parentType}_close`) {
+      return n
+    }
+
+    const nextToken = tokens[n + 1]
+    resetRangeState(rRange, n)
+    resetCaptionState(rCaption)
+    resetSpecialState(rSp)
+
+    const detection =
+      detectCheckTypeOpen(tokens, token, n, rCaption) ||
+      detectFenceToken(token, n, rCaption) ||
+      detectHtmlBlockToken(tokens, token, n, rCaption, rSp, opt) ||
+      detectImageParagraph(tokens, token, nextToken, n, rCaption, rSp, opt)
+
+    if (!detection) {
+      if (containerType === 'blockquote') {
+      const closeIndex = figureWithCaptionCore(tokens, opt, fNum, figureNumberState, fallbackLabelState, TokenConstructor, containerType, n + 1)
+        n = (typeof closeIndex === 'number' ? closeIndex : n) + 1
+      } else {
+        n++
       }
+      continue
     }
 
-    if (token.type === 'paragraph_open' && nextToken.type === 'inline' && nextToken.children[0].type === 'image') {
-      let ntChildTokenIndex = 1
-      let imageNum = 1
-      let isMultipleImagesHorizontal = true
-      let isMultipleImagesVertical = true
-      checkToken = true
-      rCaption.name = 'img'
-      const children = nextToken.children
-      const childrenLength = children.length
-      while (ntChildTokenIndex < childrenLength) {
-        const ntChildToken = children[ntChildTokenIndex]
-        if (ntChildTokenIndex === childrenLength - 1) {
-          let imageAttrs = ntChildToken.content.match(imageAttrsReg)
-          if(ntChildToken.type === 'text' && imageAttrs) {
-            imageAttrs = imageAttrs[1].split(/ +/)
-            let iai = 0
-            const attrsLength = imageAttrs.length
-            while (iai < attrsLength) {
-              if (classAttrReg.test(imageAttrs[iai])) {
-                imageAttrs[iai] = imageAttrs[iai].replace(classAttrReg, "class=")
-              }
-              if (idAttrReg.test(imageAttrs[iai])) {
-                imageAttrs[iai] = imageAttrs[iai].replace(idAttrReg, "id=")
-              }
-              let imageAttr = imageAttrs[iai].match(attrParseReg)
-              if (!imageAttr || !imageAttr[1]) {
-                iai++
-                continue
-              }
-              rSp.attrs.push([imageAttr[1], imageAttr[2]])
-              iai++
-            }
-            break
-          }
-        }
+    rRange.end = detection.en
 
-        if (!opt.multipleImages) {
-          checkToken = false
-          break
-        }
-        if (ntChildToken.type === 'image') {
-          imageNum += 1
-        } else if (ntChildToken.type === 'text' && whitespaceReg.test(ntChildToken.content)) {
-          isMultipleImagesVertical = false
-          if (isMultipleImagesVertical) {
-            isMultipleImagesHorizontal = false
-          }
-        } else if (ntChildToken.type === 'softbreak') {
-          isMultipleImagesHorizontal = false
-          if (isMultipleImagesHorizontal) {
-            isMultipleImagesVertical = false
-          }
-        } else {
-          checkToken = false
-          break
-        }
-        ntChildTokenIndex++
-      }
-      if (checkToken && imageNum > 1 && opt.multipleImages) {
-        if (isMultipleImagesHorizontal) {
-          rCaption.nameSuffix = '-horizontal'
-        } else if (isMultipleImagesVertical) {
-          rCaption.nameSuffix = '-vertical'
-        } else {
-          rCaption.nameSuffix = '-multiple'
-        }
-        ntChildTokenIndex = 0
-        while (ntChildTokenIndex < childrenLength) {
-          const ccToken = children[ntChildTokenIndex]
-          if (ccToken.type === 'text' && whitespaceReg.test(ccToken.content)) {
-            ccToken.content = ''
-          }
-          ntChildTokenIndex++
-        }
+    rSp.figureClassName = resolveFigureClassName(detection.tagName, rCaption, rSp, opt)
+    checkCaption(tokens, rRange.start, rRange.end, rCaption, fNum, rSp, opt, TokenConstructor)
+    applyCaptionDrivenFigureClass(rCaption, rSp, opt)
+
+    let hasCaption = rCaption.isPrev || rCaption.isNext
+    let pendingAutoCaption = ''
+    if (!hasCaption && detection.type === 'image' && opt.autoCaptionDetection) {
+      pendingAutoCaption = getAutoCaptionFromImage(detection.imageToken, opt, fallbackLabelState)
+      if (pendingAutoCaption) {
+        hasCaption = true
       }
-      en = n + 2
-      rRange.end = en
-      checkTokenTagName = 'img'
-      nextToken.children[0].type = 'image'
+    }
 
-      if (opt.imgAltCaption) setAltToLabel({ tokens, Token: TokenConstructor }, n)
-      if (opt.imgTitleCaption) setTitleToLabel({ tokens, Token: TokenConstructor }, n)
-      checkCaption(tokens, n, en, rCaption, fNum, rSp, opt, TokenConstructor)
+    if (detection.canWrap === false) {
+      let nextIndex = rRange.end + 1
+      if (containerType === 'blockquote') {
+        const closeIndex = figureWithCaptionCore(tokens, opt, fNum, figureNumberState, fallbackLabelState, TokenConstructor, containerType, rRange.start + 1)
+        nextIndex = Math.max(nextIndex, (typeof closeIndex === 'number' ? closeIndex : rRange.end) + 1)
+      }
+      n = nextIndex
+      continue
+    }
 
+    let shouldWrap = false
+    if (detection.type === 'html') {
+      shouldWrap = detection.canWrap !== false && (hasCaption || detection.wrapWithoutCaption)
+    } else if (detection.type === 'image') {
+      shouldWrap = detection.canWrap !== false && (hasCaption || detection.wrapWithoutCaption)
       if (parentType === 'list_item' || isInListItem(tokens, n)) {
         const isInTightList = token.hidden === true
         if (isInTightList) {
-          checkToken = false
-        } else {
-          if (!opt.oneImageWithoutCaption && !rCaption.isPrev && !rCaption.isNext) {
-            checkToken = false
-          }
+          shouldWrap = false
+        } else if (!hasCaption && !opt.oneImageWithoutCaption) {
+          shouldWrap = false
         }
       }
+    } else {
+      shouldWrap = detection.canWrap !== false && hasCaption
+    }
 
-      if (checkToken && (opt.oneImageWithoutCaption || rCaption.isPrev || rCaption.isNext)) {
-        if (rCaption.nameSuffix) checkTokenTagName += rCaption.nameSuffix
-        wrapWithFigure(tokens, rRange, checkTokenTagName, rCaption, true, rSp, opt, TokenConstructor)
+    if (shouldWrap) {
+      if (pendingAutoCaption) {
+        const captionTokens = createAutoCaptionParagraph(pendingAutoCaption, TokenConstructor)
+        tokens.splice(rRange.start, 0, ...captionTokens)
+        const insertedLength = captionTokens.length
+        rRange.start += insertedLength
+        rRange.end += insertedLength
+        n += insertedLength
+        checkCaption(tokens, rRange.start, rRange.end, rCaption, fNum, rSp, opt, TokenConstructor)
+        applyCaptionDrivenFigureClass(rCaption, rSp, opt)
       }
+      ensureAutoFigureNumbering(tokens, rRange, rCaption, figureNumberState, opt)
+      wrapWithFigure(tokens, rRange, detection.tagName, rCaption, detection.replaceInsteadOfWrap, rSp, opt, TokenConstructor)
     }
 
-    if (!checkToken || !rCaption.name) {n++; continue;}
-
-    n = rRange.start
-    en = rRange.end
-    if (rCaption.isPrev) {
-      changePrevCaptionPosition(tokens, n, rCaption, opt)
-      n = en + 1
-      continue
+    let nextIndex
+    if (!rCaption.name) {
+      nextIndex = n + 1
+    } else {
+      const en = rRange.end
+      if (rCaption.isPrev) {
+        changePrevCaptionPosition(tokens, rRange.start, rCaption, opt)
+        nextIndex = en + 1
+      } else if (rCaption.isNext) {
+        changeNextCaptionPosition(tokens, en, rCaption)
+        nextIndex = en + 4
+      } else {
+        nextIndex = en + 1
+      }
     }
-    if (rCaption.isNext) {
-      changeNextCaptionPosition(tokens, en, rCaption)
-      n = en + 4
-      continue
+
+    if (containerType === 'blockquote') {
+      const closeIndex = figureWithCaptionCore(tokens, opt, fNum, figureNumberState, fallbackLabelState, TokenConstructor, containerType, rRange.start + 1)
+      const fallbackIndex = rCaption.name ? rRange.end : n
+      nextIndex = Math.max(nextIndex, (typeof closeIndex === 'number' ? closeIndex : fallbackIndex) + 1)
     }
-    n = en + 1
+
+    n = nextIndex
   }
-  return
+  return tokens.length
 }
 
 const isInListItem = (() => {
@@ -576,44 +911,53 @@ const isInListItem = (() => {
 
 const mditFigureWithPCaption = (md, option) => {
   let opt = {
+    // --- figure-wrapper behavior ---
     classPrefix: 'f',
     figureClassThatWrapsIframeTypeBlockquote: 'f-img',
+    figureClassThatWrapsSlides: 'f-slide',
     styleProcess : true,
+    oneImageWithoutCaption: false,
+    iframeWithoutCaption: false,
+    videoWithoutCaption: false,
+    audioWithoutCaption: false,
+    iframeTypeBlockquoteWithoutCaption: false,
+    multipleImages: true,
+    roleDocExample: false,
+    allIframeTypeFigureClassName: '', // e.g. 'f-embed' to force a single class for iframe-like embeds (recommended)
+
+    // --- automatic caption detection heuristics ---
+    // Applies only to the first image within an image-only paragraph (even when multipleImages is true).
+    // Priority: caption paragraphs (before/after) > alt text > title attribute; auto detection only runs when no paragraph caption exists.
+    autoCaptionDetection: true,
+    autoAltCaption: false, // allow alt text (when matching markReg.img or fallback) to build captions automatically
+    autoTitleCaption: false, // same as above but reads from the title attribute when alt isn't usable
+
+    // --- numbering controls ---
+    autoLabelNumber: false, // shorthand for enabling numbering for both img/table unless setLabelNumbers is provided explicitly
+    setLabelNumbers: [], // preferred; supports ['img'], ['table'], or both
+
+    // --- caption text formatting (delegated to p7d-markdown-it-p-captions) ---
     hasNumClass: false,
-    scaleSuffix: false,
     dquoteFilename: false,
     strongFilename: false,
     bLabel: false,
     strongLabel: false,
     jointSpaceUseHalfWidth: false,
-    oneImageWithoutCaption: false,
-    iframeWithoutCaption: false,
-    videoWithoutCaption: false,
-    iframeTypeBlockquoteWithoutCaption: false,
     removeUnnumberedLabel: false,
     removeUnnumberedLabelExceptMarks: [],
     removeMarkNameInCaptionClass: false,
-    multipleImages: true,
-    imgAltCaption: false,
-    setFigureNumber: false,
-    imgTitleCaption: false,
-    roleDocExample: false,
-    allIframeTypeFigureClassName: '',
+    wrapCaptionBody: false,
   }
+  const hasExplicitSetLabelNumbers = option && Object.prototype.hasOwnProperty.call(option, 'setLabelNumbers')
   if (option) Object.assign(opt, option)
-
-  if (opt.imgAltCaption || opt.imgTitleCaption) {
-    opt.oneImageWithoutCaption = true
-    opt.multipleImages = false
-    if (opt.setFigureNumber) {
-      opt.removeUnnumberedLabelExceptMarks = opt.removeUnnumberedLabelExceptMarks.filter(
-        mark => mark !== 'img' && mark !== 'table'
-      )
-    }
-    md.block.ruler.before('paragraph', 'img_attr_caption', (state) => {
-      imgAttrToPCaption(state, state.line, opt)
-    })
+  // Normalize option shorthands now so downstream logic works with a consistent { img, table } shape.
+  opt.setLabelNumbers = normalizeSetLabelNumbers(opt.setLabelNumbers)
+  if (opt.autoLabelNumber && !hasExplicitSetLabelNumbers) {
+    opt.setLabelNumbers.img = true
+    opt.setLabelNumbers.table = true
   }
+  // Precompute `.f-*-label` permutations so numbering lookup doesn't rebuild arrays per caption.
+  opt.labelClassLookup = buildLabelClassLookup(opt)
 
   //If nextCaption has `{}` style and `f-img-multipleImages`, when upgraded to markdown-it-attrs@4.2.0, the existing script will have `{}` style on nextCaption. Therefore, since markdown-it-attrs is md.core.ruler.before('linkify'), figure_with_caption will be processed after it.
   md.core.ruler.before('replacements', 'figure_with_caption', (state) => {