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

package/index.js

@@ -1,42 +1,198 @@
 import {
+  analyzeCaptionStart,
+  buildLabelClassLookup,
+  buildLabelPrefixMarkerRegFromMarkers,
+  getGeneratedLabelDefaults,
+  normalizeLabelPrefixMarkers,
   setCaptionParagraph,
   getMarkRegStateForLanguages,
+  stripLabelPrefixMarker,
 } from 'p7d-markdown-it-p-captions'
+import { detectHtmlFigureCandidate } from './embeds/detect.js'
 
-const htmlRegCache = new Map()
-const blueskyEmbedReg = /^<blockquote class="bluesky-embed"[^]*?>[\s\S]*?$/
-const videoIframeReg = /^<[^>]*? src="https:\/\/(?:www.youtube-nocookie.com|player.vimeo.com)\//i
-const classNameReg = /^<[^>]*? class="(twitter-tweet|instagram-media|text-post-media|bluesky-embed|mastodon-embed)"/
 const imageAttrsReg = /^ *\{(.*?)\} *$/
 const classAttrReg = /^\./
 const idAttrReg = /^#/
-const attrParseReg = /^(.*?)="?(.*)"?$/
 const sampLangReg = /^ *(?:samp|shell|console)(?:(?= )|$)/
-const endBlockquoteScriptReg = /<\/blockquote> *<script[^>]*?><\/script>$/
-const iframeTagReg = /<iframe(?=[\s>])/i
 const asciiLabelReg = /^[A-Za-z]/
+const attrNameReg = /^[^\s=]+$/
+const labelTrailingJointReg = /[.\u3002\uff0e:：]\s*$/
 const CHECK_TYPE_TOKEN_MAP = {
   table_open: 'table',
   pre_open: 'pre',
   blockquote_open: 'blockquote',
 }
