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

package/index.js

@@ -1,27 +1,52 @@
 import {
+  analyzeCaptionParagraph,
   analyzeCaptionStart,
-  buildLabelClassLookup,
+  applyCaptionParagraph,
   buildLabelPrefixMarkerRegFromMarkers,
+  canonicalizeCaptionNumberingMark,
+  createCaptionNumberingPolicy,
+  createCaptionNumberingRuntime,
   getGeneratedLabelDefaults,
+  normalizeAutoLabelNumberSets,
   normalizeLabelPrefixMarkers,
   setCaptionParagraph,
   getMarkRegStateForLanguages,
   stripLabelPrefixMarker,
 } from 'p7d-markdown-it-p-captions'
-import { detectHtmlFigureCandidate } from './embeds/detect.js'
+import { applyHtmlFigureTransform, detectHtmlFigureCandidate } from './embeds/detect.js'
+import {
+  createFigureCaptionCounterKeyResolverFromMarkRegState,
+} from './caption-numbering/counter-series.js'
+import {
+  createUnscopedNumberingContext,
+  formatFigureCaptionGeneratedNumberUnchecked,
+  getCaptionNumberingContext,
+  parseFigureCaptionExplicitNumberUnchecked,
+} from './caption-numbering/number-codec.js'
+import {
+  getFigureCaptionNumberingPolicyState,
+  normalizeFigureCaptionNumberingPolicy,
+} from './caption-numbering/options.js'
+import {
+  createFigureCaptionScopeRuntime,
+  getFigureCaptionScopeNestedContainerType,
+  updateFigureCaptionScopeFromHeading,
+} from './caption-numbering/scope.js'
 
 const imageAttrsReg = /^ *\{(.*?)\} *$/
-const classAttrReg = /^\./
-const idAttrReg = /^#/
 const sampLangReg = /^ *(?:samp|shell|console)(?:(?= )|$)/
 const asciiLabelReg = /^[A-Za-z]/
 const attrNameReg = /^[^\s=]+$/
-const labelTrailingJointReg = /[.\u3002\uff0e:：]\s*$/
+const labelTrailingJointReg = /[.\u3002\uff0e:：\u3000]\s*$/
+const installedKey = Symbol.for('p7d-markdown-it-figure-with-p-caption.installed')
 const CHECK_TYPE_TOKEN_MAP = {
   table_open: 'table',
   pre_open: 'pre',
   blockquote_open: 'blockquote',
 }
