@asciidoctor/core 4.0.0 → 4.0.2

package/build/node/index.cjs

@@ -1,11 +1,12 @@
 'use strict';
 
 const node_module = require('node:module');
+const node_url = require('node:url');
 const node_fs = require('node:fs');
 const path = require('node:path');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-var version = "4.0.0";
+var version = "4.0.2";
 const packageJson = {
 	version: version};
 
@@ -1752,14 +1753,23 @@ Logger.BasicFormatter = class {
 
 Logger.AutoFormattingMessage = {
   /**
-   * Attach auto-formatting to any plain object carrying { text, source_location }.
-   * @param {{text: string, source_location?: string}} obj
+   * Attach auto-formatting to any plain object carrying
+   * { text, source_location, include_location }.
+   *
+   * The location(s) are rendered only by inspect()/toString() (used when a
+   * stderr Logger formats the line); the structured `source_location` /
+   * `include_location` remain on the object so a MemoryLogger can record them
+   * on the resulting LogMessage without duplicating them inside `text`.
+   * @param {{text: string, source_location?: any, include_location?: any}} obj
    * @returns {typeof obj} The same object with inspect() and toString() added.
    */
   attach(obj) {
     obj.inspect = function () {
       const sloc = this.source_location;
-      return sloc ? `${sloc}: ${this.text}` : this.text
+      const iloc = this.include_location;
+      let text = sloc ? `${sloc}: ${this.text}` : this.text;
+      if (iloc) text += ` (${iloc})`;
+      return text
     };
     obj.toString = obj.inspect;
     return obj
@@ -1770,27 +1780,45 @@ Logger.AutoFormattingMessage = {
 
 /** Wrapper stored by MemoryLogger; provides getSeverity/getText/getSourceLocation. */
 class LogMessage {
+  /**
+   * @param {string} severity - Severity label, e.g. 'ERROR'.
+   * @param {string|{text: string, source_location?: import('./reader.js').Cursor}|null} message
+   */
   constructor(severity, message) {
     this.message = message;
+    /** @type {string} */
     this.severity = severity; // string label, e.g. 'ERROR'
     // AutoFormattingMessage objects carry { text, source_location }
     if (message !== null && typeof message === 'object' && 'text' in message) {
-      this._text = message.text;
-      this._sourceLocation = message.source_location ?? null;
+      /** @type {string} */
+      this.text = message.text;
+      /** @type {import('./reader.js').Cursor|null} */
+      this.sourceLocation = message.source_location ?? null;
     } else {
-      this._text = message != null ? String(message) : '';
-      this._sourceLocation = null;
+      this.text = message != null ? String(message) : '';
+      this.sourceLocation = null;
     }
   }
 
+  /**
+   * @returns {string} The severity label, e.g. 'ERROR'.
+   */
   getSeverity() {
     return this.severity
   }
+
+  /**
+   * @returns {string} The message text.
+   */
   getText() {
-    return this._text
+    return this.text
   }
+
+  /**
+   * @returns {import('./reader.js').Cursor|undefined} The source location, if any.
+   */
   getSourceLocation() {
-    return this._sourceLocation ?? undefined
+    return this.sourceLocation ?? undefined
   }
 }
 
@@ -1803,6 +1831,7 @@ class MemoryLogger {
     // matching Ruby's MemoryLogger (level: UNKNOWN). The add() method stores all
     // messages unconditionally — level is only used by the isDebug() guard.
     this.level = Severity.UNKNOWN;
+    /** @type {LogMessage[]} */
     this.messages = [];
   }
 
@@ -1810,6 +1839,9 @@ class MemoryLogger {
     return new MemoryLogger()
   }
 
+  /**
+   * @returns {LogMessage[]} The log messages recorded so far, in order.
+   */
   getMessages() {
     return this.messages
   }
@@ -3008,9 +3040,10 @@ class AbstractNode {
    * Construct a URI reference or data URI to the target image.
    *
    * If the target image is already a URI it is left untouched (unless data-uri
-   * conversion is requested). The image is resolved relative to the directory
-   * named by assetDirKey. When data-uri is enabled and the safe level permits,
-   * the image is embedded as a Base64 data URI.
+   * conversion is requested). If the target image is a data URI, then it is
+   * already an embedded image, so it is returned as-is. The image is resolved
+   * relative to the directory named by assetDirKey. When data-uri is enabled and
+   * the safe level permits, the image is embedded as a Base64 data URI.
    *
    * NOTE: When the document has both 'data-uri' and 'allow-uri-read' enabled
    * and the resolved image URL is a remote URI, this method returns a Promise
@@ -3021,6 +3054,8 @@ class AbstractNode {
    * @returns {Promise<string>} a Promise resolving to a String reference or data URI.
    */
   async imageUri(targetImage, assetDirKey = 'imagesdir') {
+    // A data URI is already an embedded image, so use it as-is rather than reading or re-encoding it.
+    if (targetImage.startsWith('data:')) return targetImage
     const doc = this.document;
     if (doc.safe < SafeMode.SECURE && doc.hasAttribute('data-uri')) {
       let imagesBase;
@@ -5428,7 +5463,18 @@ class SecurityError extends Error {
 function applyBackendTraits(instance) {
   instance._backendTraits = null;
 
-  instance.basebackend = function (value = null) {
+  // Install a Ruby-style trait accessor method, but never clobber a flat string
+  // property the converter already declared (convention #2). Overwriting e.g.
+  // `converter.outfilesuffix = '.html'` with a method would silently turn the
+  // author's string into a function; the backend traits stay reachable through
+  // `_getBackendTraits()` instead.
+  const defineTraitAccessor = (name, fn) => {
+    const existing = Object.getOwnPropertyDescriptor(instance, name);
+    if (existing && typeof existing.value !== 'function') return
+    instance[name] = fn;
+  };
+
+  defineTraitAccessor('basebackend', function (value = null) {
     if (value) {
       const traits = (this._backendTraits ??= {});
       traits.basebackend = value;
@@ -5442,19 +5488,19 @@ function applyBackendTraits(instance) {
       return value
     }
     return this._getBackendTraits().basebackend
-  };
-  instance.filetype = function (value = null) {
+  });
+  defineTraitAccessor('filetype', function (value = null) {
     if (value) return (this._getBackendTraits().filetype = value)
     return this._getBackendTraits().filetype
-  };
-  instance.htmlsyntax = function (value = null) {
+  });
+  defineTraitAccessor('htmlsyntax', function (value = null) {
     if (value) return (this._getBackendTraits().htmlsyntax = value)
     return this._getBackendTraits().htmlsyntax
-  };
-  instance.outfilesuffix = function (value = null) {
+  });
+  defineTraitAccessor('outfilesuffix', function (value = null) {
     if (value) return (this._getBackendTraits().outfilesuffix = value)
     return this._getBackendTraits().outfilesuffix
-  };
+  });
   instance.supportsTemplates = function (value = true) {
     this._getBackendTraits().supportsTemplates = value;
   };
@@ -5538,7 +5584,9 @@ function normalizeConverter(converter, backend) {
     }
   }
 
-  // Apply the BackendTraits mixin so Document can call the standard accessor methods.
+  // Apply the BackendTraits mixin so Document can read traits via
+  // _getBackendTraits(). Flat string properties (convention #2) are preserved:
+  // applyBackendTraits does not overwrite an existing same-named data property.
   applyBackendTraits(converter);
   if (traits) {
     converter._backendTraits = traits;
@@ -6275,7 +6323,7 @@ function resolveBrowserIncludePath(reader, target, attrlist) {
     // ── Rule 2: target is an absolute URL (http:// / https:// / …) ───────────
   } else if (isUriish(pTarget)) {
     const descends = pathResolver.descendsFrom(pTarget, baseDir);
-    if (descends === false && !doc.getAttribute('allow-uri-read')) {
+    if (descends === false && !doc.hasAttribute('allow-uri-read')) {
       return reader.replaceNextLine(_linkReplacement(reader, target, attrlist))
     }
     incPath = relpath = pTarget;
@@ -6309,7 +6357,7 @@ function resolveBrowserIncludePath(reader, target, attrlist) {
   } else {
     // Nested include: context dir is an absolute URL.
     const ctxDescends = pathResolver.descendsFrom(ctxDir, baseDir);
-    if (ctxDescends !== false || doc.getAttribute('allow-uri-read')) {
+    if (ctxDescends !== false || doc.hasAttribute('allow-uri-read')) {
       incPath = `${ctxDir}/${pTarget}`;
       relpath = ctxDescends !== false ? incPath.slice(ctxDescends) : pTarget;
     } else {
@@ -6973,22 +7021,34 @@ class Reader {
   }
 
   /** @param {string} msg @param {{ sourceLocation?: any, includeLocation?: any }} [opts] */
-  _logWarn(msg, { sourceLocation, includeLocation } = {}) {
-    let text = sourceLocation ? `${sourceLocation.lineInfo}: ${msg}` : msg;
-    if (includeLocation) text += ` (${includeLocation.lineInfo})`;
-    this.logger.warn(text);
+  _logWarn(msg, opts = {}) {
+    this.logger.warn(this._messageWithContext(msg, opts));
   }
   _logError(msg, opts = {}) {
-    let text = opts.sourceLocation
-      ? `${opts.sourceLocation.lineInfo}: ${msg}`
-      : msg;
-    if (opts.includeLocation) text += ` (${opts.includeLocation.lineInfo})`;
-    this.logger.error(text);
+    this.logger.error(this._messageWithContext(msg, opts));
   }
   /** @param {string} msg @param {{ sourceLocation?: any }} [opts] */
-  _logInfo(msg, { sourceLocation } = {}) {
-    const text = sourceLocation ? `${sourceLocation.lineInfo}: ${msg}` : msg;
-    this.logger.info(text);
+  _logInfo(msg, opts = {}) {
+    this.logger.info(this._messageWithContext(msg, opts));
+  }
+
+  /**
+   * Build an auto-formatting message that keeps the cursor as a structured
+   * source_location (rather than baking it into the text). When displayed by a
+   * stderr Logger the location is rendered as a "<path>: line <N>: " prefix, but
+   * a MemoryLogger records it separately on the LogMessage so consumers can call
+   * getSourceLocation(). Mirrors Ruby's Logging#message_with_context.
+   * @param {string} msg
+   * @param {{ sourceLocation?: any, includeLocation?: any }} [opts]
+   * @internal
+   */
+  _messageWithContext(msg, { sourceLocation, includeLocation } = {}) {
+    if (!sourceLocation && !includeLocation) return msg
+    return Logger.AutoFormattingMessage.attach({
+      text: msg,
+      source_location: sourceLocation ?? null,
+      include_location: includeLocation ?? null,
+    })
   }
 }
 
@@ -7746,7 +7806,7 @@ class PreprocessorReader extends Reader {
     }
 
     if (isUriish(target) || typeof this._dir !== 'string') {
-      if (!doc.getAttribute('allow-uri-read')) {
+      if (!doc.hasAttribute('allow-uri-read')) {
         this._logWarn(
           `cannot include contents of URI: ${target} (allow-uri-read attribute not enabled)`,
           { sourceLocation: this.cursor }
@@ -10356,7 +10416,12 @@ class Parser {
             }
           }
 (intro ?? section).blocks.push(newBlock);
-          for (const key of Object.keys(attributes)) delete attributes[key];
+          // Reset the shared attributes object for the next block. Use Reflect.ownKeys
+          // (not Object.keys) so the Symbol-keyed attribute entries (ATTR_ENTRIES_KEY)
+          // are cleared too; otherwise the array of AttributeEntry objects leaks and
+          // accumulates across blocks, causing reassigned attributes (e.g. a body-level
+          // `:name:` redefined later) to all resolve to the final value at playback time.
+          for (const key of Reflect.ownKeys(attributes)) delete attributes[key];
         }
       }
 
@@ -11203,7 +11268,13 @@ class Parser {
       }
     }
 
-    if (Object.keys(attributes).length > 0) block.updateAttributes(attributes);
+    // Reflect.ownKeys (not Object.keys) so a block carrying only Symbol-keyed
+    // attribute entries (ATTR_ENTRIES_KEY) — e.g. an `:attr:` entry immediately
+    // preceding a list or table — still receives them, matching Ruby's
+    // `attributes.empty?` where the `:attribute_entries` key is counted. Without this
+    // the entries are dropped and the attribute is not played back for that block.
+    if (Reflect.ownKeys(attributes).length > 0)
+      block.updateAttributes(attributes);
     block.commitSubs();
 
     if (block.hasSub('callouts')) {
@@ -16044,7 +16115,7 @@ class Document extends AbstractBlock {
 
     const attrOverrides = this._attributeOverrides;
     attrOverrides.asciidoctor = '';
-    attrOverrides['asciidoctor-version'] = '3.0.0.dev'; // matches Ruby VERSION
+    attrOverrides['asciidoctor-version'] = packageJson.version;
 
     const safeModeName = SafeMode.nameForValue(this.safe);
     attrOverrides['safe-mode-name'] = safeModeName;
@@ -16231,13 +16302,21 @@ class Document extends AbstractBlock {
     }
 
     // Pre-compute all async text values (titles, list item text, cell text, reftexts)
-    // so that synchronous getters work correctly during conversion.
-    await this._resolveAllTexts(this);
-    // Reset the footnote counter so that body-content footnotes (processed during conversion)
-    // start numbering from 1, reproducing Ruby's "out of sequence" quirk: title footnotes are
-    // numbered during parsing via apply_title_subs, then the counter restarts for body content.
-    delete this.attributes['footnote-number'];
-    delete this._counters['footnote-number'];
+    // so that synchronous getters work correctly during conversion. _resolveAllTexts
+    // replays attribute entries in document order (mirroring conversion) so body-level
+    // attribute (re)assignments are in scope; snapshot and restore the document
+    // attributes so the downstream steps and conversion still start from the restored
+    // (header) state, matching Ruby's restore_attributes-before-convert invariant.
+    //
+    // This runs in two passes because list item / table cell / dlist text may contain
+    // natural cross-references (e.g. <<Some section title>>) that resolve against the
+    // reftext→id map. Pass 1 substitutes titles and reftexts only, so every section
+    // reftext is known; the map is then built; pass 2 substitutes the block content
+    // text, where resolveId() can now match those natural references.
+    const attributesSnapshot = { ...this.attributes };
+    // Pass 1: titles + reftexts (no block content text yet).
+    await this._resolveAllTexts(this, false);
+    this._restoreAttributeSnapshot(attributesSnapshot);
     // Pre-compute reftext for all registered inline anchor nodes.
     for (const ref of Object.values(this.catalog.refs)) {
       if (ref && typeof ref.precomputeReftext === 'function') {
@@ -16246,6 +16325,15 @@ class Document extends AbstractBlock {
     }
     // Build the reftext→id lookup map so that resolveId() is synchronous.
     await this._buildReftextsMap();
+    // Pass 2: list item / table cell / dlist text, now that natural cross-references
+    // can be resolved against the reftext→id map.
+    await this._resolveAllTexts(this, true);
+    this._restoreAttributeSnapshot(attributesSnapshot);
+    // Reset the footnote counter so that body-content footnotes (processed during conversion)
+    // start numbering from 1, reproducing Ruby's "out of sequence" quirk: title footnotes are
+    // numbered during parsing via apply_title_subs, then the counter restarts for body content.
+    delete this.attributes['footnote-number'];
+    delete this._counters['footnote-number'];
 
     this._parsed = true;
     return this
@@ -17300,12 +17388,39 @@ class Document extends AbstractBlock {
       : ['attributes']
   }
 
+  /**
+   * @private
+   * Restore the document attributes to a previously captured snapshot, discarding any
+   * body-level (re)assignments replayed while pre-computing text. Mirrors Ruby's
+   * restore_attributes-before-convert invariant.
+   * @param {Object} snapshot - The attributes snapshot to restore.
+   */
+  _restoreAttributeSnapshot(snapshot) {
+    for (const key of Reflect.ownKeys(this.attributes))
+      delete this.attributes[key];
+    Object.assign(this.attributes, snapshot);
+  }
+
   /**
    * @private
    * Walk the block tree and pre-compute all async text values.
    * Handles titles (AbstractBlock), list item text, table cell text, and reftexts.
-   */
-  async _resolveAllTexts(block) {
+   *
+   * Runs in two passes (see {@link parse}): with `resolveContent` false only titles and
+   * reftexts are substituted (so the reftext→id map can be built); with `resolveContent`
+   * true the list item / table cell / dlist text is substituted, resolving any natural
+   * cross-references against the now-complete map. Title/reftext pre-computation is
+   * idempotent (results are cached), so running it in both passes is a no-op the second time.
+   * @param {AbstractBlock} block - The block to resolve.
+   * @param {boolean} resolveContent - Whether to substitute list item / cell / dlist text.
+   */
+  async _resolveAllTexts(block, resolveContent) {
+    // Replay this block's attribute entries (in document order, since the walk is
+    // depth-first pre-order like conversion) so that body-level attribute assignments
+    // and reassignments are in scope when the block's — and its descendants' and later
+    // siblings' — title / list item / table cell / reftext values are substituted.
+    // Mirrors AbstractBlock#convert, which calls playbackAttributes before converting.
+    this.playbackAttributes(block.attributes);
     // The header section lives outside document.blocks; pre-compute its title here so
     // that doc.doctitle() returns the fully-substituted title (with replacements applied,
     // e.g. ' → &#8217;) rather than the header-subs-only fallback.
@@ -17325,12 +17440,12 @@ class Document extends AbstractBlock {
       // dlist.blocks is an array of [[term, ...], item_or_null] pairs.
       for (const [terms, item] of block.blocks ?? []) {
         for (const term of terms ?? []) {
-          await term.precomputeText?.();
-          await this._resolveAllTexts(term);
+          if (resolveContent) await term.precomputeText?.();
+          await this._resolveAllTexts(term, resolveContent);
         }
         if (item) {
-          await item.precomputeText?.();
-          await this._resolveAllTexts(item);
+          if (resolveContent) await item.precomputeText?.();
+          await this._resolveAllTexts(item, resolveContent);
         }
       }
     } else if (ctx === 'table') {
@@ -17340,14 +17455,14 @@ class Document extends AbstractBlock {
         ...(block.rows?.foot ?? []),
       ]) {
         for (const cell of row) {
-          await cell.precomputeText?.();
+          if (resolveContent) await cell.precomputeText?.();
           await cell.precomputeReftext?.();
         }
       }
     } else {
       for (const child of block.blocks ?? []) {
-        await child.precomputeText?.();
-        await this._resolveAllTexts(child);
+        if (resolveContent) await child.precomputeText?.();
+        await this._resolveAllTexts(child, resolveContent);
       }
     }
   }
@@ -17639,14 +17754,19 @@ class Document extends AbstractBlock {
     let newBasebackend, newFiletype;
 
     if (converter && typeof converter._getBackendTraits === 'function') {
-      newBasebackend = converter.basebackend();
-      newFiletype = converter.filetype();
-      const htmlsyntax = converter.htmlsyntax();
+      // Read the traits object directly rather than the same-named accessor
+      // methods. A user converter that declares flat string properties
+      // (`converter.outfilesuffix = '.html'`, convention #2) keeps them intact,
+      // so callers reading `converter.outfilesuffix` still see the string.
+      const traits = converter._getBackendTraits();
+      newBasebackend = traits.basebackend;
+      newFiletype = traits.filetype;
+      const htmlsyntax = traits.htmlsyntax;
       if (htmlsyntax) attrs.htmlsyntax = htmlsyntax;
       if (init) {
-        attrs.outfilesuffix ??= converter.outfilesuffix();
+        attrs.outfilesuffix ??= traits.outfilesuffix;
       } else if (!this.isAttributeLocked('outfilesuffix')) {
-        attrs.outfilesuffix = converter.outfilesuffix();
+        attrs.outfilesuffix = traits.outfilesuffix;
       }
     } else if (converter) {
       const traits = deriveBackendTraits(newBackend);
@@ -18034,7 +18154,7 @@ const Substitutors = {
    *
    * @param {string|string[]} text - The text to process; must not be null.
    * @param {string[]} [subs=NORMAL_SUBS] - The substitutions to perform.
-   * @returns {string|string[]} Text with substitutions applied.
+   * @returns {Promise<string|string[]>} Text with substitutions applied.
    */
   async applySubs(text, subs = NORMAL_SUBS) {
     const isEmpty = Array.isArray(text) ? text.length === 0 : text.length === 0;
@@ -18148,7 +18268,7 @@ const Substitutors = {
    * Substitute quoted text (emphasis, strong, monospaced, etc.)
    *
    * @param {string} text
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async subQuotes(text) {
     const compat = this.document.compatMode;
@@ -18320,7 +18440,7 @@ const Substitutors = {
    * Substitute inline macros (links, images, etc.)
    *
    * @param {string} text
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async subMacros(text) {
     const foundSquareBracket = text.includes('[');
@@ -19215,7 +19335,7 @@ const Substitutors = {
    * Substitute post replacements (hard line breaks).
    *
    * @param {string} text
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async subPostReplacements(text) {
     if (
@@ -19253,7 +19373,7 @@ const Substitutors = {
    *
    * @param {string} source
    * @param {boolean} processCallouts
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async subSource(source, processCallouts) {
     return processCallouts
@@ -19265,7 +19385,7 @@ const Substitutors = {
    * Substitute callout source references.
    *
    * @param {string} text
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async subCallouts(text) {
     const calloutRx = this.hasAttribute('line-comment')
@@ -19294,7 +19414,7 @@ const Substitutors = {
    *
    * @param {string} source
    * @param {boolean} processCallouts
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async highlightSource(source, processCallouts) {
     const syntaxHl = this.document.syntaxHighlighter;
@@ -19640,7 +19760,7 @@ const Substitutors = {
    * Restore passthrough text by reinserting into placeholder positions.
    *
    * @param {string} text
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async restorePassthroughs(text) {
     if (!text.includes(PASS_START)) return text
@@ -19832,7 +19952,7 @@ const Substitutors = {
    * @param {string} attrlist
    * @param {string[]} [posattrs=[]]
    * @param {Object} [opts={}]
-   * @returns {Object}
+   * @returns {Promise<Object>}
    */
   async parseAttributes(attrlist, posattrs = [], opts = {}) {
     if (!attrlist || attrlist.length === 0) return {}
@@ -20957,7 +21077,7 @@ class Html5Converter extends ConverterBase {
     let reproducible;
     if (!(reproducible = node.hasAttribute('reproducible'))) {
       result.push(
-        `<meta name="generator" content="Asciidoctor ${node.getAttribute('asciidoctor-version')}"${slash}>`
+        `<meta name="generator" content="Asciidoctor.js ${node.getAttribute('asciidoctor-version')}"${slash}>`
       );
     }
     if (node.hasAttribute('app-name')) {
@@ -21674,7 +21794,9 @@ ${await node.content()}
     const slash = this._voidSlash;
     let img, src;
     if (
-      (node.hasAttribute('format', 'svg') || target.includes('.svg')) &&
+      (node.hasAttribute('format', 'svg') ||
+        target.includes('.svg') ||
+        target.startsWith('data:image/svg+xml')) &&
       node.document.safe < SafeMode.SECURE
     ) {
       if (node.hasOption('inline')) {
@@ -22515,7 +22637,9 @@ Your browser does not support the video tag.
       if (node.hasAttribute('title'))
         attrs += ` title="${node.getAttribute('title')}"`;
       if (
-        (node.hasAttribute('format', 'svg') || target.includes('.svg')) &&
+        (node.hasAttribute('format', 'svg') ||
+          target.includes('.svg') ||
+          target.startsWith('data:image/svg+xml')) &&
         node.document.safe < SafeMode.SECURE
       ) {
         if (node.hasOption('inline')) {
@@ -22608,12 +22732,17 @@ Your browser does not support the video tag.
 
   // NOTE expose readSvgContents for Bespoke converter
   async readSvgContents(node, target) {
-    let svg = await node.readContents(target, {
-      start: node.document.getAttribute('imagesdir'),
-      normalize: true,
-      label: 'SVG',
-      warnIfEmpty: true,
-    });
+    // A data-URI carries the SVG in the target itself (e.g. an embedded diagram
+    // produced with `:data-uri:`), so decode it directly rather than trying to
+    // read it as a file or remote URI.
+    let svg = target.startsWith('data:')
+      ? this._decodeDataUri(target)
+      : await node.readContents(target, {
+          start: node.document.getAttribute('imagesdir'),
+          normalize: true,
+          label: 'SVG',
+          warnIfEmpty: true,
+        });
     if (!svg) return null
     if (!svg.startsWith('<svg')) svg = svg.replace(SvgPreambleRx, '');
     // Fix incomplete SVG start tag (missing closing >) by inserting > before the first child element.
@@ -22645,6 +22774,27 @@ Your browser does not support the video tag.
 
   // ── Private helpers ─────────────────────────────────────────────────────────
 
+  /**
+   * Decode an inline `data:` URI to its text contents (e.g. an SVG document) so
+   * an image whose target is a data-URI can be embedded inline. Supports both
+   * Base64 (`;base64,`) and percent-encoded payloads. Returns null when the
+   * payload is missing.
+   *
+   * @internal
+   * @private
+   */
+  _decodeDataUri(target) {
+    const comma = target.indexOf(',');
+    if (comma === -1) return null
+    const meta = target.slice('data:'.length, comma);
+    const data = target.slice(comma + 1);
+    if (/;base64\b/i.test(meta)) {
+      const bytes = Uint8Array.from(atob(data), (c) => c.charCodeAt(0));
+      return new TextDecoder('utf-8').decode(bytes)
+    }
+    return decodeURIComponent(data)
+  }
+
   /**
    * @internal
    * @private
@@ -22887,8 +23037,7 @@ const composite = /*#__PURE__*/Object.freeze({
 //   - Ruby File.directory?/File.file? → fsp.stat().isDirectory()/isFile() (async).
 //   - Ruby File.basename / File.expand_path → node:path basename / resolve.
 //   - PathResolver.system_path → pathResolver.systemPath().
-//   - template.render(node, opts) → template.render({node, opts, helpers}).
-//   - Helpers loaded from helpers.js/helpers.cjs; can export configure(enginesContext).
+//   - template.render(node, opts) → template.render({node, opts, helpers}).//   - Helpers loaded from helpers.js/helpers.cjs/helpers.mjs; can export configure(enginesContext).
 //   - Custom engines registered via TemplateConverter.TemplateEngine.register(ext, adapter).
 //   - Thread safety / Mutex → not needed (single-threaded JS).
 //   - load_eruby / eRuby support → not applicable in JS environment.
@@ -23162,7 +23311,11 @@ class TemplateConverter extends ConverterBase {
       if (!(await _isFile(file))) continue
 
       // Collect helpers separately; process after all templates.
-      if (basename === 'helpers.js' || basename === 'helpers.cjs') {
+      if (
+        basename === 'helpers.js' ||
+        basename === 'helpers.cjs' ||
+        basename === 'helpers.mjs'
+      ) {
         helpersFile = file;
         continue
       }
@@ -23230,8 +23383,8 @@ class TemplateConverter extends ConverterBase {
         const pugOpts = { ...(this.engineOptions.pug ?? {}), filename: file };
         const renderFn = pug.compileFile(file, pugOpts);
         template = { render: renderFn, file };
-      } else if (ext === 'js' || ext === 'cjs') {
-        const renderFn = _require(file);
+      } else if (ext === 'js' || ext === 'cjs' || ext === 'mjs') {
+        const renderFn = await _loadModule(file, ext);
         template = { render: renderFn, file };
       } else {
         // Fall back to custom TemplateEngine registry.
@@ -23246,16 +23399,20 @@ class TemplateConverter extends ConverterBase {
       result[name] = template;
     }
 
-    // Load helpers if found (or if a helpers.js exists at the top of the dir).
-    const fallbackHelpers = path.join(templateDir, 'helpers.js');
-    const fallbackHelpersCjs = path.join(templateDir, 'helpers.cjs');
-    if (!helpersFile && (await _isFile(fallbackHelpers)))
-      helpersFile = fallbackHelpers;
-    if (!helpersFile && (await _isFile(fallbackHelpersCjs)))
-      helpersFile = fallbackHelpersCjs;
+    // Load helpers if found (or if a helpers file exists at the top of the dir).
+    if (!helpersFile) {
+      for (const ext of ['js', 'cjs', 'mjs']) {
+        const fallback = path.join(templateDir, `helpers.${ext}`);
+        if (await _isFile(fallback)) {
+          helpersFile = fallback;
+          break
+        }
+      }
+    }
 
     if (helpersFile) {
-      const ctx = _require(helpersFile);
+      const helpersExt = helpersFile.slice(helpersFile.lastIndexOf('.') + 1);
+      const ctx = await _loadModule(helpersFile, helpersExt);
       if (typeof ctx.configure === 'function') ctx.configure(enginesCtx);
       result['helpers.js'] = { file: helpersFile, ctx };
     }
@@ -23283,6 +23440,32 @@ class TemplateConverter extends ConverterBase {
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
+/**
+ * Load a JavaScript module (template render function or helpers object) by
+ * file extension.
+ *
+ * - `.cjs` files are always CommonJS: require() returns `module.exports`.
+ * - `.js` and `.mjs` files are loaded with a dynamic `import()`, which Node
+ *   resolves as either ES modules or CommonJS. The export is taken from the
+ *   module's default export (`export default …` in ESM, `module.exports = …`
+ *   in CommonJS via interop); when there is no default export the module
+ *   namespace is returned instead, so ESM helpers exposing named exports
+ *   (`export function configure() {}`) work too.
+ * @param {string} file - absolute path to the module file
+ * @param {string} ext - file extension without the leading dot ('js' | 'cjs' | 'mjs')
+ * @returns {Promise<*>} the module's default export, or its namespace
+ * @internal
+ * @private
+ */
+async function _loadModule(file, ext) {
+  if (ext === 'cjs') {
+    const mod = _require(file);
+    return mod?.default ? mod.default : mod
+  }
+  const mod = await import(node_url.pathToFileURL(file).href);
+  return mod.default ?? mod
+}
+
 /**
  * @internal
  * @private
@@ -24471,7 +24654,7 @@ class ManPageConverter extends ConverterBase {
       `'\\" t
 .\\"     Title: ${mantitle}
 .\\"    Author: ${node.hasAttribute('authors') ? node.getAttribute('authors') : '[see the "AUTHOR(S)" section]'}
-.\\" Generator: Asciidoctor ${node.getAttribute('asciidoctor-version')}`,
+.\\" Generator: Asciidoctor.js ${node.getAttribute('asciidoctor-version')}`,
     ];
 
     if (docdate) result.push(`.\\"      Date: ${docdate}`);
@@ -25329,6 +25512,7 @@ exports.Inline = Inline;
 exports.InlineMacroProcessor = InlineMacroProcessor;
 exports.List = List;
 exports.ListItem = ListItem;
+exports.LogMessage = LogMessage;
 exports.Logger = Logger;
 exports.LoggerManager = LoggerManager;
 exports.MemoryHttpCache = MemoryHttpCache;