-const HTML_TAG_DETECTORS = [
-  { candidate: 'video', lookupTag: 'video', hintKey: 'hasVideoHint' },
-  { candidate: 'audio', lookupTag: 'audio', hintKey: 'hasAudioHint' },
-  { candidate: 'iframe', lookupTag: 'iframe', hintKey: 'hasIframeHint' },
-  { candidate: 'blockquote', lookupTag: 'blockquote', hintKey: 'hasBlockquoteHint' },
-  {
-    candidate: 'div',
-    lookupTag: 'div',
-    hintKey: 'hasDivHint',
-    requiresIframeTag: true,
-    matchedTag: 'iframe',
-    setVideoIframe: true,
-  },
-]
-const fallbackLabelDefaults = { en: 'Figure', ja: '図' }
-
 const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+const normalizeLanguageCode = (value) => {
+  if (value === null || value === undefined) return ''
+  const normalized = String(value).trim().toLowerCase()
+  if (!normalized) return ''
+  const separatorIndex = normalized.search(/[-_]/)
+  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
+  target.push(lang)
+  return true
+}
+const normalizePreferredLanguages = (value, availableLanguages) => {
+  if (!Array.isArray(availableLanguages) || availableLanguages.length === 0) return []
+  const languages = []
+  if (typeof value === 'string') {
+    appendAvailableLanguage(languages, normalizeLanguageCode(value), availableLanguages)
+    return languages
+  }
+  const source = Array.isArray(value) ? value : []
+  if (source.length === 0) return languages
+  for (let i = 0; i < source.length; i++) {
+    const lang = normalizeLanguageCode(source[i])
+    appendAvailableLanguage(languages, lang, availableLanguages)
+  }
+  return languages
+}
+const prioritizeLanguages = (languages, preferredLanguages) => {
+  if (!Array.isArray(languages) || languages.length === 0) return []
+  if (typeof preferredLanguages === 'string') {
+    if (!preferredLanguages || languages.indexOf(preferredLanguages) === -1) return languages
+    if (languages[0] === preferredLanguages) return languages
+    const prioritized = [preferredLanguages]
+    for (let i = 0; i < languages.length; i++) {
+      appendAvailableLanguage(prioritized, languages[i], languages)
+    }
+    return prioritized
+  }
+  if (!Array.isArray(preferredLanguages) || preferredLanguages.length === 0) return languages
+  const prioritized = []
+  for (let i = 0; i < preferredLanguages.length; i++) {
+    appendAvailableLanguage(prioritized, preferredLanguages[i], languages)
+  }
+  if (prioritized.length === 0) return languages
+  for (let i = 0; i < languages.length; i++) {
+    appendAvailableLanguage(prioritized, languages[i], languages)
+  }
+  return prioritized
+}
+const isAsciiAlphaCode = (code) => {
+  return (code >= 0x41 && code <= 0x5a) || (code >= 0x61 && code <= 0x7a)
+}
+const isJapaneseCharCode = (code) => {
+  return (
+    (code >= 0x3040 && code <= 0x30ff) ||
+    (code >= 0x31f0 && code <= 0x31ff) ||
+    (code >= 0x4e00 && code <= 0x9fff) ||
+    (code >= 0xff66 && code <= 0xff9f)
+  )
+}
+const isHyphenFenceLine = (src, lineStart) => {
+  if (typeof src !== 'string' || lineStart < 0 || lineStart >= src.length) return 0
+  let index = lineStart
+  let hyphenCount = 0
+  while (index < src.length && src.charCodeAt(index) === 0x2d) {
+    hyphenCount++
+    index++
+  }
+  if (hyphenCount < 3) return 0
+  while (index < src.length && src.charCodeAt(index) === 0x20) {
+    index++
+  }
+  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
+  let lineStart = src.indexOf('\n')
+  if (lineStart === -1) return src
+  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)
+    }
+    const nextLineStart = src.indexOf('\n', lineStart)
+    if (nextLineStart === -1) break
+    lineStart = nextLineStart + 1
+  }
+  return src
+}
+const detectDocumentPrimaryLanguage = (src, availableLanguages) => {
+  if (!src || availableLanguages.indexOf('ja') === -1) return ''
+  const body = skipLeadingFrontmatter(src)
+  const limit = Math.min(body.length, 8192)
+  let japaneseCount = 0
+  let asciiAlphaCount = 0
+  for (let i = 0; i < limit; i++) {
+    const code = body.charCodeAt(i)
+    if (isJapaneseCharCode(code)) {
+      japaneseCount++
+      continue
+    }
+    if (isAsciiAlphaCode(code)) {
+      asciiAlphaCount++
+    }
+  }
+  if (japaneseCount === 0) return ''
+  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 &&
+    opt.markRegState &&
+    Array.isArray(opt.markRegState.languages)
+  ) ? 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 env = state && state.env ? state.env : null
+
+  const envLocale = normalizeLanguageCode(env && env.locale)
+  if (envLocale && baseLanguages.indexOf(envLocale) !== -1) {
+    return prioritizeLanguages(baseLanguages, envLocale)
+  }
+
+  const envPreferredLocales = normalizePreferredLanguages(env && env.preferredLocales, baseLanguages)
+  if (envPreferredLocales.length > 0) {
+    return prioritizeLanguages(baseLanguages, envPreferredLocales)
+  }
+
+  const explicitPreferred = opt && Array.isArray(opt.preferredLanguages)
+    ? opt.preferredLanguages
+    : []
+  if (explicitPreferred.length > 0) {
+    return prioritizeLanguages(baseLanguages, explicitPreferred)
+  }
+
+  const envPreferred = normalizePreferredLanguages(env && env.preferredLanguages, baseLanguages)
+  if (envPreferred.length > 0) {
+    return prioritizeLanguages(baseLanguages, envPreferred)
+  }
+
+  const envLanguage = normalizeLanguageCode(env && (env.preferredLanguage || env.lang || env.language))
+  if (envLanguage && baseLanguages.indexOf(envLanguage) !== -1) {
+    return prioritizeLanguages(baseLanguages, envLanguage)
+  }
+
+  const detectedLanguage = detectDocumentPrimaryLanguage(state && state.src ? state.src : '', baseLanguages)
+  if (detectedLanguage) {
+    return prioritizeLanguages(baseLanguages, detectedLanguage)
+  }
+  return baseLanguages
+}
+const needsPreferredLanguagesResolution = (opt) => {
+  if (!opt || !opt.markRegState || !Array.isArray(opt.markRegState.languages)) 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()
@@ -50,36 +206,6 @@ const normalizeClassOptionWithFallback = (value, fallbackValue) => {
   const normalized = normalizeOptionalClassName(value)
   return normalized || fallbackValue
 }
-const normalizeLanguages = (value) => {
-  if (!Array.isArray(value)) return ['en', 'ja']
-  const normalized = []
-  const seen = new Set()
-  for (let i = 0; i < value.length; i++) {
-    const lang = value[i]
-    if (typeof lang !== 'string') continue
-    const trimmed = lang.trim()
-    if (!trimmed || seen.has(trimmed)) continue
-    seen.add(trimmed)
-    normalized.push(trimmed)
-  }
-  if (normalized.length === 0) return ['en', 'ja']
-  return normalized
-}
-const normalizeLabelPrefixMarkers = (value) => {
-  if (typeof value === 'string') {
-    return value ? [value] : []
-  }
-  if (Array.isArray(value)) {
-    const normalized = value.map(entry => String(entry)).filter(Boolean)
-    return normalized.length > 2 ? normalized.slice(0, 2) : normalized
-  }
-  return []
-}
-const buildLabelPrefixMarkerRegFromList = (markers) => {
-  if (!markers || markers.length === 0) return null
-  const pattern = markers.map(escapeRegExp).join('|')
-  return new RegExp('^(?:' + pattern + ')(?:[ \\t　]+)?')
-}
 const resolveLabelPrefixMarkerPair = (markers) => {
   if (!markers || markers.length === 0) return { prev: [], next: [] }
   if (markers.length === 1) {
@@ -87,26 +213,6 @@ const resolveLabelPrefixMarkerPair = (markers) => {
   }
   return { prev: [markers[0]], next: [markers[1]] }
 }
-const stripLeadingPrefix = (text, prefix) => {
-  if (typeof text !== 'string' || !text || !prefix) return text
-  if (text.startsWith(prefix)) return text.slice(prefix.length)
-  return text
-}
-const stripLabelPrefixMarkerFromInline = (inlineToken, markerText) => {
-  if (!inlineToken || !markerText) return
-  if (typeof inlineToken.content === 'string') {
-    inlineToken.content = stripLeadingPrefix(inlineToken.content, markerText)
-  }
-  if (inlineToken.children && inlineToken.children.length) {
-    for (let i = 0; i < inlineToken.children.length; i++) {
-      const child = inlineToken.children[i]
-      if (child && child.type === 'text' && typeof child.content === 'string') {
-        child.content = stripLeadingPrefix(child.content, markerText)
-        break
-      }
-    }
-  }
-}
 const getLabelPrefixMarkerMatch = (inlineToken, markerReg) => {
   if (!markerReg || !inlineToken || inlineToken.type !== 'inline') return null
   const content = typeof inlineToken.content === 'string' ? inlineToken.content : ''
@@ -118,10 +224,62 @@ const getLabelPrefixMarkerMatch = (inlineToken, markerReg) => {
   return match[0]
 }
 
-const parseImageAttrs = (raw) => {
+const splitImageAttrParts = (raw) => {
   if (raw === null || raw === undefined) return null
+  const parts = []
+  let current = ''
+  let quote = ''
+  let escaped = false
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i]
+    if (quote) {
+      current += ch
+      if (escaped) {
+        escaped = false
+        continue
+      }
+      if (ch === '\\') {
+        escaped = true
+        continue
+      }
+      if (ch === quote) {
+        quote = ''
+      }
+      continue
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch
+      current += ch
+      continue
+    }
+    if (ch === ' ') {
+      if (current) {
+        parts.push(current)
+        current = ''
+      }
+      continue
+    }
+    current += ch
+  }
+  if (quote) return null
+  if (current) parts.push(current)
+  return parts
+}
+
+const unquoteAttrValue = (value) => {
+  if (typeof value !== 'string' || value.length < 2) return value || ''
+  const first = value[0]
+  const last = value[value.length - 1]
+  if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+    return value.slice(1, -1).replace(/\\(["'\\])/g, '$1')
+  }
+  return value
+}
+
+const parseImageAttrs = (raw) => {
+  const parts = splitImageAttrParts(raw)
+  if (!parts || parts.length === 0) return null
   const attrs = []
-  const parts = raw.split(/ +/)
   for (let i = 0; i < parts.length; i++) {
     let entry = parts[i]
     if (!entry) continue
@@ -130,9 +288,15 @@ const parseImageAttrs = (raw) => {
     } else if (idAttrReg.test(entry)) {
       entry = entry.replace(idAttrReg, 'id=')
     }
-    const imageAttr = entry.match(attrParseReg)
-    if (!imageAttr || !imageAttr[1]) continue
-    attrs.push([imageAttr[1], imageAttr[2]])
+    const equalIndex = entry.indexOf('=')
+    if (equalIndex === -1) {
+      if (!attrNameReg.test(entry)) return null
+      attrs.push([entry, ''])
+      continue
+    }
+    const name = entry.slice(0, equalIndex)
+    if (!name || !attrNameReg.test(name)) return null
+    attrs.push([name, unquoteAttrValue(entry.slice(equalIndex + 1))])
   }
   return attrs
 }
@@ -149,20 +313,6 @@ const normalizeAutoLabelNumberSets = (value) => {
   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.autoLabelNumberSets
   if (!setting) return false
@@ -241,60 +391,43 @@ const getImageAltText = (token) => {
 
 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
+const getFallbackStringLabelJoint = (label) => {
+  if (!label) return ''
+  if (labelTrailingJointReg.test(label)) {
+    return asciiLabelReg.test(label) ? ' ' : ''
   }
-  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
-  )
+  return asciiLabelReg.test(label) ? '. ' : '　'
 }
 
-const isSentenceBoundaryChar = (char) => {
-  return char === '.' || char === '!' || char === '?' || char === '。' || char === '！' || char === '？'
-}
-
-const getAutoFallbackLabel = (text) => {
-  const lang = detectCaptionLanguage(text)
-  if (lang === 'ja') return fallbackLabelDefaults.ja || fallbackLabelDefaults.en || ''
-  return fallbackLabelDefaults.en || fallbackLabelDefaults.ja || ''
-}
-
-const getPersistedFallbackLabel = (text, fallbackState) => {
-  if (!fallbackState) return getAutoFallbackLabel(text)
-  if (fallbackState.img) return fallbackState.img
-  const resolved = getAutoFallbackLabel(text)
-  fallbackState.img = resolved
-  return resolved
-}
-
-const buildCaptionWithFallback = (text, fallbackOption, fallbackState) => {
+const buildCaptionWithFallback = (text, fallbackOption, mark, markRegState, preferredLanguages) => {
   const trimmedText = (text || '').trim()
   if (!fallbackOption) return ''
+  if (!trimmedText) return ''
   let label = ''
+  let generatedDefaults = null
   if (typeof fallbackOption === 'string') {
     label = fallbackOption.trim()
   } else if (fallbackOption === true) {
-    label = getPersistedFallbackLabel(trimmedText, fallbackState)
+    generatedDefaults = getGeneratedLabelDefaults(mark, trimmedText, markRegState, preferredLanguages)
+    label = generatedDefaults && generatedDefaults.label ? generatedDefaults.label : ''
+  }
+  if (!label) return fallbackOption === true ? '' : trimmedText
+  if (generatedDefaults) {
+    return label + (generatedDefaults.joint || '') + (generatedDefaults.space || '') + trimmedText
   }
-  if (!label) return trimmedText
-  const isAsciiLabel = asciiLabelReg.test(label)
-  if (!trimmedText) {
-    return isAsciiLabel ? label + '.' : label
+  return label + getFallbackStringLabelJoint(label) + trimmedText
+}
+
+const validateFallbackCaptionLabelOption = (optionName, fallbackOption, markRegState) => {
+  if (typeof fallbackOption !== 'string') return
+  const sampleCaption = buildCaptionWithFallback('caption', fallbackOption, 'img', markRegState, null)
+  const analysis = analyzeCaptionStart(sampleCaption, {
+    markRegState,
+    preferredMark: 'img',
+  })
+  if (!analysis || analysis.mark !== 'img' || analysis.kind !== 'caption') {
+    throw new Error(`${optionName} must be a string label recognized as an image caption by p7d-markdown-it-p-captions: ${fallbackOption}`)
   }
-  return label + (isAsciiLabel ? '. ' : '　') + trimmedText
 }
 
 const createAutoCaptionParagraph = (captionText, TokenConstructor) => {
@@ -322,12 +455,18 @@ const getCaptionInlineToken = (tokens, range, caption) => {
 }
 
 const hasClassName = (classAttr, className) => {
-  const index = classAttr.indexOf(className)
-  if (index === -1) return false
-  const end = index + className.length
-  if (index > 0 && classAttr.charCodeAt(index - 1) > 0x20) return false
-  if (end < classAttr.length && classAttr.charCodeAt(end) > 0x20) return false
-  return true
+  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) => {
@@ -420,154 +559,55 @@ const ensureAutoFigureNumbering = (tokens, range, caption, figureNumberState, op
   updateInlineTokenContent(inlineToken, originalText, newLabelText)
 }
 
-const matchAutoCaptionText = (text, reg) => {
-  if (!text || !reg) return ''
+const matchAutoCaptionText = (text, opt, preferredMark = 'img') => {
+  if (!text || !opt || !opt.markRegState) return ''
   const trimmed = text.trim()
-  if (trimmed && reg.test(trimmed)) return trimmed
+  if (!trimmed) return ''
+  const analysis = analyzeCaptionStart(trimmed, {
+    markRegState: opt.markRegState,
+    preferredMark,
+  })
+  if (analysis) return trimmed
   return ''
 }
 
-const getAutoCaptionFromImage = (imageToken, opt, fallbackLabelState) => {
-  const imgCaptionMarkReg = opt && opt.imgCaptionMarkReg ? opt.imgCaptionMarkReg : null
+const getAutoCaptionFromImage = (imageToken, opt) => {
   if (!opt.autoCaptionDetection) return ''
-  if (!imgCaptionMarkReg && !opt.autoAltCaption && !opt.autoTitleCaption) return ''
+  if (!opt.autoAltCaption && !opt.autoTitleCaption && !(opt.markRegState && opt.markRegState.markReg && opt.markRegState.markReg.img)) return ''
 
   const altText = getImageAltText(imageToken)
-  let caption = matchAutoCaptionText(altText, imgCaptionMarkReg)
+  let caption = matchAutoCaptionText(altText, opt)
   if (caption) {
     clearImageAltAttr(imageToken)
     return caption
   }
   if (!caption && opt.autoAltCaption) {
     const altForFallback = altText || ''
-    caption = buildCaptionWithFallback(altForFallback, opt.autoAltCaption, fallbackLabelState)
-    if (imageToken) {
+    const fallbackCaption = buildCaptionWithFallback(altForFallback, opt.autoAltCaption, 'img', opt.markRegState, opt.preferredLanguages)
+    if (fallbackCaption && imageToken) {
       clearImageAltAttr(imageToken)
     }
+    caption = fallbackCaption
   }
   if (caption) return caption
 
   const titleText = getImageTitleText(imageToken)
-  caption = matchAutoCaptionText(titleText, imgCaptionMarkReg)
+  caption = matchAutoCaptionText(titleText, opt)
   if (caption) {
     clearImageTitleAttr(imageToken)
     return caption
   }
   if (!caption && opt.autoTitleCaption) {
     const titleForFallback = titleText || ''
-    caption = buildCaptionWithFallback(titleForFallback, opt.autoTitleCaption, fallbackLabelState)
-    if (imageToken) {
+    const fallbackCaption = buildCaptionWithFallback(titleForFallback, opt.autoTitleCaption, 'img', opt.markRegState, opt.preferredLanguages)
+    if (fallbackCaption && imageToken) {
       clearImageTitleAttr(imageToken)
     }
+    caption = fallbackCaption
   }
   return caption
 }
 
-const getHtmlReg = (tag) => {
-  const cached = htmlRegCache.get(tag)
-  if (cached) return cached
-  const regexStr = `^<${tag} ?[^>]*?>[\\s\\S]*?<\\/${tag}>(\\n| *?)(<script [^>]*?>(?:<\\/script>)?)? *(\\n|$)`
-  const reg = new RegExp(regexStr)
-  htmlRegCache.set(tag, reg)
-  return reg
-}
-
-const getHtmlDetectionHints = (content) => {
-  const hasBlueskyHint = content.indexOf('bluesky-embed') !== -1
-  const hasVideoHint = content.indexOf('<video') !== -1
-  const hasAudioHint = content.indexOf('<audio') !== -1
-  const hasIframeHint = content.indexOf('<iframe') !== -1
-  const hasBlockquoteHint = content.indexOf('<blockquote') !== -1
-  const hasDivHint = content.indexOf('<div') !== -1
-  return {
-    hasBlueskyHint,
-    hasVideoHint,
-    hasAudioHint,
-    hasIframeHint,
-    hasBlockquoteHint,
-    hasDivHint,
-    hasIframeTag: hasIframeHint || (hasDivHint && iframeTagReg.test(content)),
-    hasBlueskyEmbed: hasBlueskyHint && blueskyEmbedReg.test(content),
-  }
-}
-
-const hasAnyHtmlDetectionHint = (hints) => {
-  return !!(
-    hints.hasBlueskyHint ||
-    hints.hasVideoHint ||
-    hints.hasAudioHint ||
-    hints.hasIframeHint ||
-    hints.hasBlockquoteHint ||
-    hints.hasDivHint
-  )
-}
-
-const appendHtmlBlockNewlineIfNeeded = (token, hasTag) => {
-  if ((hasTag[2] && hasTag[3] !== '\n') || (hasTag[1] !== '\n' && hasTag[2] === undefined)) {
-    token.content += '\n'
-  }
-}
-
-const consumeBlockquoteEmbedScript = (tokens, token, startIndex) => {
-  let addedCont = ''
-  let j = startIndex + 1
-  while (j < tokens.length) {
-    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 = ''
-      if (nextToken.children) {
-        for (let k = 0; k < nextToken.children.length; k++) {
-          nextToken.children[k].content = ''
-        }
-      }
-      break
-    }
-    if (nextToken.type === 'paragraph_open') {
-      addedCont += '\n'
-      tokens.splice(j, 1)
-      continue
-    }
-    j++
-  }
-  token.content += addedCont
-}
-
-const detectHtmlTagCandidate = (tokens, token, startIndex, detector, hints, sp) => {
-  if (detector.requiresIframeTag && !hints.hasIframeTag) return ''
-  const hasTagHint = !!(detector.hintKey && hints[detector.hintKey])
-  const allowBlueskyFallback = detector.candidate === 'blockquote' && hints.hasBlueskyEmbed
-  if (!hasTagHint && !allowBlueskyFallback) return ''
-  const hasTag = hasTagHint ? token.content.match(getHtmlReg(detector.lookupTag)) : null
-  const isBlueskyBlockquote = detector.candidate === 'blockquote' && !hasTag && hints.hasBlueskyEmbed
-  if (!hasTag && !isBlueskyBlockquote) return ''
-  if (hasTag) {
-    appendHtmlBlockNewlineIfNeeded(token, hasTag)
-    if (detector.setVideoIframe) {
-      sp.isVideoIframe = true
-    }
-    return detector.matchedTag || detector.candidate
-  }
-  consumeBlockquoteEmbedScript(tokens, token, startIndex)
-  return 'blockquote'
-}
-
-const isIframeTypeEmbedBlockquote = (content) => {
-  return content.indexOf('class="') !== -1 && classNameReg.test(content)
-}
-
-const resolveHtmlWrapWithoutCaption = (matchedTag, sp, opt) => {
-  const htmlWrapWithoutCaption = opt.htmlWrapWithoutCaption
-  if (!htmlWrapWithoutCaption) return false
-  if (matchedTag === 'blockquote') {
-    return !!(sp.isIframeTypeBlockquote && htmlWrapWithoutCaption.iframeTypeBlockquote)
-  }
-  return !!htmlWrapWithoutCaption[matchedTag]
-}
-
 const checkPrevCaption = (tokens, n, caption, sp, opt, captionState) => {
   if(n < 3) return caption
   const captionStartToken = tokens[n-3]
@@ -579,11 +619,11 @@ const checkPrevCaption = (tokens, n, caption, sp, opt, captionState) => {
   const captionName = sp && sp.captionDecision ? sp.captionDecision.mark : ''
   if(!captionName) {
     if (opt.labelPrefixMarkerWithoutLabelPrevReg) {
-      const markerMatch = getLabelPrefixMarkerMatch(captionInlineToken, opt.labelPrefixMarkerWithoutLabelPrevReg)
-      if (markerMatch) {
-        stripLabelPrefixMarkerFromInline(captionInlineToken, markerMatch)
-        caption.isPrev = true
-      }
+        const markerMatch = getLabelPrefixMarkerMatch(captionInlineToken, opt.labelPrefixMarkerWithoutLabelPrevReg)
+        if (markerMatch) {
+          stripLabelPrefixMarker(captionInlineToken, markerMatch)
+          caption.isPrev = true
+        }
     }
     return
   }
@@ -603,11 +643,11 @@ const checkNextCaption = (tokens, en, caption, sp, opt, captionState) => {
   const captionName = sp && sp.captionDecision ? sp.captionDecision.mark : ''
   if(!captionName) {
     if (opt.labelPrefixMarkerWithoutLabelNextReg) {
-      const markerMatch = getLabelPrefixMarkerMatch(captionInlineToken, opt.labelPrefixMarkerWithoutLabelNextReg)
-      if (markerMatch) {
-        stripLabelPrefixMarkerFromInline(captionInlineToken, markerMatch)
-        caption.isNext = true
-      }
+        const markerMatch = getLabelPrefixMarkerMatch(captionInlineToken, opt.labelPrefixMarkerWithoutLabelNextReg)
+        if (markerMatch) {
+          stripLabelPrefixMarker(captionInlineToken, markerMatch)
+          caption.isNext = true
+        }
     }
     return
   }
@@ -676,59 +716,117 @@ 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)
   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(n + 2, 0, captionStartToken, captionInlineToken, captionEndToken)
   tokens.splice(n-3, 3)
   return true
 }
 
 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]
+  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+5, 3)
+  tokens.splice(en+4, 3)
   return true
 }
 
+const getTokenMap = (token) => {
+  return token && Array.isArray(token.map) && token.map.length === 2 ? token.map : null
+}
+
+const findNearestMapInRange = (tokens, start, end, step) => {
+  let i = start
+  while (step > 0 ? i <= end : i >= end) {
+    const map = getTokenMap(tokens[i])
+    if (map) return map
+    i += step
+  }
+  return null
+}
+
+const getRangeMap = (tokens, start, end) => {
+  const startMap = getTokenMap(tokens[start]) || findNearestMapInRange(tokens, start, end, 1)
+  if (!startMap) return null
+  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]
+}
+
+const getTokenLevel = (token, fallback = 0) => {
+  return token && typeof token.level === 'number' ? token.level : fallback
+}
+
+const adjustTokenLevels = (tokens, start, end, delta) => {
+  if (!delta) return
+  for (let i = start; i <= end; i++) {
+    const token = tokens[i]
+    if (token && typeof token.level === 'number') {
+      token.level += delta
+    }
+  }
+}
+
 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.block = true
+  figureStartToken.level = baseLevel
 
   if (opt.roleDocExample && (checkTokenTagName === 'pre-code' || checkTokenTagName === 'pre-samp')) {
     figureStartToken.attrSet('role', 'doc-example')
   }
   const figureEndToken = new TokenConstructor('figure_close', 'figure', -1)
-  const rangeStartMap = tokens[n] && Array.isArray(tokens[n].map) && tokens[n].map.length === 2
-    ? tokens[n].map
-    : null
-  const rangeEndMap = tokens[en] && Array.isArray(tokens[en].map) && tokens[en].map.length === 2
-    ? tokens[en].map
-    : rangeStartMap
-  if (rangeStartMap) {
-    figureStartToken.map = [rangeStartMap[0], rangeStartMap[1]]
-  }
-  if (rangeEndMap) {
-    figureEndToken.map = [rangeEndMap[0], rangeEndMap[1]]
+  figureEndToken.block = true
+  figureEndToken.level = baseLevel
+  const rangeMap = getRangeMap(tokens, n, en)
+  if (rangeMap) {
+    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
@@ -743,12 +841,13 @@ const wrapWithFigure = (tokens, range, checkTokenTagName, caption, replaceInstea
     joinAttrs(tokens[n].attrs)
   }
   if (replaceInsteadOfWrap) {
-    tokens.splice(en, 1, createBreakToken(), figureEndToken, createBreakToken())
-    tokens.splice(n, 1, figureStartToken, createBreakToken())
+    tokens.splice(en, 1, createBreakToken(), figureEndToken)
+    tokens.splice(n, 1, figureStartToken, createEmptyTextToken())
     en = en + 2
   } else {
-    tokens.splice(en+1, 0, figureEndToken, createBreakToken())
-    tokens.splice(n, 0, figureStartToken, createBreakToken())
+    adjustTokenLevels(tokens, n, en, 1)
+    tokens.splice(en+1, 0, figureEndToken)
+    tokens.splice(n, 0, figureStartToken, createEmptyTextToken())
     en = en + 3
   }
   range.start = n
@@ -852,38 +951,6 @@ const detectFenceToken = (token, n, caption) => {
   }
 }
 
-const detectHtmlBlockToken = (tokens, token, n, caption, sp, opt) => {
-  if (!token || token.type !== 'html_block') return null
-  const hints = getHtmlDetectionHints(token.content)
-  if (!hasAnyHtmlDetectionHint(hints)) return null
-  let matchedTag = ''
-  for (let i = 0; i < HTML_TAG_DETECTORS.length; i++) {
-    matchedTag = detectHtmlTagCandidate(tokens, token, n, HTML_TAG_DETECTORS[i], hints, sp)
-    if (matchedTag) break
-  }
-  if (!matchedTag) return null
-  if (matchedTag === 'blockquote') {
-    if (isIframeTypeEmbedBlockquote(token.content)) {
-      sp.isIframeTypeBlockquote = true
-    } else {
-      return null
-    }
-  }
-  if (matchedTag === 'iframe' && videoIframeReg.test(token.content)) {
-    sp.isVideoIframe = true
-  }
-  caption.name = matchedTag
-  const wrapWithoutCaption = resolveHtmlWrapWithoutCaption(matchedTag, sp, opt)
-  return {
-    type: 'html',
-    tagName: matchedTag,
-    en: n,
-    replaceInsteadOfWrap: false,
-    wrapWithoutCaption,
-    canWrap: true,
-  }
-}
-
 const hasLeadingImageChild = (token) => {
   return !!(token &&
     token.type === 'inline' &&
@@ -896,7 +963,7 @@ const hasLeadingImageChild = (token) => {
 const detectImageParagraph = (nextToken, n, caption, sp, opt) => {
   const multipleImagesEnabled = !!opt.multipleImages
   const styleProcessEnabled = !!opt.styleProcess
-  const allowSingleImageWithoutCaption = !!opt.oneImageWithoutCaption
+  const allowImageParagraphWithoutCaption = !!opt.imageOnlyParagraphWithoutCaption
   const children = nextToken.children
   const imageToken = children[0]
   const childrenLength = children.length
@@ -911,7 +978,7 @@ const detectImageParagraph = (nextToken, n, caption, sp, opt) => {
       tagName: 'img',
       en: n + 2,
       replaceInsteadOfWrap: true,
-      wrapWithoutCaption: allowSingleImageWithoutCaption,
+      wrapWithoutCaption: allowImageParagraphWithoutCaption,
       canWrap: true,
       imageToken,
     }
@@ -935,13 +1002,13 @@ const detectImageParagraph = (nextToken, n, caption, sp, opt) => {
         const imageAttrs = rawContent.match(imageAttrsReg)
         if (imageAttrs) {
           const parsedAttrs = parseImageAttrs(imageAttrs[1])
-          if (parsedAttrs && parsedAttrs.length) {
+          if (parsedAttrs) {
             for (let i = 0; i < parsedAttrs.length; i++) {
               sp.attrs.push(parsedAttrs[i])
             }
             child.content = ''
+            break
           }
-          break
         }
       }
       if (typeof rawContent === 'string' && rawContent.trim()) {
@@ -992,7 +1059,7 @@ const detectImageParagraph = (nextToken, n, caption, sp, opt) => {
     tagName,
     en,
     replaceInsteadOfWrap: true,
-    wrapWithoutCaption: isValid && allowSingleImageWithoutCaption,
+    wrapWithoutCaption: isValid && allowImageParagraphWithoutCaption,
     canWrap: isValid,
     imageToken,
   }
@@ -1004,15 +1071,19 @@ const figureWithCaption = (state, opt) => {
     table: 0,
   }
 
-  const fallbackLabelState = {
-    img: null,
-  }
-
   const captionState = { tokens: state.tokens, Token: state.Token }
-  figureWithCaptionCore(state.tokens, opt, figureNumberState, fallbackLabelState, state.Token, captionState, null, 0)
+  const shouldResolvePreferredLanguages = !!(
+    opt.shouldResolvePreferredLanguages &&
+    sourceMayNeedPreferredLanguages(state)
+  )
+  const renderOpt = shouldResolvePreferredLanguages ? Object.create(opt) : opt
+  if (shouldResolvePreferredLanguages) {
+    renderOpt.preferredLanguages = resolvePreferredLanguagesForState(state, opt)
+  }
+  figureWithCaptionCore(state.tokens, renderOpt, figureNumberState, state.Token, captionState, null, 0)
 }
 
-const figureWithCaptionCore = (tokens, opt, figureNumberState, fallbackLabelState, TokenConstructor, captionState, parentType = null, startIndex = 0) => {
+const figureWithCaptionCore = (tokens, opt, figureNumberState, TokenConstructor, captionState, parentType = null, startIndex = 0) => {
   const rRange = { start: startIndex, end: startIndex }
   const rCaption = {
     name: '', nameSuffix: '', isPrev: false, isNext: false
@@ -1030,7 +1101,7 @@ const figureWithCaptionCore = (tokens, opt, figureNumberState, fallbackLabelStat
     const containerType = getNestedContainerType(token)
 
     if (containerType && containerType !== 'blockquote') {
-      const closeIndex = figureWithCaptionCore(tokens, opt, figureNumberState, fallbackLabelState, TokenConstructor, captionState, containerType, n + 1)
+      const closeIndex = figureWithCaptionCore(tokens, opt, figureNumberState, TokenConstructor, captionState, containerType, n + 1)
       n = (typeof closeIndex === 'number' ? closeIndex : n) + 1
       continue
     }
@@ -1055,7 +1126,12 @@ const figureWithCaptionCore = (tokens, opt, figureNumberState, fallbackLabelStat
       resetRangeState(rRange, n)
       resetCaptionState(rCaption)
       resetSpecialState(rSp)
-      detection = detectHtmlBlockToken(tokens, token, n, rCaption, rSp, opt)
+      detection = detectHtmlFigureCandidate(tokens, token, n, opt.htmlWrapWithoutCaption)
+      if (detection) {
+        rCaption.name = detection.tagName
+        rSp.isVideoIframe = !!detection.isVideoIframe
+        rSp.isIframeTypeBlockquote = !!detection.isIframeTypeBlockquote
+      }
     } else if (tokenType === 'fence') {
       resetRangeState(rRange, n)
       resetCaptionState(rCaption)
@@ -1070,7 +1146,7 @@ const figureWithCaptionCore = (tokens, opt, figureNumberState, fallbackLabelStat
 
     if (!detection) {
       if (containerType === 'blockquote') {
-        const closeIndex = figureWithCaptionCore(tokens, opt, figureNumberState, fallbackLabelState, TokenConstructor, captionState, containerType, n + 1)
+        const closeIndex = figureWithCaptionCore(tokens, opt, figureNumberState, TokenConstructor, captionState, containerType, n + 1)
         n = (typeof closeIndex === 'number' ? closeIndex : n) + 1
       } else {
         n++
@@ -1087,7 +1163,7 @@ const figureWithCaptionCore = (tokens, opt, figureNumberState, fallbackLabelStat
     let hasCaption = rCaption.isPrev || rCaption.isNext
     let pendingAutoCaption = ''
     if (!hasCaption && detection.type === 'image' && opt.autoCaptionDetection) {
-      pendingAutoCaption = getAutoCaptionFromImage(detection.imageToken, opt, fallbackLabelState)
+      pendingAutoCaption = getAutoCaptionFromImage(detection.imageToken, opt)
       if (pendingAutoCaption) {
         hasCaption = true
       }
@@ -1096,7 +1172,7 @@ const figureWithCaptionCore = (tokens, opt, figureNumberState, fallbackLabelStat
     if (detection.canWrap === false) {
       let nextIndex = rRange.end + 1
       if (containerType === 'blockquote') {
-        const closeIndex = figureWithCaptionCore(tokens, opt, figureNumberState, fallbackLabelState, TokenConstructor, captionState, containerType, rRange.start + 1)
+        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
@@ -1151,7 +1227,7 @@ const figureWithCaptionCore = (tokens, opt, figureNumberState, fallbackLabelStat
     }
 
     if (containerType === 'blockquote') {
-      const closeIndex = figureWithCaptionCore(tokens, opt, figureNumberState, fallbackLabelState, TokenConstructor, captionState, containerType, rRange.start + 1)
+      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)
     }
@@ -1165,13 +1241,15 @@ const mditFigureWithPCaption = (md, option) => {
   let 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
 
     // --- figure-wrapper behavior ---
     classPrefix: 'f',
     figureClassThatWrapsIframeTypeBlockquote: null,
     figureClassThatWrapsSlides: null,
     styleProcess: true,
-    oneImageWithoutCaption: false,
+    imageOnlyParagraphWithoutCaption: false,
+    oneImageWithoutCaption: false, // legacy alias for imageOnlyParagraphWithoutCaption
     iframeWithoutCaption: false,
     videoWithoutCaption: false,
     audioWithoutCaption: false,
@@ -1210,20 +1288,27 @@ const mditFigureWithPCaption = (md, option) => {
     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')
   if (option) Object.assign(opt, option)
+  opt.imageOnlyParagraphWithoutCaption = hasExplicitImageOnlyParagraphWithoutCaption
+    ? !!opt.imageOnlyParagraphWithoutCaption
+    : !!opt.oneImageWithoutCaption
+  opt.oneImageWithoutCaption = !!opt.oneImageWithoutCaption
   if (!hasExplicitLabelClassFollowsFigure && opt.figureToLabelClassMap) {
     opt.labelClassFollowsFigure = true
   }
   opt.classPrefix = normalizeOptionalClassName(opt.classPrefix)
   opt.allIframeTypeFigureClassName = normalizeOptionalClassName(opt.allIframeTypeFigureClassName)
-  opt.languages = normalizeLanguages(opt.languages)
   opt.markRegState = getMarkRegStateForLanguages(opt.languages)
-  opt.imgCaptionMarkReg = opt.markRegState && opt.markRegState.markReg
-    ? opt.markRegState.markReg.img
-    : null
+  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)
   opt.htmlWrapWithoutCaption = {
     iframe: !!opt.iframeWithoutCaption,
     video: !!opt.videoWithoutCaption,
@@ -1260,12 +1345,12 @@ const mditFigureWithPCaption = (md, option) => {
   // Precompute label-class permutations so numbering lookup doesn't rebuild arrays per caption.
   opt.labelClassLookup = buildLabelClassLookup(opt)
   const markerList = normalizeLabelPrefixMarkers(opt.labelPrefixMarker)
-  opt.labelPrefixMarkerReg = buildLabelPrefixMarkerRegFromList(markerList)
+  opt.labelPrefixMarkerReg = buildLabelPrefixMarkerRegFromMarkers(markerList)
   opt.cleanCaptionRegCache = new Map()
   if (opt.allowLabelPrefixMarkerWithoutLabel === true) {
     const markerPair = resolveLabelPrefixMarkerPair(markerList)
-    opt.labelPrefixMarkerWithoutLabelPrevReg = buildLabelPrefixMarkerRegFromList(markerPair.prev)
-    opt.labelPrefixMarkerWithoutLabelNextReg = buildLabelPrefixMarkerRegFromList(markerPair.next)
+    opt.labelPrefixMarkerWithoutLabelPrevReg = buildLabelPrefixMarkerRegFromMarkers(markerPair.prev)
+    opt.labelPrefixMarkerWithoutLabelNextReg = buildLabelPrefixMarkerRegFromMarkers(markerPair.next)
   } else {
     opt.labelPrefixMarkerWithoutLabelPrevReg = null
     opt.labelPrefixMarkerWithoutLabelNextReg = null