+const hasOwnOption = (option, name) => !!(
+  option && Object.prototype.hasOwnProperty.call(option, name)
+)
 const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 const normalizeLanguageCode = (value) => {
   if (value === null || value === undefined) return ''
@@ -31,11 +56,10 @@ const normalizeLanguageCode = (value) => {
   return separatorIndex === -1 ? normalized : normalized.slice(0, separatorIndex)
 }
 const appendAvailableLanguage = (target, lang, availableLanguages) => {
-  if (!lang) return false
-  if (availableLanguages.indexOf(lang) === -1) return false
-  if (target.indexOf(lang) !== -1) return false
+  if (!lang) return
+  if (availableLanguages.indexOf(lang) === -1) return
+  if (target.indexOf(lang) !== -1) return
   target.push(lang)
-  return true
 }
 const normalizePreferredLanguages = (value, availableLanguages) => {
   if (!Array.isArray(availableLanguages) || availableLanguages.length === 0) return []
@@ -100,31 +124,30 @@ const isHyphenFenceLine = (src, lineStart) => {
   if (index >= src.length || src.charCodeAt(index) !== 0x0a) return 0
   return hyphenCount
 }
-const skipLeadingFrontmatter = (src) => {
-  if (typeof src !== 'string' || isHyphenFenceLine(src, 0) === 0) return src
+const getBodyStartAfterLeadingFrontmatter = (src) => {
+  if (typeof src !== 'string' || isHyphenFenceLine(src, 0) === 0) return 0
   let lineStart = src.indexOf('\n')
-  if (lineStart === -1) return src
+  if (lineStart === -1) return 0
   lineStart++
   while (lineStart < src.length) {
     if (isHyphenFenceLine(src, lineStart) > 0) {
       const nextLineStart = src.indexOf('\n', lineStart)
-      if (nextLineStart === -1) return ''
-      return src.slice(nextLineStart + 1)
+      return nextLineStart === -1 ? src.length : nextLineStart + 1
     }
     const nextLineStart = src.indexOf('\n', lineStart)
     if (nextLineStart === -1) break
     lineStart = nextLineStart + 1
   }
-  return src
+  return 0
 }
 const detectDocumentPrimaryLanguage = (src, availableLanguages) => {
   if (!src || availableLanguages.indexOf('ja') === -1) return ''
-  const body = skipLeadingFrontmatter(src)
-  const limit = Math.min(body.length, 8192)
+  const bodyStart = getBodyStartAfterLeadingFrontmatter(src)
+  const limit = Math.min(src.length, bodyStart + 8192)
   let japaneseCount = 0
   let asciiAlphaCount = 0
-  for (let i = 0; i < limit; i++) {
-    const code = body.charCodeAt(i)
+  for (let i = bodyStart; i < limit; i++) {
+    const code = src.charCodeAt(i)
     if (isJapaneseCharCode(code)) {
       japaneseCount++
       continue
@@ -137,10 +160,6 @@ const detectDocumentPrimaryLanguage = (src, availableLanguages) => {
   if (asciiAlphaCount === 0) return 'ja'
   return japaneseCount * 2 >= asciiAlphaCount ? 'ja' : ''
 }
-const sourceMayNeedPreferredLanguages = (state) => {
-  const src = state && typeof state.src === 'string' ? state.src : ''
-  return src.indexOf('![') !== -1
-}
 const resolvePreferredLanguagesForState = (state, opt) => {
   const availableLanguages = (
     opt &&
@@ -149,10 +168,7 @@ const resolvePreferredLanguagesForState = (state, opt) => {
   ) ? opt.markRegState.languages : []
   if (availableLanguages.length === 0) return []
 
-  const optionLanguages = opt && Array.isArray(opt.normalizedOptionLanguages)
-    ? opt.normalizedOptionLanguages
-    : []
-  const baseLanguages = optionLanguages.length > 0 ? optionLanguages : availableLanguages
+  const baseLanguages = availableLanguages
   const env = state && state.env ? state.env : null
 
   const envLocale = normalizeLanguageCode(env && env.locale)
@@ -190,18 +206,15 @@ const resolvePreferredLanguagesForState = (state, opt) => {
 }
 const needsPreferredLanguagesResolution = (opt) => {
   if (!opt || !opt.markRegState || !Array.isArray(opt.markRegState.languages)) return false
+  if (!opt.autoCaptionDetection) return false
   if (opt.markRegState.languages.length <= 1) return false
   return opt.autoAltCaption === true || opt.autoTitleCaption === true
 }
 const normalizeOptionalClassName = (value) => {
   if (value === null || value === undefined) return ''
-  const normalized = String(value).trim()
-  return normalized || ''
-}
-const buildClassPrefix = (value) => {
-  const normalized = normalizeOptionalClassName(value)
-  return normalized ? normalized + '-' : ''
+  return String(value).trim()
 }
+const buildClassPrefix = (normalized) => normalized ? normalized + '-' : ''
 const normalizeClassOptionWithFallback = (value, fallbackValue) => {
   const normalized = normalizeOptionalClassName(value)
   return normalized || fallbackValue
@@ -283,10 +296,11 @@ const parseImageAttrs = (raw) => {
   for (let i = 0; i < parts.length; i++) {
     let entry = parts[i]
     if (!entry) continue
-    if (classAttrReg.test(entry)) {
-      entry = entry.replace(classAttrReg, 'class=')
-    } else if (idAttrReg.test(entry)) {
-      entry = entry.replace(idAttrReg, 'id=')
+    const firstCode = entry.charCodeAt(0)
+    if (firstCode === 0x2e) {
+      entry = 'class=' + entry.slice(1)
+    } else if (firstCode === 0x23) {
+      entry = 'id=' + entry.slice(1)
     }
     const equalIndex = entry.indexOf('=')
     if (equalIndex === -1) {
@@ -301,22 +315,50 @@ const parseImageAttrs = (raw) => {
   return attrs
 }
 
-const normalizeAutoLabelNumberSets = (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 shouldApplyLabelNumbering = (captionType, opt) => {
-  const setting = opt.autoLabelNumberSets
-  if (!setting) return false
-  return !!setting[captionType]
+const getEnabledCaptionNumberingMarks = (sets, opt) => {
+  if (!Array.isArray(sets) || sets.length === 0) return []
+  const exceptMarks = opt && Array.isArray(opt.removeUnnumberedLabelExceptMarks)
+    ? opt.removeUnnumberedLabelExceptMarks
+    : []
+  if (!opt || !opt.removeUnnumberedLabel) return sets
+  return sets.filter(mark => exceptMarks.indexOf(mark) !== -1)
+}
+
+const createFigureCaptionNumberingPolicy = (enabledMarks, advancedPolicy, markRegState) => {
+  if (enabledMarks.length === 0) return null
+  const resolveCounterKey = createFigureCaptionCounterKeyResolverFromMarkRegState(markRegState)
+  const getCounterKey = ({ captionDecision }) => resolveCounterKey(captionDecision)
+  if (!advancedPolicy) {
+    return createCaptionNumberingPolicy({
+      enabledMarks,
+      explicitCounter: 'max',
+      generatedNumberHasNumClass: false,
+      getCounterKey,
+    })
+  }
+  return createCaptionNumberingPolicy({
+    enabledMarks,
+    explicitCounter: 'max',
+    generatedNumberHasNumClass: false,
+    getCounterKey,
+    getSequenceKey({ captionContext }) {
+      return getCaptionNumberingContext(captionContext).sequenceKey
+    },
+    // p-captions resolves getSequenceKey first, so the following callbacks can
+    // reuse that already-branded context without a second WeakSet lookup.
+    parseExplicitNumber({ number, captionContext }) {
+      return parseFigureCaptionExplicitNumberUnchecked(
+        number,
+        captionContext && captionContext.numbering,
+      )
+    },
+    formatGeneratedNumber({ sequence, captionContext }) {
+      return formatFigureCaptionGeneratedNumberUnchecked(
+        sequence,
+        captionContext && captionContext.numbering,
+      )
+    },
+  })
 }
 
 const isOnlySpacesText = (token) => {
@@ -418,7 +460,24 @@ const buildCaptionWithFallback = (text, fallbackOption, mark, markRegState, pref
   return label + getFallbackStringLabelJoint(label) + trimmedText
 }
 
+const resolveCaptionPreferredLanguages = (captionState, opt) => {
+  const renderState = captionState.preferredLanguageState
+  if (!renderState) return captionState.preferredLanguages
+  captionState.preferredLanguages = resolvePreferredLanguagesForState(renderState, opt)
+  captionState.preferredLanguageState = null
+  return captionState.preferredLanguages
+}
+
 const validateFallbackCaptionLabelOption = (optionName, fallbackOption, markRegState) => {
+  if (
+    fallbackOption !== undefined &&
+    fallbackOption !== null &&
+    fallbackOption !== false &&
+    fallbackOption !== true &&
+    typeof fallbackOption !== 'string'
+  ) {
+    throw new TypeError(`${optionName} must be false, true, a string label, or null.`)
+  }
   if (typeof fallbackOption !== 'string') return
   const sampleCaption = buildCaptionWithFallback('caption', fallbackOption, 'img', markRegState, null)
   const analysis = analyzeCaptionStart(sampleCaption, {
@@ -444,121 +503,6 @@ const createAutoCaptionParagraph = (captionText, TokenConstructor) => {
   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 hasClassName = (classAttr, className) => {
-  if (!classAttr || !className) return false
-  let index = 0
-  while (index < classAttr.length) {
-    index = classAttr.indexOf(className, index)
-    if (index === -1) return false
-    const end = index + className.length
-    const beforeBoundary = index === 0 || classAttr.charCodeAt(index - 1) <= 0x20
-    const afterBoundary = end >= classAttr.length || classAttr.charCodeAt(end) <= 0x20
-    if (beforeBoundary && afterBoundary) return true
-    index = end
-  }
-  return false
-}
-
-const hasAnyClassName = (classAttr, classNames) => {
-  for (let i = 0; i < classNames.length; i++) {
-    if (hasClassName(classAttr, classNames[i])) return true
-  }
-  return false
-}
-
-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
-    if (!hasAnyClassName(classAttr, classNames)) 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 parseTrailingPositiveInteger = (text) => {
-  if (typeof text !== 'string' || text.length === 0) return null
-  let end = text.length - 1
-  while (end >= 0 && text.charCodeAt(end) === 0x20) end--
-  if (end < 0) return null
-  const lastCode = text.charCodeAt(end)
-  if (lastCode < 0x30 || lastCode > 0x39) return null
-  let start = end
-  while (start >= 0) {
-    const code = text.charCodeAt(start)
-    if (code < 0x30 || code > 0x39) break
-    start--
-  }
-  let value = 0
-  let digitBase = 1
-  for (let i = end; i > start; i--) {
-    value += (text.charCodeAt(i) - 0x30) * digitBase
-    digitBase *= 10
-  }
-  return value
-}
-
-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 originalText = labelTextToken.content
-  let end = originalText.length - 1
-  while (end >= 0 && originalText.charCodeAt(end) === 0x20) end--
-  if (end >= 0) {
-    const code = originalText.charCodeAt(end)
-    if (code >= 0x30 && code <= 0x39) {
-      const explicitValue = parseTrailingPositiveInteger(originalText)
-      if (explicitValue !== null) {
-        if (explicitValue > (figureNumberState[captionType] || 0)) {
-          figureNumberState[captionType] = explicitValue
-        }
-        return
-      }
-    }
-  }
-  figureNumberState[captionType] = (figureNumberState[captionType] || 0) + 1
-  const baseLabel = originalText.trim()
-  if (!baseLabel) return
-  const joint = asciiLabelReg.test(baseLabel) ? ' ' : ''
-  const newLabelText = baseLabel + joint + figureNumberState[captionType]
-  labelTextToken.content = newLabelText
-  updateInlineTokenContent(inlineToken, originalText, newLabelText)
-}
-
 const matchAutoCaptionText = (text, opt, preferredMark = 'img') => {
   if (!text || !opt || !opt.markRegState) return ''
   const trimmed = text.trim()
@@ -571,89 +515,116 @@ const matchAutoCaptionText = (text, opt, preferredMark = 'img') => {
   return ''
 }
 
-const getAutoCaptionFromImage = (imageToken, opt) => {
-  if (!opt.autoCaptionDetection) return ''
-  if (!opt.autoAltCaption && !opt.autoTitleCaption && !(opt.markRegState && opt.markRegState.markReg && opt.markRegState.markReg.img)) return ''
+const getAutoCaptionFromImage = (imageToken, opt, captionState) => {
+  if (!opt.autoAltCaption && !opt.autoTitleCaption && !(opt.markRegState && opt.markRegState.markReg && opt.markRegState.markReg.img)) return null
 
   const altText = getImageAltText(imageToken)
   let caption = matchAutoCaptionText(altText, opt)
   if (caption) {
-    clearImageAltAttr(imageToken)
-    return caption
+    return { text: caption, source: 'alt' }
   }
-  if (!caption && opt.autoAltCaption) {
-    const altForFallback = altText || ''
-    const fallbackCaption = buildCaptionWithFallback(altForFallback, opt.autoAltCaption, 'img', opt.markRegState, opt.preferredLanguages)
-    if (fallbackCaption && imageToken) {
-      clearImageAltAttr(imageToken)
-    }
-    caption = fallbackCaption
+  if (opt.autoAltCaption) {
+    const preferredLanguages = opt.autoAltCaption === true
+      ? resolveCaptionPreferredLanguages(captionState, opt)
+      : captionState.preferredLanguages
+    caption = buildCaptionWithFallback(altText, opt.autoAltCaption, 'img', opt.markRegState, preferredLanguages)
   }
-  if (caption) return caption
+  if (caption) return { text: caption, source: 'alt' }
 
   const titleText = getImageTitleText(imageToken)
   caption = matchAutoCaptionText(titleText, opt)
   if (caption) {
-    clearImageTitleAttr(imageToken)
-    return caption
+    return { text: caption, source: 'title' }
   }
-  if (!caption && opt.autoTitleCaption) {
-    const titleForFallback = titleText || ''
-    const fallbackCaption = buildCaptionWithFallback(titleForFallback, opt.autoTitleCaption, 'img', opt.markRegState, opt.preferredLanguages)
-    if (fallbackCaption && imageToken) {
-      clearImageTitleAttr(imageToken)
-    }
-    caption = fallbackCaption
+  if (opt.autoTitleCaption) {
+    const preferredLanguages = opt.autoTitleCaption === true
+      ? resolveCaptionPreferredLanguages(captionState, opt)
+      : captionState.preferredLanguages
+    caption = buildCaptionWithFallback(titleText, opt.autoTitleCaption, 'img', opt.markRegState, preferredLanguages)
+  }
+  return caption ? { text: caption, source: 'title' } : null
+}
+
+const consumeAutoCaptionSource = (imageToken, autoCaption) => {
+  if (!imageToken || !autoCaption) return
+  if (autoCaption.source === 'alt') {
+    clearImageAltAttr(imageToken)
+  } else if (autoCaption.source === 'title') {
+    clearImageTitleAttr(imageToken)
   }
-  return caption
+}
+
+const setFigureCaptionParagraph = (index, captionState, caption, sp, opt) => {
+  const needsCaptionDrivenClassBeforeApply = !!(
+    opt.labelClassFollowsFigure &&
+    caption.name === 'iframe' &&
+    !opt.allIframeTypeFigureClassName
+  )
+  if (!needsCaptionDrivenClassBeforeApply) {
+    return setCaptionParagraph(index, captionState, caption, captionState.numberingRuntime, sp, opt)
+  }
+  const decision = analyzeCaptionParagraph(index, captionState, {
+    captionName: caption.name,
+    isIframeTypeBlockquote: sp.isIframeTypeBlockquote,
+    isVideoIframe: sp.isVideoIframe,
+  }, opt)
+  if (!decision) return false
+  // Figure-following label classes need the final caption-driven wrapper class
+  // before p-captions constructs the label/body spans.
+  applyCaptionDrivenFigureClass(caption, sp, opt, decision)
+  return applyCaptionParagraph(
+    decision,
+    captionState,
+    sp,
+    captionState.numberingRuntime,
+    opt,
+  )
 }
 
 const checkPrevCaption = (tokens, n, caption, sp, opt, captionState) => {
-  if(n < 3) return caption
-  const captionStartToken = tokens[n-3]
-  const captionInlineToken = tokens[n-2]
-  const captionEndToken = tokens[n-1]
+  if (n < 3) return
+  const captionStartToken = tokens[n - 3]
+  const captionInlineToken = tokens[n - 2]
+  const captionEndToken = tokens[n - 1]
   if (captionStartToken === undefined || captionEndToken === undefined) return
   if (captionStartToken.type !== 'paragraph_open' || captionEndToken.type !== 'paragraph_close') return
-  setCaptionParagraph(n-3, captionState, caption, null, sp, opt)
+  setFigureCaptionParagraph(n - 3, captionState, caption, sp, opt)
   const captionName = sp && sp.captionDecision ? sp.captionDecision.mark : ''
-  if(!captionName) {
+  if (!captionName) {
     if (opt.labelPrefixMarkerWithoutLabelPrevReg) {
-        const markerMatch = getLabelPrefixMarkerMatch(captionInlineToken, opt.labelPrefixMarkerWithoutLabelPrevReg)
-        if (markerMatch) {
-          stripLabelPrefixMarker(captionInlineToken, markerMatch)
-          caption.isPrev = true
-        }
+      const markerMatch = getLabelPrefixMarkerMatch(captionInlineToken, opt.labelPrefixMarkerWithoutLabelPrevReg)
+      if (markerMatch) {
+        stripLabelPrefixMarker(captionInlineToken, markerMatch)
+        caption.isPrev = true
+      }
     }
     return
   }
   caption.name = captionName
   caption.isPrev = true
-  return
 }
 
 const checkNextCaption = (tokens, en, caption, sp, opt, captionState) => {
-  if (en + 2 > tokens.length) return
-  const captionStartToken = tokens[en+1]
-  const captionInlineToken = tokens[en+2]
-  const captionEndToken = tokens[en+3]
+  if (en + 3 >= tokens.length) return
+  const captionStartToken = tokens[en + 1]
+  const captionInlineToken = tokens[en + 2]
+  const captionEndToken = tokens[en + 3]
   if (captionStartToken === undefined || captionEndToken === undefined) return
   if (captionStartToken.type !== 'paragraph_open' || captionEndToken.type !== 'paragraph_close') return
-  setCaptionParagraph(en+1, captionState, caption, null, sp, opt)
+  setFigureCaptionParagraph(en + 1, captionState, caption, sp, opt)
   const captionName = sp && sp.captionDecision ? sp.captionDecision.mark : ''
-  if(!captionName) {
+  if (!captionName) {
     if (opt.labelPrefixMarkerWithoutLabelNextReg) {
-        const markerMatch = getLabelPrefixMarkerMatch(captionInlineToken, opt.labelPrefixMarkerWithoutLabelNextReg)
-        if (markerMatch) {
-          stripLabelPrefixMarker(captionInlineToken, markerMatch)
-          caption.isNext = true
-        }
+      const markerMatch = getLabelPrefixMarkerMatch(captionInlineToken, opt.labelPrefixMarkerWithoutLabelNextReg)
+      if (markerMatch) {
+        stripLabelPrefixMarker(captionInlineToken, markerMatch)
+        caption.isNext = true
+      }
     }
     return
   }
   caption.name = captionName
   caption.isNext = true
-  return
 }
 
 const cleanCaptionTokenAttrs = (token, captionName, opt) => {
@@ -701,24 +672,26 @@ const resolveFigureClassName = (checkTokenTagName, sp, opt) => {
   return className
 }
 
-const applyCaptionDrivenFigureClass = (caption, sp, opt) => {
+const applyCaptionDrivenFigureClass = (caption, sp, opt, decision = sp && sp.captionDecision) => {
   if (!sp) return
   const figureClassForSlides = opt.figureClassThatWrapsSlides
   if (!figureClassForSlides) return
-  const detectedMark = (sp.captionDecision && sp.captionDecision.mark) || (caption && caption.name) || ''
+  const detectedMark = (decision && decision.mark) || (caption && caption.name) || ''
   if (detectedMark !== 'slide') return
   if (opt.allIframeTypeFigureClassName && sp.figureClassName === opt.allIframeTypeFigureClassName) return
+  if (sp.figureClassName === figureClassForSlides) 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]
-  const figureBaseLevel = getTokenLevel(tokens[n])
-
-  cleanCaptionTokenAttrs(captionStartToken, caption.name, opt)
+const convertCaptionTokens = (
+  captionStartToken,
+  captionInlineToken,
+  captionEndToken,
+  figureBaseLevel,
+  captionName,
+  opt,
+) => {
+  cleanCaptionTokenAttrs(captionStartToken, captionName, opt)
   captionStartToken.type = 'figcaption_open'
   captionStartToken.tag = 'figcaption'
   captionStartToken.block = true
@@ -728,33 +701,61 @@ const changePrevCaptionPosition = (tokens, n, caption, opt) => {
   captionEndToken.tag = 'figcaption'
   captionEndToken.block = true
   captionEndToken.level = figureBaseLevel + 1
-  tokens.splice(n + 2, 0, captionStartToken, captionInlineToken, captionEndToken)
-  tokens.splice(n-3, 3)
-  return true
+}
+
+const changePrevCaptionPosition = (tokens, n, caption, opt) => {
+  const captionStartToken = tokens[n-3]
+  const captionInlineToken = tokens[n-2]
+  const captionEndToken = tokens[n-1]
+  const figureStartToken = tokens[n]
+  const figureStartPaddingToken = tokens[n+1]
+  convertCaptionTokens(
+    captionStartToken,
+    captionInlineToken,
+    captionEndToken,
+    getTokenLevel(tokens[n]),
+    caption.name,
+    opt,
+  )
+  tokens[n-3] = figureStartToken
+  tokens[n-2] = figureStartPaddingToken
+  tokens[n-1] = captionStartToken
+  tokens[n] = captionInlineToken
+  tokens[n+1] = captionEndToken
 }
 
 const changeNextCaptionPosition = (tokens, en, caption, opt) => {
+  const figureEndToken = tokens[en]
   const captionStartToken = tokens[en+1]
   const captionInlineToken = tokens[en+2]
   const captionEndToken = tokens[en+3]
-  const figureBaseLevel = getTokenLevel(tokens[en])
-  cleanCaptionTokenAttrs(captionStartToken, caption.name, opt)
-  captionStartToken.type = 'figcaption_open'
-  captionStartToken.tag = 'figcaption'
-  captionStartToken.block = true
-  captionStartToken.level = figureBaseLevel + 1
-  captionInlineToken.level = figureBaseLevel + 2
-  captionEndToken.type = 'figcaption_close'
-  captionEndToken.tag = 'figcaption'
-  captionEndToken.block = true
-  captionEndToken.level = figureBaseLevel + 1
-  tokens.splice(en, 0, captionStartToken, captionInlineToken, captionEndToken)
-  tokens.splice(en+4, 3)
-  return true
+  convertCaptionTokens(
+    captionStartToken,
+    captionInlineToken,
+    captionEndToken,
+    getTokenLevel(tokens[en]),
+    caption.name,
+    opt,
+  )
+  tokens[en] = captionStartToken
+  tokens[en+1] = captionInlineToken
+  tokens[en+2] = captionEndToken
+  tokens[en+3] = figureEndToken
 }
 
 const getTokenMap = (token) => {
-  return token && Array.isArray(token.map) && token.map.length === 2 ? token.map : null
+  if (!token || !Array.isArray(token.map) || token.map.length !== 2) return null
+  const startLine = token.map[0]
+  const endLine = token.map[1]
+  if (
+    !Number.isSafeInteger(startLine) ||
+    !Number.isSafeInteger(endLine) ||
+    startLine < 0 ||
+    endLine < startLine
+  ) {
+    return null
+  }
+  return token.map
 }
 
 const findNearestMapInRange = (tokens, start, end, step) => {
@@ -773,9 +774,6 @@ const getRangeMap = (tokens, start, end) => {
   const endMap = getTokenMap(tokens[end]) || findNearestMapInRange(tokens, end, start, -1) || startMap
   const startLine = startMap[0]
   const endLine = Math.max(startMap[1], endMap[1])
-  if (typeof startLine !== 'number' || typeof endLine !== 'number' || endLine < startLine) {
-    return [startMap[0], startMap[1]]
-  }
   return [startLine, endLine]
 }
 
@@ -793,14 +791,27 @@ const adjustTokenLevels = (tokens, start, end, delta) => {
   }
 }
 
+const createTextToken = (TokenConstructor, content, level) => {
+  const token = new TokenConstructor('text', '', 0)
+  token.content = content
+  token.level = level
+  return token
+}
+
+const joinTokenAttrs = (token, attrs) => {
+  if (!attrs || attrs.length === 0) return
+  for (let i = 0; i < attrs.length; i++) {
+    token.attrJoin(attrs[i][0], attrs[i][1])
+  }
+}
+
 const wrapWithFigure = (tokens, range, checkTokenTagName, caption, replaceInsteadOfWrap, sp, opt, TokenConstructor) => {
   let n = range.start
   let en = range.end
   const baseLevel = getTokenLevel(tokens[n])
   const childLevel = baseLevel + 1
   const figureStartToken = new TokenConstructor('figure_open', 'figure', 1)
-  const figureClassName = sp.figureClassName || resolveFigureClassName(checkTokenTagName, sp, opt)
-  figureStartToken.attrSet('class', figureClassName)
+  figureStartToken.attrSet('class', sp.figureClassName)
   figureStartToken.block = true
   figureStartToken.level = baseLevel
 
@@ -815,65 +826,50 @@ const wrapWithFigure = (tokens, range, checkTokenTagName, caption, replaceInstea
     figureStartToken.map = [rangeMap[0], rangeMap[1]]
     figureEndToken.map = [rangeMap[0], rangeMap[1]]
   }
-  const createBreakToken = () => {
-    const breakToken = new TokenConstructor('text', '', 0)
-    breakToken.content = '\n'
-    breakToken.level = childLevel
-    return breakToken
-  }
-  const createEmptyTextToken = () => {
-    const emptyToken = new TokenConstructor('text', '', 0)
-    emptyToken.content = ''
-    emptyToken.level = childLevel
-    return emptyToken
-  }
   if (caption.name === 'img') {
-    const joinAttrs = (attrs) => {
-      if (!attrs || attrs.length === 0) return
-      for (let i = 0; i < attrs.length; i++) {
-        const attr = attrs[i]
-        figureStartToken.attrJoin(attr[0], attr[1])
-      }
-    }
     // `styleProcess` should keep working even when markdown-it-attrs is absent.
-    if (opt.styleProcess) joinAttrs(sp.attrs)
+    if (opt.styleProcess) joinTokenAttrs(figureStartToken, sp.attrs)
     // Forward attrs already materialized by markdown-it-attrs on the image paragraph.
-    joinAttrs(tokens[n].attrs)
+    joinTokenAttrs(figureStartToken, tokens[n].attrs)
   }
   if (replaceInsteadOfWrap) {
-    tokens.splice(en, 1, createBreakToken(), figureEndToken)
-    tokens.splice(n, 1, figureStartToken, createEmptyTextToken())
+    const contentToken = tokens[n + 1]
+    tokens.splice(
+      n,
+      en - n + 1,
+      figureStartToken,
+      createTextToken(TokenConstructor, '', childLevel),
+      contentToken,
+      createTextToken(TokenConstructor, '\n', childLevel),
+      figureEndToken,
+    )
     en = en + 2
+  } else if (n === en) {
+    const contentToken = tokens[n]
+    adjustTokenLevels(tokens, n, en, 1)
+    tokens.splice(
+      n,
+      1,
+      figureStartToken,
+      createTextToken(TokenConstructor, '', childLevel),
+      contentToken,
+      figureEndToken,
+    )
+    en = en + 3
   } else {
     adjustTokenLevels(tokens, n, en, 1)
     tokens.splice(en+1, 0, figureEndToken)
-    tokens.splice(n, 0, figureStartToken, createEmptyTextToken())
+    tokens.splice(n, 0, figureStartToken, createTextToken(TokenConstructor, '', childLevel))
     en = en + 3
   }
   range.start = n
   range.end = en
-  return
 }
 
 const checkCaption = (tokens, n, en, caption, sp, opt, captionState) => {
   checkPrevCaption(tokens, n, caption, sp, opt, captionState)
   if (caption.isPrev) return
   checkNextCaption(tokens, en, caption, sp, opt, captionState)
-  return
-}
-
-const getNestedContainerType = (token) => {
-  if (!token) return null
-  switch (token.type) {
-    case 'blockquote_open':
-      return 'blockquote'
-    case 'list_item_open':
-      return 'list_item'
-    case 'dd_open':
-      return 'dd'
-    default:
-      return null
-  }
 }
 
 const resetRangeState = (range, start) => {
@@ -894,6 +890,7 @@ const resetSpecialState = (sp) => {
   sp.isIframeTypeBlockquote = false
   sp.figureClassName = ''
   sp.captionDecision = null
+  sp.numbering = null
 }
 
 const findClosingTokenIndex = (tokens, startIndex, tag) => {
@@ -910,19 +907,20 @@ const findClosingTokenIndex = (tokens, startIndex, tag) => {
     }
     i++
   }
-  return startIndex
+  return -1
 }
 
 const detectCheckTypeOpen = (tokens, token, n, caption, baseType) => {
   if (!token || !baseType) return null
   if (n > 1 && tokens[n - 2] && tokens[n - 2].type === 'figure_open') return null
-  let tagName = token.tag
+  const tagName = token.tag
   caption.name = baseType
   if (baseType === 'pre') {
     if (tokens[n + 1] && tokens[n + 1].tag === 'code') caption.name = 'pre-code'
     if (tokens[n + 1] && tokens[n + 1].tag === 'samp') caption.name = 'pre-samp'
   }
   const en = findClosingTokenIndex(tokens, n, tagName)
+  if (en < 0) return null
   return {
     type: 'block',
     tagName,
@@ -935,11 +933,8 @@ const detectCheckTypeOpen = (tokens, token, n, caption, baseType) => {
 
 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'
-  }
+  const useSampTag = sampLangReg.test(token.info)
+  const tagName = useSampTag ? 'pre-samp' : 'pre-code'
   caption.name = tagName
   return {
     type: 'fence',
@@ -948,6 +943,8 @@ const detectFenceToken = (token, n, caption) => {
     replaceInsteadOfWrap: false,
     wrapWithoutCaption: false,
     canWrap: true,
+    token,
+    useSampTag,
   }
 }
 
@@ -971,6 +968,7 @@ const detectImageParagraph = (nextToken, n, caption, sp, opt) => {
   let isMultipleImagesHorizontal = true
   let isMultipleImagesVertical = true
   let isValid = true
+  let trailingAttrToken = null
   caption.name = 'img'
   if (childrenLength === 1) {
     return {
@@ -1006,7 +1004,7 @@ const detectImageParagraph = (nextToken, n, caption, sp, opt) => {
             for (let i = 0; i < parsedAttrs.length; i++) {
               sp.attrs.push(parsedAttrs[i])
             }
-            child.content = ''
+            trailingAttrToken = child
             break
           }
         }
@@ -1044,12 +1042,6 @@ const detectImageParagraph = (nextToken, n, caption, sp, opt) => {
     } else {
       caption.nameSuffix = '-multiple'
     }
-    for (let i = 0; i < childrenLength; i++) {
-      const child = children[i]
-      if (isOnlySpacesText(child)) {
-        child.content = ''
-      }
-    }
   }
   const en = n + 2
   let tagName = 'img'
@@ -1062,28 +1054,56 @@ const detectImageParagraph = (nextToken, n, caption, sp, opt) => {
     wrapWithoutCaption: isValid && allowImageParagraphWithoutCaption,
     canWrap: isValid,
     imageToken,
+    inlineToken: nextToken,
+    trailingAttrToken,
   }
 }
 
-const figureWithCaption = (state, opt) => {
-  const figureNumberState = {
-    img: 0,
-    table: 0,
+const applyImageParagraphTransform = (detection) => {
+  if (!detection || detection.type !== 'image') return
+  if (detection.trailingAttrToken) {
+    detection.trailingAttrToken.content = ''
   }
+  if (!detection.inlineToken || detection.tagName === 'img') return
+  const children = detection.inlineToken.children
+  for (let i = 0; i < children.length; i++) {
+    if (isOnlySpacesText(children[i])) {
+      children[i].content = ''
+    }
+  }
+}
 
-  const captionState = { tokens: state.tokens, Token: state.Token }
-  const shouldResolvePreferredLanguages = !!(
-    opt.shouldResolvePreferredLanguages &&
-    sourceMayNeedPreferredLanguages(state)
-  )
-  const renderOpt = shouldResolvePreferredLanguages ? Object.create(opt) : opt
-  if (shouldResolvePreferredLanguages) {
-    renderOpt.preferredLanguages = resolvePreferredLanguagesForState(state, opt)
+const applyWrappedCandidateTransform = (detection) => {
+  if (detection.type === 'image') {
+    applyImageParagraphTransform(detection)
+  } else if (detection.type === 'fence' && detection.useSampTag) {
+    detection.token.tag = 'samp'
+  }
+}
+
+const figureWithCaption = (state, opt) => {
+  const numberingRuntime = opt.captionNumberingPolicy
+    ? createCaptionNumberingRuntime(opt.captionNumberingPolicy, { env: state.env })
+    : null
+  const numberingScopeState = numberingRuntime
+    ? createFigureCaptionScopeRuntime(
+      state,
+      opt.normalizedAutoLabelNumberPolicy,
+      opt.unscopedNumberingContext,
+    )
+    : null
+  const captionState = {
+    tokens: state.tokens,
+    Token: state.Token,
+    preferredLanguages: opt.preferredLanguages,
+    numberingRuntime,
+    numberingScopeState,
   }
-  figureWithCaptionCore(state.tokens, renderOpt, figureNumberState, state.Token, captionState, null, 0)
+  if (opt.shouldResolvePreferredLanguages) captionState.preferredLanguageState = state
+  figureWithCaptionCore(state.tokens, opt, state.Token, captionState, null, 0)
 }
 
-const figureWithCaptionCore = (tokens, opt, figureNumberState, TokenConstructor, captionState, parentType = null, startIndex = 0) => {
+const figureWithCaptionCore = (tokens, opt, TokenConstructor, captionState, parentType = null, startIndex = 0) => {
   const rRange = { start: startIndex, end: startIndex }
   const rCaption = {
     name: '', nameSuffix: '', isPrev: false, isNext: false
@@ -1093,21 +1113,31 @@ const figureWithCaptionCore = (tokens, opt, figureNumberState, TokenConstructor,
     isVideoIframe: false,
     isIframeTypeBlockquote: false,
     figureClassName: '',
-    captionDecision: null
-  }
+    captionDecision: null,
+    numbering: null,
+  }
+  const numberingScopeState = parentType ? null : captionState.numberingScopeState
+  const headingScopeState = numberingScopeState &&
+    !numberingScopeState.fixed &&
+    numberingScopeState.scopeConfig.usesHeading
+    ? numberingScopeState
+    : null
+  const parentCloseType = parentType ? parentType + '_close' : ''
   let n = startIndex
   while (n < tokens.length) {
     const token = tokens[n]
-    const containerType = getNestedContainerType(token)
+    if (headingScopeState && token.type === 'heading_open') {
+      updateFigureCaptionScopeFromHeading(tokens, n, headingScopeState)
+    }
+    const containerType = getFigureCaptionScopeNestedContainerType(token)
 
     if (containerType && containerType !== 'blockquote') {
-      const closeIndex = figureWithCaptionCore(tokens, opt, figureNumberState, TokenConstructor, captionState, containerType, n + 1)
-      n = (typeof closeIndex === 'number' ? closeIndex : n) + 1
+      const closeIndex = figureWithCaptionCore(tokens, opt, TokenConstructor, captionState, containerType, n + 1)
+      n = closeIndex + 1
       continue
     }
 
-
-    if (parentType && token.type === `${parentType}_close`) {
+    if (parentCloseType && token.type === parentCloseType) {
       return n
     }
 
@@ -1146,8 +1176,8 @@ const figureWithCaptionCore = (tokens, opt, figureNumberState, TokenConstructor,
 
     if (!detection) {
       if (containerType === 'blockquote') {
-        const closeIndex = figureWithCaptionCore(tokens, opt, figureNumberState, TokenConstructor, captionState, containerType, n + 1)
-        n = (typeof closeIndex === 'number' ? closeIndex : n) + 1
+        const closeIndex = figureWithCaptionCore(tokens, opt, TokenConstructor, captionState, containerType, n + 1)
+        n = closeIndex + 1
       } else {
         n++
       }
@@ -1156,63 +1186,77 @@ const figureWithCaptionCore = (tokens, opt, figureNumberState, TokenConstructor,
 
     rRange.end = detection.en
 
+    if (detection.canWrap === false || (detection.type === 'image' && token.hidden === true)) {
+      let nextIndex = rRange.end + 1
+      if (containerType === 'blockquote') {
+        const closeIndex = figureWithCaptionCore(tokens, opt, TokenConstructor, captionState, containerType, rRange.start + 1)
+        nextIndex = Math.max(nextIndex, closeIndex + 1)
+      }
+      n = nextIndex
+      continue
+    }
+
+    if (detection.type === 'html') {
+      rRange.end = applyHtmlFigureTransform(tokens, detection)
+    }
+
+    if (captionState.numberingRuntime) {
+      rSp.numbering = captionState.numberingScopeState
+        ? captionState.numberingScopeState.currentContext
+        : opt.unscopedNumberingContext
+    }
     rSp.figureClassName = resolveFigureClassName(detection.tagName, rSp, opt)
     checkCaption(tokens, rRange.start, rRange.end, rCaption, rSp, opt, captionState)
-    applyCaptionDrivenFigureClass(rCaption, rSp, opt)
 
     let hasCaption = rCaption.isPrev || rCaption.isNext
-    let pendingAutoCaption = ''
+    if (hasCaption) applyCaptionDrivenFigureClass(rCaption, rSp, opt)
+    let pendingAutoCaption = null
     if (!hasCaption && detection.type === 'image' && opt.autoCaptionDetection) {
-      pendingAutoCaption = getAutoCaptionFromImage(detection.imageToken, opt)
+      pendingAutoCaption = getAutoCaptionFromImage(detection.imageToken, opt, captionState)
       if (pendingAutoCaption) {
         hasCaption = true
       }
     }
 
-    if (detection.canWrap === false) {
-      let nextIndex = rRange.end + 1
-      if (containerType === 'blockquote') {
-        const closeIndex = figureWithCaptionCore(tokens, opt, figureNumberState, TokenConstructor, captionState, containerType, rRange.start + 1)
-        nextIndex = Math.max(nextIndex, (typeof closeIndex === 'number' ? closeIndex : rRange.end) + 1)
-      }
-      n = nextIndex
-      continue
+    let shouldWrap = hasCaption
+    if (detection.type === 'html' || detection.type === 'image') {
+      shouldWrap = shouldWrap || detection.wrapWithoutCaption
     }
-
-    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 (token.hidden === true) {
-        shouldWrap = false
+    if (pendingAutoCaption) {
+      const captionTokens = createAutoCaptionParagraph(pendingAutoCaption.text, TokenConstructor)
+      const insertIndex = rRange.start
+      const insertedLength = captionTokens.length
+      tokens.splice(insertIndex, 0, ...captionTokens)
+      rRange.start += insertedLength
+      rRange.end += insertedLength
+      n += insertedLength
+      try {
+        checkCaption(tokens, rRange.start, rRange.end, rCaption, rSp, opt, captionState)
+      } catch (error) {
+        tokens.splice(insertIndex, insertedLength)
+        throw error
+      }
+      if (rCaption.isPrev || rCaption.isNext) {
+        consumeAutoCaptionSource(detection.imageToken, pendingAutoCaption)
+        applyCaptionDrivenFigureClass(rCaption, rSp, opt)
+      } else {
+        tokens.splice(insertIndex, insertedLength)
+        rRange.start -= insertedLength
+        rRange.end -= insertedLength
+        n -= insertedLength
+        shouldWrap = detection.wrapWithoutCaption
       }
-    } else {
-      shouldWrap = detection.canWrap !== false && hasCaption
     }
-
     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, rSp, opt, captionState)
-        applyCaptionDrivenFigureClass(rCaption, rSp, opt)
+      if (detection.type !== 'html') {
+        applyWrappedCandidateTransform(detection)
       }
-      ensureAutoFigureNumbering(tokens, rRange, rCaption, figureNumberState, opt)
       wrapWithFigure(tokens, rRange, detection.tagName, rCaption, detection.replaceInsteadOfWrap, rSp, opt, TokenConstructor)
     }
 
     let nextIndex
     if (!rCaption.isPrev && !rCaption.isNext) {
-      if (shouldWrap && detection.type === 'html') {
-        nextIndex = rRange.end + 1
-      } else {
-        nextIndex = n + 1
-      }
+      nextIndex = shouldWrap ? rRange.end + 1 : n + 1
     } else {
       const en = rRange.end
       if (rCaption.isPrev) {
@@ -1221,15 +1265,20 @@ const figureWithCaptionCore = (tokens, opt, figureNumberState, TokenConstructor,
       } else if (rCaption.isNext) {
         changeNextCaptionPosition(tokens, en, rCaption, opt)
         nextIndex = en + 4
-      } else {
-        nextIndex = en + 1
       }
     }
 
     if (containerType === 'blockquote') {
-      const closeIndex = figureWithCaptionCore(tokens, opt, figureNumberState, TokenConstructor, captionState, containerType, rRange.start + 1)
-      const fallbackIndex = rCaption.name ? rRange.end : n
-      nextIndex = Math.max(nextIndex, (typeof closeIndex === 'number' ? closeIndex : fallbackIndex) + 1)
+      const nestedContentStart = rRange.start + (shouldWrap ? 3 : 1)
+      const closeIndex = figureWithCaptionCore(
+        tokens,
+        opt,
+        TokenConstructor,
+        captionState,
+        containerType,
+        nestedContentStart,
+      )
+      nextIndex = Math.max(nextIndex, closeIndex + 1)
     }
 
     n = nextIndex
@@ -1238,7 +1287,11 @@ const figureWithCaptionCore = (tokens, opt, figureNumberState, TokenConstructor,
 }
 
 const mditFigureWithPCaption = (md, option) => {
-  let opt = {
+  if (md[installedKey]) return
+  if (hasOwnOption(option, 'setFigureNumber')) {
+    throw new Error('setFigureNumber is not supported by figure-with-p-caption; use autoLabelNumber or autoLabelNumberSets')
+  }
+  const opt = {
     // Caption languages delegated to p-captions.
     languages: ['en', 'ja'],
     preferredLanguages: null, // compatibility tie-break for generated fallback labels; prefer env.locale / env.preferredLocales per render
@@ -1271,7 +1324,8 @@ const mditFigureWithPCaption = (md, option) => {
 
     // --- numbering controls ---
     autoLabelNumber: false, // shorthand for enabling numbering for both img/table unless autoLabelNumberSets is provided explicitly
-    autoLabelNumberSets: [], // preferred; supports ['img'], ['table'], or both
+    autoLabelNumberSets: [], // preferred; supports img/table/code/samp/video marks
+    autoLabelNumberPolicy: undefined, // omitted: automatic Chapter/Appendix scope; explicit null: document-wide numbering
 
     // --- caption text formatting (delegated to p7d-markdown-it-p-captions) ---
     hasNumClass: false,
@@ -1287,16 +1341,20 @@ const mditFigureWithPCaption = (md, option) => {
     labelClassFollowsFigure: false,
     figureToLabelClassMap: null,
   }
-  const hasExplicitAutoLabelNumberSets = option && Object.prototype.hasOwnProperty.call(option, 'autoLabelNumberSets')
-  const hasExplicitImageOnlyParagraphWithoutCaption = option && Object.prototype.hasOwnProperty.call(option, 'imageOnlyParagraphWithoutCaption')
-  const hasExplicitFigureClassThatWrapsIframeTypeBlockquote = option && Object.prototype.hasOwnProperty.call(option, 'figureClassThatWrapsIframeTypeBlockquote')
-  const hasExplicitFigureClassThatWrapsSlides = option && Object.prototype.hasOwnProperty.call(option, 'figureClassThatWrapsSlides')
-  const hasExplicitLabelClassFollowsFigure = option && Object.prototype.hasOwnProperty.call(option, 'labelClassFollowsFigure')
+  const hasExplicitAutoLabelNumberSets = hasOwnOption(option, 'autoLabelNumberSets')
+  const hasExplicitImageOnlyParagraphWithoutCaption = hasOwnOption(option, 'imageOnlyParagraphWithoutCaption')
+  const hasExplicitFigureClassThatWrapsIframeTypeBlockquote = hasOwnOption(option, 'figureClassThatWrapsIframeTypeBlockquote')
+  const hasExplicitFigureClassThatWrapsSlides = hasOwnOption(option, 'figureClassThatWrapsSlides')
+  const hasExplicitLabelClassFollowsFigure = hasOwnOption(option, 'labelClassFollowsFigure')
   if (option) Object.assign(opt, option)
+  if (Array.isArray(opt.removeUnnumberedLabelExceptMarks)) {
+    opt.removeUnnumberedLabelExceptMarks = opt.removeUnnumberedLabelExceptMarks.map(
+      canonicalizeCaptionNumberingMark,
+    )
+  }
   opt.imageOnlyParagraphWithoutCaption = hasExplicitImageOnlyParagraphWithoutCaption
     ? !!opt.imageOnlyParagraphWithoutCaption
     : !!opt.oneImageWithoutCaption
-  opt.oneImageWithoutCaption = !!opt.oneImageWithoutCaption
   if (!hasExplicitLabelClassFollowsFigure && opt.figureToLabelClassMap) {
     opt.labelClassFollowsFigure = true
   }
@@ -1305,7 +1363,6 @@ const mditFigureWithPCaption = (md, option) => {
   opt.markRegState = getMarkRegStateForLanguages(opt.languages)
   opt.preferredLanguages = normalizePreferredLanguages(opt.preferredLanguages, opt.markRegState.languages)
   if (opt.preferredLanguages.length === 0) opt.preferredLanguages = null
-  opt.normalizedOptionLanguages = normalizePreferredLanguages(opt.languages, opt.markRegState.languages)
   opt.shouldResolvePreferredLanguages = needsPreferredLanguagesResolution(opt)
   validateFallbackCaptionLabelOption('autoAltCaption', opt.autoAltCaption, opt.markRegState)
   validateFallbackCaptionLabelOption('autoTitleCaption', opt.autoTitleCaption, opt.markRegState)
@@ -1315,12 +1372,27 @@ const mditFigureWithPCaption = (md, option) => {
     audio: !!opt.audioWithoutCaption,
     iframeTypeBlockquote: !!opt.iframeTypeBlockquoteWithoutCaption,
   }
-  // Normalize option shorthands now so downstream logic works with a consistent { img, table } shape.
-  opt.autoLabelNumberSets = normalizeAutoLabelNumberSets(opt.autoLabelNumberSets)
-  if (opt.autoLabelNumber && !hasExplicitAutoLabelNumberSets) {
-    opt.autoLabelNumberSets.img = true
-    opt.autoLabelNumberSets.table = true
-  }
+  const requestedAutoLabelNumberSets = hasExplicitAutoLabelNumberSets
+    ? option.autoLabelNumberSets
+    : opt.autoLabelNumber
+      ? ['img', 'table']
+      : []
+  opt.autoLabelNumberSets = normalizeAutoLabelNumberSets(requestedAutoLabelNumberSets)
+  const enabledNumberingMarks = getEnabledCaptionNumberingMarks(opt.autoLabelNumberSets, opt)
+  opt.normalizedAutoLabelNumberPolicy = enabledNumberingMarks.length === 0 &&
+    opt.autoLabelNumberPolicy === undefined
+    ? null
+    : normalizeFigureCaptionNumberingPolicy(opt.autoLabelNumberPolicy)
+  opt.captionNumberingPolicy = createFigureCaptionNumberingPolicy(
+    enabledNumberingMarks,
+    opt.normalizedAutoLabelNumberPolicy,
+    opt.markRegState,
+  )
+  opt.unscopedNumberingContext = opt.captionNumberingPolicy && opt.normalizedAutoLabelNumberPolicy
+    ? createUnscopedNumberingContext(
+      getFigureCaptionNumberingPolicyState(opt.normalizedAutoLabelNumberPolicy).separator,
+    )
+    : null
   const classPrefix = buildClassPrefix(opt.classPrefix)
   opt.figureClassPrefix = classPrefix
   opt.captionClassPrefix = classPrefix
@@ -1342,8 +1414,6 @@ const mditFigureWithPCaption = (md, option) => {
       defaultSlideFigureClass,
     )
   }
-  // Precompute label-class permutations so numbering lookup doesn't rebuild arrays per caption.
-  opt.labelClassLookup = buildLabelClassLookup(opt)
   const markerList = normalizeLabelPrefixMarkers(opt.labelPrefixMarker)
   opt.labelPrefixMarkerReg = buildLabelPrefixMarkerRegFromMarkers(markerList)
   opt.cleanCaptionRegCache = new Map()
@@ -1356,10 +1426,14 @@ const mditFigureWithPCaption = (md, option) => {
     opt.labelPrefixMarkerWithoutLabelNextReg = null
   }
 
-  //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.
+  // Run after markdown-it-attrs has attached paragraph attrs, but before text replacements.
   md.core.ruler.before('replacements', 'figure_with_caption', (state) => {
     figureWithCaption(state, opt)
   })
+  Object.defineProperty(md, installedKey, {
+    value: true,
+    configurable: true,
+  })
 }
 
 export default mditFigureWithPCaption