@asciidoctor/core 4.0.0-alpha.6 → 4.0.1

package/build/browser/index.js

@@ -1,4 +1,4 @@
-var version = "4.0.0-alpha.6";
+var version = "4.0.1";
 const packageJson = {
 	version: version};
 
@@ -1745,14 +1745,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
@@ -1763,27 +1772,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
   }
 }
 
@@ -1796,6 +1823,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 = [];
   }
 
@@ -1803,6 +1831,9 @@ class MemoryLogger {
     return new MemoryLogger()
   }
 
+  /**
+   * @returns {LogMessage[]} The log messages recorded so far, in order.
+   */
   getMessages() {
     return this.messages
   }
@@ -6268,7 +6299,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;
@@ -6302,7 +6333,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 {
@@ -6966,22 +6997,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,
+    })
   }
 }
 
@@ -7739,7 +7782,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 }
@@ -10349,7 +10392,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];
         }
       }
 
@@ -11196,7 +11244,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')) {
@@ -13466,6 +13520,7 @@ function _uniform(str, chr, len) {
  * DSL interface for include processors.
  *
  * @typedef {DocumentProcessorDslInterface & {
+ *   handles(fn: (target: string) => boolean): void;
  *   handles(fn: (doc: Document, target: string) => boolean): void;
  * }} IncludeProcessorDslInterface
  */
@@ -13516,7 +13571,7 @@ function _uniform(str, chr, len) {
  *   - Called with a single Function argument → stores it as the process block.
  *   - Called with non-Function arguments   → invokes the stored process block.
  *
- * The this context inside a stored process function is bound to the processor
+ * The `this` context inside a stored process function is bound to the processor
  * instance at definition time.
  */
 const ProcessorDsl = {
@@ -13690,6 +13745,35 @@ const SyntaxProcessorDsl = {
 const IncludeProcessorDsl = {
   ...DocumentProcessorDsl,
 
+  /**
+   * @overload
+   * @param {(target: string) => boolean} fn - Predicate that receives only the include target.
+   * @returns {void}
+   */
+  /**
+   * @overload
+   * @param {(doc: Document, target: string) => boolean} fn - Predicate that receives the document and the include target.
+   * @returns {void}
+   */
+  /**
+   * @overload
+   * @param {Document} doc - The document being parsed.
+   * @param {string} target - The include target.
+   * @returns {boolean}
+   */
+  /**
+   * Register a function that decides whether this include processor handles a given target,
+   * or invoke the registered handler.
+   *
+   * **Setter form** — register a predicate. The callback may accept either just the target
+   * string (arity 1) or both the document and the target string (arity 2).
+   *
+   * **Invoker form** — call the registered predicate with `(doc, target)` and return its
+   * result, or return `true` if no predicate has been registered.
+   *
+   * @param {...*} args
+   * @returns {boolean | void}
+   */
   handles(...args) {
     if (args.length === 1 && typeof args[0] === 'function') {
       const fn = args[0];
@@ -14457,6 +14541,8 @@ class ProcessorExtension extends Extension {
     super(kind, instance, instance.config);
     this.processMethod =
       processMethod || ((...args) => instance.process(...args));
+    /** @internal */
+    this._direct = false;
   }
 }
 
@@ -14484,10 +14570,24 @@ const SYNTAX_PROCESSOR_CLASSES = {
  * Registry holds the extensions which have been registered and activated, has
  * methods for registering or defining a processor and looks up extensions
  * stored in the registry during parsing.
+ *
+ * A registry can be reused across multiple conversions. Extensions registered
+ * via a group block (passed to {@link Extensions.create} or
+ * {@link Extensions.register}) are re-executed on every activation. Extensions
+ * registered directly on the registry instance (e.g. `registry.preprocessor(fn)`)
+ * are preserved across activations.
+ *
+ * @example
+ * const registry = Extensions.create('my-ext', function () {
+ *   this.preprocessor(function () { ... })
+ * })
+ * // registry can be passed to multiple conversions safely
  */
 class Registry {
   constructor(groups = {}) {
     this.groups = groups;
+    /** @internal */
+    this._activating = false;
     this._reset();
   }
 
@@ -14504,18 +14604,26 @@ class Registry {
       ...Object.values(Extensions.groups()),
       ...Object.values(this.groups),
     ];
-    for (const group of extGroups) {
-      if (typeof group === 'function') {
-        // Check if it is a class (constructor) with an activate prototype method.
-        if (group.prototype && typeof group.prototype.activate === 'function') {
-          new group().activate(this);
-        } else {
-          // Plain function — call in the context of this registry (like instance_exec).
-          group.length === 0 ? group.call(this) : group(this);
+    this._activating = true;
+    try {
+      for (const group of extGroups) {
+        if (typeof group === 'function') {
+          // Check if it is a class (constructor) with an activate prototype method.
+          if (
+            group.prototype &&
+            typeof group.prototype.activate === 'function'
+          ) {
+            new group().activate(this);
+          } else {
+            // Plain function — call in the context of this registry (like instance_exec).
+            group.length === 0 ? group.call(this) : group(this);
+          }
+        } else if (group && typeof group.activate === 'function') {
+          group.activate(this);
         }
-      } else if (group && typeof group.activate === 'function') {
-        group.activate(this);
       }
+    } finally {
+      this._activating = false;
     }
     return this
   }
@@ -15091,6 +15199,7 @@ class Registry {
     }
 
     const extension = new ProcessorExtension(kind, processorInstance);
+    extension._direct = !this._activating;
     extension.config.position === '>>'
       ? store.unshift(extension)
       : store.push(extension);
@@ -15162,27 +15271,44 @@ class Registry {
     }
 
     store[name] = new ProcessorExtension(kind, processorInstance);
+    store[name]._direct = !this._activating;
     return store[name]
   }
 
   /** @internal */
   _reset() {
+    // Keep extensions registered directly (outside a group); only clear group-registered ones.
+    // Extensions tagged with _direct=true survive across activations.
+    const keepArr = (arr) => {
+      const kept = arr?.filter((e) => e._direct) ?? [];
+      return kept.length ? kept : null
+    };
+    const keepMap = (map) => {
+      if (!map) return null
+      const kept = Object.create(null);
+      for (const [k, v] of Object.entries(map)) if (v._direct) kept[k] = v;
+      return Object.keys(kept).length ? kept : null
+    };
     /** @internal */
-    this._preprocessor_extensions = null;
+    this._preprocessor_extensions = keepArr(this._preprocessor_extensions);
     /** @internal */
-    this._tree_processor_extensions = null;
+    this._tree_processor_extensions = keepArr(this._tree_processor_extensions);
     /** @internal */
-    this._postprocessor_extensions = null;
+    this._postprocessor_extensions = keepArr(this._postprocessor_extensions);
     /** @internal */
-    this._include_processor_extensions = null;
+    this._include_processor_extensions = keepArr(
+      this._include_processor_extensions
+    );
     /** @internal */
-    this._docinfo_processor_extensions = null;
+    this._docinfo_processor_extensions = keepArr(
+      this._docinfo_processor_extensions
+    );
     /** @internal */
-    this._block_extensions = null;
+    this._block_extensions = keepMap(this._block_extensions);
     /** @internal */
-    this._block_macro_extensions = null;
+    this._block_macro_extensions = keepMap(this._block_macro_extensions);
     /** @internal */
-    this._inline_macro_extensions = null;
+    this._inline_macro_extensions = keepMap(this._inline_macro_extensions);
     this.document = null;
   }
 
@@ -15265,6 +15391,13 @@ const Extensions = {
   /**
    * Create a new Registry, optionally pre-populated with a named block.
    *
+   * When a `block` is provided it is stored as a group and re-executed on every
+   * activation, making the registry safe to reuse across multiple conversions.
+   * Without a `block`, any extensions registered directly on the returned registry
+   * (e.g. `registry.preprocessor(fn)`) are stored in transient state that is
+   * cleared on every activation — those registrations will be lost from the second
+   * conversion onwards. Prefer the block form when the registry may be reused.
+   *
    * @param {string|null} [name=null] - Optional name for the group; auto-generated if omitted.
    * @param {Function|null} [block=null] - Optional function to register as the group.
    * @returns {Registry}
@@ -16145,8 +16278,16 @@ 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.
+    // 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.
+    const attributesSnapshot = { ...this.attributes };
     await this._resolveAllTexts(this);
+    for (const key of Reflect.ownKeys(this.attributes))
+      delete this.attributes[key];
+    Object.assign(this.attributes, 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.
@@ -17220,6 +17361,12 @@ class Document extends AbstractBlock {
    * Handles titles (AbstractBlock), list item text, table cell text, and reftexts.
    */
   async _resolveAllTexts(block) {
+    // 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.
@@ -17948,7 +18095,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;
@@ -18062,7 +18209,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;
@@ -18234,7 +18381,7 @@ const Substitutors = {
    * Substitute inline macros (links, images, etc.)
    *
    * @param {string} text
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async subMacros(text) {
     const foundSquareBracket = text.includes('[');
@@ -19129,7 +19276,7 @@ const Substitutors = {
    * Substitute post replacements (hard line breaks).
    *
    * @param {string} text
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async subPostReplacements(text) {
     if (
@@ -19167,7 +19314,7 @@ const Substitutors = {
    *
    * @param {string} source
    * @param {boolean} processCallouts
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async subSource(source, processCallouts) {
     return processCallouts
@@ -19179,7 +19326,7 @@ const Substitutors = {
    * Substitute callout source references.
    *
    * @param {string} text
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async subCallouts(text) {
     const calloutRx = this.hasAttribute('line-comment')
@@ -19208,7 +19355,7 @@ const Substitutors = {
    *
    * @param {string} source
    * @param {boolean} processCallouts
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async highlightSource(source, processCallouts) {
     const syntaxHl = this.document.syntaxHighlighter;
@@ -19554,7 +19701,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
@@ -19746,7 +19893,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 {}
@@ -24690,4 +24837,4 @@ const manpage = /*#__PURE__*/Object.freeze({
   default: ManPageConverter
 });
 
-export { AbstractBlock, AbstractNode, Author, Block, BlockMacroProcessor, BlockProcessor, ContentModel, ConverterBase, CustomFactory$1 as ConverterCustomFactory, Converter as ConverterFactory, Cursor, DefaultFactory$1 as DefaultConverterFactory, DefaultFactory as DefaultSyntaxHighlighterFactory, DocinfoProcessor, Document, DocumentTitle, Extensions, Footnote, Html5Converter, HttpCache, HttpCacheManager, ImageReference, IncludeProcessor, Inline, InlineMacroProcessor, List, ListItem, Logger, LoggerManager, MemoryHttpCache, MemoryLogger, NullLogger, Postprocessor, Preprocessor, Processor, ProcessorExtension, Reader, Registry, RevisionInfo, SafeMode, Section, SyntaxHighlighter, SyntaxHighlighterBase, Timings, TreeProcessor, convert, deriveBackendTraits, getCoreVersion, getVersion, load };
+export { AbstractBlock, AbstractNode, Author, Block, BlockMacroProcessor, BlockProcessor, ContentModel, ConverterBase, CustomFactory$1 as ConverterCustomFactory, Converter as ConverterFactory, Cursor, DefaultFactory$1 as DefaultConverterFactory, DefaultFactory as DefaultSyntaxHighlighterFactory, DocinfoProcessor, Document, DocumentTitle, Extensions, Footnote, Html5Converter, HttpCache, HttpCacheManager, ImageReference, IncludeProcessor, Inline, InlineMacroProcessor, List, ListItem, LogMessage, Logger, LoggerManager, MemoryHttpCache, MemoryLogger, NullLogger, Postprocessor, Preprocessor, Processor, ProcessorExtension, Reader, Registry, RevisionInfo, SafeMode, Section, SyntaxHighlighter, SyntaxHighlighterBase, Timings, TreeProcessor, convert, deriveBackendTraits, getCoreVersion, getVersion, load };